private void ProcessGroup(InstanceGroup grp) { if (grp is InstanceElement) { ProcessElement((InstanceElement)grp); } else { //Its a group node of sequence or choice if (!grp.IsChoice) { for (int i = 0; i < grp.Occurs; i++) { InstanceGroup childGroup = grp.Child; while (childGroup != null) { ProcessGroup(childGroup); childGroup = childGroup.Sibling; } } } else { ProcessChoiceGroup(grp); } } }
private void ProcessChoiceGroup(InstanceGroup grp) { for (int i = 0; i < grp.Occurs; i++) { //Cyclically iterate over the children of choice ProcessGroup(grp.GetChild(i % grp.NoOfChildren)); } }
private void GenerateGroupBase(XmlSchemaGroupBase gBase, InstanceGroup grp) { foreach (XmlSchemaParticle particle1 in gBase.Items) { GenerateParticle(particle1, false, grp); } }
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 ProcessElement(InstanceElement elem) { if (_instanceElementsProcessed[elem] != null) { return; } _instanceElementsProcessed.Add(elem, elem); for (int i = 0; i < elem.Occurs; i++) { _writer.WriteStartElement(elem.QualifiedName.Name, elem.QualifiedName.Namespace); ProcessElementAttrs(elem); ProcessComment(elem); CheckIfMixed(elem); if (elem.IsNillable) { if (elem.GenNil) { WriteNillable(); elem.GenNil = false; _writer.WriteEndElement(); continue; } else { elem.GenNil = true; } } if (elem.ValueGenerator != null) { if (elem.IsFixed) { _writer.WriteString(elem.FixedValue); } else if (elem.HasDefault) { _writer.WriteString(elem.DefaultValue); } else { _writer.WriteString(elem.ValueGenerator.GenerateValue()); } } else { InstanceGroup childGroup = elem.Child; while (childGroup != null) { ProcessGroup(childGroup); childGroup = childGroup.Sibling; } } _writer.WriteEndElement(); } _instanceElementsProcessed.Remove(elem); }
private void GenerateAll(XmlSchemaAll all, InstanceGroup grp) { XmlSchemaParticle pt; for (int i = all.Items.Count; i > 0; i--) { pt = (XmlSchemaParticle)(all.Items[i - 1]); GenerateParticle(pt, false, grp); } }
private InstanceElement GetParentInstanceElement(InstanceGroup grp) { InstanceElement elem = grp as InstanceElement; while (elem == null && grp != null) { grp = grp.Parent; elem = grp as InstanceElement; } return(elem); }
private void ProcessInstanceTree(InstanceElement rootElement) { if (rootElement != null) { _instanceElementsProcessed.Add(rootElement, rootElement); _writer.WriteStartElement(rootElement.QualifiedName.Name, _rootTargetNamespace); _writer.WriteAttributeString("xmlns", "xsi", null, NsXsi); ProcessElementAttrs(rootElement); ProcessComment(rootElement); CheckIfMixed(rootElement); if (rootElement.ValueGenerator != null) { if (rootElement.IsFixed) { _writer.WriteString(rootElement.FixedValue); } else if (rootElement.HasDefault) { _writer.WriteString(rootElement.DefaultValue); } else { _writer.WriteString(rootElement.ValueGenerator.GenerateValue()); } } else { InstanceGroup group = rootElement.Child; while (group != null) { ProcessGroup(group); group = group.Sibling; } } _writer.WriteEndElement(); } else { _writer.WriteComment("Schema did not lead to generation of a valid XML document"); } }
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); }