docs/HtmlAgilityPack/MixedCodeDocumentFragmentList.cs

   1 // HtmlAgilityPack V1.0 - Simon Mourier <simon underscore mourier at hotmail dot com>
   2 using System;
   3 using System.Collections;
   4
   5 namespace HtmlAgilityPack
   6 {
   7     /// <summary>
   8     /// Represents a list of mixed code fragments.
   9     /// </summary>
  10     public class MixedCodeDocumentFragmentList : IEnumerable
  11     {
  12         #region Fields
  13
  14         private MixedCodeDocument _doc;
  15         private ArrayList _items = new ArrayList();
  16
  17         #endregion
  18
  19         #region Constructors
  20
  21         internal MixedCodeDocumentFragmentList(MixedCodeDocument doc)
  22         {
  23             _doc = doc;
  24         }
  25
  26         #endregion
  27
  28         #region Properties
  29
  30         ///<summary>
  31         /// Gets the Document
  32         ///</summary>
  33         public MixedCodeDocument Doc
  34         {
  35             get { return _doc; }
  36         }
  37
  38         /// <summary>
  39         /// Gets the number of fragments contained in the list.
  40         /// </summary>
  41         public int Count
  42         {
  43             get { return _items.Count; }
  44         }
  45
  46         /// <summary>
  47         /// Gets a fragment from the list using its index.
  48         /// </summary>
  49         public MixedCodeDocumentFragment this[int index]
  50         {
  51             get { return _items[index] as MixedCodeDocumentFragment; }
  52         }
  53
  54         #endregion
  55
  56         #region IEnumerable Members
  57
  58         /// <summary>
  59         /// Gets an enumerator that can iterate through the fragment list.
  60         /// </summary>
  61         IEnumerator IEnumerable.GetEnumerator()
  62         {
  63             return GetEnumerator();
  64         }
  65
  66         #endregion
  67
  68         #region Public Methods
  69
  70         /// <summary>
  71         /// Appends a fragment to the list of fragments.
  72         /// </summary>
  73         /// <param name="newFragment">The fragment to append. May not be null.</param>
  74         public void Append(MixedCodeDocumentFragment newFragment)
  75         {
  76             if (newFragment == null)
  77             {
  78                 throw new ArgumentNullException("newFragment");
  79             }
  80             _items.Add(newFragment);
  81         }
  82
  83         /// <summary>
  84         /// Gets an enumerator that can iterate through the fragment list.
  85         /// </summary>
  86         public MixedCodeDocumentFragmentEnumerator GetEnumerator()
  87         {
  88             return new MixedCodeDocumentFragmentEnumerator(_items);
  89         }
  90
  91         /// <summary>
  92         /// Prepends a fragment to the list of fragments.
  93         /// </summary>
  94         /// <param name="newFragment">The fragment to append. May not be null.</param>
  95         public void Prepend(MixedCodeDocumentFragment newFragment)
  96         {
  97             if (newFragment == null)
  98             {
  99                 throw new ArgumentNullException("newFragment");
 100             }
 101             _items.Insert(0, newFragment);
 102         }
 103
 104         /// <summary>
 105         /// Remove a fragment from the list of fragments. If this fragment was not in the list, an exception will be raised.
 106         /// </summary>
 107         /// <param name="fragment">The fragment to remove. May not be null.</param>
 108         public void Remove(MixedCodeDocumentFragment fragment)
 109         {
 110             if (fragment == null)
 111             {
 112                 throw new ArgumentNullException("fragment");
 113             }
 114             int index = GetFragmentIndex(fragment);
 115             if (index == -1)
 116             {
 117                 throw new IndexOutOfRangeException();
 118             }
 119             RemoveAt(index);
 120         }
 121
 122         /// <summary>
 123         /// Remove all fragments from the list.
 124         /// </summary>
 125         public void RemoveAll()
 126         {
 127             _items.Clear();
 128         }
 129
 130         /// <summary>
 131         /// Remove a fragment from the list of fragments, using its index in the list.
 132         /// </summary>
 133         /// <param name="index">The index of the fragment to remove.</param>
 134         public void RemoveAt(int index)
 135         {
 136             //MixedCodeDocumentFragment frag = (MixedCodeDocumentFragment) _items[index];
 137             _items.RemoveAt(index);
 138         }
 139
 140         #endregion
 141
 142         #region Internal Methods
 143
 144         internal void Clear()
 145         {
 146             _items.Clear();
 147         }
 148
 149         internal int GetFragmentIndex(MixedCodeDocumentFragment fragment)
 150         {
 151             if (fragment == null)
 152             {
 153                 throw new ArgumentNullException("fragment");
 154             }
 155             for (int i = 0; i < _items.Count; i++)
 156             {
 157                 if ((_items[i]) == fragment)
 158                 {
 159                     return i;
 160                 }
 161             }
 162             return -1;
 163         }
 164
 165         #endregion
 166
 167         #region Nested type: MixedCodeDocumentFragmentEnumerator
 168
 169         /// <summary>
 170         /// Represents a fragment enumerator.
 171         /// </summary>
 172         public class MixedCodeDocumentFragmentEnumerator : IEnumerator
 173         {
 174             #region Fields
 175
 176             private int _index;
 177             private ArrayList _items;
 178
 179             #endregion
 180
 181             #region Constructors
 182
 183             internal MixedCodeDocumentFragmentEnumerator(ArrayList items)
 184             {
 185                 _items = items;
 186                 _index = -1;
 187             }
 188
 189             #endregion
 190
 191             #region Properties
 192
 193             /// <summary>
 194             /// Gets the current element in the collection.
 195             /// </summary>
 196             public MixedCodeDocumentFragment Current
 197             {
 198                 get { return (MixedCodeDocumentFragment) (_items[_index]); }
 199             }
 200
 201             #endregion
 202
 203             #region IEnumerator Members
 204
 205             /// <summary>
 206             /// Gets the current element in the collection.
 207             /// </summary>
 208             object IEnumerator.Current
 209             {
 210                 get { return (Current); }
 211             }
 212
 213             /// <summary>
 214             /// Advances the enumerator to the next element of the collection.
 215             /// </summary>
 216             /// <returns>true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.</returns>
 217             public bool MoveNext()
 218             {
 219                 _index++;
 220                 return (_index < _items.Count);
 221             }
 222
 223             /// <summary>
 224             /// Sets the enumerator to its initial position, which is before the first element in the collection.
 225             /// </summary>
 226             public void Reset()
 227             {
 228                 _index = -1;
 229             }
 230
 231             #endregion
 232         }
 233
 234         #endregion
 235     }
 236 }