docs/HtmlAgilityPack/HtmlNodeCollection.cs

   1 // HtmlAgilityPack V1.0 - Simon Mourier <simon underscore mourier at hotmail dot com>
   2 using System;
   3 using System.Collections;
   4 using System.Collections.Generic;
   5
   6 namespace HtmlAgilityPack
   7 {
   8     /// <summary>
   9     /// Represents a combined list and collection of HTML nodes.
  10     /// </summary>
  11     public class HtmlNodeCollection : IList<HtmlNode>
  12     {
  13         #region Fields
  14
  15         private readonly HtmlNode _parentnode;
  16         private readonly List<HtmlNode> _items = new List<HtmlNode>();
  17
  18         #endregion
  19
  20         #region Constructors
  21
  22         /// <summary>
  23         /// Initialize the HtmlNodeCollection with the base parent node
  24         /// </summary>
  25         /// <param name="parentnode">The base node of the collection</param>
  26         public HtmlNodeCollection(HtmlNode parentnode)
  27         {
  28             _parentnode = parentnode; // may be null
  29         }
  30
  31         #endregion
  32
  33         #region Properties
  34
  35         /// <summary>
  36         /// Gets a given node from the list.
  37         /// </summary>
  38         public int this[HtmlNode node]
  39         {
  40             get
  41             {
  42                 int index = GetNodeIndex(node);
  43                 if (index == -1)
  44                 {
  45                     throw new ArgumentOutOfRangeException("node",
  46                                                           "Node \"" + node.CloneNode(false).OuterHtml +
  47                                                           "\" was not found in the collection");
  48                 }
  49                 return index;
  50             }
  51         }
  52
  53         /// <summary>
  54         /// Get node with tag name
  55         /// </summary>
  56         /// <param name="nodeName"></param>
  57         /// <returns></returns>
  58         public HtmlNode this[string nodeName]
  59         {
  60             get
  61             {
  62                 nodeName = nodeName.ToLower();
  63                 for (int i = 0; i < _items.Count; i++)
  64                     if (_items[i].Equals(nodeName))
  65                         return _items[i];
  66
  67                 return null;
  68             }
  69         }
  70
  71         #endregion
  72
  73         #region IList<HtmlNode> Members
  74
  75         /// <summary>
  76         /// Gets the number of elements actually contained in the list.
  77         /// </summary>
  78         public int Count
  79         {
  80             get { return _items.Count; }
  81         }
  82
  83         /// <summary>
  84         /// Is collection read only
  85         /// </summary>
  86         public bool IsReadOnly
  87         {
  88             get { return false; }
  89         }
  90
  91         /// <summary>
  92         /// Gets the node at the specified index.
  93         /// </summary>
  94         public HtmlNode this[int index]
  95         {
  96             get { return _items[index]; }
  97             set { _items[index] = value; }
  98         }
  99
 100         /// <summary>
 101         /// Add node to the collection
 102         /// </summary>
 103         /// <param name="node"></param>
 104         public void Add(HtmlNode node)
 105         {
 106             _items.Add(node);
 107         }
 108
 109         /// <summary>
 110         /// Clears out the collection of HtmlNodes. Removes each nodes reference to parentnode, nextnode and prevnode
 111         /// </summary>
 112         public void Clear()
 113         {
 114             foreach (HtmlNode node in _items)
 115             {
 116                 node.ParentNode = null;
 117                 node.NextSibling = null;
 118                 node.PreviousSibling = null;
 119             }
 120             _items.Clear();
 121         }
 122
 123         /// <summary>
 124         /// Gets existence of node in collection
 125         /// </summary>
 126         /// <param name="item"></param>
 127         /// <returns></returns>
 128         public bool Contains(HtmlNode item)
 129         {
 130             return _items.Contains(item);
 131         }
 132
 133         /// <summary>
 134         /// Copy collection to array
 135         /// </summary>
 136         /// <param name="array"></param>
 137         /// <param name="arrayIndex"></param>
 138         public void CopyTo(HtmlNode[] array, int arrayIndex)
 139         {
 140             _items.CopyTo(array, arrayIndex);
 141         }
 142
 143         /// <summary>
 144         /// Get Enumerator
 145         /// </summary>
 146         /// <returns></returns>
 147         IEnumerator<HtmlNode> IEnumerable<HtmlNode>.GetEnumerator()
 148         {
 149             return _items.GetEnumerator();
 150         }
 151
 152         /// <summary>
 153         /// Get Explicit Enumerator
 154         /// </summary>
 155         /// <returns></returns>
 156         IEnumerator IEnumerable.GetEnumerator()
 157         {
 158             return _items.GetEnumerator();
 159         }
 160
 161         /// <summary>
 162         /// Get index of node
 163         /// </summary>
 164         /// <param name="item"></param>
 165         /// <returns></returns>
 166         public int IndexOf(HtmlNode item)
 167         {
 168             return _items.IndexOf(item);
 169         }
 170
 171         /// <summary>
 172         /// Insert node at index
 173         /// </summary>
 174         /// <param name="index"></param>
 175         /// <param name="node"></param>
 176         public void Insert(int index, HtmlNode node)
 177         {
 178             HtmlNode next = null;
 179             HtmlNode prev = null;
 180
 181             if (index > 0)
 182             {
 183                 prev = _items[index - 1];
 184             }
 185
 186             if (index < _items.Count)
 187             {
 188                 next = _items[index];
 189             }
 190
 191             _items.Insert(index, node);
 192
 193             if (prev != null)
 194             {
 195                 if (node == prev)
 196                 {
 197                     throw new InvalidProgramException("Unexpected error.");
 198                 }
 199                 prev._nextnode = node;
 200             }
 201
 202             if (next != null)
 203             {
 204                 next._prevnode = node;
 205             }
 206
 207             node._prevnode = prev;
 208             if (next == node)
 209             {
 210                 throw new InvalidProgramException("Unexpected error.");
 211             }
 212             node._nextnode = next;
 213             node._parentnode = _parentnode;
 214         }
 215
 216         /// <summary>
 217         /// Remove node
 218         /// </summary>
 219         /// <param name="item"></param>
 220         /// <returns></returns>
 221         public bool Remove(HtmlNode item)
 222         {
 223             int i = _items.IndexOf(item);
 224             RemoveAt(i);
 225             return true;
 226         }
 227
 228         /// <summary>
 229         /// Remove <see cref="HtmlNode"/> at index
 230         /// </summary>
 231         /// <param name="index"></param>
 232         public void RemoveAt(int index)
 233         {
 234             HtmlNode next = null;
 235             HtmlNode prev = null;
 236             HtmlNode oldnode = _items[index];
 237
 238             if (index > 0)
 239             {
 240                 prev = _items[index - 1];
 241             }
 242
 243             if (index < (_items.Count - 1))
 244             {
 245                 next = _items[index + 1];
 246             }
 247
 248             _items.RemoveAt(index);
 249
 250             if (prev != null)
 251             {
 252                 if (next == prev)
 253                 {
 254                     throw new InvalidProgramException("Unexpected error.");
 255                 }
 256                 prev._nextnode = next;
 257             }
 258
 259             if (next != null)
 260             {
 261                 next._prevnode = prev;
 262             }
 263
 264             oldnode._prevnode = null;
 265             oldnode._nextnode = null;
 266             oldnode._parentnode = null;
 267         }
 268
 269         #endregion
 270
 271         #region Public Methods
 272
 273         /// <summary>
 274         /// Get first instance of node in supplied collection
 275         /// </summary>
 276         /// <param name="items"></param>
 277         /// <param name="name"></param>
 278         /// <returns></returns>
 279         public static HtmlNode FindFirst(HtmlNodeCollection items, string name)
 280         {
 281             foreach (HtmlNode node in items)
 282             {
 283                 if (node.Name.ToLower().Contains(name))
 284                     return node;
 285                 if (node.HasChildNodes)
 286                 {
 287                     HtmlNode returnNode = FindFirst(node.ChildNodes, name);
 288                     if (returnNode != null)
 289                         return returnNode;
 290                 }
 291             }
 292             return null;
 293         }
 294
 295         /// <summary>
 296         /// Add node to the end of the collection
 297         /// </summary>
 298         /// <param name="node"></param>
 299         public void Append(HtmlNode node)
 300         {
 301             HtmlNode last = null;
 302             if (_items.Count > 0)
 303             {
 304                 last = _items[_items.Count - 1];
 305             }
 306
 307             _items.Add(node);
 308             node._prevnode = last;
 309             node._nextnode = null;
 310             node._parentnode = _parentnode;
 311             if (last != null)
 312             {
 313                 if (last == node)
 314                 {
 315                     throw new InvalidProgramException("Unexpected error.");
 316                 }
 317                 last._nextnode = node;
 318             }
 319         }
 320
 321         /// <summary>
 322         /// Get first instance of node with name
 323         /// </summary>
 324         /// <param name="name"></param>
 325         /// <returns></returns>
 326         public HtmlNode FindFirst(string name)
 327         {
 328             return FindFirst(this, name);
 329         }
 330
 331         /// <summary>
 332         /// Get index of node
 333         /// </summary>
 334         /// <param name="node"></param>
 335         /// <returns></returns>
 336         public int GetNodeIndex(HtmlNode node)
 337         {
 338             // TODO: should we rewrite this? what would be the key of a node?
 339             for (int i = 0; i < _items.Count; i++)
 340             {
 341                 if (node == (_items[i]))
 342                 {
 343                     return i;
 344                 }
 345             }
 346             return -1;
 347         }
 348
 349         /// <summary>
 350         /// Add node to the beginning of the collection
 351         /// </summary>
 352         /// <param name="node"></param>
 353         public void Prepend(HtmlNode node)
 354         {
 355             HtmlNode first = null;
 356             if (_items.Count > 0)
 357             {
 358                 first = _items[0];
 359             }
 360
 361             _items.Insert(0, node);
 362
 363             if (node == first)
 364             {
 365                 throw new InvalidProgramException("Unexpected error.");
 366             }
 367             node._nextnode = first;
 368             node._prevnode = null;
 369             node._parentnode = _parentnode;
 370             if (first != null)
 371             {
 372                 first._prevnode = node;
 373             }
 374         }
 375
 376         /// <summary>
 377         /// Remove node at index
 378         /// </summary>
 379         /// <param name="index"></param>
 380         /// <returns></returns>
 381         public bool Remove(int index)
 382         {
 383             RemoveAt(index);
 384             return true;
 385         }
 386
 387         /// <summary>
 388         /// Replace node at index
 389         /// </summary>
 390         /// <param name="index"></param>
 391         /// <param name="node"></param>
 392         public void Replace(int index, HtmlNode node)
 393         {
 394             HtmlNode next = null;
 395             HtmlNode prev = null;
 396             HtmlNode oldnode = _items[index];
 397
 398             if (index > 0)
 399             {
 400                 prev = _items[index - 1];
 401             }
 402
 403             if (index < (_items.Count - 1))
 404             {
 405                 next = _items[index + 1];
 406             }
 407
 408             _items[index] = node;
 409
 410             if (prev != null)
 411             {
 412                 if (node == prev)
 413                 {
 414                     throw new InvalidProgramException("Unexpected error.");
 415                 }
 416                 prev._nextnode = node;
 417             }
 418
 419             if (next != null)
 420             {
 421                 next._prevnode = node;
 422             }
 423
 424             node._prevnode = prev;
 425
 426             if (next == node)
 427             {
 428                 throw new InvalidProgramException("Unexpected error.");
 429             }
 430
 431             node._nextnode = next;
 432             node._parentnode = _parentnode;
 433
 434             oldnode._prevnode = null;
 435             oldnode._nextnode = null;
 436             oldnode._parentnode = null;
 437         }
 438
 439         #endregion
 440
 441         #region LINQ Methods
 442
 443         /// <summary>
 444         /// Get all node descended from this collection
 445         /// </summary>
 446         /// <returns></returns>
 447         public IEnumerable<HtmlNode> DescendantNodes()
 448         {
 449             foreach (HtmlNode item in _items)
 450                 foreach (HtmlNode n in item.DescendantNodes())
 451                     yield return n;
 452         }
 453
 454         /// <summary>
 455         /// Get all node descended from this collection
 456         /// </summary>
 457         /// <returns></returns>
 458         public IEnumerable<HtmlNode> Descendants()
 459         {
 460             foreach (HtmlNode item in _items)
 461                 foreach (HtmlNode n in item.Descendants())
 462                     yield return n;
 463         }
 464
 465         /// <summary>
 466         /// Get all node descended from this collection with matching name
 467         /// </summary>
 468         /// <returns></returns>
 469         public IEnumerable<HtmlNode> Descendants(string name)
 470         {
 471             foreach (HtmlNode item in _items)
 472                 foreach (HtmlNode n in item.Descendants(name))
 473                     yield return n;
 474         }
 475
 476         /// <summary>
 477         /// Gets all first generation elements in collection
 478         /// </summary>
 479         /// <returns></returns>
 480         public IEnumerable<HtmlNode> Elements()
 481         {
 482             foreach (HtmlNode item in _items)
 483                 foreach (HtmlNode n in item.ChildNodes)
 484                     yield return n;
 485         }
 486
 487         /// <summary>
 488         /// Gets all first generation elements matching name
 489         /// </summary>
 490         /// <param name="name"></param>
 491         /// <returns></returns>
 492         public IEnumerable<HtmlNode> Elements(string name)
 493         {
 494             foreach (HtmlNode item in _items)
 495                 foreach (HtmlNode n in item.Elements(name))
 496                     yield return n;
 497         }
 498
 499         /// <summary>
 500         /// All first generation nodes in collection
 501         /// </summary>
 502         /// <returns></returns>
 503         public IEnumerable<HtmlNode> Nodes()
 504         {
 505             foreach (HtmlNode item in _items)
 506                 foreach (HtmlNode n in item.ChildNodes)
 507                     yield return n;
 508         }
 509
 510         #endregion
 511     }
 512 }