Fix comments

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

diff --git a/mcs/class/corlib/System.Threading/CompressedStack.cs b/mcs/class/corlib/System.Threading/CompressedStack.cs
index 66b509f5d2e9125dfc60f03fb22d8071108a3f81..0e79ce5779791fa138e808e87634484624a5f8af 100644 (file)
--- a/mcs/class/corlib/System.Threading/CompressedStack.cs
+++ b/mcs/class/corlib/System.Threading/CompressedStack.cs
@@ -1,10 +1,11 @@
 //
 // System.Threading.Thread.cs
 //
-// Author:
-//   Zoltan Varga (vargaz@freemail.hu)
+// Authors:
+//     Zoltan Varga (vargaz@freemail.hu)
+//     Sebastien Pouliot  <sebastien@ximian.com>
 //
-// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
 //
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the
@@ -26,59 +27,128 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
+using System.Collections;
+using System.Diagnostics;
+using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Runtime.Serialization;
+using System.Security;
+using System.Security.Permissions;
 
 namespace System.Threading {
 
-#if NET_2_0
        [Serializable]
-       [ComVisibleAttribute (false)]
        public sealed class CompressedStack : ISerializable {
-#else
-       public class CompressedStack {
-#endif
+               private ArrayList _list;
 
-               internal CompressedStack ()
+               internal CompressedStack (int length)
                {
+                       if (length > 0)
+                               _list = new ArrayList (length);
                }
 
-               ~CompressedStack ()
+               internal CompressedStack (CompressedStack cs)
                {
+                       if ((cs != null) && (cs._list != null))
+                               _list = (ArrayList) cs._list.Clone ();
                }
 
-#if NET_2_0
-               [MonoTODO]
                [ComVisibleAttribute (false)]
                public CompressedStack CreateCopy ()
                {
-                       throw new NotImplementedException ();
+                       return new CompressedStack (this);
                }
 
-               [MonoTODO]
+               public static CompressedStack Capture ()
+               {
+                       CompressedStack cs = new CompressedStack (0);
+                       cs._list = SecurityFrame.GetStack (1);
+
+                       // include any current CompressedStack inside the new Capture
+                       CompressedStack currentCs = Thread.CurrentThread.GetCompressedStack ();
+                       if (currentCs != null) {
+                               for (int i=0; i < currentCs._list.Count; i++)
+                                       cs._list.Add (currentCs._list [i]);
+                       }
+                       return cs;
+               }
+
+               // NOTE: This method doesn't show in the class library status page because
+               // it cannot be "found" with the StrongNameIdentityPermission for ECMA key.
+               // But it's there!
+               [SecurityPermission (SecurityAction.LinkDemand, UnmanagedCode = true)]
+               [StrongNameIdentityPermission (SecurityAction.LinkDemand, PublicKey="00000000000000000400000000000000")]
+               static public CompressedStack GetCompressedStack ()
+               {
+                       // Note: CompressedStack.GetCompressedStack doesn't return null
+                       // like Thread.CurrentThread.GetCompressedStack if no compressed
+                       // stack is present.
+                       CompressedStack cs = Thread.CurrentThread.GetCompressedStack ();
+                       if (cs == null) {
+                               cs = CompressedStack.Capture ();
+                       } else {
+                               // merge the existing compressed stack (from a previous Thread) with the current
+                               // Thread stack so we can assign "all of it" to yet another Thread
+                               CompressedStack newstack = CompressedStack.Capture ();
+                               for (int i=0; i < newstack._list.Count; i++)
+                                       cs._list.Add (newstack._list [i]);
+                       }
+                       return cs;
+               }
+
+               [MonoTODO ("incomplete")]
+               [ReflectionPermission (SecurityAction.Demand, MemberAccess = true)]
                public void GetObjectData (SerializationInfo info, StreamingContext context)
                {
                        if (info == null)
                                throw new ArgumentNullException ("info");
                }
 
-               [MonoTODO]
-               static public CompressedStack Capture ()
+               [SecurityPermission (SecurityAction.LinkDemand, Infrastructure = true)]
+               static public void Run (CompressedStack compressedStack, ContextCallback callback, object state)
                {
-                       throw new NotImplementedException ();
+                       if (compressedStack == null)
+                               throw new ArgumentException ("compressedStack");
+
+                       Thread t = Thread.CurrentThread;
+                       CompressedStack original = null;
+                       try {
+                               original = t.GetCompressedStack (); 
+                               t.SetCompressedStack (compressedStack);
+                               callback (state);
+                       }
+                       finally {
+                               if (original != null)
+                                       t.SetCompressedStack (original);
+                       }
                }
 
-               [MonoTODO]
-               static public CompressedStack GetCompressedStack ()
+               // internal stuff
+               internal bool Equals (CompressedStack cs)
                {
-                       throw new NotImplementedException ();
+                       if (IsEmpty ())
+                               return cs.IsEmpty ();
+                       if (cs.IsEmpty ())
+                               return false;
+                       if (_list.Count != cs._list.Count)
+                               return false;
+
+                       for (int i=0; i < _list.Count; i++) {
+                               SecurityFrame sf1 = (SecurityFrame) _list [i];
+                               SecurityFrame sf2 = (SecurityFrame) cs._list [i];
+                               if (!sf1.Equals (sf2))
+                                       return false;
+                       }
+                       return true;
                }
 
-               [MonoTODO]
-               static public CompressedStackSwitcher SetCompressedStack (CompressedStack cs)
+               internal bool IsEmpty ()
                {
-                       throw new NotImplementedException ();
+                       return ((_list == null) || (_list.Count == 0));
+               }
+
+               internal IList List {
+                       get { return _list; }
                }
-#endif
        }
 }