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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlSchemaComplexType.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. // <owner current="true" primary="true">priyal</owner>
  15. //------------------------------------------------------------------------------
  16. namespace System.Xml.Schema
  17. {
  18.    
  19.     using System.Collections;
  20.     using System.ComponentModel;
  21.     using System.Xml.Serialization;
  22.    
  23.     /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType"]/*' />
  24.     /// <devdoc>
  25.     /// <para>[To be supplied.]</para>
  26.     /// </devdoc>
  27.     public class XmlSchemaComplexType : XmlSchemaType
  28.     {
  29.         XmlSchemaDerivationMethod block = XmlSchemaDerivationMethod.None;
  30.        
  31.         XmlSchemaContentModel contentModel;
  32.         XmlSchemaParticle particle;
  33.         XmlSchemaObjectCollection attributes;
  34.         XmlSchemaAnyAttribute anyAttribute;
  35.        
  36.         XmlSchemaParticle contentTypeParticle = XmlSchemaParticle.Empty;
  37.         XmlSchemaDerivationMethod blockResolved;
  38.         XmlSchemaObjectTable localElements;
  39.         XmlSchemaObjectTable attributeUses;
  40.         XmlSchemaAnyAttribute attributeWildcard;
  41.        
  42.         static XmlSchemaComplexType anyTypeLax;
  43.         static XmlSchemaComplexType anyTypeSkip;
  44.         static XmlSchemaComplexType untypedAnyType;
  45.        
  46.         //additional info for Partial validation
  47.         byte pvFlags;
  48.         const byte wildCardMask = 1;
  49.         const byte dupDeclMask = 2;
  50.         const byte isMixedMask = 4;
  51.         const byte isAbstractMask = 8;
  52.        
  53.         static XmlSchemaComplexType()
  54.         {
  55.             anyTypeLax = CreateAnyType(XmlSchemaContentProcessing.Lax);
  56.             anyTypeSkip = CreateAnyType(XmlSchemaContentProcessing.Skip);
  57.            
  58.             // Create xdt:untypedAny
  59.             untypedAnyType = new XmlSchemaComplexType();
  60.             untypedAnyType.SetQualifiedName(new XmlQualifiedName("untypedAny", XmlReservedNs.NsXQueryDataType));
  61.             untypedAnyType.IsMixed = true;
  62.             untypedAnyType.SetContentTypeParticle(anyTypeLax.ContentTypeParticle);
  63.             untypedAnyType.SetContentType(XmlSchemaContentType.Mixed);
  64.            
  65.             untypedAnyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl();
  66.             untypedAnyType.ElementDecl.SchemaType = untypedAnyType;
  67.             untypedAnyType.ElementDecl.ContentValidator = AnyTypeContentValidator;
  68.            
  69.         }
  70.        
  71.         static XmlSchemaComplexType CreateAnyType(XmlSchemaContentProcessing processContents)
  72.         {
  73.             XmlSchemaComplexType localAnyType = new XmlSchemaComplexType();
  74.             localAnyType.SetQualifiedName(DatatypeImplementation.QnAnyType);
  75.            
  76.             XmlSchemaAny anyElement = new XmlSchemaAny();
  77.             anyElement.MinOccurs = decimal.Zero;
  78.             anyElement.MaxOccurs = decimal.MaxValue;
  79.            
  80.             anyElement.ProcessContents = processContents;
  81.             anyElement.BuildNamespaceList(null);
  82.             XmlSchemaSequence seq = new XmlSchemaSequence();
  83.             seq.Items.Add(anyElement);
  84.            
  85.             localAnyType.SetContentTypeParticle(seq);
  86.             localAnyType.SetContentType(XmlSchemaContentType.Mixed);
  87.            
  88.             localAnyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl();
  89.             localAnyType.ElementDecl.SchemaType = localAnyType;
  90.            
  91.             //Create contentValidator for Any
  92.             ParticleContentValidator contentValidator = new ParticleContentValidator(XmlSchemaContentType.Mixed);
  93.             contentValidator.Start();
  94.             contentValidator.OpenGroup();
  95.             contentValidator.AddNamespaceList(anyElement.NamespaceList, anyElement);
  96.             contentValidator.AddStar();
  97.             contentValidator.CloseGroup();
  98.             ContentValidator anyContentValidator = contentValidator.Finish(true);
  99.             localAnyType.ElementDecl.ContentValidator = anyContentValidator;
  100.            
  101.             XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute();
  102.             anyAttribute.ProcessContents = processContents;
  103.             anyAttribute.BuildNamespaceList(null);
  104.             localAnyType.SetAttributeWildcard(anyAttribute);
  105.             localAnyType.ElementDecl.AnyAttribute = anyAttribute;
  106.             return localAnyType;
  107.         }
  108.        
  109.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.XmlSchemaComplexType"]/*' />
  110.         /// <devdoc>
  111.         /// <para>[To be supplied.]</para>
  112.         /// </devdoc>
  113.         public XmlSchemaComplexType()
  114.         {
  115.         }
  116.        
  117.        
  118.         [XmlIgnore()]
  119.         static internal XmlSchemaComplexType AnyType {
  120.             get { return anyTypeLax; }
  121.         }
  122.        
  123.         [XmlIgnore()]
  124.         static internal XmlSchemaComplexType UntypedAnyType {
  125.             get { return untypedAnyType; }
  126.         }
  127.        
  128.         [XmlIgnore()]
  129.         static internal XmlSchemaComplexType AnyTypeSkip {
  130.             get { return anyTypeSkip; }
  131.         }
  132.        
  133.         static internal ContentValidator AnyTypeContentValidator {
  134.             get { return anyTypeLax.ElementDecl.ContentValidator; }
  135.         }
  136.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.IsAbstract"]/*' />
  137.         /// <devdoc>
  138.         /// <para>[To be supplied.]</para>
  139.         /// </devdoc>
  140.         [XmlAttribute("abstract"), DefaultValue(false)]
  141.         public bool IsAbstract {
  142.             get { return (pvFlags & isAbstractMask) != 0; }
  143.             set {
  144.                 if (value) {
  145.                     pvFlags = (byte)(pvFlags | isAbstractMask);
  146.                 }
  147.                 else {
  148.                     pvFlags = (byte)(pvFlags & ~isAbstractMask);
  149.                 }
  150.             }
  151.         }
  152.        
  153.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.Block"]/*' />
  154.         /// <devdoc>
  155.         /// <para>[To be supplied.]</para>
  156.         /// </devdoc>
  157.         [XmlAttribute("block"), DefaultValue(XmlSchemaDerivationMethod.None)]
  158.         public XmlSchemaDerivationMethod Block {
  159.             get { return block; }
  160.             set { block = value; }
  161.         }
  162.        
  163.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.IsMixed"]/*' />
  164.         /// <devdoc>
  165.         /// <para>[To be supplied.]</para>
  166.         /// </devdoc>
  167.         [XmlAttribute("mixed"), DefaultValue(false)]
  168.         public override bool IsMixed {
  169.             get { return (pvFlags & isMixedMask) != 0; }
  170.             set {
  171.                 if (value) {
  172.                     pvFlags = (byte)(pvFlags | isMixedMask);
  173.                 }
  174.                 else {
  175.                     pvFlags = (byte)(pvFlags & ~isMixedMask);
  176.                 }
  177.             }
  178.         }
  179.        
  180.        
  181.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.ContentModel"]/*' />
  182.         /// <devdoc>
  183.         /// <para>[To be supplied.]</para>
  184.         /// </devdoc>
  185.         [XmlElement("simpleContent", typeof(XmlSchemaSimpleContent)), XmlElement("complexContent", typeof(XmlSchemaComplexContent))]
  186.         public XmlSchemaContentModel ContentModel {
  187.             get { return contentModel; }
  188.             set { contentModel = value; }
  189.         }
  190.        
  191.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.Particle"]/*' />
  192.         /// <devdoc>
  193.         /// <para>[To be supplied.]</para>
  194.         /// </devdoc>
  195.         [XmlElement("group", typeof(XmlSchemaGroupRef)), XmlElement("choice", typeof(XmlSchemaChoice)), XmlElement("all", typeof(XmlSchemaAll)), XmlElement("sequence", typeof(XmlSchemaSequence))]
  196.         public XmlSchemaParticle Particle {
  197.             get { return particle; }
  198.             set { particle = value; }
  199.         }
  200.        
  201.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.Attributes"]/*' />
  202.         /// <devdoc>
  203.         /// <para>[To be supplied.]</para>
  204.         /// </devdoc>
  205.         [XmlElement("attribute", typeof(XmlSchemaAttribute)), XmlElement("attributeGroup", typeof(XmlSchemaAttributeGroupRef))]
  206.         public XmlSchemaObjectCollection Attributes {
  207.             get {
  208.                 if (attributes == null) {
  209.                     attributes = new XmlSchemaObjectCollection();
  210.                 }
  211.                 return attributes;
  212.             }
  213.         }
  214.        
  215.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.AnyAttribute"]/*' />
  216.         /// <devdoc>
  217.         /// <para>[To be supplied.]</para>
  218.         /// </devdoc>
  219.         [XmlElement("anyAttribute")]
  220.         public XmlSchemaAnyAttribute AnyAttribute {
  221.             get { return anyAttribute; }
  222.             set { anyAttribute = value; }
  223.         }
  224.        
  225.        
  226.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.ContentType"]/*' />
  227.         /// <devdoc>
  228.         /// <para>[To be supplied.]</para>
  229.         /// </devdoc>
  230.         [XmlIgnore()]
  231.         public XmlSchemaContentType ContentType {
  232.             get { return SchemaContentType; }
  233.         }
  234.        
  235.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.ContentTypeParticle"]/*' />
  236.         /// <devdoc>
  237.         /// <para>[To be supplied.]</para>
  238.         /// </devdoc>
  239.         [XmlIgnore()]
  240.         public XmlSchemaParticle ContentTypeParticle {
  241.             get { return contentTypeParticle; }
  242.         }
  243.        
  244.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.BlockResolved"]/*' />
  245.         /// <devdoc>
  246.         /// <para>[To be supplied.]</para>
  247.         /// </devdoc>
  248.         [XmlIgnore()]
  249.         public XmlSchemaDerivationMethod BlockResolved {
  250.             get { return blockResolved; }
  251.         }
  252.        
  253.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.AttributeUses"]/*' />
  254.         /// <devdoc>
  255.         /// <para>[To be supplied.]</para>
  256.         /// </devdoc>
  257.         [XmlIgnore()]
  258.         public XmlSchemaObjectTable AttributeUses {
  259.             get {
  260.                 if (attributeUses == null) {
  261.                     attributeUses = new XmlSchemaObjectTable();
  262.                 }
  263.                 return attributeUses;
  264.             }
  265.         }
  266.        
  267.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.AttributeWildcard"]/*' />
  268.         /// <devdoc>
  269.         /// <para>[To be supplied.]</para>
  270.         /// </devdoc>
  271.         [XmlIgnore()]
  272.         public XmlSchemaAnyAttribute AttributeWildcard {
  273.             get { return attributeWildcard; }
  274.         }
  275.        
  276.         /// <include file='doc\XmlSchemaComplexType.uex' path='docs/doc[@for="XmlSchemaComplexType.LocalElements"]/*' />
  277.         /// <devdoc>
  278.         /// <para>[To be supplied.]</para>
  279.         /// </devdoc>
  280.         [XmlIgnore()]
  281.         internal XmlSchemaObjectTable LocalElements {
  282.             get {
  283.                 if (localElements == null) {
  284.                     localElements = new XmlSchemaObjectTable();
  285.                 }
  286.                 return localElements;
  287.             }
  288.         }
  289.        
  290.         internal void SetContentTypeParticle(XmlSchemaParticle value)
  291.         {
  292.             contentTypeParticle = value;
  293.         }
  294.        
  295.         internal void SetBlockResolved(XmlSchemaDerivationMethod value)
  296.         {
  297.             blockResolved = value;
  298.         }
  299.        
  300.         internal void SetAttributeWildcard(XmlSchemaAnyAttribute value)
  301.         {
  302.             attributeWildcard = value;
  303.         }
  304.        
  305.         internal bool HasWildCard {
  306.             get { return (pvFlags & wildCardMask) != 0; }
  307.             set {
  308.                 if (value) {
  309.                     pvFlags = (byte)(pvFlags | wildCardMask);
  310.                 }
  311.                 else {
  312.                     pvFlags = (byte)(pvFlags & ~wildCardMask);
  313.                 }
  314.             }
  315.         }
  316.        
  317.         internal bool HasDuplicateDecls {
  318.             get { return (pvFlags & dupDeclMask) != 0; }
  319.             set {
  320.                 if (value) {
  321.                     pvFlags = (byte)(pvFlags | dupDeclMask);
  322.                 }
  323.                 else {
  324.                     pvFlags = (byte)(pvFlags & ~dupDeclMask);
  325.                 }
  326.             }
  327.         }
  328.        
  329.         internal override XmlQualifiedName DerivedFrom {
  330.             get {
  331.                 if (contentModel == null) {
  332.                     // type derived from anyType
  333.                     return XmlQualifiedName.Empty;
  334.                 }
  335.                 if (contentModel.Content is XmlSchemaComplexContentRestriction)
  336.                     return ((XmlSchemaComplexContentRestriction)contentModel.Content).BaseTypeName;
  337.                 else if (contentModel.Content is XmlSchemaComplexContentExtension)
  338.                     return ((XmlSchemaComplexContentExtension)contentModel.Content).BaseTypeName;
  339.                 else if (contentModel.Content is XmlSchemaSimpleContentRestriction)
  340.                     return ((XmlSchemaSimpleContentRestriction)contentModel.Content).BaseTypeName;
  341.                 else if (contentModel.Content is XmlSchemaSimpleContentExtension)
  342.                     return ((XmlSchemaSimpleContentExtension)contentModel.Content).BaseTypeName;
  343.                 else
  344.                     return XmlQualifiedName.Empty;
  345.             }
  346.         }
  347.        
  348.         internal void SetAttributes(XmlSchemaObjectCollection newAttributes)
  349.         {
  350.             attributes = newAttributes;
  351.         }
  352.        
  353.         internal bool ContainsIdAttribute(bool findAll)
  354.         {
  355.             int idCount = 0;
  356.             foreach (XmlSchemaAttribute attribute in this.AttributeUses.Values) {
  357.                 if (attribute.Use != XmlSchemaUse.Prohibited) {
  358.                     XmlSchemaDatatype datatype = attribute.Datatype;
  359.                     if (datatype != null && datatype.TypeCode == XmlTypeCode.Id) {
  360.                         idCount++;
  361.                         if (idCount > 1) {
  362.                             //two or more attributes is error
  363.                             break;
  364.                         }
  365.                     }
  366.                 }
  367.             }
  368.             return findAll ? (idCount > 1) : (idCount > 0);
  369.         }
  370.        
  371.         internal override XmlSchemaObject Clone()
  372.         {
  373.             XmlSchemaComplexType complexType = (XmlSchemaComplexType)MemberwiseClone();
  374.            
  375.             //Deep clone the QNames as these will be updated on chameleon includes
  376.             if (complexType.ContentModel != null) {
  377.                 //simpleContent or complexContent
  378.                 XmlSchemaSimpleContent simpleContent = complexType.ContentModel as XmlSchemaSimpleContent;
  379.                 if (simpleContent != null) {
  380.                     XmlSchemaSimpleContent newSimpleContent = (XmlSchemaSimpleContent)simpleContent.Clone();
  381.                    
  382.                     XmlSchemaSimpleContentExtension simpleExt = simpleContent.Content as XmlSchemaSimpleContentExtension;
  383.                     if (simpleExt != null) {
  384.                         XmlSchemaSimpleContentExtension newSimpleExt = (XmlSchemaSimpleContentExtension)simpleExt.Clone();
  385.                         newSimpleExt.BaseTypeName = simpleExt.BaseTypeName.Clone();
  386.                         newSimpleExt.SetAttributes(CloneAttributes(simpleExt.Attributes));
  387.                         newSimpleContent.Content = newSimpleExt;
  388.                     }
  389.                     else {
  390.                         //simpleContent.Content is XmlSchemaSimpleContentRestriction
  391.                         XmlSchemaSimpleContentRestriction simpleRest = (XmlSchemaSimpleContentRestriction)simpleContent.Content;
  392.                         XmlSchemaSimpleContentRestriction newSimpleRest = (XmlSchemaSimpleContentRestriction)simpleRest.Clone();
  393.                         newSimpleRest.BaseTypeName = simpleRest.BaseTypeName.Clone();
  394.                         newSimpleRest.SetAttributes(CloneAttributes(simpleRest.Attributes));
  395.                         newSimpleContent.Content = newSimpleRest;
  396.                     }
  397.                    
  398.                     complexType.ContentModel = newSimpleContent;
  399.                 }
  400.                 else {
  401.                     // complexType.ContentModel is XmlSchemaComplexContent
  402.                     XmlSchemaComplexContent complexContent = (XmlSchemaComplexContent)complexType.ContentModel;
  403.                     XmlSchemaComplexContent newComplexContent = (XmlSchemaComplexContent)complexContent.Clone();
  404.                    
  405.                     XmlSchemaComplexContentExtension complexExt = complexContent.Content as XmlSchemaComplexContentExtension;
  406.                     if (complexExt != null) {
  407.                         XmlSchemaComplexContentExtension newComplexExt = (XmlSchemaComplexContentExtension)complexExt.Clone();
  408.                         newComplexExt.BaseTypeName = complexExt.BaseTypeName.Clone();
  409.                         newComplexExt.SetAttributes(CloneAttributes(complexExt.Attributes));
  410.                         if (HasParticleRef(complexExt.Particle)) {
  411.                             newComplexExt.Particle = CloneParticle(complexExt.Particle);
  412.                         }
  413.                         newComplexContent.Content = newComplexExt;
  414.                     }
  415.                     else {
  416.                         // complexContent.Content is XmlSchemaComplexContentRestriction
  417.                         XmlSchemaComplexContentRestriction complexRest = complexContent.Content as XmlSchemaComplexContentRestriction;
  418.                         XmlSchemaComplexContentRestriction newComplexRest = (XmlSchemaComplexContentRestriction)complexRest.Clone();
  419.                         newComplexRest.BaseTypeName = complexRest.BaseTypeName.Clone();
  420.                         newComplexRest.SetAttributes(CloneAttributes(complexRest.Attributes));
  421.                         if (HasParticleRef(newComplexRest.Particle)) {
  422.                             newComplexRest.Particle = CloneParticle(newComplexRest.Particle);
  423.                         }
  424.                         newComplexContent.Content = newComplexRest;
  425.                     }
  426.                     complexType.ContentModel = newComplexContent;
  427.                 }
  428.             }
  429.             else {
  430.                 //equals XmlSchemaComplexContent with baseType is anyType
  431.                 if (HasParticleRef(complexType.Particle)) {
  432.                     complexType.Particle = CloneParticle(complexType.Particle);
  433.                 }
  434.                 complexType.SetAttributes(CloneAttributes(complexType.Attributes));
  435.             }
  436.             complexType.ClearCompiledState();
  437.             return complexType;
  438.         }
  439.        
  440.         private void ClearCompiledState()
  441.         {
  442.             //Re-set post-compiled state for cloned object
  443.             this.attributeUses = null;
  444.             this.localElements = null;
  445.             this.attributeWildcard = null;
  446.             this.contentTypeParticle = XmlSchemaParticle.Empty;
  447.             this.blockResolved = XmlSchemaDerivationMethod.None;
  448.         }
  449.        
  450.         static internal XmlSchemaObjectCollection CloneAttributes(XmlSchemaObjectCollection attributes)
  451.         {
  452.             if (HasAttributeQNameRef(attributes)) {
  453.                 XmlSchemaObjectCollection newAttributes = attributes.Clone();
  454.                 XmlSchemaAttributeGroupRef attributeGroupRef;
  455.                 XmlSchemaAttributeGroupRef newAttGroupRef;
  456.                 XmlSchemaObject xso;
  457.                 XmlSchemaAttribute att;
  458.                
  459.                 for (int i = 0; i < attributes.Count; i++) {
  460.                     xso = attributes[i];
  461.                     attributeGroupRef = xso as XmlSchemaAttributeGroupRef;
  462.                     if (attributeGroupRef != null) {
  463.                         newAttGroupRef = (XmlSchemaAttributeGroupRef)attributeGroupRef.Clone();
  464.                         newAttGroupRef.RefName = attributeGroupRef.RefName.Clone();
  465.                         newAttributes[i] = newAttGroupRef;
  466.                     }
  467.                     else {
  468.                         //Its XmlSchemaAttribute
  469.                         att = xso as XmlSchemaAttribute;
  470.                         if (!att.RefName.IsEmpty || !att.SchemaTypeName.IsEmpty) {
  471.                             newAttributes[i] = att.Clone();
  472.                         }
  473.                     }
  474.                 }
  475.                 return newAttributes;
  476.             }
  477.             return attributes;
  478.         }
  479.        
  480.         private static XmlSchemaObjectCollection CloneGroupBaseParticles(XmlSchemaObjectCollection groupBaseParticles)
  481.         {
  482.             XmlSchemaObjectCollection newParticles = groupBaseParticles.Clone();
  483.            
  484.             for (int i = 0; i < groupBaseParticles.Count; i++) {
  485.                 XmlSchemaParticle p = (XmlSchemaParticle)groupBaseParticles[i];
  486.                 newParticles[i] = CloneParticle(p);
  487.             }
  488.             return newParticles;
  489.         }
  490.        
  491.         static internal XmlSchemaParticle CloneParticle(XmlSchemaParticle particle)
  492.         {
  493.             XmlSchemaGroupBase groupBase = particle as XmlSchemaGroupBase;
  494.             if (groupBase != null && !(groupBase is XmlSchemaAll)) {
  495.                 //Choice or sequence
  496.                 XmlSchemaGroupBase newGroupBase = groupBase;
  497.                
  498.                 XmlSchemaObjectCollection newGroupbaseParticles = CloneGroupBaseParticles(groupBase.Items);
  499.                 newGroupBase = (XmlSchemaGroupBase)groupBase.Clone();
  500.                 newGroupBase.SetItems(newGroupbaseParticles);
  501.                 return newGroupBase;
  502.             }
  503.             else if (particle is XmlSchemaGroupRef) {
  504.                 // group ref
  505.                 XmlSchemaGroupRef newGroupRef = (XmlSchemaGroupRef)particle.Clone();
  506.                 newGroupRef.RefName = newGroupRef.RefName.Clone();
  507.                 return newGroupRef;
  508.             }
  509.             else {
  510.                 XmlSchemaElement oldElem = particle as XmlSchemaElement;
  511.                 if (oldElem != null && (!oldElem.RefName.IsEmpty || !oldElem.SchemaTypeName.IsEmpty)) {
  512.                     //Its element ref or type name is present
  513.                     XmlSchemaElement newElem = (XmlSchemaElement)oldElem.Clone();
  514.                     return newElem;
  515.                 }
  516.             }
  517.             return particle;
  518.         }
  519.        
  520.         static internal bool HasParticleRef(XmlSchemaParticle particle)
  521.         {
  522.             XmlSchemaGroupBase groupBase = particle as XmlSchemaGroupBase;
  523.             if (groupBase != null && !(groupBase is XmlSchemaAll)) {
  524.                 bool foundRef = false;
  525.                 int i = 0;
  526.                 while (i < groupBase.Items.Count && !foundRef) {
  527.                     XmlSchemaParticle p = (XmlSchemaParticle)groupBase.Items[i++];
  528.                     if (p is XmlSchemaGroupRef) {
  529.                         foundRef = true;
  530.                     }
  531.                     else {
  532.                         XmlSchemaElement elem = p as XmlSchemaElement;
  533.                         if (elem != null && (!elem.RefName.IsEmpty || !elem.SchemaTypeName.IsEmpty)) {
  534.                             foundRef = true;
  535.                         }
  536.                         else {
  537.                             foundRef = HasParticleRef(p);
  538.                         }
  539.                     }
  540.                 }
  541.                 return foundRef;
  542.             }
  543.             else if (particle is XmlSchemaGroupRef) {
  544.                 return true;
  545.             }
  546.             return false;
  547.         }
  548.        
  549.         static internal bool HasAttributeQNameRef(XmlSchemaObjectCollection attributes)
  550.         {
  551.             foreach (XmlSchemaObject xso in attributes) {
  552.                 if (xso is XmlSchemaAttributeGroupRef) {
  553.                     return true;
  554.                 }
  555.                 else {
  556.                     XmlSchemaAttribute attribute = xso as XmlSchemaAttribute;
  557.                     if (!attribute.RefName.IsEmpty || !attribute.SchemaTypeName.IsEmpty) {
  558.                         return true;
  559.                     }
  560.                 }
  561.             }
  562.             return false;
  563.         }
  564.     }
  565.    
  566. }

Developer Fusion