Ejemplo n.º 1
0
        private List <XmlSchemaElement> GetAllSchemaElements(XmlSchemaParticle particule)
        {
            if (particule is XmlSchemaSequence)
            {
                return(GetAllSchemaElements((particule as XmlSchemaSequence).Items));
            }
            else if (particule is XmlSchemaChoice)
            {
                return(GetAllSchemaElements((particule as XmlSchemaChoice).Items));
            }

            return(null);
        }
Ejemplo n.º 2
0
        private void BuildProperties(XmlSchemaElement parentElement, XmlSchemaType schemaType, ClrContentTypeInfo typeInfo)
        {
            XmlSchemaComplexType ct = schemaType as XmlSchemaComplexType;

            if (ct != null)
            {
                if (ct.TypeCode == XmlTypeCode.Item)
                {
                    return;
                }
                XmlSchemaParticle    particleToProperties = ct.ContentTypeParticle;
                XmlSchemaComplexType baseType             = ct.BaseXmlSchemaType as XmlSchemaComplexType;
                if (schemaType.GetContentType() == XmlSchemaContentType.TextOnly)
                {
                    //Try to create a text property for the simple content
                    ClrPropertyInfo property = BuildComplexTypeTextProperty(parentElement, ct);
                    if (property != null)
                    {
                        typeInfo.AddMember(property);
                    }
                    if (baseType == null)
                    { //Derived from Simple type, first step simpleContent extension
                        TraverseAttributes(ct.AttributeUses, typeInfo);
                    }
                    else
                    {                                     //Derived from another complex type simple content, generate the content only if there are additional restrictions
                        if (!ct.IsDerivedByRestriction()) //process attributes only if not derived by restriction
                        {
                            TraverseAttributes(ct.AttributeUses, baseType.AttributeUses, typeInfo);
                        }
                    }
                }
                else
                {
                    Debug.Assert(baseType != null); //ComplexType with complexContent is always derived from another complexType
                    if (ct.IsDerivedByRestriction())
                    {                               //Do not handle restrictions on complex content?
                        return;
                    }
                    if (particleToProperties.GetParticleType() != ParticleType.Empty)
                    {
                        TraverseParticle(particleToProperties, baseType, typeInfo, ct.DerivedBy);
                    }
                    TraverseAttributes(ct.AttributeUses, baseType.AttributeUses, typeInfo);
                }
            }
            else
            {
                typeInfo.AddMember(BuildSimpleTypeTextProperty(parentElement, schemaType as XmlSchemaSimpleType));
            }
        }
Ejemplo n.º 3
0
        public override void GetExpectedParticles(ArrayList al)
        {
            // if not started, then just collect all items from seq.
            if (currentAutomata == null)
            {
                foreach (XmlSchemaParticle p in seq.CompiledItems)
                {
                    al.Add(p);
                    if (!p.ValidateIsEmptiable())
                    {
                        break;
                    }
                }
                return;
            }

            // automata for ongoing iteration
            if (currentAutomata != null)
            {
                currentAutomata.GetExpectedParticles(al);
                if (!currentAutomata.EvaluateIsEmptiable())
                {
                    return;
                }

                // remaining items after currentAutomata
                for (int i = current + 1; i < seq.CompiledItems.Count; i++)
                {
                    XmlSchemaParticle p = seq.CompiledItems [i] as XmlSchemaParticle;
                    al.Add(p);
                    if (!p.ValidateIsEmptiable())
                    {
                        break;
                    }
                }
            }

            // itself
            if (Occured + 1 == seq.ValidatedMaxOccurs)
            {
                return;
            }

            {
                for (int i = 0; i <= current; i++)
                {
                    al.Add(seq.CompiledItems [i]);
                }
            }
        }
