mcs/class/System.XML/System.Xml/XmlValidatingReader.cs

   1 //
   2 // System.Xml.XmlValidatingReader.cs
   3 //
   4 // Author:
   5 //   Tim Coleman (tim@timcoleman.com)
   6 //   Atsushi Enomoto (ginga@kit.hi-ho.ne.jp)
   7 //
   8 // Copyright (C) Tim Coleman, 2002
   9 // (C)2003 Atsushi Enomoto
  10 //
  11
  12 using System.IO;
  13 using System.Text;
  14 using System.Xml.Schema;
  15 using Mono.Xml;
  16
  17 namespace System.Xml {
  18         public class XmlValidatingReader : XmlReader, IXmlLineInfo {
  19
  20                 #region Fields
  21
  22                 EntityHandling entityHandling;
  23                 XmlReader sourceReader;
  24                 XmlReader validatingReader;
  25                 XmlResolver resolver;
  26                 ValidationType validationType;
  27
  28                 #endregion // Fields
  29
  30                 #region Constructors
  31
  32                 [MonoTODO]
  33                 public XmlValidatingReader (XmlReader reader)
  34                         : base ()
  35                 {
  36                         this.sourceReader = reader;
  37                         entityHandling = EntityHandling.ExpandEntities;
  38                         validationType = ValidationType.Auto;
  39                 }
  40
  41                 public XmlValidatingReader (Stream xmlFragment, XmlNodeType fragType, XmlParserContext context)
  42                         : this (new XmlTextReader (xmlFragment, fragType, context))
  43                 {
  44                 }
  45
  46                 public XmlValidatingReader (string xmlFragment, XmlNodeType fragType, XmlParserContext context)
  47                         : this (new XmlTextReader (xmlFragment, fragType, context))
  48                 {
  49                 }
  50
  51                 #endregion // Constructors
  52
  53                 #region Properties
  54
  55                 public override int AttributeCount {
  56                         [MonoTODO]
  57                         get { return validatingReader == null ? 0 : validatingReader.AttributeCount; }
  58                 }
  59
  60                 public override string BaseURI {
  61                         [MonoTODO]
  62                         get { return validatingReader == null ? String.Empty : validatingReader.BaseURI; }
  63                 }
  64
  65                 public override bool CanResolveEntity {
  66                         get { return validatingReader == null ? false : validatingReader.CanResolveEntity; }
  67                 }
  68
  69                 public override int Depth {
  70                         [MonoTODO]
  71                         get { return validatingReader == null ? 0 : validatingReader.Depth; }
  72                 }
  73
  74                 public Encoding Encoding {
  75                         [MonoTODO]
  76                         get { throw new NotImplementedException (); }
  77                 }
  78
  79                 [MonoTODO]
  80                 public EntityHandling EntityHandling {
  81                         get { return entityHandling; }
  82                         set { entityHandling = value; }
  83                 }
  84
  85                 public override bool EOF {
  86                         [MonoTODO]
  87                         get { return validatingReader == null ? false : validatingReader.EOF; }
  88                 }
  89
  90                 public override bool HasValue {
  91                         [MonoTODO]
  92                         get { return validatingReader == null ? false : validatingReader.HasValue; }
  93                 }
  94
  95                 public override bool IsDefault {
  96                         [MonoTODO]
  97                         get { return validatingReader == null ? false : validatingReader.IsDefault; }
  98                 }
  99
 100                 public override bool IsEmptyElement {
 101                         [MonoTODO]
 102                         get { return validatingReader == null ? false : validatingReader.IsEmptyElement; }
 103                 }
 104
 105                 public override string this [int i] {
 106                         [MonoTODO]
 107                         get { return validatingReader [i]; }
 108                 }
 109
 110                 public override string this [string name] {
 111                         [MonoTODO]
 112                         get { return validatingReader == null ? String.Empty : validatingReader [name]; }
 113                 }
 114
 115                 public override string this [string localName, string namespaceName] {
 116                         [MonoTODO]
 117                         get { return validatingReader == null ? String.Empty : validatingReader [localName, namespaceName]; }
 118                 }
 119
 120                 int IXmlLineInfo.LineNumber {
 121                         get {
 122                                 IXmlLineInfo info = validatingReader as IXmlLineInfo;
 123                                 return info != null ? info.LineNumber : 0;
 124                         }
 125                 }
 126
 127                 int IXmlLineInfo.LinePosition {
 128                         get {
 129                                 IXmlLineInfo info = validatingReader as IXmlLineInfo;
 130                                 return info != null ? info.LinePosition : 0;
 131                         }
 132                 }
 133
 134                 public override string LocalName {
 135                         [MonoTODO]
 136                         get { return validatingReader == null ? String.Empty : validatingReader.LocalName; }
 137                 }
 138
 139                 public override string Name {
 140                         [MonoTODO]
 141                         get { return validatingReader == null ? String.Empty : validatingReader.Name; }
 142                 }
 143
 144                 [MonoTODO]
 145                 public bool Namespaces {
 146                         get {
 147                                 XmlTextReader xtr = sourceReader as XmlTextReader;
 148                                 if (xtr != null)
 149                                         return xtr.Namespaces;
 150                                 else
 151                                         throw new NotImplementedException ();
 152                         }
 153                         set {
 154                                 XmlTextReader xtr = sourceReader as XmlTextReader;
 155                                 if (xtr != null)
 156                                         xtr.Namespaces = value;
 157                                 else
 158                                         throw new NotImplementedException ();
 159                         }
 160                 }
 161
 162                 public override string NamespaceURI {
 163                         [MonoTODO]
 164                         get { return validatingReader == null ? String.Empty : validatingReader.NamespaceURI; }
 165                 }
 166
 167                 public override XmlNameTable NameTable {
 168                         [MonoTODO]
 169                         get { return validatingReader == null ? null : validatingReader.NameTable; }
 170                 }
 171
 172                 public override XmlNodeType NodeType {
 173                         [MonoTODO]
 174                         get { return validatingReader == null ? XmlNodeType.None : validatingReader.NodeType; }
 175                 }
 176
 177                 public override string Prefix {
 178                         [MonoTODO]
 179                         get { return validatingReader == null ? String.Empty : validatingReader.Prefix; }
 180                 }
 181
 182                 public override char QuoteChar {
 183                         [MonoTODO]
 184                         get { return validatingReader == null ? '"' : validatingReader.QuoteChar; }
 185                 }
 186
 187                 [MonoTODO ("confirm which reader should be returned.")]
 188                 public XmlReader Reader {
 189                         get { return sourceReader; }
 190                 }
 191
 192                 public override ReadState ReadState {
 193                         [MonoTODO]
 194                         get {
 195                                 if (validatingReader == null)
 196                                         return ReadState.Initial;
 197                                 return validatingReader.ReadState;
 198                         }
 199                 }
 200
 201                 public XmlSchemaCollection Schemas {
 202                         [MonoTODO]
 203                         get { throw new NotImplementedException (); }
 204                 }
 205
 206                 public object SchemaType {
 207                         [MonoTODO]
 208                         get { throw new NotImplementedException (); }
 209                 }
 210
 211                 [MonoTODO]
 212                 public ValidationType ValidationType {
 213                         get { return validationType; }
 214                         set {
 215                                 if (ReadState != ReadState.Initial)
 216                                         throw new InvalidOperationException ("ValidationType cannot be set after the first call to Read method.");
 217                                 switch (validationType) {
 218                                 case ValidationType.Auto:
 219                                 case ValidationType.DTD:
 220                                 case ValidationType.None:
 221                                         validationType = value;
 222                                         break;
 223                                 case ValidationType.Schema:
 224                                 case ValidationType.XDR:
 225                                         throw new NotImplementedException ();
 226                                 }
 227                         }
 228                 }
 229
 230                 public override string Value {
 231                         [MonoTODO]
 232                         get { return validatingReader == null ? String.Empty : validatingReader.Value; }
 233                 }
 234
 235                 public override string XmlLang {
 236                         [MonoTODO]
 237                         get { return validatingReader == null ? String.Empty : validatingReader.XmlLang; }
 238                 }
 239
 240                 public XmlResolver XmlResolver {
 241                         [MonoTODO]
 242                         set { resolver = value; }
 243                 }
 244
 245                 public override XmlSpace XmlSpace {
 246                         [MonoTODO]
 247                         get { return validatingReader == null ? XmlSpace.None : validatingReader.XmlSpace; }
 248                 }
 249
 250                 #endregion // Properties
 251
 252                 #region Methods
 253
 254                 [MonoTODO]
 255                 public override void Close ()
 256                 {
 257                         validatingReader.Close ();
 258                 }
 259
 260                 [MonoTODO]
 261                 public override string GetAttribute (int i)
 262                 {
 263                         return validatingReader.GetAttribute (i);
 264                 }
 265
 266                 [MonoTODO]
 267                 public override string GetAttribute (string name)
 268                 {
 269                         return validatingReader.GetAttribute (name);
 270                 }
 271
 272                 [MonoTODO]
 273                 public override string GetAttribute (string localName, string namespaceName)
 274                 {
 275                         return validatingReader.GetAttribute (localName, namespaceName);
 276                 }
 277
 278                 bool IXmlLineInfo.HasLineInfo ()
 279                 {
 280                         IXmlLineInfo info = validatingReader as IXmlLineInfo;
 281                         return info != null ? info.HasLineInfo () : false;
 282                 }
 283
 284                 [MonoTODO]
 285                 public override string LookupNamespace (string prefix)
 286                 {
 287                         return validatingReader.LookupNamespace (prefix);
 288                 }
 289
 290                 [MonoTODO]
 291                 public override void MoveToAttribute (int i)
 292                 {
 293                         validatingReader.MoveToAttribute (i);
 294                 }
 295
 296                 [MonoTODO]
 297                 public override bool MoveToAttribute (string name)
 298                 {
 299                         return validatingReader.MoveToAttribute (name);
 300                 }
 301
 302                 [MonoTODO]
 303                 public override bool MoveToAttribute (string localName, string namespaceName)
 304                 {
 305                         return validatingReader.MoveToAttribute (localName, namespaceName);
 306                 }
 307
 308                 [MonoTODO]
 309                 public override bool MoveToElement ()
 310                 {
 311                         return validatingReader.MoveToElement ();
 312                 }
 313
 314                 [MonoTODO]
 315                 public override bool MoveToFirstAttribute ()
 316                 {
 317                         return validatingReader.MoveToFirstAttribute ();
 318                 }
 319
 320                 [MonoTODO]
 321                 public override bool MoveToNextAttribute ()
 322                 {
 323                         return validatingReader.MoveToNextAttribute ();
 324                 }
 325
 326                 [MonoTODO]
 327                 public override bool Read ()
 328                 {
 329                         if (ReadState == ReadState.Initial) {
 330                                 switch (ValidationType) {
 331                                 case ValidationType.Auto:
 332                                 case ValidationType.None:
 333                                         validatingReader = // new XmlSchemaValidatingReader (
 334                                                 new DTDValidatingReader (sourceReader, this);
 335                                         break;
 336                                 case ValidationType.DTD:
 337                                         validatingReader = new DTDValidatingReader (sourceReader, this);
 338                                         break;
 339                                 case ValidationType.Schema:
 340 //                                      validatingReader = new XmlSchemaValidatingReader (sourceReader, this);
 341 //                                      break;
 342                                 case ValidationType.XDR:
 343                                         throw new NotImplementedException ();
 344                                 }
 345                         }
 346                         return validatingReader.Read ();
 347                 }
 348
 349                 [MonoTODO]
 350                 public override bool ReadAttributeValue ()
 351                 {
 352                         return validatingReader.ReadAttributeValue ();
 353                 }
 354
 355 #if USE_VERSION_1_0
 356                 [MonoTODO]
 357                 public override string ReadInnerXml ()
 358                 {
 359                         return validatingReader.ReadInnerXml ();
 360                 }
 361
 362                 [MonoTODO]
 363                 public override string ReadOuterXml ()
 364                 {
 365                         return validatingReader.ReadOuterXml ();
 366                 }
 367 #endif
 368
 369                 [MonoTODO]
 370                 public override string ReadString ()
 371                 {
 372                         return validatingReader.ReadString ();
 373                 }
 374
 375                 [MonoTODO]
 376                 public object ReadTypedValue ()
 377                 {
 378                         throw new NotImplementedException ();
 379                 }
 380
 381                 public override void ResolveEntity ()
 382                 {
 383                         validatingReader.ResolveEntity ();
 384                 }
 385
 386                 // It should be "protected" as usual "event model"
 387                 // methods are, but validation event is not exposed,
 388                 // so it is no other way to make it "internal".
 389                 internal void OnValidationEvent (object o, ValidationEventArgs e)
 390                 {
 391                         if (ValidationEventHandler != null)
 392                                 ValidationEventHandler (o, e);
 393                         else if (ValidationType != ValidationType.None)
 394                                 throw e.Exception;
 395                 }
 396                 #endregion // Methods
 397
 398                 #region Events and Delegates
 399
 400                 public event ValidationEventHandler ValidationEventHandler;
 401
 402                 #endregion // Events and Delegates
 403         }
 404 }