Filters/HtmlAgilityPack/HtmlAttribute.cs

   1 /*
   2 Copyright (C) 2003 Simon Mourier <simonm@microsoft.com>
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions
   7 are met:
   8 1. Redistributions of source code must retain the above copyright
   9    notice, this list of conditions and the following disclaimer.
  10 2. Redistributions in binary form must reproduce the above copyright
  11    notice, this list of conditions and the following disclaimer in the
  12    documentation and/or other materials provided with the distribution.
  13 3. The name of the author may not be used to endorse or promote products
  14    derived from this software without specific prior written permission.
  15
  16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27
  28 using System;
  29 using System.Collections;
  30
  31 namespace HtmlAgilityPack
  32 {
  33         /// <summary>
  34         /// Represents an HTML attribute.
  35         /// </summary>
  36         public class HtmlAttribute: IComparable
  37         {
  38                 internal int _line = 0;
  39                 internal int _lineposition = 0;
  40                 internal int _streamposition = 0;
  41                 internal int _namestartindex = 0;
  42                 internal int _namelength = 0;
  43                 internal int _valuestartindex = 0;
  44                 internal int _valuelength = 0;
  45                 internal HtmlDocument _ownerdocument; // attribute can exists without a node
  46                 internal HtmlNode _ownernode;
  47                 internal string _name;
  48                 internal string _value;
  49
  50                 internal HtmlAttribute(HtmlDocument ownerdocument)
  51                 {
  52                         _ownerdocument = ownerdocument;
  53                 }
  54
  55                 /// <summary>
  56                 /// Creates a duplicate of this attribute.
  57                 /// </summary>
  58                 /// <returns>The cloned attribute.</returns>
  59                 public HtmlAttribute Clone()
  60                 {
  61                         HtmlAttribute att = new HtmlAttribute(_ownerdocument);
  62                         att.Name = Name;
  63                         att.Value = Value;
  64                         return att;
  65                 }
  66
  67                 /// <summary>
  68                 /// Compares the current instance with another attribute. Comparison is based on attributes' name.
  69                 /// </summary>
  70                 /// <param name="obj">An attribute to compare with this instance.</param>
  71                 /// <returns>A 32-bit signed integer that indicates the relative order of the names comparison.</returns>
  72                 public int CompareTo(object obj)
  73                 {
  74                         HtmlAttribute att = obj as HtmlAttribute;
  75                         if (att == null)
  76                         {
  77                                 throw new ArgumentException("obj");
  78                         }
  79                         return Name.CompareTo(att.Name);
  80                 }
  81
  82                 internal string XmlName
  83                 {
  84                         get
  85                         {
  86                                 return GetXmlName(Name);
  87                         }
  88                 }
  89
  90                 /// <summary>
  91                 /// Gets a valid XML name.
  92                 /// </summary>
  93                 /// <param name="name">Any text.</param>
  94                 /// <returns>A string that is a valid XML name.</returns>
  95                 internal static string GetXmlName(string name)
  96                 {
  97                         string xmlname = string.Empty;
  98                         bool nameisok = true;
  99                         for(int i=0;i<name.Length;i++)
 100                         {
 101                                 // names are lcase
 102                                 // note: we are very limited here
 103                                 if (((name[i]>='a') && (name[i]<='z')) ||
 104                                         ((name[i]>='0') && (name[i]<='9')) ||
 105                                         //                                      (name[i]==':') || (name[i]=='_') || (name[i]=='-') || (name[i]=='.')) // these are bads in fact
 106                                         (name[i]=='_') || (name[i]=='-') || (name[i]=='.'))
 107                                 {
 108                                         xmlname += name[i];
 109                                 }
 110                                 else
 111                                 {
 112                                         nameisok = false;
 113                                         byte[] bytes = System.Text.Encoding.UTF8.GetBytes(new char[]{name[i]});
 114                                         for(int j=0;j<bytes.Length;j++)
 115                                         {
 116                                                 xmlname += bytes[j].ToString("x2");
 117                                         }
 118                                         xmlname += "_";
 119                                 }
 120
 121                         }
 122                         if (nameisok)
 123                         {
 124                                 return xmlname;
 125                         }
 126                         return "_" + xmlname;
 127                 }
 128
 129                 internal string XmlValue
 130                 {
 131                         get
 132                         {
 133                                 return Value;
 134                         }
 135                 }
 136
 137                 /// <summary>
 138                 /// Gets the qualified name of the attribute.
 139                 /// </summary>
 140                 public string Name
 141                 {
 142                         get
 143                         {
 144                                 if (_name == null)
 145                                 {
 146                                         _name = _ownerdocument._text.Substring(_namestartindex, _namelength).ToLower();
 147                                 }
 148                                 return _name;
 149                         }
 150                         set
 151                         {
 152                                 if (value == null)
 153                                 {
 154                                         throw new ArgumentNullException("value");
 155                                 }
 156                                 _name = value.ToLower();
 157                                 if (_ownernode != null)
 158                                 {
 159                                         _ownernode._innerchanged = true;
 160                                         _ownernode._outerchanged = true;
 161                                 }
 162                         }
 163                 }
 164
 165                 /// <summary>
 166                 /// Gets or sets the value of the attribute.
 167                 /// </summary>
 168                 public string Value
 169                 {
 170                         get
 171                         {
 172                                 if (_value == null)
 173                                 {
 174                                         _value = _ownerdocument._text.Substring(_valuestartindex, _valuelength);
 175                                 }
 176                                 return _value;
 177                         }
 178                         set
 179                         {
 180                                 _value = value;
 181                                 if (_ownernode != null)
 182                                 {
 183                                         _ownernode._innerchanged = true;
 184                                         _ownernode._outerchanged = true;
 185                                 }
 186                         }
 187                 }
 188
 189                 /// <summary>
 190                 /// Gets the line number of this attribute in the document.
 191                 /// </summary>
 192                 public int Line
 193                 {
 194                         get
 195                         {
 196                                 return _line;
 197                         }
 198                 }
 199
 200                 /// <summary>
 201                 /// Gets the column number of this attribute in the document.
 202                 /// </summary>
 203                 public int LinePosition
 204                 {
 205                         get
 206                         {
 207                                 return _lineposition;
 208                         }
 209                 }
 210
 211                 /// <summary>
 212                 /// Gets the stream position of this attribute in the document, relative to the start of the document.
 213                 /// </summary>
 214                 public int StreamPosition
 215                 {
 216                         get
 217                         {
 218                                 return _streamposition;
 219                         }
 220                 }
 221
 222                 /// <summary>
 223                 /// Gets the HTML node to which this attribute belongs.
 224                 /// </summary>
 225                 public HtmlNode OwnerNode
 226                 {
 227                         get
 228                         {
 229                                 return _ownernode;
 230                         }
 231                 }
 232
 233                 /// <summary>
 234                 /// Gets the HTML document to which this attribute belongs.
 235                 /// </summary>
 236                 public HtmlDocument OwnerDocument
 237                 {
 238                         get
 239                         {
 240                                 return _ownerdocument;
 241                         }
 242                 }
 243
 244         }
 245
 246         /// <summary>
 247         /// Represents a combined list and collection of HTML nodes.
 248         /// </summary>
 249         public class HtmlAttributeCollection: IEnumerable
 250         {
 251                 internal Hashtable _hashitems = new Hashtable();
 252                 private ArrayList _items = new ArrayList();
 253                 private HtmlNode _ownernode;
 254
 255                 internal HtmlAttributeCollection(HtmlNode ownernode)
 256                 {
 257                         _ownernode = ownernode;
 258                 }
 259
 260                 /// <summary>
 261                 /// Inserts the specified attribute as the last attribute in the collection.
 262                 /// </summary>
 263                 /// <param name="newAttribute">The attribute to insert. May not be null.</param>
 264                 /// <returns>The appended attribute.</returns>
 265                 public HtmlAttribute Append(HtmlAttribute newAttribute)
 266                 {
 267                         if (newAttribute == null)
 268                         {
 269                                 throw new ArgumentNullException("newAttribute");
 270                         }
 271
 272                         _hashitems[newAttribute.Name] = newAttribute;
 273                         newAttribute._ownernode = _ownernode;
 274                         _items.Add(newAttribute);
 275
 276                         _ownernode._innerchanged = true;
 277                         _ownernode._outerchanged = true;
 278                         return newAttribute;
 279                 }
 280
 281                 /// <summary>
 282                 /// Creates and inserts a new attribute as the last attribute in the collection.
 283                 /// </summary>
 284                 /// <param name="name">The name of the attribute to insert.</param>
 285                 /// <returns>The appended attribute.</returns>
 286                 public HtmlAttribute Append(string name)
 287                 {
 288                         HtmlAttribute att = _ownernode._ownerdocument.CreateAttribute(name);
 289                         return Append(att);
 290                 }
 291
 292                 /// <summary>
 293                 /// Creates and inserts a new attribute as the last attribute in the collection.
 294                 /// </summary>
 295                 /// <param name="name">The name of the attribute to insert.</param>
 296                 /// <param name="value">The value of the attribute to insert.</param>
 297                 /// <returns>The appended attribute.</returns>
 298                 public HtmlAttribute Append(string name, string value)
 299                 {
 300                         HtmlAttribute att = _ownernode._ownerdocument.CreateAttribute(name, value);
 301                         return Append(att);
 302                 }
 303
 304                 /// <summary>
 305                 /// Inserts the specified attribute as the first node in the collection.
 306                 /// </summary>
 307                 /// <param name="newAttribute">The attribute to insert. May not be null.</param>
 308                 /// <returns>The prepended attribute.</returns>
 309                 public HtmlAttribute Prepend(HtmlAttribute newAttribute)
 310                 {
 311                         if (newAttribute == null)
 312                         {
 313                                 throw new ArgumentNullException("newAttribute");
 314                         }
 315
 316                         _hashitems[newAttribute.Name] = newAttribute;
 317                         newAttribute._ownernode = _ownernode;
 318                         _items.Insert(0, newAttribute);
 319
 320                         _ownernode._innerchanged = true;
 321                         _ownernode._outerchanged = true;
 322                         return newAttribute;
 323                 }
 324
 325                 /// <summary>
 326                 /// Removes the attribute at the specified index.
 327                 /// </summary>
 328                 /// <param name="index">The index of the attribute to remove.</param>
 329                 public void RemoveAt(int index)
 330                 {
 331                         HtmlAttribute att = (HtmlAttribute)_items[index];
 332                         _hashitems.Remove(att.Name);
 333                         _items.RemoveAt(index);
 334
 335                         _ownernode._innerchanged = true;
 336                         _ownernode._outerchanged = true;
 337                 }
 338
 339                 /// <summary>
 340                 /// Removes a given attribute from the list.
 341                 /// </summary>
 342                 /// <param name="attribute">The attribute to remove. May not be null.</param>
 343                 public void Remove(HtmlAttribute attribute)
 344                 {
 345                         if (attribute == null)
 346                         {
 347                                 throw new ArgumentNullException("attribute");
 348                         }
 349                         int index = GetAttributeIndex(attribute);
 350                         if (index == -1)
 351                         {
 352                                 throw new IndexOutOfRangeException();
 353                         }
 354                         RemoveAt(index);
 355                 }
 356
 357                 /// <summary>
 358                 /// Removes an attribute from the list, using its name. If there are more than one attributes with this name, they will all be removed.
 359                 /// </summary>
 360                 /// <param name="name">The attribute's name. May not be null.</param>
 361                 public void Remove(string name)
 362                 {
 363                         if (name == null)
 364                         {
 365                                 throw new ArgumentNullException("name");
 366                         }
 367
 368                         string lname = name.ToLower();
 369                         for(int i=0;i<_items.Count;i++)
 370                         {
 371                                 HtmlAttribute att = (HtmlAttribute)_items[i];
 372                                 if (att.Name == lname)
 373                                 {
 374                                         RemoveAt(i);
 375                                 }
 376                         }
 377                 }
 378
 379                 /// <summary>
 380                 /// Remove all attributes in the list.
 381                 /// </summary>
 382                 public void RemoveAll()
 383                 {
 384                         _hashitems.Clear();
 385                         _items.Clear();
 386
 387                         _ownernode._innerchanged = true;
 388                         _ownernode._outerchanged = true;
 389                 }
 390
 391                 /// <summary>
 392                 /// Gets the number of elements actually contained in the list.
 393                 /// </summary>
 394                 public int Count
 395                 {
 396                         get
 397                         {
 398                                 return _items.Count;
 399                         }
 400                 }
 401
 402                 internal int GetAttributeIndex(HtmlAttribute attribute)
 403                 {
 404                         if (attribute == null)
 405                         {
 406                                 throw new ArgumentNullException("attribute");
 407                         }
 408                         for(int i=0;i<_items.Count;i++)
 409                         {
 410                                 if (((HtmlAttribute)_items[i])==attribute)
 411                                         return i;
 412                         }
 413                         return -1;
 414                 }
 415
 416                 internal int GetAttributeIndex(string name)
 417                 {
 418                         if (name == null)
 419                         {
 420                                 throw new ArgumentNullException("name");
 421                         }
 422                         string lname = name.ToLower();
 423                         for(int i=0;i<_items.Count;i++)
 424                         {
 425                                 if (((HtmlAttribute)_items[i]).Name==lname)
 426                                         return i;
 427                         }
 428                         return -1;
 429                 }
 430
 431                 /// <summary>
 432                 /// Gets a given attribute from the list using its name.
 433                 /// </summary>
 434                 public HtmlAttribute this[string name]
 435                 {
 436                         get
 437                         {
 438                                 if (name == null)
 439                                 {
 440                                         throw new ArgumentNullException("name");
 441                                 }
 442                                 return _hashitems[name.ToLower()] as HtmlAttribute;
 443                         }
 444                 }
 445
 446                 /// <summary>
 447                 /// Gets the attribute at the specified index.
 448                 /// </summary>
 449                 public HtmlAttribute this[int index]
 450                 {
 451                         get
 452                         {
 453                                 return _items[index] as HtmlAttribute;
 454                         }
 455                 }
 456
 457                 internal void Clear()
 458                 {
 459                         _hashitems.Clear();
 460                         _items.Clear();
 461                 }
 462
 463                 /// <summary>
 464                 /// Returns an enumerator that can iterate through the list.
 465                 /// </summary>
 466                 /// <returns>An IEnumerator for the entire list.</returns>
 467                 public HtmlAttributeEnumerator GetEnumerator()
 468                 {
 469                         return new HtmlAttributeEnumerator(_items);
 470                 }
 471
 472                 IEnumerator IEnumerable.GetEnumerator()
 473                 {
 474                         return GetEnumerator();
 475                 }
 476
 477                 /// <summary>
 478                 /// Represents an enumerator that can iterate through the list.
 479                 /// </summary>
 480                 public class HtmlAttributeEnumerator: IEnumerator
 481                 {
 482                         int _index;
 483                         ArrayList _items;
 484
 485                         internal HtmlAttributeEnumerator(ArrayList items)
 486                         {
 487                                 _items = items;
 488                                 _index = -1;
 489                         }
 490
 491                         /// <summary>
 492                         /// Sets the enumerator to its initial position, which is before the first element in the collection.
 493                         /// </summary>
 494                         public void Reset()
 495                         {
 496                                 _index = -1;
 497                         }
 498
 499                         /// <summary>
 500                         /// Advances the enumerator to the next element of the collection.
 501                         /// </summary>
 502                         /// <returns>true if the enumerator was successfully advanced to the next element, false if the enumerator has passed the end of the collection.</returns>
 503                         public bool MoveNext()
 504                         {
 505                                 _index++;
 506                                 return (_index<_items.Count);
 507                         }
 508
 509                         /// <summary>
 510                         /// Gets the current element in the collection.
 511                         /// </summary>
 512                         public HtmlAttribute Current
 513                         {
 514                                 get
 515                                 {
 516                                         return (HtmlAttribute)(_items[_index]);
 517                                 }
 518                         }
 519
 520                         /// <summary>
 521                         /// Gets the current element in the collection.
 522                         /// </summary>
 523                         object IEnumerator.Current
 524                         {
 525                                 get
 526                                 {
 527                                         return (Current);
 528                                 }
 529                         }
 530                 }
 531         }
 532
 533 }