protected override void Visit(XmlSchemaSimpleTypeList list) { PushNode(SimpleTypeStructureNodeType.List, list); Traverse(list.BaseItemType); PopNode(); }
static XmlSchemaSimpleType() { // This is not used in the meantime. XmlSchemaSimpleType st = new XmlSchemaSimpleType(); XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); list.ItemTypeName = new XmlQualifiedName("anyURI", XmlSchema.Namespace); st.Content = list; st.BaseXmlSchemaTypeInternal = null; st.variety = XmlSchemaDerivationMethod.List; schemaLocationType = st; // Built-In schema types XsAnySimpleType = BuildSchemaType("anySimpleType", null); XsString = BuildSchemaType("string", "anySimpleType"); XsBoolean = BuildSchemaType("boolean", "anySimpleType"); XsDecimal = BuildSchemaType("decimal", "anySimpleType"); XsFloat = BuildSchemaType("float", "anySimpleType"); XsDouble = BuildSchemaType("double", "anySimpleType"); XsDuration = BuildSchemaType("duration", "anySimpleType"); XsDateTime = BuildSchemaType("dateTime", "anySimpleType"); XsTime = BuildSchemaType("time", "anySimpleType"); XsDate = BuildSchemaType("date", "anySimpleType"); XsGYearMonth = BuildSchemaType("gYearMonth", "anySimpleType"); XsGYear = BuildSchemaType("gYear", "anySimpleType"); XsGMonthDay = BuildSchemaType("gMonthDay", "anySimpleType"); XsGDay = BuildSchemaType("gDay", "anySimpleType"); XsGMonth = BuildSchemaType("gMonth", "anySimpleType"); XsHexBinary = BuildSchemaType("hexBinary", "anySimpleType"); XsBase64Binary = BuildSchemaType("base64Binary", "anySimpleType"); XsAnyUri = BuildSchemaType("anyURI", "anySimpleType"); XsQName = BuildSchemaType("QName", "anySimpleType"); XsNotation = BuildSchemaType("NOTATION", "anySimpleType"); // derived types XsNormalizedString = BuildSchemaType("normalizedString", "string"); XsToken = BuildSchemaType("token", "normalizedString"); XsLanguage = BuildSchemaType("language", "token"); XsNMToken = BuildSchemaType("NMTOKEN", "token"); XsName = BuildSchemaType("Name", "token"); XsNCName = BuildSchemaType("NCName", "Name"); XsID = BuildSchemaType("ID", "NCName"); XsIDRef = BuildSchemaType("IDREF", "NCName"); XsEntity = BuildSchemaType("ENTITY", "NCName"); XsInteger = BuildSchemaType("integer", "decimal"); XsNonPositiveInteger = BuildSchemaType("nonPositiveInteger", "integer"); XsNegativeInteger = BuildSchemaType("negativeInteger", "nonPositiveInteger"); XsLong = BuildSchemaType("long", "integer"); XsInt = BuildSchemaType("int", "long"); XsShort = BuildSchemaType("short", "int"); XsByte = BuildSchemaType("byte", "short"); XsNonNegativeInteger = BuildSchemaType("nonNegativeInteger", "integer"); XsUnsignedLong = BuildSchemaType("unsignedLong", "nonNegativeInteger"); XsUnsignedInt = BuildSchemaType("unsignedInt", "unsignedLong"); XsUnsignedShort = BuildSchemaType("unsignedShort", "unsignedInt"); XsUnsignedByte = BuildSchemaType("unsignedByte", "unsignedShort"); XsPositiveInteger = BuildSchemaType("positiveInteger", "nonNegativeInteger"); // xdt:* XdtAnyAtomicType = BuildSchemaType("anyAtomicType", "anySimpleType", true, false); XdtUntypedAtomic = BuildSchemaType("untypedAtomic", "anyAtomicType", true, true); XdtDayTimeDuration = BuildSchemaType("dayTimeDuration", "duration", true, false); XdtYearMonthDuration = BuildSchemaType("yearMonthDuration", "duration", true, false); // NMTOKENS, IDREFS, ENTITIES - lists XsIDRefs = new XmlSchemaSimpleType(); XmlSchemaSimpleTypeList sl = new XmlSchemaSimpleTypeList(); sl.ItemType = XsIDRef; XsIDRefs.Content = sl; XsEntities = new XmlSchemaSimpleType(); sl = new XmlSchemaSimpleTypeList(); sl.ItemType = XsEntity; XsEntities.Content = sl; XsNMTokens = new XmlSchemaSimpleType(); sl = new XmlSchemaSimpleTypeList(); sl.ItemType = XsNMToken; XsNMTokens.Content = sl; }
static void AddUriListType(DiscoveryVersion discoveryVersion, XmlSchema schema) { // <xs:simpleType name="UriListType"> XmlSchemaSimpleType uriListType = new XmlSchemaSimpleType(); uriListType.Name = ProtocolStrings.SchemaNames.UriListType; // <xs:list itemType="xs:anyURI" /> XmlSchemaSimpleTypeList uriListTypeContent = new XmlSchemaSimpleTypeList(); uriListTypeContent.ItemTypeName = discoveryVersion.Implementation.QualifiedNames.AnyUriType; // </xs:simpleType> uriListType.Content = uriListTypeContent; schema.Items.Add(uriListType); }
void ExportAttributeAccessor(XmlSchemaComplexType type, AttributeAccessor accessor, bool valueTypeOptional, string ns) { if (accessor == null) return; XmlSchemaObjectCollection attributes; if (type.ContentModel != null) { if (type.ContentModel.Content is XmlSchemaComplexContentRestriction) attributes = ((XmlSchemaComplexContentRestriction)type.ContentModel.Content).Attributes; else if (type.ContentModel.Content is XmlSchemaComplexContentExtension) attributes = ((XmlSchemaComplexContentExtension)type.ContentModel.Content).Attributes; else if (type.ContentModel.Content is XmlSchemaSimpleContentExtension) attributes = ((XmlSchemaSimpleContentExtension)type.ContentModel.Content).Attributes; else throw new InvalidOperationException(Res.GetString(Res.XmlInvalidContent, type.ContentModel.Content.GetType().Name)); } else { attributes = type.Attributes; } if (accessor.IsSpecialXmlNamespace) { // add <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> AddSchemaImport(XmlReservedNs.NsXml, ns); // generate <xsd:attribute ref="xml:lang" use="optional" /> XmlSchemaAttribute attribute = new XmlSchemaAttribute(); attribute.Use = XmlSchemaUse.Optional; attribute.RefName = new XmlQualifiedName(accessor.Name, XmlReservedNs.NsXml); attributes.Add(attribute); } else if (accessor.Any) { if (type.ContentModel == null) { type.AnyAttribute = new XmlSchemaAnyAttribute(); } else { XmlSchemaContent content = type.ContentModel.Content; if (content is XmlSchemaComplexContentExtension) { XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension)content; extension.AnyAttribute = new XmlSchemaAnyAttribute(); } else if (content is XmlSchemaComplexContentRestriction) { XmlSchemaComplexContentRestriction restriction = (XmlSchemaComplexContentRestriction)content; restriction.AnyAttribute = new XmlSchemaAnyAttribute(); } else if (type.ContentModel.Content is XmlSchemaSimpleContentExtension) { XmlSchemaSimpleContentExtension extension = (XmlSchemaSimpleContentExtension)content; extension.AnyAttribute = new XmlSchemaAnyAttribute(); } } } else { XmlSchemaAttribute attribute = new XmlSchemaAttribute(); attribute.Use = XmlSchemaUse.None; if (!accessor.HasDefault && !valueTypeOptional && accessor.Mapping.TypeDesc.IsValueType) { attribute.Use = XmlSchemaUse.Required; } attribute.Name = accessor.Name; if (accessor.Namespace == null || accessor.Namespace == ns) { // determine the form attribute value XmlSchema schema = schemas[ns]; if (schema == null) attribute.Form = accessor.Form == attributeFormDefault ? XmlSchemaForm.None : accessor.Form; else { attribute.Form = accessor.Form == schema.AttributeFormDefault ? XmlSchemaForm.None : accessor.Form; } attributes.Add(attribute); } else { // we are going to add the attribute to the top-level items. "use" attribute should not be set if (this.attributes[accessor] == null) { attribute.Use = XmlSchemaUse.None; attribute.Form = accessor.Form; AddSchemaItem(attribute, accessor.Namespace, ns); this.attributes.Add(accessor, accessor); } XmlSchemaAttribute refAttribute = new XmlSchemaAttribute(); refAttribute.Use = XmlSchemaUse.None; refAttribute.RefName = new XmlQualifiedName(accessor.Name, accessor.Namespace); attributes.Add(refAttribute); AddSchemaImport(accessor.Namespace, ns); } if (accessor.Mapping is PrimitiveMapping) { PrimitiveMapping pm = (PrimitiveMapping)accessor.Mapping; if (pm.IsList) { // create local simple type for the list-like attributes XmlSchemaSimpleType dataType = new XmlSchemaSimpleType(); XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); if (pm.IsAnonymousType) { list.ItemType = (XmlSchemaSimpleType)ExportAnonymousPrimitiveMapping(pm); } else { list.ItemTypeName = ExportPrimitiveMapping(pm, accessor.Namespace == null ? ns : accessor.Namespace); } dataType.Content = list; attribute.SchemaType = dataType; } else { if (pm.IsAnonymousType) { attribute.SchemaType = (XmlSchemaSimpleType)ExportAnonymousPrimitiveMapping(pm); } else { attribute.SchemaTypeName = ExportPrimitiveMapping(pm, accessor.Namespace == null ? ns : accessor.Namespace); } } } else if (!(accessor.Mapping is SpecialMapping)) throw new InvalidOperationException(Res.GetString(Res.XmlInternalError)); if (accessor.HasDefault) { attribute.DefaultValue = ExportDefaultValue(accessor.Mapping, accessor.Default); } } }
void GetAttributeValueCompletionData (XmlCompletionDataList data, XmlSchemaSimpleTypeList list) { if (list.ItemType != null) { GetAttributeValueCompletionData (data, list.ItemType); } else if (list.ItemTypeName != null) { var simpleType = FindSimpleType (list.ItemTypeName); if (simpleType != null) GetAttributeValueCompletionData (data, simpleType); } }
XmlSchemaSimpleType GetSchemaSimpleListType (TypeData typeData) { XmlSchemaSimpleType stype = new XmlSchemaSimpleType (); XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList (); TypeData itemTypeData = TypeTranslator.GetTypeData (typeData.ListItemType); list.ItemTypeName = new XmlQualifiedName (itemTypeData.XmlType, XmlSchema.Namespace); stype.Content = list; return stype; }
//<list // id = ID // itemType = QName // {any attributes with non-schema namespace . . .}> // Content: (annotation?, (simpleType?)) //</list> internal static XmlSchemaSimpleTypeList Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); reader.MoveToElement(); if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h,"Should not happen :1: XmlSchemaSimpleTypeList.Read, name="+reader.Name,null); reader.Skip(); return null; } list.LineNumber = reader.LineNumber; list.LinePosition = reader.LinePosition; list.SourceUri = reader.BaseURI; while(reader.MoveToNextAttribute()) { if(reader.Name == "id") { list.Id = reader.Value; } else if(reader.Name == "itemType") { Exception innerex; list.ItemTypeName = XmlSchemaUtil.ReadQNameAttribute(reader,out innerex); if(innerex != null) error(h, reader.Value + " is not a valid value for itemType attribute",innerex); } else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h,reader.Name + " is not a valid attribute for list",null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader,list); } } reader.MoveToElement(); if(reader.IsEmptyElement) return list; // Content: annotation?, simpleType? int level = 1; while(reader.ReadNextElement()) { if(reader.NodeType == XmlNodeType.EndElement) { if(reader.LocalName != xmlname) error(h,"Should not happen :2: XmlSchemaSimpleTypeList.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) list.Annotation = annotation; continue; } if(level <= 2 && reader.LocalName == "simpleType") { level = 3; XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader,h); if(stype != null) list.itemType = stype; continue; } reader.RaiseInvalidElementError(); } return list; }
/// <summary> /// Finish constructing built-in types by setting up derivation and list links. /// </summary> internal static void FinishBuiltinType(XmlSchemaSimpleType derivedType, XmlSchemaSimpleType baseType) { Debug.Assert(derivedType != null && baseType != null); // Create link from the derived type to the base type derivedType.SetBaseSchemaType(baseType); derivedType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction); if (derivedType.Datatype.Variety == XmlSchemaDatatypeVariety.Atomic) { //Content is restriction XmlSchemaSimpleTypeRestriction restContent = new XmlSchemaSimpleTypeRestriction(); restContent.BaseTypeName = baseType.QualifiedName; derivedType.Content = restContent; } // Create link from a list type to its member type if (derivedType.Datatype.Variety == XmlSchemaDatatypeVariety.List) { XmlSchemaSimpleTypeList listContent = new XmlSchemaSimpleTypeList(); derivedType.SetDerivedBy(XmlSchemaDerivationMethod.List); switch (derivedType.Datatype.TypeCode) { case XmlTypeCode.NmToken: listContent.ItemType = listContent.BaseItemType = enumToTypeCode[(int) XmlTypeCode.NmToken]; break; case XmlTypeCode.Entity: listContent.ItemType = listContent.BaseItemType = enumToTypeCode[(int) XmlTypeCode.Entity]; break; case XmlTypeCode.Idref: listContent.ItemType = listContent.BaseItemType = enumToTypeCode[(int) XmlTypeCode.Idref]; break; } derivedType.Content = listContent; } }
static XmlSchemaSimpleType () { // This is not used in the meantime. XmlSchemaSimpleType st = new XmlSchemaSimpleType (); XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList (); list.ItemTypeName = new XmlQualifiedName ("anyURI", XmlSchema.Namespace); st.Content = list; st.BaseXmlSchemaTypeInternal = null; st.variety = XmlSchemaDerivationMethod.List; schemaLocationType = st; #if NET_2_0 // Built-In schema types XsAnySimpleType = BuildSchemaType ("anySimpleType", null); XsString = BuildSchemaType ("string", "anySimpleType"); XsBoolean = BuildSchemaType ("boolean", "anySimpleType"); XsDecimal = BuildSchemaType ("decimal", "anySimpleType"); XsFloat = BuildSchemaType ("float", "anySimpleType"); XsDouble = BuildSchemaType ("double", "anySimpleType"); XsDuration = BuildSchemaType ("duration", "anySimpleType"); XsDateTime = BuildSchemaType ("dateTime", "anySimpleType"); XsTime = BuildSchemaType ("time", "anySimpleType"); XsDate = BuildSchemaType ("date", "anySimpleType"); XsGYearMonth = BuildSchemaType ("gYearMonth", "anySimpleType"); XsGYear = BuildSchemaType ("gYear", "anySimpleType"); XsGMonthDay = BuildSchemaType ("gMonthDay", "anySimpleType"); XsGDay = BuildSchemaType ("gDay", "anySimpleType"); XsGMonth = BuildSchemaType ("gMonth", "anySimpleType"); XsHexBinary = BuildSchemaType ("hexBinary", "anySimpleType"); XsBase64Binary = BuildSchemaType ("base64Binary", "anySimpleType"); XsAnyUri = BuildSchemaType ("anyURI", "anySimpleType"); XsQName = BuildSchemaType ("QName", "anySimpleType"); XsNotation = BuildSchemaType ("NOTATION", "anySimpleType"); // derived types XsNormalizedString = BuildSchemaType ("normalizedString", "string"); XsToken = BuildSchemaType ("token", "normalizedString"); XsLanguage = BuildSchemaType ("language", "token"); XsNMToken = BuildSchemaType ("NMTOKEN", "token"); XsName = BuildSchemaType ("Name", "token"); XsNCName = BuildSchemaType ("NCName", "Name"); XsID = BuildSchemaType ("ID", "NCName"); XsIDRef = BuildSchemaType ("IDREF", "NCName"); XsEntity = BuildSchemaType ("ENTITY", "NCName"); XsInteger = BuildSchemaType ("integer", "decimal"); XsNonPositiveInteger = BuildSchemaType ("nonPositiveInteger", "integer"); XsNegativeInteger = BuildSchemaType ("negativeInteger", "nonPositiveInteger"); XsLong = BuildSchemaType ("long", "integer"); XsInt = BuildSchemaType ("int", "long"); XsShort = BuildSchemaType ("short", "int"); XsByte = BuildSchemaType ("byte", "short"); XsNonNegativeInteger = BuildSchemaType ("nonNegativeInteger", "integer"); XsUnsignedLong = BuildSchemaType ("unsignedLong", "nonNegativeInteger"); XsUnsignedInt = BuildSchemaType ("unsignedInt", "unsignedLong"); XsUnsignedShort = BuildSchemaType ("unsignedShort", "unsignedInt"); XsUnsignedByte = BuildSchemaType ("unsignedByte", "unsignedShort"); XsPositiveInteger = BuildSchemaType ("positiveInteger", "nonNegativeInteger"); // xdt:* XdtAnyAtomicType = BuildSchemaType ("anyAtomicType", "anySimpleType", true, false); XdtUntypedAtomic = BuildSchemaType ("untypedAtomic", "anyAtomicType", true, true); XdtDayTimeDuration = BuildSchemaType ("dayTimeDuration", "duration", true, false); XdtYearMonthDuration = BuildSchemaType ("yearMonthDuration", "duration", true, false); // NMTOKENS, IDREFS, ENTITIES - lists XsIDRefs = new XmlSchemaSimpleType (); XmlSchemaSimpleTypeList sl = new XmlSchemaSimpleTypeList (); sl.ItemType = XsIDRef; XsIDRefs.Content = sl; XsEntities = new XmlSchemaSimpleType (); sl = new XmlSchemaSimpleTypeList (); sl.ItemType = XsEntity; XsEntities.Content = sl; XsNMTokens = new XmlSchemaSimpleType (); sl = new XmlSchemaSimpleTypeList (); sl.ItemType = XsNMToken; XsNMTokens.Content = sl; #endif }
/// <summary> /// Create and add an element to a service descriptions schema. Used to create a native XmlType element. /// </summary> /// <param name="elementName">A string contininig the name of an element.</param> /// <param name="elementTypeNs">A string containing the namespace of the type.</param> /// <param name="xmlTypeName">A string containing the name of an element type.</param> /// <param name="isArray">True if the element represents an array of native types.</param> /// <param name="serviceDesc">The ServiceDescription used to store Wsdl definition.</param> private void AddNativeTypeElement(string elementName, string elementNs, string xmlTypeName, bool isArray, XmlSchemaSequence seq, XmlSchema schema ) { XmlSchemaElement elemType = new XmlSchemaElement(); elemType.Name = elementName; if (isArray) elemType.SchemaTypeName = new XmlQualifiedName(elementName + "ListType", elementNs); else elemType.SchemaTypeName = new XmlQualifiedName(xmlTypeName, "http://www.w3.org/2001/XMLSchema"); seq.Items.Add(elemType); // If this is an array add a simple list type if (isArray) { XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType(); simpleType.Name = elementName + "ListType"; XmlSchemaSimpleTypeList simpleContent = new XmlSchemaSimpleTypeList(); simpleContent.ItemTypeName = new XmlQualifiedName(xmlTypeName, "http://www.w3.org/2001/XMLSchema"); simpleType.Content = simpleContent; AddSchemaItem(schema, simpleType); } return; }
void Handler.BeginSimpleTypeList(XmlSchemaSimpleTypeList list) { }
protected override void Visit(XmlSchemaSimpleTypeList list) { if (list.BaseItemType.QualifiedName.IsEmpty) { _writer.WriteHtmlArtItemWithText(ArtItem.List, "List"); } else { var topic = _context.TopicManager.GetTopic(list.BaseItemType); if (topic != null) { _writer.WriteHtmlArtItemWithTopicLink(ArtItem.List, topic); } else { _writer.WriteHtmlArtItemWithText(ArtItem.List, list.BaseItemType.QualifiedName.Name); } } }
internal static XmlSchemaSimpleTypeList Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSimpleTypeList xmlSchemaSimpleTypeList = new XmlSchemaSimpleTypeList(); reader.MoveToElement(); if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "list") { XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaSimpleTypeList.Read, name=" + reader.Name, null); reader.Skip(); return(null); } xmlSchemaSimpleTypeList.LineNumber = reader.LineNumber; xmlSchemaSimpleTypeList.LinePosition = reader.LinePosition; xmlSchemaSimpleTypeList.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { xmlSchemaSimpleTypeList.Id = reader.Value; } else if (reader.Name == "itemType") { Exception ex; xmlSchemaSimpleTypeList.ItemTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out ex); if (ex != null) { XmlSchemaObject.error(h, reader.Value + " is not a valid value for itemType attribute", ex); } } 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 list", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaSimpleTypeList); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(xmlSchemaSimpleTypeList); } int num = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != "list") { XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaSimpleTypeList.Read, name=" + reader.Name, null); } break; } if (num <= 1 && reader.LocalName == "annotation") { num = 2; XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h); if (xmlSchemaAnnotation != null) { xmlSchemaSimpleTypeList.Annotation = xmlSchemaAnnotation; } } else if (num <= 2 && reader.LocalName == "simpleType") { num = 3; XmlSchemaSimpleType xmlSchemaSimpleType = XmlSchemaSimpleType.Read(reader, h); if (xmlSchemaSimpleType != null) { xmlSchemaSimpleTypeList.itemType = xmlSchemaSimpleType; } } else { reader.RaiseInvalidElementError(); } } return(xmlSchemaSimpleTypeList); }
//<simpleType // final = (#all | (list | union | restriction)) // id = ID // name = NCName // {any attributes with non-schema namespace . . .}> // Content: (annotation?, (restriction | list | union)) //</simpleType> internal static XmlSchemaSimpleType Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSimpleType stype = new XmlSchemaSimpleType(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaGroup.Read, name=" + reader.Name, null); reader.Skip(); return(null); } stype.LineNumber = reader.LineNumber; stype.LinePosition = reader.LinePosition; stype.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "final") { Exception innerex; stype.Final = XmlSchemaUtil.ReadDerivationAttribute(reader, out innerex, "final", XmlSchemaUtil.FinalAllowed); if (innerex != null) { error(h, "some invalid values not a valid value for final", innerex); } } else if (reader.Name == "id") { stype.Id = reader.Value; } else if (reader.Name == "name") { stype.Name = reader.Value; } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for simpleType", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, stype); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(stype); } // Content: (annotation?, (restriction | list | union)) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaSimpleType.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) { stype.Annotation = annotation; } continue; } if (level <= 2) { if (reader.LocalName == "restriction") { level = 3; XmlSchemaSimpleTypeRestriction restriction = XmlSchemaSimpleTypeRestriction.Read(reader, h); if (restriction != null) { stype.content = restriction; } continue; } if (reader.LocalName == "list") { level = 3; XmlSchemaSimpleTypeList list = XmlSchemaSimpleTypeList.Read(reader, h); if (list != null) { stype.content = list; } continue; } if (reader.LocalName == "union") { level = 3; XmlSchemaSimpleTypeUnion union = XmlSchemaSimpleTypeUnion.Read(reader, h); if (union != null) { stype.content = union; } continue; } } reader.RaiseInvalidElementError(); } return(stype); }
internal static void FinishBuiltinType(XmlSchemaSimpleType derivedType, XmlSchemaSimpleType baseType) { derivedType.SetBaseSchemaType(baseType); derivedType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction); if (derivedType.Datatype.Variety == XmlSchemaDatatypeVariety.Atomic) { XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction { BaseTypeName = baseType.QualifiedName }; derivedType.Content = restriction; } if (derivedType.Datatype.Variety == XmlSchemaDatatypeVariety.List) { XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); derivedType.SetDerivedBy(XmlSchemaDerivationMethod.List); switch (derivedType.Datatype.TypeCode) { case XmlTypeCode.Idref: list.ItemType = list.BaseItemType = enumToTypeCode[0x26]; break; case XmlTypeCode.Entity: list.ItemType = list.BaseItemType = enumToTypeCode[0x27]; break; case XmlTypeCode.NmToken: list.ItemType = list.BaseItemType = enumToTypeCode[0x22]; break; } derivedType.Content = list; } }
private XmlSchemaType ExportEnumMapping(EnumMapping mapping, string ns) { if (!mapping.IncludeInSchema) { throw new InvalidOperationException(Res.GetString("XmlCannotIncludeInSchema", new object[] { mapping.TypeDesc.Name })); } XmlSchemaSimpleType type = (XmlSchemaSimpleType) this.types[mapping]; if (type == null) { this.CheckForDuplicateType(mapping, mapping.Namespace); type = new XmlSchemaSimpleType { Name = mapping.TypeName }; if (!mapping.IsAnonymousType) { this.types.Add(mapping, type); this.AddSchemaItem(type, mapping.Namespace, ns); } XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction { BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema") }; for (int i = 0; i < mapping.Constants.Length; i++) { ConstantMapping mapping2 = mapping.Constants[i]; XmlSchemaEnumerationFacet item = new XmlSchemaEnumerationFacet { Value = mapping2.XmlName }; restriction.Facets.Add(item); } if (!mapping.IsFlags) { type.Content = restriction; } else { XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); XmlSchemaSimpleType type2 = new XmlSchemaSimpleType { Content = restriction }; list.ItemType = type2; type.Content = list; } } if (!mapping.IsAnonymousType) { this.AddSchemaImport(mapping.Namespace, ns); } return type; }
EnumDataContract ImportFlagsEnum(XmlQualifiedName typeName, XmlSchemaSimpleTypeList list, XmlSchemaAnnotation annotation) { XmlSchemaSimpleType anonymousType = list.ItemType; if (anonymousType == null) ThrowEnumTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.GetString(SR.EnumListMustContainAnonymousType)); XmlSchemaSimpleTypeContent content = anonymousType.Content; if (content is XmlSchemaSimpleTypeUnion) ThrowEnumTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.GetString(SR.EnumUnionInAnonymousTypeNotSupported)); else if (content is XmlSchemaSimpleTypeList) ThrowEnumTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.GetString(SR.EnumListInAnonymousTypeNotSupported)); else if (content is XmlSchemaSimpleTypeRestriction) { XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction)content; if (CheckIfEnum(restriction)) return ImportEnum(typeName, restriction, true /*isFlags*/, annotation); else ThrowEnumTypeCannotBeImportedException(typeName.Name, typeName.Namespace, SR.GetString(SR.EnumRestrictionInvalid)); } return null; }
internal override XmlSchemaObject Clone() { XmlSchemaSimpleTypeList newList = (XmlSchemaSimpleTypeList)MemberwiseClone(); newList.ItemTypeName = _itemTypeName.Clone(); return newList; }
protected virtual void Visit(XmlSchemaSimpleTypeList list) { Traverse(list.BaseItemType); }
//<list // id = ID // itemType = QName // {any attributes with non-schema namespace . . .}> // Content: (annotation?, (simpleType?)) //</list> internal static XmlSchemaSimpleTypeList Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaSimpleTypeList.Read, name=" + reader.Name, null); reader.Skip(); return(null); } list.LineNumber = reader.LineNumber; list.LinePosition = reader.LinePosition; list.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { list.Id = reader.Value; } else if (reader.Name == "itemType") { Exception innerex; list.ItemTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex); if (innerex != null) { error(h, reader.Value + " is not a valid value for itemType attribute", innerex); } } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for list", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, list); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(list); } // Content: annotation?, simpleType? int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaSimpleTypeList.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) { list.Annotation = annotation; } continue; } if (level <= 2 && reader.LocalName == "simpleType") { level = 3; XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader, h); if (stype != null) { list.itemType = stype; } continue; } reader.RaiseInvalidElementError(); } return(list); }
void ExportEnumDataContract(EnumDataContract enumDataContract, XmlSchema schema) { XmlSchemaSimpleType type = new XmlSchemaSimpleType(); type.Name = enumDataContract.StableName.Name; XmlElement actualTypeElement = (enumDataContract.BaseContractName == DefaultEnumBaseTypeName) ? null : ExportActualType(enumDataContract.BaseContractName); type.Annotation = GetSchemaAnnotation(actualTypeElement, ExportSurrogateData(enumDataContract)); schema.Items.Add(type); XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); restriction.BaseTypeName = StringQualifiedName; SchemaHelper.AddSchemaImport(enumDataContract.BaseContractName.Namespace, schema); if (enumDataContract.Values != null) { for (int i = 0; i < enumDataContract.Values.Count; i++) { XmlSchemaEnumerationFacet facet = new XmlSchemaEnumerationFacet(); facet.Value = enumDataContract.Members[i].Name; if (enumDataContract.Values[i] != GetDefaultEnumValue(enumDataContract.IsFlags, i)) facet.Annotation = GetSchemaAnnotation(EnumerationValueAnnotationName, enumDataContract.GetStringFromEnumValue(enumDataContract.Values[i]), schema); restriction.Facets.Add(facet); } } if (enumDataContract.IsFlags) { XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); XmlSchemaSimpleType anonymousType = new XmlSchemaSimpleType(); anonymousType.Content = restriction; list.ItemType = anonymousType; type.Content = list; } else type.Content = restriction; }
void ExportEnumSchema (XmlTypeMapping map) { if (IsMapExported (map)) return; SetMapExported (map); XmlSchema schema = GetSchema (map.XmlTypeNamespace); XmlSchemaSimpleType stype = new XmlSchemaSimpleType (); stype.Name = map.ElementName; schema.Items.Add (stype); XmlSchemaSimpleTypeRestriction rest = new XmlSchemaSimpleTypeRestriction (); rest.BaseTypeName = new XmlQualifiedName ("string",XmlSchema.Namespace); EnumMap emap = (EnumMap) map.ObjectMap; foreach (EnumMap.EnumMapMember emem in emap.Members) { XmlSchemaEnumerationFacet ef = new XmlSchemaEnumerationFacet (); ef.Value = emem.XmlName; rest.Facets.Add (ef); } if (emap.IsFlags) { XmlSchemaSimpleTypeList slist = new XmlSchemaSimpleTypeList (); XmlSchemaSimpleType restrictionType = new XmlSchemaSimpleType (); restrictionType.Content = rest; slist.ItemType = restrictionType; stype.Content = slist; } else { stype.Content = rest; } }
private void Write14_XmlSchemaSimpleTypeList(XmlSchemaSimpleTypeList o) { if (o != null) { this.WriteStartElement("list"); this.WriteAttribute("id", "", o.Id); this.WriteAttributes(o.UnhandledAttributes, o); if (!o.ItemTypeName.IsEmpty) { this.WriteAttribute("itemType", "", o.ItemTypeName); } this.Write5_XmlSchemaAnnotation(o.Annotation); this.Write9_XmlSchemaSimpleType(o.ItemType); this.WriteEndElement(); } }
XmlSchemaType ExportEnumMapping(EnumMapping mapping, string ns) { if (!mapping.IncludeInSchema) throw new InvalidOperationException(Res.GetString(Res.XmlCannotIncludeInSchema, mapping.TypeDesc.Name)); XmlSchemaSimpleType dataType = (XmlSchemaSimpleType)types[mapping]; if (dataType == null) { CheckForDuplicateType(mapping, mapping.Namespace); dataType = new XmlSchemaSimpleType(); dataType.Name = mapping.TypeName; if (!mapping.IsAnonymousType) { types.Add(mapping, dataType); AddSchemaItem(dataType, mapping.Namespace, ns); } XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); restriction.BaseTypeName = new XmlQualifiedName("string", XmlSchema.Namespace); for (int i = 0; i < mapping.Constants.Length; i++) { ConstantMapping constant = mapping.Constants[i]; XmlSchemaEnumerationFacet enumeration = new XmlSchemaEnumerationFacet(); enumeration.Value = constant.XmlName; restriction.Facets.Add(enumeration); } if (!mapping.IsFlags) { dataType.Content = restriction; } else { XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); XmlSchemaSimpleType enumType = new XmlSchemaSimpleType(); enumType.Content = restriction; list.ItemType = enumType; dataType.Content = list; } } if (!mapping.IsAnonymousType) { AddSchemaImport(mapping.Namespace, ns); } return dataType; }
public virtual void Check (ConformanceCheckContext ctx, XmlSchemaSimpleTypeList value) {}
static void AddQNameListType(DiscoveryVersion discoveryVersion, XmlSchema schema) { // <xs:simpleType name="QNameListType"> XmlSchemaSimpleType qNameListType = new XmlSchemaSimpleType(); qNameListType.Name = ProtocolStrings.SchemaNames.QNameListType; // <xs:list itemType="xs:QName" /> XmlSchemaSimpleTypeList qNameListTypeContent = new XmlSchemaSimpleTypeList(); qNameListTypeContent.ItemTypeName = discoveryVersion.Implementation.QualifiedNames.QNameType; // </xs:simpleType> qNameListType.Content = qNameListTypeContent; schema.Items.Add(qNameListType); }
XmlQualifiedName ExportEnumMapping(EnumMapping mapping, string ns) { XmlSchemaSimpleType dataType = (XmlSchemaSimpleType)types[mapping]; if (dataType == null) { CheckForDuplicateType(mapping.TypeName, mapping.Namespace); dataType = new XmlSchemaSimpleType(); dataType.Name = mapping.TypeName; types.Add(mapping, dataType); AddSchemaItem(dataType, mapping.Namespace, ns); XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); restriction.BaseTypeName = new XmlQualifiedName("string", XmlSchema.Namespace); for (int i = 0; i < mapping.Constants.Length; i++) { ConstantMapping constant = mapping.Constants[i]; XmlSchemaEnumerationFacet enumeration = new XmlSchemaEnumerationFacet(); enumeration.Value = constant.XmlName; restriction.Facets.Add(enumeration); } if (!mapping.IsFlags) { dataType.Content = restriction; } else { XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); XmlSchemaSimpleType enumType = new XmlSchemaSimpleType(); enumType.Content = restriction; list.ItemType = enumType; dataType.Content = list; } } else { AddSchemaImport(mapping.Namespace, ns); } return new XmlQualifiedName(mapping.TypeName, mapping.Namespace); }
XmlCompletionItemCollection GetAttributeValueCompletion(XmlSchemaSimpleTypeList list) { XmlCompletionItemCollection completionItems = new XmlCompletionItemCollection(); if (list.ItemType != null) { completionItems.AddRange(GetAttributeValueCompletion(list.ItemType)); } else if (list.ItemTypeName != null) { XmlSchemaSimpleType simpleType = FindSimpleType(list.ItemTypeName); if (simpleType != null) { completionItems.AddRange(GetAttributeValueCompletion(simpleType)); } } return completionItems; }
/// <summary> /// Create and add an element to a service descriptions schema. Used to create a native XmlType element. /// </summary> /// <param name="elementName">A string contininig the name of an element.</param> /// <param name="elementTypeNs">A string containing the namespace of the type.</param> /// <param name="xmlTypeName">A string containing the name of an element type.</param> /// <param name="isArray">True if the element represents an array of native types.</param> /// <param name="serviceDesc">The ServiceDescription used to store Wsdl definition.</param> private void AddNativeTypeElement(string elementName, string elementNs, string xmlTypeName, bool isArray, ServiceDescription serviceDesc) { XmlSchema schema = FindSchemaByNamespace(elementNs, serviceDesc.Types.Schemas); if (schema == null) { schema = new XmlSchema(); serviceDesc.Types.Schemas.Add(schema); schema.TargetNamespace = FixupNamespace(elementNs); } // Add the element to the schema XmlSchemaElement element = new XmlSchemaElement(); element.Name = elementName; if (isArray) element.SchemaTypeName = new XmlQualifiedName(elementName + "ListType", elementNs); else element.SchemaTypeName = new XmlQualifiedName(xmlTypeName, "http://www.w3.org/2001/XMLSchema"); AddSchemaItem(schema, element); // If this is an array add a simple list type if (isArray) { XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType(); simpleType.Name = elementName + "ListType"; XmlSchemaSimpleTypeList simpleContent = new XmlSchemaSimpleTypeList(); simpleContent.ItemTypeName = new XmlQualifiedName(xmlTypeName, "http://www.w3.org/2001/XMLSchema"); simpleType.Content = simpleContent; AddSchemaItem(schema, simpleType); } return; }
internal override int Validate(ValidationEventHandler h, XmlSchema schema) { // 3.14.6 Properties Correct. // // 1. Post Compilation Properties // {name}, {target namespace} => QNameInternal. Already Compile()d. // {base type definition} => baseSchemaTypeInternal // {final} => finalResolved. Already Compile()d. // {variety} => resolvedDerivedBy. Already Compile()d. // // 2. Should be checked by "recursed" field. if (IsValidated(schema.ValidationId)) { return(errorCount); } if (recursed) { error(h, "Circular type reference was found."); return(errorCount); } recursed = true; CollectBaseType(h, schema); if (content != null) { errorCount += content.Validate(h, schema); } /* * // BaseSchemaType property * BaseXmlSchemaTypeInternal = content.ActualBaseSchemaType as XmlSchemaType; * if (this.BaseXmlSchemaTypeInternal == null) * this.DatatypeInternal = content.ActualBaseSchemaType as XmlSchemaDatatype; */ // Datatype property XmlSchemaSimpleType simple = BaseXmlSchemaType as XmlSchemaSimpleType; if (simple != null) { this.DatatypeInternal = simple.Datatype; } // else // DatatypeInternal = BaseSchemaType as XmlSchemaDatatype; // 3. XmlSchemaSimpleType baseSType = BaseXmlSchemaType as XmlSchemaSimpleType; if (baseSType != null) { if ((baseSType.FinalResolved & this.resolvedDerivedBy) != 0) { error(h, "Specified derivation is prohibited by the base simple type."); } } // {variety} if (this.resolvedDerivedBy == XmlSchemaDerivationMethod.Restriction && baseSType != null) { this.variety = baseSType.Variety; } else { this.variety = this.resolvedDerivedBy; } // 3.14.6 Derivation Valid (Restriction, Simple) XmlSchemaSimpleTypeRestriction r = Content as XmlSchemaSimpleTypeRestriction; object baseType = BaseXmlSchemaType != null ? (object)BaseXmlSchemaType : Datatype; if (r != null) { ValidateDerivationValid(baseType, r.Facets, h, schema); } // TODO: describe which validation term this belongs to. XmlSchemaSimpleTypeList l = Content as XmlSchemaSimpleTypeList; if (l != null) { XmlSchemaSimpleType itemSimpleType = l.ValidatedListItemType as XmlSchemaSimpleType; if (itemSimpleType != null && itemSimpleType.Content is XmlSchemaSimpleTypeList) { error(h, "List type must not be derived from another list type."); } } recursed = false; ValidationId = schema.ValidationId; return(errorCount); }
/// <summary> /// For a given type, generate a complex schema element. Recursively generate a complex type for any non /// native type referenced by this type. /// </summary> /// <param name="members">An array of MemberInfo objects that contain the reflected details of the sub /// types continined within this type.</param> /// <param name="element">A reference to an XmlElement used to store the new element information.</param> /// <param name="schema">A Schema object used to store the new element.</param> /// <param name="schemaNamespace">A string containing the Schemas targetnamespace.</param> /// <param name="serviceDesc"></param> void ProcessDataMemberType(MemberInfo[] members, ref XmlSchemaElement element, XmlSchema schema, string schemaNamespace, ServiceDescription serviceDesc) { element.SchemaTypeName = new XmlQualifiedName(element.Name + "Type", schemaNamespace); if (AddSchemaItem(schema, element)) return; XmlSchemaComplexType complexType = new XmlSchemaComplexType(); complexType.Name = element.Name + "Type"; complexType.Particle = new XmlSchemaSequence(); if (AddSchemaItem(schema, complexType)) return; // If members is null this type is an empty wrapper if (members == null) return; foreach (MemberInfo member in members) { FieldInfo fieldInfo = (FieldInfo)member; DataMemberAttrib dataMemberAttrib = GetDataMemberAttribute(fieldInfo); if (fieldInfo.FieldType.FullName != null) { // Special handling if the field type is an array bool isArray = false; string fieldTypeName = fieldInfo.FieldType.FullName; if (fieldTypeName.EndsWith("[]")) { isArray = true; fieldTypeName = fieldTypeName.Substring(0, fieldTypeName.Length - 2); } // If this is not a native type recurse and create the base type string xmlTypeName = CodeGenUtils.GetXmlType(fieldTypeName); if (xmlTypeName == null) { XmlSchemaElement elementItem = new XmlSchemaElement(); elementItem.RefName = new XmlQualifiedName(fieldInfo.Name, schemaNamespace); elementItem.MinOccurs = 0; elementItem.MaxOccurs = 1; // If the data member has modifiers reset values bool isAttribute = false; if (dataMemberAttrib != null) { elementItem.MinOccurs = dataMemberAttrib.IsRequired ? 1 : 0; if (dataMemberAttrib.Name != null) elementItem.RefName = new XmlQualifiedName(dataMemberAttrib.Name, schemaNamespace); isAttribute = dataMemberAttrib.IsAttribute; } if (isArray) { string fieldName = fieldInfo.FieldType.Name; fieldName = fieldName.Substring(0, fieldName.Length - 2); ProcessDataContract(fieldInfo.FieldType.GetElementType(), schemaNamespace, serviceDesc); elementItem.MaxOccursString = "unbounded"; } else { ProcessDataContract(fieldInfo.FieldType, schemaNamespace, serviceDesc); } // If order is set insert element at order position if (dataMemberAttrib != null && dataMemberAttrib.Order >= 0) ((XmlSchemaSequence)complexType.Particle).Items.Insert(dataMemberAttrib.Order, elementItem); else ((XmlSchemaSequence)complexType.Particle).Items.Add(elementItem); } else{ Logger.WriteLine(" Field = " + fieldInfo.FieldType.UnderlyingSystemType + " " + fieldInfo.Name, LogLevel.Verbose); XmlSchemaElement elementItem = new XmlSchemaElement(); elementItem.Name = fieldInfo.Name; // Process any types if (xmlTypeName == "any") { XmlSchemaAny anyElement = new XmlSchemaAny(); anyElement.MinOccurs = 0; anyElement.MaxOccursString = "unbounded"; anyElement.Namespace = "##other"; anyElement.ProcessContents = XmlSchemaContentProcessing.Lax; ((XmlSchemaSequence)complexType.Particle).Items.Add(anyElement); } else if (xmlTypeName == "anyAttribute") { XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute(); anyAttribute.Namespace = "##any"; anyAttribute.ProcessContents = XmlSchemaContentProcessing.Lax; complexType.AnyAttribute = anyAttribute; } else { elementItem.MinOccurs = 1; elementItem.MaxOccurs = 1; if (dataMemberAttrib != null) { if (dataMemberAttrib.IsAttribute) { XmlSchemaAttribute attrib = new XmlSchemaAttribute(); attrib.SchemaTypeName = new XmlQualifiedName(xmlTypeName, "http://www.w3.org/2001/XMLSchema"); attrib.Name = fieldInfo.FieldType.Name; if (dataMemberAttrib.IsRequired) attrib.Use = XmlSchemaUse.Required; return; } elementItem.MinOccurs = dataMemberAttrib.IsRequired ? 1 : 0; elementItem.IsNillable = dataMemberAttrib.IsNillable; } // If the type is an array create a simple List type before adding the element particle if (isArray && xmlTypeName != "base64Binary") { XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType(); simpleType.Name = fieldInfo.Name + "ListType"; XmlSchemaSimpleTypeList simpleContent = new XmlSchemaSimpleTypeList(); string itemTypeName = fieldInfo.FieldType.FullName; itemTypeName = itemTypeName.Substring(0, itemTypeName.Length - 2); simpleContent.ItemTypeName = new XmlQualifiedName(CodeGenUtils.GetXmlType(itemTypeName), "http://www.w3.org/2001/XMLSchema"); simpleType.Content = simpleContent; AddSchemaItem(schema, simpleType); elementItem.SchemaTypeName = new XmlQualifiedName(simpleType.Name, schemaNamespace); } else elementItem.SchemaTypeName = new XmlQualifiedName(xmlTypeName, "http://www.w3.org/2001/XMLSchema"); ((XmlSchemaSequence)complexType.Particle).Items.Add(elementItem); } } } } }
private void ExportAttributeAccessor(XmlSchemaComplexType type, AttributeAccessor accessor, bool valueTypeOptional, string ns) { if (accessor != null) { XmlSchemaObjectCollection attributes; if (type.ContentModel != null) { if (type.ContentModel.Content is XmlSchemaComplexContentRestriction) { attributes = ((XmlSchemaComplexContentRestriction) type.ContentModel.Content).Attributes; } else if (!(type.ContentModel.Content is XmlSchemaComplexContentExtension)) { if (!(type.ContentModel.Content is XmlSchemaSimpleContentExtension)) { throw new InvalidOperationException(Res.GetString("XmlInvalidContent", new object[] { type.ContentModel.Content.GetType().Name })); } attributes = ((XmlSchemaSimpleContentExtension) type.ContentModel.Content).Attributes; } else { attributes = ((XmlSchemaComplexContentExtension) type.ContentModel.Content).Attributes; } } else { attributes = type.Attributes; } if (accessor.IsSpecialXmlNamespace) { this.AddSchemaImport("http://www.w3.org/XML/1998/namespace", ns); XmlSchemaAttribute item = new XmlSchemaAttribute { Use = XmlSchemaUse.Optional, RefName = new XmlQualifiedName(accessor.Name, "http://www.w3.org/XML/1998/namespace") }; attributes.Add(item); } else if (accessor.Any) { if (type.ContentModel == null) { type.AnyAttribute = new XmlSchemaAnyAttribute(); } else { XmlSchemaContent content = type.ContentModel.Content; if (content is XmlSchemaComplexContentExtension) { XmlSchemaComplexContentExtension extension = (XmlSchemaComplexContentExtension) content; extension.AnyAttribute = new XmlSchemaAnyAttribute(); } else if (content is XmlSchemaComplexContentRestriction) { XmlSchemaComplexContentRestriction restriction = (XmlSchemaComplexContentRestriction) content; restriction.AnyAttribute = new XmlSchemaAnyAttribute(); } else if (type.ContentModel.Content is XmlSchemaSimpleContentExtension) { XmlSchemaSimpleContentExtension extension2 = (XmlSchemaSimpleContentExtension) content; extension2.AnyAttribute = new XmlSchemaAnyAttribute(); } } } else { XmlSchemaAttribute attribute2 = new XmlSchemaAttribute { Use = XmlSchemaUse.None }; if ((!accessor.HasDefault && !valueTypeOptional) && accessor.Mapping.TypeDesc.IsValueType) { attribute2.Use = XmlSchemaUse.Required; } attribute2.Name = accessor.Name; if ((accessor.Namespace == null) || (accessor.Namespace == ns)) { XmlSchema schema = this.schemas[ns]; if (schema == null) { attribute2.Form = (accessor.Form == XmlSchemaForm.Unqualified) ? XmlSchemaForm.None : accessor.Form; } else { attribute2.Form = (accessor.Form == schema.AttributeFormDefault) ? XmlSchemaForm.None : accessor.Form; } attributes.Add(attribute2); } else { if (this.attributes[accessor] == null) { attribute2.Use = XmlSchemaUse.None; attribute2.Form = accessor.Form; this.AddSchemaItem(attribute2, accessor.Namespace, ns); this.attributes.Add(accessor, accessor); } XmlSchemaAttribute attribute3 = new XmlSchemaAttribute { Use = XmlSchemaUse.None, RefName = new XmlQualifiedName(accessor.Name, accessor.Namespace) }; attributes.Add(attribute3); this.AddSchemaImport(accessor.Namespace, ns); } if (accessor.Mapping is PrimitiveMapping) { PrimitiveMapping mapping = (PrimitiveMapping) accessor.Mapping; if (mapping.IsList) { XmlSchemaSimpleType type2 = new XmlSchemaSimpleType(); XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList(); if (mapping.IsAnonymousType) { list.ItemType = (XmlSchemaSimpleType) this.ExportAnonymousPrimitiveMapping(mapping); } else { list.ItemTypeName = this.ExportPrimitiveMapping(mapping, (accessor.Namespace == null) ? ns : accessor.Namespace); } type2.Content = list; attribute2.SchemaType = type2; } else if (mapping.IsAnonymousType) { attribute2.SchemaType = (XmlSchemaSimpleType) this.ExportAnonymousPrimitiveMapping(mapping); } else { attribute2.SchemaTypeName = this.ExportPrimitiveMapping(mapping, (accessor.Namespace == null) ? ns : accessor.Namespace); } } else if (!(accessor.Mapping is SpecialMapping)) { throw new InvalidOperationException(Res.GetString("XmlInternalError")); } if (accessor.HasDefault) { attribute2.DefaultValue = ExportDefaultValue(accessor.Mapping, accessor.Default); } } } }
public override void Check (ConformanceCheckContext ctx, XmlSchemaSimpleTypeList value) { CheckSchemaQName (ctx, value, value.ItemTypeName); }
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; } }
XmlCompletionDataCollection GetAttributeValueCompletionData(XmlSchemaSimpleTypeList list) { XmlCompletionDataCollection data = new XmlCompletionDataCollection(); if (list.ItemType != null) { data.AddRange(GetAttributeValueCompletionData(list.ItemType)); } else if (list.ItemTypeName != null) { XmlSchemaSimpleType simpleType = FindSimpleType(list.ItemTypeName); if (simpleType != null) { data.AddRange(GetAttributeValueCompletionData(simpleType)); } } return data; }
void Write14_XmlSchemaSimpleTypeList(XmlSchemaSimpleTypeList o) { if ((object)o == null) return; WriteStartElement("list"); WriteAttribute(@"id", @"", ((System.String)o.@Id)); WriteAttributes((XmlAttribute[])o.@UnhandledAttributes, o); if ([email protected]){ WriteAttribute(@"itemType", @"", o.@ItemTypeName); } Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.@Annotation); Write9_XmlSchemaSimpleType((XmlSchemaSimpleType)o.@ItemType); WriteEndElement(); }
internal static XmlSchemaSimpleType Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSimpleType xmlSchemaSimpleType = new XmlSchemaSimpleType(); reader.MoveToElement(); if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "simpleType") { XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaGroup.Read, name=" + reader.Name, null); reader.Skip(); return(null); } xmlSchemaSimpleType.LineNumber = reader.LineNumber; xmlSchemaSimpleType.LinePosition = reader.LinePosition; xmlSchemaSimpleType.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "final") { Exception ex; xmlSchemaSimpleType.Final = XmlSchemaUtil.ReadDerivationAttribute(reader, out ex, "final", XmlSchemaUtil.FinalAllowed); if (ex != null) { XmlSchemaObject.error(h, "some invalid values not a valid value for final", ex); } } else if (reader.Name == "id") { xmlSchemaSimpleType.Id = reader.Value; } else if (reader.Name == "name") { xmlSchemaSimpleType.Name = 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 simpleType", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaSimpleType); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(xmlSchemaSimpleType); } int num = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != "simpleType") { XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaSimpleType.Read, name=" + reader.Name, null); } break; } if (num <= 1 && reader.LocalName == "annotation") { num = 2; XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h); if (xmlSchemaAnnotation != null) { xmlSchemaSimpleType.Annotation = xmlSchemaAnnotation; } } else { if (num <= 2) { if (reader.LocalName == "restriction") { num = 3; XmlSchemaSimpleTypeRestriction xmlSchemaSimpleTypeRestriction = XmlSchemaSimpleTypeRestriction.Read(reader, h); if (xmlSchemaSimpleTypeRestriction != null) { xmlSchemaSimpleType.content = xmlSchemaSimpleTypeRestriction; } continue; } if (reader.LocalName == "list") { num = 3; XmlSchemaSimpleTypeList xmlSchemaSimpleTypeList = XmlSchemaSimpleTypeList.Read(reader, h); if (xmlSchemaSimpleTypeList != null) { xmlSchemaSimpleType.content = xmlSchemaSimpleTypeList; } continue; } if (reader.LocalName == "union") { num = 3; XmlSchemaSimpleTypeUnion xmlSchemaSimpleTypeUnion = XmlSchemaSimpleTypeUnion.Read(reader, h); if (xmlSchemaSimpleTypeUnion != null) { xmlSchemaSimpleType.content = xmlSchemaSimpleTypeUnion; } continue; } } reader.RaiseInvalidElementError(); } } return(xmlSchemaSimpleType); }