private void GenerateParticle(XmlSchemaParticle particle, bool root, InstanceGroup iGrp) { decimal max; max = particle.MaxOccurs >= _maxThreshold ? _maxThreshold : particle.MaxOccurs; max = particle.MinOccurs > max ? particle.MinOccurs : max; if (particle is XmlSchemaSequence) { XmlSchemaSequence seq = (XmlSchemaSequence)particle; InstanceGroup grp = new InstanceGroup(); grp.Occurs = max; iGrp.AddChild(grp); GenerateGroupBase(seq, grp); } else if (particle is XmlSchemaChoice) { XmlSchemaChoice ch = (XmlSchemaChoice)particle; if (ch.MaxOccurs == 1) { XmlSchemaParticle pt = (XmlSchemaParticle)(ch.Items[0]); GenerateParticle(pt, false, iGrp); } else { InstanceGroup grp = new InstanceGroup(); grp.Occurs = max; grp.IsChoice = true; iGrp.AddChild(grp); GenerateGroupBase(ch, grp); } } else if (particle is XmlSchemaAll) { GenerateAll((XmlSchemaAll)particle, iGrp); } else if (particle is XmlSchemaElement) { XmlSchemaElement elem = particle as XmlSchemaElement; XmlSchemaChoice ch = null; if (!elem.RefName.IsEmpty) { ch = GetSubstitutionChoice(elem); } if (ch != null) { GenerateParticle(ch, false, iGrp); } else { GenerateElement(elem, false, iGrp, null); } } else if (particle is XmlSchemaAny && particle.MinOccurs > 0) { //Generate any only if we should GenerateAny((XmlSchemaAny)particle, iGrp); } }
private void GenerateAny(XmlSchemaAny any, InstanceGroup grp) { InstanceElement parentElem = grp as InstanceElement; char[] whitespace = new char[] { ' ', '\t', '\n', '\r' }; InstanceElement elem = null; XmlSchemaElement anyElem = null; string namespaceList = any.Namespace; if (namespaceList == null) { //no namespace defaults to "##any" namespaceList = "##any"; } if (any.ProcessContents == XmlSchemaContentProcessing.Skip || any.ProcessContents == XmlSchemaContentProcessing.Lax) { if (namespaceList == "##any" || namespaceList == "##targetNamespace") { elem = new InstanceElement(new XmlQualifiedName("any_element", _rootTargetNamespace)); } else if (namespaceList == "##local") { elem = new InstanceElement(new XmlQualifiedName("any_element", string.Empty)); } else if (namespaceList == "##other") { elem = new InstanceElement(new XmlQualifiedName("any_element", "otherNS")); } if (elem != null) { elem.ValueGenerator = XmlValueGenerator._anyGenerator; elem.Occurs = any.MaxOccurs >= _maxThreshold ? _maxThreshold : any.MaxOccurs; elem.Occurs = any.MinOccurs > elem.Occurs ? any.MinOccurs : elem.Occurs; grp.AddChild(elem); return; } } //ProcessContents = strict || namespaceList is actually a list of namespaces switch (namespaceList) { case "##any": case "##targetNamespace": anyElem = GetElementFromNS(_rootTargetNamespace); break; case "##other": XmlSchema anySchema = GetParentSchema(any); anyElem = GetElementFromNS(anySchema.TargetNamespace, true); break; case "##local": //Shd get local elements in some schema anyElem = GetElementFromNS(string.Empty); break; default: foreach (string ns in namespaceList.Split(whitespace)) { if (ns == "##targetNamespace") { anyElem = GetElementFromNS(_rootTargetNamespace); } else if (ns == "##local") { anyElem = GetElementFromNS(string.Empty); } else { anyElem = GetElementFromNS(ns); } if (anyElem != null) { //found a match break; } } break; } if (anyElem != null && GenerateElement(anyElem, false, grp, any)) { return; } else { //Write comment in generated XML that match for wild card cd not be found. if (parentElem == null) { parentElem = GetParentInstanceElement(grp); } if (parentElem.Comment.Length == 0) { //For multiple wildcards in the same element, generate comment only once parentElem.Comment.Append(" Element Wild card could not be matched. Generated XML may not be valid. "); } } }
private bool GenerateElement(XmlSchemaElement e, bool root, InstanceGroup parentElem, XmlSchemaAny any) { XmlSchemaElement eGlobalDecl = e; if (!e.RefName.IsEmpty) { eGlobalDecl = (XmlSchemaElement)_schemaSet.GlobalElements[e.QualifiedName]; } if (!eGlobalDecl.IsAbstract) { InstanceElement elem = (InstanceElement)_elementTypesProcessed[eGlobalDecl]; if (elem != null) { Debug.Assert(!root); if (any == null && e.MinOccurs > 0) { //If not generating for any or optional ref to cyclic global element decimal occurs = e.MaxOccurs; if (e.MaxOccurs >= _maxThreshold) { occurs = _maxThreshold; } if (e.MinOccurs > occurs) { occurs = e.MinOccurs; } parentElem.AddChild(elem.Clone(occurs)); } return(false); } elem = new InstanceElement(eGlobalDecl.QualifiedName); if (root) { _instanceRoot = elem; } else { parentElem.AddChild(elem); } //Get minOccurs, maxOccurs alone from the current particle, everything else pick up from globalDecl if (any != null) { //Element from any elem.Occurs = any.MaxOccurs >= _maxThreshold ? _maxThreshold : any.MaxOccurs; elem.Occurs = any.MinOccurs > elem.Occurs ? any.MinOccurs : elem.Occurs; } else { elem.Occurs = e.MaxOccurs >= _maxThreshold ? _maxThreshold : e.MaxOccurs; elem.Occurs = e.MinOccurs > elem.Occurs ? e.MinOccurs : elem.Occurs; } elem.DefaultValue = eGlobalDecl.DefaultValue; elem.FixedValue = eGlobalDecl.FixedValue; elem.IsNillable = eGlobalDecl.IsNillable; if (eGlobalDecl.ElementSchemaType == _anyType) { elem.ValueGenerator = XmlValueGenerator._anyGenerator; } else { XmlSchemaComplexType ct = eGlobalDecl.ElementSchemaType as XmlSchemaComplexType; if (ct != null) { _elementTypesProcessed.Add(eGlobalDecl, elem); if (!ct.IsAbstract) { elem.IsMixed = ct.IsMixed; ProcessComplexType(ct, elem); } else { // Ct is abstract, need to generate instance elements with xsi:type XmlSchemaComplexType dt = GetDerivedType(ct); if (dt != null) { elem.XsiType = dt.QualifiedName; ProcessComplexType(dt, elem); } } } else { //elementType is XmlSchemaSimpleType elem.ValueGenerator = XmlValueGenerator.CreateGenerator(eGlobalDecl.ElementSchemaType.Datatype, _listLength); } } if (elem.ValueGenerator != null && elem.ValueGenerator.Prefix == null) { elem.ValueGenerator.Prefix = elem.QualifiedName.Name; } return(true); } // End of e.IsAbstract return(false); }