Ejemplo n.º 4
0
        private void GetProperties(XmlSchema xmlSchema, string elementname)
        {
            foreach (object xItem in xmlSchema.SchemaTypes.Values)
            {
                XmlSchemaComplexType item = xItem as XmlSchemaComplexType;
                #region item
                if (item != null)
                {
                    if (item.Name.Equals(elementname))
                    {
                        XmlSchemaContentModel   model    = item.ContentModel;
                        XmlSchemaComplexContent complex  = model as XmlSchemaComplexContent;
                        SoapClasses             newClass = this.GetClass(elementname);

                        if (complex != null && newClass != null)
                        {
                            XmlSchemaComplexContentExtension extension = complex.Content as XmlSchemaComplexContentExtension;
                            XmlSchemaParticle particle = extension.Particle;
                            XmlSchemaSequence sequence = particle as XmlSchemaSequence;

                            if (extension != null)
                            {
                                newClass.SuperClassType = extension.BaseTypeName.Name;
                            }

                            if (sequence != null)
                            {
                                foreach (XmlSchemaElement childElement in sequence.Items)
                                {
                                    if (newClass != null)
                                    {
                                        SoapClassProperties newProp = new SoapClassProperties(XpoDefault.Session);
                                        newProp.Name = childElement.Name;

                                        newProp.PropertyClassType = childElement.SchemaTypeName.Name;
                                        newProp.IsArray           = childElement.SchemaTypeName.Name.StartsWith("ArrayOf");//.Equals("unbounded"));
                                        newClass.Properties.Add(newProp);
                                    }
                                }
                            }

                            newClass.Save();
                        }
                        return;
                    }
                }
                #endregion
            }
        }
Ejemplo n.º 5
0
        private string getFlags(XmlSchemaParticle particle)
        {
            string flags = "O";

            if (particle.MinOccurs > 0)
            {
                flags = "M";
            }
            if (particle.MaxOccursString == "unbounded")
            {
                flags += "R";
            }

            return(flags);
        }
Ejemplo n.º 6
0
        private void WalkSchemaParticle(List <string> list, XmlSchemaParticle particle)
        {
            if (particle is XmlSchemaElement)
            {
                list.Add(((XmlSchemaElement)particle).Name);
            }
            else if (particle is XmlSchemaGroupBase)
            {
                XmlSchemaGroupBase xsgb = particle as XmlSchemaGroupBase;

                foreach (XmlSchemaParticle p in xsgb.Items)
                {
                    this.WalkSchemaParticle(list, p);
                }
            }
        }
