// It makes complexType not to have Simple content model. private void ToComplexContentType(ComplexType type) { SimpleModel sm = type.ContentModel as SimpleModel; if (sm == null) { return; } SOMList atts = GetAttributes(type); foreach (SOMObject o in atts) { type.Attributes.Add(o); } // FIXME: need to copy AnyAttribute. // (though not considered right now) type.ContentModel = null; type.IsMixed = true; }
private Hashtable CollectAttrTable(SOMList attList) { // get attribute definition table. Hashtable table = new Hashtable(); foreach (XmlSchemaObject obj in attList) { Attr attr = obj as Attr; if (attr == null) { throw Error(obj, String.Format("Attribute inference only supports direct attribute definition. {0} is not supported.", obj.GetType())); } if (attr.RefName != QName.Empty) { table.Add(attr.RefName, attr); } else { table.Add(new QName(attr.Name, ""), attr); } } return(table); }
public XmlSchemaSimpleContentRestriction() { baseTypeName = XmlQualifiedName.Empty; attributes = new XmlSchemaObjectCollection(); facets = new XmlSchemaObjectCollection(); }
public XmlSchemaComplexContentExtension() { attributes = new XmlSchemaObjectCollection(); baseTypeName = XmlQualifiedName.Empty; }
public XmlSchemaAll() { items = new XmlSchemaObjectCollection(); }
public XmlSchemaSequence() { items = new XmlSchemaObjectCollection(); }
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle, ValidationEventHandler h, XmlSchema schema, bool raiseError) { if (this == baseParticle) // quick check { return(true); } XmlSchemaElement el = baseParticle as XmlSchemaElement; if (el != null) { // Forbidden if (raiseError) { error(h, "Invalid sequence paricle derivation."); } return(false); } XmlSchemaSequence seq = baseParticle as XmlSchemaSequence; if (seq != null) { // Recurse if (!ValidateOccurenceRangeOK(seq, h, schema, raiseError)) { return(false); } // If it is totally optional, then ignore their contents. if (seq.ValidatedMinOccurs == 0 && seq.ValidatedMaxOccurs == 0 && this.ValidatedMinOccurs == 0 && this.ValidatedMaxOccurs == 0) { return(true); } return(ValidateRecurse(seq, h, schema, raiseError)); } XmlSchemaAll all = baseParticle as XmlSchemaAll; if (all != null) { // RecurseUnordered XmlSchemaObjectCollection already = new XmlSchemaObjectCollection(); for (int i = 0; i < this.Items.Count; i++) { XmlSchemaElement de = this.Items [i] as XmlSchemaElement; if (de == null) { if (raiseError) { error(h, "Invalid sequence particle derivation by restriction from all."); } return(false); } foreach (XmlSchemaElement e in all.Items) { if (e.QualifiedName == de.QualifiedName) { if (already.Contains(e)) { if (raiseError) { error(h, "Base element particle is mapped to the derived element particle in a sequence two or more times."); } return(false); } else { already.Add(e); if (!de.ValidateDerivationByRestriction(e, h, schema, raiseError)) { return(false); } } } } } foreach (XmlSchemaElement e in all.Items) { if (!already.Contains(e)) { if (!e.ValidateIsEmptiable()) { if (raiseError) { error(h, "In base -all- particle, mapping-skipped base element which is not emptiable was found."); } return(false); } } } return(true); } XmlSchemaAny any = baseParticle as XmlSchemaAny; if (any != null) { // NSRecurseCheckCardinality return(ValidateNSRecurseCheckCardinality(any, h, schema, raiseError)); } XmlSchemaChoice choice = baseParticle as XmlSchemaChoice; if (choice != null) { // MapAndSum // In fact it is not Recurse, but it looks almost common. return(ValidateSeqRecurseMapSumCommon(choice, h, schema, false, true, raiseError)); } return(true); }
private void InferAttributes(Element el, string ns, bool isNew) { // Now this element is going to have complexType. // It currently not, then we have to replace it. ComplexType ct = null; SOMList attList = null; Hashtable table = null; do { switch (source.NamespaceURI) { case NamespaceXml: if (schemas.Schemas( NamespaceXml).Count == 0) { IncludeXmlAttributes(); } break; case XmlSchema.InstanceNamespace: if (source.LocalName == "nil") { el.IsNillable = true; } // all other xsi:* atts are ignored continue; case NamespaceXmlns: continue; } if (ct == null) { ct = ToComplexType(el); attList = GetAttributes(ct); table = CollectAttrTable(attList); } QName attrName = new QName( source.LocalName, source.NamespaceURI); Attr attr = table [attrName] as Attr; if (attr == null) { attList.Add(InferNewAttribute( attrName, isNew, ns)); } else { table.Remove(attrName); if (attr.RefName != null && attr.RefName != QName.Empty) { continue; // just a reference } InferMergedAttribute(attr); } } while (source.MoveToNextAttribute()); // mark all attr definitions that did not appear // as optional. if (table != null) { foreach (Attr attr in table.Values) { attr.Use = Use.Optional; } } }