implement watchers & static callbacks

Author: kersny

src/Libuv.Tests/webserver.cs

@@ -51,6 +51,14 @@ static void Main ()
 				Console.WriteLine("Prepare Watcher 2 Called");
 			});
 			watch2.Start();
+			var check = new CheckWatcher((ptr, stat) => {
+				Console.WriteLine("Check Watcher Called");
+			});
+			check.Start();
+			var idle = new IdleWatcher((ptr, stat) => {
+				Console.WriteLine("Idle Watcher Called");
+			});
+			idle.Start();
 			uv_run();
 		}
 	}

src/Libuv/CheckWatcher.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Libuv {
+	public class CheckWatcher : Watcher {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		public delegate void uv_check_cb(IntPtr socket, int status);
+		[DllImport("uvwrap")]
+		internal static extern IntPtr create_check_watcher(IntPtr myself, uv_check_cb cb);
+		[DllImport("uvwrap")]
+		internal static extern int uv_check_init(IntPtr check);
+		[DllImport("uvwrap")]
+		internal static extern int manos_check_start(IntPtr check);
+		[DllImport("uvwrap")]
+		internal static extern int uv_check_stop(IntPtr check);
+		private static uv_check_cb unmanaged_callback;
+		private Action<CheckWatcher, int> callback;
+		static CheckWatcher()
+		{
+			unmanaged_callback = StaticCallback;
+		}
+		public CheckWatcher(Action<CheckWatcher, int> callback)
+		{
+			watcher = create_check_watcher(GCHandle.ToIntPtr(gc_handle), unmanaged_callback);
+			uv_check_init(this.watcher);
+			this.callback = callback;
+		}
+		private static void StaticCallback(IntPtr watcher, int status)
+		{
+			var handle = GCHandle.FromIntPtr(watcher);
+			var watcher_instance = (CheckWatcher)handle.Target;
+			watcher_instance.callback(watcher_instance, status);
+		}
+		public void Start()
+		{
+			manos_check_start(this.watcher);
+		}
+		public void Stop()
+		{
+			uv_check_stop(this.watcher);
+		}
+	}
+}

src/Libuv/IdleWatcher.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Libuv {
+	public class IdleWatcher : Watcher {
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		public delegate void uv_idle_cb(IntPtr socket, int status);
+		[DllImport("uvwrap")]
+		internal static extern IntPtr create_idle_watcher(IntPtr myself, uv_idle_cb cb);
+		[DllImport("uvwrap")]
+		internal static extern int uv_idle_init(IntPtr idle);
+		[DllImport("uvwrap")]
+		internal static extern int manos_idle_start(IntPtr idle);
+		[DllImport("uvwrap")]
+		internal static extern int uv_idle_stop(IntPtr idle);
+		private static uv_idle_cb unmanaged_callback;
+		private Action<IdleWatcher, int> callback;
+		static IdleWatcher()
+		{
+			unmanaged_callback = StaticCallback;
+		}
+		public IdleWatcher(Action<IdleWatcher, int> callback)
+		{
+			watcher = create_idle_watcher(GCHandle.ToIntPtr(gc_handle), unmanaged_callback);
+			uv_idle_init(this.watcher);
+			this.callback = callback;
+		}
+		private static void StaticCallback(IntPtr watcher, int status)
+		{
+			var handle = GCHandle.FromIntPtr(watcher);
+			var watcher_instance = (IdleWatcher)handle.Target;
+			watcher_instance.callback(watcher_instance, status);
+		}
+		public void Start()
+		{
+			manos_idle_start(this.watcher);
+		}
+		public void Stop()
+		{
+			uv_idle_stop(this.watcher);
+		}
+	}
+}

src/Libuv/Libuv.csproj

@@ -45,6 +45,8 @@
     <Compile Include="TcpServer.cs" />
     <Compile Include="Watcher.cs" />
     <Compile Include="PrepareWatcher.cs" />
+    <Compile Include="CheckWatcher.cs" />
+    <Compile Include="IdleWatcher.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <Target Name="ListSources">

src/Libuv/PrepareWatcher.cs

@@ -39,20 +39,5 @@ public void Stop()
 		{
 			uv_prepare_stop(this.watcher);
 		}
-		~PrepareWatcher()
-		{
-			Cleanup();
-		}
-		private void Cleanup()
-		{
-			gc_handle.Free();
-			destroy_watcher(this.watcher);
-		}
-		public override void Dispose()
-		{
-			Cleanup();
-			GC.SuppressFinalize(this);
-
-		}
 	}
 }

src/Libuv/Watcher.cs

@@ -7,10 +7,23 @@ public abstract class Watcher : IDisposable {
 		internal static extern void destroy_watcher(IntPtr watcher);
 		internal IntPtr watcher;
 		internal GCHandle gc_handle;
-		public abstract void Dispose();
 		internal Watcher()
 		{
 			gc_handle = GCHandle.Alloc(this);
 		}
+		~Watcher()
+		{
+			Cleanup();
+		}
+		private void Cleanup()
+		{
+			gc_handle.Free();
+			destroy_watcher(this.watcher);
+		}
+		public void Dispose()
+		{
+			Cleanup();
+			GC.SuppressFinalize(this);
+		}
 	}
 }

src/wrapper/uv_wrap.c

@@ -98,26 +98,50 @@ typedef struct {
 	void* cb;
 } manos_static_data_container;
 typedef void (*manos_static_cb)(void* handle, int status);
-static void prepare_cb(uv_prepare_t* prepare, int status)
+static void watcher_cb(uv_handle_t* watcher, int status)
 {
-	manos_static_data_container* container = (manos_static_data_container*)prepare->data;
+	manos_static_data_container* container = (manos_static_data_container*)watcher->data;
 	manos_static_cb cb = container->cb;
 	cb(container->data, status);
 }
-uv_prepare_t* create_prepare_watcher(void* data, void* cb)
+void addstruct(uv_handle_t* handle, void* data, void* cb)
 {
-	uv_prepare_t* ret = malloc(sizeof(uv_prepare_t));
 	manos_static_data_container* inter = malloc(sizeof(manos_static_data_container));
 	inter->data = data;
 	inter->cb = cb;
-	ret->data = inter;
+	handle->data = inter;
+}
+uv_prepare_t* create_prepare_watcher(void* data, void* cb)
+{
+	uv_prepare_t* ret = malloc(sizeof(uv_prepare_t));
+	addstruct((uv_handle_t*)ret, data, cb);
 	return ret;
 }
 int manos_prepare_start(uv_prepare_t *ptr)
 {
-	uv_prepare_start(ptr, prepare_cb);
+	uv_prepare_start(ptr, watcher_cb);
+}
+uv_check_t* create_check_watcher(void* data, void* cb)
+{
+	uv_check_t* ret = malloc(sizeof(uv_check_t));
+	addstruct((uv_handle_t*)ret, data, cb);
+	return ret;
+}
+int manos_check_start(uv_check_t *ptr)
+{
+	uv_check_start(ptr, watcher_cb);
+}
+uv_idle_t* create_idle_watcher(void* data, void* cb)
+{
+	uv_idle_t* ret = malloc(sizeof(uv_idle_t));
+	addstruct((uv_handle_t*)ret, data, cb);
+	return ret;
+}
+int manos_idle_start(uv_idle_t *ptr)
+{
+	uv_idle_start(ptr, watcher_cb);
 }
-void destroy_watcher(uv_prepare_t* ptr)
+void destroy_watcher(uv_handle_t* ptr)
 {
 	free(ptr->data);
 	free(ptr);