public XmlSchemaRedefine()
{
attributeGroups = new XmlSchemaObjectTable();
groups = new XmlSchemaObjectTable();
items = new XmlSchemaObjectCollection(this);
schemaTypes = new XmlSchemaObjectTable();
}
void Write5_XmlSchemaAnnotation(XmlSchemaAnnotation o)
{
if ((object)o == null)
{
return;
}
WriteStartElement("annotation");
WriteAttribute(@"id", @"", ((System.String)o.@Id));
WriteAttributes((XmlAttribute[])o.@UnhandledAttributes, o);
System.Xml.Schema.XmlSchemaObjectCollection a = (System.Xml.Schema.XmlSchemaObjectCollection)o.@Items;
if (a != null)
{
for (int ia = 0; ia < a.Count; ia++)
{
XmlSchemaObject ai = (XmlSchemaObject)a[ia];
if (ai is XmlSchemaAppInfo)
{
Write7_XmlSchemaAppInfo((XmlSchemaAppInfo)ai);
}
else if (ai is XmlSchemaDocumentation)
{
Write6_XmlSchemaDocumentation((XmlSchemaDocumentation)ai);
}
}
}
WriteEndElement();
}
void AddAttributes(ClassInfo classInfo, XmlSchemaObjectCollection attributes)
{
foreach (XmlSchemaAttribute attribute in attributes)
{
classInfo.Attributes.Add(PropertyFromAttribute(classInfo, attribute));
}
}
public static void WriteConstraintsSection(this MamlWriter writer, Context context, XmlSchemaObjectCollection constraints)
{
if (!context.Configuration.DocumentConstraints)
return;
writer.StartSection("Constraints", "constraints");
writer.WriteConstraintTable(context, constraints);
writer.EndSection();
}
public XmlSchemaElement()
{
block = XmlSchemaDerivationMethod.None;
final = XmlSchemaDerivationMethod.None;
constraints = new XmlSchemaObjectCollection();
refName = XmlQualifiedName.Empty;
schemaTypeName = XmlQualifiedName.Empty;
substitutionGroup = XmlQualifiedName.Empty;
InitPostCompileInformations ();
}
void ReadDocumentationFromAnnotation(XmlSchemaObjectCollection annotationItems)
{
foreach (XmlSchemaObject schemaObject in annotationItems) {
XmlSchemaDocumentation schemaDocumentation = schemaObject as XmlSchemaDocumentation;
if (schemaDocumentation != null) {
ReadSchemaDocumentationFromMarkup(schemaDocumentation.Markup);
}
}
RemoveWhitespaceFromDocumentation();
}
private static void EnumerateDocumentedItems(XmlSchemaObjectCollection schemaItems, Dictionary<string, string> documentedItems)
{
foreach (XmlSchemaObject schemaObj in schemaItems)
{
string documentation = GetDocumenation(schemaObj);
if (documentation != null)
{
string uniqueName = GetUniqueName(schemaObj);
documentedItems[uniqueName] = documentation;
}
EnumerateDocumentedItems(schemaObj, documentedItems);
}
}
public XmlSchema ()
{
attributeFormDefault= XmlSchemaForm.None;
blockDefault = XmlSchemaDerivationMethod.None;
elementFormDefault = XmlSchemaForm.None;
finalDefault = XmlSchemaDerivationMethod.None;
includes = new XmlSchemaObjectCollection();
isCompiled = false;
items = new XmlSchemaObjectCollection();
attributeGroups = new XmlSchemaObjectTable();
attributes = new XmlSchemaObjectTable();
elements = new XmlSchemaObjectTable();
groups = new XmlSchemaObjectTable();
notations = new XmlSchemaObjectTable();
schemaTypes = new XmlSchemaObjectTable();
}
// It makes complexType not to have Simple content model.
private void ToComplexContentType(ComplexType type)
{
SimpleModel sm = type.ContentModel as SimpleModel;
if (sm == null)
{
return;
}
SOMList atts = GetAttributes(type);
foreach (SOMObject o in atts)
{
type.Attributes.Add(o);
}
// FIXME: need to copy AnyAttribute.
// (though not considered right now)
type.ContentModel = null;
type.IsMixed = true;
}
private static string Process(XmlSchemaObjectCollection collection)
{
StringBuilder result = new StringBuilder();
foreach (XmlSchemaObject schemaObject in collection)
{
if (schemaObject is XmlSchemaDocumentation)
result.Append(ProcessDocumentation((XmlSchemaDocumentation)schemaObject));
else if (schemaObject is XmlSchemaElement)
result.Append(ProcessElement((XmlSchemaElement)schemaObject));
else if (schemaObject is XmlSchemaAnnotation)
result.Append(ProcessAnnotation((XmlSchemaAnnotation)schemaObject));
else if (schemaObject is XmlSchemaAttribute)
result.Append(ProcessAttribute((XmlSchemaAttribute)schemaObject));
else if (schemaObject is XmlSchemaSimpleType)
result.Append(ProcessSchemaSimpleType((XmlSchemaSimpleType)schemaObject));
else
result.AppendLine(string.Format("Unsupported type: {0}", schemaObject));
}
return result.ToString();
}
private static void WriteConstraintFieldList(this MamlWriter writer, XmlSchemaObjectCollection fields)
{
if (fields.Count == 1)
{
var field = (XmlSchemaXPath)fields[0];
writer.WriteString(field.XPath);
return;
}
writer.StartList(ListClass.Ordered);
foreach (XmlSchemaXPath field in fields)
{
writer.StartListItem();
writer.StartParagraph();
writer.WriteString(field.XPath);
writer.EndParagraph();
writer.EndListItem();
}
writer.EndList();
}
public static void WriteConstraintTable(this MamlWriter writer, Context context, XmlSchemaObjectCollection constraints)
{
if (constraints.Count == 0)
return;
writer.StartTable();
writer.StartTableHeader();
writer.StartTableRow();
writer.StartTableRowEntry();
writer.EndTableRowEntry();
writer.StartTableRowEntry();
writer.WriteString("Type");
writer.EndTableRowEntry();
writer.StartTableRowEntry();
writer.WriteString("Description");
writer.EndTableRowEntry();
writer.StartTableRowEntry();
writer.WriteString("Selector");
writer.EndTableRowEntry();
writer.StartTableRowEntry();
writer.WriteString("Fields");
writer.EndTableRowEntry();
writer.EndTableRow();
writer.EndTableHeader();
var rowBuilder = new ConstraintRowWriter(writer, context);
rowBuilder.Traverse(constraints);
writer.EndTable();
}
private Hashtable CollectAttrTable(SOMList attList)
{
// get attribute definition table.
Hashtable table = new Hashtable();
foreach (XmlSchemaObject obj in attList)
{
Attr attr = obj as Attr;
if (attr == null)
{
throw Error(obj, String.Format("Attribute inference only supports direct attribute definition. {0} is not supported.", obj.GetType()));
}
if (attr.RefName != QName.Empty)
{
table.Add(attr.RefName, attr);
}
else
{
table.Add(new QName(attr.Name, ""),
attr);
}
}
return(table);
}
private void Add(XmlSchemaObjectCollection collToAdd) {
this.InnerList.InsertRange(0, collToAdd);
}
internal void SetAttributes(XmlSchemaObjectCollection newAttributes) {
attributes = newAttributes;
}
public XmlSchemaComplexContentRestriction()
{
baseTypeName = XmlQualifiedName.Empty;
attributes = new XmlSchemaObjectCollection();
}
public static int ValidateAttributesResolved(XmlSchemaObjectTable attributesResolved, ValidationEventHandler h, XmlSchema schema, XmlSchemaObjectCollection attributes, XmlSchemaAnyAttribute anyAttribute, ref XmlSchemaAnyAttribute anyAttributeUse, XmlSchemaAttributeGroup redefined, bool skipEquivalent)
{
int num = 0;
if (anyAttribute != null && anyAttributeUse == null)
{
anyAttributeUse = anyAttribute;
}
ArrayList arrayList = new ArrayList();
foreach (XmlSchemaObject xmlSchemaObject in attributes)
{
XmlSchemaAttributeGroupRef xmlSchemaAttributeGroupRef = xmlSchemaObject as XmlSchemaAttributeGroupRef;
if (xmlSchemaAttributeGroupRef != null)
{
XmlSchemaAttributeGroup xmlSchemaAttributeGroup = null;
if (redefined != null && xmlSchemaAttributeGroupRef.RefName == redefined.QualifiedName)
{
xmlSchemaAttributeGroup = redefined;
}
else
{
xmlSchemaAttributeGroup = schema.FindAttributeGroup(xmlSchemaAttributeGroupRef.RefName);
}
if (xmlSchemaAttributeGroup == null)
{
if (!schema.missedSubComponents)
{
xmlSchemaAttributeGroupRef.error(h, "Referenced attribute group " + xmlSchemaAttributeGroupRef.RefName + " was not found in the corresponding schema.");
}
}
else if (xmlSchemaAttributeGroup.AttributeGroupRecursionCheck)
{
xmlSchemaAttributeGroup.error(h, "Attribute group recursion was found: " + xmlSchemaAttributeGroupRef.RefName);
}
else
{
try
{
xmlSchemaAttributeGroup.AttributeGroupRecursionCheck = true;
num += xmlSchemaAttributeGroup.Validate(h, schema);
}
finally
{
xmlSchemaAttributeGroup.AttributeGroupRecursionCheck = false;
}
if (xmlSchemaAttributeGroup.AnyAttributeUse != null && anyAttribute == null)
{
anyAttributeUse = xmlSchemaAttributeGroup.AnyAttributeUse;
}
foreach (object obj in xmlSchemaAttributeGroup.AttributeUses)
{
XmlSchemaAttribute xmlSchemaAttribute = (XmlSchemaAttribute)((DictionaryEntry)obj).Value;
if (!XmlSchemaUtil.StrictMsCompliant || xmlSchemaAttribute.Use != XmlSchemaUse.Prohibited)
{
if (xmlSchemaAttribute.RefName != null && xmlSchemaAttribute.RefName != XmlQualifiedName.Empty && (!skipEquivalent || !XmlSchemaUtil.AreAttributesEqual(xmlSchemaAttribute, attributesResolved[xmlSchemaAttribute.RefName] as XmlSchemaAttribute)))
{
XmlSchemaUtil.AddToTable(attributesResolved, xmlSchemaAttribute, xmlSchemaAttribute.RefName, h);
}
else if (!skipEquivalent || !XmlSchemaUtil.AreAttributesEqual(xmlSchemaAttribute, attributesResolved[xmlSchemaAttribute.QualifiedName] as XmlSchemaAttribute))
{
XmlSchemaUtil.AddToTable(attributesResolved, xmlSchemaAttribute, xmlSchemaAttribute.QualifiedName, h);
}
}
}
}
}
else
{
XmlSchemaAttribute xmlSchemaAttribute2 = xmlSchemaObject as XmlSchemaAttribute;
if (xmlSchemaAttribute2 != null)
{
num += xmlSchemaAttribute2.Validate(h, schema);
if (arrayList.Contains(xmlSchemaAttribute2.QualifiedName))
{
xmlSchemaAttribute2.error(h, string.Format("Duplicate attributes was found for '{0}'", xmlSchemaAttribute2.QualifiedName));
}
arrayList.Add(xmlSchemaAttribute2.QualifiedName);
if (!XmlSchemaUtil.StrictMsCompliant || xmlSchemaAttribute2.Use != XmlSchemaUse.Prohibited)
{
if (xmlSchemaAttribute2.RefName != null && xmlSchemaAttribute2.RefName != XmlQualifiedName.Empty && (!skipEquivalent || !XmlSchemaUtil.AreAttributesEqual(xmlSchemaAttribute2, attributesResolved[xmlSchemaAttribute2.RefName] as XmlSchemaAttribute)))
{
XmlSchemaUtil.AddToTable(attributesResolved, xmlSchemaAttribute2, xmlSchemaAttribute2.RefName, h);
}
else if (!skipEquivalent || !XmlSchemaUtil.AreAttributesEqual(xmlSchemaAttribute2, attributesResolved[xmlSchemaAttribute2.QualifiedName] as XmlSchemaAttribute))
{
XmlSchemaUtil.AddToTable(attributesResolved, xmlSchemaAttribute2, xmlSchemaAttribute2.QualifiedName, h);
}
}
}
else if (anyAttribute == null)
{
anyAttributeUse = (XmlSchemaAnyAttribute)xmlSchemaObject;
anyAttribute.Validate(h, schema);
}
}
}
return(num);
}
private XmlSchemaAttribute AddAttribute(string localName, string prefix, string childURI, string attrValue, bool bCreatingNewType, XmlSchema parentSchema, XmlSchemaObjectCollection addLocation, XmlSchemaObjectTable compiledAttributes)
{
if (childURI == XmlSchema.Namespace)
{
throw new XmlSchemaInferenceException(Res.SchInf_schema, 0, 0);
}
XmlSchemaAttribute xsa = null;
int AttributeType = -1;
XmlSchemaAttribute returnedAttribute = null; //this value will change to attributeReference if childURI!= parentURI
XmlSchema xs = null;
bool add = true;
Debug.Assert(compiledAttributes != null); //AttributeUses is never null
// First we need to look into the already compiled attributes
// (they come from the schemaset which we got on input)
// If there are none or we don't find it there, then we must search the list of attributes
// where we are going to add a new one (if it doesn't exist).
// This is necessary to avoid adding duplicate attribute declarations.
ICollection searchCollectionPrimary, searchCollectionSecondary;
if (compiledAttributes.Count > 0) {
searchCollectionPrimary = compiledAttributes.Values;
searchCollectionSecondary = addLocation;
}
else {
searchCollectionPrimary = addLocation;
searchCollectionSecondary = null;
}
if (childURI == XmlReservedNs.NsXml)
{
XmlSchemaAttribute attributeReference = null;
//see if the reference exists
attributeReference = FindAttributeRef(searchCollectionPrimary, localName, childURI);
if (attributeReference == null && searchCollectionSecondary != null) {
attributeReference = FindAttributeRef(searchCollectionSecondary, localName, childURI);
}
if (attributeReference == null)
{
attributeReference = new XmlSchemaAttribute();
attributeReference.RefName = new XmlQualifiedName(localName, childURI);
if (bCreatingNewType && this.Occurrence == InferenceOption.Restricted)
{
attributeReference.Use = XmlSchemaUse.Required;
}
else
{
attributeReference.Use = XmlSchemaUse.Optional;
}
addLocation.Add(attributeReference);
}
returnedAttribute = attributeReference;
}
else
{
if (childURI.Length == 0)
{
xs = parentSchema;
add = false;
}
else if (childURI != null && !schemaSet.Contains(childURI))
{
/*if (parentSchema.AttributeFormDefault = XmlSchemaForm.Unqualified && childURI.Length == 0)
{
xs = parentSchema;
add = false;
break;
}*/
xs = new XmlSchema();
xs.AttributeFormDefault = XmlSchemaForm.Unqualified;
xs.ElementFormDefault = XmlSchemaForm.Qualified;
if (childURI.Length != 0)
xs.TargetNamespace = childURI;
//schemas.Add(childURI, xs);
this.schemaSet.Add(xs);
if (prefix.Length != 0 && String.Compare(prefix, "xml", StringComparison.OrdinalIgnoreCase) != 0)
NamespaceManager.AddNamespace(prefix, childURI);
}
else
{
ArrayList col = this.schemaSet.Schemas(childURI) as ArrayList;
if (col != null && col.Count > 0)
{
xs = col[0] as XmlSchema;
}
}
if (childURI.Length != 0) //
{
XmlSchemaAttribute attributeReference = null;
//see if the reference exists
attributeReference = FindAttributeRef(searchCollectionPrimary, localName, childURI);
if (attributeReference == null & searchCollectionSecondary != null) {
attributeReference = FindAttributeRef(searchCollectionSecondary, localName, childURI);
}
if (attributeReference == null)
{
attributeReference = new XmlSchemaAttribute();
attributeReference.RefName = new XmlQualifiedName(localName, childURI);
if (bCreatingNewType && this.Occurrence == InferenceOption.Restricted)
{
attributeReference.Use = XmlSchemaUse.Required;
}
else
{
attributeReference.Use = XmlSchemaUse.Optional;
}
addLocation.Add(attributeReference);
}
returnedAttribute = attributeReference;
//see if the attribute exists on the global level
xsa = FindAttribute(xs.Items, localName);
if (xsa == null)
{
xsa = new XmlSchemaAttribute();
xsa.Name = localName;
xsa.SchemaTypeName = RefineSimpleType(attrValue, ref AttributeType);
xsa.LineNumber = AttributeType; //we use LineNumber to store flags of valid types
xs.Items.Add(xsa);
}
else
{
if (xsa.Parent == null)
{
AttributeType = xsa.LineNumber; // we use LineNumber to store flags of valid types
}
else
{
AttributeType = GetSchemaType(xsa.SchemaTypeName);
xsa.Parent = null;
}
xsa.SchemaTypeName = RefineSimpleType(attrValue, ref AttributeType);
xsa.LineNumber = AttributeType; // we use LineNumber to store flags of valid types
}
}
else
{
xsa = FindAttribute(searchCollectionPrimary, localName);
if (xsa == null && searchCollectionSecondary != null) {
xsa = FindAttribute(searchCollectionSecondary, localName);
}
if (xsa == null)
{
xsa = new XmlSchemaAttribute();
xsa.Name = localName;
xsa.SchemaTypeName = RefineSimpleType(attrValue, ref AttributeType);
xsa.LineNumber = AttributeType; // we use LineNumber to store flags of valid types
if (bCreatingNewType && this.Occurrence == InferenceOption.Restricted)
xsa.Use = XmlSchemaUse.Required;
else
xsa.Use = XmlSchemaUse.Optional;
addLocation.Add(xsa);
if (xs.AttributeFormDefault != XmlSchemaForm.Unqualified)
{
xsa.Form = XmlSchemaForm.Unqualified;
}
}
else
{
if (xsa.Parent == null)
{
AttributeType = xsa.LineNumber; // we use LineNumber to store flags of valid types
}
else
{
AttributeType = GetSchemaType(xsa.SchemaTypeName);
xsa.Parent = null;
}
xsa.SchemaTypeName = RefineSimpleType(attrValue, ref AttributeType);
xsa.LineNumber = AttributeType; // we use LineNumber to store flags of valid types
}
returnedAttribute = xsa;
}
}
string nullString = null;
if (add && childURI != parentSchema.TargetNamespace)
{
for (int i = 0; i < parentSchema.Includes.Count; ++i)
{
XmlSchemaImport import = parentSchema.Includes[i] as XmlSchemaImport;
if (import == null)
{
continue;
}
if (import.Namespace == childURI)
{
add = false;
}
}
if (add)
{
XmlSchemaImport import = new XmlSchemaImport();
import.Schema = xs;
if (childURI.Length != 0)
{
nullString = childURI;
}
import.Namespace = nullString;
parentSchema.Includes.Add(import);
}
}
return returnedAttribute;
}
public static int ValidateAttributesResolved(
XmlSchemaObjectTable attributesResolved,
ValidationEventHandler h,
XmlSchema schema,
XmlSchemaObjectCollection attributes,
XmlSchemaAnyAttribute anyAttribute,
ref XmlSchemaAnyAttribute anyAttributeUse,
XmlSchemaAttributeGroup redefined,
bool skipEquivalent)
{
int errorCount = 0;
if (anyAttribute != null && anyAttributeUse == null)
{
anyAttributeUse = anyAttribute;
}
ArrayList newAttrNames = new ArrayList();
foreach (XmlSchemaObject xsobj in attributes)
{
XmlSchemaAttributeGroupRef grpRef = xsobj as XmlSchemaAttributeGroupRef;
if (grpRef != null)
{
// Resolve attributeGroup redefinition.
XmlSchemaAttributeGroup grp = null;
if (redefined != null && grpRef.RefName == redefined.QualifiedName)
{
grp = redefined;
}
else
{
grp = schema.FindAttributeGroup(grpRef.RefName);
}
// otherwise, it might be missing sub components.
if (grp == null)
{
if (!schema.missedSubComponents) // && schema.Schemas [grpRef.RefName.Namespace] != null)
{
grpRef.error(h, "Referenced attribute group " + grpRef.RefName + " was not found in the corresponding schema.");
}
continue;
}
if (grp.AttributeGroupRecursionCheck)
{
grp.error(h, "Attribute group recursion was found: " + grpRef.RefName);
continue;
}
try {
grp.AttributeGroupRecursionCheck = true;
errorCount += grp.Validate(h, schema);
} finally {
grp.AttributeGroupRecursionCheck = false;
}
if (grp.AnyAttributeUse != null)
{
if (anyAttribute == null)
{
anyAttributeUse = grp.AnyAttributeUse;
}
}
foreach (DictionaryEntry entry in grp.AttributeUses)
{
XmlSchemaAttribute attr = (XmlSchemaAttribute)entry.Value;
#if BUGGY_MS_COMPLIANT
if (attr.Use == XmlSchemaUse.Prohibited)
{
continue;
}
#endif
if (attr.RefName != null && attr.RefName != XmlQualifiedName.Empty && (!skipEquivalent || !AreAttributesEqual(attr, attributesResolved [attr.RefName] as XmlSchemaAttribute)))
{
AddToTable(attributesResolved, attr, attr.RefName, h);
}
else if (!skipEquivalent || !AreAttributesEqual(attr, attributesResolved [attr.QualifiedName] as XmlSchemaAttribute))
{
AddToTable(attributesResolved, attr, attr.QualifiedName, h);
}
}
}
else
{
XmlSchemaAttribute attr = xsobj as XmlSchemaAttribute;
if (attr != null)
{
errorCount += attr.Validate(h, schema);
if (newAttrNames.Contains(attr.QualifiedName))
{
attr.error(h, String.Format("Duplicate attributes was found for '{0}'", attr.QualifiedName));
}
newAttrNames.Add(attr.QualifiedName);
#if BUGGY_MS_COMPLIANT
if (attr.Use == XmlSchemaUse.Prohibited)
{
continue;
}
#endif
if (attr.RefName != null && attr.RefName != XmlQualifiedName.Empty && (!skipEquivalent || !AreAttributesEqual(attr, attributesResolved [attr.RefName] as XmlSchemaAttribute)))
{
AddToTable(attributesResolved, attr, attr.RefName, h);
}
else if (!skipEquivalent || !AreAttributesEqual(attr, attributesResolved [attr.QualifiedName] as XmlSchemaAttribute))
{
AddToTable(attributesResolved, attr, attr.QualifiedName, h);
}
}
else
{
if (anyAttribute == null)
{
anyAttributeUse = (XmlSchemaAnyAttribute)xsobj;
anyAttribute.Validate(h, schema);
}
}
}
}
return(errorCount);
}
/// <summary>Initializes a new instance of the <see cref="T:System.Xml.Schema.XmlSchemaChoice" /> class.</summary>
public XmlSchemaChoice()
{
this.items = new XmlSchemaObjectCollection();
}
internal abstract void SetItems(XmlSchemaObjectCollection newItems);
internal virtual RestrictionFacets ConstructRestriction(DatatypeImplementation datatype, XmlSchemaObjectCollection facets, XmlNameTable nameTable)
{
RestrictionFacets restriction = new RestrictionFacets();
FacetsCompiler compiler = new FacetsCompiler(datatype, restriction);
for (int i = 0; i < facets.Count; i++)
{
XmlSchemaFacet source = (XmlSchemaFacet)facets[i];
if (source.Value == null)
{
throw new XmlSchemaException("Sch_InvalidFacet", source);
}
IXmlNamespaceResolver nsmgr = new SchemaNamespaceManager(source);
switch (source.FacetType)
{
case FacetType.Length:
compiler.CompileLengthFacet(source);
break;
case FacetType.MinLength:
compiler.CompileMinLengthFacet(source);
break;
case FacetType.MaxLength:
compiler.CompileMaxLengthFacet(source);
break;
case FacetType.Pattern:
compiler.CompilePatternFacet(source as XmlSchemaPatternFacet);
break;
case FacetType.Whitespace:
compiler.CompileWhitespaceFacet(source);
break;
case FacetType.Enumeration:
compiler.CompileEnumerationFacet(source, nsmgr, nameTable);
break;
case FacetType.MinExclusive:
compiler.CompileMinExclusiveFacet(source);
break;
case FacetType.MinInclusive:
compiler.CompileMinInclusiveFacet(source);
break;
case FacetType.MaxExclusive:
compiler.CompileMaxExclusiveFacet(source);
break;
case FacetType.MaxInclusive:
compiler.CompileMaxInclusiveFacet(source);
break;
case FacetType.TotalDigits:
compiler.CompileTotalDigitsFacet(source);
break;
case FacetType.FractionDigits:
compiler.CompileFractionDigitsFacet(source);
break;
default:
throw new XmlSchemaException("Sch_UnknownFacet", source);
}
}
compiler.FinishFacetCompile();
compiler.CompileFacetCombinations();
return(restriction);
}
private void Add(XmlSchemaObjectCollection collToAdd)
{
this.InnerList.InsertRange(0, collToAdd);
}
protected XmlSchemaGroupBase()
{
compiledItems = new XmlSchemaObjectCollection();
}
internal void ProcessAttributes(ref XmlSchemaElement xse, XmlSchemaType effectiveSchemaType, bool bCreatingNewType, XmlSchema parentSchema)
{
XmlSchemaObjectCollection attributesSeen = new XmlSchemaObjectCollection();
XmlSchemaComplexType ct = effectiveSchemaType as XmlSchemaComplexType;
Debug.Assert(xtr.NodeType == XmlNodeType.Attribute);
do
{
if (xtr.NamespaceURI == XmlSchema.Namespace)
{
throw new XmlSchemaInferenceException(Res.SchInf_schema, 0, 0);
}
if (xtr.NamespaceURI == XmlReservedNs.NsXmlNs)
{
if (xtr.Prefix=="xmlns")
NamespaceManager.AddNamespace(xtr.LocalName, xtr.Value);
}
else if (xtr.NamespaceURI == XmlReservedNs.NsXsi)
{
string localName = xtr.LocalName;
if (localName == "nil")
{
xse.IsNillable = true;
}
else if (localName != "type" && localName != "schemaLocation" && localName != "noNamespaceSchemaLocation")
{
throw new XmlSchemaInferenceException(Res.Sch_NotXsiAttribute,localName);
}
}
else
{
if (ct == null || ct == XmlSchemaComplexType.AnyType)
{
ct = new XmlSchemaComplexType();
xse.SchemaType = ct;
}
XmlSchemaAttribute xsa=null;
//The earlier assumption of checking just schemaTypeName !Empty is not correct for schemas that are not generated by us, schemaTypeName can point to any complex type as well
//Check that it is a simple type by checking typeCode
//Switch to complex type simple content extension
if (effectiveSchemaType != null && effectiveSchemaType.Datatype != null && !xse.SchemaTypeName.IsEmpty)
{
//type was previously simple type, now it will become complex with simple type extension
Debug.Assert(ct != null);
XmlSchemaSimpleContent sc = new XmlSchemaSimpleContent();
ct.ContentModel = sc;
XmlSchemaSimpleContentExtension sce = new XmlSchemaSimpleContentExtension();
sc.Content = sce;
sce.BaseTypeName = xse.SchemaTypeName;
sce.LineNumber = xse.LineNumber;
xse.LineNumber = 0;
xse.SchemaTypeName = XmlQualifiedName.Empty; //re-set the name
}
Debug.Assert(ct != null); //either the user-defined type itself is a complex type or we switched from a simple type to a complex type
if (ct.ContentModel != null)
{
XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct);
Debug.Assert(sce != null);
xsa = AddAttribute(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, xtr.Value, bCreatingNewType, parentSchema, sce.Attributes, ct.AttributeUses);
}
else //add atributes directly to complex type
{
xsa = AddAttribute(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, xtr.Value, bCreatingNewType, parentSchema, ct.Attributes, ct.AttributeUses);
}
if (xsa != null) {
attributesSeen.Add(xsa);
}
}
} while (xtr.MoveToNextAttribute());
if (!bCreatingNewType)
{
//make attributes that did not appear this time optional
if (ct!=null) {
MakeExistingAttributesOptional(ct, attributesSeen);
}
}
}
internal void MakeExistingAttributesOptional(XmlSchemaComplexType ct, XmlSchemaObjectCollection attributesInInstance) {
if (ct == null) {
throw new XmlSchemaInferenceException(Res.SchInf_noct, 0, 0);
}
if (ct.ContentModel != null) {
XmlSchemaSimpleContentExtension xssce = CheckSimpleContentExtension(ct);
SwitchUseToOptional(xssce.Attributes, attributesInInstance);
}
else { //either <xs:attribute> as child of xs:complexType or the attributes are within the content model
SwitchUseToOptional(ct.Attributes, attributesInInstance);
}
}
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));
}
private int CountGroupSelfReference(XmlSchemaObjectCollection items, XmlQualifiedName name, XmlSchemaGroup redefined)
{
int num = 0;
for (int i = 0; i < items.Count; i++)
{
XmlSchemaGroupRef source = items[i] as XmlSchemaGroupRef;
if (source != null)
{
if (source.RefName == name)
{
source.Redefined = redefined;
if ((source.MinOccurs != 1M) || (source.MaxOccurs != 1M))
{
base.SendValidationEvent("Sch_MinMaxGroupRedefine", source);
}
num++;
}
}
else if (items[i] is XmlSchemaGroupBase)
{
num += this.CountGroupSelfReference(((XmlSchemaGroupBase) items[i]).Items, name, redefined);
}
if (num > 1)
{
return num;
}
}
return num;
}
void WriteSortedItems(XmlSchemaObjectCollection items) {
if (items == null) return;
ArrayList list = new ArrayList();
for (int i = 0; i < items.Count; i++) {
list.Add(items[i]);
}
list.Sort(new XmlSchemaObjectComparer());
for (int i = 0; i < list.Count; i++) {
Write3_XmlSchemaObject((XmlSchemaObject)list[i]);
}
}
public XmlSchemaSimpleContentExtension()
{
baseTypeName = XmlQualifiedName.Empty;
attributes = new XmlSchemaObjectCollection();
}
private void CompileLocalAttributes(XmlSchemaComplexType baseType, XmlSchemaComplexType derivedType, XmlSchemaObjectCollection attributes, XmlSchemaAnyAttribute anyAttribute, XmlSchemaDerivationMethod derivedBy)
{
XmlSchemaAnyAttribute b = (baseType != null) ? baseType.AttributeWildcard : null;
for (int i = 0; i < attributes.Count; i++)
{
XmlSchemaAttribute xa = attributes[i] as XmlSchemaAttribute;
if (xa != null)
{
if (xa.Use != XmlSchemaUse.Prohibited)
{
this.CompileAttribute(xa);
}
if ((xa.Use != XmlSchemaUse.Prohibited) || (((xa.Use == XmlSchemaUse.Prohibited) && (derivedBy == XmlSchemaDerivationMethod.Restriction)) && (baseType != XmlSchemaComplexType.AnyType)))
{
if (derivedType.AttributeUses[xa.QualifiedName] == null)
{
derivedType.AttributeUses.Add(xa.QualifiedName, xa);
}
else
{
base.SendValidationEvent("Sch_DupAttributeUse", xa.QualifiedName.ToString(), xa);
}
}
else
{
base.SendValidationEvent("Sch_AttributeIgnored", xa.QualifiedName.ToString(), xa, XmlSeverityType.Warning);
}
}
else
{
XmlSchemaAttributeGroupRef source = (XmlSchemaAttributeGroupRef) attributes[i];
XmlSchemaAttributeGroup attributeGroup = (XmlSchemaAttributeGroup) this.schema.AttributeGroups[source.RefName];
if (attributeGroup != null)
{
this.CompileAttributeGroup(attributeGroup);
foreach (XmlSchemaAttribute attribute3 in attributeGroup.AttributeUses.Values)
{
if ((attribute3.Use != XmlSchemaUse.Prohibited) || (((attribute3.Use == XmlSchemaUse.Prohibited) && (derivedBy == XmlSchemaDerivationMethod.Restriction)) && (baseType != XmlSchemaComplexType.AnyType)))
{
if (derivedType.AttributeUses[attribute3.QualifiedName] == null)
{
derivedType.AttributeUses.Add(attribute3.QualifiedName, attribute3);
}
else
{
base.SendValidationEvent("Sch_DupAttributeUse", attribute3.QualifiedName.ToString(), source);
}
}
else
{
base.SendValidationEvent("Sch_AttributeIgnored", attribute3.QualifiedName.ToString(), attribute3, XmlSeverityType.Warning);
}
}
anyAttribute = this.CompileAnyAttributeIntersection(anyAttribute, attributeGroup.AttributeWildcard);
}
else
{
base.SendValidationEvent("Sch_UndefAttributeGroupRef", source.RefName.ToString(), source);
}
}
}
if (baseType != null)
{
if (derivedBy == XmlSchemaDerivationMethod.Extension)
{
derivedType.SetAttributeWildcard(this.CompileAnyAttributeUnion(anyAttribute, b));
foreach (XmlSchemaAttribute attribute4 in baseType.AttributeUses.Values)
{
XmlSchemaAttribute attribute5 = (XmlSchemaAttribute) derivedType.AttributeUses[attribute4.QualifiedName];
if (attribute5 != null)
{
if ((attribute5.AttributeSchemaType != attribute4.AttributeSchemaType) || (attribute4.Use == XmlSchemaUse.Prohibited))
{
base.SendValidationEvent("Sch_InvalidAttributeExtension", attribute5);
}
}
else
{
derivedType.AttributeUses.Add(attribute4.QualifiedName, attribute4);
}
}
}
else
{
if ((anyAttribute != null) && ((b == null) || !XmlSchemaAnyAttribute.IsSubset(anyAttribute, b)))
{
base.SendValidationEvent("Sch_InvalidAnyAttributeRestriction", derivedType);
}
else
{
derivedType.SetAttributeWildcard(anyAttribute);
}
foreach (XmlSchemaAttribute attribute6 in baseType.AttributeUses.Values)
{
XmlSchemaAttribute attribute7 = (XmlSchemaAttribute) derivedType.AttributeUses[attribute6.QualifiedName];
if (attribute7 == null)
{
derivedType.AttributeUses.Add(attribute6.QualifiedName, attribute6);
}
else if ((attribute6.Use == XmlSchemaUse.Prohibited) && (attribute7.Use != XmlSchemaUse.Prohibited))
{
base.SendValidationEvent("Sch_AttributeRestrictionProhibited", attribute7);
}
else if ((attribute7.Use != XmlSchemaUse.Prohibited) && (((attribute6.AttributeSchemaType == null) || (attribute7.AttributeSchemaType == null)) || !XmlSchemaType.IsDerivedFrom(attribute7.AttributeSchemaType, attribute6.AttributeSchemaType, XmlSchemaDerivationMethod.Empty)))
{
base.SendValidationEvent("Sch_AttributeRestrictionInvalid", attribute7);
}
}
foreach (XmlSchemaAttribute attribute8 in derivedType.AttributeUses.Values)
{
if ((((XmlSchemaAttribute) baseType.AttributeUses[attribute8.QualifiedName]) == null) && ((b == null) || !b.Allows(attribute8.QualifiedName)))
{
base.SendValidationEvent("Sch_AttributeRestrictionInvalidFromWildcard", attribute8);
}
}
}
}
else
{
derivedType.SetAttributeWildcard(anyAttribute);
}
}
private static void CleanupAttributes(XmlSchemaObjectCollection attributes)
{
for (int i = 0; i < attributes.Count; i++)
{
XmlSchemaAttribute attribute = attributes[i] as XmlSchemaAttribute;
if (attribute != null)
{
CleanupAttribute(attribute);
}
}
}
public XmlSchemaComplexContentExtension()
{
attributes = new XmlSchemaObjectCollection();
baseTypeName = XmlQualifiedName.Empty;
}
internal virtual void OnAdd(XmlSchemaObjectCollection container, object?item)
{
}
// ArrayList compiledFields;
public XmlSchemaIdentityConstraint()
{
fields = new XmlSchemaObjectCollection();
qName = XmlQualifiedName.Empty;
}
private void InferAttributes(Element el, string ns, bool isNew)
{
// Now this element is going to have complexType.
// It currently not, then we have to replace it.
ComplexType ct = null;
SOMList attList = null;
Hashtable table = null;
do
{
switch (source.NamespaceURI)
{
case NamespaceXml:
if (schemas.Schemas(
NamespaceXml).Count == 0)
{
IncludeXmlAttributes();
}
break;
case XmlSchema.InstanceNamespace:
if (source.LocalName == "nil")
{
el.IsNillable = true;
}
// all other xsi:* atts are ignored
continue;
case NamespaceXmlns:
continue;
}
if (ct == null)
{
ct = ToComplexType(el);
attList = GetAttributes(ct);
table = CollectAttrTable(attList);
}
QName attrName = new QName(
source.LocalName, source.NamespaceURI);
Attr attr = table [attrName] as Attr;
if (attr == null)
{
attList.Add(InferNewAttribute(
attrName, isNew, ns));
}
else
{
table.Remove(attrName);
if (attr.RefName != null &&
attr.RefName != QName.Empty)
{
continue; // just a reference
}
InferMergedAttribute(attr);
}
} while (source.MoveToNextAttribute());
// mark all attr definitions that did not appear
// as optional.
if (table != null)
{
foreach (Attr attr in table.Values)
{
attr.Use = Use.Optional;
}
}
}
internal XmlSchemaDatatype DeriveByRestriction(XmlSchemaObjectCollection facets, XmlNameTable nameTable)
{
return(((DatatypeImplementation)this).DeriveByRestriction(facets, nameTable));
}
internal static XmlQualifiedName NameOf(XmlSchemaObjectCollection items) {
ArrayList list = new ArrayList();
for (int i = 0; i < items.Count; i++) {
list.Add(NameOf(items[i]));
}
list.Sort(new QNameComparer());
return (XmlQualifiedName)list[0];
}
// 3.14.6 Derivation Valid (RestrictionSimple)
internal void ValidateDerivationValid(object baseType, XmlSchemaObjectCollection facets,
ValidationEventHandler h, XmlSchema schema)
{
// TODO
XmlSchemaSimpleType baseSimpleType = baseType as XmlSchemaSimpleType;
switch (this.Variety)
{
// 1. atomic type
case XmlSchemaDerivationMethod.Restriction:
// 1.1
if (baseSimpleType != null && baseSimpleType.resolvedDerivedBy != XmlSchemaDerivationMethod.Restriction)
{
error(h, "Base schema type is not either atomic type or primitive type.");
}
// 1.2
if (baseSimpleType != null &&
(baseSimpleType.FinalResolved & XmlSchemaDerivationMethod.Restriction) != 0)
{
error(h, "Derivation by restriction is prohibited by the base simple type.");
}
// TODO: 1.3 facet restriction valid.
break;
case XmlSchemaDerivationMethod.List:
/*
* XmlSchemaSimpleTypeList thisList = Content as XmlSchemaSimpleTypeList;
* // 2.1 item list type not allowed
* if (baseSimpleType != null && baseSimpleType.resolvedDerivedBy == XmlSchemaDerivationMethod.List)
* error (h, "Base list schema type is not allowed.");
* XmlSchemaSimpleTypeUnion baseUnion = baseSimpleType.Content as XmlSchemaSimpleTypeUnion;
* if (baseUnion != null) {
* bool errorFound = false;
* foreach (object memberType in baseUnion.ValidatedTypes) {
* XmlSchemaSimpleType memberST = memberType as XmlSchemaSimpleType;
* if (memberST != null && memberST.resolvedDerivedBy == XmlSchemaDerivationMethod.List)
* errorFound = true;
* }
* if (errorFound)
* error (h, "Base union schema type should not contain list types.");
* }
*/
// 2.2 facets limited
if (facets != null)
{
foreach (XmlSchemaFacet facet in facets)
{
if (facet is XmlSchemaLengthFacet ||
facet is XmlSchemaMaxLengthFacet ||
facet is XmlSchemaMinLengthFacet ||
facet is XmlSchemaEnumerationFacet ||
facet is XmlSchemaPatternFacet)
{
continue;
}
else
{
error(h, "Not allowed facet was found on this simple type which derives list type.");
}
}
}
break;
case XmlSchemaDerivationMethod.Union:
// 3.1
// 3.2
if (facets != null)
{
foreach (XmlSchemaFacet facet in facets)
{
if (facet is XmlSchemaEnumerationFacet ||
facet is XmlSchemaPatternFacet)
{
continue;
}
else
{
error(h, "Not allowed facet was found on this simple type which derives list type.");
}
}
}
break;
}
}
void WriteFacets(XmlSchemaObjectCollection facets) {
if (facets == null) return;
ArrayList a = new ArrayList();
for (int i = 0; i < facets.Count; i++) {
a.Add(facets[i]);
}
a.Sort(new XmlFacetComparer());
for (int ia = 0; ia < a.Count; ia++) {
XmlSchemaObject ai = (XmlSchemaObject)a[ia];
if (ai is XmlSchemaMinExclusiveFacet) {
Write_XmlSchemaFacet("minExclusive", (XmlSchemaFacet)ai);
}
else if (ai is XmlSchemaMaxInclusiveFacet) {
Write_XmlSchemaFacet("maxInclusive", (XmlSchemaFacet)ai);
}
else if (ai is XmlSchemaMaxExclusiveFacet) {
Write_XmlSchemaFacet("maxExclusive", (XmlSchemaFacet)ai);
}
else if (ai is XmlSchemaMinInclusiveFacet) {
Write_XmlSchemaFacet("minInclusive", (XmlSchemaFacet)ai);
}
else if (ai is XmlSchemaLengthFacet) {
Write_XmlSchemaFacet("length", (XmlSchemaFacet)ai);
}
else if (ai is XmlSchemaEnumerationFacet) {
Write_XmlSchemaFacet("enumeration", (XmlSchemaFacet)ai);
}
else if (ai is XmlSchemaMinLengthFacet) {
Write_XmlSchemaFacet("minLength", (XmlSchemaFacet)ai);
}
else if (ai is XmlSchemaPatternFacet) {
Write_XmlSchemaFacet("pattern", (XmlSchemaFacet)ai);
}
else if (ai is XmlSchemaTotalDigitsFacet) {
Write_XmlSchemaFacet("totalDigits", (XmlSchemaFacet)ai);
}
else if (ai is XmlSchemaMaxLengthFacet) {
Write_XmlSchemaFacet("maxLength", (XmlSchemaFacet)ai);
}
else if (ai is XmlSchemaWhiteSpaceFacet) {
Write_XmlSchemaFacet("whiteSpace", (XmlSchemaFacet)ai);
}
else if (ai is XmlSchemaFractionDigitsFacet) {
Write_XmlSchemaFacet("fractionDigit", (XmlSchemaFacet)ai);
}
}
}
internal virtual void OnRemove(XmlSchemaObjectCollection container, object item)
{
}
private int GetMappingParticle(XmlSchemaParticle particle, XmlSchemaObjectCollection collection)
{
for (int i = 0; i < collection.Count; i++)
{
if (this.IsValidRestriction(particle, (XmlSchemaParticle) collection[i]))
{
return i;
}
}
return -1;
}
internal virtual void OnClear(XmlSchemaObjectCollection container)
{
}
//Compile-time Facet Checking
internal virtual RestrictionFacets ConstructRestriction(DatatypeImplementation datatype, XmlSchemaObjectCollection facets, XmlNameTable nameTable) {
//Datatype is the type on which this method is called
RestrictionFacets derivedRestriction = new RestrictionFacets();
FacetsCompiler facetCompiler = new FacetsCompiler(datatype, derivedRestriction);
for (int i = 0; i < facets.Count; ++i) {
XmlSchemaFacet facet = (XmlSchemaFacet)facets[i];
if (facet.Value == null) {
throw new XmlSchemaException(Res.Sch_InvalidFacet, facet);
}
IXmlNamespaceResolver nsmgr = new SchemaNamespaceManager(facet);
switch(facet.FacetType) {
case FacetType.Length:
facetCompiler.CompileLengthFacet(facet);
break;
case FacetType.MinLength:
facetCompiler.CompileMinLengthFacet(facet);
break;
case FacetType.MaxLength:
facetCompiler.CompileMaxLengthFacet(facet);
break;
case FacetType.Pattern:
facetCompiler.CompilePatternFacet(facet as XmlSchemaPatternFacet);
break;
case FacetType.Enumeration:
facetCompiler.CompileEnumerationFacet(facet, nsmgr, nameTable);
break;
case FacetType.Whitespace:
facetCompiler.CompileWhitespaceFacet(facet);
break;
case FacetType.MinInclusive:
facetCompiler.CompileMinInclusiveFacet(facet);
break;
case FacetType.MinExclusive:
facetCompiler.CompileMinExclusiveFacet(facet);
break;
case FacetType.MaxInclusive:
facetCompiler.CompileMaxInclusiveFacet(facet);
break;
case FacetType.MaxExclusive:
facetCompiler.CompileMaxExclusiveFacet(facet);
break;
case FacetType.TotalDigits:
facetCompiler.CompileTotalDigitsFacet(facet);
break;
case FacetType.FractionDigits:
facetCompiler.CompileFractionDigitsFacet(facet);
break;
default:
throw new XmlSchemaException(Res.Sch_UnknownFacet, facet);
}
}
facetCompiler.FinishFacetCompile();
facetCompiler.CompileFacetCombinations();
return derivedRestriction;
}
/// <summary>Initializes a new instance of the <see cref="T:System.Xml.Schema.XmlSchemaAttributeGroup" /> class.</summary>
public XmlSchemaAttributeGroup()
{
this.attributes = new XmlSchemaObjectCollection();
this.qualifiedName = XmlQualifiedName.Empty;
}
internal override void SetItems(XmlSchemaObjectCollection newItems)
{
this.items = newItems;
}
internal abstract XmlSchemaDatatype DeriveByRestriction(XmlSchemaObjectCollection facets, XmlNameTable nameTable, XmlSchemaType schemaType);
internal XmlSchemaObjectCollection Clone() {
XmlSchemaObjectCollection coll = new XmlSchemaObjectCollection();
coll.Add(this);
return coll;
}
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);
}
/// <summary>
/// Verifies that the current element has its corresponding element in the sequence and order is the same.
/// If the order is not the same, it changes the particle from Sequence to Sequence with Choice.
/// If there is more elements of the same kind in the sequence, sets maxOccurs to unbounded
/// </summary>
/// <param name="bCreatingNewType">True if this is a new type. This is important for setting minOccurs=0 for elements that did not exist in a particle.</param>
/// <param name="xtr">text reader positioned to the current element</param>
/// <param name="ct">complex type with Sequence or Choice Particle</param>
/// <param name="lastUsedSeqItem">ordinal number in the sequence to indicate current sequence position</param>
/// <param name="itemsMadeOptional">hashtable of elements with minOccurs changed to 0 in order to satisfy sequence requirements. These elements will be rolled back if Sequence becomes Sequence of Choice.</param>
/// <param name="bParticleChanged">This indicates to the caller if Sequence was changed to Choice</param>
internal XmlSchemaElement FindMatchingElement(bool bCreatingNewType, XmlReader xtr,XmlSchemaComplexType ct, ref int lastUsedSeqItem, ref bool bParticleChanged, XmlSchema parentSchema, bool setMaxoccurs)
{
if (xtr.NamespaceURI == XmlSchema.Namespace)
{
throw new XmlSchemaInferenceException(Res.SchInf_schema, 0, 0);
}
bool bItemNotUsedYet = ((lastUsedSeqItem == -1)? true: false);
XmlSchemaObjectCollection minOccursCandidates = new XmlSchemaObjectCollection(); //elements that are skipped in the sequence and need minOccurs modified.
if (ct.Particle.GetType() == typeof (XmlSchemaSequence))
{
string childURI = xtr.NamespaceURI;
if (childURI.Length == 0)
{
childURI = null;
}
XmlSchemaSequence xss = (XmlSchemaSequence) ct.Particle;
if (xss.Items.Count < 1 && !bCreatingNewType)
{
lastUsedSeqItem = 0;
XmlSchemaElement e = AddElement(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, parentSchema, xss.Items,-1);
e.MinOccurs = 0;
return e;
}
if (xss.Items[0].GetType() == typeof (XmlSchemaChoice))
{ // <sequence minOccurs="0" maxOccurs="unbounded"><choice><element>...</choice></sequence>
XmlSchemaChoice xsch = (XmlSchemaChoice) xss.Items[0];
for (int i = 0; i < xsch.Items.Count; ++i)
{
XmlSchemaElement el = xsch.Items[i] as XmlSchemaElement;
if (el == null)
{
throw new XmlSchemaInferenceException(Res.SchInf_UnknownParticle, 0, 0);
}
if ((el.Name == xtr.LocalName) &&( parentSchema.TargetNamespace == childURI))
{ // element is in the same namespace
InferElement(el, false, parentSchema);
SetMinMaxOccurs(el, setMaxoccurs);
return el;
}
else if ((el.RefName.Name == xtr.LocalName) && (el.RefName.Namespace == xtr.NamespaceURI))
{
XmlSchemaElement referencedElement = FindGlobalElement(childURI, xtr.LocalName, out parentSchema);
InferElement(referencedElement, false, parentSchema);
SetMinMaxOccurs(el, setMaxoccurs);
return referencedElement;
}
}
XmlSchemaElement subElement = AddElement(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, parentSchema, xsch.Items,-1);
return subElement;
}
else
{ //this should be sequence of elements
int iSeqItem = 0; //iterator through schema sequence items
if (lastUsedSeqItem >= 0)
iSeqItem = lastUsedSeqItem;
XmlSchemaParticle particle = xss.Items[iSeqItem] as XmlSchemaParticle;
XmlSchemaElement el = particle as XmlSchemaElement;
if (el == null)
{
throw new XmlSchemaInferenceException(Res.SchInf_UnknownParticle, 0, 0);
}
if (el.Name == xtr.LocalName && parentSchema.TargetNamespace == childURI)
{
if (!bItemNotUsedYet) //read: if item was already used one or more times
el.MaxOccurs = decimal.MaxValue; //set it to unbounded
lastUsedSeqItem = iSeqItem;
InferElement(el, false, parentSchema);
SetMinMaxOccurs(el, false);
return el;
}
else if (el.RefName.Name == xtr.LocalName && el.RefName.Namespace == xtr.NamespaceURI)
{
if (!bItemNotUsedYet) //read: if item was already used one or more times
el.MaxOccurs = decimal.MaxValue; //set it to unbounded
lastUsedSeqItem = iSeqItem;
XmlSchemaElement referencedElement = FindGlobalElement(childURI, xtr.LocalName, out parentSchema);
InferElement(referencedElement, false, parentSchema);
SetMinMaxOccurs(el, false);
return el;
}
if (bItemNotUsedYet && el.MinOccurs!=decimal.Zero)
minOccursCandidates.Add(el);
iSeqItem++;
while (iSeqItem < xss.Items.Count)
{
particle = xss.Items[iSeqItem] as XmlSchemaParticle;
el = particle as XmlSchemaElement;
if (el == null)
{
throw new XmlSchemaInferenceException(Res.SchInf_UnknownParticle, 0, 0);
}
if (el.Name == xtr.LocalName && parentSchema.TargetNamespace == childURI)
{
lastUsedSeqItem = iSeqItem;
for (int i = 0; i < minOccursCandidates.Count; ++i)
{
((XmlSchemaElement) minOccursCandidates[i]).MinOccurs = decimal.Zero;
}
InferElement(el, false, parentSchema);
SetMinMaxOccurs(el, setMaxoccurs);
return el;
}
else if (el.RefName.Name == xtr.LocalName && el.RefName.Namespace == xtr.NamespaceURI)
{
lastUsedSeqItem = iSeqItem;
for (int i = 0; i < minOccursCandidates.Count; ++i)
{
((XmlSchemaElement) minOccursCandidates[i]).MinOccurs = decimal.Zero;
}
XmlSchemaElement referencedElement = FindGlobalElement(childURI, xtr.LocalName, out parentSchema);
InferElement(referencedElement, false, parentSchema);
SetMinMaxOccurs(el, setMaxoccurs);
return referencedElement;
}
minOccursCandidates.Add(el);
iSeqItem++;
}
//element not found in the sequence order, if it is found out of order change Sequence of elements to Sequence of Choices otherwise insert into sequence as optional
XmlSchemaElement subElement = null;
XmlSchemaElement actualElement = null;
//
if (parentSchema.TargetNamespace == childURI)
{
subElement = FindElement(xss.Items, xtr.LocalName);
actualElement = subElement;
}
else
{
subElement = FindElementRef(xss.Items, xtr.LocalName, xtr.NamespaceURI);
if (subElement != null)
{
actualElement = FindGlobalElement(childURI, xtr.LocalName, out parentSchema);
}
}
if (null != subElement)
{
XmlSchemaChoice xsc = new XmlSchemaChoice();
xsc.MaxOccurs = decimal.MaxValue;
SetMinMaxOccurs(subElement, setMaxoccurs);
InferElement(actualElement, false, parentSchema);
for (int i = 0; i < xss.Items.Count; ++i)
{
xsc.Items.Add(CreateNewElementforChoice((XmlSchemaElement) xss.Items[i]));
}
xss.Items.Clear();
xss.Items.Add(xsc);
return subElement;
}
else
{
subElement = AddElement(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, parentSchema, xss.Items, ++lastUsedSeqItem);
if (!bCreatingNewType)
subElement.MinOccurs = decimal.Zero;
return subElement;
}
}
}
else
{
throw new XmlSchemaInferenceException(Res.SchInf_noseq, 0, 0);
}
}
public XmlSchemaSequence()
{
items = new XmlSchemaObjectCollection();
}
internal XmlSchemaElement FindElementRef(XmlSchemaObjectCollection elements, string elementName, string nsURI)
{
for (int i = 0; i < elements.Count; ++i)
{
XmlSchemaElement xse = elements[i] as XmlSchemaElement;
if (xse != null && xse.RefName != null)
{
if (xse.RefName.Name == elementName && xse.RefName.Namespace == nsURI)
{
return xse;
}
}
}
return null;
}
internal override void SetItems(XmlSchemaObjectCollection newItems)
{
_items = newItems;
}
private void SwitchUseToOptional(XmlSchemaObjectCollection attributes, XmlSchemaObjectCollection attributesInInstance) {
for (int i = 0; i < attributes.Count; ++i)
{
XmlSchemaAttribute attr = attributes[i] as XmlSchemaAttribute;
if (attr != null) {
if (attributesInInstance != null) {
if (attr.RefName.Name.Length == 0) { //If the attribute is not present in this instance, make it optional
if (null == FindAttribute(attributesInInstance, attr.Name)) {
attr.Use = XmlSchemaUse.Optional;
}
}
else {
if (null == FindAttributeRef(attributesInInstance, attr.RefName.Name, attr.RefName.Namespace)) {
attr.Use = XmlSchemaUse.Optional;
}
}
}
else {
attr.Use = XmlSchemaUse.Optional;
}
}
}
}
internal void SetAttributes(XmlSchemaObjectCollection newAttributes)
{
_attributes = newAttributes;
}
private XmlSchemaElement AddElement(string localName, string prefix, string childURI, XmlSchema parentSchema, XmlSchemaObjectCollection addLocation, int positionWithinCollection)
{
if (childURI == XmlSchema.Namespace)
{
throw new XmlSchemaInferenceException(Res.SchInf_schema, 0, 0);
}
XmlSchemaElement xse = null;
XmlSchemaElement returnedElement = xse; //this value will change to elementReference if childURI!= parentURI
XmlSchema xs = null;
bool bCreatingNewType = true;
if (childURI == String.Empty)
{
childURI = null;
}
// The new element belongs to the same ns as parent and addlocation is not null
if (parentSchema != null && childURI == parentSchema.TargetNamespace)
{
xse = new XmlSchemaElement();
xse.Name = localName;
xs = parentSchema;
if (xs.ElementFormDefault != XmlSchemaForm.Qualified && addLocation != null)
{
xse.Form = XmlSchemaForm.Qualified;
}
}
else if (schemaSet.Contains(childURI))
{
xse = this.FindGlobalElement(childURI, localName, out xs);
if (xse == null)
{
ArrayList col = this.schemaSet.Schemas(childURI)as ArrayList;
if (col != null && col.Count > 0 )
{
xs = col[0] as XmlSchema;
}
xse = new XmlSchemaElement();
xse.Name = localName;
xs.Items.Add(xse);
}
else
bCreatingNewType = false;
}
else
{
xs = CreateXmlSchema(childURI);
if (prefix.Length!=0)
NamespaceManager.AddNamespace(prefix, childURI);
xse=new XmlSchemaElement();
xse.Name = localName;
xs.Items.Add(xse); //add global element declaration only when creating new schema
}
if (parentSchema == null)
{
parentSchema = xs;
this.rootSchema = parentSchema;
}
if (childURI != parentSchema.TargetNamespace )
{
bool add = true;
for (int i = 0; i < parentSchema.Includes.Count; ++i)
{
XmlSchemaImport import = parentSchema.Includes[i] as XmlSchemaImport;
if (import == null)
{
continue;
}
//Debug.WriteLine(import.Schema.TargetNamespace);
if (import.Namespace == childURI)
{
add = false;
}
}
if (add)
{
XmlSchemaImport import = new XmlSchemaImport();
import.Schema = xs;
import.Namespace = childURI;
parentSchema.Includes.Add(import);
}
}
returnedElement = xse;
if (addLocation != null)
{
if (childURI == parentSchema.TargetNamespace )
{
if (this.Occurrence == InferenceOption.Relaxed /*&& parentSchema.Items != addLocation*/)
{
xse.MinOccurs = 0;
}
if (positionWithinCollection == -1)
{
positionWithinCollection = addLocation.Add(xse);
}
else
{
addLocation.Insert(positionWithinCollection, xse);
}
}
else
{
XmlSchemaElement elementReference = new XmlSchemaElement();
elementReference.RefName = new XmlQualifiedName(localName, childURI);
if (this.Occurrence == InferenceOption.Relaxed)
{
elementReference.MinOccurs = 0;
}
if (positionWithinCollection == -1)
{
positionWithinCollection = addLocation.Add(elementReference);
}
else
{
addLocation.Insert(positionWithinCollection, elementReference);
}
returnedElement = elementReference;
/* if (childURI == XmlSchema.Namespace)
{
schemaList.Add(new ReplaceList(addLocation, positionWithinCollection));
}*/
}
}
InferElement(xse, bCreatingNewType, xs);
return returnedElement;
}
public XmlSchemaAnnotation()
{
items = new XmlSchemaObjectCollection();
}
private void PreprocessAttributes(XmlSchemaObjectCollection attributes, XmlSchemaAnyAttribute anyAttribute, XmlSchemaObject parent)
{
for (int i = 0; i < attributes.Count; i++)
{
this.SetParent(attributes[i], parent);
XmlSchemaAttribute attribute = attributes[i] as XmlSchemaAttribute;
if (attribute != null)
{
this.PreprocessLocalAttribute(attribute);
}
else
{
XmlSchemaAttributeGroupRef source = (XmlSchemaAttributeGroupRef) attributes[i];
if (source.RefName.IsEmpty)
{
base.SendValidationEvent("Sch_MissAttribute", "ref", source);
}
else
{
this.ValidateQNameAttribute(source, "ref", source.RefName);
}
this.PreprocessAnnotation(attributes[i]);
this.ValidateIdAttribute(attributes[i]);
}
}
if (anyAttribute != null)
{
try
{
this.SetParent(anyAttribute, parent);
this.PreprocessAnnotation(anyAttribute);
anyAttribute.BuildNamespaceList(this.targetNamespace);
}
catch (FormatException exception)
{
base.SendValidationEvent("Sch_InvalidAnyDetailed", new string[] { exception.Message }, exception, anyAttribute);
}
this.ValidateIdAttribute(anyAttribute);
}
}
/// <summary>Initializes a new instance of the <see cref="T:System.Xml.Schema.XmlSchemaSimpleTypeUnion" /> class.</summary>
public XmlSchemaSimpleTypeUnion()
{
this.baseTypes = new XmlSchemaObjectCollection();
}
