class/System.DirectoryServices/System.DirectoryServices/SchemaNameCollection.cs

   1 /******************************************************************************
   2 * The MIT License
   3 * Copyright (c) 2003 Novell Inc.,  www.novell.com
   4 *
   5 * Permission is hereby granted, free of charge, to any person obtaining  a copy
   6 * of this software and associated documentation files (the Software), to deal
   7 * in the Software without restriction, including  without limitation the rights
   8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 * copies of the Software, and to  permit persons to whom the Software is
  10 * furnished to do so, subject to the following conditions:
  11 *
  12 * The above copyright notice and this permission notice shall be included in
  13 * all copies or substantial portions of the Software.
  14 *
  15 * THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21 * SOFTWARE.
  22 *******************************************************************************/
  23
  24 //
  25 // System.DirectoryServices.SchemaNameCollection.cs
  26 //
  27 // Author:
  28 //   Sunil Kumar (sunilk@novell.com)
  29 //
  30 // (C)  Novell Inc.
  31 //
  32
  33 using System.Collections;
  34
  35 namespace System.DirectoryServices
  36 {
  37
  38         /// <summary>
  39         ///Contains a list of the schema names that the
  40         /// SchemaFilter property of a DirectoryEntries
  41         ///  object can use.
  42         /// </summary>
  43         public class SchemaNameCollection : IList, ICollection, IEnumerable
  44         {
  45                 internal SchemaNameCollection ()
  46                 {
  47                 }
  48
  49                 [MonoTODO]
  50                 int IList.Add(object avalue)
  51                 {
  52                         throw new NotImplementedException();
  53                 }
  54
  55                 [MonoTODO]
  56                 public int Add (string value)
  57                 {
  58                         throw new NotImplementedException();
  59                 }
  60
  61                 [MonoTODO]
  62                 public void Clear()
  63                 {
  64                         throw new NotImplementedException();
  65                 }
  66                 [MonoTODO]
  67                 bool IList.Contains(object cvalue)
  68                 {
  69                         throw new NotImplementedException();
  70                 }
  71                 [MonoTODO]
  72                 int IList.IndexOf(object ivalue)
  73                 {
  74                         throw new NotImplementedException();
  75                 }
  76                 [MonoTODO]
  77                 void IList.Insert(int index,object ivalue)
  78                 {
  79                         throw new NotImplementedException();
  80                 }
  81                 [MonoTODO]
  82                 void IList.Remove(object rvalue)
  83                 {
  84                         throw new NotImplementedException();
  85                 }
  86                 [MonoTODO]
  87                 public void RemoveAt(int index)
  88                 {
  89                         throw new NotImplementedException();
  90                 }
  91
  92                 bool IList.IsFixedSize
  93                 {
  94                         get
  95                         {
  96                                 return true;
  97                         }
  98                 }
  99
 100                 bool IList.IsReadOnly
 101                 {
 102                         get
 103                         {
 104                                 return true;
 105                         }
 106                 }
 107                 object IList.this[int recordIndex]
 108                 {
 109                         [MonoTODO]
 110                         get
 111                         {
 112                                 throw new InvalidOperationException();
 113                         }
 114                         [MonoTODO]
 115                         set
 116                         {
 117                                 throw new InvalidOperationException();
 118                         }
 119                 }
 120
 121                 public string this[int index]
 122                 {
 123                         [MonoTODO]
 124                         get { throw new NotImplementedException (); }
 125                         [MonoTODO]
 126                         set { throw new NotImplementedException (); }
 127
 128                 }
 129
 130                 public int Count
 131                 {
 132                         get
 133                         {
 134                                 return 0;
 135                         }
 136                 }
 137                 bool ICollection.IsSynchronized
 138                 {
 139                         [MonoTODO]
 140                         get
 141                         {
 142                                 return true;
 143                         }
 144                 }
 145
 146                 object ICollection.SyncRoot {
 147                         [MonoTODO]
 148                         get {
 149                                 // FIXME:
 150                                 return this;
 151                         }
 152                 }
 153
 154                 [MonoTODO]
 155                 public IEnumerator GetEnumerator()
 156                 {
 157                         throw new NotImplementedException();
 158                 }
 159
 160                 [MonoTODO]
 161                 public void AddRange (SchemaNameCollection coll)
 162                 {
 163                         throw new NotImplementedException();
 164                 }
 165
 166                 [MonoTODO]
 167                 public void AddRange (string[] coll)
 168                 {
 169                         throw new NotImplementedException();
 170                 }
 171
 172                 [MonoTODO]
 173                 public bool Contains (string s)
 174                 {
 175                         throw new NotImplementedException();
 176                 }
 177
 178                 [MonoTODO]
 179                 void ICollection.CopyTo (Array arr, int pos)
 180                 {
 181                         throw new NotImplementedException ();
 182                 }
 183
 184                 [MonoTODO]
 185                 public void CopyTo (string[] copy_to, int pos)
 186                 {
 187                         throw new NotImplementedException();
 188                 }
 189
 190                 [MonoTODO]
 191                 public int IndexOf (string s)
 192                 {
 193                         throw new NotImplementedException();
 194                 }
 195
 196                 [MonoTODO]
 197                 public void Insert (int pos, string s)
 198                 {
 199                         throw new NotImplementedException();
 200                 }
 201
 202                 [MonoTODO]
 203                 public void Remove (string s)
 204                 {
 205                         throw new NotImplementedException();
 206                 }
 207         }
 208 }
 209