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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="BaseProcessor.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.Collections;
  20.     using System.Text;
  21.     using System.Diagnostics;
  22.    
  23.     internal class BaseProcessor
  24.     {
  25.         XmlNameTable nameTable;
  26.         SchemaNames schemaNames;
  27.         ValidationEventHandler eventHandler;
  28.         XmlSchemaCompilationSettings compilationSettings;
  29.         int errorCount = 0;
  30.         string NsXml;
  31.        
  32.         public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) : this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings())
  33.         {
  34.         }
  35.         //Use the default for XmlSchemaCollection
  36.         public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings)
  37.         {
  38.             Debug.Assert(nameTable != null);
  39.             this.nameTable = nameTable;
  40.             this.schemaNames = schemaNames;
  41.             this.eventHandler = eventHandler;
  42.             this.compilationSettings = compilationSettings;
  43.             NsXml = nameTable.Add(XmlReservedNs.NsXml);
  44.         }
  45.        
  46.         protected XmlNameTable NameTable {
  47.             get { return nameTable; }
  48.         }
  49.        
  50.         protected SchemaNames SchemaNames {
  51.             get {
  52.                 if (schemaNames == null) {
  53.                     schemaNames = new SchemaNames(nameTable);
  54.                 }
  55.                 return schemaNames;
  56.             }
  57.         }
  58.        
  59.         protected ValidationEventHandler EventHandler {
  60.             get { return eventHandler; }
  61.         }
  62.        
  63.         protected XmlSchemaCompilationSettings CompilationSettings {
  64.             get { return compilationSettings; }
  65.         }
  66.        
  67.         protected bool HasErrors {
  68.             get { return errorCount != 0; }
  69.         }
  70.        
  71.         protected void AddToTable(XmlSchemaObjectTable table, XmlQualifiedName qname, XmlSchemaObject item)
  72.         {
  73.             if (qname.Name.Length == 0) {
  74.                 return;
  75.             }
  76.             XmlSchemaObject existingObject = (XmlSchemaObject)table[qname];
  77.            
  78.             if (existingObject != null) {
  79.                 if (existingObject == item) {
  80.                     return;
  81.                 }
  82.                 string code = Res.Sch_DupGlobalElement;
  83.                 if (item is XmlSchemaAttributeGroup) {
  84.                     string ns = nameTable.Add(qname.Namespace);
  85.                     if (Ref.Equal(ns, NsXml)) {
  86.                         //Check for xml namespace
  87.                         XmlSchema schemaForXmlNS = Preprocessor.GetBuildInSchema();
  88.                         XmlSchemaObject builtInAttributeGroup = schemaForXmlNS.AttributeGroups[qname];
  89.                         if ((object)existingObject == (object)builtInAttributeGroup) {
  90.                             table.Insert(qname, item);
  91.                             return;
  92.                         }
  93.                         else if ((object)item == (object)builtInAttributeGroup) {
  94.                             //trying to overwrite customer's component with built-in, ignore built-in
  95.                             return;
  96.                         }
  97.                     }
  98.                     else if (IsValidAttributeGroupRedefine(existingObject, item)) {
  99.                         //check for redefines
  100.                         table.Insert(qname, item);
  101.                         return;
  102.                     }
  103.                     code = Res.Sch_DupAttributeGroup;
  104.                 }
  105.                 else if (item is XmlSchemaAttribute) {
  106.                     string ns = nameTable.Add(qname.Namespace);
  107.                     if (Ref.Equal(ns, NsXml)) {
  108.                         XmlSchema schemaForXmlNS = Preprocessor.GetBuildInSchema();
  109.                         XmlSchemaObject builtInAttribute = schemaForXmlNS.Attributes[qname];
  110.                         if ((object)existingObject == (object)builtInAttribute) {
  111.                             //replace built-in one
  112.                             table.Insert(qname, item);
  113.                             return;
  114.                         }
  115.                         else if ((object)item == (object)builtInAttribute) {
  116.                             //trying to overwrite customer's component with built-in, ignore built-in
  117.                             return;
  118.                         }
  119.                     }
  120.                     code = Res.Sch_DupGlobalAttribute;
  121.                 }
  122.                 else if (item is XmlSchemaSimpleType) {
  123.                     if (IsValidTypeRedefine(existingObject, item)) {
  124.                         table.Insert(qname, item);
  125.                         return;
  126.                     }
  127.                     code = Res.Sch_DupSimpleType;
  128.                 }
  129.                 else if (item is XmlSchemaComplexType) {
  130.                     if (IsValidTypeRedefine(existingObject, item)) {
  131.                         table.Insert(qname, item);
  132.                         return;
  133.                     }
  134.                     code = Res.Sch_DupComplexType;
  135.                 }
  136.                 else if (item is XmlSchemaGroup) {
  137.                     if (IsValidGroupRedefine(existingObject, item)) {
  138.                         //check for redefines
  139.                         table.Insert(qname, item);
  140.                         return;
  141.                     }
  142.                     code = Res.Sch_DupGroup;
  143.                 }
  144.                 else if (item is XmlSchemaNotation) {
  145.                     code = Res.Sch_DupNotation;
  146.                 }
  147.                 else if (item is XmlSchemaIdentityConstraint) {
  148.                     code = Res.Sch_DupIdentityConstraint;
  149.                 }
  150.                 else {
  151.                     Debug.Assert(item is XmlSchemaElement);
  152.                 }
  153.                 SendValidationEvent(code, qname.ToString(), item);
  154.             }
  155.             else {
  156.                 table.Add(qname, item);
  157.             }
  158.         }
  159.        
  160.         private bool IsValidAttributeGroupRedefine(XmlSchemaObject existingObject, XmlSchemaObject item)
  161.         {
  162.             XmlSchemaAttributeGroup attGroup = item as XmlSchemaAttributeGroup;
  163.             if (existingObject == attGroup.Redefined) {
  164.                 //attribute group is the redefinition of existingObject
  165.                 XmlSchemaAttributeGroup existingAttGroup = existingObject as XmlSchemaAttributeGroup;
  166.                 if (existingAttGroup.AttributeUses.Count == 0) {
  167.                     //If the existing one is not already compiled, then replace.
  168.                     return true;
  169.                 }
  170.             }
  171.             return false;
  172.         }
  173.        
  174.         private bool IsValidGroupRedefine(XmlSchemaObject existingObject, XmlSchemaObject item)
  175.         {
  176.             XmlSchemaGroup group = item as XmlSchemaGroup;
  177.             if (existingObject == group.Redefined) {
  178.                 //group is the redefinition of existingObject
  179.                 XmlSchemaGroup existingGroup = existingObject as XmlSchemaGroup;
  180.                 if (existingGroup.CanonicalParticle == null) {
  181.                     //If the existing one is not already compiled, then replace.
  182.                     return true;
  183.                 }
  184.             }
  185.             return false;
  186.         }
  187.        
  188.         private bool IsValidTypeRedefine(XmlSchemaObject existingObject, XmlSchemaObject item)
  189.         {
  190.             XmlSchemaType schemaType = item as XmlSchemaType;
  191.             if (existingObject == schemaType.Redefined) {
  192.                 //schemaType is the redefinition of existingObject
  193.                 XmlSchemaType existingType = existingObject as XmlSchemaType;
  194.                 if (existingType.ElementDecl == null) {
  195.                     //If the existing one is not already compiled, then replace.
  196.                     return true;
  197.                 }
  198.             }
  199.             return false;
  200.         }
  201.        
  202.         protected void SendValidationEvent(string code, XmlSchemaObject source)
  203.         {
  204.             SendValidationEvent(new XmlSchemaException(code, source), XmlSeverityType.Error);
  205.         }
  206.        
  207.         protected void SendValidationEvent(string code, string msg, XmlSchemaObject source)
  208.         {
  209.             SendValidationEvent(new XmlSchemaException(code, msg, source), XmlSeverityType.Error);
  210.         }
  211.        
  212.         protected void SendValidationEvent(string code, string msg1, string msg2, XmlSchemaObject source)
  213.         {
  214.             SendValidationEvent(new XmlSchemaException(code, new string[] {msg1, msg2}, source), XmlSeverityType.Error);
  215.         }
  216.        
  217.         protected void SendValidationEvent(string code, string[] args, Exception innerException, XmlSchemaObject source)
  218.         {
  219.             SendValidationEvent(new XmlSchemaException(code, args, innerException, source.SourceUri, source.LineNumber, source.LinePosition, source), XmlSeverityType.Error);
  220.         }
  221.        
  222.         protected void SendValidationEvent(string code, string msg1, string msg2, string sourceUri, int lineNumber, int linePosition)
  223.         {
  224.             SendValidationEvent(new XmlSchemaException(code, new string[] {msg1, msg2}, sourceUri, lineNumber, linePosition), XmlSeverityType.Error);
  225.         }
  226.        
  227.         protected void SendValidationEvent(string code, XmlSchemaObject source, XmlSeverityType severity)
  228.         {
  229.             SendValidationEvent(new XmlSchemaException(code, source), severity);
  230.         }
  231.        
  232.         protected void SendValidationEvent(XmlSchemaException e)
  233.         {
  234.             SendValidationEvent(e, XmlSeverityType.Error);
  235.         }
  236.        
  237.         protected void SendValidationEvent(string code, string msg, XmlSchemaObject source, XmlSeverityType severity)
  238.         {
  239.             SendValidationEvent(new XmlSchemaException(code, msg, source), severity);
  240.         }
  241.        
  242.         protected void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity)
  243.         {
  244.             if (severity == XmlSeverityType.Error) {
  245.                 errorCount++;
  246.             }
  247.             if (eventHandler != null) {
  248.                 eventHandler(null, new ValidationEventArgs(e, severity));
  249.             }
  250.             else if (severity == XmlSeverityType.Error) {
  251.                 throw e;
  252.             }
  253.         }
  254.        
  255.         protected void SendValidationEventNoThrow(XmlSchemaException e, XmlSeverityType severity)
  256.         {
  257.             if (severity == XmlSeverityType.Error) {
  258.                 errorCount++;
  259.             }
  260.             if (eventHandler != null) {
  261.                 eventHandler(null, new ValidationEventArgs(e, severity));
  262.             }
  263.         }
  264.     }
  265.    
  266. }
  267. // namespace System.Xml

Developer Fusion