Add Runnable, Future and RunnableFuture interface

JShim/JShim.csproj

@@ -46,10 +46,13 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Java\Beans\PropertyChangeSupport.cs" />
+    <Compile Include="Java\Lang\Runnable.cs" />
     <Compile Include="Java\Time\Instant.cs" />
     <Compile Include="Java\Time\LocalDateTime.cs" />
     <Compile Include="Java\Time\ZonedDateTime.cs" />
     <Compile Include="Java\Time\ZoneId.cs" />
+    <Compile Include="Java\Util\Concurrent\Future.cs" />
+    <Compile Include="Java\Util\Concurrent\RunnableFuture.cs" />
     <Compile Include="Microsoft\NET\FSUtils.cs" />
     <Compile Include="Sun\NIO\FS\WindowsFileStore.cs" />
     <Compile Include="Sun\NIO\FS\WindowsFileSystem.cs" />
@@ -78,6 +81,7 @@
     <Folder Include="Java" />
     <Folder Include="Javax" />
     <Folder Include="Javax\Swing" />
+    <Folder Include="Java\Lang" />
     <Folder Include="Java\Time" />
     <Folder Include="Microsoft" />
     <Folder Include="Microsoft\NET" />

JShim/Java/Lang/Runnable.cs

@@ -0,0 +1,21 @@
+
+using System;
+
+namespace Java.Lang
+{
+	/// <summary>
+	/// Description of Runnable.
+	/// </summary>
+	public interface Runnable
+	{
+		/// <summary>
+		/// When an object implementing interface Runnable is used to create a 
+		/// thread, starting the thread causes the object's run method to be 
+		/// called in that separately executing thread.
+		/// 
+		/// The general contract of the method run is that it may take any 
+		/// action whatsoever.
+		/// </summary>
+		void Run();
+	}
+}

JShim/Java/Util/Concurrent/Future.cs

@@ -0,0 +1,83 @@
+
+using System;
+
+namespace Java.Util.Concurrent
+{
+	/// <summary>
+	/// A Future represents the result of an asynchronous computation. Methods 
+	/// are provided to check if the computation is complete, to wait for its 
+	/// completion, and to retrieve the result of the computation. The result 
+	/// can only be retrieved using method get when the computation has 
+	/// completed, blocking if necessary until it is ready. Cancellation is 
+	/// performed by the cancel method. Additional methods are provided to 
+	/// determine if the task completed normally or was cancelled. Once a 
+	/// computation has completed, the computation cannot be cancelled. If you 
+	/// would like to use a Future for the sake of cancellability but not 
+	/// provide a usable result, you can declare types of the form Future<?> and
+	/// return null as a result of the underlying task.
+	/// </summary>
+	public interface Future<V>
+	{
+		/// <summary>
+		/// Attempts to cancel execution of this task. This attempt will fail if
+		/// the task has already completed, has already been cancelled, or could
+		/// not be cancelled for some other reason. If successful, and this task
+		/// has not started when cancel is called, this task should never run. If
+		/// the task has already started, then the mayInterruptIfRunning 
+		/// parameter determines whether the thread executing this task should 
+		/// be interrupted in an attempt to stop the task.
+		/// 
+		/// After this method returns, subsequent calls to isDone() will always 
+		/// return true. Subsequent calls to isCancelled() will always return 
+		/// true if this method returned true.
+		/// </summary>
+		/// <param name="mayInterruptIfRunning">
+		/// true if the thread executing this task should be interrupted; 
+		/// otherwise, in-progress tasks are allowed to complete
+		/// </param>
+		/// <returns>
+		/// false if the task could not be cancelled, typically because it has 
+		/// already completed normally; true otherwise
+		/// </returns>
+		bool Cancel(bool mayInterruptIfRunning);
+
+		/// <summary>
+		/// Waits if necessary for the computation to complete, and then 
+		/// retrieves its result.
+		/// </summary>
+		/// <returns>
+		/// the computed result
+		/// </returns>
+		V Get();
+
+		/// <summary>
+		/// Waits if necessary for at most the given time for the computation to
+		/// complete, and then retrieves its result, if available.
+		/// </summary>
+		/// <param name="timeout">the maximum time to wait</param>
+		/// <param name="unit">the time unit of the timeout argument</param>
+		/// <returns>
+		/// the computed result
+		/// </returns>
+		V Get(long timeout, TimeUnit unit);
+
+		/// <summary>
+		/// Returns true if this task was cancelled before it completed 
+		/// normally.
+		/// </summary>
+		/// <returns>
+		/// true if this task was cancelled before it completed
+		/// </returns>
+		bool IsCancelled();
+
+		/// <summary>
+		/// Returns true if this task completed. Completion may be due to normal
+		/// termination, an exception, or cancellation -- in all of these cases,
+		/// this method will return true.
+		/// </summary>
+		/// <returns>
+		/// true if this task completed
+		/// </returns>
+		bool IsDone();
+	}
+}

JShim/Java/Util/Concurrent/RunnableFuture.cs

@@ -0,0 +1,18 @@
+
+using System;
+using Java.Lang;
+
+namespace Java.Util.Concurrent
+{
+	/// <summary>
+	/// Description of RunnableFuture.
+	/// </summary>
+	public interface RunnableFuture<V> : Runnable, Future<V>
+	{
+		/// <summary>
+		/// Sets this Future to the result of its computation unless it has been
+		/// cancelled.
+		/// </summary>
+		new void Run();
+	}
+}

JShim/Javax/Swing/SwingWorker.cs

@@ -12,7 +12,7 @@ namespace Javax.Swing
 	/// <summary>
 	/// 
 	/// </summary>
-	public abstract class SwingWorker<T,V>
+	public abstract class SwingWorker<T,V> : RunnableFuture<T>
 	{
 		private static readonly ILog log = LogManager.GetLogger(typeof(SwingWorker<T,V>));
 		private readonly BackgroundWorker backgroundWorker;