docs/HtmlAgilityPack/HtmlAttribute.cs

   1 // HtmlAgilityPack V1.0 - Simon Mourier <simon underscore mourier at hotmail dot com>
   2
   3 #region
   4
   5 using System;
   6 using System.Diagnostics;
   7
   8 #endregion
   9
  10 namespace HtmlAgilityPack
  11 {
  12     /// <summary>
  13     /// Represents an HTML attribute.
  14     /// </summary>
  15     [DebuggerDisplay("Name: {OriginalName}, Value: {Value}")]
  16     public class HtmlAttribute : IComparable
  17     {
  18         #region Fields
  19
  20         private int _line;
  21         internal int _lineposition;
  22         internal string _name;
  23         internal int _namelength;
  24         internal int _namestartindex;
  25         internal HtmlDocument _ownerdocument; // attribute can exists without a node
  26         internal HtmlNode _ownernode;
  27         private AttributeValueQuote _quoteType = AttributeValueQuote.DoubleQuote;
  28         internal int _streamposition;
  29         internal string _value;
  30         internal int _valuelength;
  31         internal int _valuestartindex;
  32
  33         #endregion
  34
  35         #region Constructors
  36
  37         internal HtmlAttribute(HtmlDocument ownerdocument)
  38         {
  39             _ownerdocument = ownerdocument;
  40         }
  41
  42         #endregion
  43
  44         #region Properties
  45
  46         /// <summary>
  47         /// Gets the line number of this attribute in the document.
  48         /// </summary>
  49         public int Line
  50         {
  51             get { return _line; }
  52             internal set { _line = value; }
  53         }
  54
  55         /// <summary>
  56         /// Gets the column number of this attribute in the document.
  57         /// </summary>
  58         public int LinePosition
  59         {
  60             get { return _lineposition; }
  61         }
  62
  63         /// <summary>
  64         /// Gets the qualified name of the attribute.
  65         /// </summary>
  66         public string Name
  67         {
  68             get
  69             {
  70                 if (_name == null)
  71                 {
  72                     _name = _ownerdocument._text.Substring(_namestartindex, _namelength);
  73                 }
  74                 return _name.ToLower();
  75             }
  76             set
  77             {
  78                 if (value == null)
  79                 {
  80                     throw new ArgumentNullException("value");
  81                 }
  82                 _name = value;
  83                 if (_ownernode != null)
  84                 {
  85                     _ownernode._innerchanged = true;
  86                     _ownernode._outerchanged = true;
  87                 }
  88             }
  89         }
  90
  91         /// <summary>
  92         /// Name of attribute with original case
  93         /// </summary>
  94         public string OriginalName
  95         {
  96             get { return _name; }
  97         }
  98
  99         /// <summary>
 100         /// Gets the HTML document to which this attribute belongs.
 101         /// </summary>
 102         public HtmlDocument OwnerDocument
 103         {
 104             get { return _ownerdocument; }
 105         }
 106
 107         /// <summary>
 108         /// Gets the HTML node to which this attribute belongs.
 109         /// </summary>
 110         public HtmlNode OwnerNode
 111         {
 112             get { return _ownernode; }
 113         }
 114
 115         /// <summary>
 116         /// Specifies what type of quote the data should be wrapped in
 117         /// </summary>
 118         public AttributeValueQuote QuoteType
 119         {
 120             get { return _quoteType; }
 121             set { _quoteType = value; }
 122         }
 123
 124         /// <summary>
 125         /// Gets the stream position of this attribute in the document, relative to the start of the document.
 126         /// </summary>
 127         public int StreamPosition
 128         {
 129             get { return _streamposition; }
 130         }
 131
 132         /// <summary>
 133         /// Gets or sets the value of the attribute.
 134         /// </summary>
 135         public string Value
 136         {
 137             get
 138             {
 139                 if (_value == null)
 140                 {
 141                     _value = _ownerdocument._text.Substring(_valuestartindex, _valuelength);
 142                 }
 143                 return _value;
 144             }
 145             set
 146             {
 147                 _value = value;
 148                 if (_ownernode != null)
 149                 {
 150                     _ownernode._innerchanged = true;
 151                     _ownernode._outerchanged = true;
 152                 }
 153             }
 154         }
 155
 156         internal string XmlName
 157         {
 158             get { return HtmlDocument.GetXmlName(Name); }
 159         }
 160
 161         internal string XmlValue
 162         {
 163             get { return Value; }
 164         }
 165
 166         /// <summary>
 167         /// Gets a valid XPath string that points to this Attribute
 168         /// </summary>
 169         public string XPath
 170         {
 171             get
 172             {
 173                 string basePath = (OwnerNode == null) ? "/" : OwnerNode.XPath + "/";
 174                 return basePath + GetRelativeXpath();
 175             }
 176         }
 177
 178         #endregion
 179
 180         #region IComparable Members
 181
 182         /// <summary>
 183         /// Compares the current instance with another attribute. Comparison is based on attributes' name.
 184         /// </summary>
 185         /// <param name="obj">An attribute to compare with this instance.</param>
 186         /// <returns>A 32-bit signed integer that indicates the relative order of the names comparison.</returns>
 187         public int CompareTo(object obj)
 188         {
 189             HtmlAttribute att = obj as HtmlAttribute;
 190             if (att == null)
 191             {
 192                 throw new ArgumentException("obj");
 193             }
 194             return Name.CompareTo(att.Name);
 195         }
 196
 197         #endregion
 198
 199         #region Public Methods
 200
 201         /// <summary>
 202         /// Creates a duplicate of this attribute.
 203         /// </summary>
 204         /// <returns>The cloned attribute.</returns>
 205         public HtmlAttribute Clone()
 206         {
 207             HtmlAttribute att = new HtmlAttribute(_ownerdocument);
 208             att.Name = Name;
 209             att.Value = Value;
 210             return att;
 211         }
 212
 213         /// <summary>
 214         /// Removes this attribute from it's parents collection
 215         /// </summary>
 216         public void Remove()
 217         {
 218             _ownernode.Attributes.Remove(this);
 219         }
 220
 221         #endregion
 222
 223         #region Private Methods
 224
 225         private string GetRelativeXpath()
 226         {
 227             if (OwnerNode == null)
 228                 return Name;
 229
 230             int i = 1;
 231             foreach (HtmlAttribute node in OwnerNode.Attributes)
 232             {
 233                 if (node.Name != Name) continue;
 234
 235                 if (node == this)
 236                     break;
 237
 238                 i++;
 239             }
 240             return "@" + Name + "[" + i + "]";
 241         }
 242
 243         #endregion
 244     }
 245
 246     /// <summary>
 247     /// An Enum representing different types of Quotes used for surrounding attribute values
 248     /// </summary>
 249     public enum AttributeValueQuote
 250     {
 251         /// <summary>
 252         /// A single quote mark '
 253         /// </summary>
 254         SingleQuote,
 255         /// <summary>
 256         /// A double quote mark "
 257         /// </summary>
 258         DoubleQuote
 259     }
 260 }