Ejemplo n.º 7
0
        public static bool Contains(this XmlSchemaParticle particle, XmlSchemaParticle childParticle)
        {
            XmlSchemaGroupBase groupBase = particle as XmlSchemaGroupBase;

            if (groupBase != null)
            {
                foreach (XmlSchemaParticle item in groupBase.Items)
                {
                    if (item == childParticle)
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }
Ejemplo n.º 8
0
        public override XsdValidationState EvaluateStartElement(string localName, string ns)
        {
            this.emptiableComputed = false;
            bool flag = true;
            int  i    = 0;

            while (i < this.choice.CompiledItems.Count)
            {
                XmlSchemaParticle  xsobj = (XmlSchemaParticle)this.choice.CompiledItems[i];
                XsdValidationState xsdValidationState  = base.Manager.Create(xsobj);
                XsdValidationState xsdValidationState2 = xsdValidationState.EvaluateStartElement(localName, ns);
                if (xsdValidationState2 != XsdValidationState.Invalid)
                {
                    base.OccuredInternal++;
                    if (base.Occured > this.choice.ValidatedMaxOccurs)
                    {
                        return(XsdValidationState.Invalid);
                    }
                    if (base.Occured == this.choice.ValidatedMaxOccurs)
                    {
                        return(xsdValidationState2);
                    }
                    return(base.Manager.MakeSequence(xsdValidationState2, this));
                }
                else
                {
                    if (!this.emptiableComputed)
                    {
                        flag &= xsdValidationState.EvaluateIsEmptiable();
                    }
                    i++;
                }
            }
            if (!this.emptiableComputed)
            {
                if (flag)
                {
                    this.emptiable = true;
                }
                if (!this.emptiable)
                {
                    this.emptiable = (this.choice.ValidatedMinOccurs <= base.Occured);
                }
                this.emptiableComputed = true;
            }
            return(XsdValidationState.Invalid);
        }
Ejemplo n.º 9
0
 /// <summary>
 /// Gets the child elements of the given XML particle that are eligible to
 /// be the next element in the XML document.
 /// </summary>
 /// <param name="p_xspParticle">The particle whoe children are to be retrieved.</param>
 /// <returns>A list of the child elements of the given XML particle that are eligible to
 /// be the next element in the XML document.</returns>
 private List <KeyValuePair <string, string> > GetChildrenElements(XmlSchemaParticle p_xspParticle)
 {
     if (p_xspParticle is XmlSchemaElement)
     {
         XmlSchemaElement xseElement = (XmlSchemaElement)p_xspParticle;
         return(new List <KeyValuePair <string, string> >()
         {
             new KeyValuePair <string, string>(xseElement.Name, GetDocumentation(xseElement))
         });
     }
     else if (p_xspParticle is XmlSchemaSequence)
     {
         XmlSchemaSequence xssSequence = (XmlSchemaSequence)p_xspParticle;
         List <KeyValuePair <string, string> > lstChoices = new List <KeyValuePair <string, string> >();
         foreach (XmlSchemaParticle xspParticle in xssSequence.Items)
         {
             lstChoices.AddRange(GetChildrenElements(xspParticle));
             if (xspParticle.MinOccurs > 0)
             {
                 break;
             }
         }
         return(lstChoices);
     }
     else if (p_xspParticle is XmlSchemaChoice)
     {
         XmlSchemaChoice xscChoice = (XmlSchemaChoice)p_xspParticle;
         List <KeyValuePair <string, string> > lstChoices = new List <KeyValuePair <string, string> >();
         foreach (XmlSchemaParticle xspParticle in xscChoice.Items)
         {
             lstChoices.AddRange(GetChildrenElements(xspParticle));
         }
         return(lstChoices);
     }
     else if (p_xspParticle is XmlSchemaAll)
     {
         XmlSchemaAll xsaAll = (XmlSchemaAll)p_xspParticle;
         List <KeyValuePair <string, string> > lstChoices = new List <KeyValuePair <string, string> >();
         foreach (XmlSchemaParticle xspParticle in xsaAll.Items)
         {
             lstChoices.AddRange(GetChildrenElements(xspParticle));
         }
         return(lstChoices);
     }
     return(null);
 }
Ejemplo n.º 10
0
        public static IEnumerable <XmlSchemaElement> GetAlternativesFromParticle(XmlSchemaParticle particle)
        {
            if (particle is XmlSchemaElement)
            {
                yield return(particle as XmlSchemaElement);

                yield break;
            }

            XmlSchemaParticle result;

            XmlSchemaSequence seq = particle as XmlSchemaSequence;

            if (seq != null)
            {
                foreach (XmlSchemaObject o in seq.Items)
                {
                    result = o as XmlSchemaParticle;
                    if (result != null)
                    {
                        foreach (XmlSchemaElement el in GetAlternativesFromParticle(result))
                        {
                            yield return(el);
                        }
                    }
                }
            }

            XmlSchemaChoice ch = particle as XmlSchemaChoice;

            if (ch != null)
            {
                foreach (XmlSchemaObject a in ch.Items)
                {
                    result = a as XmlSchemaParticle;
                    if (result != null)
                    {
                        foreach (XmlSchemaElement el2 in GetAlternativesFromParticle(result))
                        {
                            yield return(el2);
                        }
                    }
                }
            }
        }
Ejemplo n.º 11
0
        public override XsdValidationState EvaluateStartElement(string localName, string ns)
        {
            emptiableComputed = false;
            bool allChildrenEmptiable = true;

            for (int i = 0; i < choice.CompiledItems.Count; i++)
            {
                XmlSchemaParticle  xsobj  = (XmlSchemaParticle)choice.CompiledItems [i];
                XsdValidationState xa     = Manager.Create(xsobj);
                XsdValidationState result = xa.EvaluateStartElement(localName, ns);
                if (result != XsdValidationState.Invalid)
                {
                    OccuredInternal++;
                    if (Occured > choice.ValidatedMaxOccurs)
                    {
                        return(XsdValidationState.Invalid);
                    }
                    else if (Occured == choice.ValidatedMaxOccurs)
                    {
                        return(result);
                    }
                    else
                    {
                        return(Manager.MakeSequence(result, this));
                    }
                }
                if (!emptiableComputed)
                {
                    allChildrenEmptiable &= xa.EvaluateIsEmptiable();
                }
            }
            if (!emptiableComputed)
            {
                if (allChildrenEmptiable)
                {
                    emptiable = true;
                }
                if (!emptiable)
                {
                    emptiable = choice.ValidatedMinOccurs <= Occured;
                }
                emptiableComputed = true;
            }
            return(XsdValidationState.Invalid);
        }
        private Occurs GetOccurence(XmlSchemaParticle particle)
        {
            Occurs occur;

            if (particle.MinOccurs == new decimal(1))
            {
                occur = (!(particle.MaxOccurs == new decimal(1)) ? Occurs.OneOrMore : Occurs.One);
            }
            else if (!(particle.MinOccurs == new decimal(0)))
            {
                Debug.Assert(particle.MinOccurs > new decimal(1));
                occur = Occurs.OneOrMore;
            }
            else
            {
                occur = (!(particle.MaxOccurs == new decimal(1)) ? Occurs.ZeroOrMore : Occurs.ZeroOrOne);
            }
            return(occur);
        }
        private void BuildProperties(XmlSchemaElement parentElement, XmlSchemaType schemaType, ClrContentTypeInfo typeInfo)
        {
            XmlSchemaComplexType ct = schemaType as XmlSchemaComplexType;

            if (ct == null)
            {
                typeInfo.AddMember(this.BuildSimpleTypeTextProperty(parentElement, schemaType as XmlSchemaSimpleType));
            }
            else if (ct.TypeCode != XmlTypeCode.Item)
            {
                XmlSchemaParticle    particleToProperties = ct.ContentTypeParticle;
                XmlSchemaComplexType baseType             = ct.BaseXmlSchemaType as XmlSchemaComplexType;
                if (schemaType.GetContentType() != XmlSchemaContentType.TextOnly)
                {
                    Debug.Assert(baseType != null);
                    if (ct.IsDerivedByRestriction())
                    {
                        return;
                    }
                    if (particleToProperties.GetParticleType() != ParticleType.Empty)
                    {
                        this.TraverseParticle(particleToProperties, baseType, typeInfo, ct.DerivedBy);
                    }
                    this.TraverseAttributes(ct.AttributeUses, baseType.AttributeUses, typeInfo);
                }
                else
                {
                    ClrPropertyInfo property = this.BuildComplexTypeTextProperty(parentElement, ct);
                    if (property != null)
                    {
                        typeInfo.AddMember(property);
                    }
                    if (baseType == null)
                    {
                        this.TraverseAttributes(ct.AttributeUses, typeInfo);
                    }
                    else if (!ct.IsDerivedByRestriction())
                    {
                        this.TraverseAttributes(ct.AttributeUses, baseType.AttributeUses, typeInfo);
                    }
                }
            }
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Finds the element specified in the given stack, starting from the given XML particle.
        /// </summary>
        /// <param name="p_xspParticle">The particle at which to being the search.</param>
        /// <param name="p_stkCode">A stack describing a path to an XML element.</param>
        /// <returns>The element specified by the given stack, or <c>null</c> if no such
        /// element could be found.</returns>
        private XmlSchemaElement findElement(XmlSchemaParticle p_xspParticle, Stack <string> p_stkCode)
        {
            if (p_xspParticle is XmlSchemaElement)
            {
                XmlSchemaElement xseElement = (XmlSchemaElement)p_xspParticle;
                if (p_stkCode.Peek().Equals(xseElement.Name))
                {
                    p_stkCode.Pop();
                    if (p_stkCode.Count == 0)
                    {
                        return(xseElement);
                    }

                    if (xseElement.ElementSchemaType is XmlSchemaComplexType)
                    {
                        XmlSchemaComplexType xctElement = (XmlSchemaComplexType)xseElement.ElementSchemaType;
                        if (xctElement.ContentTypeParticle != null)
                        {
                            return(findElement(xctElement.ContentTypeParticle, p_stkCode));
                        }
                    }
                    //if this isn't a complex type, then this element has no children,
                    // so if this isn't the element we are looking for, we are looking
                    // in the wrong part of the schema tree.
                }
            }
            else if (p_xspParticle is XmlSchemaGroupBase)
            {
                //this handle sequences, choices, and all
                XmlSchemaGroupBase xbsGroup   = (XmlSchemaGroupBase)p_xspParticle;
                XmlSchemaElement   xseElement = null;
                foreach (XmlSchemaParticle xspParticle in xbsGroup.Items)
                {
                    xseElement = findElement(xspParticle, p_stkCode);
                    if (xseElement != null)
                    {
                        return(xseElement);
                    }
                }
            }

            return(null);
        }
Ejemplo n.º 15
0
 private static void TraverseParticle(XmlSchemaParticle particle, ArrayList elementDeclsInContentModel)
 {
     if (particle is XmlSchemaElement)
     {
         XmlSchemaElement value = particle as XmlSchemaElement;
         elementDeclsInContentModel.Add(value);
     }
     else if (particle is XmlSchemaGroupBase)
     {
         foreach (XmlSchemaParticle item in (particle as XmlSchemaGroupBase).Items)
         {
             TraverseParticle(item, elementDeclsInContentModel);
         }
     }
     else if (particle is XmlSchemaAny)
     {
         m_processContent = (particle as XmlSchemaAny).ProcessContents;
     }
 }
        public static bool Contains(this XmlSchemaParticle particle, XmlSchemaParticle childParticle)
        {
            bool flag;
            XmlSchemaGroupBase groupBase = particle as XmlSchemaGroupBase;

            if (groupBase != null)
            {
                foreach (XmlSchemaParticle item in groupBase.Items)
                {
                    if (item == childParticle)
                    {
                        flag = true;
                        return(flag);
                    }
                }
            }
            flag = false;
            return(flag);
        }
Ejemplo n.º 17
0
        /*void Start()
         * {
         *  XmlSchemaComplexType complexType;
         *  foreach (XmlSchemaType type in xs.SchemaTypes.Values)
         *  {
         *      complexType = type as XmlSchemaComplexType;
         *      if (complexType != null)
         *          TraverseParticle(complexType.ContentTypeParticle);
         *  }
         *
         *  foreach (XmlSchemaElement el in xs.Elements.Values)
         *      TraverseParticle(el);
         * }*/

        void TraverseParticle(XmlSchemaParticle particle, string paramElementName)
        {
            if (particle != null)
            {
                if (particle is XmlSchemaSequence)
                {
                    XmlSchemaSequence seqxml = particle as XmlSchemaSequence;
                    foreach (object obj in seqxml.Items)
                    {
                        if (obj is XmlSchemaElement)
                        {
                            XmlSchemaElement elem = obj as XmlSchemaElement;
                            string           name = elem.Name;
                            if (elem.SchemaTypeName != null && !string.IsNullOrEmpty(elem.SchemaTypeName.Name))
                            {
                                parameterMappings[paramElementName].Add(name, elem.SchemaTypeName.Name);
                            }
                        }
                    }
                }
                if (particle is XmlSchemaElement)
                {
                    XmlSchemaElement elem = particle as XmlSchemaElement;

                    if (elem.RefName.IsEmpty)
                    {
                        XmlSchemaType        type        = (XmlSchemaType)elem.ElementSchemaType;
                        XmlSchemaComplexType complexType = type as XmlSchemaComplexType;
                        if (complexType != null && complexType.Name == null)
                        {
                            TraverseParticle(complexType.ContentTypeParticle, null);
                        }
                    }
                }
                else if (particle is XmlSchemaGroupBase)
                {
                    //xs:all, xs:choice, xs:sequence
                    //XmlSchemaGroupBase baseParticle = particle as XmlSchemaGroupBase;
                    //foreach (XmlSchemaParticle subParticle in baseParticle.Items)
                    //TraverseParticle(subParticle,null);
                }
            }
        }
 private static void TraverseParticle(XmlSchemaParticle particle, ArrayList elementDeclsInContentModel)
 {
     if (particle is XmlSchemaElement)
     {
         XmlSchemaElement value = particle as XmlSchemaElement;
         elementDeclsInContentModel.Add(value);
     }
     else
     {
         if (!(particle is XmlSchemaGroupBase))
         {
             return;
         }
         foreach (XmlSchemaParticle item in (particle as XmlSchemaGroupBase).Items)
         {
             TraverseParticle(item, elementDeclsInContentModel);
         }
     }
 }
        public SQLSchema(string XMLSchemaPath, bool identity, bool includeFileId = false)
        {
            //Store whether we are including a file id
            IncludeFileId = includeFileId;
            Identity      = identity;

            //If required, create a table to hold the names and ids of multiple files
            if (includeFileId)
            {
                SQLDatabase.DropTable("__File");
                FileTable      = new SQLTable();
                FileTable.Name = "__File";
                FileTable.Columns.Add(new SQLColumn("FileName", new SQLDataType("string", 255), true, false, FileTable));
                FileTable.Schema = this;
                FileTable.Create(false);
            }

            //Load the schema
            XmlSchemaSet ss = new XmlSchemaSet();

            ss.Add(null, XMLSchemaPath);

            //For each schema in the collection - ha, there's only ever one, but how else do you get to the schema collection?
            foreach (XmlSchema schema in ss.Schemas())
            {
                //Get the namespace
                NameSpace = schema.TargetNamespace;

                //Loop through the top-level elements - only be one of these too
                foreach (XmlSchemaElement schemaElement in schema.Elements.Values)
                {
                    //Cast the schema element to a particle
                    XmlSchemaParticle schemaParticle = (XmlSchemaParticle)schemaElement;

                    //Point to the root of the table hierarchy
                    XmlNode node = TableHierarchy;

                    //Recurse through all of the particles in the schema
                    TraverseParticle(schemaParticle, schema, node);
                }
            }
        }
Ejemplo n.º 20
0
        /// <summary>
        ///     Returns the XmlSchemaElement specified by the given qname defined in the given particle.
        /// </summary>
        /// <param name="particle"></param>
        /// <param name="qname"></param>
        /// <returns></returns>
        private XmlSchemaElement GetXmlSchemaElementFromParticle(XmlSchemaParticle particle, XmlQualifiedName qname)
        {
            XmlSchemaElement xe = null;
            var xsgb            = particle as XmlSchemaGroupBase;
            var xsgr            = particle as XmlSchemaGroupRef;

            if (xsgb != null)
            {
                xe = GetXmlElementFromXmlSchemaGroupBase(xsgb, qname);
            }
            else if (xsgr != null)
            {
                xe = GetXmlElementFromXmlSchemaGroupBase(xsgr.Particle, qname);
            }
            else if (particle != null)
            {
                Debug.Fail("Unable to handle case where particle type is " + particle.GetType());
            }
            return(xe);
        }
Ejemplo n.º 21
0
        public static bool ContainsWildCard(this XmlSchemaParticle particle, XmlSchemaAny any)
        {
            XmlSchemaGroupBase groupBase = particle as XmlSchemaGroupBase;

            if (groupBase != null)
            {
                foreach (XmlSchemaParticle p in groupBase.Items)
                {
                    if (p == any)
                    {
                        return(true);
                    }
                    else if (p.ContainsWildCard(any))
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }
Ejemplo n.º 22
0
        public static bool ContainsElement(this XmlSchemaParticle particle, XmlSchemaElement element)
        {
            XmlSchemaGroupBase groupBase = particle as XmlSchemaGroupBase;

            if (groupBase != null)
            {
                foreach (XmlSchemaParticle p in groupBase.Items)
                {
                    if (p == element)
                    {
                        return(true);
                    }
                    else if (p.ContainsElement(element))
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }
Ejemplo n.º 23
0
        internal XSParticle(XmlSchemaParticle particle)
            : this()
        {
            if (!string.IsNullOrEmpty(particle.MinOccursString))
            {
                _minOccurs = ValueFactory.Create(particle.MinOccurs);
            }

            if (particle.MaxOccursString == XS_UNBOUNDED)
            {
                _maxOccurs = ValueFactory.Create(decimal.MinusOne);
            }

            else if (!string.IsNullOrEmpty(particle.MaxOccursString))
            {
                _minOccurs = ValueFactory.Create(particle.MaxOccurs);
            }

            _term = XMLSchemaSerializer.CreateIXSFragment(particle);
        }
Ejemplo n.º 24
0
        private ChildEntry AddLeaf(ChildType childType, XmlSchemaObject parent, XmlSchemaParticle particle)
        {
            if (_childEntryStack.Count == 0)
            {
                var root = new List <ChildEntry>();
                _childEntryStack.Push(root);
            }

            var childEntry = new ChildEntry
            {
                ChildType = childType,
                MinOccurs = particle == null ? 1 : particle.MinOccurs,
                MaxOccurs = particle == null ? 1 : particle.MaxOccurs,
                Particle  = particle,
                Parent    = parent
            };

            _childEntryStack.Peek().Add(childEntry);
            return(childEntry);
        }
Ejemplo n.º 25
0
        /*
         * ParseParticle
         *
         * This method parses an XML particle.  A particle can be one of the following:
         *
         * XmlSchemaElement
         * XmlSchemaGroupBase - can be Sequence, Choice or All.
         * XmlSchemaGroupRef
         */
        private static IPluglet ParseParticle(IPluglet parent, XmlSchemaParticle pa, XmlSchema schema)
        {
            //Console.WriteLine("ParseParticle.. " + pa.Id);
            IPluglet ret = null;

            if (pa is XmlSchemaElement)
            {
                ret = ParseElement(parent, (XmlSchemaElement)pa, schema);
            }

            else if (pa is XmlSchemaAny)
            {
                AppendSchemaError("SchemaCode107EXmlSchemaAnyFound");
            }

            else if (pa is XmlSchemaGroupBase)
            {
                if (pa is XmlSchemaAll)
                {
                    AppendSchemaError("SchemaCode108EXmlSchemaAllFound");
                }

                else if (pa is XmlSchemaSequence)
                {
                    AppendSchemaError("SchemaCode109EXmlSchemaSequenceFound");
                }

                else if (pa is XmlSchemaChoice)
                {
                    AppendSchemaError("SchemaCode110EXmlSchemaChoiceFound");
                }
            }

            else if (pa is XmlSchemaGroupRef)
            {
                ParseParticle(parent, (XmlSchemaParticle)((XmlSchemaGroupRef)pa).Particle,
                              schema);
            }

            return(ret);
        }
Ejemplo n.º 26
0
        void CollectSubElements(XmlSchemaParticle particle)
        {
            // choice | sequence
            XmlSchemaGroupBase sgb = particle as XmlSchemaGroupBase;

            if (sgb != null)
            {
                foreach (XmlSchemaObject xso in sgb.Items)
                {
                    XmlSchemaElement xse = xso as XmlSchemaElement;
                    if (xse != null)
                    {
                        // If it's a ref, xse.QualifiedName.Name is the name of the element
                        ElementWrapper elw = new ElementWrapper(xse, false);
                        if (elw.IsComplexType)
                        {
                            Add(this.complexSubElements, xse);
                        }
                        else
                        {
                            Add(this.simpleSubElements, xse);
                        }

                        continue;
                    }
                    XmlSchemaParticle subParticle = xso as XmlSchemaParticle;
                    if (subParticle != null)
                    {
                        CollectSubElements(subParticle);
                        continue;
                    }
                }
            }
            // group
            XmlSchemaGroupRef groupRef = particle as XmlSchemaGroupRef;

            if (groupRef != null)
            {
                CollectSubElements(groupRef.Particle);
            }
        }
 public override void GetExpectedParticles(ArrayList al)
 {
     if (this.currentAutomata == null)
     {
         foreach (XmlSchemaObject xmlSchemaObject in this.seq.CompiledItems)
         {
             XmlSchemaParticle xmlSchemaParticle = (XmlSchemaParticle)xmlSchemaObject;
             al.Add(xmlSchemaParticle);
             if (!xmlSchemaParticle.ValidateIsEmptiable())
             {
                 break;
             }
         }
         return;
     }
     if (this.currentAutomata != null)
     {
         this.currentAutomata.GetExpectedParticles(al);
         if (!this.currentAutomata.EvaluateIsEmptiable())
         {
             return;
         }
         for (int i = this.current + 1; i < this.seq.CompiledItems.Count; i++)
         {
             XmlSchemaParticle xmlSchemaParticle2 = this.seq.CompiledItems[i] as XmlSchemaParticle;
             al.Add(xmlSchemaParticle2);
             if (!xmlSchemaParticle2.ValidateIsEmptiable())
             {
                 break;
             }
         }
     }
     if (base.Occured + 1 == this.seq.ValidatedMaxOccurs)
     {
         return;
     }
     for (int j = 0; j <= this.current; j++)
     {
         al.Add(this.seq.CompiledItems[j]);
     }
 }
Ejemplo n.º 28
0
 public override bool EvaluateEndElement()
 {
     this.emptiableComputed = false;
     if (this.choice.ValidatedMinOccurs > base.Occured + 1)
     {
         return(false);
     }
     if (this.choice.ValidatedMinOccurs <= base.Occured)
     {
         return(true);
     }
     for (int i = 0; i < this.choice.CompiledItems.Count; i++)
     {
         XmlSchemaParticle xsobj = (XmlSchemaParticle)this.choice.CompiledItems[i];
         if (base.Manager.Create(xsobj).EvaluateIsEmptiable())
         {
             return(true);
         }
     }
     return(false);
 }
Ejemplo n.º 29
0
 IEnumerable <XmlSchemaElement> GetElementsInParticle(XmlSchemaParticle p)
 {
     if (p is XmlSchemaElement)
     {
         yield return((XmlSchemaElement)p);
     }
     else
     {
         var gb = p as XmlSchemaGroupBase;
         if (gb != null)
         {
             foreach (XmlSchemaParticle pp in gb.Items)
             {
                 foreach (var e in GetElementsInParticle(pp))
                 {
                     yield return(e);
                 }
             }
         }
     }
 }
Ejemplo n.º 30
0
        Shape ProcessParticle(XmlSchemaParticle xsp, Shape parent)
        {
            Shape s;

            if (xsp == XmlSchemaParticle.Empty)
            {
                return(null);
            }
            if (xsp is XmlSchemaElement)
            {
                s = ProcessParticleElement((XmlSchemaElement)xsp);
            }
            else if (xsp is XmlSchemaSequence)
            {
                s = ProcessParticleGroup((XmlSchemaSequence)xsp, BindingType.Sequence);
            }
            else if (xsp is XmlSchemaChoice)
            {
                s = ProcessParticleGroup((XmlSchemaChoice)xsp, BindingType.Choice);
            }
            else if (xsp is XmlSchemaAll)
            {
                s = ProcessParticleGroup((XmlSchemaAll)xsp, BindingType.All);
            }
            else              //XmlSchemaAny
            {
                return(null); //Ignore Any in the content model
            }
            if (xsp.MaxOccurs > 1)
            {
                Shape rep = new Shape(s.Name, BindingType.Repeat);
                rep.AddSubShape(s);
                s = rep;
            }
            if (parent != null)
            {
                parent.AddSubShape(s);
            }
            return(s);
        }
Ejemplo n.º 31
0
	public void DumpParticle (XmlSchemaParticle p)
	{
		if (p is XmlSchemaGroupBase)
			DumpGroupBase ((XmlSchemaGroupBase) p);
		else if (p is XmlSchemaElement)
			DumpElementNoRecurse ((XmlSchemaElement) p);
		else if (p is XmlSchemaAny)
			DumpAny ((XmlSchemaAny) p);
		else
			IndentLine (p);
	}
Ejemplo n.º 32
0
    } //WriteXmlSchemaSimpleType()

    //XmlSchemaParticle
    public static void WriteXmlSchemaParticle(XmlSchemaParticle particle, 
                                              XmlSchema myXmlSchema, 
                                              XmlTextWriter myXmlTextWriter)
    {
      if (particle is XmlSchemaElement)
      {
        WriteXmlSchemaElement((XmlSchemaElement)particle, myXmlSchema, myXmlTextWriter);
      } //if
      else if (particle is XmlSchemaSequence)
      {
        myXmlTextWriter.WriteStartElement("sequence", XmlSchema.Namespace);
        foreach(XmlSchemaParticle particle1 in ((XmlSchemaSequence)particle).Items)
          WriteXmlSchemaParticle(particle1, myXmlSchema, myXmlTextWriter);

        myXmlTextWriter.WriteEndElement();
      } //else if
      else if (particle is XmlSchemaGroupRef)
      {
        XmlSchemaGroupRef xsgr = (XmlSchemaGroupRef)particle;
        XmlSchemaGroup group = (XmlSchemaGroup)myXmlSchema.Groups[xsgr.RefName];
        WriteXmlSchemaGroup(group, myXmlSchema, myXmlTextWriter, xsgr.RefName.Name);
      } //else if
      else
      {
        Console.WriteLine("Not Implemented for this type: {0}", particle.ToString());
      } //else
    } //WriteXmlSchemaParticle()
Ejemplo n.º 33
0
    } //WriteExampleAttribute()

    // Write example particles
    public static void WriteExampleParticle(XmlSchemaParticle particle, 
                                            XmlSchema myXmlSchema,
                                            XmlTextWriter myXmlTextWriter)
    {
      Decimal max;

      if (particle.MaxOccurs == -1 || particle.MaxOccurs > 10000)
      {
        max = 5;
      } //if
      else
      {
        max = particle.MaxOccurs;
      } //else

      for (int i = 0; i < max; i ++)
      {
        if (particle is XmlSchemaElement)
        {
          WriteExampleElement((XmlSchemaElement)particle, myXmlSchema, myXmlTextWriter);
        } //if 
        else if (particle is XmlSchemaSequence)
        {
          foreach (XmlSchemaParticle particle1 in ((XmlSchemaSequence)particle).Items)
            WriteExampleParticle(particle1, myXmlSchema, myXmlTextWriter);
        } //else if
        else if (particle is XmlSchemaGroupRef)
        {
          XmlSchemaGroupRef xsgr = (XmlSchemaGroupRef)particle;
          XmlSchemaGroup group = (XmlSchemaGroup)myXmlSchema.Groups[xsgr.RefName];
          WriteExampleParticle(group.Particle, myXmlSchema, myXmlTextWriter);
        } //else if
        else
        {
          Console.WriteLine("Not Implemented for this type: {0}", particle.ToString());
        } //else
      } //for
    } //WriteExampleParticle()