docs/HtmlAgilityPack/HtmlAttributeCollection.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 HtmlAttributeCollection : IList<HtmlAttribute>
  12     {
  13         #region Fields
  14
  15         internal Dictionary<string, HtmlAttribute> Hashitems = new Dictionary<string, HtmlAttribute>();
  16         private HtmlNode _ownernode;
  17         private List<HtmlAttribute> items = new List<HtmlAttribute>();
  18
  19         #endregion
  20
  21         #region Constructors
  22
  23         internal HtmlAttributeCollection(HtmlNode ownernode)
  24         {
  25             _ownernode = ownernode;
  26         }
  27
  28         #endregion
  29
  30         #region Properties
  31
  32         /// <summary>
  33         /// Gets a given attribute from the list using its name.
  34         /// </summary>
  35         public HtmlAttribute this[string name]
  36         {
  37             get
  38             {
  39                 if (name == null)
  40                 {
  41                     throw new ArgumentNullException("name");
  42                 }
  43                 return Hashitems.ContainsKey(name.ToLower()) ? Hashitems[name.ToLower()] : null;
  44             }
  45             set { Append(value); }
  46         }
  47
  48         #endregion
  49
  50         #region IList<HtmlAttribute> Members
  51
  52         /// <summary>
  53         /// Gets the number of elements actually contained in the list.
  54         /// </summary>
  55         public int Count
  56         {
  57             get { return items.Count; }
  58         }
  59
  60         /// <summary>
  61         /// Gets readonly status of colelction
  62         /// </summary>
  63         public bool IsReadOnly
  64         {
  65             get { return false; }
  66         }
  67
  68         /// <summary>
  69         /// Gets the attribute at the specified index.
  70         /// </summary>
  71         public HtmlAttribute this[int index]
  72         {
  73             get { return items[index]; }
  74             set { items[index] = value; }
  75         }
  76
  77         /// <summary>
  78         /// Adds supplied item to collection
  79         /// </summary>
  80         /// <param name="item"></param>
  81         public void Add(HtmlAttribute item)
  82         {
  83             Append(item);
  84         }
  85
  86         /// <summary>
  87         /// Explicit clear
  88         /// </summary>
  89         void ICollection<HtmlAttribute>.Clear()
  90         {
  91             items.Clear();
  92         }
  93
  94         /// <summary>
  95         /// Retreives existence of supplied item
  96         /// </summary>
  97         /// <param name="item"></param>
  98         /// <returns></returns>
  99         public bool Contains(HtmlAttribute item)
 100         {
 101             return items.Contains(item);
 102         }
 103
 104         /// <summary>
 105         /// Copies collection to array
 106         /// </summary>
 107         /// <param name="array"></param>
 108         /// <param name="arrayIndex"></param>
 109         public void CopyTo(HtmlAttribute[] array, int arrayIndex)
 110         {
 111             items.CopyTo(array, arrayIndex);
 112         }
 113
 114         /// <summary>
 115         /// Get Explicit enumerator
 116         /// </summary>
 117         /// <returns></returns>
 118         IEnumerator<HtmlAttribute> IEnumerable<HtmlAttribute>.GetEnumerator()
 119         {
 120             return items.GetEnumerator();
 121         }
 122
 123         /// <summary>
 124         /// Explicit non-generic enumerator
 125         /// </summary>
 126         /// <returns></returns>
 127         IEnumerator IEnumerable.GetEnumerator()
 128         {
 129             return items.GetEnumerator();
 130         }
 131
 132         /// <summary>
 133         /// Retrieves the index for the supplied item, -1 if not found
 134         /// </summary>
 135         /// <param name="item"></param>
 136         /// <returns></returns>
 137         public int IndexOf(HtmlAttribute item)
 138         {
 139             return items.IndexOf(item);
 140         }
 141
 142         /// <summary>
 143         /// Inserts given item into collection at supplied index
 144         /// </summary>
 145         /// <param name="index"></param>
 146         /// <param name="item"></param>
 147         public void Insert(int index, HtmlAttribute item)
 148         {
 149             if (item == null)
 150             {
 151                 throw new ArgumentNullException("item");
 152             }
 153
 154             Hashitems[item.Name] = item;
 155             item._ownernode = _ownernode;
 156             items.Insert(index, item);
 157
 158             _ownernode._innerchanged = true;
 159             _ownernode._outerchanged = true;
 160         }
 161
 162         /// <summary>
 163         /// Explicit collection remove
 164         /// </summary>
 165         /// <param name="item"></param>
 166         /// <returns></returns>
 167         bool ICollection<HtmlAttribute>.Remove(HtmlAttribute item)
 168         {
 169             return items.Remove(item);
 170         }
 171
 172         /// <summary>
 173         /// Removes the attribute at the specified index.
 174         /// </summary>
 175         /// <param name="index">The index of the attribute to remove.</param>
 176         public void RemoveAt(int index)
 177         {
 178             HtmlAttribute att = items[index];
 179             Hashitems.Remove(att.Name);
 180             items.RemoveAt(index);
 181
 182             _ownernode._innerchanged = true;
 183             _ownernode._outerchanged = true;
 184         }
 185
 186         #endregion
 187
 188         #region Public Methods
 189
 190         /// <summary>
 191         /// Adds a new attribute to the collection with the given values
 192         /// </summary>
 193         /// <param name="name"></param>
 194         /// <param name="value"></param>
 195         public void Add(string name, string value)
 196         {
 197             Append(name, value);
 198         }
 199
 200         /// <summary>
 201         /// Inserts the specified attribute as the last attribute in the collection.
 202         /// </summary>
 203         /// <param name="newAttribute">The attribute to insert. May not be null.</param>
 204         /// <returns>The appended attribute.</returns>
 205         public HtmlAttribute Append(HtmlAttribute newAttribute)
 206         {
 207             if (newAttribute == null)
 208             {
 209                 throw new ArgumentNullException("newAttribute");
 210             }
 211
 212             Hashitems[newAttribute.Name] = newAttribute;
 213             newAttribute._ownernode = _ownernode;
 214             items.Add(newAttribute);
 215
 216             _ownernode._innerchanged = true;
 217             _ownernode._outerchanged = true;
 218             return newAttribute;
 219         }
 220
 221         /// <summary>
 222         /// Creates and inserts a new attribute as the last attribute in the collection.
 223         /// </summary>
 224         /// <param name="name">The name of the attribute to insert.</param>
 225         /// <returns>The appended attribute.</returns>
 226         public HtmlAttribute Append(string name)
 227         {
 228             HtmlAttribute att = _ownernode._ownerdocument.CreateAttribute(name);
 229             return Append(att);
 230         }
 231
 232         /// <summary>
 233         /// Creates and inserts a new attribute as the last attribute in the collection.
 234         /// </summary>
 235         /// <param name="name">The name of the attribute to insert.</param>
 236         /// <param name="value">The value of the attribute to insert.</param>
 237         /// <returns>The appended attribute.</returns>
 238         public HtmlAttribute Append(string name, string value)
 239         {
 240             HtmlAttribute att = _ownernode._ownerdocument.CreateAttribute(name, value);
 241             return Append(att);
 242         }
 243
 244         /// <summary>
 245         /// Checks for existance of attribute with given name
 246         /// </summary>
 247         /// <param name="name"></param>
 248         /// <returns></returns>
 249         public bool Contains(string name)
 250         {
 251             for (int i = 0; i < items.Count; i++)
 252             {
 253                 if (items[i].Name.Equals(name.ToLower()))
 254                     return true;
 255             }
 256             return false;
 257         }
 258
 259         /// <summary>
 260         /// Inserts the specified attribute as the first node in the collection.
 261         /// </summary>
 262         /// <param name="newAttribute">The attribute to insert. May not be null.</param>
 263         /// <returns>The prepended attribute.</returns>
 264         public HtmlAttribute Prepend(HtmlAttribute newAttribute)
 265         {
 266             Insert(0, newAttribute);
 267             return newAttribute;
 268         }
 269
 270         /// <summary>
 271         /// Removes a given attribute from the list.
 272         /// </summary>
 273         /// <param name="attribute">The attribute to remove. May not be null.</param>
 274         public void Remove(HtmlAttribute attribute)
 275         {
 276             if (attribute == null)
 277             {
 278                 throw new ArgumentNullException("attribute");
 279             }
 280             int index = GetAttributeIndex(attribute);
 281             if (index == -1)
 282             {
 283                 throw new IndexOutOfRangeException();
 284             }
 285             RemoveAt(index);
 286         }
 287
 288         /// <summary>
 289         /// Removes an attribute from the list, using its name. If there are more than one attributes with this name, they will all be removed.
 290         /// </summary>
 291         /// <param name="name">The attribute's name. May not be null.</param>
 292         public void Remove(string name)
 293         {
 294             if (name == null)
 295             {
 296                 throw new ArgumentNullException("name");
 297             }
 298
 299             string lname = name.ToLower();
 300             for (int i = 0; i < items.Count; i++)
 301             {
 302                 HtmlAttribute att = items[i];
 303                 if (att.Name == lname)
 304                 {
 305                     RemoveAt(i);
 306                 }
 307             }
 308         }
 309
 310         /// <summary>
 311         /// Remove all attributes in the list.
 312         /// </summary>
 313         public void RemoveAll()
 314         {
 315             Hashitems.Clear();
 316             items.Clear();
 317
 318             _ownernode._innerchanged = true;
 319             _ownernode._outerchanged = true;
 320         }
 321
 322         #endregion
 323
 324         #region LINQ Methods
 325
 326         /// <summary>
 327         /// Returns all attributes with specified name. Handles case insentivity
 328         /// </summary>
 329         /// <param name="attributeName">Name of the attribute</param>
 330         /// <returns></returns>
 331         public IEnumerable<HtmlAttribute> AttributesWithName(string attributeName)
 332         {
 333             attributeName = attributeName.ToLower();
 334             for (int i = 0; i < items.Count; i++)
 335             {
 336                 if (items[i].Name.Equals(attributeName))
 337                     yield return items[i];
 338             }
 339         }
 340
 341         /// <summary>
 342         /// Removes all attributes from the collection
 343         /// </summary>
 344         public void Remove()
 345         {
 346             foreach (HtmlAttribute item in items)
 347                 item.Remove();
 348         }
 349
 350         #endregion
 351
 352         #region Internal Methods
 353
 354         /// <summary>
 355         /// Clears the attribute collection
 356         /// </summary>
 357         internal void Clear()
 358         {
 359             Hashitems.Clear();
 360             items.Clear();
 361         }
 362
 363         internal int GetAttributeIndex(HtmlAttribute attribute)
 364         {
 365             if (attribute == null)
 366             {
 367                 throw new ArgumentNullException("attribute");
 368             }
 369             for (int i = 0; i < items.Count; i++)
 370             {
 371                 if ((items[i]) == attribute)
 372                     return i;
 373             }
 374             return -1;
 375         }
 376
 377         internal int GetAttributeIndex(string name)
 378         {
 379             if (name == null)
 380             {
 381                 throw new ArgumentNullException("name");
 382             }
 383             string lname = name.ToLower();
 384             for (int i = 0; i < items.Count; i++)
 385             {
 386                 if ((items[i]).Name == lname)
 387                     return i;
 388             }
 389             return -1;
 390         }
 391
 392         #endregion
 393     }
 394 }