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;
}
protected override void Visit(XmlSchemaAny particle)
{
if (particle.MaxOccurs == 0)
return;
PushNode(ChildType.Any, particle.Parent, particle);
foreach (XmlSchemaElement extensionElement in _schemaSetManager.GetExtensionElements(particle))
AddLeaf(ChildType.ElementExtension, particle, extensionElement);
PopNode();
}
public virtual string ImportAnyElement (
XmlSchemaAny any,
bool mixed,
XmlSchemas schemas,
XmlSchemaImporter importer,
CodeCompileUnit compileUnit,
CodeNamespace mainNamespace,
CodeGenerationOptions options,
CodeDomProvider codeProvider
)
{
return null;
}
public static System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(System.Xml.Schema.XmlSchemaSet xs)
{
Appointments ds = new Appointments();
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);
}
private static void AddDefaultTypedDatasetType(XmlSchemaSet schemas, XmlSchema datasetSchema, string localName, string ns)
{
XmlSchemaComplexType item = new XmlSchemaComplexType {
Name = localName,
Particle = new XmlSchemaSequence()
};
XmlSchemaAny any = new XmlSchemaAny {
Namespace = (datasetSchema.TargetNamespace == null) ? string.Empty : datasetSchema.TargetNamespace
};
((XmlSchemaSequence) item.Particle).Items.Add(any);
schemas.Add(datasetSchema);
XmlSchema schema = SchemaHelper.GetSchema(ns, schemas);
schema.Items.Add(item);
schemas.Reprocess(datasetSchema);
schemas.Reprocess(schema);
}
private static void AddDefaultDatasetType(XmlSchemaSet schemas, string localName, string ns)
{
XmlSchemaComplexType item = new XmlSchemaComplexType {
Name = localName,
Particle = new XmlSchemaSequence()
};
XmlSchemaElement element = new XmlSchemaElement {
RefName = new XmlQualifiedName("schema", "http://www.w3.org/2001/XMLSchema")
};
((XmlSchemaSequence) item.Particle).Items.Add(element);
XmlSchemaAny any = new XmlSchemaAny();
((XmlSchemaSequence) item.Particle).Items.Add(any);
XmlSchema schema = SchemaHelper.GetSchema(ns, schemas);
schema.Items.Add(item);
schemas.Reprocess(schema);
}
internal void AddAny(XmlSchemaAny any)
{
ContentNode n = new AnyNode(any);
if (stack.Count > 0)
{
InternalNode inNode = (InternalNode)stack.Pop();
if (inNode != null)
{
inNode.RightNode = n;
n.ParentNode = inNode;
n = inNode;
}
}
stack.Push(n);
isPartial = true;
abnormalContent = true;
}
internal override XmlSchemaParticle GetOptimizedParticle(bool isTop)
{
if (this.OptimizedParticle != null)
{
return(this.OptimizedParticle);
}
XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
this.CopyInfo(xmlSchemaAny);
xmlSchemaAny.CompileOccurence(null, null);
xmlSchemaAny.wildcard = this.wildcard;
this.OptimizedParticle = xmlSchemaAny;
xmlSchemaAny.Namespace = this.Namespace;
xmlSchemaAny.ProcessContents = this.ProcessContents;
xmlSchemaAny.Annotation = base.Annotation;
xmlSchemaAny.UnhandledAttributes = base.UnhandledAttributes;
return(this.OptimizedParticle);
}
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle, ValidationEventHandler h, XmlSchema schema, bool raiseError)
{
XmlSchemaAny xmlSchemaAny = baseParticle as XmlSchemaAny;
XmlSchemaAll xmlSchemaAll = baseParticle as XmlSchemaAll;
if (xmlSchemaAny != null)
{
return(base.ValidateNSRecurseCheckCardinality(xmlSchemaAny, h, schema, raiseError));
}
if (xmlSchemaAll != null)
{
return(this.ValidateOccurenceRangeOK(xmlSchemaAll, h, schema, raiseError) && base.ValidateRecurse(xmlSchemaAll, h, schema, raiseError));
}
if (raiseError)
{
base.error(h, "Invalid -all- particle derivation was found.");
}
return(false);
}
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 SchemaElementDecl FastGetElementDecl(object particle)
{
SchemaElementDecl elementDecl = null;
if (particle != null)
{
XmlSchemaElement element = particle as XmlSchemaElement;
if (element != null)
{
elementDecl = element.ElementDecl;
}
else
{
XmlSchemaAny any = (XmlSchemaAny)particle;
processContents = any.ProcessContentsCorrect;
}
}
return(elementDecl);
}
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle, ValidationEventHandler h, XmlSchema schema, bool raiseError)
{
XmlSchemaAny xmlSchemaAny = baseParticle as XmlSchemaAny;
if (xmlSchemaAny != null)
{
return(base.ValidateNSRecurseCheckCardinality(xmlSchemaAny, h, schema, raiseError));
}
XmlSchemaChoice xmlSchemaChoice = baseParticle as XmlSchemaChoice;
if (xmlSchemaChoice != null)
{
return(this.ValidateOccurenceRangeOK(xmlSchemaChoice, h, schema, raiseError) && ((xmlSchemaChoice.ValidatedMinOccurs == 0m && xmlSchemaChoice.ValidatedMaxOccurs == 0m && base.ValidatedMinOccurs == 0m && base.ValidatedMaxOccurs == 0m) || base.ValidateSeqRecurseMapSumCommon(xmlSchemaChoice, h, schema, true, false, raiseError)));
}
if (raiseError)
{
base.error(h, "Invalid choice derivation by restriction was found.");
}
return(false);
}
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle,
ValidationEventHandler h, XmlSchema schema, bool raiseError)
{
XmlSchemaAny baseAny = baseParticle as XmlSchemaAny;
if (baseAny == null)
{
if (raiseError)
{
error(h, "Invalid particle derivation by restriction was found.");
}
return(false);
}
// 3.9.6 Particle Derivation OK (Any:Any - NSSubset)
if (!ValidateOccurenceRangeOK(baseParticle, h, schema, raiseError))
{
return(false);
}
return(wildcard.ValidateWildcardSubset(baseAny.wildcard, h, schema, raiseError));
}
internal override bool ParticleEquals(XmlSchemaParticle other)
{
XmlSchemaAny xmlSchemaAny = other as XmlSchemaAny;
if (xmlSchemaAny == null)
{
return(false);
}
if (this.HasValueAny != xmlSchemaAny.HasValueAny || this.HasValueLocal != xmlSchemaAny.HasValueLocal || this.HasValueOther != xmlSchemaAny.HasValueOther || this.HasValueTargetNamespace != xmlSchemaAny.HasValueTargetNamespace || this.ResolvedProcessContents != xmlSchemaAny.ResolvedProcessContents || base.ValidatedMaxOccurs != xmlSchemaAny.ValidatedMaxOccurs || base.ValidatedMinOccurs != xmlSchemaAny.ValidatedMinOccurs || this.ResolvedNamespaces.Count != xmlSchemaAny.ResolvedNamespaces.Count)
{
return(false);
}
for (int i = 0; i < this.ResolvedNamespaces.Count; i++)
{
if (this.ResolvedNamespaces[i] != xmlSchemaAny.ResolvedNamespaces[i])
{
return(false);
}
}
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;
}
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle,
ValidationEventHandler h, XmlSchema schema, bool raiseError)
{
XmlSchemaAny any = baseParticle as XmlSchemaAny;
if (any != null)
{
// NSRecurseCheckCardinality
return(ValidateNSRecurseCheckCardinality(any, h, schema, raiseError));
}
XmlSchemaChoice choice = baseParticle as XmlSchemaChoice;
if (choice != null)
{
// RecurseLax
if (!ValidateOccurenceRangeOK(choice, h, schema, raiseError))
{
return(false);
}
// If it is totally optional, then ignore their contents.
if (choice.ValidatedMinOccurs == 0 && choice.ValidatedMaxOccurs == 0 &&
this.ValidatedMinOccurs == 0 && this.ValidatedMaxOccurs == 0)
{
return(true);
}
// return ValidateRecurseLax (choice, h, schema, raiseError);
return(this.ValidateSeqRecurseMapSumCommon(choice, h, schema, true, false, raiseError));
}
if (raiseError)
{
error(h, "Invalid choice derivation by restriction was found.");
}
return(false);
}
private bool IsAnyFromAny(XmlSchemaAny derivedAny, XmlSchemaAny baseAny)
{
return (this.IsValidOccurrenceRangeRestriction(derivedAny, baseAny) && NamespaceList.IsSubset(derivedAny.NamespaceList, baseAny.NamespaceList));
}
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;
}
}
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 bool IsAnyFromAny(XmlSchemaAny derivedAny, XmlSchemaAny baseAny) {
if (!IsValidOccurrenceRangeRestriction(derivedAny, baseAny)) {
restrictionErrorMsg = Res.GetString(Res.Sch_AnyFromAnyRule1);
return false;
}
if (!NamespaceList.IsSubset(derivedAny.NamespaceList, baseAny.NamespaceList)) {
restrictionErrorMsg = Res.GetString(Res.Sch_AnyFromAnyRule2);
return false;
}
if ((int)derivedAny.ProcessContentsCorrect < (int)baseAny.ProcessContentsCorrect) {
restrictionErrorMsg = Res.GetString(Res.Sch_AnyFromAnyRule3);
return false;
}
return true;
}
static XmlSchemaComplexType CreateAnyType()
{
XmlSchemaComplexType anyType = new XmlSchemaComplexType();
anyType.IsMixed = true;
anyType.Particle = new XmlSchemaSequence();
XmlSchemaAny any = new XmlSchemaAny();
any.MinOccurs = 0;
any.MaxOccurs = Decimal.MaxValue;
any.ProcessContents = XmlSchemaContentProcessing.Lax;
((XmlSchemaSequence)anyType.Particle).Items.Add(any);
anyType.AnyAttribute = new XmlSchemaAnyAttribute();
return anyType;
}
private XmlSchemaType ExportSpecialMapping(SpecialMapping mapping, string ns, bool isAny, XmlSchemaElement element)
{
switch (mapping.TypeDesc.Kind)
{
case TypeKind.Node:
{
XmlSchemaComplexType type = new XmlSchemaComplexType {
IsMixed = mapping.TypeDesc.IsMixed
};
XmlSchemaSequence sequence = new XmlSchemaSequence();
XmlSchemaAny item = new XmlSchemaAny();
if (isAny)
{
type.AnyAttribute = new XmlSchemaAnyAttribute();
type.IsMixed = true;
item.MaxOccurs = 79228162514264337593543950335M;
}
sequence.Items.Add(item);
type.Particle = sequence;
if (element != null)
{
element.SchemaType = type;
}
return type;
}
case TypeKind.Serializable:
{
SerializableMapping mapping2 = (SerializableMapping) mapping;
if (!mapping2.IsAny)
{
if ((mapping2.XsiType != null) || (mapping2.XsdType != null))
{
XmlSchemaType xsdType = mapping2.XsdType;
foreach (XmlSchema schema2 in mapping2.Schemas.Schemas())
{
if (schema2.TargetNamespace != "http://www.w3.org/2001/XMLSchema")
{
this.schemas.Add(schema2, true);
this.AddSchemaImport(schema2.TargetNamespace, ns);
if (!mapping2.XsiType.IsEmpty && (mapping2.XsiType.Namespace == schema2.TargetNamespace))
{
xsdType = (XmlSchemaType) schema2.SchemaTypes[mapping2.XsiType];
}
}
}
if (element != null)
{
element.SchemaTypeName = mapping2.XsiType;
if (element.SchemaTypeName.IsEmpty)
{
element.SchemaType = xsdType;
}
}
mapping2.CheckDuplicateElement(element, ns);
return xsdType;
}
if (mapping2.Schema != null)
{
XmlSchemaComplexType type4 = new XmlSchemaComplexType();
XmlSchemaAny any3 = new XmlSchemaAny();
XmlSchemaSequence sequence3 = new XmlSchemaSequence();
sequence3.Items.Add(any3);
type4.Particle = sequence3;
string targetNamespace = mapping2.Schema.TargetNamespace;
any3.Namespace = (targetNamespace == null) ? "" : targetNamespace;
XmlSchema schema3 = this.schemas[targetNamespace];
if (schema3 == null)
{
this.schemas.Add(mapping2.Schema);
}
else if (schema3 != mapping2.Schema)
{
throw new InvalidOperationException(Res.GetString("XmlDuplicateNamespace", new object[] { targetNamespace }));
}
if (element != null)
{
element.SchemaType = type4;
}
mapping2.CheckDuplicateElement(element, ns);
return type4;
}
XmlSchemaComplexType type5 = new XmlSchemaComplexType();
XmlSchemaElement element2 = new XmlSchemaElement {
RefName = new XmlQualifiedName("schema", "http://www.w3.org/2001/XMLSchema")
};
XmlSchemaSequence sequence4 = new XmlSchemaSequence();
sequence4.Items.Add(element2);
sequence4.Items.Add(new XmlSchemaAny());
type5.Particle = sequence4;
this.AddSchemaImport("http://www.w3.org/2001/XMLSchema", ns);
if (element != null)
{
element.SchemaType = type5;
}
return type5;
}
XmlSchemaComplexType type2 = new XmlSchemaComplexType {
IsMixed = mapping.TypeDesc.IsMixed
};
XmlSchemaSequence sequence2 = new XmlSchemaSequence();
XmlSchemaAny any2 = new XmlSchemaAny();
if (isAny)
{
type2.AnyAttribute = new XmlSchemaAnyAttribute();
type2.IsMixed = true;
any2.MaxOccurs = 79228162514264337593543950335M;
}
if (mapping2.NamespaceList.Length > 0)
{
any2.Namespace = mapping2.NamespaceList;
}
any2.ProcessContents = XmlSchemaContentProcessing.Lax;
if (mapping2.Schemas != null)
{
foreach (XmlSchema schema in mapping2.Schemas.Schemas())
{
if (schema.TargetNamespace != "http://www.w3.org/2001/XMLSchema")
{
this.schemas.Add(schema, true);
this.AddSchemaImport(schema.TargetNamespace, ns);
}
}
}
sequence2.Items.Add(any2);
type2.Particle = sequence2;
if (element != null)
{
element.SchemaType = type2;
}
return type2;
}
}
throw new ArgumentException(Res.GetString("XmlInternalError"), "mapping");
}
public string ExportAnyType(XmlMembersMapping members)
{
if (((members.Count != 1) || !members[0].Any) || (members[0].ElementName.Length != 0))
{
return null;
}
XmlMemberMapping mapping = members[0];
string ns = mapping.Namespace;
bool isArrayLike = mapping.Mapping.TypeDesc.IsArrayLike;
bool mixed = (isArrayLike && (mapping.Mapping.TypeDesc.ArrayElementTypeDesc != null)) ? mapping.Mapping.TypeDesc.ArrayElementTypeDesc.IsMixed : mapping.Mapping.TypeDesc.IsMixed;
if (mixed && mapping.Mapping.TypeDesc.IsMixed)
{
isArrayLike = true;
}
string str2 = mixed ? "any" : (isArrayLike ? "anyElements" : "anyElement");
string name = str2;
int num = 0;
XmlSchema schema = this.schemas[ns];
if (schema != null)
{
while (true)
{
XmlSchemaType schemaType = FindSchemaType(name, schema.Items);
if (schemaType == null)
{
break;
}
if (IsAnyType(schemaType, mixed, isArrayLike))
{
return name;
}
num++;
name = str2 + num.ToString(CultureInfo.InvariantCulture);
}
}
XmlSchemaComplexType item = new XmlSchemaComplexType {
Name = name,
IsMixed = mixed
};
XmlSchemaSequence sequence = new XmlSchemaSequence();
XmlSchemaAny any = new XmlSchemaAny {
MinOccurs = 0M
};
if (isArrayLike)
{
any.MaxOccurs = 79228162514264337593543950335M;
}
sequence.Items.Add(any);
item.Particle = sequence;
this.AddSchemaItem(item, ns, null);
return name;
}
// 3.8.6. Attribute Wildcard Intersection
// Only try to examine if their intersection is expressible, and
// returns if the result is empty.
internal bool ExamineAttributeWildcardIntersection(XmlSchemaAny other,
ValidationEventHandler h, XmlSchema schema)
{
return(wildcard.ExamineAttributeWildcardIntersection(other, h, schema));
}
internal static XmlSchemaAny Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAny xmlSchemaAny = new XmlSchemaAny();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "any")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaAny.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
xmlSchemaAny.LineNumber = reader.LineNumber;
xmlSchemaAny.LinePosition = reader.LinePosition;
xmlSchemaAny.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaAny.Id = reader.Value;
}
else if (reader.Name == "maxOccurs")
{
try
{
xmlSchemaAny.MaxOccursString = reader.Value;
}
catch (Exception innerException)
{
XmlSchemaObject.error(h, reader.Value + " is an invalid value for maxOccurs", innerException);
}
}
else if (reader.Name == "minOccurs")
{
try
{
xmlSchemaAny.MinOccursString = reader.Value;
}
catch (Exception innerException2)
{
XmlSchemaObject.error(h, reader.Value + " is an invalid value for minOccurs", innerException2);
}
}
else if (reader.Name == "namespace")
{
xmlSchemaAny.nameSpace = reader.Value;
}
else if (reader.Name == "processContents")
{
Exception ex;
xmlSchemaAny.processing = XmlSchemaUtil.ReadProcessingAttribute(reader, out ex);
if (ex != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for processContents", 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 any", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaAny);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaAny);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "any")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaAny.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaAny.Annotation = xmlSchemaAnnotation;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaAny);
}
internal static XmlSchemaChoice Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaChoice xmlSchemaChoice = new XmlSchemaChoice();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "choice")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaChoice.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
xmlSchemaChoice.LineNumber = reader.LineNumber;
xmlSchemaChoice.LinePosition = reader.LinePosition;
xmlSchemaChoice.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaChoice.Id = reader.Value;
}
else if (reader.Name == "maxOccurs")
{
try
{
xmlSchemaChoice.MaxOccursString = reader.Value;
}
catch (Exception innerException)
{
XmlSchemaObject.error(h, reader.Value + " is an invalid value for maxOccurs", innerException);
}
}
else if (reader.Name == "minOccurs")
{
try
{
xmlSchemaChoice.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 choice", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaChoice);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaChoice);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "choice")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaChoice.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaChoice.Annotation = xmlSchemaAnnotation;
}
}
else
{
if (num <= 2)
{
if (reader.LocalName == "element")
{
num = 2;
XmlSchemaElement xmlSchemaElement = XmlSchemaElement.Read(reader, h);
if (xmlSchemaElement != null)
{
xmlSchemaChoice.items.Add(xmlSchemaElement);
}
continue;
}
if (reader.LocalName == "group")
{
num = 2;
XmlSchemaGroupRef xmlSchemaGroupRef = XmlSchemaGroupRef.Read(reader, h);
if (xmlSchemaGroupRef != null)
{
xmlSchemaChoice.items.Add(xmlSchemaGroupRef);
}
continue;
}
if (reader.LocalName == "choice")
{
num = 2;
XmlSchemaChoice xmlSchemaChoice2 = XmlSchemaChoice.Read(reader, h);
if (xmlSchemaChoice2 != null)
{
xmlSchemaChoice.items.Add(xmlSchemaChoice2);
}
continue;
}
if (reader.LocalName == "sequence")
{
num = 2;
XmlSchemaSequence xmlSchemaSequence = XmlSchemaSequence.Read(reader, h);
if (xmlSchemaSequence != null)
{
xmlSchemaChoice.items.Add(xmlSchemaSequence);
}
continue;
}
if (reader.LocalName == "any")
{
num = 2;
XmlSchemaAny xmlSchemaAny = XmlSchemaAny.Read(reader, h);
if (xmlSchemaAny != null)
{
xmlSchemaChoice.items.Add(xmlSchemaAny);
}
continue;
}
}
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaChoice);
}
//<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);
}
internal override bool ValidateDerivationByRestriction(XmlSchemaParticle baseParticle,
ValidationEventHandler h, XmlSchema schema, bool raiseError)
{
if (this == baseParticle) // quick check
{
return(true);
}
XmlSchemaElement el = baseParticle as XmlSchemaElement;
if (el != null)
{
// Forbidden
if (raiseError)
{
error(h, "Invalid sequence paricle derivation.");
}
return(false);
}
XmlSchemaSequence seq = baseParticle as XmlSchemaSequence;
if (seq != null)
{
// Recurse
if (!ValidateOccurenceRangeOK(seq, h, schema, raiseError))
{
return(false);
}
// If it is totally optional, then ignore their contents.
if (seq.ValidatedMinOccurs == 0 && seq.ValidatedMaxOccurs == 0 &&
this.ValidatedMinOccurs == 0 && this.ValidatedMaxOccurs == 0)
{
return(true);
}
return(ValidateRecurse(seq, h, schema, raiseError));
}
XmlSchemaAll all = baseParticle as XmlSchemaAll;
if (all != null)
{
// RecurseUnordered
XmlSchemaObjectCollection already = new XmlSchemaObjectCollection();
for (int i = 0; i < this.Items.Count; i++)
{
XmlSchemaElement de = this.Items [i] as XmlSchemaElement;
if (de == null)
{
if (raiseError)
{
error(h, "Invalid sequence particle derivation by restriction from all.");
}
return(false);
}
foreach (XmlSchemaElement e in all.Items)
{
if (e.QualifiedName == de.QualifiedName)
{
if (already.Contains(e))
{
if (raiseError)
{
error(h, "Base element particle is mapped to the derived element particle in a sequence two or more times.");
}
return(false);
}
else
{
already.Add(e);
if (!de.ValidateDerivationByRestriction(e, h, schema, raiseError))
{
return(false);
}
}
}
}
}
foreach (XmlSchemaElement e in all.Items)
{
if (!already.Contains(e))
{
if (!e.ValidateIsEmptiable())
{
if (raiseError)
{
error(h, "In base -all- particle, mapping-skipped base element which is not emptiable was found.");
}
return(false);
}
}
}
return(true);
}
XmlSchemaAny any = baseParticle as XmlSchemaAny;
if (any != null)
{
// NSRecurseCheckCardinality
return(ValidateNSRecurseCheckCardinality(any, h, schema, raiseError));
}
XmlSchemaChoice choice = baseParticle as XmlSchemaChoice;
if (choice != null)
{
// MapAndSum
// In fact it is not Recurse, but it looks almost common.
return(ValidateSeqRecurseMapSumCommon(choice, h, schema, false, true, raiseError));
}
return(true);
}
internal override void CheckXsdDeterministic(ArrayList terminalNodes, out BitSet set, out NamespaceList any)
{
set = null;
any = this.any.NamespaceList;
}
public string ExportAnyType(string ns)
{
string name = "any";
int num = 0;
XmlSchema schema = this.schemas[ns];
if (schema != null)
{
while (true)
{
XmlSchemaType schemaType = FindSchemaType(name, schema.Items);
if (schemaType == null)
{
break;
}
if (IsAnyType(schemaType, true, true))
{
return name;
}
num++;
name = "any" + num.ToString(CultureInfo.InvariantCulture);
}
}
XmlSchemaComplexType item = new XmlSchemaComplexType {
Name = name,
IsMixed = true
};
XmlSchemaSequence sequence = new XmlSchemaSequence();
XmlSchemaAny any = new XmlSchemaAny {
MinOccurs = 0M,
MaxOccurs = 79228162514264337593543950335M
};
sequence.Items.Add(any);
item.Particle = sequence;
this.AddSchemaItem(item, ns, null);
return name;
}
private bool IsGroupBaseFromAny(XmlSchemaGroupBase derivedGroupBase, XmlSchemaAny baseAny)
{
decimal num;
decimal num2;
this.CalculateEffectiveTotalRange(derivedGroupBase, out num, out num2);
if (!this.IsValidOccurrenceRangeRestriction(num, num2, baseAny.MinOccurs, baseAny.MaxOccurs))
{
return false;
}
string minOccursString = baseAny.MinOccursString;
baseAny.MinOccurs = 0M;
for (int i = 0; i < derivedGroupBase.Items.Count; i++)
{
if (!this.IsValidRestriction((XmlSchemaParticle) derivedGroupBase.Items[i], baseAny))
{
baseAny.MinOccursString = minOccursString;
return false;
}
}
baseAny.MinOccursString = minOccursString;
return true;
}
private void ExportElementAccessor(XmlSchemaGroupBase group, ElementAccessor accessor, bool repeats, bool valueTypeOptional, string ns)
{
if (accessor.Any && (accessor.Name.Length == 0))
{
XmlSchemaAny item = new XmlSchemaAny {
MinOccurs = 0M,
MaxOccurs = repeats ? 79228162514264337593543950335M : 1M
};
if (((accessor.Namespace != null) && (accessor.Namespace.Length > 0)) && (accessor.Namespace != ns))
{
item.Namespace = accessor.Namespace;
}
group.Items.Add(item);
}
else
{
XmlSchemaElement element = (XmlSchemaElement) this.elements[accessor];
int num = (((repeats || accessor.HasDefault) || (!accessor.IsNullable && !accessor.Mapping.TypeDesc.IsValueType)) || valueTypeOptional) ? 0 : 1;
decimal num2 = (repeats || accessor.IsUnbounded) ? 79228162514264337593543950335M : 1M;
if (element == null)
{
element = new XmlSchemaElement {
IsNillable = accessor.IsNullable,
Name = accessor.Name
};
if (accessor.HasDefault)
{
element.DefaultValue = ExportDefaultValue(accessor.Mapping, accessor.Default);
}
if (accessor.IsTopLevelInSchema)
{
this.elements.Add(accessor, element);
element.Form = accessor.Form;
this.AddSchemaItem(element, accessor.Namespace, ns);
}
else
{
element.MinOccurs = num;
element.MaxOccurs = num2;
XmlSchema schema = this.schemas[ns];
if (schema == null)
{
element.Form = (accessor.Form == XmlSchemaForm.Qualified) ? XmlSchemaForm.None : accessor.Form;
}
else
{
element.Form = (accessor.Form == schema.ElementFormDefault) ? XmlSchemaForm.None : accessor.Form;
}
}
this.ExportElementMapping(element, accessor.Mapping, accessor.Namespace, accessor.Any);
}
if (accessor.IsTopLevelInSchema)
{
XmlSchemaElement element2 = new XmlSchemaElement {
RefName = new XmlQualifiedName(accessor.Name, accessor.Namespace),
MinOccurs = num,
MaxOccurs = num2
};
group.Items.Add(element2);
this.AddSchemaImport(accessor.Namespace, ns);
}
else
{
group.Items.Add(element);
}
}
}
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;
}
static XmlSchemaComplexType CreateAnyElementType()
{
XmlSchemaComplexType anyElementType = new XmlSchemaComplexType();
anyElementType.IsMixed = false;
anyElementType.Particle = new XmlSchemaSequence();
XmlSchemaAny any = new XmlSchemaAny();
any.MinOccurs = 0;
any.ProcessContents = XmlSchemaContentProcessing.Lax;
((XmlSchemaSequence)anyElementType.Particle).Items.Add(any);
return anyElementType;
}
static void AddProbeMatchType(DiscoveryVersion discoveryVersion, XmlSchema schema)
{
// <xs:complexType name="ProbeMatchType">
XmlSchemaComplexType probeMatchType = new XmlSchemaComplexType();
probeMatchType.Name = ProtocolStrings.SchemaNames.ProbeMatchType;
// <xs:sequence>
XmlSchemaSequence probeMatcheSequence = new XmlSchemaSequence();
// <xs:element ref="wsa:EndpointReference" />
XmlSchemaElement eprElement = new XmlSchemaElement();
eprElement.RefName = discoveryVersion.Implementation.QualifiedNames.EprElement;
// <xs:element minOccurs="0" ref="tns:Types" />
XmlSchemaElement typesElement = new XmlSchemaElement();
typesElement.RefName = discoveryVersion.Implementation.QualifiedNames.TypesElement;
typesElement.MinOccurs = 0;
// <xs:element minOccurs="0" ref="tns:Scopes" />
XmlSchemaElement scopesElement = new XmlSchemaElement();
scopesElement.RefName = discoveryVersion.Implementation.QualifiedNames.ScopesElement;
scopesElement.MinOccurs = 0;
// <xs:element minOccurs="0" ref="tns:XAddrs" />
XmlSchemaElement xAddrsElement = new XmlSchemaElement();
xAddrsElement.RefName = discoveryVersion.Implementation.QualifiedNames.XAddrsElement;
xAddrsElement.MinOccurs = 0;
// <xs:element ref="tns:MetadataVersion" /> -- allowing minOccurs=0 because the same type is used for Bye messages
XmlSchemaElement metadataVersionElement = new XmlSchemaElement();
metadataVersionElement.RefName = discoveryVersion.Implementation.QualifiedNames.MetadataVersionElement;
metadataVersionElement.MinOccurs = 0;
// <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other" processContents="lax" />
XmlSchemaAny any = new XmlSchemaAny();
any.Namespace = "##other";
any.ProcessContents = XmlSchemaContentProcessing.Lax;
any.MinOccurs = 0;
any.MaxOccurs = decimal.MaxValue;
// </xs:sequence>
probeMatcheSequence.Items.Add(eprElement);
probeMatcheSequence.Items.Add(typesElement);
probeMatcheSequence.Items.Add(scopesElement);
probeMatcheSequence.Items.Add(xAddrsElement);
probeMatcheSequence.Items.Add(metadataVersionElement);
probeMatcheSequence.Items.Add(any);
// <xs:anyAttribute namespace="##other" processContents="lax" />
XmlSchemaAnyAttribute anyAttribue = new XmlSchemaAnyAttribute();
anyAttribue.Namespace = "##other";
anyAttribue.ProcessContents = XmlSchemaContentProcessing.Lax;
// </xs:complexType>
probeMatchType.Particle = probeMatcheSequence;
probeMatchType.AnyAttribute = anyAttribue;
schema.Items.Add(probeMatchType);
}
private bool IsElementFromAny(XmlSchemaElement derivedElement, XmlSchemaAny baseAny) {
if (!baseAny.Allows(derivedElement.QualifiedName)) {
restrictionErrorMsg = Res.GetString(Res.Sch_ElementFromAnyRule1, derivedElement.QualifiedName.ToString());
return false;
}
if (!IsValidOccurrenceRangeRestriction(derivedElement, baseAny)) {
restrictionErrorMsg = Res.GetString(Res.Sch_ElementFromAnyRule2, derivedElement.QualifiedName.ToString());
return false;
}
return true;
}
static void AddProbeType(DiscoveryVersion discoveryVersion, XmlSchema schema)
{
// <xs:complexType name="ProbeType">
XmlSchemaComplexType probeType = new XmlSchemaComplexType();
probeType.Name = ProtocolStrings.SchemaNames.ProbeType;
// <xs:sequence>
XmlSchemaSequence probeTypeSequence = new XmlSchemaSequence();
// <xs:element ref="tns:Types" minOccurs="0" />
XmlSchemaElement typesElement = new XmlSchemaElement();
typesElement.RefName = discoveryVersion.Implementation.QualifiedNames.TypesElement;
typesElement.MinOccurs = 0;
// <xs:element ref="tns:Scopes" minOccurs="0" />
XmlSchemaElement scopesElement = new XmlSchemaElement();
scopesElement.RefName = discoveryVersion.Implementation.QualifiedNames.ScopesElement;
scopesElement.MinOccurs = 0;
// <xs:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded" />
XmlSchemaAny any = new XmlSchemaAny();
any.Namespace = "##other";
any.ProcessContents = XmlSchemaContentProcessing.Lax;
any.MinOccurs = 0;
any.MaxOccurs = decimal.MaxValue;
// </xs:sequence>
probeTypeSequence.Items.Add(typesElement);
probeTypeSequence.Items.Add(scopesElement);
probeTypeSequence.Items.Add(any);
// <xs:anyAttribute namespace="##other" processContents="lax" />
XmlSchemaAnyAttribute anyAttribue = new XmlSchemaAnyAttribute();
anyAttribue.Namespace = "##other";
anyAttribue.ProcessContents = XmlSchemaContentProcessing.Lax;
// </xs:complexType>
probeType.Particle = probeTypeSequence;
probeType.AnyAttribute = anyAttribue;
schema.Items.Add(probeType);
}
private bool IsGroupBaseFromAny(XmlSchemaGroupBase derivedGroupBase, XmlSchemaAny baseAny) {
decimal minOccurs, maxOccurs;
CalculateEffectiveTotalRange(derivedGroupBase, out minOccurs, out maxOccurs);
if (!IsValidOccurrenceRangeRestriction(minOccurs, maxOccurs, baseAny.MinOccurs, baseAny.MaxOccurs)) {
restrictionErrorMsg = Res.GetString(Res.Sch_GroupBaseFromAny2, derivedGroupBase.LineNumber.ToString(NumberFormatInfo.InvariantInfo), derivedGroupBase.LinePosition.ToString(NumberFormatInfo.InvariantInfo), baseAny.LineNumber.ToString(NumberFormatInfo.InvariantInfo), baseAny.LinePosition.ToString(NumberFormatInfo.InvariantInfo));
return false;
}
// eliminate occurrance range check
string minOccursAny = baseAny.MinOccursString;
baseAny.MinOccurs = decimal.Zero;
for (int i = 0; i < derivedGroupBase.Items.Count; ++i) {
if (!IsValidRestriction((XmlSchemaParticle)derivedGroupBase.Items[i], baseAny)) {
restrictionErrorMsg = Res.GetString(Res.Sch_GroupBaseFromAny1);
baseAny.MinOccursString = minOccursAny;
return false;
}
}
baseAny.MinOccursString = minOccursAny;
return true;
}
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));
}
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;
}
// 3.8.6. Attribute Wildcard Intersection
// Only try to examine if their intersection is expressible, and
// returns true if the result is empty.
public bool ExamineAttributeWildcardIntersection (XmlSchemaAny other,
ValidationEventHandler h, XmlSchema schema)
{
// 1.
if (this.HasValueAny == other.HasValueAny &&
this.HasValueLocal == other.HasValueLocal &&
this.HasValueOther == other.HasValueOther &&
this.HasValueTargetNamespace == other.HasValueTargetNamespace &&
this.ResolvedProcessing == other.ResolvedProcessContents) {
bool notEqual = false;
for (int i = 0; i < this.ResolvedNamespaces.Count; i++) {
if (!other.ResolvedNamespaces.Contains (this.ResolvedNamespaces [i]))
notEqual = true;
}
if (!notEqual)
return false;
}
// 2.
if (this.HasValueAny)
return !other.HasValueAny &&
!other.HasValueLocal &&
!other.HasValueOther &&
!other.HasValueTargetNamespace &&
other.ResolvedNamespaces.Count == 0;
if (other.HasValueAny)
return !this.HasValueAny &&
!this.HasValueLocal &&
!this.HasValueOther &&
!this.HasValueTargetNamespace &&
this.ResolvedNamespaces.Count == 0;
// 5.
if (this.HasValueOther && other.HasValueOther && this.TargetNamespace != other.TargetNamespace) {
// xsobj.error (h, "The Wildcard intersection is not expressible.");
return false;
}
// 3.
if (this.HasValueOther) {
if (other.HasValueLocal && this.TargetNamespace != String.Empty)
return false;
if (other.HasValueTargetNamespace && this.TargetNamespace != other.TargetNamespace)
return false;
return other.ValidateWildcardAllowsNamespaceName (this.TargetNamespace, h, schema, false);
}
if (other.HasValueOther) {
if (this.HasValueLocal && other.TargetNamespace != String.Empty)
return false;
if (this.HasValueTargetNamespace && other.TargetNamespace != this.TargetNamespace)
return false;
return this.ValidateWildcardAllowsNamespaceName (other.TargetNamespace, h, schema, false);
}
// 4.
if (this.ResolvedNamespaces.Count > 0) {
for (int i = 0; i < this.ResolvedNamespaces.Count; i++)
if (other.ResolvedNamespaces.Contains (this.ResolvedNamespaces [i]))
return false;
}
return true;
}
void Write53_XmlSchemaAny(XmlSchemaAny o) {
if ((object)o == null) return;
WriteStartElement("any");
WriteAttribute(@"id", @"", o.@Id);
WriteAttribute("minOccurs", "", XmlConvert.ToString(o.MinOccurs));
WriteAttribute(@"maxOccurs", @"", o.MaxOccurs == decimal.MaxValue ? "unbounded" : XmlConvert.ToString(o.MaxOccurs));
WriteAttribute(@"namespace", @"", ToString(o.NamespaceList));
XmlSchemaContentProcessing process = o.@ProcessContents == XmlSchemaContentProcessing.@None ? XmlSchemaContentProcessing.Strict : o.@ProcessContents;
WriteAttribute(@"processContents", @"", Write34_XmlSchemaContentProcessing(process));
WriteAttributes((XmlAttribute[])o.@UnhandledAttributes, o);
Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.@Annotation);
WriteEndElement();
}
private ClrWildCardPropertyInfo BuildAnyProperty(XmlSchemaAny any, bool addToTypeDef)
{
ClrWildCardPropertyInfo property = new ClrWildCardPropertyInfo(any.Namespace, any.GetTargetNS(), addToTypeDef, GetOccurence(any));
property.PropertyName = Constants.Any;
return property;
}
private bool IsElementFromAny(XmlSchemaElement derivedElement, XmlSchemaAny baseAny)
{
return (baseAny.Allows(derivedElement.QualifiedName) && this.IsValidOccurrenceRangeRestriction(derivedElement, baseAny));
}
internal AnyNode(XmlSchemaAny any)
{
this.any = any;
contentType = Type.Any;
}
//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;
}
//<any
// id = ID
// maxOccurs = (nonNegativeInteger | unbounded) : 1
// minOccurs = nonNegativeInteger : 1
// namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local)) ) : ##any
// processContents = (lax | skip | strict) : strict
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</any>
internal static XmlSchemaAny Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAny any = new XmlSchemaAny();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaAny.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
any.LineNumber = reader.LineNumber;
any.LinePosition = reader.LinePosition;
any.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
any.Id = reader.Value;
}
else if (reader.Name == "maxOccurs")
{
try
{
any.MaxOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for maxOccurs", e);
}
}
else if (reader.Name == "minOccurs")
{
try
{
any.MinOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for minOccurs", e);
}
}
else if (reader.Name == "namespace")
{
any.nameSpace = reader.Value;
}
else if (reader.Name == "processContents")
{
Exception innerex;
any.processing = XmlSchemaUtil.ReadProcessingAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for processContents", innerex);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for any", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, any);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(any);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaAny.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)
{
any.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(any);
}
/**************************************************************************
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;
}
static void AddResolveType(DiscoveryVersion discoveryVersion, XmlSchema schema)
{
//<xs:complexType name="ResolveType" >
XmlSchemaComplexType resolveType = new XmlSchemaComplexType();
resolveType.Name = ProtocolStrings.SchemaNames.ResolveType;
// <xs:sequence>
XmlSchemaSequence resolveSequence = new XmlSchemaSequence();
// <xs:element ref="wsa:EndpointReference" />
XmlSchemaElement eprElement = new XmlSchemaElement();
eprElement.RefName = discoveryVersion.Implementation.QualifiedNames.EprElement;
// <xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other" processContents="lax" />
XmlSchemaAny any = new XmlSchemaAny();
any.Namespace = "##other";
any.ProcessContents = XmlSchemaContentProcessing.Lax;
any.MinOccurs = 0;
any.MaxOccurs = decimal.MaxValue;
resolveSequence.Items.Add(eprElement);
resolveSequence.Items.Add(any);
// <xs:anyAttribute namespace="##other" processContents="lax" />
XmlSchemaAnyAttribute anyAttribue = new XmlSchemaAnyAttribute();
anyAttribue.Namespace = "##other";
anyAttribue.ProcessContents = XmlSchemaContentProcessing.Lax;
// </xs:complexType>
resolveType.Particle = resolveSequence;
resolveType.AnyAttribute = anyAttribue;
schema.Items.Add(resolveType);
}
