public XmlSchemaRedefine()
{
attributeGroups = new XmlSchemaObjectTable();
groups = new XmlSchemaObjectTable();
items = new XmlSchemaObjectCollection(this);
schemaTypes = new XmlSchemaObjectTable();
}
internal override void ValidateUniqueParticleAttribution(XmlSchemaObjectTable qnames, ArrayList nsNames,
ValidationEventHandler h, XmlSchema schema)
{
foreach (XmlSchemaParticle p in this.Items)
{
p.ValidateUniqueParticleAttribution(qnames, nsNames, h, schema);
}
}
internal override void ValidateUniqueTypeAttribution(XmlSchemaObjectTable labels,
ValidationEventHandler h, XmlSchema schema)
{
if (TargetGroup != null)
{
TargetGroup.Particle.ValidateUniqueTypeAttribution(labels, h, schema);
}
}
internal override void ValidateUniqueParticleAttribution(XmlSchemaObjectTable qnames, ArrayList nsNames,
ValidationEventHandler h, XmlSchema schema)
{
if (TargetGroup != null)
{
TargetGroup.Particle.ValidateUniqueParticleAttribution(qnames, nsNames, h, schema);
}
}
internal override void ValidateUniqueTypeAttribution(XmlSchemaObjectTable labels,
ValidationEventHandler h, XmlSchema schema)
{
foreach (XmlSchemaParticle p in this.Items)
{
p.ValidateUniqueTypeAttribution(labels, h, schema);
}
}
void ValidateUPAOnHeadingOptionalComponents(XmlSchemaObjectTable qnames, ArrayList nsNames,
ValidationEventHandler h, XmlSchema schema)
{
// heading optional components
foreach (XmlSchemaParticle p in this.Items)
{
p.ValidateUniqueParticleAttribution(qnames, nsNames, h, schema);
if (p.ValidatedMinOccurs != 0)
{
break;
}
}
}
internal override void ValidateUniqueParticleAttribution(
XmlSchemaObjectTable qnames, ArrayList nsNames,
ValidationEventHandler h, XmlSchema schema)
{
// Wildcard Intersection check.
foreach (XmlSchemaAny other in nsNames)
{
if (!ExamineAttributeWildcardIntersection(other, h, schema))
{
error(h, "Ambiguous -any- particle was found.");
}
}
nsNames.Add(this);
}
public static void AddToTable(XmlSchemaObjectTable table, XmlSchemaObject obj,
XmlQualifiedName qname, ValidationEventHandler h)
{
if (table.Contains(qname))
{
// FIXME: This logic unexpectedly allows
// one redefining item and two or more redefining items.
// FIXME: redefining item is not simple replacement,
// but much more complex stuff.
if (obj.isRedefineChild) // take precedence.
{
if (obj.redefinedObject != null)
{
obj.error(h, String.Format("Named item {0} was already contained in the schema object table.", qname));
}
else
{
obj.redefinedObject = table [qname];
}
table.Set(qname, obj);
}
else if (table [qname].isRedefineChild)
{
if (table [qname].redefinedObject != null)
{
obj.error(h, String.Format("Named item {0} was already contained in the schema object table.", qname));
}
else
{
table [qname].redefinedObject = obj;
}
return; // never add to the table.
}
else if (StrictMsCompliant)
{
table.Set(qname, obj);
}
else
{
obj.error(h, String.Format("Named item {0} was already contained in the schema object table. {1}",
qname, "Consider setting MONO_STRICT_MS_COMPLIANT to 'yes' to mimic MS implementation."));
}
}
else
{
table.Set(qname, obj);
}
}
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();
named_identities = new XmlSchemaObjectTable();
ids = new Hashtable();
compilationItems = new XmlSchemaObjectCollection();
}
void ValidateUPAOnItems(XmlSchemaObjectTable qnames, ArrayList nsNames,
ValidationEventHandler h, XmlSchema schema)
{
// non-optional components
XmlSchemaObjectTable elems = new XmlSchemaObjectTable();
ArrayList wildcards = new ArrayList();
XmlSchemaObjectTable tmpElems = new XmlSchemaObjectTable();
ArrayList tmpWildcards = new ArrayList();
for (int i = 0; i < Items.Count; i++)
{
XmlSchemaParticle p1 = Items [i] as XmlSchemaParticle;
p1.ValidateUniqueParticleAttribution(elems, wildcards, h, schema);
if (p1.ValidatedMinOccurs == p1.ValidatedMaxOccurs)
{
elems.Clear();
wildcards.Clear();
}
else
{
if (p1.ValidatedMinOccurs != 0)
{
foreach (XmlQualifiedName n in tmpElems.Names)
{
elems.Set(n, null); // remove
}
foreach (object o in tmpWildcards)
{
wildcards.Remove(o);
}
}
foreach (XmlQualifiedName n in elems.Names)
{
tmpElems.Set(n, elems [n]);
}
tmpWildcards.Clear();
tmpWildcards.AddRange(wildcards);
}
}
}
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
if (IsValidated(schema.CompilationId))
{
return(errorCount);
}
if (redefined == null && redefinedObject != null)
{
redefinedObject.Compile(h, schema);
redefined = (XmlSchemaAttributeGroup)redefinedObject;
redefined.Validate(h, schema);
}
XmlSchemaObjectCollection actualAttributes = null;
/*
* if (this.redefined != null) {
* actualAttributes = new XmlSchemaObjectCollection ();
* foreach (XmlSchemaObject obj in Attributes) {
* XmlSchemaAttributeGroupRef grp = obj as XmlSchemaAttributeGroupRef;
* if (grp != null && grp.QualifiedName == this.QualifiedName)
* actualAttributes.Add (redefined);
* else
* actualAttributes.Add (obj);
* }
* }
* else
*/
actualAttributes = Attributes;
attributeUses = new XmlSchemaObjectTable();
errorCount += XmlSchemaUtil.ValidateAttributesResolved(attributeUses,
h, schema, actualAttributes, AnyAttribute,
ref anyAttributeUse, redefined, false);
ValidationId = schema.ValidationId;
return(errorCount);
}
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 (StrictMsCompliant && attr.Use == XmlSchemaUse.Prohibited)
{
continue;
}
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 (StrictMsCompliant && attr.Use == XmlSchemaUse.Prohibited)
{
continue;
}
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);
}
internal override void ValidateUniqueTypeAttribution(XmlSchemaObjectTable labels,
ValidationEventHandler h, XmlSchema schema)
{
// do nothing
}
internal override void ValidateUniqueParticleAttribution(XmlSchemaObjectTable qnames,
ArrayList nsNames, ValidationEventHandler h, XmlSchema schema)
{
// do nothing
}
internal virtual void ValidateUniqueTypeAttribution(XmlSchemaObjectTable labels,
ValidationEventHandler h, XmlSchema schema)
{
}
internal XmlSchemaObjectTableEnumerator(XmlSchemaObjectTable table)
{
tmp = (IEnumerable)table.table;
xenum = (IDictionaryEnumerator)tmp.GetEnumerator();
}
internal virtual void ValidateUniqueParticleAttribution(
XmlSchemaObjectTable qnames, ArrayList nsNames,
ValidationEventHandler h, XmlSchema schema)
{
}
internal override void ValidateUniqueParticleAttribution(XmlSchemaObjectTable qnames, ArrayList nsNames,
ValidationEventHandler h, XmlSchema schema)
{
ValidateUPAOnHeadingOptionalComponents(qnames, nsNames, h, schema);
ValidateUPAOnItems(qnames, nsNames, h, schema);
}
