Update copyrights

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

diff --git a/mcs/class/corlib/System.Threading/AtomicBoolean.cs b/mcs/class/corlib/System.Threading/AtomicBoolean.cs
index c7ebdc9e0592da353598fc1e4cd40337971b21bf..28faf014b29351a105b14c8af4d845bd6a576efd 100644 (file)
--- a/mcs/class/corlib/System.Threading/AtomicBoolean.cs
+++ b/mcs/class/corlib/System.Threading/AtomicBoolean.cs
@@ -1,4 +1,3 @@
-#if NET_4_0
 // AtomicBoolean.cs
 //
 // Copyright (c) 2008 Jérémie "Garuma" Laval
@@ -25,69 +24,163 @@
 
 using System;
 
+#if INSIDE_MONO_PARALLEL
+using System.Threading;
+
+namespace Mono.Threading
+#else
 namespace System.Threading
+#endif
 {
-       internal struct AtomicBoolean
+#if INSIDE_MONO_PARALLEL
+       public
+#endif
+       struct AtomicBooleanValue
        {
                int flag;
                const int UnSet = 0;
                const int Set = 1;
-               
-               public bool CompareAndExchange(bool expected, bool newVal)
+
+               public bool CompareAndExchange (bool expected, bool newVal)
                {
                        int newTemp = newVal ? Set : UnSet;
                        int expectedTemp = expected ? Set : UnSet;
-                       
-                       return Interlocked.CompareExchange(ref flag, newTemp, expectedTemp) == expectedTemp;
+
+                       return Interlocked.CompareExchange (ref flag, newTemp, expectedTemp) == expectedTemp;
                }
-               
-               public static AtomicBoolean FromValue(bool value)
+
+               public static AtomicBooleanValue FromValue (bool value)
                {
-                       AtomicBoolean temp = new AtomicBoolean();
+                       AtomicBooleanValue temp = new AtomicBooleanValue ();
                        temp.Value = value;
-                       
+
                        return temp;
                }
-               
-               public bool Exchange(bool newVal)
+
+               public bool TrySet ()
+               {
+                       return !Exchange (true);
+               }
+
+               public bool TryRelaxedSet ()
+               {
+                       return flag == UnSet && !Exchange (true);
+               }
+
+               public bool Exchange (bool newVal)
                {
                        int newTemp = newVal ? Set : UnSet;
-                       return Interlocked.Exchange(ref flag, newTemp) == Set;
+                       return Interlocked.Exchange (ref flag, newTemp) == Set;
                }
-               
+
                public bool Value {
                        get {
                                return flag == Set;
-                       } 
+                       }
                        set {
-                               Thread.VolatileWrite(ref flag, value ? Set : UnSet);
+                               Exchange (value);
                        }
                }
-               
-               public bool Equals(AtomicBoolean rhs)
+
+               public bool Equals (AtomicBooleanValue rhs)
                {
                        return this.flag == rhs.flag;
                }
-               
-               public override bool Equals(object rhs)
+
+               public override bool Equals (object rhs)
                {
-                       return rhs is AtomicBoolean ? Equals((AtomicBoolean)rhs) : false;
+                       return rhs is AtomicBooleanValue ? Equals ((AtomicBooleanValue)rhs) : false;
                }
-               
-               public override int GetHashCode()
+
+               public override int GetHashCode ()
                {
-                       return flag.GetHashCode();
+                       return flag.GetHashCode ();
                }
-               
-               public static explicit operator bool(AtomicBoolean rhs)
+
+               public static explicit operator bool (AtomicBooleanValue rhs)
                {
                        return rhs.Value;
                }
-               
-               public static implicit operator AtomicBoolean(bool rhs)
+
+               public static implicit operator AtomicBooleanValue (bool rhs)
                {
-                       return AtomicBoolean.FromValue(rhs);
+                       return AtomicBooleanValue.FromValue (rhs);
                }
        }
-}
+
+#if INSIDE_MONO_PARALLEL
+       public
 #endif
+       class AtomicBoolean
+       {
+               int flag;
+               const int UnSet = 0;
+               const int Set = 1;
+
+               public bool CompareAndExchange (bool expected, bool newVal)
+               {
+                       int newTemp = newVal ? Set : UnSet;
+                       int expectedTemp = expected ? Set : UnSet;
+
+                       return Interlocked.CompareExchange (ref flag, newTemp, expectedTemp) == expectedTemp;
+               }
+
+               public static AtomicBoolean FromValue (bool value)
+               {
+                       AtomicBoolean temp = new AtomicBoolean ();
+                       temp.Value = value;
+
+                       return temp;
+               }
+
+               public bool TrySet ()
+               {
+                       return !Exchange (true);
+               }
+
+               public bool TryRelaxedSet ()
+               {
+                       return flag == UnSet && !Exchange (true);
+               }
+
+               public bool Exchange (bool newVal)
+               {
+                       int newTemp = newVal ? Set : UnSet;
+                       return Interlocked.Exchange (ref flag, newTemp) == Set;
+               }
+
+               public bool Value {
+                       get {
+                               return flag == Set;
+                       }
+                       set {
+                               Exchange (value);
+                       }
+               }
+
+               public bool Equals (AtomicBoolean rhs)
+               {
+                       return this.flag == rhs.flag;
+               }
+
+               public override bool Equals (object rhs)
+               {
+                       return rhs is AtomicBoolean ? Equals ((AtomicBoolean)rhs) : false;
+               }
+
+               public override int GetHashCode ()
+               {
+                       return flag.GetHashCode ();
+               }
+
+               public static explicit operator bool (AtomicBoolean rhs)
+               {
+                       return rhs.Value;
+               }
+
+               public static implicit operator AtomicBoolean (bool rhs)
+               {
+                       return AtomicBoolean.FromValue (rhs);
+               }
+       }
+}