public static System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(System.Xml.Schema.XmlSchemaSet xs) { System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType(); System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence(); Products ds = new Products(); xs.Add(ds.GetSchemaSerializable()); System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny(); any1.Namespace = "http://www.w3.org/2001/XMLSchema"; any1.MinOccurs = new decimal(0); any1.MaxOccurs = decimal.MaxValue; any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax; sequence.Items.Add(any1); System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny(); any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1"; any2.MinOccurs = new decimal(1); any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax; sequence.Items.Add(any2); System.Xml.Schema.XmlSchemaAttribute attribute1 = new System.Xml.Schema.XmlSchemaAttribute(); attribute1.Name = "namespace"; attribute1.FixedValue = ds.Namespace; type.Attributes.Add(attribute1); System.Xml.Schema.XmlSchemaAttribute attribute2 = new System.Xml.Schema.XmlSchemaAttribute(); attribute2.Name = "tableTypeName"; attribute2.FixedValue = "ProductDataTable"; type.Attributes.Add(attribute2); type.Particle = sequence; return(type); }
public static System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(System.Xml.Schema.XmlSchemaSet xs) { TypedDataSet ds = new TypedDataSet(); System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType(); System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence(); xs.Add(ds.GetSchemaSerializable()); if (PublishLegacyWSDL()) { System.Xml.Schema.XmlSchemaAny any = new System.Xml.Schema.XmlSchemaAny(); any.Namespace = ds.Namespace; sequence.Items.Add(any); } else { System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny(); any1.Namespace = "http://www.w3.org/2001/XMLSchema"; any1.MinOccurs = new System.Decimal(0); any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax; sequence.Items.Add(any1); System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny(); any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1"; any2.MinOccurs = new System.Decimal(0); any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax; sequence.Items.Add(any2); sequence.MaxOccurs = System.Decimal.MaxValue; System.Xml.Schema.XmlSchemaAttribute attribute = new System.Xml.Schema.XmlSchemaAttribute(); attribute.Name = "namespace"; attribute.FixedValue = ds.Namespace; type.Attributes.Add(attribute); } type.Particle = sequence; return(type); }
public static XmlSchemaElement AndSchema() { var type = new XmlSchemaComplexType(); var any = new XmlSchemaAny(); any.MinOccurs = 1; any.MaxOccursString = "unbounded"; any.ProcessContents = XmlSchemaContentProcessing.Strict; any.Namespace = "##local"; var sequence = new XmlSchemaSequence(); type.Particle = sequence; sequence.Items.Add(any); var attrib = new XmlSchemaAttribute(); attrib.Name = "expressionLanguage"; attrib.Use = XmlSchemaUse.Optional; attrib.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); type.Attributes.Add(attrib); attrib = new XmlSchemaAttribute(); attrib.Name = "failMessage"; attrib.Use = XmlSchemaUse.Optional; attrib.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); type.Attributes.Add(attrib); var element = new XmlSchemaElement(); element.Name = "and"; element.SchemaType = type; return element; }
private void CreateSchema(String name, DataTable dt) { XmlSchema schema = new XmlSchema(); rootElem = new XmlSchemaElement(); rootElem.Name = XmlConvert.EncodeName(name); schema.Items.Add(rootElem); XmlSchemaComplexType rootContent = new XmlSchemaComplexType(); rootElem.SchemaType = rootContent; XmlSchemaSequence s1 = new XmlSchemaSequence(); rootContent.Particle = s1; rowElem = new XmlSchemaElement(); rowElem.Name = "row"; rowElem.MinOccurs = 0; rowElem.MaxOccursString = "unbounded"; s1.Items.Add(rowElem); XmlSchemaComplexType rowContent = new XmlSchemaComplexType(); rowElem.SchemaType = rowContent; XmlSchemaSequence s2 = new XmlSchemaSequence(); rowContent.Particle = s2; DataRow[] dt_rows = dt.Select(); dataElem = new XmlSchemaElement[dt_rows.Length]; dataContent = new XmlSchemaSimpleType[dt_rows.Length]; for (int k = 0; k < dt_rows.Length; k++) { DataRow r = dt_rows[k]; dataElem[k] = new XmlSchemaElement(); dataElem[k].Name = XmlConvert.EncodeName((String)r["ColumnName"]); if (r["AllowDBNull"] != DBNull.Value && (bool)r["AllowDBNull"]) dataElem[k].MinOccurs = 0; Type dataType = (Type)r["DataType"]; XmlTypeCode typeCode = XQuerySequenceType.GetXmlTypeCode(dataType); if (typeCode == XmlTypeCode.Item) dataContent[k] = null; else { dataContent[k] = XmlSchemaType.GetBuiltInSimpleType(typeCode); dataElem[k].SchemaTypeName = dataContent[k].QualifiedName; } s2.Items.Add(dataElem[k]); } m_schemaSet = new XmlSchemaSet(); m_schemaSet.Add(schema); m_schemaSet.Compile(); NewNode(XmlNodeType.XmlDeclaration, null, null, null); NewNode(XmlNodeType.Element, name, null, null); m_readState = ReadState.Initial; //XmlWriter writer = XmlWriter.Create("c:\\work\\schema.xml"); //schema.Write(writer); //writer.Close(); }
private string genExpXsd() { sch.XmlSchema expSchema = new sch.XmlSchema(); //Create the PdeData element sch.XmlSchemaElement rootElement = new sch.XmlSchemaElement(); rootElement.Name = ROOT_ELEMENT; expSchema.Items.Add(rootElement); sch.XmlSchemaComplexType rootType = new sch.XmlSchemaComplexType(); rootType.IsMixed = false; sch.XmlSchemaSequence rootSequence = new sch.XmlSchemaSequence(); rootType.Particle = rootSequence; rootElement.SchemaType = rootType; foreach (ExportItemMap itemMap in exportItems) { if (itemMap.mapType == ProntoDoc.Framework.CoreObject.MapType.singleCell) { sch.XmlSchemaElement item = new sch.XmlSchemaElement(); item.Name = itemMap.treeNodeName; item.SchemaTypeName = new XmlQualifiedName(itemMap.dataType, ns); rootSequence.Items.Add(item); } else { sch.XmlSchemaElement tabElement = new sch.XmlSchemaElement(); tabElement.MinOccurs = 0; tabElement.MaxOccursString = "unbounded"; tabElement.Name = itemMap.treeNodeName; rootSequence.Items.Add(tabElement); sch.XmlSchemaComplexType tabType = new sch.XmlSchemaComplexType(); tabType.IsMixed = false; sch.XmlSchemaAll tabAll = new sch.XmlSchemaAll(); tabType.Particle = tabAll; tabElement.SchemaType = tabType; //generate children node foreach (TableColumnMap col in itemMap.tabCols) { sch.XmlSchemaElement item = new sch.XmlSchemaElement(); item.Name = col.treeNodeName; item.SchemaTypeName = new XmlQualifiedName(col.dataType, ns); tabAll.Items.Add(item); } } } expSchema.Compile(new sch.ValidationEventHandler(ValidationEventHandler)); FileStream stream = new FileStream("e:\\tempout.xsd", FileMode.Create); //Write the file expSchema.Write(stream); stream.Close(); return("e:\\tempout.xsd"); }
/// <summary> /// Формируем XmlSchema для правильного отображения индикаторов группы в VGridControl /// </summary> /// <param name="elmList">названия всех по</param> /// <returns>Возвращаем поток в который записана XmlSchema</returns> public static MemoryStream CreateXmlSchemaForIndicatorsInGroup(List<string[]> elmList) { var xmlSchema = new XmlSchema(); // <xs:element name="root"> var elementRoot = new XmlSchemaElement(); xmlSchema.Items.Add(elementRoot); elementRoot.Name = "root"; // <xs:complexType> var complexType = new XmlSchemaComplexType(); elementRoot.SchemaType = complexType; // <xs:choice minOccurs="0" maxOccurs="unbounded"> var choice = new XmlSchemaChoice(); complexType.Particle = choice; choice.MinOccurs = 0; choice.MaxOccursString = "unbounded"; // <xs:element name="record"> var elementRecord = new XmlSchemaElement(); choice.Items.Add(elementRecord); elementRecord.Name = "record"; // <xs:complexType> var complexType2 = new XmlSchemaComplexType(); elementRecord.SchemaType = complexType2; // <xs:sequence> var sequence = new XmlSchemaSequence(); complexType2.Particle = sequence; foreach (var el in elmList) { var element = new XmlSchemaElement(); sequence.Items.Add(element); element.Name = el[0]; element.SchemaTypeName = new XmlQualifiedName(el[1], "http://www.w3.org/2001/XMLSchema"); } var schemaSet = new XmlSchemaSet(); schemaSet.Add(xmlSchema); schemaSet.Compile(); XmlSchema compiledSchema = null; foreach (XmlSchema schema1 in schemaSet.Schemas()) compiledSchema = schema1; var nsmgr = new XmlNamespaceManager(new NameTable()); nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema"); var ms = new MemoryStream(); if (compiledSchema != null) compiledSchema.Write(ms, nsmgr); ms.Position = 0; return ms; }
XmlSchemaComplexType GetStype () { XmlSchemaSequence seq = new XmlSchemaSequence (); seq.Items.Add (new XmlSchemaAny ()); XmlSchemaComplexType stype = new XmlSchemaComplexType (); stype.Particle = seq; return stype; }
private Sequence CreateSequence() { Sequence s = new Sequence(); if (laxOccurrence) { s.MinOccurs = 0; } return(s); }
private Schema.XmlSchemaSequence CreateSequenceElement(Schema.XmlSchema parent, string name) { Schema.XmlSchemaElement element = new Schema.XmlSchemaElement(); element.Name = name; parent.Items.Add(element); Schema.XmlSchemaComplexType type = new Schema.XmlSchemaComplexType(); type.IsMixed = false; Schema.XmlSchemaSequence sequence = new Schema.XmlSchemaSequence(); type.Particle = sequence; element.SchemaType = type; return(sequence); }
public static System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(System.Xml.Schema.XmlSchemaSet xs) { Products ds = new Products(); System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType(); System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence(); xs.Add(ds.GetSchemaSerializable()); System.Xml.Schema.XmlSchemaAny any = new System.Xml.Schema.XmlSchemaAny(); any.Namespace = ds.Namespace; sequence.Items.Add(any); type.Particle = sequence; return(type); }
internal void ReflectStringParametersMessage() { Message inputMessage = InputMessage; foreach (ParameterInfo parameterInfo in Method.InParameters) { MessagePart part = new MessagePart(); part.Name = XmlConvert.EncodeLocalName(parameterInfo.Name); if (parameterInfo.ParameterType.IsArray) { string typeNs = DefaultNamespace; if (typeNs.EndsWith("/", StringComparison.Ordinal)) typeNs += "AbstractTypes"; else typeNs += "/AbstractTypes"; string typeName = "StringArray"; if (!ServiceDescription.Types.Schemas.Contains(typeNs)) { XmlSchema schema = new XmlSchema(); schema.TargetNamespace = typeNs; ServiceDescription.Types.Schemas.Add(schema); XmlSchemaElement element = new XmlSchemaElement(); element.Name = "String"; element.SchemaTypeName = new XmlQualifiedName("string", XmlSchema.Namespace); element.MinOccurs = decimal.Zero; element.MaxOccurs = decimal.MaxValue; XmlSchemaSequence all = new XmlSchemaSequence(); all.Items.Add(element); XmlSchemaComplexContentRestriction restriction = new XmlSchemaComplexContentRestriction(); restriction.BaseTypeName = new XmlQualifiedName(Soap.ArrayType, Soap.Encoding); restriction.Particle = all; XmlSchemaImport import = new XmlSchemaImport(); import.Namespace = restriction.BaseTypeName.Namespace; XmlSchemaComplexContent model = new XmlSchemaComplexContent(); model.Content = restriction; XmlSchemaComplexType type = new XmlSchemaComplexType(); type.Name = typeName; type.ContentModel = model; schema.Items.Add(type); schema.Includes.Add(import); } part.Type = new XmlQualifiedName(typeName, typeNs); } else { part.Type = new XmlQualifiedName("string", XmlSchema.Namespace); } inputMessage.Parts.Add(part); } }
private Sequence PopulateSequence(ComplexType ct) { Particle p = PopulateParticle(ct); Sequence s = p as Sequence; if (s != null) { return(s); } else { throw Error(ct, String.Format("Target complexType contains unacceptable type of particle {0}", p)); } }
private void InferComplexContent(Element el, string ns, bool isNew) { ComplexType ct = ToComplexType(el); ToComplexContentType(ct); int position = 0; bool consumed = false; do { switch (source.NodeType) { case XmlNodeType.Element: Sequence s = PopulateSequence(ct); Choice c = s.Items.Count > 0 ? s.Items [0] as Choice : null; if (c != null) { ProcessLax(c, ns); } else { ProcessSequence(ct, s, ns, ref position, ref consumed, isNew); } source.MoveToContent(); break; case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.SignificantWhitespace: MarkAsMixed(ct); source.ReadString(); source.MoveToContent(); break; case XmlNodeType.EndElement: return; // finished case XmlNodeType.None: throw new NotImplementedException("Internal Error: Should not happen."); } } while (true); }
private Schema.XmlSchemaAll CreateElement(Schema.XmlSchemaSequence parent, string name) { Schema.XmlSchemaElement element = new Schema.XmlSchemaElement(); element.MinOccurs = 0; element.MaxOccursString = "unbounded"; element.Name = name; parent.Items.Add(element); Schema.XmlSchemaComplexType type = new Schema.XmlSchemaComplexType(); type.IsMixed = false; Schema.XmlSchemaAll elementAll = new Schema.XmlSchemaAll(); type.Particle = elementAll; element.SchemaType = type; return(elementAll); }
// Note that it does not return the changed sequence. private Choice ToSequenceOfChoice(Sequence s) { Choice c = new Choice(); if (laxOccurrence) { c.MinOccurs = 0; } c.MaxOccursString = "unbounded"; foreach (Particle p in s.Items) { c.Items.Add(p); } s.Items.Clear(); s.Items.Add(c); return(c); }
private Parameter[] GetParameters(string messagePartName) { List <Parameter> parameters = new List <Parameter>(); //Types types = serviceDescription.Types; //System.Xml.Schema.XmlSchema xmlSchema = types.Schemas[0]; foreach (XmlSchemaElement schemaElement in e.GlobalElements.Values) { //} //foreach (object item in xmlSchema.Items) //{ // System.Xml.Schema.XmlSchemaElement schemaElement = item as System.Xml.Schema.XmlSchemaElement; if (schemaElement != null) { if (schemaElement.Name == messagePartName) { System.Xml.Schema.XmlSchemaType schemaType = schemaElement.SchemaType; System.Xml.Schema.XmlSchemaComplexType complexType = schemaType as System.Xml.Schema.XmlSchemaComplexType; if (complexType != null) { System.Xml.Schema.XmlSchemaParticle particle = complexType.Particle; System.Xml.Schema.XmlSchemaSequence sequence = particle as System.Xml.Schema.XmlSchemaSequence; if (sequence != null) { foreach (System.Xml.Schema.XmlSchemaElement childElement in sequence.Items) { string parameterName = childElement.Name; string parameterType = childElement.SchemaTypeName.Name; parameters.Add(new Parameter(parameterName, parameterType, null, null)); } } } break; } } } return(parameters.ToArray()); }
private bool CheckIfCollection(XmlSchemaSequence rootSequence) { if ((rootSequence.Items == null) || (rootSequence.Items.Count == 0)) { return false; } this.RemoveOptionalUnknownSerializationElements(rootSequence.Items); if (rootSequence.Items.Count != 1) { return false; } XmlSchemaObject obj2 = rootSequence.Items[0]; if (!(obj2 is XmlSchemaElement)) { return false; } XmlSchemaElement element = (XmlSchemaElement) obj2; if (!(element.MaxOccursString == "unbounded")) { return (element.MaxOccurs > 1M); } return true; }
private static XmlSchemaComplexType CreateAnyType(XmlSchemaContentProcessing processContents) { XmlSchemaComplexType localAnyType = new XmlSchemaComplexType(); localAnyType.SetQualifiedName(DatatypeImplementation.QnAnyType); XmlSchemaAny anyElement = new XmlSchemaAny(); anyElement.MinOccurs = decimal.Zero; anyElement.MaxOccurs = decimal.MaxValue; anyElement.ProcessContents = processContents; anyElement.BuildNamespaceList(null); XmlSchemaSequence seq = new XmlSchemaSequence(); seq.Items.Add(anyElement); localAnyType.SetContentTypeParticle(seq); localAnyType.SetContentType(XmlSchemaContentType.Mixed); localAnyType.ElementDecl = SchemaElementDecl.CreateAnyTypeElementDecl(); localAnyType.ElementDecl.SchemaType = localAnyType; //Create contentValidator for Any ParticleContentValidator contentValidator = new ParticleContentValidator(XmlSchemaContentType.Mixed); contentValidator.Start(); contentValidator.OpenGroup(); contentValidator.AddNamespaceList(anyElement.NamespaceList, anyElement); contentValidator.AddStar(); contentValidator.CloseGroup(); ContentValidator anyContentValidator = contentValidator.Finish(true); localAnyType.ElementDecl.ContentValidator = anyContentValidator; XmlSchemaAnyAttribute anyAttribute = new XmlSchemaAnyAttribute(); anyAttribute.ProcessContents = processContents; anyAttribute.BuildNamespaceList(null); localAnyType.SetAttributeWildcard(anyAttribute); localAnyType.ElementDecl.AnyAttribute = anyAttribute; return localAnyType; }
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 void ProcessSequence(ComplexType ct, Sequence s, string ns, ref int position, ref bool consumed, bool isNew) { for (int i = 0; i < position; i++) { Element iel = s.Items [i] as Element; if (ElementMatches(iel, ns)) { // Sequence element type violation // might happen (might not, but we // cannot backtrack here). So switch // to sequence of choice* here. ProcessLax(ToSequenceOfChoice(s), ns); return; } } if (s.Items.Count <= position) { QName name = new QName(source.LocalName, source.NamespaceURI); Element nel = CreateElement(name); if (laxOccurrence) { nel.MinOccurs = 0; } InferElement(nel, ns, true); if (ns == name.Namespace) { s.Items.Add(nel); } else { Element re = new Element(); if (laxOccurrence) { re.MinOccurs = 0; } re.RefName = name; AddImport(ns, name.Namespace); s.Items.Add(re); } consumed = true; return; } Element el = s.Items [position] as Element; if (el == null) { throw Error(s, String.Format("Target complex type content sequence has an unacceptable type of particle {0}", s.Items [position])); } bool matches = ElementMatches(el, ns); if (matches) { if (consumed) { el.MaxOccursString = "unbounded"; } InferElement(el, source.NamespaceURI, false); source.MoveToContent(); switch (source.NodeType) { case XmlNodeType.None: if (source.NodeType == XmlNodeType.Element) { goto case XmlNodeType.Element; } else if (source.NodeType == XmlNodeType.EndElement) { goto case XmlNodeType.EndElement; } break; case XmlNodeType.Element: ProcessSequence(ct, s, ns, ref position, ref consumed, isNew); break; case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.SignificantWhitespace: MarkAsMixed(ct); source.ReadString(); goto case XmlNodeType.None; case XmlNodeType.Whitespace: source.ReadString(); goto case XmlNodeType.None; case XmlNodeType.EndElement: return; default: source.Read(); break; } } else { if (consumed) { position++; consumed = false; ProcessSequence(ct, s, ns, ref position, ref consumed, isNew); } else { ProcessLax(ToSequenceOfChoice(s), ns); } } }
public XmlSchema GetSchema () { XmlSchema s = new XmlSchema (); s.TargetNamespace = "http://www.go-mono.org/schemas"; s.Id = "monoschema"; XmlSchemaElement e = new XmlSchemaElement (); e.Name = "data"; s.Items.Add (e); XmlSchemaComplexType cs = new XmlSchemaComplexType (); XmlSchemaSequence seq = new XmlSchemaSequence (); XmlSchemaAny any = new XmlSchemaAny (); any.MinOccurs = 0; any.MaxOccurs = decimal.MaxValue; seq.Items.Add (any); cs.Particle = seq; e.SchemaType = cs; return s; }
QName ExportParameters (MessageBodyDescription msgbody, string name, string ns) { XmlSchema xs = GetSchema (ns); //FIXME: Extract to a HasElement method ? foreach (XmlSchemaObject o in xs.Items) { XmlSchemaElement e = o as XmlSchemaElement; if (e == null) continue; if (e.Name == name) throw new InvalidOperationException (String.Format ( "Message element named '{0}:{1}' has already been exported.", ns, name)); } //Create the element for "parameters" XmlSchemaElement schema_element = new XmlSchemaElement (); schema_element.Name = name; XmlSchemaComplexType complex_type = new XmlSchemaComplexType (); //Generate Sequence representing the message/parameters //FIXME: MessageContractAttribute XmlSchemaSequence sequence = new XmlSchemaSequence (); XmlSchemaElement element = null; if (msgbody.ReturnValue == null) { //parameters foreach (MessagePartDescription part in msgbody.Parts) { if (part.Type == null) //FIXME: Eg. when WsdlImporter is used to import a wsdl throw new NotImplementedException (); element = GetSchemaElementForPart (part, xs); sequence.Items.Add (element); } } else { //ReturnValue if (msgbody.ReturnValue.Type != typeof (void)) { element = GetSchemaElementForPart (msgbody.ReturnValue, xs); sequence.Items.Add (element); } } complex_type.Particle = sequence; schema_element.SchemaType = complex_type; xs.Items.Add (schema_element); GeneratedXmlSchemas.Reprocess (xs); return new QName (schema_element.Name, xs.TargetNamespace); }
private bool IsSequenceFromChoice(XmlSchemaSequence derivedSequence, XmlSchemaChoice baseChoice) { decimal num; decimal num2; this.CalculateSequenceRange(derivedSequence, out num, out num2); if (!this.IsValidOccurrenceRangeRestriction(num, num2, baseChoice.MinOccurs, baseChoice.MaxOccurs) || (derivedSequence.Items.Count > baseChoice.Items.Count)) { return false; } for (int i = 0; i < derivedSequence.Items.Count; i++) { if (this.GetMappingParticle((XmlSchemaParticle) derivedSequence.Items[i], baseChoice.Items) < 0) { return false; } } return true; }
private XmlSchemaParticle CannonicalizeAll(XmlSchemaAll all, bool root, bool substitution) { if (all.Items.Count > 0) { XmlSchemaAll all2 = new XmlSchemaAll { MinOccurs = all.MinOccurs, MaxOccurs = all.MaxOccurs, SourceUri = all.SourceUri, LineNumber = all.LineNumber, LinePosition = all.LinePosition }; for (int i = 0; i < all.Items.Count; i++) { XmlSchemaParticle item = this.CannonicalizeParticle((XmlSchemaElement) all.Items[i], false, substitution); if (item != XmlSchemaParticle.Empty) { all2.Items.Add(item); } } all = all2; } if (all.Items.Count == 0) { return XmlSchemaParticle.Empty; } if (root && (all.Items.Count == 1)) { XmlSchemaSequence sequence = new XmlSchemaSequence { MinOccurs = all.MinOccurs, MaxOccurs = all.MaxOccurs }; sequence.Items.Add((XmlSchemaParticle) all.Items[0]); return sequence; } if ((!root && (all.Items.Count == 1)) && ((all.MinOccurs == 1M) && (all.MaxOccurs == 1M))) { return (XmlSchemaParticle) all.Items[0]; } if (!root) { base.SendValidationEvent("Sch_NotAllAlone", all); return XmlSchemaParticle.Empty; } return all; }
private void CompileComplexContentExtension(XmlSchemaComplexType complexType, XmlSchemaComplexContent complexContent, XmlSchemaComplexContentExtension complexExtension) { XmlSchemaComplexType redefined = null; if ((complexType.Redefined != null) && (complexExtension.BaseTypeName == complexType.Redefined.QualifiedName)) { redefined = (XmlSchemaComplexType) complexType.Redefined; this.CompileComplexType(redefined); } else { redefined = this.GetComplexType(complexExtension.BaseTypeName); if (redefined == null) { base.SendValidationEvent("Sch_UndefBaseExtension", complexExtension.BaseTypeName.ToString(), complexExtension); return; } } if (((redefined != null) && (redefined.ElementDecl != null)) && (redefined.ContentType == XmlSchemaContentType.TextOnly)) { base.SendValidationEvent("Sch_NotComplexContent", complexType); } else { complexType.SetBaseSchemaType(redefined); if ((redefined.FinalResolved & XmlSchemaDerivationMethod.Extension) != XmlSchemaDerivationMethod.Empty) { base.SendValidationEvent("Sch_BaseFinalExtension", complexType); } this.CompileLocalAttributes(redefined, complexType, complexExtension.Attributes, complexExtension.AnyAttribute, XmlSchemaDerivationMethod.Extension); XmlSchemaParticle contentTypeParticle = redefined.ContentTypeParticle; XmlSchemaParticle item = this.CannonicalizeParticle(complexExtension.Particle, true, true); if (contentTypeParticle != XmlSchemaParticle.Empty) { if (item != XmlSchemaParticle.Empty) { XmlSchemaSequence particle = new XmlSchemaSequence(); particle.Items.Add(contentTypeParticle); particle.Items.Add(item); complexType.SetContentTypeParticle(this.CompileContentTypeParticle(particle, false)); } else { complexType.SetContentTypeParticle(contentTypeParticle); } XmlSchemaContentType contentType = this.GetSchemaContentType(complexType, complexContent, item); if (contentType == XmlSchemaContentType.Empty) { contentType = redefined.ContentType; } complexType.SetContentType(contentType); if (complexType.ContentType != redefined.ContentType) { base.SendValidationEvent("Sch_DifContentType", complexType); } } else { complexType.SetContentTypeParticle(item); complexType.SetContentType(this.GetSchemaContentType(complexType, complexContent, complexType.ContentTypeParticle)); } complexType.SetDerivedBy(XmlSchemaDerivationMethod.Extension); } }
//<extension // base = QName // id = ID // {any attributes with non-schema namespace . . .}> // Content: (annotation?, ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?))) //</extension> internal static XmlSchemaComplexContentExtension Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaComplexContentExtension extension = new XmlSchemaComplexContentExtension(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaComplexContentExtension.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", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, extension); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(extension); } //Content: 1. annotation?, // (2.(group | all | choice | sequence)?, (3.(attribute | attributeGroup)*, 4.anyAttribute?))) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaComplexContentExtension.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 == "group") { level = 3; XmlSchemaGroupRef group = XmlSchemaGroupRef.Read(reader, h); if (group != null) { extension.particle = group; } continue; } if (reader.LocalName == "all") { level = 3; XmlSchemaAll all = XmlSchemaAll.Read(reader, h); if (all != null) { extension.particle = all; } continue; } if (reader.LocalName == "choice") { level = 3; XmlSchemaChoice choice = XmlSchemaChoice.Read(reader, h); if (choice != null) { extension.particle = choice; } continue; } if (reader.LocalName == "sequence") { level = 3; XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader, h); if (sequence != null) { extension.particle = sequence; } continue; } } if (level <= 3) { if (reader.LocalName == "attribute") { level = 3; XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader, h); if (attr != null) { extension.Attributes.Add(attr); } continue; } if (reader.LocalName == "attributeGroup") { level = 3; XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader, h); if (attr != null) { extension.attributes.Add(attr); } continue; } } if (level <= 4 && reader.LocalName == "anyAttribute") { level = 5; XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader, h); if (anyattr != null) { extension.AnyAttribute = anyattr; } continue; } reader.RaiseInvalidElementError(); } return(extension); }
/// <summary> /// Gets the class schema. /// </summary> /// <param name="t">The t.</param> /// <returns>schema info</returns> public static SchemaInfo GetClassSchema(this Type t) { var schemaInfo = new SchemaInfo(); var classType = new XmlSchemaComplexType { Name = t.Name }; var attribData = t.GetCustomAttributeDataOfType(typeof(DataContractAttribute)); if (attribData.NamedArguments != null && attribData.NamedArguments.Count > 0) { foreach (var p1 in attribData.NamedArguments) { switch (p1.MemberInfo.Name) { case "Namespace": schemaInfo.Schema.TargetNamespace = p1.TypedValue.Value as string; break; } } } var sequence = new XmlSchemaSequence(); classType.Particle = sequence; var propList = t.GetProperties(); foreach (var p1 in propList) { var el = new XmlSchemaElement { Name = p1.Name, MinOccurs = 0 }; var xmlName = p1.PropertyType.XmlName(); if (xmlName != null) { el.SchemaTypeName = xmlName; } else { if (p1.PropertyType.IsListType()) { // what is this a list of? if (p1.PropertyType.FullName != null) { var pr = Primitive2Xml.XmlName(InternalType(p1.PropertyType.FullName, false)); if (pr != null) { el.SchemaTypeName = new XmlQualifiedName("ArrayOf" + pr.Name); schemaInfo.CustomTypes.Add(el.SchemaTypeName); } else { var schName = InternalType(p1.PropertyType.FullName, true); el.SchemaTypeName = new XmlQualifiedName("ArrayOf" + schName); schemaInfo.CustomTypes.Add(new XmlQualifiedName(schName)); schemaInfo.CustomTypes.Add(el.SchemaTypeName); } } } else if (p1.PropertyType.Name.Contains("Nullable")) { // what is this a nullable of? if (p1.PropertyType.FullName != null) { var pr = Primitive2Xml.XmlName(InternalType(p1.PropertyType.FullName, false)); if (pr != null) { el.SchemaTypeName = pr; } else { var schName = InternalType(p1.PropertyType.FullName, true); el.SchemaTypeName = new XmlQualifiedName(schName); schemaInfo.CustomTypes.Add(el.SchemaTypeName); } el.IsNillable = true; } } else { el.SchemaTypeName = new XmlQualifiedName(p1.PropertyType.Name); schemaInfo.CustomTypes.Add(el.SchemaTypeName); } } // get data member var attrData = p1.GetCustomAttributeDataOfType(typeof(DataMemberAttribute)); if (attrData != null && attrData.NamedArguments != null && attrData.NamedArguments.Count > 0) { foreach (var pp in attrData.NamedArguments) { switch (pp.MemberInfo.Name) { case "IsRequired": { var v = (bool)pp.TypedValue.Value; el.MinOccurs = v ? 1 : 0; } break; } } } sequence.Items.Add(el); } schemaInfo.Schema.Items.Add(classType); return schemaInfo; }
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle, ValidationEventHandler h, XmlSchema schema, bool raiseError) { if (this == baseParticle) { return(true); } XmlSchemaElement xmlSchemaElement = baseParticle as XmlSchemaElement; if (xmlSchemaElement != null) { if (raiseError) { base.error(h, "Invalid sequence paricle derivation."); } return(false); } XmlSchemaSequence xmlSchemaSequence = baseParticle as XmlSchemaSequence; if (xmlSchemaSequence != null) { return(this.ValidateOccurenceRangeOK(xmlSchemaSequence, h, schema, raiseError) && ((xmlSchemaSequence.ValidatedMinOccurs == 0m && xmlSchemaSequence.ValidatedMaxOccurs == 0m && base.ValidatedMinOccurs == 0m && base.ValidatedMaxOccurs == 0m) || base.ValidateRecurse(xmlSchemaSequence, h, schema, raiseError))); } XmlSchemaAll xmlSchemaAll = baseParticle as XmlSchemaAll; if (xmlSchemaAll != null) { XmlSchemaObjectCollection xmlSchemaObjectCollection = new XmlSchemaObjectCollection(); for (int i = 0; i < this.Items.Count; i++) { XmlSchemaElement xmlSchemaElement2 = this.Items[i] as XmlSchemaElement; if (xmlSchemaElement2 == null) { if (raiseError) { base.error(h, "Invalid sequence particle derivation by restriction from all."); } return(false); } foreach (XmlSchemaObject xmlSchemaObject in xmlSchemaAll.Items) { XmlSchemaElement xmlSchemaElement3 = (XmlSchemaElement)xmlSchemaObject; if (xmlSchemaElement3.QualifiedName == xmlSchemaElement2.QualifiedName) { if (xmlSchemaObjectCollection.Contains(xmlSchemaElement3)) { if (raiseError) { base.error(h, "Base element particle is mapped to the derived element particle in a sequence two or more times."); } return(false); } xmlSchemaObjectCollection.Add(xmlSchemaElement3); if (!xmlSchemaElement2.ValidateDerivationByRestriction(xmlSchemaElement3, h, schema, raiseError)) { return(false); } } } } foreach (XmlSchemaObject xmlSchemaObject2 in xmlSchemaAll.Items) { XmlSchemaElement xmlSchemaElement4 = (XmlSchemaElement)xmlSchemaObject2; if (!xmlSchemaObjectCollection.Contains(xmlSchemaElement4) && !xmlSchemaElement4.ValidateIsEmptiable()) { if (raiseError) { base.error(h, "In base -all- particle, mapping-skipped base element which is not emptiable was found."); } return(false); } } return(true); } XmlSchemaAny xmlSchemaAny = baseParticle as XmlSchemaAny; if (xmlSchemaAny != null) { return(base.ValidateNSRecurseCheckCardinality(xmlSchemaAny, h, schema, raiseError)); } XmlSchemaChoice xmlSchemaChoice = baseParticle as XmlSchemaChoice; return(xmlSchemaChoice == null || base.ValidateSeqRecurseMapSumCommon(xmlSchemaChoice, h, schema, false, true, raiseError)); }
internal static XmlSchemaSequence Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaSequence xmlSchemaSequence = new XmlSchemaSequence(); reader.MoveToElement(); if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "sequence") { XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaSequence.Read, name=" + reader.Name, null); reader.Skip(); return(null); } xmlSchemaSequence.LineNumber = reader.LineNumber; xmlSchemaSequence.LinePosition = reader.LinePosition; xmlSchemaSequence.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { xmlSchemaSequence.Id = reader.Value; } else if (reader.Name == "maxOccurs") { try { xmlSchemaSequence.MaxOccursString = reader.Value; } catch (Exception innerException) { XmlSchemaObject.error(h, reader.Value + " is an invalid value for maxOccurs", innerException); } } else if (reader.Name == "minOccurs") { try { xmlSchemaSequence.MinOccursString = reader.Value; } catch (Exception innerException2) { XmlSchemaObject.error(h, reader.Value + " is an invalid value for minOccurs", innerException2); } } 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 sequence", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaSequence); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(xmlSchemaSequence); } int num = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != "sequence") { XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaSequence.Read, name=" + reader.Name, null); } break; } if (num <= 1 && reader.LocalName == "annotation") { num = 2; XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h); if (xmlSchemaAnnotation != null) { xmlSchemaSequence.Annotation = xmlSchemaAnnotation; } } else { if (num <= 2) { if (reader.LocalName == "element") { num = 2; XmlSchemaElement xmlSchemaElement = XmlSchemaElement.Read(reader, h); if (xmlSchemaElement != null) { xmlSchemaSequence.items.Add(xmlSchemaElement); } continue; } if (reader.LocalName == "group") { num = 2; XmlSchemaGroupRef xmlSchemaGroupRef = XmlSchemaGroupRef.Read(reader, h); if (xmlSchemaGroupRef != null) { xmlSchemaSequence.items.Add(xmlSchemaGroupRef); } continue; } if (reader.LocalName == "choice") { num = 2; XmlSchemaChoice xmlSchemaChoice = XmlSchemaChoice.Read(reader, h); if (xmlSchemaChoice != null) { xmlSchemaSequence.items.Add(xmlSchemaChoice); } continue; } if (reader.LocalName == "sequence") { num = 2; XmlSchemaSequence xmlSchemaSequence2 = XmlSchemaSequence.Read(reader, h); if (xmlSchemaSequence2 != null) { xmlSchemaSequence.items.Add(xmlSchemaSequence2); } continue; } if (reader.LocalName == "any") { num = 2; XmlSchemaAny xmlSchemaAny = XmlSchemaAny.Read(reader, h); if (xmlSchemaAny != null) { xmlSchemaSequence.items.Add(xmlSchemaAny); } continue; } } reader.RaiseInvalidElementError(); } } return(xmlSchemaSequence); }
//<choice // id = ID // maxOccurs = (nonNegativeInteger | unbounded) : 1 // minOccurs = nonNegativeInteger : 1 // {any attributes with non-schema namespace . . .}> // Content: (annotation?, (element | group | choice | sequence | any)*) //</choice> internal static XmlSchemaChoice Read(XmlSchemaReader reader, ValidationEventHandler h) { XmlSchemaChoice choice = new XmlSchemaChoice(); reader.MoveToElement(); if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname) { error(h, "Should not happen :1: XmlSchemaChoice.Read, name=" + reader.Name, null); reader.SkipToEnd(); return(null); } choice.LineNumber = reader.LineNumber; choice.LinePosition = reader.LinePosition; choice.SourceUri = reader.BaseURI; while (reader.MoveToNextAttribute()) { if (reader.Name == "id") { choice.Id = reader.Value; } else if (reader.Name == "maxOccurs") { try { choice.MaxOccursString = reader.Value; } catch (Exception e) { error(h, reader.Value + " is an invalid value for maxOccurs", e); } } else if (reader.Name == "minOccurs") { try { choice.MinOccursString = reader.Value; } catch (Exception e) { error(h, reader.Value + " is an invalid value for minOccurs", e); } } else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace) { error(h, reader.Name + " is not a valid attribute for choice", null); } else { XmlSchemaUtil.ReadUnhandledAttribute(reader, choice); } } reader.MoveToElement(); if (reader.IsEmptyElement) { return(choice); } // Content: (annotation?, (element | group | choice | sequence | any)*) int level = 1; while (reader.ReadNextElement()) { if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName != xmlname) { error(h, "Should not happen :2: XmlSchemaChoice.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) { choice.Annotation = annotation; } continue; } if (level <= 2) { if (reader.LocalName == "element") { level = 2; XmlSchemaElement element = XmlSchemaElement.Read(reader, h); if (element != null) { choice.items.Add(element); } continue; } if (reader.LocalName == "group") { level = 2; XmlSchemaGroupRef group = XmlSchemaGroupRef.Read(reader, h); if (group != null) { choice.items.Add(group); } continue; } if (reader.LocalName == "choice") { level = 2; XmlSchemaChoice ch = XmlSchemaChoice.Read(reader, h); if (ch != null) { choice.items.Add(ch); } continue; } if (reader.LocalName == "sequence") { level = 2; XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader, h); if (sequence != null) { choice.items.Add(sequence); } continue; } if (reader.LocalName == "any") { level = 2; XmlSchemaAny any = XmlSchemaAny.Read(reader, h); if (any != null) { choice.items.Add(any); } continue; } } reader.RaiseInvalidElementError(); } return(choice); }
private string GenExportedXSD(string stnName, PdeExports pdeExports) { // initialize schema string schemaNamespace = "http://www.w3.org/2001/XMLSchema"; Schema.XmlSchema expSchema = new Schema.XmlSchema(); // create STN node (root node) Schema.XmlSchemaSequence stnElementSequence = CreateSequenceElement(expSchema, stnName); Schema.XmlSchemaAll field = null; Schema.XmlSchemaAll table = null; foreach (DomainExportItem expDomain in pdeExports.Items) { if (expDomain.Items == null || expDomain.Items.Count == 0) { continue; } foreach (ExportItem expItem in expDomain.Items) { if (!expItem.IsUsed) { continue; } switch (expItem.MapType) { case MapType.SingleCell: #region field if (field == null) { field = CreateElement(stnElementSequence, MarkupConstant.PdeExportField); } // create field informations Schema.XmlSchemaElement fieldElement = new Schema.XmlSchemaElement(); fieldElement.Name = expItem.EncodeTreeNodeName; fieldElement.SchemaTypeName = new System.Xml.XmlQualifiedName(GetXsdDataType(expItem.DataType), schemaNamespace); field.Items.Add(fieldElement); #endregion break; case MapType.Table: #region table if (table == null) { table = CreateElement(stnElementSequence, MarkupConstant.PdeExportTable); } // create table informations Schema.XmlSchemaElement tableElement = new Schema.XmlSchemaElement(); tableElement.MinOccurs = 0; tableElement.MaxOccursString = "unbounded"; tableElement.Name = expItem.EncodeTreeNodeName; table.Items.Add(tableElement); Schema.XmlSchemaComplexType tableElementType = new Schema.XmlSchemaComplexType(); tableElementType.IsMixed = false; Schema.XmlSchemaAll tableElementAll = new Schema.XmlSchemaAll(); tableElementType.Particle = tableElementAll; tableElement.SchemaType = tableElementType; // gen column informations if (expItem.Columns != null && expItem.Columns.Count > 0) { foreach (ColumnExportItem col in expItem.Columns) { if (!col.IsUsed) { continue; } Schema.XmlSchemaElement colElement = new Schema.XmlSchemaElement(); colElement.Name = col.EncodeTreeNodeName; colElement.SchemaTypeName = new System.Xml.XmlQualifiedName(GetXsdDataType(col.DataType), schemaNamespace); tableElementAll.Items.Add(colElement); } } #endregion break; case MapType.Chart: break; default: break; } } } // complie schema expSchema.Compile(new Schema.ValidationEventHandler(ValidationEventHandler)); // write schem to xsd file string xsdFilePath = string.Format("{0}\\{1}.xsd", AssetManager.FileAdapter.TemporaryFolderPath, Guid.NewGuid().ToString()); using (System.IO.FileStream stream = new System.IO.FileStream(xsdFilePath, System.IO.FileMode.Create)) { expSchema.Write(stream); stream.Close(); } return(xsdFilePath); }
/// <include file='doc\SoapSchemaImporter.uex' path='docs/doc[@for="SoapSchemaImporter.ImportMembersMapping3"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember[] members, bool hasWrapperElement, Type baseType, bool baseTypeCanBeIndirect) { XmlSchemaComplexType type = new XmlSchemaComplexType(); XmlSchemaSequence seq = new XmlSchemaSequence(); type.Particle = seq; foreach (SoapSchemaMember member in members) { XmlSchemaElement element = new XmlSchemaElement(); element.Name = member.MemberName; element.SchemaTypeName = member.MemberType; seq.Items.Add(element); } CodeIdentifiers identifiers = new CodeIdentifiers(); identifiers.UseCamelCasing = true; MembersMapping mapping = new MembersMapping(); mapping.TypeDesc = Scope.GetTypeDesc(typeof(object[])); mapping.Members = ImportTypeMembers(type, ns, identifiers); mapping.HasWrapperElement = hasWrapperElement; if (baseType != null) { for (int i = 0; i < mapping.Members.Length; i++) { MemberMapping member = mapping.Members[i]; if (member.Accessor.Mapping is StructMapping) MakeDerived((StructMapping)member.Accessor.Mapping, baseType, baseTypeCanBeIndirect); } } ElementAccessor accessor = new ElementAccessor(); accessor.IsSoap = true; accessor.Name = name; accessor.Namespace = ns; accessor.Mapping = mapping; accessor.IsNullable = false; accessor.Form = XmlSchemaForm.Qualified; return new XmlMembersMapping(Scope, accessor, XmlMappingAccess.Read | XmlMappingAccess.Write); }
void Write54_XmlSchemaSequence(XmlSchemaSequence o) { if ((object)o == null) return; WriteStartElement("sequence"); WriteAttribute(@"id", @"", ((System.String)o.@Id)); WriteAttribute("minOccurs", "", XmlConvert.ToString(o.MinOccurs)); WriteAttribute("maxOccurs", "", o.MaxOccurs == decimal.MaxValue ? "unbounded" : XmlConvert.ToString(o.MaxOccurs)); WriteAttributes((XmlAttribute[])o.@UnhandledAttributes, o); Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.@Annotation); XmlSchemaObjectCollection a = (XmlSchemaObjectCollection)o.@Items; if (a != null) { for (int ia = 0; ia < a.Count; ia++) { XmlSchemaObject ai = (XmlSchemaObject)a[ia]; if (ai is XmlSchemaAny) { Write53_XmlSchemaAny((XmlSchemaAny)ai); } else if (ai is XmlSchemaSequence) { Write54_XmlSchemaSequence((XmlSchemaSequence)ai); } else if (ai is XmlSchemaChoice) { Write52_XmlSchemaChoice((XmlSchemaChoice)ai); } else if (ai is XmlSchemaElement) { Write46_XmlSchemaElement((XmlSchemaElement)ai); } else if (ai is XmlSchemaGroupRef) { Write55_XmlSchemaGroupRef((XmlSchemaGroupRef)ai); } } } WriteEndElement(); }
private bool IsSequenceFromChoice(XmlSchemaSequence derivedSequence, XmlSchemaChoice baseChoice) { decimal minOccurs, maxOccurs; minOccurs = derivedSequence.MinOccurs * derivedSequence.Items.Count; if (derivedSequence.MaxOccurs == decimal.MaxValue) { maxOccurs = decimal.MaxValue; } else { maxOccurs = derivedSequence.MaxOccurs * derivedSequence.Items.Count; } if (!IsValidOccurrenceRangeRestriction(minOccurs, maxOccurs, baseChoice.MinOccurs, baseChoice.MaxOccurs) || derivedSequence.Items.Count > baseChoice.Items.Count) { return false; } for (int i = 0; i < derivedSequence.Items.Count; ++i) { if (GetMappingParticle((XmlSchemaParticle)derivedSequence.Items[i], baseChoice.Items) < 0) return false; } return true; }
private void CalculateSequenceRange(XmlSchemaSequence sequence, out decimal minOccurs, out decimal maxOccurs) { minOccurs = 0M; maxOccurs = 0M; for (int i = 0; i < sequence.Items.Count; i++) { XmlSchemaParticle particle = (XmlSchemaParticle) sequence.Items[i]; minOccurs += particle.MinOccurs; if (particle.MaxOccurs == 79228162514264337593543950335M) { maxOccurs = 79228162514264337593543950335M; } else if (maxOccurs != 79228162514264337593543950335M) { maxOccurs += particle.MaxOccurs; } } minOccurs *= sequence.MinOccurs; if (sequence.MaxOccurs == 79228162514264337593543950335M) { maxOccurs = 79228162514264337593543950335M; } else if (maxOccurs != 79228162514264337593543950335M) { maxOccurs *= sequence.MaxOccurs; } }
private void CompileComplexContentExtension(XmlSchemaComplexType complexType, XmlSchemaComplexContent complexContent, XmlSchemaComplexContentExtension complexExtension) { XmlSchemaComplexType baseType = null; if (complexType.Redefined != null && complexExtension.BaseTypeName == complexType.Redefined.QualifiedName) { baseType = (XmlSchemaComplexType)complexType.Redefined; CompileComplexType(baseType); } else { baseType = GetComplexType(complexExtension.BaseTypeName); if (baseType == null) { SendValidationEvent(Res.Sch_UndefBaseExtension, complexExtension.BaseTypeName.ToString(), complexExtension); return; } } if ((baseType.FinalResolved & XmlSchemaDerivationMethod.Extension) != 0) { SendValidationEvent(Res.Sch_BaseFinalExtension, complexType); } CompileLocalAttributes(baseType, complexType, complexExtension.Attributes, complexExtension.AnyAttribute, XmlSchemaDerivationMethod.Extension); XmlSchemaParticle baseParticle = baseType.ContentTypeParticle; XmlSchemaParticle extendedParticle = CannonicalizeParticle(complexExtension.Particle, true); if (baseParticle != XmlSchemaParticle.Empty) { if (extendedParticle != XmlSchemaParticle.Empty) { XmlSchemaSequence compiledParticle = new XmlSchemaSequence(); compiledParticle.Items.Add(baseParticle); compiledParticle.Items.Add(extendedParticle); complexType.SetContentTypeParticle(CompileContentTypeParticle(compiledParticle)); } else { complexType.SetContentTypeParticle(baseParticle); } } else { complexType.SetContentTypeParticle(extendedParticle); } XmlSchemaContentType contentType = GetSchemaContentType(complexType, complexContent, extendedParticle); if (contentType == XmlSchemaContentType.Empty) { //Derived content type is empty, Get ContentType from base contentType = baseType.ContentType; // In case of a simple base type (content type is TextOnly) the derived type // will be the same as the base type. So set the same content type and then also // set the same data type. if (contentType == XmlSchemaContentType.TextOnly) { complexType.SetDatatype(baseType.Datatype); } } complexType.SetContentType(contentType); if (baseType.ContentType != XmlSchemaContentType.Empty && complexType.ContentType != baseType.ContentType) { //If base is empty, do not check SendValidationEvent(Res.Sch_DifContentType, complexType); return; } complexType.SetBaseSchemaType(baseType); complexType.SetDerivedBy(XmlSchemaDerivationMethod.Extension); }
private bool IsSequenceFromAll(XmlSchemaSequence derivedSequence, XmlSchemaAll baseAll) { if (!this.IsValidOccurrenceRangeRestriction(derivedSequence, baseAll) || (derivedSequence.Items.Count > baseAll.Items.Count)) { return false; } BitSet set = new BitSet(baseAll.Items.Count); for (int i = 0; i < derivedSequence.Items.Count; i++) { int mappingParticle = this.GetMappingParticle((XmlSchemaParticle) derivedSequence.Items[i], baseAll.Items); if (mappingParticle < 0) { return false; } if (set[mappingParticle]) { return false; } set.Set(mappingParticle); } for (int j = 0; j < baseAll.Items.Count; j++) { if (!set[j] && !this.IsParticleEmptiable((XmlSchemaParticle) baseAll.Items[j])) { return false; } } return true; }
internal static XmlSchema BuildSchema (DiscoveryVersion version) { var schema = new XmlSchema () { TargetNamespace = version.Namespace }; var anyAttr = new XmlSchemaAnyAttribute () { Namespace = "##other", ProcessContents = XmlSchemaContentProcessing.Lax }; var probePart = new XmlSchemaSequence (); probePart.Items.Add (new XmlSchemaElement () { RefName = new XmlQualifiedName ("Types", version.Namespace), MinOccurs = 0 }); probePart.Items.Add (new XmlSchemaElement () { RefName = new XmlQualifiedName ("Scopes", version.Namespace), MinOccurs = 0 }); probePart.Items.Add (new XmlSchemaAny () { MinOccurs = 0, MaxOccursString = "unbounded", Namespace = "##other", ProcessContents = XmlSchemaContentProcessing.Lax }); var ct = new XmlSchemaComplexType () { Name = "ProbeType", Particle = probePart, AnyAttribute = anyAttr }; schema.Items.Add (ct); schema.Items.Add (new XmlSchemaSimpleType () { Name = "QNameListType", Content = new XmlSchemaSimpleTypeList () { ItemTypeName = new XmlQualifiedName ("QName", XmlSchema.Namespace) } }); var scr = new XmlSchemaSimpleContentRestriction () { BaseTypeName = new XmlQualifiedName ("UriListType", version.Namespace), AnyAttribute = anyAttr }; scr.Attributes.Add (new XmlSchemaAttribute () { Name = "matchBy", SchemaTypeName = new XmlQualifiedName ("anyURI", XmlSchema.Namespace) }); schema.Items.Add (new XmlSchemaComplexType () { Name = "ScopesType", ContentModel = new XmlSchemaSimpleContent () { Content = scr } }); schema.Items.Add (new XmlSchemaSimpleType () { Name = "UriListType", Content = new XmlSchemaSimpleTypeList () { ItemTypeName = new XmlQualifiedName ("anyURI", XmlSchema.Namespace) } }); schema.Items.Add (new XmlSchemaElement () { Name = "Types", SchemaTypeName = new XmlQualifiedName ("QNameListType", version.Namespace) }); schema.Items.Add (new XmlSchemaElement () { Name = "Scopes", SchemaTypeName = new XmlQualifiedName ("ScopesType", version.Namespace) }); return schema; }
private XmlSchemaParticle CannonicalizeSequence(XmlSchemaSequence sequence, bool root, bool substitution) { if (sequence.Items.Count > 0) { XmlSchemaSequence sequence2 = new XmlSchemaSequence { MinOccurs = sequence.MinOccurs, MaxOccurs = sequence.MaxOccurs }; for (int i = 0; i < sequence.Items.Count; i++) { XmlSchemaParticle item = this.CannonicalizeParticle((XmlSchemaParticle) sequence.Items[i], false, substitution); if (item != XmlSchemaParticle.Empty) { if (((item.MinOccurs == 1M) && (item.MaxOccurs == 1M)) && (item is XmlSchemaSequence)) { XmlSchemaSequence sequence3 = (XmlSchemaSequence) item; for (int j = 0; j < sequence3.Items.Count; j++) { sequence2.Items.Add(sequence3.Items[j]); } } else { sequence2.Items.Add(item); } } } sequence = sequence2; } if (sequence.Items.Count == 0) { return XmlSchemaParticle.Empty; } if ((!root && (sequence.Items.Count == 1)) && ((sequence.MinOccurs == 1M) && (sequence.MaxOccurs == 1M))) { return (XmlSchemaParticle) sequence.Items[0]; } return sequence; }
public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs) { XmlSchemaComplexType type = new XmlSchemaComplexType(); XmlSchemaSequence sequence = new XmlSchemaSequence(); DsNpStat stat = new DsNpStat(); xs.Add(stat.GetSchemaSerializable()); XmlSchemaAny item = new XmlSchemaAny { Namespace = "http://www.w3.org/2001/XMLSchema", MinOccurs = 0M, MaxOccurs = 79228162514264337593543950335M, ProcessContents = XmlSchemaContentProcessing.Lax }; sequence.Items.Add(item); XmlSchemaAny any2 = new XmlSchemaAny { Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1", MinOccurs = 1M, ProcessContents = XmlSchemaContentProcessing.Lax }; sequence.Items.Add(any2); XmlSchemaAttribute attribute = new XmlSchemaAttribute { Name = "namespace", FixedValue = stat.Namespace }; type.Attributes.Add(attribute); XmlSchemaAttribute attribute2 = new XmlSchemaAttribute { Name = "tableTypeName", FixedValue = "V_NpStatDataTable" }; type.Attributes.Add(attribute2); type.Particle = sequence; return type; }
//Exports <xs:type for SMMessage //FIXME: complex type for this can be made static QName ExportTypeMessage () { XmlSchema xs = GetSchema ("http://schemas.microsoft.com/Message"); QName qname = new QName ("MessageBody", xs.TargetNamespace); foreach (XmlSchemaObject o in xs.Items) { XmlSchemaComplexType ct = o as XmlSchemaComplexType; if (ct == null) continue; if (ct.Name == "MessageBody") //Already exported return qname; } XmlSchemaComplexType complex_type = new XmlSchemaComplexType (); complex_type.Name = "MessageBody"; XmlSchemaSequence sequence = new XmlSchemaSequence (); XmlSchemaAny any = new XmlSchemaAny (); any.MinOccurs = 0; any.MaxOccursString = "unbounded"; any.Namespace = "##any"; sequence.Items.Add (any); complex_type.Particle = sequence; xs.Items.Add (complex_type); GeneratedXmlSchemas.Reprocess (xs); return qname; }
/// <summary> /// Returns an XmlSchema for the Suggestion that describes the /// XML representation of the output that is produced by the WriteXml /// method and consumed by the ReadXmlMethod /// </summary> /// <returns>XmlSchema for the Suggestion</returns> public System.Xml.Schema.XmlSchema GetSchema() { // This method must return //<xs:schema // id="types" // elementFormDefault="qualified" // version="Exchange2007" // xmlns:t=".../types" // targetNamespace=".../types" // xmlns:tns=".../types" // xmlns:xs="http://www.w3.org/2001/XMLSchema"> // <xs:complexType name="Suggestion"> // <xs:sequence> // <xs:element minOccurs="1" maxOccurs="1" name="MeetingTime" // type="xs:dateTime" /> // <xs:element minOccurs="1" maxOccurs="1" name="IsWorkTime" // type="xs:boolean" /> // <xs:element minOccurs="1" maxOccurs="1" // name="SuggestionQuality" // type="t:SuggestionQuality" /> // <xs:element minOccurs="0" maxOccurs="1" // name="AttendeeConflictDataArray" // type="t:ArrayOfAttendeeConflictData" /> // </xs:sequence> // </xs:complexType> string xsTypes = "http://schemas.microsoft.com/exchange/services/2006/types"; string xsSchema = "http://www.w3.org/2001/XMLSchema"; XmlSchema schema = new XmlSchema(); schema.Id = "types"; schema.ElementFormDefault = XmlSchemaForm.Qualified; schema.Version = "Exchange2007"; schema.TargetNamespace = xsTypes; // <xs:complexType ... > XmlSchemaComplexType xmlct1 = new XmlSchemaComplexType(); schema.Items.Add(xmlct1); xmlct1.Name = "Suggestion"; // <xs:sequence ... > XmlSchemaSequence xmlsq1 = new XmlSchemaSequence(); xmlct1.Particle = xmlsq1; // <xs:element ... name="MeetingTime" ... /> XmlSchemaElement xmle1 = new XmlSchemaElement(); xmlsq1.Items.Add(xmle1); xmle1.Name = "MeetingTime"; xmle1.MinOccurs = 1; xmle1.MaxOccurs = 1; xmle1.SchemaTypeName = new XmlQualifiedName("dateTime", xsSchema); // <xs:element ... name="IsWorkTime" ... /> XmlSchemaElement xmle2 = new XmlSchemaElement(); xmlsq1.Items.Add(xmle2); xmle2.Name = "IsWorkTime"; xmle2.MinOccurs = 1; xmle2.MaxOccurs = 1; xmle2.SchemaTypeName = new XmlQualifiedName("boolean", xsSchema); // <xs:element ... name="SuggestionQuality" ... /> XmlSchemaElement xmle3 = new XmlSchemaElement(); xmlsq1.Items.Add(xmle3); xmle3.Name = "SuggestionQuality"; xmle3.MinOccurs = 1; xmle3.MaxOccurs = 1; xmle3.SchemaTypeName = new XmlQualifiedName( "SuggestionQuality", xsTypes); // <xs:element ... name="AttendeeConflictDataArray" ... /> XmlSchemaElement xmle4 = new XmlSchemaElement(); xmlsq1.Items.Add(xmle4); xmle4.Name = "AttendeeConflictDataArray"; xmle4.MinOccurs = 0; xmle4.MaxOccurs = 1; xmle4.SchemaTypeName = new XmlQualifiedName( "ArrayOfAttendeeConflictData", xsTypes); return schema; }
public static XmlSchemaComplexType GetTypedDataSetSchema(XmlSchemaSet xs) { DsNpStat stat = new DsNpStat(); XmlSchemaComplexType type = new XmlSchemaComplexType(); XmlSchemaSequence sequence = new XmlSchemaSequence(); xs.Add(stat.GetSchemaSerializable()); XmlSchemaAny item = new XmlSchemaAny { Namespace = stat.Namespace }; sequence.Items.Add(item); type.Particle = sequence; return type; }
private string SchemaSearching(XmlSchema xmlSchema, string inputParamType) { string returnval = null; XmlGenerator xmlGen = new XmlGenerator(); foreach (object item in xmlSchema.Items) { System.Xml.Schema.XmlSchemaElement schemaElement = item as System.Xml.Schema.XmlSchemaElement; if (schemaElement != null) { if (schemaElement.Name == inputParamType) { returnval = xmlGen.GenerateXmlString(schemaElement, xmlSchema); break;//The parameter was found no need to go through rest of elements } } else { //This is a complex Type System.Xml.Schema.XmlSchemaComplexType complexType = item as System.Xml.Schema.XmlSchemaComplexType; if (complexType != null) { if (complexType.Name == inputParamType) { Logger.Text += "Complex Type Name : " + complexType.Name + "\r\n"; System.Xml.Schema.XmlSchemaParticle particle = complexType.Particle; System.Xml.Schema.XmlSchemaSequence sequence = particle as System.Xml.Schema.XmlSchemaSequence; System.Xml.Schema.XmlSchemaAll schemaall = particle as System.Xml.Schema.XmlSchemaAll; if (sequence != null) { foreach (System.Xml.Schema.XmlSchemaElement childElement in sequence.Items) { string parameterName = childElement.Name; string parameterType = childElement.SchemaTypeName.Name; returnval = '<' + complexType.Name + '>' + xmlGen.GenerateXmlString(childElement, xmlSchema) + "</" + complexType.Name + '>'; } } else { if (schemaall != null) { returnval = '<' + complexType.Name + '>' + xmlGen.GenerateXmlString(schemaall, xmlSchema) + "</" + complexType.Name + '>'; } else { System.Xml.Schema.XmlSchemaComplexContent cmplxContent = null; if (cmplxContent != null) { returnval = '<' + complexType.Name + '>' + xmlGen.GenerateXmlString(cmplxContent, xmlSchema) + "</" + complexType.Name + '>';; } } } break; //The parameter was found no need to go through rest of elements } } else { //Nothing to do? //System.Xml.Schema.XmlSchemaSimpleType simpleType = item as System.Xml.Schema.XmlSchemaSimpleType; } } } return(returnval); }
/************************************************************************** The V2.0 (no V1.0 or V1.1) WSDL for Untyped DataTable being returned as a result (no parameters) <s:element name="anyUserSpecifiedMethodName"> <!-- This is where parameters go --> <s:complexType /> </s:element> <s:element name="anyUserSpecifiedMethodName"+"Response"> <s:complexType> <s:sequence> <s:element minOccurs="0" maxOccurs="1" name="anyUserSpecifiedMethodName"+"Result"> <s:complexType> <s:sequence> <s:any minOccurs="0" maxOccurs="unbounded" namespace="http://www.w3.org/2001/XMLSchema" processContents="lax" /> <s:any minOccurs="1" namespace="urn:schemas-microsoft-com:xml-diffgram-v1" processContents="lax" /> </s:sequence> </s:complexType> </s:element> </s:sequence> </s:complexType> </s:element> Typed DataTable is not supported in WSDL (SQLBU 444636) either fails because xsd generates its typed DataTable with an internal parameterless ctor or System.NullReferenceException: Object reference not set to an instance of an object. (if namespace of StronglyTyped DataTable is not set) at System.Data.XmlTreeGen.FindTargetNamespace(DataTable table) or System.InvalidOperationException: Schema Id is missing. The schema returned from WebServiceDataSetServer.Service+StudentsDataTable.GetSchema() must have an Id. at System.Xml.Serialization.SerializableMapping.RetrieveSerializableSchema() *****************************************************************************/ public static XmlSchemaComplexType GetDataTableSchema(XmlSchemaSet schemaSet) { XmlSchemaComplexType type = new XmlSchemaComplexType(); XmlSchemaSequence sequence = new XmlSchemaSequence(); XmlSchemaAny any = new XmlSchemaAny(); any.Namespace = XmlSchema.Namespace; any.MinOccurs = 0; any.MaxOccurs = Decimal.MaxValue; any.ProcessContents = XmlSchemaContentProcessing.Lax; sequence.Items.Add(any); any = new XmlSchemaAny(); any.Namespace = Keywords.DFFNS; any.MinOccurs = 1; // when recognizing WSDL - MinOccurs="0" denotes DataSet, a MinOccurs="1" for DataTable any.ProcessContents = XmlSchemaContentProcessing.Lax; sequence.Items.Add(any); type.Particle = sequence; return type; }
private bool IsElementFromGroupBase(XmlSchemaElement derivedElement, XmlSchemaGroupBase baseGroupBase) { if (baseGroupBase is XmlSchemaSequence) { XmlSchemaSequence virtualSeq = new XmlSchemaSequence(); virtualSeq.MinOccurs = 1; virtualSeq.MaxOccurs = 1; virtualSeq.Items.Add(derivedElement); if (IsGroupBaseFromGroupBase((XmlSchemaGroupBase)virtualSeq, baseGroupBase, true)) { return true; } restrictionErrorMsg = Res.GetString(Res.Sch_ElementFromGroupBase1, derivedElement.QualifiedName.ToString(), derivedElement.LineNumber.ToString(NumberFormatInfo.InvariantInfo), derivedElement.LinePosition.ToString(NumberFormatInfo.InvariantInfo), baseGroupBase.LineNumber.ToString(NumberFormatInfo.InvariantInfo), baseGroupBase.LinePosition.ToString(NumberFormatInfo.InvariantInfo)); } else if (baseGroupBase is XmlSchemaChoice) { XmlSchemaChoice virtualChoice = new XmlSchemaChoice(); virtualChoice.MinOccurs = 1; virtualChoice.MaxOccurs = 1; virtualChoice.Items.Add(derivedElement); if (IsGroupBaseFromGroupBase((XmlSchemaGroupBase)virtualChoice, baseGroupBase, false)) { return true; } restrictionErrorMsg = Res.GetString(Res.Sch_ElementFromGroupBase2, derivedElement.QualifiedName.ToString(), derivedElement.LineNumber.ToString(NumberFormatInfo.InvariantInfo), derivedElement.LinePosition.ToString(NumberFormatInfo.InvariantInfo), baseGroupBase.LineNumber.ToString(NumberFormatInfo.InvariantInfo), baseGroupBase.LinePosition.ToString(NumberFormatInfo.InvariantInfo)); } else if (baseGroupBase is XmlSchemaAll) { XmlSchemaAll virtualAll = new XmlSchemaAll(); virtualAll.MinOccurs = 1; virtualAll.MaxOccurs = 1; virtualAll.Items.Add(derivedElement); if (IsGroupBaseFromGroupBase((XmlSchemaGroupBase)virtualAll, baseGroupBase, true)) { return true; } restrictionErrorMsg = Res.GetString(Res.Sch_ElementFromGroupBase3, derivedElement.QualifiedName.ToString(), derivedElement.LineNumber.ToString(NumberFormatInfo.InvariantInfo), derivedElement.LinePosition.ToString(NumberFormatInfo.InvariantInfo), baseGroupBase.LineNumber.ToString(NumberFormatInfo.InvariantInfo), baseGroupBase.LinePosition.ToString(NumberFormatInfo.InvariantInfo)); } return false; }
/// <summary> /// Gets the list schema. /// </summary> /// <param name="t">The t.</param> /// <returns>schema info</returns> public static SchemaInfo GetListSchema(this Type t) { var schemaInfo = new SchemaInfo(); var classType = new XmlSchemaComplexType { Name = "ArrayOf" + t.Name }; var sequence = new XmlSchemaSequence(); schemaInfo.Schema.Items.Add(classType); classType.Particle = sequence; sequence.Items.Add(new XmlSchemaElement { Name = t.Name, MinOccurs = 0, MaxOccursString = "unbounded", SchemaTypeName = new XmlQualifiedName(t.Name) }); return schemaInfo; }
private bool IsSequenceFromAll(XmlSchemaSequence derivedSequence, XmlSchemaAll baseAll) { if (!IsValidOccurrenceRangeRestriction(derivedSequence, baseAll) || derivedSequence.Items.Count > baseAll.Items.Count) { return false; } BitSet map = new BitSet(baseAll.Items.Count); for (int j = 0; j < derivedSequence.Items.Count; ++j) { int i = GetMappingParticle((XmlSchemaParticle)derivedSequence.Items[j], baseAll.Items); if (i >= 0) { if (map[i]) { return false; } else { map.Set(i); } } else { return false; } } for (int i = 0; i < baseAll.Items.Count; i++) { if (!map[i] && !IsParticleEmptiable((XmlSchemaParticle)baseAll.Items[i])) { return false; } } return true; }