Merge pull request #2653 from lambdageek/dev/exception_type-1

[mono.git] / mcs / class / corlib / System.Threading / EventWaitHandle.cs

diff --git a/mcs/class/corlib/System.Threading/EventWaitHandle.cs b/mcs/class/corlib/System.Threading/EventWaitHandle.cs
index 1f95bc5b0b3028e408aaaa66ecfc9d51f5d562db..fba21dc3ce56b3a51a69c083fef85fc8fa16763c 100644 (file)
--- a/mcs/class/corlib/System.Threading/EventWaitHandle.cs
+++ b/mcs/class/corlib/System.Threading/EventWaitHandle.cs
@@ -27,11 +27,9 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
-#if NET_2_0
-
-using System.Security.AccessControl;
 using System.IO;
 using System.Runtime.InteropServices;
+using System.Security.AccessControl;
 
 namespace System.Threading
 {
@@ -42,42 +40,57 @@ namespace System.Threading
                {
                        Handle = handle;
                }
+
+               static bool IsManualReset (EventResetMode mode)
+               {
+                       if ((mode < EventResetMode.AutoReset) || (mode > EventResetMode.ManualReset))
+                               throw new ArgumentException ("mode");
+                       return (mode == EventResetMode.ManualReset);
+               }
                
                public EventWaitHandle (bool initialState, EventResetMode mode)
                {
                        bool created;
-                       
-                       Handle = NativeEventCalls.CreateEvent_internal ((mode == EventResetMode.ManualReset), initialState, null, out created);
+                       bool manual = IsManualReset (mode);
+                       Handle = NativeEventCalls.CreateEvent_internal (manual, initialState, null, out created);
                }
                
+#if !MOBILE
+               
                public EventWaitHandle (bool initialState, EventResetMode mode,
                                        string name)
                {
                        bool created;
-                       
-                       Handle = NativeEventCalls.CreateEvent_internal ((mode == EventResetMode.ManualReset), initialState, name, out created);
+                       bool manual = IsManualReset (mode);
+                       Handle = NativeEventCalls.CreateEvent_internal (manual, initialState, name, out created);
                }
                
                public EventWaitHandle (bool initialState, EventResetMode mode,
                                        string name, out bool createdNew)
                {
-                       Handle = NativeEventCalls.CreateEvent_internal ((mode == EventResetMode.ManualReset), initialState, name, out createdNew);
+                       bool manual = IsManualReset (mode);
+                       Handle = NativeEventCalls.CreateEvent_internal (manual, initialState, name, out createdNew);
                }
-               
-               [MonoTODO ("Implement access control")]
+
+
+               [MonoTODO ("Use access control in CreateEvent_internal")]
                public EventWaitHandle (bool initialState, EventResetMode mode,
                                        string name, out bool createdNew,
                                        EventWaitHandleSecurity eventSecurity)
                {
-                       Handle = NativeEventCalls.CreateEvent_internal ((mode == EventResetMode.ManualReset), initialState, name, out createdNew);
+                       bool manual = IsManualReset (mode);
+                       Handle = NativeEventCalls.CreateEvent_internal (manual, initialState, name, out createdNew);
                }
                
-               [MonoTODO]
                public EventWaitHandleSecurity GetAccessControl ()
                {
-                       throw new NotImplementedException ();
+                       return new EventWaitHandleSecurity (SafeWaitHandle,
+                                                           AccessControlSections.Owner |
+                                                           AccessControlSections.Group |
+                                                           AccessControlSections.Access);
+
                }
-               
+
                public static EventWaitHandle OpenExisting (string name)
                {
                        return(OpenExisting (name, EventWaitHandleRights.Synchronize | EventWaitHandleRights.Modify));
@@ -107,27 +120,116 @@ namespace System.Threading
                        
                        return(new EventWaitHandle (handle));
                }
+
+               public static bool TryOpenExisting (string name, out EventWaitHandle result)
+               {
+                       return TryOpenExisting (
+                               name, EventWaitHandleRights.Synchronize | EventWaitHandleRights.Modify, out result);
+               }
+
+               public static bool TryOpenExisting (string name, EventWaitHandleRights rights,
+                                                   out EventWaitHandle result)
+               {
+                       if (name == null) {
+                               throw new ArgumentNullException ("name");
+                       }
+                       if ((name.Length == 0) || (name.Length > 260)) {
+                               throw new ArgumentException ("name", Locale.GetText ("Invalid length [1-260]."));
+                       }
+                       
+                       MonoIOError error;
+                       IntPtr handle = NativeEventCalls.OpenEvent_internal (name, rights, out error);
+                       if (handle == (IntPtr)null) {
+                               result = null;
+                               return false;
+                       }
+
+                       result = new EventWaitHandle (handle);
+                       return true;
+               }
+#else
+               public EventWaitHandle (bool initialState, EventResetMode mode, string name)
+               {
+                       throw new NotSupportedException ();
+               }
+               
+               public EventWaitHandle (bool initialState, EventResetMode mode,
+                                       string name, out bool createdNew)
+               {
+                       throw new NotSupportedException ();
+               }
                
+               
+               public EventWaitHandle (bool initialState, EventResetMode mode,
+                                       string name, out bool createdNew,
+                                       EventWaitHandleSecurity eventSecurity)
+               {
+                       throw new NotSupportedException ();
+               }
+
+               public static EventWaitHandle OpenExisting (string name)
+               {
+                       throw new NotSupportedException (); 
+               }
+
+               public static EventWaitHandle OpenExisting (string name, EventWaitHandleRights rights)
+               {
+                       throw new NotSupportedException (); 
+               }
+
+               public static bool TryOpenExisting (string name, out EventWaitHandle result)
+               {
+                       throw new NotSupportedException (); 
+               }
+
+               public static bool TryOpenExisting (string name, EventWaitHandleRights rights,
+                                                   out EventWaitHandle result)
+               {
+                       throw new NotSupportedException (); 
+               }
+#endif
+
                public bool Reset ()
                {
-                       CheckDisposed ();
+                       /* This needs locking since another thread could dispose the handle */
+                       lock (this) {
+                               CheckDisposed ();
                        
-                       return (NativeEventCalls.ResetEvent_internal (Handle));
+                               return NativeEventCalls.ResetEvent (SafeWaitHandle);
+                       }
                }
                
                public bool Set ()
                {
-                       CheckDisposed ();
+                       lock (this) {
+                               CheckDisposed ();
                        
-                       return (NativeEventCalls.SetEvent_internal (Handle));
+                               return NativeEventCalls.SetEvent (SafeWaitHandle);
+                       }
                }
 
-               [MonoTODO]
+               internal void CheckDisposed ()
+               {
+                       if (disposed)
+                               throw new ObjectDisposedException (GetType ().FullName);
+               }
+
+               bool disposed;
+               protected override void Dispose(bool explicitDisposing)
+               {
+                       base.Dispose (explicitDisposing);
+                       disposed = true;
+               }
+
+#if !NET_2_1
                public void SetAccessControl (EventWaitHandleSecurity eventSecurity)
                {
-                       throw new NotImplementedException ();
+                       if (null == eventSecurity)
+                               throw new ArgumentNullException ("eventSecurity");
+                               
+                       eventSecurity.PersistModifications (SafeWaitHandle);
+
                }
+#endif
        }
 }
-
-#endif