コード例 #1
0
        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);
        }
コード例 #2
0
        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);
        }
コード例 #3
0
        /// <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);
        }