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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlSchema.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.Collections;
  21.     using System.ComponentModel;
  22.     using System.Xml.Serialization;
  23.     using System.Threading;
  24.     using System.Diagnostics;
  25.    
  26.     /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema"]/*' />
  27.     /// <devdoc>
  28.     /// <para>[To be supplied.]</para>
  29.     /// </devdoc>
  30.     [XmlRoot("schema", Namespace = XmlSchema.Namespace)]
  31.     public class XmlSchema : XmlSchemaObject
  32.     {
  33.        
  34.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Namespace"]/*' />
  35.         /// <devdoc>
  36.         /// <para>[To be supplied.]</para>
  37.         /// </devdoc>
  38.         public const string Namespace = XmlReservedNs.NsXs;
  39.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.InstanceNamespace"]/*' />
  40.         /// <devdoc>
  41.         /// <para>[To be supplied.]</para>
  42.         /// </devdoc>
  43.         public const string InstanceNamespace = XmlReservedNs.NsXsi;
  44.        
  45.         XmlSchemaForm attributeFormDefault = XmlSchemaForm.None;
  46.         XmlSchemaForm elementFormDefault = XmlSchemaForm.None;
  47.         XmlSchemaDerivationMethod blockDefault = XmlSchemaDerivationMethod.None;
  48.         XmlSchemaDerivationMethod finalDefault = XmlSchemaDerivationMethod.None;
  49.         string targetNs;
  50.         string version;
  51.         XmlSchemaObjectCollection includes = new XmlSchemaObjectCollection();
  52.         XmlSchemaObjectCollection items = new XmlSchemaObjectCollection();
  53.         string id;
  54.         XmlAttribute[] moreAttributes;
  55.        
  56.         // compiled info
  57.         bool isCompiled = false;
  58.         bool isCompiledBySet = false;
  59.         bool isPreprocessed = false;
  60.         bool isRedefined = false;
  61.         int errorCount = 0;
  62.         XmlSchemaObjectTable attributes;
  63.         XmlSchemaObjectTable attributeGroups = new XmlSchemaObjectTable();
  64.         XmlSchemaObjectTable elements = new XmlSchemaObjectTable();
  65.         XmlSchemaObjectTable types = new XmlSchemaObjectTable();
  66.         XmlSchemaObjectTable groups = new XmlSchemaObjectTable();
  67.         XmlSchemaObjectTable notations = new XmlSchemaObjectTable();
  68.         XmlSchemaObjectTable identityConstraints = new XmlSchemaObjectTable();
  69.        
  70.         static int globalIdCounter = -1;
  71.         ArrayList importedSchemas;
  72.         ArrayList importedNamespaces;
  73.        
  74.         int schemaId = -1;
  75.         //Not added to a set
  76.         Uri baseUri;
  77.         bool isChameleon;
  78.         Hashtable ids = new Hashtable();
  79.         XmlDocument document;
  80.         XmlNameTable nameTable;
  81.        
  82.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.XmlSchema"]/*' />
  83.         /// <devdoc>
  84.         /// <para>[To be supplied.]</para>
  85.         /// </devdoc>
  86.         public XmlSchema()
  87.         {
  88.         }
  89.        
  90.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Read"]/*' />
  91.         /// <devdoc>
  92.         /// <para>[To be supplied.]</para>
  93.         /// </devdoc>
  94.         public static XmlSchema Read(TextReader reader, ValidationEventHandler validationEventHandler)
  95.         {
  96.             return Read(new XmlTextReader(reader), validationEventHandler);
  97.         }
  98.        
  99.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Read1"]/*' />
  100.         /// <devdoc>
  101.         /// <para>[To be supplied.]</para>
  102.         /// </devdoc>
  103.         public static XmlSchema Read(Stream stream, ValidationEventHandler validationEventHandler)
  104.         {
  105.             return Read(new XmlTextReader(stream), validationEventHandler);
  106.         }
  107.        
  108.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Read2"]/*' />
  109.         /// <devdoc>
  110.         /// <para>[To be supplied.]</para>
  111.         /// </devdoc>
  112.         public static XmlSchema Read(XmlReader reader, ValidationEventHandler validationEventHandler)
  113.         {
  114.             XmlNameTable nameTable = reader.NameTable;
  115.             Parser parser = new Parser(SchemaType.XSD, nameTable, new SchemaNames(nameTable), validationEventHandler);
  116.             try {
  117.                 parser.Parse(reader, null);
  118.             }
  119.             catch (XmlSchemaException e) {
  120.                 if (validationEventHandler != null) {
  121.                     validationEventHandler(null, new ValidationEventArgs(e));
  122.                 }
  123.                 else {
  124.                     throw e;
  125.                 }
  126.                 return null;
  127.             }
  128.             return parser.XmlSchema;
  129.         }
  130.        
  131.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Write"]/*' />
  132.         /// <devdoc>
  133.         /// <para>[To be supplied.]</para>
  134.         /// </devdoc>
  135.         public void Write(Stream stream)
  136.         {
  137.             Write(stream, null);
  138.         }
  139.        
  140.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Write1"]/*' />
  141.         /// <devdoc>
  142.         /// <para>[To be supplied.]</para>
  143.         /// </devdoc>
  144.         public void Write(Stream stream, XmlNamespaceManager namespaceManager)
  145.         {
  146.             XmlTextWriter xmlWriter = new XmlTextWriter(stream, null);
  147.             xmlWriter.Formatting = Formatting.Indented;
  148.             Write(xmlWriter, namespaceManager);
  149.         }
  150.        
  151.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Write2"]/*' />
  152.         /// <devdoc>
  153.         /// <para>[To be supplied.]</para>
  154.         /// </devdoc>
  155.         public void Write(TextWriter writer)
  156.         {
  157.             Write(writer, null);
  158.         }
  159.        
  160.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Write3"]/*' />
  161.         /// <devdoc>
  162.         /// <para>[To be supplied.]</para>
  163.         /// </devdoc>
  164.         public void Write(TextWriter writer, XmlNamespaceManager namespaceManager)
  165.         {
  166.             XmlTextWriter xmlWriter = new XmlTextWriter(writer);
  167.             xmlWriter.Formatting = Formatting.Indented;
  168.             Write(xmlWriter, namespaceManager);
  169.         }
  170.        
  171.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Write4"]/*' />
  172.         /// <devdoc>
  173.         /// <para>[To be supplied.]</para>
  174.         /// </devdoc>
  175.         public void Write(XmlWriter writer)
  176.         {
  177.             Write(writer, null);
  178.         }
  179.        
  180.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Write5"]/*' />
  181.         /// <devdoc>
  182.         /// <para>[To be supplied.]</para>
  183.         /// </devdoc>
  184.         public void Write(XmlWriter writer, XmlNamespaceManager namespaceManager)
  185.         {
  186.             XmlSerializer serializer = new XmlSerializer(typeof(XmlSchema));
  187.             XmlSerializerNamespaces ns;
  188.            
  189.             if (namespaceManager != null) {
  190.                 ns = new XmlSerializerNamespaces();
  191.                 bool ignoreXS = false;
  192.                 if (this.Namespaces != null) {
  193.                     //User may have set both nsManager and Namespaces property on the XmlSchema object
  194.                     ignoreXS = this.Namespaces.Namespaces["xs"] != null || this.Namespaces.Namespaces.ContainsValue(XmlReservedNs.NsXs);
  195.                    
  196.                 }
  197.                 if (!ignoreXS && namespaceManager.LookupPrefix(XmlReservedNs.NsXs) == null && namespaceManager.LookupNamespace("xs") == null) {
  198.                     ns.Add("xs", XmlReservedNs.NsXs);
  199.                 }
  200.                 foreach (string prefix in namespaceManager) {
  201.                     if (prefix != "xml" && prefix != "xmlns") {
  202.                         ns.Add(prefix, namespaceManager.LookupNamespace(prefix));
  203.                     }
  204.                 }
  205.                
  206.             }
  207.             else if (this.Namespaces != null && this.Namespaces.Count > 0) {
  208.                 Hashtable serializerNS = this.Namespaces.Namespaces;
  209.                 if (serializerNS["xs"] == null && !serializerNS.ContainsValue(XmlReservedNs.NsXs)) {
  210.                     //Prefix xs not defined AND schema namespace not already mapped to a prefix
  211.                     serializerNS.Add("xs", XmlReservedNs.NsXs);
  212.                 }
  213.                 ns = this.Namespaces;
  214.             }
  215.             else {
  216.                 ns = new XmlSerializerNamespaces();
  217.                 ns.Add("xs", XmlSchema.Namespace);
  218.                 if (targetNs != null && targetNs.Length != 0) {
  219.                     ns.Add("tns", targetNs);
  220.                 }
  221.             }
  222.             serializer.Serialize(writer, this, ns);
  223.         }
  224.        
  225.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Compile"]/*' />
  226.         /// <devdoc>
  227.         /// <para>[To be supplied.]</para>
  228.         /// </devdoc>
  229.         [Obsolete("Use System.Xml.Schema.XmlSchemaSet for schema compilation and validation. http://go.microsoft.com/fwlink/?linkid=14202")]
  230.         public void Compile(ValidationEventHandler validationEventHandler)
  231.         {
  232.             SchemaInfo sInfo = new SchemaInfo();
  233.             sInfo.SchemaType = SchemaType.XSD;
  234.             CompileSchema(null, new XmlUrlResolver(), sInfo, null, validationEventHandler, NameTable, false);
  235.         }
  236.        
  237.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Compileq"]/*' />
  238.         /// <devdoc>
  239.         /// <para>[To be supplied.]</para>
  240.         /// </devdoc>
  241.         [Obsolete("Use System.Xml.Schema.XmlSchemaSet for schema compilation and validation. http://go.microsoft.com/fwlink/?linkid=14202")]
  242.         public void Compile(ValidationEventHandler validationEventHandler, XmlResolver resolver)
  243.         {
  244.             SchemaInfo sInfo = new SchemaInfo();
  245.             sInfo.SchemaType = SchemaType.XSD;
  246.             CompileSchema(null, resolver, sInfo, null, validationEventHandler, NameTable, false);
  247.         }
  248.        
  249.         #pragma warning disable 618
  250.         internal bool CompileSchema(XmlSchemaCollection xsc, XmlResolver resolver, SchemaInfo schemaInfo, string ns, ValidationEventHandler validationEventHandler, XmlNameTable nameTable, bool CompileContentModel)
  251.         {
  252.            
  253.             //Need to lock here to prevent multi-threading problems when same schema is added to set and compiled
  254.             lock (this) {
  255.                 //Preprocessing
  256.                 SchemaCollectionPreprocessor prep = new SchemaCollectionPreprocessor(nameTable, null, validationEventHandler);
  257.                 prep.XmlResolver = resolver;
  258.                 if (!prep.Execute(this, ns, true, xsc)) {
  259.                     return false;
  260.                 }
  261.                
  262.                 //Compilation
  263.                 SchemaCollectionCompiler compiler = new SchemaCollectionCompiler(nameTable, validationEventHandler);
  264.                 isCompiled = compiler.Execute(this, schemaInfo, CompileContentModel);
  265.                 this.SetIsCompiled(isCompiled);
  266.                 //TODO includes isCompiled flag
  267.                 return isCompiled;
  268.             }
  269.         }
  270.         #pragma warning restore 618
  271.        
  272.         internal void CompileSchemaInSet(XmlNameTable nameTable, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings)
  273.         {
  274.             Debug.Assert(this.isPreprocessed);
  275.             Compiler setCompiler = new Compiler(nameTable, eventHandler, null, compilationSettings);
  276.             setCompiler.Prepare(this, true);
  277.             this.isCompiledBySet = setCompiler.Compile();
  278.         }
  279.        
  280.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.AttributeFormDefault"]/*' />
  281.         /// <devdoc>
  282.         /// <para>[To be supplied.]</para>
  283.         /// </devdoc>
  284.         [XmlAttribute("attributeFormDefault"), DefaultValue(XmlSchemaForm.None)]
  285.         public XmlSchemaForm AttributeFormDefault {
  286.             get { return attributeFormDefault; }
  287.             set { attributeFormDefault = value; }
  288.         }
  289.        
  290.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.BlockDefault"]/*' />
  291.         /// <devdoc>
  292.         /// <para>[To be supplied.]</para>
  293.         /// </devdoc>
  294.         [XmlAttribute("blockDefault"), DefaultValue(XmlSchemaDerivationMethod.None)]
  295.         public XmlSchemaDerivationMethod BlockDefault {
  296.             get { return blockDefault; }
  297.             set { blockDefault = value; }
  298.         }
  299.        
  300.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.FinalDefault"]/*' />
  301.         /// <devdoc>
  302.         /// <para>[To be supplied.]</para>
  303.         /// </devdoc>
  304.         [XmlAttribute("finalDefault"), DefaultValue(XmlSchemaDerivationMethod.None)]
  305.         public XmlSchemaDerivationMethod FinalDefault {
  306.             get { return finalDefault; }
  307.             set { finalDefault = value; }
  308.         }
  309.        
  310.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.ElementFormDefault"]/*' />
  311.         /// <devdoc>
  312.         /// <para>[To be supplied.]</para>
  313.         /// </devdoc>
  314.         [XmlAttribute("elementFormDefault"), DefaultValue(XmlSchemaForm.None)]
  315.         public XmlSchemaForm ElementFormDefault {
  316.             get { return elementFormDefault; }
  317.             set { elementFormDefault = value; }
  318.         }
  319.        
  320.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.TargetNamespace"]/*' />
  321.         /// <devdoc>
  322.         /// <para>[To be supplied.]</para>
  323.         /// </devdoc>
  324.         [XmlAttribute("targetNamespace", DataType = "anyURI")]
  325.         public string TargetNamespace {
  326.             get { return targetNs; }
  327.             set { targetNs = value; }
  328.         }
  329.        
  330.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Version"]/*' />
  331.         /// <devdoc>
  332.         /// <para>[To be supplied.]</para>
  333.         /// </devdoc>
  334.         [XmlAttribute("version", DataType = "token")]
  335.         public string Version {
  336.             get { return version; }
  337.             set { version = value; }
  338.         }
  339.        
  340.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Includes"]/*' />
  341.         /// <devdoc>
  342.         /// <para>[To be supplied.]</para>
  343.         /// </devdoc>
  344.         [XmlElement("include", typeof(XmlSchemaInclude)), XmlElement("import", typeof(XmlSchemaImport)), XmlElement("redefine", typeof(XmlSchemaRedefine))]
  345.         public XmlSchemaObjectCollection Includes {
  346.             get { return includes; }
  347.         }
  348.        
  349.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Items"]/*' />
  350.         /// <devdoc>
  351.         /// <para>[To be supplied.]</para>
  352.         /// </devdoc>
  353.         [XmlElement("annotation", typeof(XmlSchemaAnnotation)), XmlElement("attribute", typeof(XmlSchemaAttribute)), XmlElement("attributeGroup", typeof(XmlSchemaAttributeGroup)), XmlElement("complexType", typeof(XmlSchemaComplexType)), XmlElement("simpleType", typeof(XmlSchemaSimpleType)), XmlElement("element", typeof(XmlSchemaElement)), XmlElement("group", typeof(XmlSchemaGroup)), XmlElement("notation", typeof(XmlSchemaNotation))]
  354.         public XmlSchemaObjectCollection Items {
  355.             get { return items; }
  356.         }
  357.        
  358.         // Compiled info
  359.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.IsCompiled"]/*' />
  360.         /// <devdoc>
  361.         /// <para>[To be supplied.]</para>
  362.         /// </devdoc>
  363.         [XmlIgnore()]
  364.         public bool IsCompiled {
  365.             get { return isCompiled || isCompiledBySet; }
  366.         }
  367.        
  368.         [XmlIgnore()]
  369.         internal bool IsCompiledBySet {
  370.             get { return isCompiledBySet; }
  371.             set { isCompiledBySet = value; }
  372.         }
  373.        
  374.         [XmlIgnore()]
  375.         internal bool IsPreprocessed {
  376.             get { return isPreprocessed; }
  377.             set { isPreprocessed = value; }
  378.         }
  379.        
  380.         [XmlIgnore()]
  381.         internal bool IsRedefined {
  382.             get { return isRedefined; }
  383.             set { isRedefined = value; }
  384.         }
  385.        
  386.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Attributes"]/*' />
  387.         /// <devdoc>
  388.         /// <para>[To be supplied.]</para>
  389.         /// </devdoc>
  390.         [XmlIgnore()]
  391.         public XmlSchemaObjectTable Attributes {
  392.             get {
  393.                 if (attributes == null) {
  394.                     attributes = new XmlSchemaObjectTable();
  395.                 }
  396.                 return attributes;
  397.             }
  398.         }
  399.        
  400.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.AttributeGroups"]/*' />
  401.         /// <devdoc>
  402.         /// <para>[To be supplied.]</para>
  403.         /// </devdoc>
  404.         [XmlIgnore()]
  405.         public XmlSchemaObjectTable AttributeGroups {
  406.             get {
  407.                 if (attributeGroups == null) {
  408.                     attributeGroups = new XmlSchemaObjectTable();
  409.                 }
  410.                 return attributeGroups;
  411.             }
  412.         }
  413.        
  414.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.SchemaTypes"]/*' />
  415.         /// <devdoc>
  416.         /// <para>[To be supplied.]</para>
  417.         /// </devdoc>
  418.         [XmlIgnore()]
  419.         public XmlSchemaObjectTable SchemaTypes {
  420.             get {
  421.                 if (types == null) {
  422.                     types = new XmlSchemaObjectTable();
  423.                 }
  424.                 return types;
  425.             }
  426.         }
  427.        
  428.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Elements"]/*' />
  429.         /// <devdoc>
  430.         /// <para>[To be supplied.]</para>
  431.         /// </devdoc>
  432.         [XmlIgnore()]
  433.         public XmlSchemaObjectTable Elements {
  434.             get {
  435.                 if (elements == null) {
  436.                     elements = new XmlSchemaObjectTable();
  437.                 }
  438.                 return elements;
  439.             }
  440.         }
  441.        
  442.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Id"]/*' />
  443.         /// <devdoc>
  444.         /// <para>[To be supplied.]</para>
  445.         /// </devdoc>
  446.         [XmlAttribute("id", DataType = "ID")]
  447.         public string Id {
  448.             get { return id; }
  449.             set { id = value; }
  450.         }
  451.        
  452.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.UnhandledAttributes"]/*' />
  453.         /// <devdoc>
  454.         /// <para>[To be supplied.]</para>
  455.         /// </devdoc>
  456.         [XmlAnyAttribute()]
  457.         public XmlAttribute[] UnhandledAttributes {
  458.             get { return moreAttributes; }
  459.             set { moreAttributes = value; }
  460.         }
  461.        
  462.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Groups"]/*' />
  463.         /// <devdoc>
  464.         /// <para>[To be supplied.]</para>
  465.         /// </devdoc>
  466.         [XmlIgnore()]
  467.         public XmlSchemaObjectTable Groups {
  468.             get { return groups; }
  469.         }
  470.        
  471.         /// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Notations"]/*' />
  472.         /// <devdoc>
  473.         /// <para>[To be supplied.]</para>
  474.         /// </devdoc>
  475.         [XmlIgnore()]
  476.         public XmlSchemaObjectTable Notations {
  477.             get { return notations; }
  478.         }
  479.        
  480.         [XmlIgnore()]
  481.         internal XmlSchemaObjectTable IdentityConstraints {
  482.             get { return identityConstraints; }
  483.         }
  484.        
  485.         [XmlIgnore()]
  486.         internal Uri BaseUri {
  487.             get { return baseUri; }
  488.             set { baseUri = value; }
  489.         }
  490.        
  491.         [XmlIgnore()]
  492.         internal int SchemaId {
  493.             get {
  494.                 if (schemaId == -1) {
  495.                     schemaId = Interlocked.Increment(ref globalIdCounter);
  496.                 }
  497.                 return schemaId;
  498.             }
  499.         }
  500.        
  501.         [XmlIgnore()]
  502.         internal bool IsChameleon {
  503.             get { return isChameleon; }
  504.             set { isChameleon = value; }
  505.         }
  506.        
  507.         [XmlIgnore()]
  508.         internal Hashtable Ids {
  509.             get { return ids; }
  510.         }
  511.        
  512.         [XmlIgnore()]
  513.         internal XmlDocument Document {
  514.             get {
  515.                 if (document == null)
  516.                     document = new XmlDocument();
  517.                 return document;
  518.             }
  519.         }
  520.        
  521.         [XmlIgnore()]
  522.         internal int ErrorCount {
  523.             get { return errorCount; }
  524.             set { errorCount = value; }
  525.         }
  526.        
  527.         internal new XmlSchema Clone()
  528.         {
  529.             XmlSchema that = new XmlSchema();
  530.             that.attributeFormDefault = this.attributeFormDefault;
  531.             that.elementFormDefault = this.elementFormDefault;
  532.             that.blockDefault = this.blockDefault;
  533.             that.finalDefault = this.finalDefault;
  534.             that.targetNs = this.targetNs;
  535.             that.version = this.version;
  536.             that.includes = this.includes;
  537.            
  538.             that.Namespaces = this.Namespaces;
  539.             that.items = this.items;
  540.             that.BaseUri = this.BaseUri;
  541.            
  542.             SchemaCollectionCompiler.Cleanup(that);
  543.             return that;
  544.         }
  545.        
  546.         internal XmlSchema DeepClone()
  547.         {
  548.             XmlSchema that = new XmlSchema();
  549.             that.attributeFormDefault = this.attributeFormDefault;
  550.             that.elementFormDefault = this.elementFormDefault;
  551.             that.blockDefault = this.blockDefault;
  552.             that.finalDefault = this.finalDefault;
  553.             that.targetNs = this.targetNs;
  554.             that.version = this.version;
  555.             that.isPreprocessed = this.isPreprocessed;
  556.             //that.IsProcessing = this.IsProcessing; //Not sure if this is needed
  557.            
  558.             //Clone its Items
  559.             foreach (XmlSchemaObject item in this.items) {
  560.                 XmlSchemaObject newItem = item.Clone();
  561.                 that.Items.Add(newItem);
  562.             }
  563.            
  564.             //Clone Includes
  565.             foreach (XmlSchemaExternal include in this.includes) {
  566.                 XmlSchemaExternal newInclude = (XmlSchemaExternal)include.Clone();
  567.                 that.Includes.Add(newInclude);
  568.             }
  569.             that.Namespaces = this.Namespaces;
  570.             //that.includes = this.includes; //Need to verify this is OK for redefines
  571.             that.BaseUri = this.BaseUri;
  572.             return that;
  573.         }
  574.        
  575.         [XmlIgnore()]
  576.         internal override string IdAttribute {
  577.             get { return Id; }
  578.             set { Id = value; }
  579.         }
  580.        
  581.         internal void SetIsCompiled(bool isCompiled)
  582.         {
  583.             this.isCompiled = isCompiled;
  584.         }
  585.        
  586.         internal override void SetUnhandledAttributes(XmlAttribute[] moreAttributes)
  587.         {
  588.             this.moreAttributes = moreAttributes;
  589.         }
  590.         internal override void AddAnnotation(XmlSchemaAnnotation annotation)
  591.         {
  592.             items.Add(annotation);
  593.         }
  594.        
  595.         internal XmlNameTable NameTable {
  596.             get {
  597.                 if (nameTable == null)
  598.                     nameTable = new System.Xml.NameTable();
  599.                 return nameTable;
  600.             }
  601.         }
  602.        
  603.         internal ArrayList ImportedSchemas {
  604.             get {
  605.                 if (importedSchemas == null) {
  606.                     importedSchemas = new ArrayList();
  607.                 }
  608.                 return importedSchemas;
  609.             }
  610.         }
  611.        
  612.         internal ArrayList ImportedNamespaces {
  613.             get {
  614.                 if (importedNamespaces == null) {
  615.                     importedNamespaces = new ArrayList();
  616.                 }
  617.                 return importedNamespaces;
  618.             }
  619.         }
  620.        
  621.         internal void GetExternalSchemasList(IList extList, XmlSchema schema)
  622.         {
  623.             Debug.Assert(extList != null && schema != null);
  624.             if (extList.Contains(schema)) {
  625.                 return;
  626.             }
  627.             extList.Add(schema);
  628.             foreach (XmlSchemaExternal ext in schema.Includes) {
  629.                 if (ext.Schema != null) {
  630.                     GetExternalSchemasList(extList, ext.Schema);
  631.                 }
  632.             }
  633.         }
  634.        
  635.         internal void AddCompiledInfo(SchemaInfo schemaInfo)
  636.         {
  637.             XmlQualifiedName itemName;
  638.             foreach (XmlSchemaElement element in elements.Values) {
  639.                 itemName = element.QualifiedName;
  640.                 schemaInfo.TargetNamespaces[itemName.Namespace] = true;
  641.                 if (schemaInfo.ElementDecls[itemName] == null) {
  642.                     schemaInfo.ElementDecls.Add(itemName, element.ElementDecl);
  643.                 }
  644.             }
  645.             foreach (XmlSchemaAttribute attribute in attributes.Values) {
  646.                 itemName = attribute.QualifiedName;
  647.                 schemaInfo.TargetNamespaces[itemName.Namespace] = true;
  648.                 if (schemaInfo.ElementDecls[itemName] == null) {
  649.                     schemaInfo.AttributeDecls.Add(itemName, attribute.AttDef);
  650.                 }
  651.             }
  652.             foreach (XmlSchemaType type in types.Values) {
  653.                 itemName = type.QualifiedName;
  654.                 schemaInfo.TargetNamespaces[itemName.Namespace] = true;
  655.                 XmlSchemaComplexType complexType = type as XmlSchemaComplexType;
  656.                 if ((complexType == null || type != XmlSchemaComplexType.AnyType) && schemaInfo.ElementDeclsByType[itemName] == null) {
  657.                     schemaInfo.ElementDeclsByType.Add(itemName, type.ElementDecl);
  658.                 }
  659.             }
  660.             foreach (XmlSchemaNotation notation in notations.Values) {
  661.                 itemName = notation.QualifiedName;
  662.                 schemaInfo.TargetNamespaces[itemName.Namespace] = true;
  663.                 SchemaNotation no = new SchemaNotation(itemName);
  664.                 no.SystemLiteral = notation.System;
  665.                 no.Pubid = notation.Public;
  666.                 if (schemaInfo.Notations[itemName.Name] == null) {
  667.                     schemaInfo.Notations.Add(itemName.Name, no);
  668.                 }
  669.             }
  670.         }
  671.     }
  672. }

Developer Fusion