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 (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 NET_2_0
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;
}
}
#endif
ValidationId = schema.ValidationId;
return(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);
}