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