The Labs \ Source Viewer \ SSCLI \ System.Xml.Schema \ BaseValidator

  1. //------------------------------------------------------------------------------
  2. // <copyright file="BaseValidator.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. // <owner current="true" primary="true">priyal</owner>
  15. //------------------------------------------------------------------------------
  16. namespace System.Xml.Schema
  17. {
  18.    
  19.     using System.IO;
  20.     using System.Diagnostics;
  21.     using System.Text;
  22.     using System.Collections;
  23.    
  24.     #pragma warning disable 618
  25.    
  26.     internal class BaseValidator
  27.     {
  28.         XmlSchemaCollection schemaCollection;
  29.         ValidationEventHandler eventHandler;
  30.         XmlNameTable nameTable;
  31.         SchemaNames schemaNames;
  32.         PositionInfo positionInfo;
  33.         XmlResolver xmlResolver;
  34.         Uri baseUri;
  35.        
  36.         protected SchemaInfo schemaInfo;
  37.         protected XmlValidatingReaderImpl reader;
  38.         protected XmlQualifiedName elementName;
  39.         protected ValidationState context;
  40.         protected StringBuilder textValue;
  41.         protected string textString;
  42.         protected bool hasSibling;
  43.         protected bool checkDatatype;
  44.        
  45.         public BaseValidator(BaseValidator other)
  46.         {
  47.             reader = other.reader;
  48.             schemaCollection = other.schemaCollection;
  49.             eventHandler = other.eventHandler;
  50.             nameTable = other.nameTable;
  51.             schemaNames = other.schemaNames;
  52.             positionInfo = other.positionInfo;
  53.             xmlResolver = other.xmlResolver;
  54.             baseUri = other.baseUri;
  55.             elementName = other.elementName;
  56.         }
  57.        
  58.         public BaseValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, ValidationEventHandler eventHandler)
  59.         {
  60.             Debug.Assert(schemaCollection == null || schemaCollection.NameTable == reader.NameTable);
  61.             this.reader = reader;
  62.             this.schemaCollection = schemaCollection;
  63.             this.eventHandler = eventHandler;
  64.             nameTable = reader.NameTable;
  65.             positionInfo = PositionInfo.GetPositionInfo(reader);
  66.             elementName = new XmlQualifiedName();
  67.         }
  68.        
  69.         public XmlValidatingReaderImpl Reader {
  70.             get { return reader; }
  71.         }
  72.        
  73.         public XmlSchemaCollection SchemaCollection {
  74.             get { return schemaCollection; }
  75.         }
  76.        
  77.         public XmlNameTable NameTable {
  78.             get { return nameTable; }
  79.         }
  80.        
  81.         public SchemaNames SchemaNames {
  82.             get {
  83.                 if (schemaNames != null) {
  84.                     return schemaNames;
  85.                 }
  86.                 if (schemaCollection != null) {
  87.                     schemaNames = schemaCollection.GetSchemaNames(nameTable);
  88.                 }
  89.                 else {
  90.                     schemaNames = new SchemaNames(nameTable);
  91.                 }
  92.                 return schemaNames;
  93.             }
  94.         }
  95.        
  96.         public PositionInfo PositionInfo {
  97.             get { return positionInfo; }
  98.         }
  99.        
  100.         public XmlResolver XmlResolver {
  101.             get { return xmlResolver; }
  102.             set { xmlResolver = value; }
  103.         }
  104.        
  105.         public Uri BaseUri {
  106.             get { return baseUri; }
  107.             set { baseUri = value; }
  108.         }
  109.        
  110.         public ValidationEventHandler EventHandler {
  111.             get { return eventHandler; }
  112.             set { eventHandler = value; }
  113.         }
  114.        
  115.         public SchemaInfo SchemaInfo {
  116.             get { return schemaInfo; }
  117.             set { schemaInfo = value; }
  118.         }
  119.        
  120.         public virtual bool PreserveWhitespace {
  121.             get { return false; }
  122.         }
  123.        
  124.         public virtual void Validate()
  125.         {
  126.         }
  127.        
  128.         public virtual void CompleteValidation()
  129.         {
  130.         }
  131.        
  132.         public virtual object FindId(string name)
  133.         {
  134.             return null;
  135.         }
  136.        
  137.         public void ValidateText()
  138.         {
  139.             if (context.NeedValidateChildren) {
  140.                 if (context.IsNill) {
  141.                     SendValidationEvent(Res.Sch_ContentInNill, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
  142.                     return;
  143.                 }
  144.                 ContentValidator contentValidator = context.ElementDecl.ContentValidator;
  145.                 XmlSchemaContentType contentType = contentValidator.ContentType;
  146.                 if (contentType == XmlSchemaContentType.ElementOnly) {
  147.                     ArrayList names = contentValidator.ExpectedElements(context, false);
  148.                     if (names == null) {
  149.                         SendValidationEvent(Res.Sch_InvalidTextInElement, XmlSchemaValidator.BuildElementName(context.LocalName, context.Namespace));
  150.                     }
  151.                     else {
  152.                         Debug.Assert(names.Count > 0);
  153.                         SendValidationEvent(Res.Sch_InvalidTextInElementExpecting, new string[] {XmlSchemaValidator.BuildElementName(context.LocalName, context.Namespace), XmlSchemaValidator.PrintExpectedElements(names, false)});
  154.                     }
  155.                 }
  156.                 else if (contentType == XmlSchemaContentType.Empty) {
  157.                     SendValidationEvent(Res.Sch_InvalidTextInEmpty, string.Empty);
  158.                 }
  159.                 if (checkDatatype) {
  160.                     SaveTextValue(reader.Value);
  161.                 }
  162.             }
  163.         }
  164.        
  165.         public void ValidateWhitespace()
  166.         {
  167.             if (context.NeedValidateChildren) {
  168.                 XmlSchemaContentType contentType = context.ElementDecl.ContentValidator.ContentType;
  169.                 if (context.IsNill) {
  170.                     SendValidationEvent(Res.Sch_ContentInNill, XmlSchemaValidator.QNameString(context.LocalName, context.Namespace));
  171.                 }
  172.                 if (contentType == XmlSchemaContentType.Empty) {
  173.                     SendValidationEvent(Res.Sch_InvalidWhitespaceInEmpty, string.Empty);
  174.                 }
  175.             }
  176.         }
  177.        
  178.         private void SaveTextValue(string value)
  179.         {
  180.             if (textString.Length == 0) {
  181.                 textString = value;
  182.             }
  183.             else {
  184.                 if (!hasSibling) {
  185.                     textValue.Append(textString);
  186.                     hasSibling = true;
  187.                 }
  188.                 textValue.Append(value);
  189.             }
  190.         }
  191.        
  192.         protected void SendValidationEvent(string code)
  193.         {
  194.             SendValidationEvent(code, string.Empty);
  195.         }
  196.        
  197.         protected void SendValidationEvent(string code, string[] args)
  198.         {
  199.             SendValidationEvent(new XmlSchemaException(code, args, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition));
  200.         }
  201.        
  202.         protected void SendValidationEvent(string code, string arg)
  203.         {
  204.             SendValidationEvent(new XmlSchemaException(code, arg, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition));
  205.         }
  206.        
  207.         protected void SendValidationEvent(string code, string arg1, string arg2)
  208.         {
  209.             SendValidationEvent(new XmlSchemaException(code, new string[] {arg1, arg2}, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition));
  210.         }
  211.        
  212.         protected void SendValidationEvent(XmlSchemaException e)
  213.         {
  214.             SendValidationEvent(e, XmlSeverityType.Error);
  215.         }
  216.        
  217.         protected void SendValidationEvent(string code, string msg, XmlSeverityType severity)
  218.         {
  219.             SendValidationEvent(new XmlSchemaException(code, msg, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition), severity);
  220.         }
  221.        
  222.         protected void SendValidationEvent(string code, string[] args, XmlSeverityType severity)
  223.         {
  224.             SendValidationEvent(new XmlSchemaException(code, args, reader.BaseURI, positionInfo.LineNumber, positionInfo.LinePosition), severity);
  225.         }
  226.        
  227.         protected void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity)
  228.         {
  229.             if (eventHandler != null) {
  230.                 eventHandler(reader, new ValidationEventArgs(e, severity));
  231.             }
  232.             else if (severity == XmlSeverityType.Error) {
  233.                 throw e;
  234.             }
  235.         }
  236.        
  237.         protected static void ProcessEntity(SchemaInfo sinfo, string name, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNumber, int linePosition)
  238.         {
  239.             SchemaEntity en = (SchemaEntity)sinfo.GeneralEntities[new XmlQualifiedName(name)];
  240.             XmlSchemaException e = null;
  241.             if (en == null) {
  242.                 // validation error, see xml spec [68]
  243.                 e = new XmlSchemaException(Res.Sch_UndeclaredEntity, name, baseUri, lineNumber, linePosition);
  244.             }
  245.             else if (en.NData.IsEmpty) {
  246.                 e = new XmlSchemaException(Res.Sch_UnparsedEntityRef, name, baseUri, lineNumber, linePosition);
  247.             }
  248.             if (e != null) {
  249.                 if (eventhandler != null) {
  250.                     eventhandler(sender, new ValidationEventArgs(e));
  251.                 }
  252.                 else {
  253.                     throw e;
  254.                 }
  255.             }
  256.         }
  257.        
  258.         public static BaseValidator CreateInstance(ValidationType valType, XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, ValidationEventHandler eventHandler, bool processIdentityConstraints)
  259.         {
  260.             switch (valType) {
  261.                 case ValidationType.XDR:
  262.                     return new XdrValidator(reader, schemaCollection, eventHandler);
  263.                 case ValidationType.Schema:
  264.                    
  265.                     return new XsdValidator(reader, schemaCollection, eventHandler);
  266.                 case ValidationType.DTD:
  267.                    
  268.                     return new DtdValidator(reader, eventHandler, processIdentityConstraints);
  269.                 case ValidationType.Auto:
  270.                    
  271.                     return new AutoValidator(reader, schemaCollection, eventHandler);
  272.                 case ValidationType.None:
  273.                    
  274.                     return new BaseValidator(reader, schemaCollection, eventHandler);
  275.                 default:
  276.                    
  277.                     break;
  278.             }
  279.             return null;
  280.         }
  281.        
  282.     }
  283.     #pragma warning restore 618
  284.    
  285. }

Developer Fusion