public XsdValidationState Get (XmlSchemaParticle xsobj) { XsdValidationState got = table [xsobj] as XsdValidationState; if (got == null) got = Create (xsobj); return got; }
private bool BuildParticleContentModel(ParticleContentValidator contentValidator, XmlSchemaParticle particle) { bool flag = false; if (particle is XmlSchemaElement) { XmlSchemaElement element = (XmlSchemaElement) particle; contentValidator.AddName(element.QualifiedName, element); } else if (particle is XmlSchemaAny) { flag = true; XmlSchemaAny any = (XmlSchemaAny) particle; contentValidator.AddNamespaceList(any.NamespaceList, any); } else if (particle is XmlSchemaGroupBase) { XmlSchemaObjectCollection items = ((XmlSchemaGroupBase) particle).Items; bool flag2 = particle is XmlSchemaChoice; contentValidator.OpenGroup(); bool flag3 = true; for (int i = 0; i < items.Count; i++) { if (flag3) { flag3 = false; } else if (flag2) { contentValidator.AddChoice(); } else { contentValidator.AddSequence(); } flag = this.BuildParticleContentModel(contentValidator, (XmlSchemaParticle) items[i]); } contentValidator.CloseGroup(); } if ((particle.MinOccurs != 1M) || (particle.MaxOccurs != 1M)) { if ((particle.MinOccurs == 0M) && (particle.MaxOccurs == 1M)) { contentValidator.AddQMark(); return flag; } if ((particle.MinOccurs == 0M) && (particle.MaxOccurs == 79228162514264337593543950335M)) { contentValidator.AddStar(); return flag; } if ((particle.MinOccurs == 1M) && (particle.MaxOccurs == 79228162514264337593543950335M)) { contentValidator.AddPlus(); return flag; } contentValidator.AddLeafRange(particle.MinOccurs, particle.MaxOccurs); } return flag; }
private void ClearCompiledState() { this.attributeUses = null; this.localElements = null; this.attributeWildcard = null; this.contentTypeParticle = XmlSchemaParticle.Empty; this.blockResolved = XmlSchemaDerivationMethod.None; }
/// <summary> /// Insert an element above an existing any item. /// </summary> /// <param name="particle">The particle in which the any item should be found.</param> /// <param name="element">The element to insert.</param> /// <returns>true if the element was inserted; false otherwise.</returns> private bool InsertElement(XmlSchemaParticle particle, XmlSchemaElement element) { if (particle is XmlSchemaChoice) { XmlSchemaChoice choice = (XmlSchemaChoice)particle; for (int i = 0; i < choice.Items.Count; i++) { XmlSchemaParticle childParticle = (XmlSchemaParticle)choice.Items[i]; if (childParticle is XmlSchemaAny) { // index this any element for later removal this.anys[childParticle] = choice; choice.Items.Insert(i, element); return true; } else { if (this.InsertElement(childParticle, element)) { return true; } } } } else if (particle is XmlSchemaSequence) { XmlSchemaSequence sequence = (XmlSchemaSequence)particle; for (int i = 0; i < sequence.Items.Count; i++) { XmlSchemaParticle childParticle = (XmlSchemaParticle)sequence.Items[i]; if (childParticle is XmlSchemaAny) { // index this any element for later removal this.anys[childParticle] = sequence; sequence.Items.Insert(i, element); return true; } else { if (this.InsertElement(childParticle, element)) { return true; } } } } return false; }
internal override XmlSchemaParticle GetOptimizedParticle(bool isTop) { if (this.OptimizedParticle != null) { return(this.OptimizedParticle); } if (this.Items.Count == 0 || base.ValidatedMaxOccurs == 0m) { this.OptimizedParticle = XmlSchemaParticle.Empty; } else if (!isTop && this.Items.Count == 1 && base.ValidatedMinOccurs == 1m && base.ValidatedMaxOccurs == 1m) { this.OptimizedParticle = ((XmlSchemaParticle)this.Items[0]).GetOptimizedParticle(false); } else { XmlSchemaChoice xmlSchemaChoice = new XmlSchemaChoice(); this.CopyInfo(xmlSchemaChoice); for (int i = 0; i < this.Items.Count; i++) { XmlSchemaParticle xmlSchemaParticle = this.Items[i] as XmlSchemaParticle; xmlSchemaParticle = xmlSchemaParticle.GetOptimizedParticle(false); if (xmlSchemaParticle != XmlSchemaParticle.Empty) { if (xmlSchemaParticle is XmlSchemaChoice && xmlSchemaParticle.ValidatedMinOccurs == 1m && xmlSchemaParticle.ValidatedMaxOccurs == 1m) { XmlSchemaChoice xmlSchemaChoice2 = xmlSchemaParticle as XmlSchemaChoice; for (int j = 0; j < xmlSchemaChoice2.Items.Count; j++) { xmlSchemaChoice.Items.Add(xmlSchemaChoice2.Items[j]); xmlSchemaChoice.CompiledItems.Add(xmlSchemaChoice2.Items[j]); } } else { xmlSchemaChoice.Items.Add(xmlSchemaParticle); xmlSchemaChoice.CompiledItems.Add(xmlSchemaParticle); } } } if (xmlSchemaChoice.Items.Count == 0) { this.OptimizedParticle = XmlSchemaParticle.Empty; } else { this.OptimizedParticle = xmlSchemaChoice; } } return(this.OptimizedParticle); }
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle, ValidationEventHandler h, XmlSchema schema, bool raiseError) { XmlSchemaAny xmlSchemaAny = baseParticle as XmlSchemaAny; if (xmlSchemaAny == null) { if (raiseError) { base.error(h, "Invalid particle derivation by restriction was found."); } return(false); } return(this.ValidateOccurenceRangeOK(baseParticle, h, schema, raiseError) && this.wildcard.ValidateWildcardSubset(xmlSchemaAny.wildcard, h, schema, raiseError)); }
internal void CopyOptimizedItems(XmlSchemaGroupBase gb) { for (int i = 0; i < Items.Count; i++) { XmlSchemaParticle p = Items [i] as XmlSchemaParticle; p = p.GetOptimizedParticle(false); if (p == XmlSchemaParticle.Empty) { continue; } gb.Items.Add(p); gb.CompiledItems.Add(p); } }
private Sequence PopulateSequence(ComplexType ct) { Particle p = PopulateParticle(ct); Sequence s = p as Sequence; if (s != null) { return(s); } else { throw Error(ct, String.Format("Target complexType contains unacceptable type of particle {0}", p)); } }
public override ArrayList ExpectedParticles(ValidationState context, bool isRequiredOnly, XmlSchemaSet schemaSet) { ArrayList particles = new ArrayList(); BitSet set = context.CurPos[context.CurrentState.CurPosIndex]; for (int i = set.NextSet(-1); i != -1; i = set.NextSet(i)) { XmlSchemaParticle p = (XmlSchemaParticle)this.positions[i].particle; if (p != null) { ContentValidator.AddParticleToExpected(p, schemaSet, particles); } } return(particles); }
internal virtual bool ValidateOccurenceRangeOK(XmlSchemaParticle other, ValidationEventHandler h, XmlSchema schema, bool raiseError) { if ((this.ValidatedMinOccurs < other.ValidatedMinOccurs) || (other.ValidatedMaxOccurs != decimal.MaxValue && this.ValidatedMaxOccurs > other.ValidatedMaxOccurs)) { if (raiseError) { error(h, "Invalid derivation occurence range was found."); } return(false); } return(true); }
internal override int Validate(ValidationEventHandler h, XmlSchema schema) { if (base.IsValidated(schema.CompilationId)) { return(this.errorCount); } base.CompiledItems.Clear(); foreach (XmlSchemaObject xmlSchemaObject in this.Items) { XmlSchemaParticle xmlSchemaParticle = (XmlSchemaParticle)xmlSchemaObject; this.errorCount += xmlSchemaParticle.Validate(h, schema); base.CompiledItems.Add(xmlSchemaParticle); } this.ValidationId = schema.ValidationId; return(this.errorCount); }
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle, ValidationEventHandler h, XmlSchema schema, bool raiseError) { XmlSchemaAny xmlSchemaAny = baseParticle as XmlSchemaAny; XmlSchemaAll xmlSchemaAll = baseParticle as XmlSchemaAll; if (xmlSchemaAny != null) { return(base.ValidateNSRecurseCheckCardinality(xmlSchemaAny, h, schema, raiseError)); } if (xmlSchemaAll != null) { return(this.ValidateOccurenceRangeOK(xmlSchemaAll, h, schema, raiseError) && base.ValidateRecurse(xmlSchemaAll, h, schema, raiseError)); } if (raiseError) { base.error(h, "Invalid -all- particle derivation was found."); } return(false); }
internal override XmlSchemaParticle GetOptimizedParticle(bool isTop) { if (OptimizedParticle != null) { return(OptimizedParticle); } if (Items.Count == 0 || ValidatedMaxOccurs == 0) { OptimizedParticle = XmlSchemaParticle.Empty; return(OptimizedParticle); } else if (Items.Count == 1) { if (ValidatedMinOccurs == 1 && ValidatedMaxOccurs == 1) { XmlSchemaSequence seq = new XmlSchemaSequence(); this.CopyInfo(seq); XmlSchemaParticle p = (XmlSchemaParticle)Items [0]; p = p.GetOptimizedParticle(false); if (p == XmlSchemaParticle.Empty) { OptimizedParticle = p; } else { seq.Items.Add(p); seq.CompiledItems.Add(p); seq.Compile(null, schema); OptimizedParticle = seq; } return(OptimizedParticle); } } XmlSchemaAll all = new XmlSchemaAll(); CopyInfo(all); CopyOptimizedItems(all); OptimizedParticle = all; all.ComputeEmptiable(); return(OptimizedParticle); }
public override ArrayList ExpectedElements(ValidationState context, bool isRequiredOnly) { ArrayList list = null; if (context.RunningPositions != null) { List <RangePositionInfo> runningPositions = context.RunningPositions; BitSet set = new BitSet(this.positions.Count); for (int i = context.CurrentState.NumberOfRunningPos - 1; i >= 0; i--) { set.Or(runningPositions[i].curpos); } for (int j = set.NextSet(-1); j != -1; j = set.NextSet(j)) { if (list == null) { list = new ArrayList(); } if (this.positions[j].symbol >= 0) { XmlSchemaParticle particle = this.positions[j].particle as XmlSchemaParticle; if (particle == null) { string str = this.symbols.NameOf(this.positions[j].symbol); if (str.Length != 0) { list.Add(str); } } else { string nameString = particle.NameString; if (!list.Contains(nameString)) { list.Add(nameString); } } } } } return(list); }
internal override XmlSchemaParticle GetOptimizedParticle(bool isTop) { if (OptimizedParticle != null) return OptimizedParticle; if (Items.Count == 0 || ValidatedMaxOccurs == 0) OptimizedParticle = XmlSchemaParticle.Empty; // LAMESPEC: Regardless of isTop, it should remove pointless particle. It seems ContentTypeParticle design bug. else if (!isTop && Items.Count == 1 && ValidatedMinOccurs == 1 && ValidatedMaxOccurs == 1) OptimizedParticle = ((XmlSchemaParticle) Items [0]).GetOptimizedParticle (false); else { XmlSchemaChoice c = new XmlSchemaChoice (); CopyInfo (c); for (int i = 0; i < Items.Count; i++) { XmlSchemaParticle p = Items [i] as XmlSchemaParticle; p = p.GetOptimizedParticle (false); if (p == XmlSchemaParticle.Empty) continue; else if (p is XmlSchemaChoice && p.ValidatedMinOccurs == 1 && p.ValidatedMaxOccurs == 1) { XmlSchemaChoice pc = p as XmlSchemaChoice; for (int ci = 0; ci < pc.Items.Count; ci++) { c.Items.Add (pc.Items [ci]); c.CompiledItems.Add (pc.Items [ci]); } } else { c.Items.Add (p); c.CompiledItems.Add (p); } } if (c.Items.Count == 0) OptimizedParticle = XmlSchemaParticle.Empty; else OptimizedParticle = c; } return OptimizedParticle; }
/* * private bool ValidateRecurseLax (XmlSchemaGroupBase baseGroup, * ValidationEventHandler h, XmlSchema schema, bool raiseError) * { * int index = 0; * for (int i = 0; i < baseGroup.CompiledItems.Count; i++) { * XmlSchemaParticle pb = (XmlSchemaParticle) baseGroup.CompiledItems [i]; * pb = pb.GetOptimizedParticle (false); * if (pb == XmlSchemaParticle.Empty) * continue; * XmlSchemaParticle pd = null; * while (this.CompiledItems.Count > index) { * pd = (XmlSchemaParticle) this.CompiledItems [index]; * pd = pd.GetOptimizedParticle (false); * index++; * if (pd != XmlSchemaParticle.Empty) * break; * } * if (!ValidateParticleSection (ref index, pd, pb, h, schema, raiseError)) * continue; * } * if (this.CompiledItems.Count > 0 && index != this.CompiledItems.Count) { * if (raiseError) * error (h, "Invalid particle derivation by restriction was found. Extraneous derived particle was found."); * return false; * } * return true; * } */ private bool ValidateParticleSection(ref int index, XmlSchemaParticle pd, XmlSchemaParticle pb, ValidationEventHandler h, XmlSchema schema, bool raiseError) { if (pd == pb) // they are same particle { return(true); } if (pd != null) { // XmlSchemaElement el = pd as XmlSchemaElement; XmlSchemaParticle pdx = pd; // if (el != null && el.SubstitutingElements.Count > 0) // pdx = el.SubstitutingChoice; if (!pdx.ValidateDerivationByRestriction(pb, h, schema, false)) { if (!pb.ValidateIsEmptiable()) { if (raiseError) { error(h, "Invalid particle derivation by restriction was found. Invalid sub-particle derivation was found."); } return(false); } else { index--; // try the same derived particle and next base particle. return(false); } } } else if (!pb.ValidateIsEmptiable()) { if (raiseError) { error(h, "Invalid particle derivation by restriction was found. Base schema particle has non-emptiable sub particle that is not mapped to the derived particle."); } return(false); } return(true); }
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; } } } } }
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle, ValidationEventHandler h, XmlSchema schema, bool raiseError) { XmlSchemaAny xmlSchemaAny = baseParticle as XmlSchemaAny; if (xmlSchemaAny != null) { return(base.ValidateNSRecurseCheckCardinality(xmlSchemaAny, h, schema, raiseError)); } XmlSchemaChoice xmlSchemaChoice = baseParticle as XmlSchemaChoice; if (xmlSchemaChoice != null) { return(this.ValidateOccurenceRangeOK(xmlSchemaChoice, h, schema, raiseError) && ((xmlSchemaChoice.ValidatedMinOccurs == 0m && xmlSchemaChoice.ValidatedMaxOccurs == 0m && base.ValidatedMinOccurs == 0m && base.ValidatedMaxOccurs == 0m) || base.ValidateSeqRecurseMapSumCommon(xmlSchemaChoice, h, schema, true, false, raiseError))); } if (raiseError) { base.error(h, "Invalid choice derivation by restriction was found."); } return(false); }
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle, ValidationEventHandler h, XmlSchema schema, bool raiseError) { XmlSchemaAny baseAny = baseParticle as XmlSchemaAny; if (baseAny == null) { if (raiseError) { error(h, "Invalid particle derivation by restriction was found."); } return(false); } // 3.9.6 Particle Derivation OK (Any:Any - NSSubset) if (!ValidateOccurenceRangeOK(baseParticle, h, schema, raiseError)) { return(false); } return(wildcard.ValidateWildcardSubset(baseAny.wildcard, h, schema, raiseError)); }
internal static bool HasParticleRef(XmlSchemaParticle?particle, XmlSchema?parentSchema) { XmlSchemaGroupBase?groupBase = particle as XmlSchemaGroupBase; if (groupBase != null) { bool foundRef = false; int i = 0; while (i < groupBase.Items.Count && !foundRef) { XmlSchemaParticle p = (XmlSchemaParticle)groupBase.Items[i++]; if (p is XmlSchemaGroupRef) { foundRef = true; } else { XmlSchemaElement?elem = p as XmlSchemaElement; // This is the same condition as in the CloneParticle method // that's on purpose. This method is used to determine if we need to clone the whole particle. // If we do, then the CloneParticle is called and it will try to clone only // those elements which need cloning - and those are the ones matching this condition. if (elem != null && (!elem.RefName.IsEmpty || !elem.SchemaTypeName.IsEmpty || GetResolvedElementForm(parentSchema, elem) == XmlSchemaForm.Qualified)) { foundRef = true; } else { foundRef = HasParticleRef(p, parentSchema); } } } return(foundRef); } else if (particle is XmlSchemaGroupRef) { return(true); } return(false); }
internal override bool ParticleEquals(XmlSchemaParticle other) { XmlSchemaAny xmlSchemaAny = other as XmlSchemaAny; if (xmlSchemaAny == null) { return(false); } if (this.HasValueAny != xmlSchemaAny.HasValueAny || this.HasValueLocal != xmlSchemaAny.HasValueLocal || this.HasValueOther != xmlSchemaAny.HasValueOther || this.HasValueTargetNamespace != xmlSchemaAny.HasValueTargetNamespace || this.ResolvedProcessContents != xmlSchemaAny.ResolvedProcessContents || base.ValidatedMaxOccurs != xmlSchemaAny.ValidatedMaxOccurs || base.ValidatedMinOccurs != xmlSchemaAny.ValidatedMinOccurs || this.ResolvedNamespaces.Count != xmlSchemaAny.ResolvedNamespaces.Count) { return(false); } for (int i = 0; i < this.ResolvedNamespaces.Count; i++) { if (this.ResolvedNamespaces[i] != xmlSchemaAny.ResolvedNamespaces[i]) { return(false); } } return(true); }
internal override bool ParticleEquals (XmlSchemaParticle other) { XmlSchemaGroupBase gb = other as XmlSchemaGroupBase; if (gb == null) return false; if (this.GetType () != gb.GetType ()) return false; if (this.ValidatedMaxOccurs != gb.ValidatedMaxOccurs || this.ValidatedMinOccurs != gb.ValidatedMinOccurs) return false; if (this.CompiledItems.Count != gb.CompiledItems.Count) return false; for (int i = 0; i < CompiledItems.Count; i++) { XmlSchemaParticle p1 = this.CompiledItems [i] as XmlSchemaParticle; XmlSchemaParticle p2 = gb.CompiledItems [i] as XmlSchemaParticle; if (!p1.ParticleEquals (p2)) return false; } return true; }
public override ArrayList ExpectedParticles(ValidationState context, bool isRequiredOnly, XmlSchemaSet schemaSet) { ArrayList particles = new ArrayList(); int[] numArray = this.transitionTable[context.CurrentState.State]; if (numArray != null) { for (int i = 0; i < (numArray.Length - 1); i++) { if (numArray[i] != -1) { XmlSchemaParticle p = (XmlSchemaParticle)this.symbols.GetParticle(i); if (p != null) { ContentValidator.AddParticleToExpected(p, schemaSet, particles); } } } } return(particles); }
private void ValidateUPAOnItems(XmlSchemaObjectTable qnames, ArrayList nsNames, ValidationEventHandler h, XmlSchema schema) { XmlSchemaObjectTable xmlSchemaObjectTable = new XmlSchemaObjectTable(); ArrayList arrayList = new ArrayList(); XmlSchemaObjectTable xmlSchemaObjectTable2 = new XmlSchemaObjectTable(); ArrayList arrayList2 = new ArrayList(); for (int i = 0; i < this.Items.Count; i++) { XmlSchemaParticle xmlSchemaParticle = this.Items[i] as XmlSchemaParticle; xmlSchemaParticle.ValidateUniqueParticleAttribution(xmlSchemaObjectTable, arrayList, h, schema); if (xmlSchemaParticle.ValidatedMinOccurs == xmlSchemaParticle.ValidatedMaxOccurs) { xmlSchemaObjectTable.Clear(); arrayList.Clear(); } else { if (xmlSchemaParticle.ValidatedMinOccurs != 0m) { foreach (object obj in xmlSchemaObjectTable2.Names) { XmlQualifiedName name = (XmlQualifiedName)obj; xmlSchemaObjectTable.Set(name, null); } foreach (object obj2 in arrayList2) { arrayList.Remove(obj2); } } foreach (object obj3 in xmlSchemaObjectTable.Names) { XmlQualifiedName name2 = (XmlQualifiedName)obj3; xmlSchemaObjectTable2.Set(name2, xmlSchemaObjectTable[name2]); } arrayList2.Clear(); arrayList2.AddRange(arrayList); } } }
private Parameter[] GetParameters(string messagePartName) { List <Parameter> parameters = new List <Parameter>(); //Types types = serviceDescription.Types; //System.Xml.Schema.XmlSchema xmlSchema = types.Schemas[0]; foreach (XmlSchemaElement schemaElement in e.GlobalElements.Values) { //} //foreach (object item in xmlSchema.Items) //{ // System.Xml.Schema.XmlSchemaElement schemaElement = item as System.Xml.Schema.XmlSchemaElement; if (schemaElement != null) { if (schemaElement.Name == messagePartName) { System.Xml.Schema.XmlSchemaType schemaType = schemaElement.SchemaType; System.Xml.Schema.XmlSchemaComplexType complexType = schemaType as System.Xml.Schema.XmlSchemaComplexType; if (complexType != null) { System.Xml.Schema.XmlSchemaParticle particle = complexType.Particle; System.Xml.Schema.XmlSchemaSequence sequence = particle as System.Xml.Schema.XmlSchemaSequence; if (sequence != null) { foreach (System.Xml.Schema.XmlSchemaElement childElement in sequence.Items) { string parameterName = childElement.Name; string parameterType = childElement.SchemaTypeName.Name; parameters.Add(new Parameter(parameterName, parameterType, null, null)); } } } break; } } } return(parameters.ToArray()); }
void ValidateUPAOnItems(XmlSchemaObjectTable qnames, ArrayList nsNames, ValidationEventHandler h, XmlSchema schema) { // non-optional components XmlSchemaObjectTable elems = new XmlSchemaObjectTable(); ArrayList wildcards = new ArrayList(); XmlSchemaObjectTable tmpElems = new XmlSchemaObjectTable(); ArrayList tmpWildcards = new ArrayList(); for (int i = 0; i < Items.Count; i++) { XmlSchemaParticle p1 = Items [i] as XmlSchemaParticle; p1.ValidateUniqueParticleAttribution(elems, wildcards, h, schema); if (p1.ValidatedMinOccurs == p1.ValidatedMaxOccurs) { elems.Clear(); wildcards.Clear(); } else { if (p1.ValidatedMinOccurs != 0) { foreach (XmlQualifiedName n in tmpElems.Names) { elems.Set(n, null); // remove } foreach (object o in tmpWildcards) { wildcards.Remove(o); } } foreach (XmlQualifiedName n in elems.Names) { tmpElems.Set(n, elems [n]); } tmpWildcards.Clear(); tmpWildcards.AddRange(wildcards); } } }
internal override XmlSchemaParticle GetOptimizedParticle(bool isTop) { if (this.OptimizedParticle != null) { return(this.OptimizedParticle); } if (this.Items.Count == 0 || base.ValidatedMaxOccurs == 0m) { this.OptimizedParticle = XmlSchemaParticle.Empty; return(this.OptimizedParticle); } if (this.Items.Count == 1 && base.ValidatedMinOccurs == 1m && base.ValidatedMaxOccurs == 1m) { XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence(); this.CopyInfo(xmlSchemaSequence); XmlSchemaParticle xmlSchemaParticle = (XmlSchemaParticle)this.Items[0]; xmlSchemaParticle = xmlSchemaParticle.GetOptimizedParticle(false); if (xmlSchemaParticle == XmlSchemaParticle.Empty) { this.OptimizedParticle = xmlSchemaParticle; } else { xmlSchemaSequence.Items.Add(xmlSchemaParticle); xmlSchemaSequence.CompiledItems.Add(xmlSchemaParticle); xmlSchemaSequence.Compile(null, this.schema); this.OptimizedParticle = xmlSchemaSequence; } return(this.OptimizedParticle); } XmlSchemaAll xmlSchemaAll = new XmlSchemaAll(); this.CopyInfo(xmlSchemaAll); base.CopyOptimizedItems(xmlSchemaAll); this.OptimizedParticle = xmlSchemaAll; xmlSchemaAll.ComputeEmptiable(); return(this.OptimizedParticle); }
public static void AddParticleToExpected(XmlSchemaParticle p, XmlSchemaSet schemaSet, ArrayList particles, bool global) { if (!particles.Contains(p)) { particles.Add(p); } XmlSchemaElement element = p as XmlSchemaElement; if ((element != null) && (global || !element.RefName.IsEmpty)) { XmlSchemaSubstitutionGroup group = (XmlSchemaSubstitutionGroup) schemaSet.SubstitutionGroups[element.QualifiedName]; if (group != null) { for (int i = 0; i < group.Members.Count; i++) { XmlSchemaElement item = (XmlSchemaElement) group.Members[i]; if (!element.QualifiedName.Equals(item.QualifiedName) && !particles.Contains(item)) { particles.Add(item); } } } } }
public override ArrayList ExpectedElements(ValidationState context, bool isRequiredOnly) { ArrayList list = null; int[] numArray = this.transitionTable[context.CurrentState.State]; if (numArray != null) { for (int i = 0; i < (numArray.Length - 1); i++) { if (numArray[i] != -1) { if (list == null) { list = new ArrayList(); } XmlSchemaParticle particle = (XmlSchemaParticle)this.symbols.GetParticle(i); if (particle == null) { string str = this.symbols.NameOf(i); if (str.Length != 0) { list.Add(str); } } else { string nameString = particle.NameString; if (!list.Contains(nameString)) { list.Add(nameString); } } } } } return(list); }
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle, ValidationEventHandler h, XmlSchema schema, bool raiseError) { XmlSchemaAny any = baseParticle as XmlSchemaAny; if (any != null) { // NSRecurseCheckCardinality return(ValidateNSRecurseCheckCardinality(any, h, schema, raiseError)); } XmlSchemaChoice choice = baseParticle as XmlSchemaChoice; if (choice != null) { // RecurseLax if (!ValidateOccurenceRangeOK(choice, h, schema, raiseError)) { return(false); } // If it is totally optional, then ignore their contents. if (choice.ValidatedMinOccurs == 0 && choice.ValidatedMaxOccurs == 0 && this.ValidatedMinOccurs == 0 && this.ValidatedMaxOccurs == 0) { return(true); } // return ValidateRecurseLax (choice, h, schema, raiseError); return(this.ValidateSeqRecurseMapSumCommon(choice, h, schema, true, false, raiseError)); } if (raiseError) { error(h, "Invalid choice derivation by restriction was found."); } return(false); }
internal static XmlSchemaParticle CloneParticle(XmlSchemaParticle particle, XmlSchema parentSchema) { XmlSchemaGroupBase base2 = particle as XmlSchemaGroupBase; if (base2 != null) { XmlSchemaGroupBase base3 = base2; XmlSchemaObjectCollection newItems = CloneGroupBaseParticles(base2.Items, parentSchema); base3 = (XmlSchemaGroupBase) base2.Clone(); base3.SetItems(newItems); return base3; } if (particle is XmlSchemaGroupRef) { XmlSchemaGroupRef ref2 = (XmlSchemaGroupRef) particle.Clone(); ref2.RefName = ref2.RefName.Clone(); return ref2; } XmlSchemaElement element = particle as XmlSchemaElement; if ((element == null) || ((element.RefName.IsEmpty && element.SchemaTypeName.IsEmpty) && (GetResolvedElementForm(parentSchema, element) != XmlSchemaForm.Qualified))) { return particle; } return (XmlSchemaElement) element.Clone(parentSchema); }
internal static bool HasParticleRef(XmlSchemaParticle particle) { XmlSchemaGroupBase groupBase = particle as XmlSchemaGroupBase; if (groupBase != null && !(groupBase is XmlSchemaAll)) { bool foundRef = false; int i = 0; while (i < groupBase.Items.Count && !foundRef) { XmlSchemaParticle p = (XmlSchemaParticle)groupBase.Items[i++]; if (p is XmlSchemaGroupRef) { foundRef = true; } else { XmlSchemaElement elem = p as XmlSchemaElement; if (elem != null && (!elem.RefName.IsEmpty || !elem.SchemaTypeName.IsEmpty)) { foundRef = true; } else { foundRef = HasParticleRef(p); } } } return(foundRef); } else if (particle is XmlSchemaGroupRef) { return(true); } return(false); }
internal static XmlSchemaParticle CloneParticle(XmlSchemaParticle particle, XmlSchema parentSchema) { XmlSchemaGroupBase groupBase = particle as XmlSchemaGroupBase; if (groupBase != null) //Choice or sequence { XmlSchemaGroupBase newGroupBase = groupBase; XmlSchemaObjectCollection newGroupbaseParticles = CloneGroupBaseParticles(groupBase.Items, parentSchema); newGroupBase = (XmlSchemaGroupBase)groupBase.Clone(); newGroupBase.SetItems(newGroupbaseParticles); return(newGroupBase); } else if (particle is XmlSchemaGroupRef) // group ref { XmlSchemaGroupRef newGroupRef = (XmlSchemaGroupRef)particle.Clone(); newGroupRef.RefName = newGroupRef.RefName.Clone(); return(newGroupRef); } else { XmlSchemaElement oldElem = particle as XmlSchemaElement; // If the particle is an element and one of the following is true: // - it references another element by name // - it references its type by name // - it's form (effective) is qualified (meaning it will inherint namespace from chameleon includes if that happens) // then the element itself needs to be cloned. if (oldElem != null && (!oldElem.RefName.IsEmpty || !oldElem.SchemaTypeName.IsEmpty || GetResolvedElementForm(parentSchema, oldElem) == XmlSchemaForm.Qualified)) { XmlSchemaElement newElem = (XmlSchemaElement)oldElem.Clone(parentSchema); return(newElem); } } return(particle); }
public static void AddParticleToExpected(XmlSchemaParticle p, XmlSchemaSet schemaSet, ArrayList particles, bool global) { if (!particles.Contains(p)) { particles.Add(p); } XmlSchemaElement element = p as XmlSchemaElement; if ((element != null) && (global || !element.RefName.IsEmpty)) { XmlSchemaSubstitutionGroup group = (XmlSchemaSubstitutionGroup)schemaSet.SubstitutionGroups[element.QualifiedName]; if (group != null) { for (int i = 0; i < group.Members.Count; i++) { XmlSchemaElement item = (XmlSchemaElement)group.Members[i]; if (!element.QualifiedName.Equals(item.QualifiedName) && !particles.Contains(item)) { particles.Add(item); } } } } }
private bool IsParticleEmptiable(XmlSchemaParticle particle) { decimal num; decimal num2; this.CalculateEffectiveTotalRange(particle, out num, out num2); return (num == 0M); }
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle, ValidationEventHandler h, XmlSchema schema, bool raiseError) { return(true); }
private XmlSchemaContentType GetSchemaContentType(XmlSchemaComplexType complexType, XmlSchemaComplexContent complexContent, XmlSchemaParticle particle) { if (((complexContent != null) && complexContent.IsMixed) || ((complexContent == null) && complexType.IsMixed)) { return XmlSchemaContentType.Mixed; } if ((particle != null) && !particle.IsEmpty) { return XmlSchemaContentType.ElementOnly; } return XmlSchemaContentType.Empty; }
/// <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 <lang cref="null"/> 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; }
// This method is used only by particles internal virtual void CopyInfo (XmlSchemaParticle obj) { obj.LineNumber = LineNumber; obj.LinePosition = LinePosition; obj.SourceUri = SourceUri; obj.errorCount = errorCount; // Other fields and properties may be useless for Particle. }
private XmlSchemaParticle CannonicalizeParticle(XmlSchemaParticle particle, bool root, bool substitution) { if ((particle == null) || particle.IsEmpty) { return XmlSchemaParticle.Empty; } if (particle is XmlSchemaElement) { return this.CannonicalizeElement((XmlSchemaElement) particle, substitution); } if (particle is XmlSchemaGroupRef) { return this.CannonicalizeGroupRef((XmlSchemaGroupRef) particle, root, substitution); } if (particle is XmlSchemaAll) { return this.CannonicalizeAll((XmlSchemaAll) particle, root, substitution); } if (particle is XmlSchemaChoice) { return this.CannonicalizeChoice((XmlSchemaChoice) particle, root, substitution); } if (particle is XmlSchemaSequence) { return this.CannonicalizeSequence((XmlSchemaSequence) particle, root, substitution); } return particle; }
private void CalculateEffectiveTotalRange(XmlSchemaParticle particle, out decimal minOccurs, out decimal maxOccurs) { if ((particle is XmlSchemaElement) || (particle is XmlSchemaAny)) { minOccurs = particle.MinOccurs; maxOccurs = particle.MaxOccurs; } else if (particle is XmlSchemaChoice) { if (((XmlSchemaChoice) particle).Items.Count == 0) { minOccurs = maxOccurs = 0M; } else { minOccurs = 79228162514264337593543950335M; maxOccurs = 0M; XmlSchemaChoice choice = (XmlSchemaChoice) particle; for (int i = 0; i < choice.Items.Count; i++) { decimal num2; decimal num3; this.CalculateEffectiveTotalRange((XmlSchemaParticle) choice.Items[i], out num2, out num3); if (num2 < minOccurs) { minOccurs = num2; } if (num3 > maxOccurs) { maxOccurs = num3; } } minOccurs *= particle.MinOccurs; if (maxOccurs != 79228162514264337593543950335M) { if (particle.MaxOccurs == 79228162514264337593543950335M) { maxOccurs = 79228162514264337593543950335M; } else { maxOccurs *= particle.MaxOccurs; } } } } else { XmlSchemaObjectCollection items = ((XmlSchemaGroupBase) particle).Items; if (items.Count == 0) { minOccurs = maxOccurs = 0M; } else { minOccurs = 0M; maxOccurs = 0M; for (int j = 0; j < items.Count; j++) { decimal num5; decimal num6; this.CalculateEffectiveTotalRange((XmlSchemaParticle) items[j], out num5, out num6); minOccurs += num5; if (maxOccurs != 79228162514264337593543950335M) { if (num6 == 79228162514264337593543950335M) { maxOccurs = 79228162514264337593543950335M; } else { maxOccurs += num6; } } } minOccurs *= particle.MinOccurs; if (maxOccurs != 79228162514264337593543950335M) { if (particle.MaxOccurs == 79228162514264337593543950335M) { maxOccurs = 79228162514264337593543950335M; } else { maxOccurs *= particle.MaxOccurs; } } } } }
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle, ValidationEventHandler h, XmlSchema schema, bool raiseError) { return(this.TargetGroup != null && this.TargetGroup.Particle.ValidateDerivationByRestriction(baseParticle, h, schema, raiseError)); }
internal override bool ParticleEquals (XmlSchemaParticle other) { return this.GetOptimizedParticle (true).ParticleEquals (other); }
void ImportParticleContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaParticle particle, CodeIdentifiers classIds, bool multiValue, ref bool isMixed) { if (particle == null) return; if (particle is XmlSchemaGroupRef) particle = GetRefGroupParticle ((XmlSchemaGroupRef)particle); if (particle.MaxOccurs > 1) multiValue = true; if (particle is XmlSchemaSequence) { ImportSequenceContent (typeQName, cmap, ((XmlSchemaSequence)particle).Items, classIds, multiValue, ref isMixed); } else if (particle is XmlSchemaChoice) { if (((XmlSchemaChoice)particle).Items.Count == 1) ImportSequenceContent (typeQName, cmap, ((XmlSchemaChoice)particle).Items, classIds, multiValue, ref isMixed); else ImportChoiceContent (typeQName, cmap, (XmlSchemaChoice)particle, classIds, multiValue); } else if (particle is XmlSchemaAll) { ImportSequenceContent (typeQName, cmap, ((XmlSchemaAll)particle).Items, classIds, multiValue, ref isMixed); } }
internal override bool ParticleEquals(XmlSchemaParticle other) { return(this.GetOptimizedParticle(true).ParticleEquals(other)); }
void ImportParticleComplexContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaParticle particle, CodeIdentifiers classIds, bool isMixed) { ImportParticleContent (typeQName, cmap, particle, classIds, false, ref isMixed); if (isMixed) AddTextMember (typeQName, cmap, classIds); }
bool CheckChoiceType (XmlQualifiedName typeQName, XmlSchemaParticle particle, ArrayList types, ref bool multiValue) { XmlQualifiedName type = null; multiValue = multiValue || particle.MaxOccurs > 1; if (particle is XmlSchemaGroupRef) return CheckChoiceType (typeQName, GetRefGroupParticle ((XmlSchemaGroupRef)particle), types, ref multiValue); if (particle is XmlSchemaElement) { string ns; XmlSchemaElement elem = (XmlSchemaElement)particle; XmlSchemaElement refElem = GetRefElement (typeQName, elem, out ns); if (refElem.SchemaType != null) return true; type = refElem.SchemaTypeName; } else if (particle is XmlSchemaAny) { type = anyType; } else if (particle is XmlSchemaSequence) { XmlSchemaSequence seq = particle as XmlSchemaSequence; foreach (XmlSchemaParticle par in seq.Items) if (!CheckChoiceType (typeQName, par, types, ref multiValue)) return false; return true; } else if (particle is XmlSchemaChoice) { foreach (XmlSchemaParticle choice in ((XmlSchemaChoice)particle).Items) if (!CheckChoiceType (typeQName, choice, types, ref multiValue)) return false; return true; } if (typeQName.Equals (type)) return false; // For primitive types, compare using CLR types, since several // xml types can be mapped to a single CLR type string t; if (IsPrimitiveTypeNamespace (type.Namespace)) t = TypeTranslator.GetPrimitiveTypeData (type.Name).FullTypeName + ":" + type.Namespace; else t = type.Name + ":" + type.Namespace; if (types.Contains (t)) return false; types.Add (t); return true; }
bool CanBeArray (XmlQualifiedName typeQName, XmlSchemaParticle particle, bool multiValue) { // To be an array, there can't be a direct child of type typeQName if (particle == null) return false; multiValue = multiValue || particle.MaxOccurs > 1; if (particle is XmlSchemaGroupRef) return CanBeArray (typeQName, GetRefGroupParticle ((XmlSchemaGroupRef)particle), multiValue); if (particle is XmlSchemaElement) { XmlSchemaElement elem = (XmlSchemaElement)particle; if (!elem.RefName.IsEmpty) return CanBeArray (typeQName, FindRefElement (elem), multiValue); else return multiValue && !typeQName.Equals (((XmlSchemaElement)particle).SchemaTypeName); } if (particle is XmlSchemaAny) return multiValue; if (particle is XmlSchemaSequence) { XmlSchemaSequence seq = particle as XmlSchemaSequence; if (seq.Items.Count != 1) return false; return CanBeArray (typeQName, (XmlSchemaParticle)seq.Items[0], multiValue); } if (particle is XmlSchemaChoice) { // Can be array if all choices have different types ArrayList types = new ArrayList (); if(!CheckChoiceType (typeQName, particle, types, ref multiValue)) return false; return multiValue; } return false; }
private bool IsValidOccurrenceRangeRestriction(XmlSchemaParticle derivedParticle, XmlSchemaParticle baseParticle) { return this.IsValidOccurrenceRangeRestriction(derivedParticle.MinOccurs, derivedParticle.MaxOccurs, baseParticle.MinOccurs, baseParticle.MaxOccurs); }
internal override bool ValidateDerivationByRestriction (XmlSchemaParticle baseParticle, ValidationEventHandler h, XmlSchema schema, bool raiseError) { if (TargetGroup != null) return TargetGroup.Particle.ValidateDerivationByRestriction (baseParticle, h, schema, raiseError); else return false; // should not occur }
private bool IsValidRestriction(XmlSchemaParticle derivedParticle, XmlSchemaParticle baseParticle) { if (derivedParticle == baseParticle) { return true; } if ((derivedParticle == null) || (derivedParticle == XmlSchemaParticle.Empty)) { return this.IsParticleEmptiable(baseParticle); } if ((baseParticle != null) && (baseParticle != XmlSchemaParticle.Empty)) { if (baseParticle is XmlSchemaElement) { return ((derivedParticle is XmlSchemaElement) && this.IsElementFromElement((XmlSchemaElement) derivedParticle, (XmlSchemaElement) baseParticle)); } if (baseParticle is XmlSchemaAny) { if (derivedParticle is XmlSchemaElement) { return this.IsElementFromAny((XmlSchemaElement) derivedParticle, (XmlSchemaAny) baseParticle); } if (derivedParticle is XmlSchemaAny) { return this.IsAnyFromAny((XmlSchemaAny) derivedParticle, (XmlSchemaAny) baseParticle); } return this.IsGroupBaseFromAny((XmlSchemaGroupBase) derivedParticle, (XmlSchemaAny) baseParticle); } if (baseParticle is XmlSchemaAll) { if (derivedParticle is XmlSchemaElement) { return this.IsElementFromGroupBase((XmlSchemaElement) derivedParticle, (XmlSchemaGroupBase) baseParticle, true); } if (derivedParticle is XmlSchemaAll) { return this.IsGroupBaseFromGroupBase((XmlSchemaGroupBase) derivedParticle, (XmlSchemaGroupBase) baseParticle, true); } if (derivedParticle is XmlSchemaSequence) { return this.IsSequenceFromAll((XmlSchemaSequence) derivedParticle, (XmlSchemaAll) baseParticle); } } else if (baseParticle is XmlSchemaChoice) { if (derivedParticle is XmlSchemaElement) { return this.IsElementFromGroupBase((XmlSchemaElement) derivedParticle, (XmlSchemaGroupBase) baseParticle, false); } if (derivedParticle is XmlSchemaChoice) { return this.IsGroupBaseFromGroupBase((XmlSchemaGroupBase) derivedParticle, (XmlSchemaGroupBase) baseParticle, false); } if (derivedParticle is XmlSchemaSequence) { return this.IsSequenceFromChoice((XmlSchemaSequence) derivedParticle, (XmlSchemaChoice) baseParticle); } } else if (baseParticle is XmlSchemaSequence) { if (derivedParticle is XmlSchemaElement) { return this.IsElementFromGroupBase((XmlSchemaElement) derivedParticle, (XmlSchemaGroupBase) baseParticle, true); } if (derivedParticle is XmlSchemaSequence) { return this.IsGroupBaseFromGroupBase((XmlSchemaGroupBase) derivedParticle, (XmlSchemaGroupBase) baseParticle, true); } } } return false; }
public Particle(XmlSchemaParticle particle) { XmlParticle = particle; MinOccurs = particle.MinOccurs; MaxOccurs = particle.MaxOccurs; }
private static void CleanupParticle(XmlSchemaParticle particle) { if (particle is XmlSchemaElement) { CleanupElement((XmlSchemaElement) particle); } else if (particle is XmlSchemaGroupBase) { XmlSchemaObjectCollection items = ((XmlSchemaGroupBase) particle).Items; for (int i = 0; i < items.Count; i++) { CleanupParticle((XmlSchemaParticle) items[i]); } } }
private XmlSchemaParticle CompileContentTypeParticle(XmlSchemaParticle particle, bool substitution) { XmlSchemaParticle particle2 = this.CannonicalizeParticle(particle, true, substitution); XmlSchemaChoice source = particle2 as XmlSchemaChoice; if ((source == null) || (source.Items.Count != 0)) { return particle2; } if (source.MinOccurs != 0M) { base.SendValidationEvent("Sch_EmptyChoice", source, XmlSeverityType.Warning); } return XmlSchemaParticle.Empty; }
/// <summary> /// Determines if the given XML particle contains the given sibling elements, and populates /// the list of elements that are eligible to be the next element in the XML document. /// </summary> /// <remarks> /// A particle contains the siblings if the siblings are children of the given particle. /// </remarks> /// <param name="p_xspParticle">That XML particle for which it is to be determined if it /// contains the given sibling element.</param> /// <param name="p_lstChoices">The list of elements that are eligible to be the next element in the XML document.</param> /// <param name="p_lstSiblings">A list of sibling elements.</param> /// <returns><lang cref="true"/> if the given siblings are contained by the given particle.</returns> private bool ContainsSiblings(XmlSchemaParticle p_xspParticle, ref List<KeyValuePair<string, string>> p_lstChoices, List<string> p_lstSiblings) { if (p_xspParticle is XmlSchemaElement) { XmlSchemaElement xseElement = (XmlSchemaElement)p_xspParticle; string strLastSibling = null; if (p_lstSiblings.Count > 0) strLastSibling = p_lstSiblings[p_lstSiblings.Count - 1]; return xseElement.Name.Equals(strLastSibling); } else if (p_xspParticle is XmlSchemaSequence) { XmlSchemaSequence xssSequence = (XmlSchemaSequence)p_xspParticle; bool booFound = false; Int32 i = 0; XmlSchemaParticle xspParticle = null; for (i = 0; i < xssSequence.Items.Count; i++) { xspParticle = (XmlSchemaParticle)xssSequence.Items[i]; if (ContainsSiblings(xspParticle, ref p_lstChoices, p_lstSiblings)) { booFound = true; break; } } if (booFound) { if (p_lstChoices == null) { Int32 intLastSiblingCount = 1; for (intLastSiblingCount = p_lstSiblings.Count - 1; (intLastSiblingCount > -1) && p_lstSiblings[intLastSiblingCount].Equals(p_lstSiblings[p_lstSiblings.Count - 1]); intLastSiblingCount--) ; intLastSiblingCount = p_lstSiblings.Count - intLastSiblingCount - 1; List<KeyValuePair<string, string>> lstChoices = new List<KeyValuePair<string, string>>(); if (intLastSiblingCount < xspParticle.MaxOccurs) lstChoices.AddRange(GetChildrenElements(xspParticle)); for (i++; i < xssSequence.Items.Count; i++) { xspParticle = (XmlSchemaParticle)xssSequence.Items[i]; lstChoices.AddRange(GetChildrenElements(xspParticle)); if (xspParticle.MinOccurs > 0) break; } if (lstChoices.Count > 0) p_lstChoices = lstChoices; } return true; } } else if (p_xspParticle is XmlSchemaChoice) { XmlSchemaChoice xscChoice = (XmlSchemaChoice)p_xspParticle; foreach (XmlSchemaParticle xspParticle in xscChoice.Items) if (ContainsSiblings(xspParticle, ref p_lstChoices, p_lstSiblings)) return true; } else if (p_xspParticle is XmlSchemaAll) { XmlSchemaAll xsaAll = (XmlSchemaAll)p_xspParticle; bool booFound = false; foreach (XmlSchemaParticle xspParticle in xsaAll.Items) { if (ContainsSiblings(xspParticle, ref p_lstChoices, p_lstSiblings)) { booFound = true; break; } } if (booFound) { if (p_lstChoices == null) { List<KeyValuePair<string, string>> lstChoices = new List<KeyValuePair<string, string>>(); List<string> lstSibling = new List<string>(); Int32 intFoundCount = 0; foreach (XmlSchemaParticle xspParticle in xsaAll.Items) { booFound = false; foreach (string strSibling in p_lstSiblings) { lstSibling.Clear(); lstSibling.Add(strSibling); if (ContainsSiblings(xspParticle, ref lstChoices, lstSibling)) { intFoundCount++; booFound = true; break; } } if (!booFound) lstChoices.AddRange(GetChildrenElements(xspParticle)); } if (intFoundCount < xsaAll.Items.Count) p_lstChoices = lstChoices; } return true; } } return false; }
private void CompileParticleElements(XmlSchemaComplexType complexType, XmlSchemaParticle particle) { if (particle is XmlSchemaElement) { XmlSchemaElement xe = (XmlSchemaElement) particle; this.CompileElement(xe); if (complexType.LocalElements[xe.QualifiedName] == null) { complexType.LocalElements.Add(xe.QualifiedName, xe); } else { XmlSchemaElement element2 = (XmlSchemaElement) complexType.LocalElements[xe.QualifiedName]; if (element2.ElementSchemaType != xe.ElementSchemaType) { base.SendValidationEvent("Sch_ElementTypeCollision", particle); } } } else if (particle is XmlSchemaGroupBase) { XmlSchemaObjectCollection items = ((XmlSchemaGroupBase) particle).Items; for (int i = 0; i < items.Count; i++) { this.CompileParticleElements(complexType, (XmlSchemaParticle) items[i]); } } }
/// <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; }
private int GetMappingParticle(XmlSchemaParticle particle, XmlSchemaObjectCollection collection) { for (int i = 0; i < collection.Count; i++) { if (this.IsValidRestriction(particle, (XmlSchemaParticle) collection[i])) { return i; } } return -1; }
private void PreprocessParticle(XmlSchemaParticle particle) { XmlSchemaObjectCollection items; if (particle is XmlSchemaAll) { if ((particle.MinOccurs != 0M) && (particle.MinOccurs != 1M)) { particle.MinOccurs = 1M; base.SendValidationEvent("Sch_InvalidAllMin", particle); } if (particle.MaxOccurs != 1M) { particle.MaxOccurs = 1M; base.SendValidationEvent("Sch_InvalidAllMax", particle); } items = ((XmlSchemaAll) particle).Items; for (int i = 0; i < items.Count; i++) { XmlSchemaElement source = (XmlSchemaElement) items[i]; if ((source.MaxOccurs != 0M) && (source.MaxOccurs != 1M)) { source.MaxOccurs = 1M; base.SendValidationEvent("Sch_InvalidAllElementMax", source); } this.SetParent(source, particle); this.PreprocessLocalElement(source); } } else { if (particle.MinOccurs > particle.MaxOccurs) { particle.MinOccurs = particle.MaxOccurs; base.SendValidationEvent("Sch_MinGtMax", particle); } if (particle is XmlSchemaChoice) { items = ((XmlSchemaChoice) particle).Items; for (int j = 0; j < items.Count; j++) { this.SetParent(items[j], particle); XmlSchemaElement element = items[j] as XmlSchemaElement; if (element != null) { this.PreprocessLocalElement(element); } else { this.PreprocessParticle((XmlSchemaParticle) items[j]); } } } else if (particle is XmlSchemaSequence) { items = ((XmlSchemaSequence) particle).Items; for (int k = 0; k < items.Count; k++) { this.SetParent(items[k], particle); XmlSchemaElement element3 = items[k] as XmlSchemaElement; if (element3 != null) { this.PreprocessLocalElement(element3); } else { this.PreprocessParticle((XmlSchemaParticle) items[k]); } } } else if (particle is XmlSchemaGroupRef) { XmlSchemaGroupRef ref2 = (XmlSchemaGroupRef) particle; if (ref2.RefName.IsEmpty) { base.SendValidationEvent("Sch_MissAttribute", "ref", ref2); } else { this.ValidateQNameAttribute(ref2, "ref", ref2.RefName); } } else if (particle is XmlSchemaAny) { try { ((XmlSchemaAny) particle).BuildNamespaceList(this.targetNamespace); } catch (FormatException exception) { base.SendValidationEvent("Sch_InvalidAnyDetailed", new string[] { exception.Message }, exception, particle); } } } this.PreprocessAnnotation(particle); this.ValidateIdAttribute(particle); }
void ImportGroupMembers(XmlSchemaParticle particle, CodeIdentifiers members, string ns) { XmlQualifiedName parentType = XmlSchemas.GetParentName(particle); if (particle is XmlSchemaGroupRef) { throw new InvalidOperationException(Res.GetString(Res.XmlSoapUnsupportedGroupRef, parentType.Name, parentType.Namespace)); } else if (particle is XmlSchemaGroupBase) { XmlSchemaGroupBase group = (XmlSchemaGroupBase)particle; if (group.IsMultipleOccurrence) throw new InvalidOperationException(Res.GetString(Res.XmlSoapUnsupportedGroupRepeat, parentType.Name, parentType.Namespace)); for (int i = 0; i < group.Items.Count; i++) { object item = group.Items[i]; if (item is XmlSchemaGroupBase || item is XmlSchemaGroupRef) throw new InvalidOperationException(Res.GetString(Res.XmlSoapUnsupportedGroupNested, parentType.Name, parentType.Namespace)); else if (item is XmlSchemaElement) ImportElementMember((XmlSchemaElement)item, members, ns); else if (item is XmlSchemaAny) throw new InvalidOperationException(Res.GetString(Res.XmlSoapUnsupportedGroupAny, parentType.Name, parentType.Namespace)); } } }