mcs/class/System.XML/System.Xml.Schema/XmlSchemaReader.cs

   1
   2 //
   3 // Permission is hereby granted, free of charge, to any person obtaining
   4 // a copy of this software and associated documentation files (the
   5 // "Software"), to deal in the Software without restriction, including
   6 // without limitation the rights to use, copy, modify, merge, publish,
   7 // distribute, sublicense, and/or sell copies of the Software, and to
   8 // permit persons to whom the Software is furnished to do so, subject to
   9 // the following conditions:
  10 //
  11 // The above copyright notice and this permission notice shall be
  12 // included in all copies or substantial portions of the Software.
  13 //
  14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  15 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  16 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  17 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  18 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  19 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  20 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21 //
  22 using System;
  23 using System.Xml;
  24
  25 namespace System.Xml.Schema
  26 {
  27         /// <summary>
  28         /// A wrapper around XmlReader
  29         /// </summary>
  30         internal class XmlSchemaReader : XmlReader, IXmlLineInfo
  31         {
  32                 XmlReader reader;
  33                 ValidationEventHandler handler;
  34                 bool hasLineInfo;
  35                 public XmlSchemaReader(XmlReader reader,ValidationEventHandler handler)
  36                 {
  37                         this.reader = reader;
  38                         this.handler = handler;
  39                         if(reader is IXmlLineInfo)
  40                         {
  41                                 IXmlLineInfo info = (IXmlLineInfo)reader;
  42                                 hasLineInfo = info.HasLineInfo();
  43                         }
  44                 }
  45
  46                 /// <summary>
  47                 /// Returns the Namespace:LocalName for the object
  48                 /// </summary>
  49                 public string FullName
  50                 {
  51                         get { return NamespaceURI + ":" + LocalName; }
  52                 }
  53
  54                 public XmlReader Reader
  55                 {
  56                         get { return this.reader; }
  57                 }
  58
  59                 public void RaiseInvalidElementError()
  60                 {
  61                         string errstr = "Element "+FullName + " is invalid in this context.\n";
  62                         if(hasLineInfo)
  63                                 errstr += "The error occured on ("+((IXmlLineInfo)reader).LineNumber
  64                                         +","+((IXmlLineInfo)reader).LinePosition+")";
  65                         XmlSchemaObject.error(handler, errstr, null);
  66                         SkipToEnd();
  67                 }
  68                 /// <summary>
  69                 /// Reads till the next Element or EndElement. Also checks that the Namespace of the element is
  70                 /// Schema's Namespace.
  71                 /// </summary>
  72                 /// <returns></returns>
  73                 public bool ReadNextElement()
  74                 {
  75                         MoveToElement();
  76                         while(Read())
  77                         {
  78                                 if(NodeType == XmlNodeType.Element || NodeType == XmlNodeType.EndElement)
  79                                 {
  80                                         if(reader.NamespaceURI != XmlSchema.Namespace)
  81                                         {
  82                                                 RaiseInvalidElementError();
  83                                         }
  84                                         else
  85                                         {
  86                                                 return true;
  87                                         }
  88                                 }
  89                         }
  90                         return false;
  91                 }
  92
  93                 /// <summary>
  94                 /// Skips to the end of the current element
  95                 /// </summary>
  96                 public void SkipToEnd()
  97                 {
  98                         MoveToElement();
  99                         if(IsEmptyElement || NodeType != XmlNodeType.Element)
 100                                 return;
 101                         if(NodeType == XmlNodeType.Element)
 102                         {
 103                                 int depth = Depth;
 104                                 while(Read())
 105                                 {
 106                                         if(Depth == depth)
 107                                                 break;
 108                                 }
 109                         }
 110                         return;
 111                 }
 112
 113                 #region LineInfo
 114                 public bool HasLineInfo()
 115                 {
 116                         return hasLineInfo;
 117                 }
 118                 public int LineNumber
 119                 {
 120                         get { return hasLineInfo?((IXmlLineInfo)reader).LineNumber: 0; }
 121                 }
 122                 public int LinePosition
 123                 {
 124                         get { return hasLineInfo?((IXmlLineInfo)reader).LinePosition: 0; }
 125                 }
 126                 #endregion
 127
 128                 #region Delegates
 129                 public override int AttributeCount
 130                 {
 131                         get { return  reader.AttributeCount; }
 132                 }
 133                 public override string BaseURI
 134                 {
 135                         get { return  reader.BaseURI; }
 136                 }
 137                 public override bool CanResolveEntity
 138                 {
 139                         get { return  reader.CanResolveEntity; }
 140                 }
 141                 public override int Depth
 142                 {
 143                         get { return  reader.Depth; }
 144                 }
 145                 public override bool EOF
 146                 {
 147                         get { return  reader.EOF; }
 148                 }
 149                 public override bool HasAttributes
 150                 {
 151                         get { return  reader.HasAttributes; }
 152                 }
 153                 public override bool HasValue
 154                 {
 155                         get { return  reader.HasValue; }
 156                 }
 157                 public override bool IsDefault
 158                 {
 159                         get { return  reader.IsDefault; }
 160                 }
 161                 public override bool IsEmptyElement
 162                 {
 163                         get { return  reader.IsEmptyElement; }
 164                 }
 165                 public override string this[ int i ]
 166                 {
 167                         get { return  reader[i]; }
 168                 }
 169                 public override string this[ string name ]
 170                 {
 171                         get { return  reader[name]; }
 172                 }
 173                 public override string this[ string name, string namespaceURI ]
 174                 {
 175                         get { return  reader[name,namespaceURI]; }
 176                 }
 177                 public override string LocalName
 178                 {
 179                         get { return  reader.LocalName; }
 180                 }
 181                 public override string Name
 182                 {
 183                         get { return  reader.Name; }
 184                 }
 185                 public override string NamespaceURI
 186                 {
 187                         get { return  reader.NamespaceURI; }
 188                 }
 189                 public override XmlNameTable NameTable
 190                 {
 191                         get { return  reader.NameTable; }
 192                 }
 193                 public override XmlNodeType NodeType
 194                 {
 195                         get { return  reader.NodeType; }
 196                 }
 197                 public override string Prefix
 198                 {
 199                         get { return  reader.Prefix; }
 200                 }
 201                 public override char QuoteChar
 202                 {
 203                         get { return  reader.QuoteChar; }
 204                 }
 205                 public override ReadState ReadState
 206                 {
 207                         get { return  reader.ReadState; }
 208                 }
 209                 public override string Value
 210                 {
 211                         get { return  reader.Value; }
 212                 }
 213                 public override string XmlLang
 214                 {
 215                         get { return  reader.XmlLang; }
 216                 }
 217                 public override XmlSpace XmlSpace
 218                 {
 219                         get { return  reader.XmlSpace; }
 220                 }
 221
 222                 public override void Close()
 223                 {
 224                         reader.Close();
 225                 }
 226
 227                 public override bool Equals(object obj)
 228                 {
 229                         return reader.Equals(obj);
 230                 }
 231
 232                 public override string GetAttribute(int i)
 233                 {
 234                         return reader.GetAttribute(i);
 235                 }
 236
 237                 public override string GetAttribute(string name)
 238                 {
 239                         return reader.GetAttribute(name);
 240                 }
 241
 242                 public override string GetAttribute(string name, string namespaceURI)
 243                 {
 244                         return reader.GetAttribute(name, namespaceURI);
 245                 }
 246
 247                 public override int GetHashCode()
 248                 {
 249                         return reader.GetHashCode();
 250                 }
 251
 252                 public override bool IsStartElement()
 253                 {
 254                         return reader.IsStartElement();
 255                 }
 256
 257                 public override bool IsStartElement(string localname, string ns)
 258                 {
 259                         return reader.IsStartElement(localname, ns);
 260                 }
 261
 262                 public override bool IsStartElement(string name)
 263                 {
 264                         return reader.IsStartElement(name);
 265                 }
 266
 267                 public override string LookupNamespace(string prefix)
 268                 {
 269                         return reader.LookupNamespace(prefix);
 270                 }
 271
 272                 public override void MoveToAttribute(int i)
 273                 {
 274                         reader.MoveToAttribute(i);
 275                 }
 276
 277                 public override bool MoveToAttribute(string name)
 278                 {
 279                         return reader.MoveToAttribute(name);
 280                 }
 281
 282                 public override bool MoveToAttribute(string name, string ns)
 283                 {
 284                         return reader.MoveToAttribute(name,ns);
 285                 }
 286
 287                 public override System.Xml.XmlNodeType MoveToContent()
 288                 {
 289                         return reader.MoveToContent();
 290                 }
 291
 292                 public override bool MoveToElement()
 293                 {
 294                         return reader.MoveToElement();
 295                 }
 296
 297                 public override bool MoveToFirstAttribute()
 298                 {
 299                         return reader.MoveToFirstAttribute();
 300                 }
 301
 302                 public override bool MoveToNextAttribute()
 303                 {
 304                         return reader.MoveToNextAttribute();
 305                 }
 306
 307                 public override bool Read()
 308                 {
 309                         return reader.Read();
 310                 }
 311
 312                 public override bool ReadAttributeValue()
 313                 {
 314                         return reader.ReadAttributeValue();
 315                 }
 316
 317                 public override string ReadElementString()
 318                 {
 319                         return reader.ReadElementString();
 320                 }
 321
 322                 public override string ReadElementString(string localname, string ns)
 323                 {
 324                         return reader.ReadElementString(localname, ns);
 325                 }
 326
 327                 public override string ReadElementString(string name)
 328                 {
 329                         return reader.ReadElementString(name);
 330                 }
 331
 332                 public override void ReadEndElement()
 333                 {
 334                         reader.ReadEndElement();
 335                 }
 336
 337                 public override string ReadInnerXml()
 338                 {
 339                         return reader.ReadInnerXml();
 340                 }
 341
 342                 public override string ReadOuterXml()
 343                 {
 344                         return reader.ReadOuterXml();
 345                 }
 346
 347                 public override void ReadStartElement()
 348                 {
 349                         reader.ReadStartElement();
 350                 }
 351
 352                 public override void ReadStartElement(string localname, string ns)
 353                 {
 354                         reader.ReadStartElement(localname, ns);
 355                 }
 356
 357                 public override void ReadStartElement(string name)
 358                 {
 359                         reader.ReadStartElement(name);
 360                 }
 361
 362                 public override string ReadString()
 363                 {
 364                         return reader.ReadString();
 365                 }
 366
 367                 public override void ResolveEntity()
 368                 {
 369                         reader.ResolveEntity();
 370                 }
 371
 372                 public override void Skip()
 373                 {
 374                         reader.Skip();
 375                 }
 376
 377                 public override string ToString()
 378                 {
 379                         return reader.ToString();
 380                 }
 381
 382                 #endregion
 383         }
 384 }