|
private Validate ( XmlReader reader, XmlResolver resolver, |
||
| reader | XmlReader | |
| resolver | XmlResolver | |
| schemaSet | ||
| valEventHandler | ValidationEventHandler | |
| return | XmlReader | |
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
if (IsValidated(schema.ValidationId))
{
return(errorCount);
}
if (baseType != null)
{
baseType.Validate(h, schema);
actualBaseSchemaType = baseType;
}
else if (baseTypeName != XmlQualifiedName.Empty)
{
XmlSchemaType st = schema.FindSchemaType(baseTypeName);
if (st != null)
{
st.Validate(h, schema);
actualBaseSchemaType = st;
}
else if (baseTypeName == XmlSchemaComplexType.AnyTypeName)
{
actualBaseSchemaType = XmlSchemaComplexType.AnyType;
}
else if (XmlSchemaUtil.IsBuiltInDatatypeName(baseTypeName))
{
actualBaseSchemaType = XmlSchemaDatatype.FromName(baseTypeName);
if (actualBaseSchemaType == null)
{
error(h, "Invalid schema datatype name is specified.");
}
}
// otherwise, it might be missing sub components.
else if (!schema.IsNamespaceAbsent(baseTypeName.Namespace))
{
error(h, "Referenced base schema type " + baseTypeName + " was not found in the corresponding schema.");
}
}
ValidationId = schema.ValidationId;
return(errorCount);
}
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
if (base.IsValidated(schema.ValidationId))
{
return(this.errorCount);
}
if (this.baseType != null)
{
this.baseType.Validate(h, schema);
this.actualBaseSchemaType = this.baseType;
}
else if (this.baseTypeName != XmlQualifiedName.Empty)
{
XmlSchemaType xmlSchemaType = schema.FindSchemaType(this.baseTypeName);
if (xmlSchemaType != null)
{
xmlSchemaType.Validate(h, schema);
this.actualBaseSchemaType = xmlSchemaType;
}
else if (this.baseTypeName == XmlSchemaComplexType.AnyTypeName)
{
this.actualBaseSchemaType = XmlSchemaComplexType.AnyType;
}
else if (XmlSchemaUtil.IsBuiltInDatatypeName(this.baseTypeName))
{
this.actualBaseSchemaType = XmlSchemaDatatype.FromName(this.baseTypeName);
if (this.actualBaseSchemaType == null)
{
base.error(h, "Invalid schema datatype name is specified.");
}
}
else if (!schema.IsNamespaceAbsent(this.baseTypeName.Namespace))
{
base.error(h, "Referenced base schema type " + this.baseTypeName + " was not found in the corresponding schema.");
}
}
this.ValidationId = schema.ValidationId;
return(this.errorCount);
}
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
if (IsValidated(schema.ValidationId))
{
return(errorCount);
}
ArrayList al = new ArrayList();
// Validate MemberTypes
if (MemberTypes != null)
{
foreach (XmlQualifiedName memberTypeName in MemberTypes)
{
object type = null;
XmlSchemaType xstype = schema.FindSchemaType(memberTypeName) as XmlSchemaSimpleType;
if (xstype != null)
{
errorCount += xstype.Validate(h, schema);
type = xstype;
}
else if (memberTypeName == XmlSchemaComplexType.AnyTypeName)
{
type = XmlSchemaSimpleType.AnySimpleType;
}
else if (memberTypeName.Namespace == XmlSchema.Namespace ||
memberTypeName.Namespace == XmlSchema.XdtNamespace)
{
type = XmlSchemaDatatype.FromName(memberTypeName);
if (type == null)
{
error(h, "Invalid schema type name was specified: " + memberTypeName);
}
}
// otherwise, it might be missing sub components.
else if (!schema.IsNamespaceAbsent(memberTypeName.Namespace))
{
error(h, "Referenced base schema type " + memberTypeName + " was not found in the corresponding schema.");
}
al.Add(type);
}
}
if (BaseTypes != null)
{
foreach (XmlSchemaSimpleType st in BaseTypes)
{
st.Validate(h, schema);
al.Add(st);
}
}
this.validatedTypes = al.ToArray();
if (validatedTypes != null)
{
validatedSchemaTypes = new XmlSchemaSimpleType [validatedTypes.Length];
for (int i = 0; i < validatedTypes.Length; i++)
{
object t = validatedTypes [i];
XmlSchemaSimpleType st = t as XmlSchemaSimpleType;
if (st == null && t != null)
{
st = XmlSchemaType.GetBuiltInSimpleType(((XmlSchemaDatatype)t).TypeCode);
}
validatedSchemaTypes [i] = st;
}
}
ValidationId = schema.ValidationId;
return(errorCount);
}
private XmlReader GetValidatingReader(XmlReader reader, XmlSchemaSet schemas, ValidationEventHandler validationEvent, XmlSchemaType schemaType, XmlSchemaElement schemaElement, XmlSchemaAttribute schemaAttribute)
{
if (schemaAttribute != null)
{
return schemaAttribute.Validate(reader, null, schemas, validationEvent);
}
if (schemaElement != null)
{
return schemaElement.Validate(reader, null, schemas, validationEvent);
}
if (schemaType != null)
{
return schemaType.Validate(reader, null, schemas, validationEvent);
}
XmlReaderSettings settings = new XmlReaderSettings {
ConformanceLevel = ConformanceLevel.Auto,
ValidationType = ValidationType.Schema,
Schemas = schemas
};
settings.ValidationEventHandler += validationEvent;
return XmlReader.Create(reader, settings);
}
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
if (base.IsValidated(schema.ValidationId))
{
return(this.errorCount);
}
if (this.SchemaType != null)
{
this.SchemaType.Validate(h, schema);
this.attributeType = this.SchemaType;
}
else if (this.SchemaTypeName != null && this.SchemaTypeName != XmlQualifiedName.Empty)
{
XmlSchemaType xmlSchemaType = schema.FindSchemaType(this.SchemaTypeName);
if (xmlSchemaType is XmlSchemaComplexType)
{
base.error(h, "An attribute can't have complexType Content");
}
else if (xmlSchemaType != null)
{
this.errorCount += xmlSchemaType.Validate(h, schema);
this.attributeType = xmlSchemaType;
}
else if (this.SchemaTypeName == XmlSchemaComplexType.AnyTypeName)
{
this.attributeType = XmlSchemaComplexType.AnyType;
}
else if (XmlSchemaUtil.IsBuiltInDatatypeName(this.SchemaTypeName))
{
this.attributeType = XmlSchemaDatatype.FromName(this.SchemaTypeName);
if (this.attributeType == null)
{
base.error(h, "Invalid xml schema namespace datatype was specified.");
}
}
else if (!schema.IsNamespaceAbsent(this.SchemaTypeName.Namespace))
{
base.error(h, "Referenced schema type " + this.SchemaTypeName + " was not found in the corresponding schema.");
}
}
if (this.RefName != null && this.RefName != XmlQualifiedName.Empty)
{
this.referencedAttribute = schema.FindAttribute(this.RefName);
if (this.referencedAttribute != null)
{
this.errorCount += this.referencedAttribute.Validate(h, schema);
}
else if (!schema.IsNamespaceAbsent(this.RefName.Namespace))
{
base.error(h, "Referenced attribute " + this.RefName + " was not found in the corresponding schema.");
}
}
if (this.attributeType == null)
{
this.attributeType = XmlSchemaSimpleType.AnySimpleType;
}
if (this.defaultValue != null || this.fixedValue != null)
{
XmlSchemaDatatype xmlSchemaDatatype = this.attributeType as XmlSchemaDatatype;
if (xmlSchemaDatatype == null)
{
xmlSchemaDatatype = ((XmlSchemaSimpleType)this.attributeType).Datatype;
}
if (xmlSchemaDatatype.TokenizedType == XmlTokenizedType.QName)
{
base.error(h, "By the defection of the W3C XML Schema specification, it is impossible to supply QName default or fixed values.");
}
else
{
try
{
if (this.defaultValue != null)
{
this.validatedDefaultValue = xmlSchemaDatatype.Normalize(this.defaultValue);
xmlSchemaDatatype.ParseValue(this.validatedDefaultValue, null, null);
}
}
catch (Exception innerException)
{
XmlSchemaObject.error(h, "The Attribute's default value is invalid with its type definition.", innerException);
}
try
{
if (this.fixedValue != null)
{
this.validatedFixedValue = xmlSchemaDatatype.Normalize(this.fixedValue);
this.validatedFixedTypedValue = xmlSchemaDatatype.ParseValue(this.validatedFixedValue, null, null);
}
}
catch (Exception innerException2)
{
XmlSchemaObject.error(h, "The Attribute's fixed value is invalid with its type definition.", innerException2);
}
}
}
if (this.Use == XmlSchemaUse.None)
{
this.validatedUse = XmlSchemaUse.Optional;
}
else
{
this.validatedUse = this.Use;
}
if (this.attributeType != null)
{
this.attributeSchemaType = (this.attributeType as XmlSchemaSimpleType);
if (this.attributeType == XmlSchemaSimpleType.AnySimpleType)
{
this.attributeSchemaType = XmlSchemaSimpleType.XsAnySimpleType;
}
if (this.attributeSchemaType == null)
{
this.attributeSchemaType = XmlSchemaType.GetBuiltInSimpleType(this.SchemaTypeName);
}
}
this.ValidationId = schema.ValidationId;
return(this.errorCount);
}
/// <summary>
/// Schema Component:
/// QName, SimpleType, Scope, Default|Fixed, annotation
/// </summary>
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
if (IsValidated(schema.ValidationId))
{
return(errorCount);
}
// -- Attribute Declaration Schema Component --
// {name}, {target namespace} -> QualifiedName. Already Compile()d.
// {type definition} -> attributeType. From SchemaType or SchemaTypeName.
// {scope} -> ParentIsSchema | isRedefineChild.
// {value constraint} -> ValidatedFixedValue, ValidatedDefaultValue.
// {annotation}
// -- Attribute Use Schema Component --
// {required}
// {attribute declaration}
// {value constraint}
// First, fill type information for type reference
if (SchemaType != null)
{
SchemaType.Validate(h, schema);
attributeType = SchemaType;
}
else if (SchemaTypeName != null && SchemaTypeName != XmlQualifiedName.Empty)
{
// If type is null, then it is missing sub components .
XmlSchemaType type = schema.FindSchemaType(SchemaTypeName);
if (type is XmlSchemaComplexType)
{
error(h, "An attribute can't have complexType Content");
}
else if (type != null) // simple type
{
errorCount += type.Validate(h, schema);
attributeType = type;
}
else if (SchemaTypeName == XmlSchemaComplexType.AnyTypeName)
{
attributeType = XmlSchemaComplexType.AnyType;
}
else if (XmlSchemaUtil.IsBuiltInDatatypeName(SchemaTypeName))
{
attributeType = XmlSchemaDatatype.FromName(SchemaTypeName);
if (attributeType == null)
{
error(h, "Invalid xml schema namespace datatype was specified.");
}
}
// otherwise, it might be missing sub components.
else if (!schema.IsNamespaceAbsent(SchemaTypeName.Namespace))
{
error(h, "Referenced schema type " + SchemaTypeName + " was not found in the corresponding schema.");
}
}
// Then, fill type information for the type references for the referencing attributes
if (RefName != null && RefName != XmlQualifiedName.Empty)
{
referencedAttribute = schema.FindAttribute(RefName);
// If el is null, then it is missing sub components .
if (referencedAttribute != null)
{
errorCount += referencedAttribute.Validate(h, schema);
}
// otherwise, it might be missing sub components.
else if (!schema.IsNamespaceAbsent(RefName.Namespace))
{
error(h, "Referenced attribute " + RefName + " was not found in the corresponding schema.");
}
}
if (attributeType == null)
{
attributeType = XmlSchemaSimpleType.AnySimpleType;
}
// Validate {value constraints}
if (defaultValue != null || fixedValue != null)
{
XmlSchemaDatatype datatype = attributeType as XmlSchemaDatatype;
if (datatype == null)
{
datatype = ((XmlSchemaSimpleType)attributeType).Datatype;
}
if (datatype.TokenizedType == XmlTokenizedType.QName)
{
error(h, "By the defection of the W3C XML Schema specification, it is impossible to supply QName default or fixed values.");
}
else
{
try {
if (defaultValue != null)
{
validatedDefaultValue = datatype.Normalize(defaultValue);
datatype.ParseValue(validatedDefaultValue, null, null);
}
} catch (Exception ex) {
// FIXME: This is not a good way to handle exception.
error(h, "The Attribute's default value is invalid with its type definition.", ex);
}
try {
if (fixedValue != null)
{
validatedFixedValue = datatype.Normalize(fixedValue);
validatedFixedTypedValue = datatype.ParseValue(validatedFixedValue, null, null);
}
} catch (Exception ex) {
// FIXME: This is not a good way to handle exception.
error(h, "The Attribute's fixed value is invalid with its type definition.", ex);
}
}
}
if (Use == XmlSchemaUse.None)
{
validatedUse = XmlSchemaUse.Optional;
}
else
{
validatedUse = Use;
}
#if NET_2_0
if (attributeType != null)
{
attributeSchemaType = attributeType as XmlSchemaSimpleType;
if (attributeType == XmlSchemaSimpleType.AnySimpleType)
{
attributeSchemaType = XmlSchemaSimpleType.XsAnySimpleType;
}
if (attributeSchemaType == null)
{
attributeSchemaType = XmlSchemaType.GetBuiltInSimpleType(SchemaTypeName);
}
}
#endif
ValidationId = schema.ValidationId;
return(errorCount);
}
private XmlReader GetValidatingReader( XmlReader reader, XmlSchemaSet schemas, ValidationEventHandler validationEvent, XmlSchemaType schemaType, XmlSchemaElement schemaElement, XmlSchemaAttribute schemaAttribute ) {
if (schemaAttribute != null) {
return schemaAttribute.Validate(reader, null, schemas, validationEvent);
}
else if (schemaElement != null) {
return schemaElement.Validate(reader, null, schemas, validationEvent);
}
else if (schemaType != null) {
return schemaType.Validate(reader, null, schemas, validationEvent);
}
Debug.Assert( schemas != null, "schemas != null" );
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.ConformanceLevel = ConformanceLevel.Auto;
readerSettings.ValidationType = ValidationType.Schema;
readerSettings.Schemas = schemas;
readerSettings.ValidationEventHandler += validationEvent;
return XmlReader.Create( reader, readerSettings );
}
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
if (base.IsValidated(schema.ValidationId))
{
return(this.errorCount);
}
ArrayList arrayList = new ArrayList();
if (this.MemberTypes != null)
{
foreach (XmlQualifiedName xmlQualifiedName in this.MemberTypes)
{
object obj = null;
XmlSchemaType xmlSchemaType = schema.FindSchemaType(xmlQualifiedName) as XmlSchemaSimpleType;
if (xmlSchemaType != null)
{
this.errorCount += xmlSchemaType.Validate(h, schema);
obj = xmlSchemaType;
}
else if (xmlQualifiedName == XmlSchemaComplexType.AnyTypeName)
{
obj = XmlSchemaSimpleType.AnySimpleType;
}
else if (xmlQualifiedName.Namespace == "http://www.w3.org/2001/XMLSchema" || xmlQualifiedName.Namespace == "http://www.w3.org/2003/11/xpath-datatypes")
{
obj = XmlSchemaDatatype.FromName(xmlQualifiedName);
if (obj == null)
{
base.error(h, "Invalid schema type name was specified: " + xmlQualifiedName);
}
}
else if (!schema.IsNamespaceAbsent(xmlQualifiedName.Namespace))
{
base.error(h, "Referenced base schema type " + xmlQualifiedName + " was not found in the corresponding schema.");
}
arrayList.Add(obj);
}
}
if (this.BaseTypes != null)
{
foreach (XmlSchemaObject xmlSchemaObject in this.BaseTypes)
{
XmlSchemaSimpleType xmlSchemaSimpleType = (XmlSchemaSimpleType)xmlSchemaObject;
xmlSchemaSimpleType.Validate(h, schema);
arrayList.Add(xmlSchemaSimpleType);
}
}
this.validatedTypes = arrayList.ToArray();
if (this.validatedTypes != null)
{
this.validatedSchemaTypes = new XmlSchemaSimpleType[this.validatedTypes.Length];
for (int j = 0; j < this.validatedTypes.Length; j++)
{
object obj2 = this.validatedTypes[j];
XmlSchemaSimpleType xmlSchemaSimpleType2 = obj2 as XmlSchemaSimpleType;
if (xmlSchemaSimpleType2 == null && obj2 != null)
{
xmlSchemaSimpleType2 = XmlSchemaType.GetBuiltInSimpleType(((XmlSchemaDatatype)obj2).TypeCode);
}
this.validatedSchemaTypes[j] = xmlSchemaSimpleType2;
}
}
this.ValidationId = schema.ValidationId;
return(this.errorCount);
}
