|
public static GetBuiltInSimpleType ( XmlQualifiedName qualifiedName ) : |
||
| qualifiedName | XmlQualifiedName | |
| Résultat | ||
private QName InferMergedType(string value, QName typeName)
{
// examine value against specified type and
// if unacceptable, then return a relaxed type.
SimpleType st = XmlSchemaType.GetBuiltInSimpleType(
typeName);
if (st == null) // non-primitive type => see above.
{
return(QNameString);
}
do
{
try {
st.Datatype.ParseValue(value,
source.NameTable,
source as IXmlNamespaceResolver);
return(typeName);
} catch {
st = st.BaseXmlSchemaType as XmlSchemaSimpleType;
typeName = st != null ? st.QualifiedName : QName.Empty;
}
} while (typeName != QName.Empty);
return(QNameString);
}
internal static XmlSchemaType GetBuiltInType(XmlTypeCode typecode)
{
if (typecode == XmlTypeCode.Item)
{
return(XmlSchemaComplexType.AnyType);
}
return(XmlSchemaType.GetBuiltInSimpleType(typecode));
}
internal static XmlSchemaType GetBuiltInType(XmlQualifiedName qualifiedName)
{
XmlSchemaType xmlSchemaType = XmlSchemaType.GetBuiltInSimpleType(qualifiedName);
if (xmlSchemaType == null)
{
xmlSchemaType = XmlSchemaType.GetBuiltInComplexType(qualifiedName);
}
return(xmlSchemaType);
}
private static XmlSchemaSimpleType BuildSchemaType(string name, string baseName, bool xdt, bool baseXdt)
{
string ns = xdt ? "http://www.w3.org/2003/11/xpath-datatypes" : XmlSchema.Namespace;
string ns2 = baseXdt ? "http://www.w3.org/2003/11/xpath-datatypes" : XmlSchema.Namespace;
XmlSchemaSimpleType st = new XmlSchemaSimpleType();
st.QNameInternal = new XmlQualifiedName(name, ns);
if (baseName != null)
{
st.BaseXmlSchemaTypeInternal = XmlSchemaType.GetBuiltInSimpleType(new XmlQualifiedName(baseName, ns2));
}
st.DatatypeInternal = XmlSchemaDatatype.FromName(st.QualifiedName);
return(st);
}
private SimpleType MakeBaseTypeAsEmptiable(SimpleType st)
{
switch (st.QualifiedName.Namespace)
{
case XmlSchema.Namespace:
case XdtNamespace:
// If a primitive type
return(XmlSchemaType.GetBuiltInSimpleType(
XmlTypeCode.String));
}
SimpleTypeRst str = st.Content as SimpleTypeRst;
if (str != null)
{
ArrayList al = null;
foreach (SchemaFacet f in str.Facets)
{
if (f is LengthFacet ||
f is MinLengthFacet)
{
if (al == null)
{
al = new ArrayList();
}
al.Add(f);
}
}
foreach (SchemaFacet f in al)
{
str.Facets.Remove(f);
}
if (str.BaseType != null)
{
str.BaseType =
MakeBaseTypeAsEmptiable(st);
}
else
{
// It might have a reference to an
// external simple type, but there is
// no assurance that any of those
// external types allow an empty
// string. So just set base type as
// xs:string.
str.BaseTypeName = QNameString;
}
} // union/list can have empty string value.
return(st);
}
private static XmlSchemaSimpleType BuildSchemaType(string name, string baseName, bool xdt, bool baseXdt)
{
string ns = (!xdt) ? "http://www.w3.org/2001/XMLSchema" : "http://www.w3.org/2003/11/xpath-datatypes";
string ns2 = (!baseXdt) ? "http://www.w3.org/2001/XMLSchema" : "http://www.w3.org/2003/11/xpath-datatypes";
XmlSchemaSimpleType xmlSchemaSimpleType = new XmlSchemaSimpleType();
xmlSchemaSimpleType.QNameInternal = new XmlQualifiedName(name, ns);
if (baseName != null)
{
xmlSchemaSimpleType.BaseXmlSchemaTypeInternal = XmlSchemaType.GetBuiltInSimpleType(new XmlQualifiedName(baseName, ns2));
}
xmlSchemaSimpleType.DatatypeInternal = XmlSchemaDatatype.FromName(xmlSchemaSimpleType.QualifiedName);
return(xmlSchemaSimpleType);
}
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
if (IsValidated(schema.ValidationId))
{
return(errorCount);
}
// ListItemType
XmlSchemaSimpleType type = itemType;
if (type == null)
{
type = schema.FindSchemaType(itemTypeName) as XmlSchemaSimpleType;
}
if (type != null)
{
errorCount += type.Validate(h, schema);
validatedListItemType = type;
}
else if (itemTypeName == XmlSchemaComplexType.AnyTypeName)
{
validatedListItemType = XmlSchemaSimpleType.AnySimpleType;
}
else if (XmlSchemaUtil.IsBuiltInDatatypeName(itemTypeName))
{
validatedListItemType = XmlSchemaDatatype.FromName(itemTypeName);
if (validatedListItemType == null)
{
error(h, "Invalid schema type name was specified: " + itemTypeName);
}
}
// otherwise, it might be missing sub components.
else if (!schema.IsNamespaceAbsent(itemTypeName.Namespace))
{
error(h, "Referenced base list item schema type " + itemTypeName + " was not found.");
}
#if NET_2_0
XmlSchemaSimpleType st = validatedListItemType as XmlSchemaSimpleType;
if (st == null && validatedListItemType != null)
{
st = XmlSchemaType.GetBuiltInSimpleType(((XmlSchemaDatatype)validatedListItemType).TypeCode);
}
validatedListItemSchemaType = st;
#endif
ValidationId = schema.ValidationId;
return(errorCount);
}
protected XmlBaseConverter(XmlSchemaType schemaType)
{
XmlSchemaDatatype datatype = schemaType.Datatype;
while ((schemaType != null) && !(schemaType is XmlSchemaSimpleType))
{
schemaType = schemaType.BaseXmlSchemaType;
}
if (schemaType == null)
{
schemaType = XmlSchemaType.GetBuiltInSimpleType(datatype.TypeCode);
}
this.schemaType = schemaType;
this.typeCode = schemaType.TypeCode;
this.clrTypeDefault = schemaType.Datatype.ValueType;
}
public override object ChangeType(double value, Type destinationType)
{
if (destinationType == null)
{
throw new ArgumentNullException("destinationType");
}
if (destinationType == XmlBaseConverter.ObjectType)
{
destinationType = base.DefaultClrType;
}
if (destinationType == XmlBaseConverter.XmlAtomicValueType)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Double), value));
}
return(this.ChangeTypeWildcardSource(value, destinationType, null));
}
internal static XmlSchemaSimpleType GetBuiltInSimpleType(XmlSchemaDatatype type)
{
if (type is XsdEntities)
{
return(XmlSchemaSimpleType.XsEntities);
}
if (type is XsdNMTokens)
{
return(XmlSchemaSimpleType.XsNMTokens);
}
if (type is XsdIDRefs)
{
return(XmlSchemaSimpleType.XsIDRefs);
}
return(XmlSchemaType.GetBuiltInSimpleType(type.TypeCode));
}
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
if (base.IsValidated(schema.ValidationId))
{
return(this.errorCount);
}
XmlSchemaSimpleType xmlSchemaSimpleType = this.itemType;
if (xmlSchemaSimpleType == null)
{
xmlSchemaSimpleType = (schema.FindSchemaType(this.itemTypeName) as XmlSchemaSimpleType);
}
if (xmlSchemaSimpleType != null)
{
this.errorCount += xmlSchemaSimpleType.Validate(h, schema);
this.validatedListItemType = xmlSchemaSimpleType;
}
else if (this.itemTypeName == XmlSchemaComplexType.AnyTypeName)
{
this.validatedListItemType = XmlSchemaSimpleType.AnySimpleType;
}
else if (XmlSchemaUtil.IsBuiltInDatatypeName(this.itemTypeName))
{
this.validatedListItemType = XmlSchemaDatatype.FromName(this.itemTypeName);
if (this.validatedListItemType == null)
{
base.error(h, "Invalid schema type name was specified: " + this.itemTypeName);
}
}
else if (!schema.IsNamespaceAbsent(this.itemTypeName.Namespace))
{
base.error(h, "Referenced base list item schema type " + this.itemTypeName + " was not found.");
}
XmlSchemaSimpleType xmlSchemaSimpleType2 = this.validatedListItemType as XmlSchemaSimpleType;
if (xmlSchemaSimpleType2 == null && this.validatedListItemType != null)
{
xmlSchemaSimpleType2 = XmlSchemaType.GetBuiltInSimpleType(((XmlSchemaDatatype)this.validatedListItemType).TypeCode);
}
this.validatedListItemSchemaType = xmlSchemaSimpleType2;
this.ValidationId = schema.ValidationId;
return(this.errorCount);
}
private ComplexType ToComplexType(Element el)
{
QName name = el.SchemaTypeName;
XmlSchemaType type = el.SchemaType;
// 1. element type is complex.
ComplexType ct = type as ComplexType;
if (ct != null)
{
return(ct);
}
// 2. reference to global complexType.
XmlSchemaType globalType = schemas.GlobalTypes [name]
as XmlSchemaType;
ct = globalType as ComplexType;
if (ct != null)
{
return(ct);
}
ct = new ComplexType();
el.SchemaType = ct;
el.SchemaTypeName = QName.Empty;
// 3. base type name is xs:anyType or no specification.
// <xs:complexType />
if (name == QNameAnyType)
{
return(ct);
}
else if (type == null && name == QName.Empty)
{
return(ct);
}
SimpleModel sc = new SimpleModel();
ct.ContentModel = sc;
// 4. type is simpleType
// -> extension of existing simple type.
SimpleType st = type as SimpleType;
if (st != null)
{
SimpleRst scr = new SimpleRst();
scr.BaseType = st;
sc.Content = scr;
return(ct);
}
SimpleExt sce = new SimpleExt();
sc.Content = sce;
// 5. type name points to primitive type
// -> simple extension of a primitive type
st = XmlSchemaType.GetBuiltInSimpleType(name);
if (st != null)
{
sce.BaseTypeName = name;
return(ct);
}
// 6. type name points to global simpleType.
st = globalType as SimpleType;
if (st != null)
{
sce.BaseTypeName = name;
return(ct);
}
throw Error(el, "Unexpected schema component that contains simpleTypeName that could not be resolved.");
}
/// <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);
}
public override object ChangeType(object value, Type destinationType, IXmlNamespaceResolver nsResolver)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (destinationType == null)
{
throw new ArgumentNullException("destinationType");
}
Type derivedType = value.GetType();
if (destinationType == XmlBaseConverter.ObjectType)
{
destinationType = base.DefaultClrType;
}
if ((destinationType == XmlBaseConverter.BooleanType) && (derivedType == XmlBaseConverter.XmlAtomicValueType))
{
return(((XmlAtomicValue)value).ValueAsBoolean);
}
if ((destinationType == XmlBaseConverter.DateTimeType) && (derivedType == XmlBaseConverter.XmlAtomicValueType))
{
return(((XmlAtomicValue)value).ValueAsDateTime);
}
if ((destinationType == XmlBaseConverter.DateTimeOffsetType) && (derivedType == XmlBaseConverter.XmlAtomicValueType))
{
return(((XmlAtomicValue)value).ValueAs(XmlBaseConverter.DateTimeOffsetType));
}
if ((destinationType == XmlBaseConverter.DecimalType) && (derivedType == XmlBaseConverter.XmlAtomicValueType))
{
return((decimal)((XmlAtomicValue)value).ValueAs(XmlBaseConverter.DecimalType));
}
if ((destinationType == XmlBaseConverter.DoubleType) && (derivedType == XmlBaseConverter.XmlAtomicValueType))
{
return(((XmlAtomicValue)value).ValueAsDouble);
}
if ((destinationType == XmlBaseConverter.Int32Type) && (derivedType == XmlBaseConverter.XmlAtomicValueType))
{
return(((XmlAtomicValue)value).ValueAsInt);
}
if ((destinationType == XmlBaseConverter.Int64Type) && (derivedType == XmlBaseConverter.XmlAtomicValueType))
{
return(((XmlAtomicValue)value).ValueAsLong);
}
if ((destinationType == XmlBaseConverter.SingleType) && (derivedType == XmlBaseConverter.XmlAtomicValueType))
{
return((float)((XmlAtomicValue)value).ValueAs(XmlBaseConverter.SingleType));
}
if (destinationType == XmlBaseConverter.XmlAtomicValueType)
{
if (derivedType == XmlBaseConverter.XmlAtomicValueType)
{
return((XmlAtomicValue)value);
}
if (derivedType == XmlBaseConverter.BooleanType)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean), (bool)value));
}
if (derivedType == XmlBaseConverter.ByteType)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.UnsignedByte), value));
}
if (derivedType == XmlBaseConverter.ByteArrayType)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Base64Binary), value));
}
if (derivedType == XmlBaseConverter.DateTimeType)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.DateTime), (DateTime)value));
}
if (derivedType == XmlBaseConverter.DateTimeOffsetType)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.DateTime), (DateTimeOffset)value));
}
if (derivedType == XmlBaseConverter.DecimalType)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Decimal), value));
}
if (derivedType == XmlBaseConverter.DoubleType)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Double), (double)value));
}
if (derivedType == XmlBaseConverter.Int16Type)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Short), value));
}
if (derivedType == XmlBaseConverter.Int32Type)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int), (int)value));
}
if (derivedType == XmlBaseConverter.Int64Type)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Long), (long)value));
}
if (derivedType == XmlBaseConverter.SByteType)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Byte), value));
}
if (derivedType == XmlBaseConverter.SingleType)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Float), value));
}
if (derivedType == XmlBaseConverter.StringType)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String), (string)value));
}
if (derivedType == XmlBaseConverter.TimeSpanType)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Duration), value));
}
if (derivedType == XmlBaseConverter.UInt16Type)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.UnsignedShort), value));
}
if (derivedType == XmlBaseConverter.UInt32Type)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.UnsignedInt), value));
}
if (derivedType == XmlBaseConverter.UInt64Type)
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.UnsignedLong), value));
}
if (XmlBaseConverter.IsDerivedFrom(derivedType, XmlBaseConverter.UriType))
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.AnyUri), value));
}
if (XmlBaseConverter.IsDerivedFrom(derivedType, XmlBaseConverter.XmlQualifiedNameType))
{
return(new XmlAtomicValue(XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.QName), value, nsResolver));
}
}
if (destinationType == XmlBaseConverter.XPathItemType)
{
if (derivedType == XmlBaseConverter.XmlAtomicValueType)
{
return((XmlAtomicValue)value);
}
if (XmlBaseConverter.IsDerivedFrom(derivedType, XmlBaseConverter.XPathNavigatorType))
{
return((XPathNavigator)value);
}
}
if ((destinationType == XmlBaseConverter.XPathNavigatorType) && XmlBaseConverter.IsDerivedFrom(derivedType, XmlBaseConverter.XPathNavigatorType))
{
return(this.ToNavigator((XPathNavigator)value));
}
if (destinationType == XmlBaseConverter.XPathItemType)
{
return((XPathItem)this.ChangeType(value, XmlBaseConverter.XmlAtomicValueType, nsResolver));
}
if (derivedType == XmlBaseConverter.XmlAtomicValueType)
{
return(((XmlAtomicValue)value).ValueAs(destinationType, nsResolver));
}
return(this.ChangeListType(value, destinationType, nsResolver));
}
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);
}
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);
}
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);
}
