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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="SchemaInfo.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;
  20.     using System.Collections;
  21.     using System.Diagnostics;
  22.    
  23.     internal enum AttributeMatchState
  24.     {
  25.         AttributeFound,
  26.         AnyIdAttributeFound,
  27.         UndeclaredElementAndAttribute,
  28.         UndeclaredAttribute,
  29.         AnyAttributeLax,
  30.         AnyAttributeSkip,
  31.         ProhibitedAnyAttribute,
  32.         ProhibitedAttribute,
  33.         AttributeNameMismatch,
  34.         ValidateAttributeInvalidCall
  35.     }
  36.    
  37.     internal class SchemaInfo
  38.     {
  39.         SchemaType schemaType;
  40.         Hashtable targetNamespaces = new Hashtable();
  41.         Hashtable elementDecls = new Hashtable();
  42.         Hashtable undeclaredElementDecls = new Hashtable();
  43.         Hashtable elementDeclsByType = new Hashtable();
  44.         Hashtable attributeDecls = new Hashtable();
  45.        
  46.         Hashtable generalEntities;
  47.         Hashtable parameterEntities;
  48.         Hashtable notations;
  49.         XmlQualifiedName docTypeName = XmlQualifiedName.Empty;
  50.         int errorCount;
  51.         bool hasNonCDataAttributes = false;
  52.         bool hasDefaultAttributes = false;
  53.        
  54.         public SchemaInfo()
  55.         {
  56.             schemaType = SchemaType.None;
  57.         }
  58.        
  59.         public SchemaType SchemaType {
  60.             get { return schemaType; }
  61.             set { schemaType = value; }
  62.         }
  63.        
  64.         public Hashtable TargetNamespaces {
  65.             get { return targetNamespaces; }
  66.         }
  67.        
  68.         public Hashtable ElementDecls {
  69.             get { return elementDecls; }
  70.         }
  71.        
  72.         public Hashtable UndeclaredElementDecls {
  73.             get { return undeclaredElementDecls; }
  74.         }
  75.        
  76.         public Hashtable ElementDeclsByType {
  77.             get { return elementDeclsByType; }
  78.         }
  79.        
  80.         public Hashtable AttributeDecls {
  81.             get { return attributeDecls; }
  82.         }
  83.        
  84.         public Hashtable GeneralEntities {
  85.             get {
  86.                 if (this.generalEntities == null) {
  87.                     this.generalEntities = new Hashtable();
  88.                 }
  89.                 return this.generalEntities;
  90.             }
  91.         }
  92.        
  93.         public Hashtable ParameterEntities {
  94.             get {
  95.                 if (this.parameterEntities == null) {
  96.                     this.parameterEntities = new Hashtable();
  97.                 }
  98.                 return this.parameterEntities;
  99.             }
  100.         }
  101.        
  102.         public Hashtable Notations {
  103.             get {
  104.                 if (this.notations == null) {
  105.                     this.notations = new Hashtable();
  106.                 }
  107.                 return this.notations;
  108.             }
  109.         }
  110.        
  111.         public XmlQualifiedName DocTypeName {
  112.             get { return docTypeName; }
  113.             set { docTypeName = value; }
  114.         }
  115.        
  116.         public int ErrorCount {
  117.             get { return errorCount; }
  118.             set { errorCount = value; }
  119.         }
  120.        
  121.         public SchemaElementDecl GetElementDecl(XmlQualifiedName qname)
  122.         {
  123.             return (SchemaElementDecl)elementDecls[qname];
  124.         }
  125.        
  126.         public SchemaElementDecl GetTypeDecl(XmlQualifiedName qname)
  127.         {
  128.             return (SchemaElementDecl)elementDeclsByType[qname];
  129.         }
  130.        
  131.         public XmlSchemaElement GetElement(XmlQualifiedName qname)
  132.         {
  133.             SchemaElementDecl ed = GetElementDecl(qname);
  134.             if (ed != null) {
  135.                 return ed.SchemaElement;
  136.             }
  137.             return null;
  138.         }
  139.        
  140.         public XmlSchemaAttribute GetAttribute(XmlQualifiedName qname)
  141.         {
  142.             SchemaAttDef attdef = (SchemaAttDef)attributeDecls[qname];
  143.             if (attdef != null) {
  144.                 return attdef.SchemaAttribute;
  145.             }
  146.             return null;
  147.         }
  148.        
  149.         public XmlSchemaElement GetType(XmlQualifiedName qname)
  150.         {
  151.             SchemaElementDecl ed = GetElementDecl(qname);
  152.             if (ed != null) {
  153.                 return ed.SchemaElement;
  154.             }
  155.             return null;
  156.         }
  157.        
  158.         public bool HasSchema(string ns)
  159.         {
  160.             return targetNamespaces[ns] != null;
  161.         }
  162.        
  163.         public bool Contains(string ns)
  164.         {
  165.             return targetNamespaces[ns] != null;
  166.         }
  167.        
  168.         public SchemaAttDef GetAttributeXdr(SchemaElementDecl ed, XmlQualifiedName qname)
  169.         {
  170.             SchemaAttDef attdef = null;
  171.             if (ed != null) {
  172.                 attdef = ed.GetAttDef(qname);
  173.                 ;
  174.                 if (attdef == null) {
  175.                     if (!ed.ContentValidator.IsOpen || qname.Namespace.Length == 0) {
  176.                         throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
  177.                     }
  178.                     attdef = (SchemaAttDef)attributeDecls[qname];
  179.                     if (attdef == null && targetNamespaces.Contains(qname.Namespace)) {
  180.                         throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
  181.                     }
  182.                 }
  183.             }
  184.             return attdef;
  185.         }
  186.        
  187.        
  188.         public SchemaAttDef GetAttributeXsd(SchemaElementDecl ed, XmlQualifiedName qname, XmlSchemaObject partialValidationType, out AttributeMatchState attributeMatchState)
  189.         {
  190.             SchemaAttDef attdef = null;
  191.             attributeMatchState = AttributeMatchState.UndeclaredAttribute;
  192.             if (ed != null) {
  193.                 attdef = ed.GetAttDef(qname);
  194.                 if (attdef != null) {
  195.                     attributeMatchState = AttributeMatchState.AttributeFound;
  196.                     return attdef;
  197.                 }
  198.                 XmlSchemaAnyAttribute any = ed.AnyAttribute;
  199.                 if (any != null) {
  200.                     if (!any.NamespaceList.Allows(qname)) {
  201.                         attributeMatchState = AttributeMatchState.ProhibitedAnyAttribute;
  202.                     }
  203.                     else if (any.ProcessContentsCorrect != XmlSchemaContentProcessing.Skip) {
  204.                         attdef = (SchemaAttDef)attributeDecls[qname];
  205.                         if (attdef != null) {
  206.                             if (attdef.Datatype.TypeCode == XmlTypeCode.Id) {
  207.                                 //anyAttribute match whose type is ID
  208.                                 attributeMatchState = AttributeMatchState.AnyIdAttributeFound;
  209.                             }
  210.                             else {
  211.                                 attributeMatchState = AttributeMatchState.AttributeFound;
  212.                             }
  213.                         }
  214.                         else if (any.ProcessContentsCorrect == XmlSchemaContentProcessing.Lax) {
  215.                             attributeMatchState = AttributeMatchState.AnyAttributeLax;
  216.                         }
  217.                     }
  218.                     else {
  219.                         attributeMatchState = AttributeMatchState.AnyAttributeSkip;
  220.                     }
  221.                 }
  222.                 else if (ed.ProhibitedAttributes[qname] != null) {
  223.                     attributeMatchState = AttributeMatchState.ProhibitedAttribute;
  224.                 }
  225.             }
  226.             else if (partialValidationType != null) {
  227.                 XmlSchemaAttribute attr = partialValidationType as XmlSchemaAttribute;
  228.                 if (attr != null) {
  229.                     if (qname.Equals(attr.QualifiedName)) {
  230.                         attdef = attr.AttDef;
  231.                         attributeMatchState = AttributeMatchState.AttributeFound;
  232.                     }
  233.                     else {
  234.                         attributeMatchState = AttributeMatchState.AttributeNameMismatch;
  235.                     }
  236.                 }
  237.                 else {
  238.                     attributeMatchState = AttributeMatchState.ValidateAttributeInvalidCall;
  239.                 }
  240.             }
  241.             else {
  242.                 attdef = (SchemaAttDef)attributeDecls[qname];
  243.                 if (attdef != null) {
  244.                     attributeMatchState = AttributeMatchState.AttributeFound;
  245.                 }
  246.                 else {
  247.                     attributeMatchState = AttributeMatchState.UndeclaredElementAndAttribute;
  248.                 }
  249.             }
  250.             return attdef;
  251.         }
  252.        
  253.         public SchemaAttDef GetAttributeXsd(SchemaElementDecl ed, XmlQualifiedName qname, ref bool skip)
  254.         {
  255.             AttributeMatchState attributeMatchState;
  256.            
  257.             SchemaAttDef attDef = GetAttributeXsd(ed, qname, null, out attributeMatchState);
  258.             switch (attributeMatchState) {
  259.                 case AttributeMatchState.UndeclaredAttribute:
  260.                     throw new XmlSchemaException(Res.Sch_UndeclaredAttribute, qname.ToString());
  261.                     break;
  262.                 case AttributeMatchState.ProhibitedAnyAttribute:
  263.                 case AttributeMatchState.ProhibitedAttribute:
  264.                    
  265.                     throw new XmlSchemaException(Res.Sch_ProhibitedAttribute, qname.ToString());
  266.                     break;
  267.                 case AttributeMatchState.AttributeFound:
  268.                 case AttributeMatchState.AnyAttributeLax:
  269.                 case AttributeMatchState.UndeclaredElementAndAttribute:
  270.                    
  271.                     break;
  272.                 case AttributeMatchState.AnyAttributeSkip:
  273.                    
  274.                     skip = true;
  275.                     break;
  276.                 default:
  277.                    
  278.                     Debug.Assert(false);
  279.                     break;
  280.             }
  281.             return attDef;
  282.         }
  283.        
  284.         public void Add(SchemaInfo sinfo, ValidationEventHandler eventhandler)
  285.         {
  286.             if (schemaType == SchemaType.None) {
  287.                 schemaType = sinfo.SchemaType;
  288.             }
  289.             else if (schemaType != sinfo.SchemaType) {
  290.                 if (eventhandler != null) {
  291.                     eventhandler(this, new ValidationEventArgs(new XmlSchemaException(Res.Sch_MixSchemaTypes, string.Empty)));
  292.                 }
  293.                 return;
  294.             }
  295.            
  296.             foreach (string tns in sinfo.TargetNamespaces.Keys) {
  297.                 if (!targetNamespaces.ContainsKey(tns)) {
  298.                     targetNamespaces.Add(tns, true);
  299.                 }
  300.             }
  301.            
  302.             foreach (DictionaryEntry entry in sinfo.elementDecls) {
  303.                 if (!elementDecls.ContainsKey(entry.Key)) {
  304.                     elementDecls.Add(entry.Key, entry.Value);
  305.                 }
  306.             }
  307.             foreach (DictionaryEntry entry in sinfo.elementDeclsByType) {
  308.                 if (!elementDeclsByType.ContainsKey(entry.Key)) {
  309.                     elementDeclsByType.Add(entry.Key, entry.Value);
  310.                 }
  311.             }
  312.             foreach (SchemaAttDef attdef in sinfo.AttributeDecls.Values) {
  313.                 if (!attributeDecls.ContainsKey(attdef.Name)) {
  314.                     attributeDecls.Add(attdef.Name, attdef);
  315.                 }
  316.             }
  317.             foreach (SchemaNotation notation in sinfo.Notations.Values) {
  318.                 if (!Notations.ContainsKey(notation.Name.Name)) {
  319.                     Notations.Add(notation.Name.Name, notation);
  320.                 }
  321.             }
  322.            
  323.         }
  324.        
  325.         public void Finish()
  326.         {
  327.             Hashtable elementHT = elementDecls;
  328.             for (int i = 0; i < 2; i++) {
  329.                 foreach (SchemaElementDecl e in elementHT.Values) {
  330.                     e.EndAddAttDef();
  331.                     if (e.HasNonCDataAttribute) {
  332.                         hasNonCDataAttributes = true;
  333.                     }
  334.                     if (e.DefaultAttDefs != null) {
  335.                         hasDefaultAttributes = true;
  336.                     }
  337.                 }
  338.                 elementHT = undeclaredElementDecls;
  339.             }
  340.         }
  341.        
  342.         internal bool HasDefaultAttributes {
  343.             get { return hasDefaultAttributes; }
  344.             set { hasDefaultAttributes = value; }
  345.         }
  346.        
  347.         internal bool HasNonCDataAttributes {
  348.             get { return hasNonCDataAttributes; }
  349.             set { hasNonCDataAttributes = value; }
  350.         }
  351.     }
  352. }

Developer Fusion