internal override int Compile(ValidationEventHandler h, XmlSchema schema) { if (this.CompilationId == schema.CompilationId) { return(0); } if (this.Content == null) { base.error(h, "Content must be present in a simpleContent"); } else if (this.Content is XmlSchemaSimpleContentRestriction) { XmlSchemaSimpleContentRestriction xmlSchemaSimpleContentRestriction = (XmlSchemaSimpleContentRestriction)this.Content; this.errorCount += xmlSchemaSimpleContentRestriction.Compile(h, schema); } else if (this.Content is XmlSchemaSimpleContentExtension) { XmlSchemaSimpleContentExtension xmlSchemaSimpleContentExtension = (XmlSchemaSimpleContentExtension)this.Content; this.errorCount += xmlSchemaSimpleContentExtension.Compile(h, schema); } else { base.error(h, "simpleContent can't have any value other than restriction or extention"); } XmlSchemaUtil.CompileID(base.Id, this, schema.IDCollection, h); this.CompilationId = schema.CompilationId; return(this.errorCount); }
///<remarks> /// 1. Content must be present and one of restriction or extention ///</remarks> internal override int Compile(ValidationEventHandler h, XmlSchema schema) { // If this is already compiled this time, simply skip. if (CompilationId == schema.CompilationId) { return(0); } if (Content == null) { error(h, "Content must be present in a simpleContent"); } else { if (Content is XmlSchemaSimpleContentRestriction) { XmlSchemaSimpleContentRestriction xscr = (XmlSchemaSimpleContentRestriction)Content; errorCount += xscr.Compile(h, schema); } else if (Content is XmlSchemaSimpleContentExtension) { XmlSchemaSimpleContentExtension xsce = (XmlSchemaSimpleContentExtension)Content; errorCount += xsce.Compile(h, schema); } else { error(h, "simpleContent can't have any value other than restriction or extention"); } } XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h); this.CompilationId = schema.CompilationId; return(errorCount); }
private void AddValueProperty(ClassInfo classInfo, XmlSchemaSimpleContentExtension sce) { var propInfo = new PropertyInfo(classInfo) { IsList = false, XmlName = "Value", XmlType = ResolveSimpleTypeName(sce.BaseTypeName.Name), IsElementValue = true }; if (!classInfo.Elements.Contains(propInfo)) classInfo.Elements.Add(propInfo); }
private SOMList GetAttributes(ComplexType ct) { if (ct.ContentModel == null) { return(ct.Attributes); } SimpleModel sc = ct.ContentModel as SimpleModel; if (sc != null) { SimpleExt sce = sc.Content as SimpleExt; if (sce != null) { return(sce.Attributes); } SimpleRst scr = sc.Content as SimpleRst; if (scr != null) { return(scr.Attributes); } else { throw Error(sc, "Invalid simple content model."); } } ComplexModel cc = ct.ContentModel as ComplexModel; if (cc != null) { ComplexExt cce = cc.Content as ComplexExt; if (cce != null) { return(cce.Attributes); } ComplexRst ccr = cc.Content as ComplexRst; if (ccr != null) { return(ccr.Attributes); } else { throw Error(cc, "Invalid simple content model."); } } throw Error(cc, "Invalid complexType. Should not happen."); }
private void ToEmptiableSimpleContent( SimpleModel sm, bool isNew) { SimpleExt se = sm.Content as SimpleExt; if (se != null) { se.BaseTypeName = QNameString; } else { SimpleRst sr = sm.Content as SimpleRst; if (sr == null) { throw Error(sm, "Invalid simple content model was passed."); } sr.BaseTypeName = QNameString; sr.BaseType = null; } }
void Write38_XmlSchemaSimpleContentExtension(XmlSchemaSimpleContentExtension o) { if ((object)o == null) return; WriteStartElement("extension"); WriteAttribute(@"id", @"", ((System.String)o.@Id)); WriteAttributes((XmlAttribute[])o.@UnhandledAttributes, o); if ([email protected]){ WriteAttribute(@"base", @"", o.@BaseTypeName); } Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.@Annotation); WriteSortedItems(o.Attributes); Write33_XmlSchemaAnyAttribute((XmlSchemaAnyAttribute)o.@AnyAttribute); WriteEndElement(); }
internal void ProcessAttributes(ref XmlSchemaElement xse, XmlSchemaType effectiveSchemaType, bool bCreatingNewType, XmlSchema parentSchema) { XmlSchemaObjectCollection attributesSeen = new XmlSchemaObjectCollection(); XmlSchemaComplexType ct = effectiveSchemaType as XmlSchemaComplexType; Debug.Assert(xtr.NodeType == XmlNodeType.Attribute); do { if (xtr.NamespaceURI == XmlSchema.Namespace) { throw new XmlSchemaInferenceException(Res.SchInf_schema, 0, 0); } if (xtr.NamespaceURI == XmlReservedNs.NsXmlNs) { if (xtr.Prefix=="xmlns") NamespaceManager.AddNamespace(xtr.LocalName, xtr.Value); } else if (xtr.NamespaceURI == XmlReservedNs.NsXsi) { string localName = xtr.LocalName; if (localName == "nil") { xse.IsNillable = true; } else if (localName != "type" && localName != "schemaLocation" && localName != "noNamespaceSchemaLocation") { throw new XmlSchemaInferenceException(Res.Sch_NotXsiAttribute,localName); } } else { if (ct == null || ct == XmlSchemaComplexType.AnyType) { ct = new XmlSchemaComplexType(); xse.SchemaType = ct; } XmlSchemaAttribute xsa=null; //The earlier assumption of checking just schemaTypeName !Empty is not correct for schemas that are not generated by us, schemaTypeName can point to any complex type as well //Check that it is a simple type by checking typeCode //Switch to complex type simple content extension if (effectiveSchemaType != null && effectiveSchemaType.Datatype != null && !xse.SchemaTypeName.IsEmpty) { //type was previously simple type, now it will become complex with simple type extension Debug.Assert(ct != null); XmlSchemaSimpleContent sc = new XmlSchemaSimpleContent(); ct.ContentModel = sc; XmlSchemaSimpleContentExtension sce = new XmlSchemaSimpleContentExtension(); sc.Content = sce; sce.BaseTypeName = xse.SchemaTypeName; sce.LineNumber = xse.LineNumber; xse.LineNumber = 0; xse.SchemaTypeName = XmlQualifiedName.Empty; //re-set the name } Debug.Assert(ct != null); //either the user-defined type itself is a complex type or we switched from a simple type to a complex type if (ct.ContentModel != null) { XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct); Debug.Assert(sce != null); xsa = AddAttribute(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, xtr.Value, bCreatingNewType, parentSchema, sce.Attributes, ct.AttributeUses); } else //add atributes directly to complex type { xsa = AddAttribute(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, xtr.Value, bCreatingNewType, parentSchema, ct.Attributes, ct.AttributeUses); } if (xsa != null) { attributesSeen.Add(xsa); } } } while (xtr.MoveToNextAttribute()); if (!bCreatingNewType) { //make attributes that did not appear this time optional if (ct!=null) { MakeExistingAttributesOptional(ct, attributesSeen); } } }
private void Write38_XmlSchemaSimpleContentExtension(XmlSchemaSimpleContentExtension o) { if (o != null) { this.WriteStartElement("extension"); this.WriteAttribute("id", "", o.Id); this.WriteAttributes(o.UnhandledAttributes, o); if (!o.BaseTypeName.IsEmpty) { this.WriteAttribute("base", "", o.BaseTypeName); } this.Write5_XmlSchemaAnnotation(o.Annotation); this.WriteSortedItems(o.Attributes); this.Write33_XmlSchemaAnyAttribute(o.AnyAttribute); this.WriteEndElement(); } }
//<extension //base = QName //id = ID //{any attributes with non-schema namespace . . .}> //Content: (annotation?, ((attribute | attributeGroup)*, anyAttribute?)) //</extension> internal static XmlSchemaSimpleContentExtension Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSimpleContentExtension extension = new XmlSchemaSimpleContentExtension(); reader.MoveToElement(); if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h,"Should not happen :1: XmlSchemaAttributeGroup.Read, name="+reader.Name,null); reader.Skip(); return null; } extension.LineNumber = reader.LineNumber; extension.LinePosition = reader.LinePosition; extension.SourceUri = reader.BaseURI; while(reader.MoveToNextAttribute()) { if(reader.Name == "base") { Exception innerex; extension.baseTypeName= XmlSchemaUtil.ReadQNameAttribute(reader,out innerex); if(innerex != null) error(h, reader.Value + " is not a valid value for base attribute",innerex); } else if(reader.Name == "id") { extension.Id = reader.Value; } else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h,reader.Name + " is not a valid attribute for extension in this context",null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader,extension); } } reader.MoveToElement(); if(reader.IsEmptyElement) return extension; //Content: 1.annotation?, 2.(attribute | attributeGroup)*, 3.anyAttribute? int level = 1; while(reader.ReadNextElement()) { if(reader.NodeType == XmlNodeType.EndElement) { if(reader.LocalName != xmlname) error(h,"Should not happen :2: XmlSchemaSimpleContentExtension.Read, name="+reader.Name,null); break; } if(level <= 1 && reader.LocalName == "annotation") { level = 2; //Only one annotation XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h); if(annotation != null) extension.Annotation = annotation; continue; } if(level <= 2) { if(reader.LocalName == "attribute") { level = 2; XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader,h); if(attr != null) extension.Attributes.Add(attr); continue; } if(reader.LocalName == "attributeGroup") { level = 2; XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader,h); if(attr != null) extension.attributes.Add(attr); continue; } } if(level <= 3 && reader.LocalName == "anyAttribute") { level = 4; XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader,h); if(anyattr != null) extension.AnyAttribute = anyattr; continue; } reader.RaiseInvalidElementError(); } return extension; }
private ComplexType ToComplexType (Element el) { QName name = el.SchemaTypeName; XmlSchemaType type = el.SchemaType; // 1. element type is complex. ComplexType ct = type as ComplexType; if (ct != null) return ct; // 2. reference to global complexType. XmlSchemaType globalType = schemas.GlobalTypes [name] as XmlSchemaType; ct = globalType as ComplexType; if (ct != null) return ct; ct = new ComplexType (); el.SchemaType = ct; el.SchemaTypeName = QName.Empty; // 3. base type name is xs:anyType or no specification. // <xs:complexType /> if (name == QNameAnyType) return ct; else if (type == null && name == QName.Empty) return ct; SimpleModel sc = new SimpleModel (); ct.ContentModel = sc; // 4. type is simpleType // -> extension of existing simple type. SimpleType st = type as SimpleType; if (st != null) { SimpleRst scr = new SimpleRst (); scr.BaseType = st; sc.Content = scr; return ct; } SimpleExt sce = new SimpleExt (); sc.Content = sce; // 5. type name points to primitive type // -> simple extension of a primitive type st = XmlSchemaType.GetBuiltInSimpleType (name); if (st != null) { sce.BaseTypeName = name; return ct; } // 6. type name points to global simpleType. st = globalType as SimpleType; if (st != null) { sce.BaseTypeName = name; return ct; } throw Error (el, "Unexpected schema component that contains simpleTypeName that could not be resolved."); }
//<extension //base = QName //id = ID //{any attributes with non-schema namespace . . .}> //Content: (annotation?, ((attribute | attributeGroup)*, anyAttribute?)) //</extension> internal static XmlSchemaSimpleContentExtension Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSimpleContentExtension extension = new XmlSchemaSimpleContentExtension(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaAttributeGroup.Read, name=" + reader.Name, null); reader.Skip(); return(null); } extension.LineNumber = reader.LineNumber; extension.LinePosition = reader.LinePosition; extension.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "base") { Exception innerex; extension.baseTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex); if (innerex != null) { error(h, reader.Value + " is not a valid value for base attribute", innerex); } } else if (reader.Name == "id") { extension.Id = reader.Value; } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for extension in this context", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, extension); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(extension); } //Content: 1.annotation?, 2.(attribute | attributeGroup)*, 3.anyAttribute? int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaSimpleContentExtension.Read, name=" + reader.Name, null); } break; } if (level <= 1 && reader.LocalName == "annotation") { level = 2; //Only one annotation XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h); if (annotation != null) { extension.Annotation = annotation; } continue; } if (level <= 2) { if (reader.LocalName == "attribute") { level = 2; XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader, h); if (attr != null) { extension.Attributes.Add(attr); } continue; } if (reader.LocalName == "attributeGroup") { level = 2; XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader, h); if (attr != null) { extension.attributes.Add(attr); } continue; } } if (level <= 3 && reader.LocalName == "anyAttribute") { level = 4; XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader, h); if (anyattr != null) { extension.AnyAttribute = anyattr; } continue; } reader.RaiseInvalidElementError(); } return(extension); }
XmlSchemaAttribute FindAttribute(XmlSchemaSimpleContentExtension extension, string name) { return FindAttribute(extension.Attributes, name); }
void ExportTypeMembers(XmlSchemaComplexType type, MemberMapping[] members, string name, string ns, bool hasSimpleContent, bool openModel) { XmlSchemaGroupBase seq = new XmlSchemaSequence(); TypeMapping textMapping = null; for (int i = 0; i < members.Length; i++) { MemberMapping member = members[i]; if (member.Ignore) continue; if (member.Text != null) { if (textMapping != null) { throw new InvalidOperationException(Res.GetString(Res.XmlIllegalMultipleText, name)); } textMapping = member.Text.Mapping; } if (member.Elements.Length > 0) { bool repeats = member.TypeDesc.IsArrayLike && !(member.Elements.Length == 1 && member.Elements[0].Mapping is ArrayMapping); bool valueTypeOptional = member.CheckSpecified != SpecifiedAccessor.None || member.CheckShouldPersist; ExportElementAccessors(seq, member.Elements, repeats, valueTypeOptional, ns); } } if (seq.Items.Count > 0) { if (type.ContentModel != null) { if (type.ContentModel.Content is XmlSchemaComplexContentRestriction) ((XmlSchemaComplexContentRestriction)type.ContentModel.Content).Particle = seq; else if (type.ContentModel.Content is XmlSchemaComplexContentExtension) ((XmlSchemaComplexContentExtension)type.ContentModel.Content).Particle = seq; else throw new InvalidOperationException(Res.GetString(Res.XmlInvalidContent, type.ContentModel.Content.GetType().Name)); } else { type.Particle = seq; } } if (textMapping != null) { if (hasSimpleContent) { if (textMapping is PrimitiveMapping && seq.Items.Count == 0) { PrimitiveMapping pm = (PrimitiveMapping)textMapping; if (pm.IsList) { type.IsMixed = true; } else { if (pm.IsAnonymousType) { throw new InvalidOperationException(Res.GetString(Res.XmlAnonymousBaseType, textMapping.TypeDesc.Name, pm.TypeDesc.Name, "AnonymousType", "false")); } // Create simpleContent XmlSchemaSimpleContent model = new XmlSchemaSimpleContent(); XmlSchemaSimpleContentExtension ex = new XmlSchemaSimpleContentExtension(); model.Content = ex; type.ContentModel = model; ex.BaseTypeName = ExportPrimitiveMapping(pm, ns); } } } else { type.IsMixed = true; } } bool anyAttribute = false; for (int i = 0; i < members.Length; i++) { AttributeAccessor accessor = members[i].Attribute; if (accessor != null) { ExportAttributeAccessor(type, members[i].Attribute, members[i].CheckSpecified != SpecifiedAccessor.None || members[i].CheckShouldPersist, ns); if (members[i].Attribute.Any) anyAttribute = true; } } if (openModel && !anyAttribute) { AttributeAccessor any = new AttributeAccessor(); any.Any = true; ExportAttributeAccessor(type, any, false, ns); } }
private static string ProcessSchemaSimpleContentExtension(XmlSchemaSimpleContentExtension schemaContentExtension) { StringBuilder result = new StringBuilder(); //if (schemaContentExtension.Annotation != null) //{ // result.AppendLine("May have nested data."); // result.Append(ProcessAnnotation(schemaContentExtension.Annotation)); //} result.Append(Process(schemaContentExtension.Attributes)); return result.ToString(); }
public override void Check (ConformanceCheckContext ctx, XmlSchemaSimpleContentExtension value) { CheckSchemaQName (ctx, value, value.BaseTypeName); }
public virtual void Check (ConformanceCheckContext ctx, XmlSchemaSimpleContentExtension value) {}
private void MoveAttributes(XmlSchemaSimpleContentExtension scExtension, XmlSchemaComplexType ct) { //copy all attributes from the simple content to the complex type //This is ok since when we move from complex type to simple content extension we copy from AttributeUses property foreach (XmlSchemaAttribute attr in scExtension.Attributes) { //since simpleContent is being cleared ct.Attributes.Add(attr); } }
internal static XmlSchemaSimpleContent Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSimpleContent xmlSchemaSimpleContent = new XmlSchemaSimpleContent(); reader.MoveToElement(); if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "simpleContent") { XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaComplexContent.Read, name=" + reader.Name, null); reader.SkipToEnd(); return(null); } xmlSchemaSimpleContent.LineNumber = reader.LineNumber; xmlSchemaSimpleContent.LinePosition = reader.LinePosition; xmlSchemaSimpleContent.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { xmlSchemaSimpleContent.Id = reader.Value; } else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema") { XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for simpleContent", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaSimpleContent); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(xmlSchemaSimpleContent); } int num = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != "simpleContent") { XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaSimpleContent.Read, name=" + reader.Name, null); } break; } if (num <= 1 && reader.LocalName == "annotation") { num = 2; XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h); if (xmlSchemaAnnotation != null) { xmlSchemaSimpleContent.Annotation = xmlSchemaAnnotation; } } else { if (num <= 2) { if (reader.LocalName == "restriction") { num = 3; XmlSchemaSimpleContentRestriction xmlSchemaSimpleContentRestriction = XmlSchemaSimpleContentRestriction.Read(reader, h); if (xmlSchemaSimpleContentRestriction != null) { xmlSchemaSimpleContent.content = xmlSchemaSimpleContentRestriction; } continue; } if (reader.LocalName == "extension") { num = 3; XmlSchemaSimpleContentExtension xmlSchemaSimpleContentExtension = XmlSchemaSimpleContentExtension.Read(reader, h); if (xmlSchemaSimpleContentExtension != null) { xmlSchemaSimpleContent.content = xmlSchemaSimpleContentExtension; } continue; } } reader.RaiseInvalidElementError(); } } return(xmlSchemaSimpleContent); }
private void MoveAttributes(XmlSchemaComplexType ct, XmlSchemaSimpleContentExtension simpleContentExtension, bool bCreatingNewType) { //copy all attributes from the complex type to the simple content ICollection sourceCollection; if (!bCreatingNewType && ct.AttributeUses.Count > 0) { sourceCollection = ct.AttributeUses.Values; } else { sourceCollection = ct.Attributes; } foreach (XmlSchemaAttribute attr in sourceCollection) { simpleContentExtension.Attributes.Add(attr); } ct.Attributes.Clear(); //Clear from pre-compiled property, post compiled will be cleared on Re-process and Compile() }
XmlCompletionDataCollection GetAttributeCompletionData(XmlSchemaSimpleContentExtension extension) { XmlCompletionDataCollection data = new XmlCompletionDataCollection(); data.AddRange(GetAttributeCompletionData(extension.Attributes)); return data; }
internal XmlSchemaObject Clone(XmlSchema parentSchema) { XmlSchemaComplexType type = (XmlSchemaComplexType) base.MemberwiseClone(); if (type.ContentModel != null) { XmlSchemaSimpleContent contentModel = type.ContentModel as XmlSchemaSimpleContent; if (contentModel != null) { XmlSchemaSimpleContent content2 = (XmlSchemaSimpleContent) contentModel.Clone(); XmlSchemaSimpleContentExtension content = contentModel.Content as XmlSchemaSimpleContentExtension; if (content != null) { XmlSchemaSimpleContentExtension extension2 = (XmlSchemaSimpleContentExtension) content.Clone(); extension2.BaseTypeName = content.BaseTypeName.Clone(); extension2.SetAttributes(CloneAttributes(content.Attributes)); content2.Content = extension2; } else { XmlSchemaSimpleContentRestriction restriction = (XmlSchemaSimpleContentRestriction) contentModel.Content; XmlSchemaSimpleContentRestriction restriction2 = (XmlSchemaSimpleContentRestriction) restriction.Clone(); restriction2.BaseTypeName = restriction.BaseTypeName.Clone(); restriction2.SetAttributes(CloneAttributes(restriction.Attributes)); content2.Content = restriction2; } type.ContentModel = content2; } else { XmlSchemaComplexContent content3 = (XmlSchemaComplexContent) type.ContentModel; XmlSchemaComplexContent content4 = (XmlSchemaComplexContent) content3.Clone(); XmlSchemaComplexContentExtension extension3 = content3.Content as XmlSchemaComplexContentExtension; if (extension3 != null) { XmlSchemaComplexContentExtension extension4 = (XmlSchemaComplexContentExtension) extension3.Clone(); extension4.BaseTypeName = extension3.BaseTypeName.Clone(); extension4.SetAttributes(CloneAttributes(extension3.Attributes)); if (HasParticleRef(extension3.Particle, parentSchema)) { extension4.Particle = CloneParticle(extension3.Particle, parentSchema); } content4.Content = extension4; } else { XmlSchemaComplexContentRestriction restriction3 = content3.Content as XmlSchemaComplexContentRestriction; XmlSchemaComplexContentRestriction restriction4 = (XmlSchemaComplexContentRestriction) restriction3.Clone(); restriction4.BaseTypeName = restriction3.BaseTypeName.Clone(); restriction4.SetAttributes(CloneAttributes(restriction3.Attributes)); if (HasParticleRef(restriction4.Particle, parentSchema)) { restriction4.Particle = CloneParticle(restriction4.Particle, parentSchema); } content4.Content = restriction4; } type.ContentModel = content4; } } else { if (HasParticleRef(type.Particle, parentSchema)) { type.Particle = CloneParticle(type.Particle, parentSchema); } type.SetAttributes(CloneAttributes(type.Attributes)); } type.ClearCompiledState(); return type; }
private ComplexType ToComplexType(Element el) { QName name = el.SchemaTypeName; XmlSchemaType type = el.SchemaType; // 1. element type is complex. ComplexType ct = type as ComplexType; if (ct != null) { return(ct); } // 2. reference to global complexType. XmlSchemaType globalType = schemas.GlobalTypes [name] as XmlSchemaType; ct = globalType as ComplexType; if (ct != null) { return(ct); } ct = new ComplexType(); el.SchemaType = ct; el.SchemaTypeName = QName.Empty; // 3. base type name is xs:anyType or no specification. // <xs:complexType /> if (name == QNameAnyType) { return(ct); } else if (type == null && name == QName.Empty) { return(ct); } SimpleModel sc = new SimpleModel(); ct.ContentModel = sc; // 4. type is simpleType // -> extension of existing simple type. SimpleType st = type as SimpleType; if (st != null) { SimpleRst scr = new SimpleRst(); scr.BaseType = st; sc.Content = scr; return(ct); } SimpleExt sce = new SimpleExt(); sc.Content = sce; // 5. type name points to primitive type // -> simple extension of a primitive type st = XmlSchemaType.GetBuiltInSimpleType(name); if (st != null) { sce.BaseTypeName = name; return(ct); } // 6. type name points to global simpleType. st = globalType as SimpleType; if (st != null) { sce.BaseTypeName = name; return(ct); } throw Error(el, "Unexpected schema component that contains simpleTypeName that could not be resolved."); }
static void AddScopesType(DiscoveryVersion discoveryVersion, XmlSchema schema) { // <xs:complexType name="ScopesType"> XmlSchemaComplexType scopesType = new XmlSchemaComplexType(); scopesType.Name = ProtocolStrings.SchemaNames.ScopesType; // <xs:simpleContent> XmlSchemaSimpleContent scopesTypeContent = new XmlSchemaSimpleContent(); // <xs:extension base="tns:UriListType"> XmlSchemaSimpleContentExtension scopesTypeContentExtension = new XmlSchemaSimpleContentExtension(); scopesTypeContentExtension.BaseTypeName = discoveryVersion.Implementation.QualifiedNames.UriListType; // <xs:attribute name="MatchBy" type="xs:anyURI" /> XmlSchemaAttribute matchBy = new XmlSchemaAttribute(); matchBy.Name = ProtocolStrings.SchemaNames.MatchByAttribute; matchBy.SchemaTypeName = discoveryVersion.Implementation.QualifiedNames.AnyUriType; // <xs:anyAttribute namespace="##other" processContents="lax" /> XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute(); anyAttribute.Namespace = "##other"; anyAttribute.ProcessContents = XmlSchemaContentProcessing.Lax; // </xs:extension> scopesTypeContentExtension.Attributes.Add(matchBy); scopesTypeContentExtension.AnyAttribute = anyAttribute; // </xs:simpleContent> scopesTypeContent.Content = scopesTypeContentExtension; // <xs:complexType name="ScopesType"> scopesType.ContentModel = scopesTypeContent; schema.Items.Add(scopesType); }
private void InferTextContent(Element el, bool isNew) { string value = source.ReadString(); if (el.SchemaType == null) { if (el.SchemaTypeName == QName.Empty) { // no type information -> infer type if (isNew) { el.SchemaTypeName = InferSimpleType( value); } else { el.SchemaTypeName = QNameString; } return; } switch (el.SchemaTypeName.Namespace) { case XmlSchema.Namespace: case XdtNamespace: // existing primitive type el.SchemaTypeName = InferMergedType( value, el.SchemaTypeName); break; default: ComplexType ct = schemas.GlobalTypes [ el.SchemaTypeName] as ComplexType; // If it is complex, then just set // mixed='true' (type cannot be set.) // If it is simple, then we cannot // make sure that string value is // valid. So just set as xs:string. if (ct != null) { MarkAsMixed(ct); } else { el.SchemaTypeName = QNameString; } break; } return; } // simpleType SimpleType st = el.SchemaType as SimpleType; if (st != null) { // If simple, then (described above) el.SchemaType = null; el.SchemaTypeName = QNameString; return; } // complexType ComplexType ect = el.SchemaType as ComplexType; SimpleModel sm = ect.ContentModel as SimpleModel; if (sm == null) { // - ComplexContent MarkAsMixed(ect); return; } // - SimpleContent SimpleExt se = sm.Content as SimpleExt; if (se != null) { se.BaseTypeName = InferMergedType(value, se.BaseTypeName); } SimpleRst sr = sm.Content as SimpleRst; if (sr != null) { sr.BaseTypeName = InferMergedType(value, sr.BaseTypeName); sr.BaseType = null; } }
XmlCompletionItemCollection GetAttributeCompletion(XmlSchemaSimpleContentExtension extension, XmlNamespaceCollection namespacesInScope) { XmlCompletionItemCollection completionItems = new XmlCompletionItemCollection(); completionItems.AddRange(GetAttributeCompletion(extension.Attributes, namespacesInScope)); completionItems.AddRange(GetBaseComplexTypeAttributeCompletion(extension.BaseTypeName, namespacesInScope)); return completionItems; }
private XmlQualifiedName ExportStructMapping(StructMapping mapping, string ns, XmlSchemaElement element) { if (mapping.TypeDesc.IsRoot) { this.needToExportRoot = true; return XmlQualifiedName.Empty; } if (mapping.IsAnonymousType) { if (this.references[mapping] != null) { throw new InvalidOperationException(Res.GetString("XmlCircularReference2", new object[] { mapping.TypeDesc.Name, "AnonymousType", "false" })); } this.references[mapping] = mapping; } XmlSchemaComplexType item = (XmlSchemaComplexType) this.types[mapping]; if (item == null) { if (!mapping.IncludeInSchema) { throw new InvalidOperationException(Res.GetString("XmlCannotIncludeInSchema", new object[] { mapping.TypeDesc.Name })); } this.CheckForDuplicateType(mapping, mapping.Namespace); item = new XmlSchemaComplexType(); if (!mapping.IsAnonymousType) { item.Name = mapping.TypeName; this.AddSchemaItem(item, mapping.Namespace, ns); this.types.Add(mapping, item); } item.IsAbstract = mapping.TypeDesc.IsAbstract; bool isOpenModel = mapping.IsOpenModel; if ((mapping.BaseMapping != null) && mapping.BaseMapping.IncludeInSchema) { if (mapping.BaseMapping.IsAnonymousType) { throw new InvalidOperationException(Res.GetString("XmlAnonymousBaseType", new object[] { mapping.TypeDesc.Name, mapping.BaseMapping.TypeDesc.Name, "AnonymousType", "false" })); } if (mapping.HasSimpleContent) { XmlSchemaSimpleContent content = new XmlSchemaSimpleContent(); XmlSchemaSimpleContentExtension extension = new XmlSchemaSimpleContentExtension { BaseTypeName = this.ExportStructMapping(mapping.BaseMapping, mapping.Namespace, null) }; content.Content = extension; item.ContentModel = content; } else { XmlSchemaComplexContentExtension extension2 = new XmlSchemaComplexContentExtension { BaseTypeName = this.ExportStructMapping(mapping.BaseMapping, mapping.Namespace, null) }; XmlSchemaComplexContent content2 = new XmlSchemaComplexContent { Content = extension2, IsMixed = XmlSchemaImporter.IsMixed((XmlSchemaComplexType) this.types[mapping.BaseMapping]) }; item.ContentModel = content2; } isOpenModel = false; } this.ExportTypeMembers(item, mapping.Members, mapping.TypeName, mapping.Namespace, mapping.HasSimpleContent, isOpenModel); this.ExportDerivedMappings(mapping); if (mapping.XmlnsMember != null) { this.AddXmlnsAnnotation(item, mapping.XmlnsMember.Name); } } else { this.AddSchemaImport(mapping.Namespace, ns); } if (mapping.IsAnonymousType) { this.references[mapping] = null; if (element != null) { element.SchemaType = item; } return XmlQualifiedName.Empty; } XmlQualifiedName name = new XmlQualifiedName(item.Name, mapping.Namespace); if (element != null) { element.SchemaTypeName = name; } return name; }
protected override void Visit(XmlSchemaSimpleContentExtension extension) { ProcessExtension(extension.BaseTypeName, extension.Attributes, extension.AnyAttribute); }
public static void genSchema() { //merge DOC to tagsMeta doc.export(); //modify xhtml5.xsd XmlSchema schema; using (var str = File.OpenRead(@"d:\LMCom\rew\Web4\Author\xhtml5.xsd")) schema = XmlSchema.Read(str, null); var meta = Lib.courseModelJsonMLMeta; XmlSchemaAttributeGroup attrGrp; var allTypes = meta.types.Values.Where(t => (t.st & (tgSt.xsdIgnore | tgSt.obsolete)) == 0).ToArray(); Func<jsClassMeta, IEnumerable<jsPropMeta>> myXsdProps = tp => tp.props.Values.Where(p => (p.st & (tgSt.xsdIgnore | tgSt.xmlIgnore)) == 0); Func<jsClassMeta, IEnumerable<jsPropMeta>> allXsdProps = tp => tp.parents(true).Where(t => (tp.st & (tgSt.xsdIgnoreTagAttrs /*| tgSt.xsdHtmlEl*/))!=0 ? t.name!="tag" : true).SelectMany(t => myXsdProps(t)); //Func<jsClassMeta, IEnumerable<jsPropMeta>> allXsdPropsNoTag = tp => tp.parents(true).Where(t => t.name != "tag").SelectMany(t => myXsdProps(t)); XmlSchemaComplexType complex; XmlSchemaSimpleContentExtension simpleExt; XmlSchemaChoice choice; XmlSchemaGroupBase grpBase; //*************** modifikace HTML 5 atributu a childs //definice parent-prop a style-sheet atributu schema.Items.Add(attrGrp = new XmlSchemaAttributeGroup { Name = "LM-spec-attrs" }); //attrGrp.Attributes.Add(new XmlSchemaAttribute { Name = "parent-prop", SchemaTypeName = new XmlQualifiedName("parentProps"), DefaultValue = "no" }); attrGrp.Attributes.Add(new XmlSchemaAttribute { Name = "style-sheet", SchemaTypeName = stringType }); attrGrp.Attributes.Add(new XmlSchemaAttribute { Name = "data-bind", SchemaTypeName = stringType }); //definice grupy pro all LM elements schema.Items.Add(new XmlSchemaGroup { Name = "LM-all-elements", Particle = choice = new XmlSchemaChoice() }); foreach (var typ in allTypes.Where(t => (t.st & tgSt.xsdNoGlobal)==0)) choice.Items.Add(new XmlSchemaElement { RefName = new XmlQualifiedName(typ.tagName) }); //modifikace commonPhrasingElements groups var commGrp = schema.Items.OfType<XmlSchemaGroup>().First(e => e.Name == "commonPhrasingElements"); ((XmlSchemaChoice)commGrp.Particle).Items.Add(new XmlSchemaGroupRef { RefName = new XmlQualifiedName("LM-all-elements") }); //modifikace coreAttributeGroupNodir o tag attribute group attrGrp = schema.Items.OfType<XmlSchemaAttributeGroup>().First(e => e.Name == "coreAttributeGroupNodir"); attrGrp.Attributes.Add(new XmlSchemaAttributeGroupRef { RefName = new XmlQualifiedName("LM-spec-attrs") }); //*************** dalse modifikace HTML 5 //modifikace id atributu z token na xs:ID var idType = schema.Items.OfType<XmlSchemaSimpleType>().First(e => e.Name == "id"); ((XmlSchemaSimpleTypeRestriction)idType.Content).BaseTypeName = new XmlQualifiedName("xs:ID"); //modifikace body var body = schema.Items.OfType<XmlSchemaElement>().First(e => e.Name == "body"); var ext = (XmlSchemaComplexContentExtension)((XmlSchemaComplexContent)((XmlSchemaComplexType)body.SchemaType).ContentModel).Content; foreach (var prop in myXsdProps(meta.types["body"])) ext.Attributes.Add(generateProp(prop)); //modifikace li schema.Items.Add(new XmlSchemaElement { Name="li", SchemaTypeName = new XmlQualifiedName("li") }); //*************** LM elements //RegEx "and-*-exchangeable" pro jmeno eval grupy XmlSchemaSimpleTypeRestriction restr; schema.Items.Add(new XmlSchemaSimpleType { Name = evalControl.xsdType_eval_group, Content = restr = new XmlSchemaSimpleTypeRestriction { BaseTypeName = new XmlQualifiedName("xs:string") } }); restr.Facets.Add(new XmlSchemaPatternFacet { Value = evalControl.xsdType_eval_group_regex }); //RegEx sequence zvukovuch vet schema.Items.Add(new XmlSchemaSimpleType { Name = _sndFile.mediaTag_sequence, Content = restr = new XmlSchemaSimpleTypeRestriction { BaseTypeName = new XmlQualifiedName("xs:string") } }); restr.Facets.Add(new XmlSchemaPatternFacet { Value = _sndFile.mediaTag_sequence_regex }); //RegEx format videa schema.Items.Add(new XmlSchemaSimpleType { Name = urlTag.mediaTag_format, Content = restr = new XmlSchemaSimpleTypeRestriction { BaseTypeName = new XmlQualifiedName("xs:string") } }); restr.Facets.Add(new XmlSchemaPatternFacet { Value = urlTag.mediaTag_format_regex }); //RegEx identifikace zvukove vety v dialogu schema.Items.Add(new XmlSchemaSimpleType { Name = phraseReplace.sndReplace_sndDialogIdx, Content = restr = new XmlSchemaSimpleTypeRestriction { BaseTypeName = new XmlQualifiedName("xs:string") } }); restr.Facets.Add(new XmlSchemaPatternFacet { Value = phraseReplace.sndReplace_sndDialogIdx_regex }); //lm typy foreach (var typ in allTypes) { if (typ.name == "sndDialog") { if (typ == null) return; } schema.Items.Add(new XmlSchemaElement { Name = typ.tagName, SchemaTypeName = new XmlQualifiedName(typ.tagName + "-type") }); //element type if ((typ.st & tgSt.xsdHtmlEl) != 0) { //odvozeno z HTML var isMixed = (typ.st & tgSt.xsdNoMixed) == 0; //mixed? schema.Items.Add(complex = new XmlSchemaComplexType { Name = typ.tagName + "-type", IsMixed = isMixed, Particle = grpBase = new XmlSchemaSequence { MinOccurs = 0, MaxOccursString = "unbounded" } }); grpBase.Items.Add(new XmlSchemaGroupRef { RefName = new XmlQualifiedName("flowContent") }); //foreach (var p in allXsdPropsNoTag(typ)) complex.Attributes.Add(generateProp(p)); foreach (var p in allXsdProps(typ)) complex.Attributes.Add(generateProp(p)); continue; } if ((typ.st & (tgSt.xsdString | tgSt.cdata)) != 0) { //pouze string content (nebo cdata) schema.Items.Add(complex = new XmlSchemaComplexType { Name = typ.tagName + "-type", ContentModel = new XmlSchemaSimpleContent { Content = simpleExt = new XmlSchemaSimpleContentExtension { BaseTypeName = new XmlQualifiedName("xs:string") } } }); foreach (var p in allXsdProps(typ)) simpleExt.Attributes.Add(generateProp(p)); continue; } if (!string.IsNullOrEmpty(typ.xsdChildElements)) { //explixitne nadefinovane child elements var childs = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>("{" + typ.xsdChildElements + "}"); //var obj = childs as JObject; //var prop = obj.Properties().FirstOrDefault(); //var arr = prop.Value as JArray; schema.Items.Add(complex = new XmlSchemaComplexType { Name = typ.tagName + "-type", IsMixed = (typ.st & tgSt.xsdMixed)!=0, Particle = genChilds(Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>("{" + typ.xsdChildElements + "}")) as XmlSchemaParticle//choice = new XmlSchemaChoice { MaxOccursString = "unbounded", MinOccurs=0 } }); //foreach (var t in typ.xsdChildElements.Split('|')) choice.Items.Add(new XmlSchemaElement { RefName = new XmlQualifiedName(t) }); //foreach (var t in typ.xsdChildElements.Split('|')) choice.Items.Add(new XmlSchemaElement { Name = t }); foreach (var p in allXsdProps(typ)) complex.Attributes.Add(generateProp(p)); continue; } schema.Items.Add(complex = new XmlSchemaComplexType { Name = typ.tagName + "-type" }); foreach (var p in allXsdProps(typ)) complex.Attributes.Add(generateProp(p)); } //lm enums foreach (var en in getAll.Enums()) generateEnum(schema, en); //schema.Compile((s, a) => { }); if (File.Exists(schemaFn)) File.Delete(schemaFn); using (var str = File.OpenWrite(schemaFn)) schema.Write(str); }
internal static XmlSchemaSimpleContentExtension Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSimpleContentExtension xmlSchemaSimpleContentExtension = new XmlSchemaSimpleContentExtension(); reader.MoveToElement(); if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "extension") { XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaAttributeGroup.Read, name=" + reader.Name, null); reader.Skip(); return(null); } xmlSchemaSimpleContentExtension.LineNumber = reader.LineNumber; xmlSchemaSimpleContentExtension.LinePosition = reader.LinePosition; xmlSchemaSimpleContentExtension.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "base") { Exception ex; xmlSchemaSimpleContentExtension.baseTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out ex); if (ex != null) { XmlSchemaObject.error(h, reader.Value + " is not a valid value for base attribute", ex); } } else if (reader.Name == "id") { xmlSchemaSimpleContentExtension.Id = reader.Value; } else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema") { XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for extension in this context", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaSimpleContentExtension); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(xmlSchemaSimpleContentExtension); } int num = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != "extension") { XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaSimpleContentExtension.Read, name=" + reader.Name, null); } break; } if (num <= 1 && reader.LocalName == "annotation") { num = 2; XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h); if (xmlSchemaAnnotation != null) { xmlSchemaSimpleContentExtension.Annotation = xmlSchemaAnnotation; } } else { if (num <= 2) { if (reader.LocalName == "attribute") { num = 2; XmlSchemaAttribute xmlSchemaAttribute = XmlSchemaAttribute.Read(reader, h); if (xmlSchemaAttribute != null) { xmlSchemaSimpleContentExtension.Attributes.Add(xmlSchemaAttribute); } continue; } if (reader.LocalName == "attributeGroup") { num = 2; XmlSchemaAttributeGroupRef xmlSchemaAttributeGroupRef = XmlSchemaAttributeGroupRef.Read(reader, h); if (xmlSchemaAttributeGroupRef != null) { xmlSchemaSimpleContentExtension.attributes.Add(xmlSchemaAttributeGroupRef); } continue; } } if (num <= 3 && reader.LocalName == "anyAttribute") { num = 4; XmlSchemaAnyAttribute xmlSchemaAnyAttribute = XmlSchemaAnyAttribute.Read(reader, h); if (xmlSchemaAnyAttribute != null) { xmlSchemaSimpleContentExtension.AnyAttribute = xmlSchemaAnyAttribute; } } else { reader.RaiseInvalidElementError(); } } } return(xmlSchemaSimpleContentExtension); }
protected override void Visit(XmlSchemaSimpleContentExtension extension) { TraverseBaseType(extension.BaseTypeName); }
private void ExportTypeMembers(XmlSchemaComplexType type, MemberMapping[] members, string name, string ns, bool hasSimpleContent, bool openModel) { XmlSchemaGroupBase group = new XmlSchemaSequence(); TypeMapping mapping = null; for (int i = 0; i < members.Length; i++) { MemberMapping mapping2 = members[i]; if (!mapping2.Ignore) { if (mapping2.Text != null) { if (mapping != null) { throw new InvalidOperationException(Res.GetString("XmlIllegalMultipleText", new object[] { name })); } mapping = mapping2.Text.Mapping; } if (mapping2.Elements.Length > 0) { bool repeats = mapping2.TypeDesc.IsArrayLike && ((mapping2.Elements.Length != 1) || !(mapping2.Elements[0].Mapping is ArrayMapping)); bool valueTypeOptional = (mapping2.CheckSpecified != SpecifiedAccessor.None) || mapping2.CheckShouldPersist; this.ExportElementAccessors(group, mapping2.Elements, repeats, valueTypeOptional, ns); } } } if (group.Items.Count > 0) { if (type.ContentModel != null) { if (type.ContentModel.Content is XmlSchemaComplexContentRestriction) { ((XmlSchemaComplexContentRestriction) type.ContentModel.Content).Particle = group; } else { if (!(type.ContentModel.Content is XmlSchemaComplexContentExtension)) { throw new InvalidOperationException(Res.GetString("XmlInvalidContent", new object[] { type.ContentModel.Content.GetType().Name })); } ((XmlSchemaComplexContentExtension) type.ContentModel.Content).Particle = group; } } else { type.Particle = group; } } if (mapping != null) { if (hasSimpleContent) { if ((mapping is PrimitiveMapping) && (group.Items.Count == 0)) { PrimitiveMapping mapping3 = (PrimitiveMapping) mapping; if (mapping3.IsList) { type.IsMixed = true; } else { if (mapping3.IsAnonymousType) { throw new InvalidOperationException(Res.GetString("XmlAnonymousBaseType", new object[] { mapping.TypeDesc.Name, mapping3.TypeDesc.Name, "AnonymousType", "false" })); } XmlSchemaSimpleContent content = new XmlSchemaSimpleContent(); XmlSchemaSimpleContentExtension extension = new XmlSchemaSimpleContentExtension(); content.Content = extension; type.ContentModel = content; extension.BaseTypeName = this.ExportPrimitiveMapping(mapping3, ns); } } } else { type.IsMixed = true; } } bool flag3 = false; for (int j = 0; j < members.Length; j++) { if (members[j].Attribute != null) { this.ExportAttributeAccessor(type, members[j].Attribute, (members[j].CheckSpecified != SpecifiedAccessor.None) || members[j].CheckShouldPersist, ns); if (members[j].Attribute.Any) { flag3 = true; } } } if (openModel && !flag3) { AttributeAccessor accessor = new AttributeAccessor { Any = true }; this.ExportAttributeAccessor(type, accessor, false, ns); } }
void ExportClassSchema (XmlTypeMapping map) { if (IsMapExported (map)) return; SetMapExported (map); if (map.TypeData.Type == typeof(object)) { foreach (XmlTypeMapping dmap in map.DerivedTypes) if (dmap.TypeData.SchemaType == SchemaTypes.Class) ExportClassSchema (dmap); return; } XmlSchema schema = GetSchema (map.XmlTypeNamespace); XmlSchemaComplexType stype = new XmlSchemaComplexType (); stype.Name = map.XmlType; schema.Items.Add (stype); ClassMap cmap = (ClassMap)map.ObjectMap; if (cmap.HasSimpleContent) { XmlSchemaSimpleContent simple = new XmlSchemaSimpleContent (); stype.ContentModel = simple; XmlSchemaSimpleContentExtension ext = new XmlSchemaSimpleContentExtension (); simple.Content = ext; XmlSchemaSequence particle; XmlSchemaAnyAttribute anyAttribute; ExportMembersMapSchema (schema, cmap, map.BaseMap, ext.Attributes, out particle, out anyAttribute); ext.AnyAttribute = anyAttribute; if (map.BaseMap == null) ext.BaseTypeName = cmap.SimpleContentBaseType; else { ext.BaseTypeName = new XmlQualifiedName (map.BaseMap.XmlType, map.BaseMap.XmlTypeNamespace); ImportNamespace (schema, map.BaseMap.XmlTypeNamespace); ExportClassSchema (map.BaseMap); } } else if (map.BaseMap != null && map.BaseMap.IncludeInSchema) { XmlSchemaComplexContent cstype = new XmlSchemaComplexContent (); XmlSchemaComplexContentExtension ext = new XmlSchemaComplexContentExtension (); ext.BaseTypeName = new XmlQualifiedName (map.BaseMap.XmlType, map.BaseMap.XmlTypeNamespace); cstype.Content = ext; stype.ContentModel = cstype; XmlSchemaSequence particle; XmlSchemaAnyAttribute anyAttribute; ExportMembersMapSchema (schema, cmap, map.BaseMap, ext.Attributes, out particle, out anyAttribute); ext.Particle = particle; ext.AnyAttribute = anyAttribute; stype.IsMixed = HasMixedContent (map); cstype.IsMixed = BaseHasMixedContent (map); ImportNamespace (schema, map.BaseMap.XmlTypeNamespace); ExportClassSchema (map.BaseMap); } else { XmlSchemaSequence particle; XmlSchemaAnyAttribute anyAttribute; ExportMembersMapSchema (schema, cmap, map.BaseMap, stype.Attributes, out particle, out anyAttribute); stype.Particle = particle; stype.AnyAttribute = anyAttribute; stype.IsMixed = cmap.XmlTextCollector != null; } foreach (XmlTypeMapping dmap in map.DerivedTypes) if (dmap.TypeData.SchemaType == SchemaTypes.Class) ExportClassSchema (dmap); }
private void CompileSimpleContentExtension(XmlSchemaComplexType complexType, XmlSchemaSimpleContentExtension simpleExtension) { XmlSchemaComplexType baseType = null; if (complexType.Redefined != null && simpleExtension.BaseTypeName == complexType.Redefined.QualifiedName) { baseType = (XmlSchemaComplexType)complexType.Redefined; CompileComplexType(baseType); complexType.SetBaseSchemaType(baseType); complexType.SetDatatype(baseType.Datatype); } else { XmlSchemaType bto = GetAnySchemaType(simpleExtension.BaseTypeName); if (bto == null) { SendValidationEvent(Res.Sch_UndeclaredType, simpleExtension.BaseTypeName.ToString(), simpleExtension); } else { complexType.SetBaseSchemaType(bto); complexType.SetDatatype(bto.Datatype); } baseType = bto as XmlSchemaComplexType; } if (baseType != null) { if ((baseType.FinalResolved & XmlSchemaDerivationMethod.Extension) != 0) { SendValidationEvent(Res.Sch_BaseFinalExtension, complexType); } if (baseType.ContentType != XmlSchemaContentType.TextOnly) { SendValidationEvent(Res.Sch_NotSimpleContent, complexType); } } complexType.SetDerivedBy(XmlSchemaDerivationMethod.Extension); CompileLocalAttributes(baseType, complexType, simpleExtension.Attributes, simpleExtension.AnyAttribute, XmlSchemaDerivationMethod.Extension); }
void GetAttributeCompletionData (XmlCompletionDataList data, XmlSchemaSimpleContentExtension extension) { GetAttributeCompletionData (data, extension.Attributes); }
private void SetContainer(State state, object container) { switch (state) { case State.Root: break; case State.Schema: break; case State.Annotation: this.annotation = (XmlSchemaAnnotation)container; break; case State.Include: this.include = (XmlSchemaInclude)container; break; case State.Import: this.import = (XmlSchemaImport)container; break; case State.Element: this.element = (XmlSchemaElement)container; break; case State.Attribute: this.attribute = (XmlSchemaAttribute)container; break; case State.AttributeGroup: this.attributeGroup = (XmlSchemaAttributeGroup)container; break; case State.AttributeGroupRef: this.attributeGroupRef = (XmlSchemaAttributeGroupRef)container; break; case State.AnyAttribute: this.anyAttribute = (XmlSchemaAnyAttribute)container; break; case State.Group: this.group = (XmlSchemaGroup)container; break; case State.GroupRef: this.groupRef = (XmlSchemaGroupRef)container; break; case State.All: this.all = (XmlSchemaAll)container; break; case State.Choice: this.choice = (XmlSchemaChoice)container; break; case State.Sequence: this.sequence = (XmlSchemaSequence)container; break; case State.Any: this.anyElement = (XmlSchemaAny)container; break; case State.Notation: this.notation = (XmlSchemaNotation)container; break; case State.SimpleType: this.simpleType = (XmlSchemaSimpleType)container; break; case State.ComplexType: this.complexType = (XmlSchemaComplexType)container; break; case State.ComplexContent: this.complexContent = (XmlSchemaComplexContent)container; break; case State.ComplexContentExtension: this.complexContentExtension = (XmlSchemaComplexContentExtension)container; break; case State.ComplexContentRestriction: this.complexContentRestriction = (XmlSchemaComplexContentRestriction)container; break; case State.SimpleContent: this.simpleContent = (XmlSchemaSimpleContent)container; break; case State.SimpleContentExtension: this.simpleContentExtension = (XmlSchemaSimpleContentExtension)container; break; case State.SimpleContentRestriction: this.simpleContentRestriction = (XmlSchemaSimpleContentRestriction)container; break; case State.SimpleTypeUnion: this.simpleTypeUnion = (XmlSchemaSimpleTypeUnion)container; break; case State.SimpleTypeList: this.simpleTypeList = (XmlSchemaSimpleTypeList)container; break; case State.SimpleTypeRestriction: this.simpleTypeRestriction = (XmlSchemaSimpleTypeRestriction)container; break; case State.Unique: case State.Key: case State.KeyRef: this.identityConstraint = (XmlSchemaIdentityConstraint)container; break; case State.Selector: case State.Field: this.xpath = (XmlSchemaXPath)container; break; case State.MinExclusive: case State.MinInclusive: case State.MaxExclusive: case State.MaxInclusive: case State.TotalDigits: case State.FractionDigits: case State.Length: case State.MinLength: case State.MaxLength: case State.Enumeration: case State.Pattern: case State.WhiteSpace: this.facet = (XmlSchemaFacet)container; break; case State.AppInfo: this.appInfo = (XmlSchemaAppInfo)container; break; case State.Documentation: this.documentation = (XmlSchemaDocumentation)container; break; case State.Redefine: this.redefine = (XmlSchemaRedefine)container; break; default: Debug.Assert(false, "State is " + state); break; } }
private static void AddElementAndType(XmlSchema schema, string baseXsdType, string ns) { // name the element and soap-encoding type the same as the base XSD type XmlSchemaElement el = new XmlSchemaElement(); el.Name = baseXsdType; el.SchemaTypeName = new XmlQualifiedName(baseXsdType, ns); schema.Items.Add(el); XmlSchemaComplexType type = new XmlSchemaComplexType(); type.Name = baseXsdType; XmlSchemaSimpleContent model = new XmlSchemaSimpleContent(); type.ContentModel = model; XmlSchemaSimpleContentExtension ex = new XmlSchemaSimpleContentExtension(); ex.BaseTypeName = new XmlQualifiedName(baseXsdType, XmlSchema.Namespace); model.Content = ex; schema.Items.Add(type); }
private void CompileSimpleContentExtension(XmlSchemaComplexType complexType, XmlSchemaSimpleContentExtension simpleExtension) { XmlSchemaComplexType redefined = null; if ((complexType.Redefined != null) && (simpleExtension.BaseTypeName == complexType.Redefined.QualifiedName)) { redefined = (XmlSchemaComplexType) complexType.Redefined; this.CompileComplexType(redefined); complexType.SetBaseSchemaType(redefined); complexType.SetDatatype(redefined.Datatype); } else { XmlSchemaType anySchemaType = this.GetAnySchemaType(simpleExtension.BaseTypeName); if (anySchemaType == null) { base.SendValidationEvent("Sch_UndeclaredType", simpleExtension.BaseTypeName.ToString(), complexType); } else { complexType.SetBaseSchemaType(anySchemaType); complexType.SetDatatype(anySchemaType.Datatype); } redefined = anySchemaType as XmlSchemaComplexType; } if (redefined != null) { if ((redefined.FinalResolved & XmlSchemaDerivationMethod.Extension) != XmlSchemaDerivationMethod.Empty) { base.SendValidationEvent("Sch_BaseFinalExtension", complexType); } if (redefined.ContentType != XmlSchemaContentType.TextOnly) { base.SendValidationEvent("Sch_NotSimpleContent", complexType); } } complexType.SetDerivedBy(XmlSchemaDerivationMethod.Extension); this.CompileLocalAttributes(redefined, complexType, simpleExtension.Attributes, simpleExtension.AnyAttribute, XmlSchemaDerivationMethod.Extension); }
internal XmlSchemaObject Clone(XmlSchema?parentSchema) { XmlSchemaComplexType complexType = (XmlSchemaComplexType)MemberwiseClone(); //Deep clone the QNames as these will be updated on chameleon includes if (complexType.ContentModel != null) { //simpleContent or complexContent XmlSchemaSimpleContent?simpleContent = complexType.ContentModel as XmlSchemaSimpleContent; if (simpleContent != null) { XmlSchemaSimpleContent newSimpleContent = (XmlSchemaSimpleContent)simpleContent.Clone(); XmlSchemaSimpleContentExtension?simpleExt = simpleContent.Content as XmlSchemaSimpleContentExtension; if (simpleExt != null) { XmlSchemaSimpleContentExtension newSimpleExt = (XmlSchemaSimpleContentExtension)simpleExt.Clone(); newSimpleExt.BaseTypeName = simpleExt.BaseTypeName.Clone(); newSimpleExt.SetAttributes(CloneAttributes(simpleExt.Attributes)); newSimpleContent.Content = newSimpleExt; } else { //simpleContent.Content is XmlSchemaSimpleContentRestriction XmlSchemaSimpleContentRestriction simpleRest = (XmlSchemaSimpleContentRestriction)simpleContent.Content !; XmlSchemaSimpleContentRestriction newSimpleRest = (XmlSchemaSimpleContentRestriction)simpleRest.Clone(); newSimpleRest.BaseTypeName = simpleRest.BaseTypeName.Clone(); newSimpleRest.SetAttributes(CloneAttributes(simpleRest.Attributes)); newSimpleContent.Content = newSimpleRest; } complexType.ContentModel = newSimpleContent; } else { // complexType.ContentModel is XmlSchemaComplexContent XmlSchemaComplexContent complexContent = (XmlSchemaComplexContent)complexType.ContentModel; XmlSchemaComplexContent newComplexContent = (XmlSchemaComplexContent)complexContent.Clone(); XmlSchemaComplexContentExtension?complexExt = complexContent.Content as XmlSchemaComplexContentExtension; if (complexExt != null) { XmlSchemaComplexContentExtension newComplexExt = (XmlSchemaComplexContentExtension)complexExt.Clone(); newComplexExt.BaseTypeName = complexExt.BaseTypeName.Clone(); newComplexExt.SetAttributes(CloneAttributes(complexExt.Attributes)); if (HasParticleRef(complexExt.Particle, parentSchema)) { newComplexExt.Particle = CloneParticle(complexExt.Particle, parentSchema); } newComplexContent.Content = newComplexExt; } else { // complexContent.Content is XmlSchemaComplexContentRestriction XmlSchemaComplexContentRestriction complexRest = (complexContent.Content as XmlSchemaComplexContentRestriction) !; XmlSchemaComplexContentRestriction newComplexRest = (XmlSchemaComplexContentRestriction)complexRest.Clone(); newComplexRest.BaseTypeName = complexRest.BaseTypeName.Clone(); newComplexRest.SetAttributes(CloneAttributes(complexRest.Attributes)); if (HasParticleRef(newComplexRest.Particle, parentSchema)) { newComplexRest.Particle = CloneParticle(newComplexRest.Particle, parentSchema); } newComplexContent.Content = newComplexRest; } complexType.ContentModel = newComplexContent; } } else { //equals XmlSchemaComplexContent with baseType is anyType if (HasParticleRef(complexType.Particle, parentSchema)) { complexType.Particle = CloneParticle(complexType.Particle, parentSchema); } complexType.SetAttributes(CloneAttributes(complexType.Attributes)); } complexType.ClearCompiledState(); return(complexType); }
private void MoveAttributes(XmlSchemaSimpleContentExtension scExtension, XmlSchemaComplexType ct) { //copy all attributes from the simple content to the complex type //This is ok since when we move from complex type to simple content extension we copy from AttributeUses property for (int i = 0; i < scExtension.Attributes.Count; ++i) //since simpleContent is being cleared { ct.Attributes.Add(scExtension.Attributes[i]); } }
XmlQualifiedName ExportStructMapping(StructMapping mapping, string ns, XmlSchemaElement element) { if (mapping.TypeDesc.IsRoot) { needToExportRoot = true; return XmlQualifiedName.Empty; } if (mapping.IsAnonymousType) { if (references[mapping] != null) throw new InvalidOperationException(Res.GetString(Res.XmlCircularReference2, mapping.TypeDesc.Name, "AnonymousType", "false")); references[mapping] = mapping; } XmlSchemaComplexType type = (XmlSchemaComplexType)types[mapping]; if (type == null) { if (!mapping.IncludeInSchema) throw new InvalidOperationException(Res.GetString(Res.XmlCannotIncludeInSchema, mapping.TypeDesc.Name)); CheckForDuplicateType(mapping, mapping.Namespace); type = new XmlSchemaComplexType(); if (!mapping.IsAnonymousType) { type.Name = mapping.TypeName; AddSchemaItem(type, mapping.Namespace, ns); types.Add(mapping, type); } type.IsAbstract = mapping.TypeDesc.IsAbstract; bool openModel = mapping.IsOpenModel; if (mapping.BaseMapping != null && mapping.BaseMapping.IncludeInSchema) { if (mapping.BaseMapping.IsAnonymousType) { throw new InvalidOperationException(Res.GetString(Res.XmlAnonymousBaseType, mapping.TypeDesc.Name, mapping.BaseMapping.TypeDesc.Name, "AnonymousType", "false")); } if (mapping.HasSimpleContent) { XmlSchemaSimpleContent model = new XmlSchemaSimpleContent(); XmlSchemaSimpleContentExtension extension = new XmlSchemaSimpleContentExtension(); extension.BaseTypeName = ExportStructMapping(mapping.BaseMapping, mapping.Namespace, null); model.Content = extension; type.ContentModel = model; } else { XmlSchemaComplexContentExtension extension = new XmlSchemaComplexContentExtension(); extension.BaseTypeName = ExportStructMapping(mapping.BaseMapping, mapping.Namespace, null); XmlSchemaComplexContent model = new XmlSchemaComplexContent(); model.Content = extension; model.IsMixed = XmlSchemaImporter.IsMixed((XmlSchemaComplexType)types[mapping.BaseMapping]); type.ContentModel = model; } openModel = false; } ExportTypeMembers(type, mapping.Members, mapping.TypeName, mapping.Namespace, mapping.HasSimpleContent, openModel); ExportDerivedMappings(mapping); if (mapping.XmlnsMember != null) { AddXmlnsAnnotation(type, mapping.XmlnsMember.Name); } } else { AddSchemaImport(mapping.Namespace, ns); } if (mapping.IsAnonymousType) { references[mapping] = null; if (element != null) element.SchemaType = type; return XmlQualifiedName.Empty; } else { XmlQualifiedName qname = new XmlQualifiedName(type.Name, mapping.Namespace); if (element != null) element.SchemaTypeName = qname; return qname; } }
/// <summary> /// Sets type of the xse based on the currently read element. /// If the type is already set, verifies that it matches the instance and if not, updates the type to validate the instance. /// </summary> /// <param name="xse">XmlSchemaElement corresponding to the element just read by the xtr XmlTextReader</param> /// <param name="bCreatingNewType">true if the type is newly created, false if the type already existed and matches the current element name</param> /// <param name="nsContext">namespaceURI of the parent element. Used to distinguish if ref= should be used when parent is in different ns than child.</param> internal void InferElement(XmlSchemaElement xse, bool bCreatingNewType, XmlSchema parentSchema) { bool bEmptyElement = xtr.IsEmptyElement; int lastUsedSeqItem = -1; Hashtable table = new Hashtable(); XmlSchemaType schemaType = GetEffectiveSchemaType(xse, bCreatingNewType); XmlSchemaComplexType ct = schemaType as XmlSchemaComplexType; //infer type based on content of the current element if (xtr.MoveToFirstAttribute()) { ProcessAttributes(ref xse, schemaType, bCreatingNewType, parentSchema); } else { if (!bCreatingNewType && ct != null) { //if type already exists and can potentially have attributes MakeExistingAttributesOptional(ct, null); } } if (ct == null || ct == XmlSchemaComplexType.AnyType) { //It was null or simple type, after processing attributes, this might have been set ct = xse.SchemaType as XmlSchemaComplexType; } //xse's type is set either to complex type if attributes exist or null if (bEmptyElement) //<element attr="3232" /> { if (!bCreatingNewType) { if (null != ct) { if (null!= ct.Particle ) { ct.Particle.MinOccurs = 0; } else if (null != ct.ContentModel) { XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct); sce.BaseTypeName = ST_string; sce.LineNumber = TF_string; } } else if (!xse.SchemaTypeName.IsEmpty) { xse.LineNumber = TF_string; xse.SchemaTypeName = ST_string; } } else { xse.LineNumber = TF_string; //xse.SchemaTypeName = ST_string; //My change } return; //We are done processing this element - all attributes are already added } bool bWhiteSpace = false; do { xtr.Read(); if (xtr.NodeType == XmlNodeType.Whitespace) { bWhiteSpace = true; } if (xtr.NodeType == XmlNodeType.EntityReference) { throw new XmlSchemaInferenceException(Res.SchInf_entity, 0, 0); } } while( (!xtr.EOF) && (xtr.NodeType != XmlNodeType.EndElement) && (xtr.NodeType != XmlNodeType.CDATA)&&(xtr.NodeType != XmlNodeType.Element)&&(xtr.NodeType != XmlNodeType.Text) ); if (xtr.NodeType == XmlNodeType.EndElement) { if (bWhiteSpace) { if (ct != null) { if (null != ct.ContentModel) { XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct); sce.BaseTypeName = ST_string; sce.LineNumber = TF_string; } else if (bCreatingNewType) { //attributes exist, but both Particle and ContentModel == null - this must be complex type with simpleContent extension XmlSchemaSimpleContent sc = new XmlSchemaSimpleContent(); ct.ContentModel = sc; XmlSchemaSimpleContentExtension sce = new XmlSchemaSimpleContentExtension(); sc.Content = sce; MoveAttributes(ct, sce, bCreatingNewType); sce.BaseTypeName = ST_string; sce.LineNumber = TF_string; } else ct.IsMixed = true; } else { xse.SchemaTypeName = ST_string; xse.LineNumber = TF_string; } } if (bCreatingNewType) { xse.LineNumber = TF_string; //xse.SchemaTypeName = ST_string; //my change } else { if (null != ct) { if (null!= ct.Particle) { ct.Particle.MinOccurs = 0; } else if (null != ct.ContentModel) { XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct); sce.BaseTypeName = ST_string; sce.LineNumber = TF_string; } } else if (!xse.SchemaTypeName.IsEmpty) { xse.LineNumber = TF_string; xse.SchemaTypeName = ST_string; } } return; //<element attr="232"></element> } int iChildNumber = 0; bool bCreatingNewSequence = false; while (!xtr.EOF && (xtr.NodeType != XmlNodeType.EndElement)) { bool bNextNodeAlreadyRead = false; //In some cases we have to look ahead one node. If true means that we did look ahead. iChildNumber++; if ((xtr.NodeType == XmlNodeType.Text) || (xtr.NodeType == XmlNodeType.CDATA) ) //node can be simple type, complex with simple content or complex with mixed content { if (null != ct) { if (null != ct.Particle) { ct.IsMixed = true; if (iChildNumber==1) { //if this is the only child and other elements do not follow, we must set particle minOccurs="0" do{ xtr.Read();} while( (!xtr.EOF) && ((xtr.NodeType == XmlNodeType.CDATA)||(xtr.NodeType == XmlNodeType.Text) || (xtr.NodeType == XmlNodeType.Comment) || (xtr.NodeType == XmlNodeType.ProcessingInstruction) || (xtr.NodeType == XmlNodeType.Whitespace) || (xtr.NodeType == XmlNodeType.SignificantWhitespace) || (xtr.NodeType == XmlNodeType.XmlDeclaration))); bNextNodeAlreadyRead = true; if (xtr.NodeType == XmlNodeType.EndElement) ct.Particle.MinOccurs=decimal.Zero; } } else if (null!=ct.ContentModel) { //complexType with simpleContent XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct); if ((xtr.NodeType == XmlNodeType.Text) && (iChildNumber==1)) { int SimpleType = -1; if (xse.Parent == null) { SimpleType = sce.LineNumber; // we use LineNumber to represent valid type flags } else { SimpleType = GetSchemaType(sce.BaseTypeName); xse.Parent = null; } sce.BaseTypeName = RefineSimpleType(xtr.Value, ref SimpleType); sce.LineNumber = SimpleType; // we use LineNumber to represent valid type flags } else { sce.BaseTypeName = ST_string; sce.LineNumber = TF_string; } } else { //attributes exist, but both Particle and ContentModel == null - this must be complex type with simpleContent extension XmlSchemaSimpleContent sc = new XmlSchemaSimpleContent(); ct.ContentModel = sc; XmlSchemaSimpleContentExtension sce = new XmlSchemaSimpleContentExtension(); sc.Content = sce; MoveAttributes(ct, sce, bCreatingNewType); if (xtr.NodeType == XmlNodeType.Text) { int TypeFlags; if(!bCreatingNewType) //previously this was empty element TypeFlags=TF_string; else TypeFlags = -1; sce.BaseTypeName = RefineSimpleType(xtr.Value, ref TypeFlags); sce.LineNumber = TypeFlags; // we use LineNumber to store flags of valid types } else { sce.BaseTypeName = ST_string; sce.LineNumber = TF_string; } } } else { //node is currently empty or with SimpleType //node will become simple type if (iChildNumber>1) { //more than one consecutive text nodes probably with PI in between xse.SchemaTypeName = ST_string; xse.LineNumber = TF_string;// we use LineNumber to store flags of valid types } else { int TypeFlags = -1; if (bCreatingNewType) if (xtr.NodeType == XmlNodeType.Text) { xse.SchemaTypeName = RefineSimpleType(xtr.Value, ref TypeFlags); xse.LineNumber = TypeFlags; // we use LineNumber to store flags of valid types } else { xse.SchemaTypeName = ST_string; xse.LineNumber = TF_string;// we use LineNumber to store flags of valid types } else if (xtr.NodeType == XmlNodeType.Text) { if (xse.Parent == null) { TypeFlags = xse.LineNumber; } else { TypeFlags = GetSchemaType(xse.SchemaTypeName); if (TypeFlags == -1 && xse.LineNumber == TF_string) { //Since schemaTypeName is not set for empty elements (<e></e>) TypeFlags = TF_string; } xse.Parent = null; } xse.SchemaTypeName = RefineSimpleType(xtr.Value, ref TypeFlags); //simple type xse.LineNumber = TypeFlags; // we use LineNumber to store flags of valid types } else { xse.SchemaTypeName = ST_string; xse.LineNumber = TF_string;// we use LineNumber to store flags of valid types } } } } else if (xtr.NodeType == XmlNodeType.Element) { XmlQualifiedName qname = new XmlQualifiedName(xtr.LocalName, xtr.NamespaceURI); bool Maxoccursflag = false; if (table.Contains(qname)) { Maxoccursflag = true; } else { table.Add(qname, null); } if (ct==null) { //untill now the element was empty or SimpleType - it now becomes complex type ct = new XmlSchemaComplexType(); xse.SchemaType = ct; if (!xse.SchemaTypeName.IsEmpty) // { ct.IsMixed=true; xse.SchemaTypeName = XmlQualifiedName.Empty; } } if (ct.ContentModel !=null) { //type was previously identified as simple content extension - we need to convert it to sequence XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct); MoveAttributes(sce, ct); ct.ContentModel = null; ct.IsMixed = true; if (ct.Particle != null) throw new XmlSchemaInferenceException(Res.SchInf_particle, 0, 0); ct.Particle = new XmlSchemaSequence(); bCreatingNewSequence = true; XmlSchemaElement subelement = AddElement(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, parentSchema,((XmlSchemaSequence)ct.Particle).Items, -1); lastUsedSeqItem = 0; if (!bCreatingNewType) ct.Particle.MinOccurs=0; //previously this was simple type so subelements did not exist } else if (ct.Particle == null) { ct.Particle = new XmlSchemaSequence(); bCreatingNewSequence = true; XmlSchemaElement subelement = AddElement(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, parentSchema,((XmlSchemaSequence)ct.Particle).Items, -1); if (!bCreatingNewType) { ((XmlSchemaSequence)ct.Particle).MinOccurs = decimal.Zero; // subelement.MinOccurs = decimal.Zero; } lastUsedSeqItem = 0; } else { bool bParticleChanged = false; XmlSchemaElement subelement = FindMatchingElement(bCreatingNewType || bCreatingNewSequence, xtr, ct, ref lastUsedSeqItem, ref bParticleChanged, parentSchema, Maxoccursflag); } } else if (xtr.NodeType == XmlNodeType.Text) { if (ct==null) throw new XmlSchemaInferenceException(Res.SchInf_ct, 0, 0); ct.IsMixed = true; } do { if (xtr.NodeType == XmlNodeType.EntityReference) { throw new XmlSchemaInferenceException(Res.SchInf_entity, 0, 0); } if (!bNextNodeAlreadyRead) { xtr.Read(); } else { bNextNodeAlreadyRead = false; } } while( (!xtr.EOF) && (xtr.NodeType != XmlNodeType.EndElement) && (xtr.NodeType != XmlNodeType.CDATA)&&(xtr.NodeType != XmlNodeType.Element)&&(xtr.NodeType != XmlNodeType.Text)); } if (lastUsedSeqItem != -1) { //Verify if all elements in a sequence exist, if not set MinOccurs=0 while (++lastUsedSeqItem < ((XmlSchemaSequence)ct.Particle).Items.Count) { if (((XmlSchemaSequence)ct.Particle).Items[lastUsedSeqItem].GetType() != typeof (XmlSchemaElement)) throw new XmlSchemaInferenceException(Res.SchInf_seq, 0 , 0); XmlSchemaElement subElement = (XmlSchemaElement) ((XmlSchemaSequence)ct.Particle).Items[lastUsedSeqItem]; subElement.MinOccurs = 0; } } }
//<simpleContent // id = ID // {any attributes with non-schema namespace . . .}> // Content: (annotation?, (restriction | extension)) //</simpleContent> internal static XmlSchemaSimpleContent Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSimpleContent simple = new XmlSchemaSimpleContent(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaComplexContent.Read, name=" + reader.Name, null); reader.SkipToEnd(); return(null); } simple.LineNumber = reader.LineNumber; simple.LinePosition = reader.LinePosition; simple.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { simple.Id = reader.Value; } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for simpleContent", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, simple); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(simple); } //Content: (annotation?, (restriction | extension)) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaSimpleContent.Read, name=" + reader.Name, null); } break; } if (level <= 1 && reader.LocalName == "annotation") { level = 2; //Only one annotation XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h); if (annotation != null) { simple.Annotation = annotation; } continue; } if (level <= 2) { if (reader.LocalName == "restriction") { level = 3; XmlSchemaSimpleContentRestriction restriction = XmlSchemaSimpleContentRestriction.Read(reader, h); if (restriction != null) { simple.content = restriction; } continue; } if (reader.LocalName == "extension") { level = 3; XmlSchemaSimpleContentExtension extension = XmlSchemaSimpleContentExtension.Read(reader, h); if (extension != null) { simple.content = extension; } continue; } } reader.RaiseInvalidElementError(); } return(simple); }