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);
}
