* roottypes.cs: Rename from tree.cs.

[mono.git] / mcs / class / System.DirectoryServices / System.DirectoryServices / SchemaNameCollection.cs

diff --git a/mcs/class/System.DirectoryServices/System.DirectoryServices/SchemaNameCollection.cs b/mcs/class/System.DirectoryServices/System.DirectoryServices/SchemaNameCollection.cs
index dafa6059d951c02bdde1075e36fd553503396d20..6b94d89070f3d42acf0e6b630e3f0c304c232c0f 100644 (file)
--- a/mcs/class/System.DirectoryServices/System.DirectoryServices/SchemaNameCollection.cs
+++ b/mcs/class/System.DirectoryServices/System.DirectoryServices/SchemaNameCollection.cs
@@ -26,9 +26,8 @@
 //
 // Author:
 //   Sunil Kumar (sunilk@novell.com)
-//   Raja R Harinath <rharinath@novell.com>
 //
-// Copyright (C) 2003, 2004  Novell Inc.
+// (C)  Novell Inc.
 //
 
 using System.Collections;
@@ -41,59 +40,169 @@ namespace System.DirectoryServices
        /// SchemaFilter property of a DirectoryEntries
        ///  object can use.
        /// </summary>
-       public class SchemaNameCollection : CollectionBase
+       public class SchemaNameCollection : IList, ICollection, IEnumerable
        {
                internal SchemaNameCollection ()
                {
                }
                
+               [MonoTODO]
+               int IList.Add(object avalue)
+               {
+                       throw new NotImplementedException();
+               }
+
+               [MonoTODO]
                public int Add (string value)
                {
-                       return List.Add (value);
+                       throw new NotImplementedException();
+               }
+               
+               [MonoTODO]
+               public void Clear()
+               {
+                       throw new NotImplementedException();
+               }
+               [MonoTODO]
+               bool IList.Contains(object cvalue)
+               {
+                       throw new NotImplementedException();
+               }
+               [MonoTODO]
+               int IList.IndexOf(object ivalue)
+               {
+                       throw new NotImplementedException();
+               }
+               [MonoTODO]
+               void IList.Insert(int index,object ivalue)
+               {
+                       throw new NotImplementedException();
+               }
+               [MonoTODO]
+               void IList.Remove(object rvalue)
+               {
+                       throw new NotImplementedException();
+               }
+               [MonoTODO]
+               public void RemoveAt(int index)
+               {
+                       throw new NotImplementedException();
+               }
+               
+               bool IList.IsFixedSize 
+               {
+                       get
+                       {
+                               return true;
+                       }
                }
 
-               public string this[int pos]
+               bool IList.IsReadOnly 
+               {
+                       get
+                       {
+                               return true;
+                       }
+               }
+               object IList.this[int recordIndex] 
                {
-                       get { return List[pos] as string; }
-                       set { List[pos] = value; }
+                       [MonoTODO]
+                       get 
+                       {
+                               throw new InvalidOperationException();
+                       }
+                       [MonoTODO]
+                       set
+                       {
+                               throw new InvalidOperationException();
+                       }
                }
 
-               public int IndexOf (string s)
+               public string this[int index]
+               {
+                       [MonoTODO]
+                       get { throw new NotImplementedException (); }
+                       [MonoTODO]
+                       set { throw new NotImplementedException (); }
+
+               }
+
+               public int Count
                {
-                       return List.IndexOf (s);
+                       get
+                       {
+                               return 0;
+                       }
+               }
+               bool ICollection.IsSynchronized 
+               {
+                       [MonoTODO]
+                       get
+                       {
+                               return true;
+                       }
                }
 
-               public bool Contains (string s)
+               object ICollection.SyncRoot { 
+                       [MonoTODO]
+                       get {
+                               // FIXME:
+                               return this;
+                       }
+               }
+
+               [MonoTODO]
+               public IEnumerator GetEnumerator() 
+               {
+                       throw new NotImplementedException();
+               }
+
+               [MonoTODO]
+               public void AddRange (SchemaNameCollection coll)
                {
-                       return List.Contains (s);
+                       throw new NotImplementedException();
                }
 
+               [MonoTODO]
                public void AddRange (string[] coll)
                {
-                       foreach (string s in coll)
-                               Add (s);
+                       throw new NotImplementedException();
                }
 
-               public void AddRange (SchemaNameCollection coll)
+               [MonoTODO]
+               public bool Contains (string s)
                {
-                       foreach (string s in coll)
-                               Add (s);
+                       throw new NotImplementedException();
                }
 
-               public void Insert (int pos, string s)
+               [MonoTODO]
+               void ICollection.CopyTo (Array arr, int pos)
+               {
+                       throw new NotImplementedException ();
+               }
+
+               [MonoTODO]
+               public void CopyTo (string[] copy_to, int pos)
                {
-                       List.Insert (pos, s);
+                       throw new NotImplementedException();
                }
 
-               public void CopyTo (string[] copy_to, int index)
+               [MonoTODO]
+               public int IndexOf (string s)
+               {
+                       throw new NotImplementedException();
+               }
+
+               [MonoTODO]
+               public void Insert (int pos, string s)
                {
-                       foreach (string s in List)
-                               copy_to[index++] = s;
+                       throw new NotImplementedException();
                }
 
+               [MonoTODO]
                public void Remove (string s)
                {
-                       List.Remove (s);
+                       throw new NotImplementedException();
                }
        }
 }