The Labs \ Source Viewer \ SSCLI \ System.Xml.Serialization \ XmlFacetComparer

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlSchemaSerializer.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">ElenaK</owner>
  15. //------------------------------------------------------------------------------
  16. namespace System.Xml.Serialization
  17. {
  18.     using System;
  19.     using System.Text;
  20.     using System.IO;
  21.     using System.Xml;
  22.     using System.Xml.Schema;
  23.     using System.Xml.Serialization;
  24.     using System.Collections;
  25.     using System.Collections.Specialized;
  26.    
  27.    
  28.     internal class XmlAttributeComparer : IComparer
  29.     {
  30.         public int Compare(object o1, object o2)
  31.         {
  32.             XmlAttribute a1 = (XmlAttribute)o1;
  33.             XmlAttribute a2 = (XmlAttribute)o2;
  34.             int ns = String.Compare(a1.NamespaceURI, a2.NamespaceURI, StringComparison.Ordinal);
  35.             if (ns == 0) {
  36.                 return String.Compare(a1.Name, a2.Name, StringComparison.Ordinal);
  37.             }
  38.             return ns;
  39.         }
  40.     }
  41.    
  42.     internal class XmlFacetComparer : IComparer
  43.     {
  44.         public int Compare(object o1, object o2)
  45.         {
  46.             XmlSchemaFacet f1 = (XmlSchemaFacet)o1;
  47.             XmlSchemaFacet f2 = (XmlSchemaFacet)o2;
  48.             return String.Compare(f1.GetType().Name + ":" + f1.Value, f2.GetType().Name + ":" + f2.Value, StringComparison.Ordinal);
  49.         }
  50.     }
  51.    
  52.     internal class QNameComparer : IComparer
  53.     {
  54.         public int Compare(object o1, object o2)
  55.         {
  56.             XmlQualifiedName qn1 = (XmlQualifiedName)o1;
  57.             XmlQualifiedName qn2 = (XmlQualifiedName)o2;
  58.             int ns = String.Compare(qn1.Namespace, qn2.Namespace, StringComparison.Ordinal);
  59.             if (ns == 0) {
  60.                 return String.Compare(qn1.Name, qn2.Name, StringComparison.Ordinal);
  61.             }
  62.             return ns;
  63.         }
  64.     }
  65.    
  66.     internal class XmlSchemaObjectComparer : IComparer
  67.     {
  68.         QNameComparer comparer = new QNameComparer();
  69.         public int Compare(object o1, object o2)
  70.         {
  71.             return comparer.Compare(NameOf((XmlSchemaObject)o1), NameOf((XmlSchemaObject)o2));
  72.         }
  73.        
  74.         static internal XmlQualifiedName NameOf(XmlSchemaObject o)
  75.         {
  76.             if (o is XmlSchemaAttribute) {
  77.                 return ((XmlSchemaAttribute)o).QualifiedName;
  78.             }
  79.             else if (o is XmlSchemaAttributeGroup) {
  80.                 return ((XmlSchemaAttributeGroup)o).QualifiedName;
  81.             }
  82.             else if (o is XmlSchemaComplexType) {
  83.                 return ((XmlSchemaComplexType)o).QualifiedName;
  84.             }
  85.             else if (o is XmlSchemaSimpleType) {
  86.                 return ((XmlSchemaSimpleType)o).QualifiedName;
  87.             }
  88.             else if (o is XmlSchemaElement) {
  89.                 return ((XmlSchemaElement)o).QualifiedName;
  90.             }
  91.             else if (o is XmlSchemaGroup) {
  92.                 return ((XmlSchemaGroup)o).QualifiedName;
  93.             }
  94.             else if (o is XmlSchemaGroupRef) {
  95.                 return ((XmlSchemaGroupRef)o).RefName;
  96.             }
  97.             else if (o is XmlSchemaNotation) {
  98.                 return ((XmlSchemaNotation)o).QualifiedName;
  99.             }
  100.             else if (o is XmlSchemaSequence) {
  101.                 XmlSchemaSequence s = (XmlSchemaSequence)o;
  102.                 if (s.Items.Count == 0)
  103.                     return new XmlQualifiedName(".sequence", Namespace(o));
  104.                 return NameOf(s.Items[0]);
  105.             }
  106.             else if (o is XmlSchemaAll) {
  107.                 XmlSchemaAll a = (XmlSchemaAll)o;
  108.                 if (a.Items.Count == 0)
  109.                     return new XmlQualifiedName(".all", Namespace(o));
  110.                 return NameOf(a.Items);
  111.             }
  112.             else if (o is XmlSchemaChoice) {
  113.                 XmlSchemaChoice c = (XmlSchemaChoice)o;
  114.                 if (c.Items.Count == 0)
  115.                     return new XmlQualifiedName(".choice", Namespace(o));
  116.                 return NameOf(c.Items);
  117.             }
  118.             else if (o is XmlSchemaAny) {
  119.                 return new XmlQualifiedName("*", SchemaObjectWriter.ToString(((XmlSchemaAny)o).NamespaceList));
  120.             }
  121.             else if (o is XmlSchemaIdentityConstraint) {
  122.                 return ((XmlSchemaIdentityConstraint)o).QualifiedName;
  123.             }
  124.             return new XmlQualifiedName("?", Namespace(o));
  125.         }
  126.        
  127.         static internal XmlQualifiedName NameOf(XmlSchemaObjectCollection items)
  128.         {
  129.             ArrayList list = new ArrayList();
  130.            
  131.             for (int i = 0; i < items.Count; i++) {
  132.                 list.Add(NameOf(items[i]));
  133.             }
  134.             list.Sort(new QNameComparer());
  135.             return (XmlQualifiedName)list[0];
  136.         }
  137.        
  138.         static internal string Namespace(XmlSchemaObject o)
  139.         {
  140.             while (o != null && !(o is XmlSchema)) {
  141.                 o = o.Parent;
  142.             }
  143.             return o == null ? "" : ((XmlSchema)o).TargetNamespace;
  144.         }
  145.     }
  146.    
  147.     internal class SchemaObjectWriter
  148.     {
  149.         StringBuilder w = new StringBuilder();
  150.         int indentLevel = -1;
  151.        
  152.         void WriteIndent()
  153.         {
  154.             for (int i = 0; i < indentLevel; i++) {
  155.                 w.Append(" ");
  156.             }
  157.         }
  158.         protected void WriteAttribute(string localName, string ns, string value)
  159.         {
  160.             if (value == null || value.Length == 0)
  161.                 return;
  162.             w.Append(",");
  163.             w.Append(ns);
  164.             if (ns != null && ns.Length != 0)
  165.                 w.Append(":");
  166.             w.Append(localName);
  167.             w.Append("=");
  168.             w.Append(value);
  169.         }
  170.         protected void WriteAttribute(string localName, string ns, XmlQualifiedName value)
  171.         {
  172.             if (value.IsEmpty)
  173.                 return;
  174.             WriteAttribute(localName, ns, value.ToString());
  175.         }
  176.        
  177.         protected void WriteStartElement(string name)
  178.         {
  179.             NewLine();
  180.             indentLevel++;
  181.             w.Append("[");
  182.             w.Append(name);
  183.         }
  184.         protected void WriteEndElement()
  185.         {
  186.             w.Append("]");
  187.             indentLevel--;
  188.         }
  189.         protected void NewLine()
  190.         {
  191.             w.Append(Environment.NewLine);
  192.             WriteIndent();
  193.         }
  194.        
  195.         protected string GetString()
  196.         {
  197.             return w.ToString();
  198.         }
  199.        
  200.         void WriteAttribute(XmlAttribute a)
  201.         {
  202.             if (a.Value != null) {
  203.                 WriteAttribute(a.Name, a.NamespaceURI, a.Value);
  204.             }
  205.         }
  206.        
  207.         void WriteAttributes(XmlAttribute[] a, XmlSchemaObject o)
  208.         {
  209.             if (a == null)
  210.                 return;
  211.             ArrayList attrs = new ArrayList();
  212.             for (int i = 0; i < a.Length; i++) {
  213.                 attrs.Add(a[i]);
  214.             }
  215.             attrs.Sort(new XmlAttributeComparer());
  216.             for (int i = 0; i < attrs.Count; i++) {
  217.                 XmlAttribute attribute = (XmlAttribute)attrs[i];
  218.                 WriteAttribute(attribute);
  219.             }
  220.         }
  221.        
  222.         static internal string ToString(NamespaceList list)
  223.         {
  224.             if (list == null)
  225.                 return null;
  226.             switch (list.Type) {
  227.                 case NamespaceList.ListType.Any:
  228.                     return "##any";
  229.                 case NamespaceList.ListType.Other:
  230.                     return "##other";
  231.                 case NamespaceList.ListType.Set:
  232.                     ArrayList ns = new ArrayList();
  233.                    
  234.                     foreach (string s in list.Enumerate) {
  235.                         ns.Add(s);
  236.                     }
  237.                     ns.Sort();
  238.                     StringBuilder sb = new StringBuilder();
  239.                     bool first = true;
  240.                     foreach (string s in ns) {
  241.                         if (first) {
  242.                             first = false;
  243.                         }
  244.                         else {
  245.                             sb.Append(" ");
  246.                         }
  247.                         if (s.Length == 0) {
  248.                             sb.Append("##local");
  249.                         }
  250.                         else {
  251.                             sb.Append(s);
  252.                         }
  253.                     }
  254.                     return sb.ToString();
  255.                 default:
  256.                    
  257.                     return list.ToString();
  258.             }
  259.         }
  260.        
  261.         internal string WriteXmlSchemaObject(XmlSchemaObject o)
  262.         {
  263.             if (o == null)
  264.                 return String.Empty;
  265.             Write3_XmlSchemaObject((XmlSchemaObject)o);
  266.             return GetString();
  267.         }
  268.        
  269.         void WriteSortedItems(XmlSchemaObjectCollection items)
  270.         {
  271.             if (items == null)
  272.                 return;
  273.            
  274.             ArrayList list = new ArrayList();
  275.             for (int i = 0; i < items.Count; i++) {
  276.                 list.Add(items[i]);
  277.             }
  278.             list.Sort(new XmlSchemaObjectComparer());
  279.             for (int i = 0; i < list.Count; i++) {
  280.                 Write3_XmlSchemaObject((XmlSchemaObject)list[i]);
  281.             }
  282.         }
  283.        
  284.         void Write1_XmlSchemaAttribute(XmlSchemaAttribute o)
  285.         {
  286.             if ((object)o == null)
  287.                 return;
  288.             WriteStartElement("attribute");
  289.             WriteAttribute("id", "", ((string)o.Id));
  290.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  291.             WriteAttribute("default", "", ((string)o.DefaultValue));
  292.             WriteAttribute("fixed", "", ((string)o.FixedValue));
  293.             if (o.Parent != null && !(o.Parent is XmlSchema)) {
  294.                 if (o.QualifiedName != null && !o.QualifiedName.IsEmpty && o.QualifiedName.Namespace != null && o.QualifiedName.Namespace.Length != 0) {
  295.                     WriteAttribute("form", "", "qualified");
  296.                 }
  297.                 else {
  298.                     WriteAttribute("form", "", "unqualified");
  299.                 }
  300.             }
  301.             WriteAttribute("name", "", ((string)o.Name));
  302.            
  303.             if (!o.RefName.IsEmpty) {
  304.                 WriteAttribute("ref", "", o.RefName);
  305.             }
  306.             else if (!o.SchemaTypeName.IsEmpty) {
  307.                 WriteAttribute("type", "", o.SchemaTypeName);
  308.             }
  309.             XmlSchemaUse use = o.Use == XmlSchemaUse.None ? XmlSchemaUse.Optional : o.Use;
  310.             WriteAttribute("use", "", Write30_XmlSchemaUse(use));
  311.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  312.             Write9_XmlSchemaSimpleType((XmlSchemaSimpleType)o.SchemaType);
  313.             WriteEndElement();
  314.         }
  315.        
  316.         void Write3_XmlSchemaObject(XmlSchemaObject o)
  317.         {
  318.             if ((object)o == null)
  319.                 return;
  320.             System.Type t = o.GetType();
  321.            
  322.             if (t == typeof(XmlSchemaComplexType)) {
  323.                 Write35_XmlSchemaComplexType((XmlSchemaComplexType)o);
  324.                 return;
  325.             }
  326.             else if (t == typeof(XmlSchemaSimpleType)) {
  327.                 Write9_XmlSchemaSimpleType((XmlSchemaSimpleType)o);
  328.                 return;
  329.             }
  330.             else if (t == typeof(XmlSchemaElement)) {
  331.                 Write46_XmlSchemaElement((XmlSchemaElement)o);
  332.                 return;
  333.             }
  334.             else if (t == typeof(XmlSchemaAppInfo)) {
  335.                 Write7_XmlSchemaAppInfo((XmlSchemaAppInfo)o);
  336.                 return;
  337.             }
  338.             else if (t == typeof(XmlSchemaDocumentation)) {
  339.                 Write6_XmlSchemaDocumentation((XmlSchemaDocumentation)o);
  340.                 return;
  341.             }
  342.             else if (t == typeof(XmlSchemaAnnotation)) {
  343.                 Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o);
  344.                 return;
  345.             }
  346.             else if (t == typeof(XmlSchemaGroup)) {
  347.                 Write57_XmlSchemaGroup((XmlSchemaGroup)o);
  348.                 return;
  349.             }
  350.             else if (t == typeof(XmlSchemaXPath)) {
  351.                 Write49_XmlSchemaXPath("xpath", "", (XmlSchemaXPath)o);
  352.                 return;
  353.             }
  354.             else if (t == typeof(XmlSchemaIdentityConstraint)) {
  355.                 Write48_XmlSchemaIdentityConstraint((XmlSchemaIdentityConstraint)o);
  356.                 return;
  357.             }
  358.             else if (t == typeof(XmlSchemaUnique)) {
  359.                 Write51_XmlSchemaUnique((XmlSchemaUnique)o);
  360.                 return;
  361.             }
  362.             else if (t == typeof(XmlSchemaKeyref)) {
  363.                 Write50_XmlSchemaKeyref((XmlSchemaKeyref)o);
  364.                 return;
  365.             }
  366.             else if (t == typeof(XmlSchemaKey)) {
  367.                 Write47_XmlSchemaKey((XmlSchemaKey)o);
  368.                 return;
  369.             }
  370.             else if (t == typeof(XmlSchemaGroupRef)) {
  371.                 Write55_XmlSchemaGroupRef((XmlSchemaGroupRef)o);
  372.                 return;
  373.             }
  374.             else if (t == typeof(XmlSchemaAny)) {
  375.                 Write53_XmlSchemaAny((XmlSchemaAny)o);
  376.                 return;
  377.             }
  378.             else if (t == typeof(XmlSchemaSequence)) {
  379.                 Write54_XmlSchemaSequence((XmlSchemaSequence)o);
  380.                 return;
  381.             }
  382.             else if (t == typeof(XmlSchemaChoice)) {
  383.                 Write52_XmlSchemaChoice((XmlSchemaChoice)o);
  384.                 return;
  385.             }
  386.             else if (t == typeof(XmlSchemaAll)) {
  387.                 Write43_XmlSchemaAll((XmlSchemaAll)o);
  388.                 return;
  389.             }
  390.             else if (t == typeof(XmlSchemaComplexContentRestriction)) {
  391.                 Write56_XmlSchemaComplexContentRestriction((XmlSchemaComplexContentRestriction)o);
  392.                 return;
  393.             }
  394.             else if (t == typeof(XmlSchemaComplexContentExtension)) {
  395.                 Write42_XmlSchemaComplexContentExtension((XmlSchemaComplexContentExtension)o);
  396.                 return;
  397.             }
  398.             else if (t == typeof(XmlSchemaSimpleContentRestriction)) {
  399.                 Write40_XmlSchemaSimpleContentRestriction((XmlSchemaSimpleContentRestriction)o);
  400.                 return;
  401.             }
  402.             else if (t == typeof(XmlSchemaSimpleContentExtension)) {
  403.                 Write38_XmlSchemaSimpleContentExtension((XmlSchemaSimpleContentExtension)o);
  404.                 return;
  405.             }
  406.             else if (t == typeof(XmlSchemaComplexContent)) {
  407.                 Write41_XmlSchemaComplexContent((XmlSchemaComplexContent)o);
  408.                 return;
  409.             }
  410.             else if (t == typeof(XmlSchemaSimpleContent)) {
  411.                 Write36_XmlSchemaSimpleContent((XmlSchemaSimpleContent)o);
  412.                 return;
  413.             }
  414.             else if (t == typeof(XmlSchemaAnyAttribute)) {
  415.                 Write33_XmlSchemaAnyAttribute((XmlSchemaAnyAttribute)o);
  416.                 return;
  417.             }
  418.             else if (t == typeof(XmlSchemaAttributeGroupRef)) {
  419.                 Write32_XmlSchemaAttributeGroupRef((XmlSchemaAttributeGroupRef)o);
  420.                 return;
  421.             }
  422.             else if (t == typeof(XmlSchemaAttributeGroup)) {
  423.                 Write31_XmlSchemaAttributeGroup((XmlSchemaAttributeGroup)o);
  424.                 return;
  425.             }
  426.             else if (t == typeof(XmlSchemaSimpleTypeRestriction)) {
  427.                 Write15_XmlSchemaSimpleTypeRestriction((XmlSchemaSimpleTypeRestriction)o);
  428.                 return;
  429.             }
  430.             else if (t == typeof(XmlSchemaSimpleTypeList)) {
  431.                 Write14_XmlSchemaSimpleTypeList((XmlSchemaSimpleTypeList)o);
  432.                 return;
  433.             }
  434.             else if (t == typeof(XmlSchemaSimpleTypeUnion)) {
  435.                 Write12_XmlSchemaSimpleTypeUnion((XmlSchemaSimpleTypeUnion)o);
  436.                 return;
  437.             }
  438.             else if (t == typeof(XmlSchemaAttribute)) {
  439.                 Write1_XmlSchemaAttribute((XmlSchemaAttribute)o);
  440.                 return;
  441.             }
  442.         }
  443.        
  444.         void Write5_XmlSchemaAnnotation(XmlSchemaAnnotation o)
  445.         {
  446.             if ((object)o == null)
  447.                 return;
  448.             WriteStartElement("annotation");
  449.            
  450.             WriteAttribute("id", "", ((string)o.Id));
  451.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  452.             System.Xml.Schema.XmlSchemaObjectCollection a = (System.Xml.Schema.XmlSchemaObjectCollection)o.Items;
  453.             if (a != null) {
  454.                 for (int ia = 0; ia < a.Count; ia++) {
  455.                     XmlSchemaObject ai = (XmlSchemaObject)a[ia];
  456.                     if (ai is XmlSchemaAppInfo) {
  457.                         Write7_XmlSchemaAppInfo((XmlSchemaAppInfo)ai);
  458.                     }
  459.                     else if (ai is XmlSchemaDocumentation) {
  460.                         Write6_XmlSchemaDocumentation((XmlSchemaDocumentation)ai);
  461.                     }
  462.                 }
  463.             }
  464.             WriteEndElement();
  465.         }
  466.        
  467.         void Write6_XmlSchemaDocumentation(XmlSchemaDocumentation o)
  468.         {
  469.             if ((object)o == null)
  470.                 return;
  471.             WriteStartElement("documentation");
  472.            
  473.             WriteAttribute("source", "", ((string)o.Source));
  474.             WriteAttribute("lang", "http://www.w3.org/XML/1998/namespace", ((string)o.Language));
  475.             XmlNode[] a = (XmlNode[])o.Markup;
  476.             if (a != null) {
  477.                 for (int ia = 0; ia < a.Length; ia++) {
  478.                     XmlNode ai = (XmlNode)a[ia];
  479.                     WriteStartElement("node");
  480.                     WriteAttribute("xml", "", ai.OuterXml);
  481.                 }
  482.             }
  483.             WriteEndElement();
  484.         }
  485.        
  486.         void Write7_XmlSchemaAppInfo(XmlSchemaAppInfo o)
  487.         {
  488.             if ((object)o == null)
  489.                 return;
  490.             WriteStartElement("appinfo");
  491.            
  492.             WriteAttribute("source", "", o.Source);
  493.             XmlNode[] a = (XmlNode[])o.Markup;
  494.             if (a != null) {
  495.                 for (int ia = 0; ia < a.Length; ia++) {
  496.                     XmlNode ai = (XmlNode)a[ia];
  497.                     WriteStartElement("node");
  498.                     WriteAttribute("xml", "", ai.OuterXml);
  499.                 }
  500.             }
  501.             WriteEndElement();
  502.         }
  503.        
  504.         void Write9_XmlSchemaSimpleType(XmlSchemaSimpleType o)
  505.         {
  506.             if ((object)o == null)
  507.                 return;
  508.             WriteStartElement("simpleType");
  509.            
  510.             WriteAttribute("id", "", ((string)o.Id));
  511.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  512.             WriteAttribute("name", "", ((string)o.Name));
  513.             WriteAttribute("final", "", Write11_XmlSchemaDerivationMethod(o.FinalResolved));
  514.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  515.             if (o.Content is XmlSchemaSimpleTypeUnion) {
  516.                 Write12_XmlSchemaSimpleTypeUnion((XmlSchemaSimpleTypeUnion)o.Content);
  517.             }
  518.             else if (o.Content is XmlSchemaSimpleTypeRestriction) {
  519.                 Write15_XmlSchemaSimpleTypeRestriction((XmlSchemaSimpleTypeRestriction)o.Content);
  520.             }
  521.             else if (o.Content is XmlSchemaSimpleTypeList) {
  522.                 Write14_XmlSchemaSimpleTypeList((XmlSchemaSimpleTypeList)o.Content);
  523.             }
  524.             WriteEndElement();
  525.         }
  526.        
  527.         string Write11_XmlSchemaDerivationMethod(XmlSchemaDerivationMethod v)
  528.         {
  529.             return v.ToString();
  530.         }
  531.        
  532.         void Write12_XmlSchemaSimpleTypeUnion(XmlSchemaSimpleTypeUnion o)
  533.         {
  534.             if ((object)o == null)
  535.                 return;
  536.             WriteStartElement("union");
  537.            
  538.             WriteAttribute("id", "", ((string)o.Id));
  539.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  540.            
  541.             if (o.MemberTypes != null) {
  542.                 ArrayList list = new ArrayList();
  543.                 for (int i = 0; i < o.MemberTypes.Length; i++) {
  544.                     list.Add(o.MemberTypes[i]);
  545.                 }
  546.                 list.Sort(new QNameComparer());
  547.                
  548.                 w.Append(",");
  549.                 w.Append("memberTypes=");
  550.                
  551.                 for (int i = 0; i < list.Count; i++) {
  552.                     XmlQualifiedName q = (XmlQualifiedName)list[i];
  553.                     w.Append(q.ToString());
  554.                     w.Append(",");
  555.                 }
  556.             }
  557.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  558.             WriteSortedItems(o.BaseTypes);
  559.             WriteEndElement();
  560.         }
  561.        
  562.         void Write14_XmlSchemaSimpleTypeList(XmlSchemaSimpleTypeList o)
  563.         {
  564.             if ((object)o == null)
  565.                 return;
  566.             WriteStartElement("list");
  567.            
  568.             WriteAttribute("id", "", ((string)o.Id));
  569.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  570.             if (!o.ItemTypeName.IsEmpty) {
  571.                 WriteAttribute("itemType", "", o.ItemTypeName);
  572.             }
  573.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  574.             Write9_XmlSchemaSimpleType((XmlSchemaSimpleType)o.ItemType);
  575.             WriteEndElement();
  576.         }
  577.        
  578.         void Write15_XmlSchemaSimpleTypeRestriction(XmlSchemaSimpleTypeRestriction o)
  579.         {
  580.             if ((object)o == null)
  581.                 return;
  582.             WriteStartElement("restriction");
  583.             WriteAttribute("id", "", ((string)o.Id));
  584.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  585.             if (!o.BaseTypeName.IsEmpty) {
  586.                 WriteAttribute("base", "", o.BaseTypeName);
  587.             }
  588.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  589.             Write9_XmlSchemaSimpleType((XmlSchemaSimpleType)o.BaseType);
  590.             WriteFacets(o.Facets);
  591.             WriteEndElement();
  592.         }
  593.        
  594.         void WriteFacets(XmlSchemaObjectCollection facets)
  595.         {
  596.             if (facets == null)
  597.                 return;
  598.            
  599.             ArrayList a = new ArrayList();
  600.             for (int i = 0; i < facets.Count; i++) {
  601.                 a.Add(facets[i]);
  602.             }
  603.             a.Sort(new XmlFacetComparer());
  604.             for (int ia = 0; ia < a.Count; ia++) {
  605.                 XmlSchemaObject ai = (XmlSchemaObject)a[ia];
  606.                 if (ai is XmlSchemaMinExclusiveFacet) {
  607.                     Write_XmlSchemaFacet("minExclusive", (XmlSchemaFacet)ai);
  608.                 }
  609.                 else if (ai is XmlSchemaMaxInclusiveFacet) {
  610.                     Write_XmlSchemaFacet("maxInclusive", (XmlSchemaFacet)ai);
  611.                 }
  612.                 else if (ai is XmlSchemaMaxExclusiveFacet) {
  613.                     Write_XmlSchemaFacet("maxExclusive", (XmlSchemaFacet)ai);
  614.                 }
  615.                 else if (ai is XmlSchemaMinInclusiveFacet) {
  616.                     Write_XmlSchemaFacet("minInclusive", (XmlSchemaFacet)ai);
  617.                 }
  618.                 else if (ai is XmlSchemaLengthFacet) {
  619.                     Write_XmlSchemaFacet("length", (XmlSchemaFacet)ai);
  620.                 }
  621.                 else if (ai is XmlSchemaEnumerationFacet) {
  622.                     Write_XmlSchemaFacet("enumeration", (XmlSchemaFacet)ai);
  623.                 }
  624.                 else if (ai is XmlSchemaMinLengthFacet) {
  625.                     Write_XmlSchemaFacet("minLength", (XmlSchemaFacet)ai);
  626.                 }
  627.                 else if (ai is XmlSchemaPatternFacet) {
  628.                     Write_XmlSchemaFacet("pattern", (XmlSchemaFacet)ai);
  629.                 }
  630.                 else if (ai is XmlSchemaTotalDigitsFacet) {
  631.                     Write_XmlSchemaFacet("totalDigits", (XmlSchemaFacet)ai);
  632.                 }
  633.                 else if (ai is XmlSchemaMaxLengthFacet) {
  634.                     Write_XmlSchemaFacet("maxLength", (XmlSchemaFacet)ai);
  635.                 }
  636.                 else if (ai is XmlSchemaWhiteSpaceFacet) {
  637.                     Write_XmlSchemaFacet("whiteSpace", (XmlSchemaFacet)ai);
  638.                 }
  639.                 else if (ai is XmlSchemaFractionDigitsFacet) {
  640.                     Write_XmlSchemaFacet("fractionDigit", (XmlSchemaFacet)ai);
  641.                 }
  642.             }
  643.         }
  644.        
  645.         void Write_XmlSchemaFacet(string name, XmlSchemaFacet o)
  646.         {
  647.             if ((object)o == null)
  648.                 return;
  649.             WriteStartElement(name);
  650.            
  651.             WriteAttribute("id", "", o.Id);
  652.             WriteAttribute("value", "", o.Value);
  653.             if (o.IsFixed) {
  654.                 WriteAttribute("fixed", "", XmlConvert.ToString(o.IsFixed));
  655.             }
  656.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  657.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  658.             WriteEndElement();
  659.         }
  660.        
  661.         string Write30_XmlSchemaUse(XmlSchemaUse v)
  662.         {
  663.             string s = null;
  664.             switch (v) {
  665.                 case XmlSchemaUse.Optional:
  666.                     s = "optional";
  667.                     break;
  668.                 case XmlSchemaUse.Prohibited:
  669.                     s = "prohibited";
  670.                     break;
  671.                 case XmlSchemaUse.Required:
  672.                     s = "required";
  673.                     break;
  674.                 default:
  675.                     break;
  676.             }
  677.             return s;
  678.         }
  679.        
  680.         void Write31_XmlSchemaAttributeGroup(XmlSchemaAttributeGroup o)
  681.         {
  682.             if ((object)o == null)
  683.                 return;
  684.             WriteStartElement("attributeGroup");
  685.            
  686.             WriteAttribute("id", "", ((string)o.Id));
  687.             WriteAttribute("name", "", ((string)o.Name));
  688.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  689.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  690.             WriteSortedItems(o.Attributes);
  691.             Write33_XmlSchemaAnyAttribute((XmlSchemaAnyAttribute)o.AnyAttribute);
  692.             WriteEndElement();
  693.         }
  694.        
  695.         void Write32_XmlSchemaAttributeGroupRef(XmlSchemaAttributeGroupRef o)
  696.         {
  697.             if ((object)o == null)
  698.                 return;
  699.             WriteStartElement("attributeGroup");
  700.            
  701.             WriteAttribute("id", "", ((string)o.Id));
  702.            
  703.             if (!o.RefName.IsEmpty) {
  704.                 WriteAttribute("ref", "", o.RefName);
  705.             }
  706.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  707.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  708.             WriteEndElement();
  709.         }
  710.        
  711.         void Write33_XmlSchemaAnyAttribute(XmlSchemaAnyAttribute o)
  712.         {
  713.             if ((object)o == null)
  714.                 return;
  715.             WriteStartElement("anyAttribute");
  716.            
  717.             WriteAttribute("id", "", ((string)o.Id));
  718.             WriteAttribute("namespace", "", ToString(o.NamespaceList));
  719.             XmlSchemaContentProcessing process = o.ProcessContents == XmlSchemaContentProcessing.None ? XmlSchemaContentProcessing.Strict : o.ProcessContents;
  720.             WriteAttribute("processContents", "", Write34_XmlSchemaContentProcessing(process));
  721.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  722.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  723.             WriteEndElement();
  724.         }
  725.        
  726.         string Write34_XmlSchemaContentProcessing(XmlSchemaContentProcessing v)
  727.         {
  728.             string s = null;
  729.             switch (v) {
  730.                 case XmlSchemaContentProcessing.Skip:
  731.                     s = "skip";
  732.                     break;
  733.                 case XmlSchemaContentProcessing.Lax:
  734.                     s = "lax";
  735.                     break;
  736.                 case XmlSchemaContentProcessing.Strict:
  737.                     s = "strict";
  738.                     break;
  739.                 default:
  740.                     break;
  741.             }
  742.             return s;
  743.         }
  744.        
  745.         void Write35_XmlSchemaComplexType(XmlSchemaComplexType o)
  746.         {
  747.             if ((object)o == null)
  748.                 return;
  749.             WriteStartElement("complexType");
  750.            
  751.             WriteAttribute("id", "", ((string)o.Id));
  752.             WriteAttribute("name", "", ((string)o.Name));
  753.             WriteAttribute("final", "", Write11_XmlSchemaDerivationMethod(o.FinalResolved));
  754.             if (((bool)o.IsAbstract) != false) {
  755.                 WriteAttribute("abstract", "", XmlConvert.ToString((bool)((bool)o.IsAbstract)));
  756.             }
  757.             WriteAttribute("block", "", Write11_XmlSchemaDerivationMethod(o.BlockResolved));
  758.             if (((bool)o.IsMixed) != false) {
  759.                 WriteAttribute("mixed", "", XmlConvert.ToString((bool)((bool)o.IsMixed)));
  760.             }
  761.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  762.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  763.             if (o.ContentModel is XmlSchemaComplexContent) {
  764.                 Write41_XmlSchemaComplexContent((XmlSchemaComplexContent)o.ContentModel);
  765.             }
  766.             else if (o.ContentModel is XmlSchemaSimpleContent) {
  767.                 Write36_XmlSchemaSimpleContent((XmlSchemaSimpleContent)o.ContentModel);
  768.             }
  769.             if (o.Particle is XmlSchemaSequence) {
  770.                 Write54_XmlSchemaSequence((XmlSchemaSequence)o.Particle);
  771.             }
  772.             else if (o.Particle is XmlSchemaGroupRef) {
  773.                 Write55_XmlSchemaGroupRef((XmlSchemaGroupRef)o.Particle);
  774.             }
  775.             else if (o.Particle is XmlSchemaChoice) {
  776.                 Write52_XmlSchemaChoice((XmlSchemaChoice)o.Particle);
  777.             }
  778.             else if (o.Particle is XmlSchemaAll) {
  779.                 Write43_XmlSchemaAll((XmlSchemaAll)o.Particle);
  780.             }
  781.             WriteSortedItems(o.Attributes);
  782.             Write33_XmlSchemaAnyAttribute((XmlSchemaAnyAttribute)o.AnyAttribute);
  783.             WriteEndElement();
  784.         }
  785.        
  786.         void Write36_XmlSchemaSimpleContent(XmlSchemaSimpleContent o)
  787.         {
  788.             if ((object)o == null)
  789.                 return;
  790.             WriteStartElement("simpleContent");
  791.            
  792.             WriteAttribute("id", "", ((string)o.Id));
  793.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  794.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  795.             if (o.Content is XmlSchemaSimpleContentRestriction) {
  796.                 Write40_XmlSchemaSimpleContentRestriction((XmlSchemaSimpleContentRestriction)o.Content);
  797.             }
  798.             else if (o.Content is XmlSchemaSimpleContentExtension) {
  799.                 Write38_XmlSchemaSimpleContentExtension((XmlSchemaSimpleContentExtension)o.Content);
  800.             }
  801.             WriteEndElement();
  802.         }
  803.        
  804.         void Write38_XmlSchemaSimpleContentExtension(XmlSchemaSimpleContentExtension o)
  805.         {
  806.             if ((object)o == null)
  807.                 return;
  808.             WriteStartElement("extension");
  809.            
  810.             WriteAttribute("id", "", ((string)o.Id));
  811.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  812.             if (!o.BaseTypeName.IsEmpty) {
  813.                 WriteAttribute("base", "", o.BaseTypeName);
  814.             }
  815.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  816.             WriteSortedItems(o.Attributes);
  817.             Write33_XmlSchemaAnyAttribute((XmlSchemaAnyAttribute)o.AnyAttribute);
  818.             WriteEndElement();
  819.         }
  820.        
  821.         void Write40_XmlSchemaSimpleContentRestriction(XmlSchemaSimpleContentRestriction o)
  822.         {
  823.             if ((object)o == null)
  824.                 return;
  825.             WriteStartElement("restriction");
  826.             WriteAttribute("id", "", ((string)o.Id));
  827.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  828.             if (!o.BaseTypeName.IsEmpty) {
  829.                 WriteAttribute("base", "", o.BaseTypeName);
  830.             }
  831.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  832.             Write9_XmlSchemaSimpleType((XmlSchemaSimpleType)o.BaseType);
  833.             WriteFacets(o.Facets);
  834.             WriteSortedItems(o.Attributes);
  835.             Write33_XmlSchemaAnyAttribute((XmlSchemaAnyAttribute)o.AnyAttribute);
  836.             WriteEndElement();
  837.         }
  838.        
  839.         void Write41_XmlSchemaComplexContent(XmlSchemaComplexContent o)
  840.         {
  841.             if ((object)o == null)
  842.                 return;
  843.             WriteStartElement("complexContent");
  844.            
  845.             WriteAttribute("id", "", ((string)o.Id));
  846.             WriteAttribute("mixed", "", XmlConvert.ToString((bool)((bool)o.IsMixed)));
  847.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  848.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  849.             if (o.Content is XmlSchemaComplexContentRestriction) {
  850.                 Write56_XmlSchemaComplexContentRestriction((XmlSchemaComplexContentRestriction)o.Content);
  851.             }
  852.             else if (o.Content is XmlSchemaComplexContentExtension) {
  853.                 Write42_XmlSchemaComplexContentExtension((XmlSchemaComplexContentExtension)o.Content);
  854.             }
  855.             WriteEndElement();
  856.         }
  857.        
  858.         void Write42_XmlSchemaComplexContentExtension(XmlSchemaComplexContentExtension o)
  859.         {
  860.             if ((object)o == null)
  861.                 return;
  862.             WriteStartElement("extension");
  863.            
  864.             WriteAttribute("id", "", ((string)o.Id));
  865.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  866.             if (!o.BaseTypeName.IsEmpty) {
  867.                 WriteAttribute("base", "", o.BaseTypeName);
  868.             }
  869.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  870.             if (o.Particle is XmlSchemaSequence) {
  871.                 Write54_XmlSchemaSequence((XmlSchemaSequence)o.Particle);
  872.             }
  873.             else if (o.Particle is XmlSchemaGroupRef) {
  874.                 Write55_XmlSchemaGroupRef((XmlSchemaGroupRef)o.Particle);
  875.             }
  876.             else if (o.Particle is XmlSchemaChoice) {
  877.                 Write52_XmlSchemaChoice((XmlSchemaChoice)o.Particle);
  878.             }
  879.             else if (o.Particle is XmlSchemaAll) {
  880.                 Write43_XmlSchemaAll((XmlSchemaAll)o.Particle);
  881.             }
  882.             WriteSortedItems(o.Attributes);
  883.             Write33_XmlSchemaAnyAttribute((XmlSchemaAnyAttribute)o.AnyAttribute);
  884.             WriteEndElement();
  885.         }
  886.        
  887.         void Write43_XmlSchemaAll(XmlSchemaAll o)
  888.         {
  889.             if ((object)o == null)
  890.                 return;
  891.             WriteStartElement("all");
  892.            
  893.             WriteAttribute("id", "", ((string)o.Id));
  894.             WriteAttribute("minOccurs", "", XmlConvert.ToString(o.MinOccurs));
  895.             WriteAttribute("maxOccurs", "", o.MaxOccurs == decimal.MaxValue ? "unbounded" : XmlConvert.ToString(o.MaxOccurs));
  896.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  897.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  898.             WriteSortedItems(o.Items);
  899.             WriteEndElement();
  900.         }
  901.        
  902.         void Write46_XmlSchemaElement(XmlSchemaElement o)
  903.         {
  904.             if ((object)o == null)
  905.                 return;
  906.             System.Type t = o.GetType();
  907.             WriteStartElement("element");
  908.             WriteAttribute("id", "", o.Id);
  909.             WriteAttribute("minOccurs", "", XmlConvert.ToString(o.MinOccurs));
  910.             WriteAttribute("maxOccurs", "", o.MaxOccurs == decimal.MaxValue ? "unbounded" : XmlConvert.ToString(o.MaxOccurs));
  911.             if (((bool)o.IsAbstract) != false) {
  912.                 WriteAttribute("abstract", "", XmlConvert.ToString((bool)((bool)o.IsAbstract)));
  913.             }
  914.             WriteAttribute("block", "", Write11_XmlSchemaDerivationMethod(o.BlockResolved));
  915.             WriteAttribute("default", "", o.DefaultValue);
  916.             WriteAttribute("final", "", Write11_XmlSchemaDerivationMethod(o.FinalResolved));
  917.             WriteAttribute("fixed", "", o.FixedValue);
  918.             if (o.Parent != null && !(o.Parent is XmlSchema)) {
  919.                 if (o.QualifiedName != null && !o.QualifiedName.IsEmpty && o.QualifiedName.Namespace != null && o.QualifiedName.Namespace.Length != 0) {
  920.                     WriteAttribute("form", "", "qualified");
  921.                 }
  922.                 else {
  923.                     WriteAttribute("form", "", "unqualified");
  924.                 }
  925.             }
  926.             if (o.Name != null && o.Name.Length != 0) {
  927.                 WriteAttribute("name", "", o.Name);
  928.             }
  929.             if (o.IsNillable) {
  930.                 WriteAttribute("nillable", "", XmlConvert.ToString(o.IsNillable));
  931.             }
  932.             if (!o.SubstitutionGroup.IsEmpty) {
  933.                 WriteAttribute("substitutionGroup", "", o.SubstitutionGroup);
  934.             }
  935.             if (!o.RefName.IsEmpty) {
  936.                 WriteAttribute("ref", "", o.RefName);
  937.             }
  938.             else if (!o.SchemaTypeName.IsEmpty) {
  939.                 WriteAttribute("type", "", o.SchemaTypeName);
  940.             }
  941.            
  942.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  943.             Write5_XmlSchemaAnnotation(o.Annotation);
  944.             if (o.SchemaType is XmlSchemaComplexType) {
  945.                 Write35_XmlSchemaComplexType((XmlSchemaComplexType)o.SchemaType);
  946.             }
  947.             else if (o.SchemaType is XmlSchemaSimpleType) {
  948.                 Write9_XmlSchemaSimpleType((XmlSchemaSimpleType)o.SchemaType);
  949.             }
  950.             WriteSortedItems(o.Constraints);
  951.             WriteEndElement();
  952.         }
  953.        
  954.         void Write47_XmlSchemaKey(XmlSchemaKey o)
  955.         {
  956.             if ((object)o == null)
  957.                 return;
  958.             System.Type t = o.GetType();
  959.             WriteStartElement("key");
  960.             WriteAttribute("id", "", ((string)o.Id));
  961.             WriteAttribute("name", "", ((string)o.Name));
  962.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  963.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  964.             Write49_XmlSchemaXPath("selector", "", (XmlSchemaXPath)o.Selector);
  965.             {
  966.                 XmlSchemaObjectCollection a = (XmlSchemaObjectCollection)o.Fields;
  967.                 if (a != null) {
  968.                     for (int ia = 0; ia < a.Count; ia++) {
  969.                         Write49_XmlSchemaXPath("field", "", (XmlSchemaXPath)a[ia]);
  970.                     }
  971.                 }
  972.             }
  973.             WriteEndElement();
  974.         }
  975.        
  976.         void Write48_XmlSchemaIdentityConstraint(XmlSchemaIdentityConstraint o)
  977.         {
  978.             if ((object)o == null)
  979.                 return;
  980.             System.Type t = o.GetType();
  981.             if (t == typeof(XmlSchemaUnique)) {
  982.                 Write51_XmlSchemaUnique((XmlSchemaUnique)o);
  983.                 return;
  984.             }
  985.             else if (t == typeof(XmlSchemaKeyref)) {
  986.                 Write50_XmlSchemaKeyref((XmlSchemaKeyref)o);
  987.                 return;
  988.             }
  989.             else if (t == typeof(XmlSchemaKey)) {
  990.                 Write47_XmlSchemaKey((XmlSchemaKey)o);
  991.                 return;
  992.             }
  993.         }
  994.        
  995.         void Write49_XmlSchemaXPath(string name, string ns, XmlSchemaXPath o)
  996.         {
  997.             if ((object)o == null)
  998.                 return;
  999.             WriteStartElement(name);
  1000.             WriteAttribute("id", "", o.Id);
  1001.             WriteAttribute("xpath", "", o.XPath);
  1002.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  1003.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  1004.             WriteEndElement();
  1005.         }
  1006.        
  1007.         void Write50_XmlSchemaKeyref(XmlSchemaKeyref o)
  1008.         {
  1009.             if ((object)o == null)
  1010.                 return;
  1011.             System.Type t = o.GetType();
  1012.             WriteStartElement("keyref");
  1013.            
  1014.             WriteAttribute("id", "", ((string)o.Id));
  1015.             WriteAttribute("name", "", ((string)o.Name));
  1016.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  1017.             WriteAttribute("refer", "", o.Refer);
  1018.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  1019.             Write49_XmlSchemaXPath("selector", "", (XmlSchemaXPath)o.Selector);
  1020.             {
  1021.                 XmlSchemaObjectCollection a = (XmlSchemaObjectCollection)o.Fields;
  1022.                 if (a != null) {
  1023.                     for (int ia = 0; ia < a.Count; ia++) {
  1024.                         Write49_XmlSchemaXPath("field", "", (XmlSchemaXPath)a[ia]);
  1025.                     }
  1026.                 }
  1027.             }
  1028.             WriteEndElement();
  1029.         }
  1030.        
  1031.         void Write51_XmlSchemaUnique(XmlSchemaUnique o)
  1032.         {
  1033.             if ((object)o == null)
  1034.                 return;
  1035.             System.Type t = o.GetType();
  1036.             WriteStartElement("unique");
  1037.            
  1038.             WriteAttribute("id", "", ((string)o.Id));
  1039.             WriteAttribute("name", "", ((string)o.Name));
  1040.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  1041.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  1042.             Write49_XmlSchemaXPath("selector", "", (XmlSchemaXPath)o.Selector);
  1043.             XmlSchemaObjectCollection a = (XmlSchemaObjectCollection)o.Fields;
  1044.             if (a != null) {
  1045.                 for (int ia = 0; ia < a.Count; ia++) {
  1046.                     Write49_XmlSchemaXPath("field", "", (XmlSchemaXPath)a[ia]);
  1047.                 }
  1048.             }
  1049.             WriteEndElement();
  1050.         }
  1051.        
  1052.         void Write52_XmlSchemaChoice(XmlSchemaChoice o)
  1053.         {
  1054.             if ((object)o == null)
  1055.                 return;
  1056.             System.Type t = o.GetType();
  1057.             WriteStartElement("choice");
  1058.            
  1059.             WriteAttribute("id", "", ((string)o.Id));
  1060.             WriteAttribute("minOccurs", "", XmlConvert.ToString(o.MinOccurs));
  1061.             WriteAttribute("maxOccurs", "", o.MaxOccurs == decimal.MaxValue ? "unbounded" : XmlConvert.ToString(o.MaxOccurs));
  1062.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  1063.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  1064.             WriteSortedItems(o.Items);
  1065.             WriteEndElement();
  1066.         }
  1067.        
  1068.         void Write53_XmlSchemaAny(XmlSchemaAny o)
  1069.         {
  1070.             if ((object)o == null)
  1071.                 return;
  1072.             WriteStartElement("any");
  1073.            
  1074.             WriteAttribute("id", "", o.Id);
  1075.             WriteAttribute("minOccurs", "", XmlConvert.ToString(o.MinOccurs));
  1076.             WriteAttribute("maxOccurs", "", o.MaxOccurs == decimal.MaxValue ? "unbounded" : XmlConvert.ToString(o.MaxOccurs));
  1077.             WriteAttribute("namespace", "", ToString(o.NamespaceList));
  1078.             XmlSchemaContentProcessing process = o.ProcessContents == XmlSchemaContentProcessing.None ? XmlSchemaContentProcessing.Strict : o.ProcessContents;
  1079.             WriteAttribute("processContents", "", Write34_XmlSchemaContentProcessing(process));
  1080.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  1081.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  1082.             WriteEndElement();
  1083.         }
  1084.        
  1085.         void Write54_XmlSchemaSequence(XmlSchemaSequence o)
  1086.         {
  1087.             if ((object)o == null)
  1088.                 return;
  1089.             WriteStartElement("sequence");
  1090.            
  1091.             WriteAttribute("id", "", ((string)o.Id));
  1092.             WriteAttribute("minOccurs", "", XmlConvert.ToString(o.MinOccurs));
  1093.             WriteAttribute("maxOccurs", "", o.MaxOccurs == decimal.MaxValue ? "unbounded" : XmlConvert.ToString(o.MaxOccurs));
  1094.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  1095.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  1096.             XmlSchemaObjectCollection a = (XmlSchemaObjectCollection)o.Items;
  1097.             if (a != null) {
  1098.                 for (int ia = 0; ia < a.Count; ia++) {
  1099.                     XmlSchemaObject ai = (XmlSchemaObject)a[ia];
  1100.                     if (ai is XmlSchemaAny) {
  1101.                         Write53_XmlSchemaAny((XmlSchemaAny)ai);
  1102.                     }
  1103.                     else if (ai is XmlSchemaSequence) {
  1104.                         Write54_XmlSchemaSequence((XmlSchemaSequence)ai);
  1105.                     }
  1106.                     else if (ai is XmlSchemaChoice) {
  1107.                         Write52_XmlSchemaChoice((XmlSchemaChoice)ai);
  1108.                     }
  1109.                     else if (ai is XmlSchemaElement) {
  1110.                         Write46_XmlSchemaElement((XmlSchemaElement)ai);
  1111.                     }
  1112.                     else if (ai is XmlSchemaGroupRef) {
  1113.                         Write55_XmlSchemaGroupRef((XmlSchemaGroupRef)ai);
  1114.                     }
  1115.                 }
  1116.             }
  1117.             WriteEndElement();
  1118.         }
  1119.        
  1120.         void Write55_XmlSchemaGroupRef(XmlSchemaGroupRef o)
  1121.         {
  1122.             if ((object)o == null)
  1123.                 return;
  1124.             WriteStartElement("group");
  1125.            
  1126.             WriteAttribute("id", "", ((string)o.Id));
  1127.             WriteAttribute("minOccurs", "", XmlConvert.ToString(o.MinOccurs));
  1128.             WriteAttribute("maxOccurs", "", o.MaxOccurs == decimal.MaxValue ? "unbounded" : XmlConvert.ToString(o.MaxOccurs));
  1129.            
  1130.             if (!o.RefName.IsEmpty) {
  1131.                 WriteAttribute("ref", "", o.RefName);
  1132.             }
  1133.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  1134.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  1135.             WriteEndElement();
  1136.         }
  1137.        
  1138.         void Write56_XmlSchemaComplexContentRestriction(XmlSchemaComplexContentRestriction o)
  1139.         {
  1140.             if ((object)o == null)
  1141.                 return;
  1142.             WriteStartElement("restriction");
  1143.            
  1144.             WriteAttribute("id", "", ((string)o.Id));
  1145.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  1146.            
  1147.             if (!o.BaseTypeName.IsEmpty) {
  1148.                 WriteAttribute("base", "", o.BaseTypeName);
  1149.             }
  1150.            
  1151.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  1152.             if (o.Particle is XmlSchemaSequence) {
  1153.                 Write54_XmlSchemaSequence((XmlSchemaSequence)o.Particle);
  1154.             }
  1155.             else if (o.Particle is XmlSchemaGroupRef) {
  1156.                 Write55_XmlSchemaGroupRef((XmlSchemaGroupRef)o.Particle);
  1157.             }
  1158.             else if (o.Particle is XmlSchemaChoice) {
  1159.                 Write52_XmlSchemaChoice((XmlSchemaChoice)o.Particle);
  1160.             }
  1161.             else if (o.Particle is XmlSchemaAll) {
  1162.                 Write43_XmlSchemaAll((XmlSchemaAll)o.Particle);
  1163.             }
  1164.             WriteSortedItems(o.Attributes);
  1165.             Write33_XmlSchemaAnyAttribute((XmlSchemaAnyAttribute)o.AnyAttribute);
  1166.             WriteEndElement();
  1167.         }
  1168.        
  1169.         void Write57_XmlSchemaGroup(XmlSchemaGroup o)
  1170.         {
  1171.             if ((object)o == null)
  1172.                 return;
  1173.             WriteStartElement("group");
  1174.            
  1175.             WriteAttribute("id", "", ((string)o.Id));
  1176.             WriteAttribute("name", "", ((string)o.Name));
  1177.             WriteAttributes((XmlAttribute[])o.UnhandledAttributes, o);
  1178.             Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.Annotation);
  1179.             if (o.Particle is XmlSchemaSequence) {
  1180.                 Write54_XmlSchemaSequence((XmlSchemaSequence)o.Particle);
  1181.             }
  1182.             else if (o.Particle is XmlSchemaChoice) {
  1183.                 Write52_XmlSchemaChoice((XmlSchemaChoice)o.Particle);
  1184.             }
  1185.             else if (o.Particle is XmlSchemaAll) {
  1186.                 Write43_XmlSchemaAll((XmlSchemaAll)o.Particle);
  1187.             }
  1188.             WriteEndElement();
  1189.         }
  1190.     }
  1191. }

Developer Fusion