The Labs \ Source Viewer \ SSCLI \ System.CodeDom \ CodeNamespaceImportCollection

  1. //------------------------------------------------------------------------------
  2. // <copyright file="CodeNamespaceImportCollection.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.CodeDom
  16. {
  17.    
  18.     using System.Diagnostics;
  19.     using System;
  20.     using System.Collections;
  21.     using System.Runtime.InteropServices;
  22.     using System.Globalization;
  23.    
  24.     /// <devdoc>
  25.     /// <para>
  26.     /// Manages a collection of <see cref='System.CodeDom.CodeNamespaceImport'/> objects.
  27.     /// </para>
  28.     /// </devdoc>
  29.     [ClassInterface(ClassInterfaceType.AutoDispatch), ComVisible(true), Serializable()]
  30.     public class CodeNamespaceImportCollection : IList
  31.     {
  32.         private ArrayList data = new ArrayList();
  33.         private Hashtable keys = new Hashtable(StringComparer.OrdinalIgnoreCase);
  34.        
  35.         /// <devdoc>
  36.         /// <para>
  37.         /// Indexer method that provides collection access.
  38.         /// </para>
  39.         /// </devdoc>
  40.         public CodeNamespaceImport this[int index]
  41.         {
  42.             get { return ((CodeNamespaceImport)data[index]); }
  43.             set {
  44.                 data[index] = value;
  45.                 SyncKeys();
  46.             }
  47.         }
  48.        
  49.         /// <devdoc>
  50.         /// <para>
  51.         /// Gets or sets the number of namespaces in the collection.
  52.         /// </para>
  53.         /// </devdoc>
  54.         public int Count {
  55.             get { return data.Count; }
  56.         }
  57.        
  58.         /// <internalonly/>
  59.         bool IList.IsReadOnly {
  60.             get { return false; }
  61.         }
  62.        
  63.         /// <internalonly/>
  64.         bool IList.IsFixedSize {
  65.             get { return false; }
  66.         }
  67.        
  68.        
  69.         /// <devdoc>
  70.         /// <para>
  71.         /// Adds a namespace import to the collection.
  72.         /// </para>
  73.         /// </devdoc>
  74.         public void Add(CodeNamespaceImport value)
  75.         {
  76.             if (!keys.ContainsKey(value.Namespace)) {
  77.                 keys[value.Namespace] = value;
  78.                 data.Add(value);
  79.             }
  80.         }
  81.        
  82.         /// <devdoc>
  83.         /// <para>
  84.         /// Adds a set of <see cref='System.CodeDom.CodeNamespaceImport'/> objects to the collection.
  85.         /// </para>
  86.         /// </devdoc>
  87.         public void AddRange(CodeNamespaceImport[] value)
  88.         {
  89.             if (value == null) {
  90.                 throw new ArgumentNullException("value");
  91.             }
  92.             foreach (CodeNamespaceImport c in value) {
  93.                 Add(c);
  94.             }
  95.         }
  96.        
  97.         /// <devdoc>
  98.         /// <para>
  99.         /// Clears the collection of members.
  100.         /// </para>
  101.         /// </devdoc>
  102.         public void Clear()
  103.         {
  104.             data.Clear();
  105.             keys.Clear();
  106.         }
  107.        
  108.         /// <devdoc>
  109.         /// <para>
  110.         /// Makes the collection of keys synchronised with the data.
  111.         /// </para>
  112.         /// </devdoc>
  113.         private void SyncKeys()
  114.         {
  115.             keys = new Hashtable(StringComparer.OrdinalIgnoreCase);
  116.             foreach (CodeNamespaceImport c in this) {
  117.                 keys[c.Namespace] = c;
  118.             }
  119.         }
  120.        
  121.         /// <devdoc>
  122.         /// <para>
  123.         /// Gets an enumerator that enumerates the collection members.
  124.         /// </para>
  125.         /// </devdoc>
  126.         public IEnumerator GetEnumerator()
  127.         {
  128.             return data.GetEnumerator();
  129.         }
  130.        
  131.         /// <internalonly/>
  132.         object IList.this[int index]
  133.         {
  134.             get { return this[index]; }
  135.             set {
  136.                 this[index] = (CodeNamespaceImport)value;
  137.                 SyncKeys();
  138.             }
  139.         }
  140.        
  141.         /// <internalonly/>
  142.         int ICollection.Count {
  143.             get { return Count; }
  144.         }
  145.        
  146.         /// <internalonly/>
  147.         bool ICollection.IsSynchronized {
  148.             get { return false; }
  149.         }
  150.        
  151.         /// <internalonly/>
  152.         object ICollection.SyncRoot {
  153.             get { return null; }
  154.         }
  155.        
  156.         /// <internalonly/>
  157.         void ICollection.CopyTo(Array array, int index)
  158.         {
  159.             data.CopyTo(array, index);
  160.         }
  161.        
  162.         /// <internalonly/>
  163.         IEnumerator IEnumerable.GetEnumerator()
  164.         {
  165.             return GetEnumerator();
  166.         }
  167.        
  168.         /// <internalonly/>
  169.         int IList.Add(object value)
  170.         {
  171.             return data.Add((CodeNamespaceImport)value);
  172.         }
  173.        
  174.         /// <internalonly/>
  175.         void IList.Clear()
  176.         {
  177.             Clear();
  178.         }
  179.        
  180.         /// <internalonly/>
  181.         bool IList.Contains(object value)
  182.         {
  183.             return data.Contains(value);
  184.         }
  185.        
  186.         /// <internalonly/>
  187.         int IList.IndexOf(object value)
  188.         {
  189.             return data.IndexOf((CodeNamespaceImport)value);
  190.         }
  191.        
  192.         /// <internalonly/>
  193.         void IList.Insert(int index, object value)
  194.         {
  195.             data.Insert(index, (CodeNamespaceImport)value);
  196.             SyncKeys();
  197.         }
  198.        
  199.         /// <internalonly/>
  200.         void IList.Remove(object value)
  201.         {
  202.             data.Remove((CodeNamespaceImport)value);
  203.             SyncKeys();
  204.         }
  205.        
  206.         /// <internalonly/>
  207.         void IList.RemoveAt(int index)
  208.         {
  209.             data.RemoveAt(index);
  210.             SyncKeys();
  211.         }
  212.     }
  213. }

Developer Fusion