The Labs \ Source Viewer \ SSCLI \ System.Xml \ ListBase

  1. //------------------------------------------------------------------------------
  2. // <copyright file="ListBase.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. using System;
  16. using System.Xml;
  17. using System.Xml.Schema;
  18. using System.Collections.Generic;
  19. using System.Diagnostics;
  20. using System.Text;
  21. namespace System.Xml
  22. {
  23.    
  24.     /// <summary>
  25.     /// Implementation of read-only IList and IList<T> interfaces. Derived classes can inherit from
  26.     /// this class and implement only two methods, Count and Item, rather than the entire IList interface.
  27.     /// </summary>
  28.     internal abstract class ListBase<T> : IList<T>, System.Collections.IList
  29.     {
  30.         //-----------------------------------------------
  31.         // Abstract IList methods that must be
  32.         // implemented by derived classes
  33.         //-----------------------------------------------
  34.         public abstract int Count {
  35.             get;
  36.         }
  37.         public abstract T this[int index]
  38.         {
  39.             get;
  40.             set;
  41.         }
  42.        
  43.        
  44.         //-----------------------------------------------
  45.         // Implemented by base class -- accessible on
  46.         // ListBase
  47.         //-----------------------------------------------
  48.         public virtual bool Contains(T value)
  49.         {
  50.             return IndexOf(value) != -1;
  51.         }
  52.        
  53.         public virtual int IndexOf(T value)
  54.         {
  55.             for (int i = 0; i < Count; i++)
  56.                 if (value.Equals(this[i]))
  57.                     return i;
  58.            
  59.             return -1;
  60.         }
  61.        
  62.         public virtual void CopyTo(T[] array, int index)
  63.         {
  64.             for (int i = 0; i < Count; i++)
  65.                 array[index + i] = this[i];
  66.         }
  67.        
  68.         public virtual IListEnumerator<T> GetEnumerator()
  69.         {
  70.             return new IListEnumerator<T>(this);
  71.         }
  72.        
  73.         public virtual bool IsFixedSize {
  74.             get { return true; }
  75.         }
  76.        
  77.         public virtual bool IsReadOnly {
  78.             get { return true; }
  79.         }
  80.        
  81.         public virtual void Add(T value)
  82.         {
  83.             Insert(Count, value);
  84.         }
  85.        
  86.         public virtual void Insert(int index, T value)
  87.         {
  88.             throw new NotSupportedException();
  89.         }
  90.        
  91.         public virtual bool Remove(T value)
  92.         {
  93.             int index = IndexOf(value);
  94.             if (index >= 0) {
  95.                 RemoveAt(index);
  96.                 return true;
  97.             }
  98.             return false;
  99.         }
  100.        
  101.         public virtual void RemoveAt(int index)
  102.         {
  103.             throw new NotSupportedException();
  104.         }
  105.        
  106.         public virtual void Clear()
  107.         {
  108.             for (int index = Count - 1; index >= 0; index--)
  109.                 RemoveAt(index);
  110.         }
  111.        
  112.        
  113.         //-----------------------------------------------
  114.         // Implemented by base class -- only accessible
  115.         // after casting to IList
  116.         //-----------------------------------------------
  117.         IEnumerator<T> IEnumerable<T>.GetEnumerator()
  118.         {
  119.             return new IListEnumerator<T>(this);
  120.         }
  121.        
  122.         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
  123.         {
  124.             return new IListEnumerator<T>(this);
  125.         }
  126.        
  127.         bool System.Collections.ICollection.IsSynchronized {
  128.             get { return IsReadOnly; }
  129.         }
  130.        
  131.         object System.Collections.ICollection.SyncRoot {
  132.             get { return this; }
  133.         }
  134.        
  135.         void System.Collections.ICollection.CopyTo(Array array, int index)
  136.         {
  137.             for (int i = 0; i < Count; i++)
  138.                 array.SetValue(this[i], index);
  139.         }
  140.        
  141.         object System.Collections.IList.this[int index]
  142.         {
  143.             get { return this[index]; }
  144.             set {
  145.                 if (!IsCompatibleType(value.GetType()))
  146.                     throw new ArgumentException();
  147.                
  148.                 this[index] = (T)value;
  149.             }
  150.         }
  151.        
  152.         int System.Collections.IList.Add(object value)
  153.         {
  154.             if (!IsCompatibleType(value.GetType()))
  155.                 throw new ArgumentException();
  156.            
  157.             Add((T)value);
  158.             return Count - 1;
  159.         }
  160.        
  161.         void System.Collections.IList.Clear()
  162.         {
  163.             Clear();
  164.         }
  165.        
  166.         bool System.Collections.IList.Contains(object value)
  167.         {
  168.             if (!IsCompatibleType(value.GetType()))
  169.                 return false;
  170.            
  171.             return Contains((T)value);
  172.         }
  173.        
  174.         int System.Collections.IList.IndexOf(object value)
  175.         {
  176.             if (!IsCompatibleType(value.GetType()))
  177.                 return -1;
  178.            
  179.             return IndexOf((T)value);
  180.         }
  181.        
  182.         void System.Collections.IList.Insert(int index, object value)
  183.         {
  184.             if (!IsCompatibleType(value.GetType()))
  185.                 throw new ArgumentException();
  186.            
  187.             Insert(index, (T)value);
  188.         }
  189.        
  190.         void System.Collections.IList.Remove(object value)
  191.         {
  192.             if (!IsCompatibleType(value.GetType()))
  193.                 throw new ArgumentException();
  194.            
  195.             Remove((T)value);
  196.         }
  197.        
  198.        
  199.         //-----------------------------------------------
  200.         // Helper methods and classes
  201.         //-----------------------------------------------
  202.        
  203.         private static bool IsCompatibleType(object value)
  204.         {
  205.             if ((value == null && !typeof(T).IsValueType) || (value is T))
  206.                 return true;
  207.            
  208.             return false;
  209.         }
  210.     }
  211.    
  212.     /// <summary>
  213.     /// Implementation of IEnumerator<T> and IEnumerator over an IList<T>.
  214.     /// </summary>
  215.     internal struct IListEnumerator<T> : IEnumerator<T>, System.Collections.IEnumerator
  216.     {
  217.         private IList<T> sequence;
  218.         private int index;
  219.         private T current;
  220.        
  221.         /// <summary>
  222.         /// Constructor.
  223.         /// </summary>
  224.         public IListEnumerator(IList<T> sequence)
  225.         {
  226.             this.sequence = sequence;
  227.             this.index = 0;
  228.             this.current = default(T);
  229.         }
  230.        
  231.         /// <summary>
  232.         /// No-op.
  233.         /// </summary>
  234.         public void Dispose()
  235.         {
  236.         }
  237.        
  238.         /// <summary>
  239.         /// Return current item. Return default value if before first item or after last item in the list.
  240.         /// </summary>
  241.         public T Current {
  242.             get { return this.current; }
  243.         }
  244.        
  245.         /// <summary>
  246.         /// Return current item. Throw exception if before first item or after last item in the list.
  247.         /// </summary>
  248.         object System.Collections.IEnumerator.Current {
  249.             get {
  250.                 if (this.index == 0)
  251.                     throw new InvalidOperationException(Res.GetString(Res.Sch_EnumNotStarted, string.Empty));
  252.                
  253.                 if (this.index > this.sequence.Count)
  254.                     throw new InvalidOperationException(Res.GetString(Res.Sch_EnumFinished, string.Empty));
  255.                
  256.                 return this.current;
  257.             }
  258.         }
  259.        
  260.         /// <summary>
  261.         /// Advance enumerator to next item in list. Return false if there are no more items.
  262.         /// </summary>
  263.         public bool MoveNext()
  264.         {
  265.             if (this.index < this.sequence.Count) {
  266.                 this.current = this.sequence[this.index];
  267.                 this.index++;
  268.                 return true;
  269.             }
  270.            
  271.             this.current = default(T);
  272.             return false;
  273.         }
  274.        
  275.         /// <summary>
  276.         /// Set the enumerator to its initial position, which is before the first item in the list.
  277.         /// </summary>
  278.         void System.Collections.IEnumerator.Reset()
  279.         {
  280.             this.index = 0;
  281.             this.current = default(T);
  282.         }
  283.     }
  284. }

Developer Fusion