XmlSchemaType.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / Xml / System / Xml / schema / XmlSchemaType.cs / 1 / XmlSchemaType.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
using System.Collections; 
using System.ComponentModel;
using System.Xml.Serialization; 

namespace System.Xml.Schema {

 
    /// 
    ///  
    ///    [To be supplied.] 
    /// 
    public class XmlSchemaType : XmlSchemaAnnotated { 
        string name;
        XmlSchemaDerivationMethod final = XmlSchemaDerivationMethod.None;
        XmlSchemaDerivationMethod derivedBy;
        XmlSchemaType baseSchemaType; 
        XmlSchemaDatatype datatype;
        XmlSchemaDerivationMethod finalResolved; 
        SchemaElementDecl elementDecl; 
        XmlQualifiedName qname = XmlQualifiedName.Empty;
        XmlSchemaType redefined; 

        //compiled information
        XmlSchemaContentType contentType;
 
        /// 
        ///  
        ///    [To be supplied.] 
        /// 
        public static XmlSchemaSimpleType GetBuiltInSimpleType(XmlQualifiedName qualifiedName) { 
            if (qualifiedName == null) {
                throw new ArgumentNullException("qualifiedName");
            }
            return DatatypeImplementation.GetSimpleTypeFromXsdType(qualifiedName); 
        }
 
        ///  
        /// 
        ///    [To be supplied.] 
        /// 
        public static XmlSchemaSimpleType GetBuiltInSimpleType(XmlTypeCode typeCode) {
            return DatatypeImplementation.GetSimpleTypeFromTypeCode(typeCode);
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        public static XmlSchemaComplexType GetBuiltInComplexType(XmlTypeCode typeCode) {
            if (typeCode == XmlTypeCode.Item) {
                return XmlSchemaComplexType.AnyType;
            } 
            return null;
        } 
 
        /// 
        ///  
        ///    [To be supplied.]
        /// 
        public static XmlSchemaComplexType GetBuiltInComplexType(XmlQualifiedName qualifiedName) {
            if (qualifiedName == null) { 
                throw new ArgumentNullException("qualifiedName");
            } 
            if (qualifiedName.Equals(XmlSchemaComplexType.AnyType.QualifiedName)) { 
                return XmlSchemaComplexType.AnyType;
            } 
            if (qualifiedName.Equals(XmlSchemaComplexType.UntypedAnyType.QualifiedName)) {
                return XmlSchemaComplexType.UntypedAnyType;
            }
            return null; 
        }
 
        ///  
        /// 
        ///    [To be supplied.] 
        /// 
        [XmlAttribute("name")]
        public string Name {
            get { return name; } 
            set { name = value; }
        } 
 
        /// 
        ///  
        ///    [To be supplied.]
        /// 
        [XmlAttribute("final"), DefaultValue(XmlSchemaDerivationMethod.None)]
        public XmlSchemaDerivationMethod Final { 
             get { return final; }
             set { final = value; } 
        } 

        ///  
        /// 
        ///    [To be supplied.]
        /// 
        [XmlIgnore] 
        public XmlQualifiedName QualifiedName {
            get { return qname; } 
        } 

        ///  
        /// 
        ///    [To be supplied.]
        /// 
        [XmlIgnore] 
        public XmlSchemaDerivationMethod FinalResolved {
             get { return finalResolved; } 
        } 

        ///  
        /// 
        ///    [To be supplied.]
        /// 
        [XmlIgnore] 
        [Obsolete("This property has been deprecated. Please use BaseXmlSchemaType property that returns a strongly typed base schema type. http://go.microsoft.com/fwlink/?linkid=14202")]
        public object BaseSchemaType { 
            get { 
                if (baseSchemaType.QualifiedName.Namespace == XmlReservedNs.NsXs) {
                    return baseSchemaType.Datatype; 
                }
                return baseSchemaType;
            }
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        [XmlIgnore]
        public XmlSchemaType BaseXmlSchemaType {
            get { return baseSchemaType;}
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        [XmlIgnore]
        public XmlSchemaDerivationMethod DerivedBy {
            get { return derivedBy; }
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        [XmlIgnore]
        public XmlSchemaDatatype Datatype {
            get { return datatype;}
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        [XmlIgnore]
        public virtual bool IsMixed {
            get { return false; }
            set {;} 
        }
 
        [XmlIgnore] 
        public XmlTypeCode TypeCode {
            get { 
                if (this == XmlSchemaComplexType.AnyType) {
                    return XmlTypeCode.Item;
                }
                if (datatype == null) { 
                    return XmlTypeCode.None;
                } 
                return datatype.TypeCode; 
            }
        } 

        [XmlIgnore]
        internal XmlValueConverter ValueConverter {
            get { 
                if (datatype == null) { //Default converter
                    return XmlUntypedConverter.Untyped; 
                } 
                return datatype.ValueConverter;
            } 
        }

        internal XmlReader Validate(XmlReader reader, XmlResolver resolver, XmlSchemaSet schemaSet, ValidationEventHandler valEventHandler) {
            if (schemaSet != null) { 
                XmlReaderSettings readerSettings = new XmlReaderSettings();
                readerSettings.ValidationType = ValidationType.Schema; 
                readerSettings.Schemas = schemaSet; 
                readerSettings.ValidationEventHandler += valEventHandler;
                return new XsdValidatingReader(reader, resolver, readerSettings, this); 
            }
            return null;
        }
 
        internal XmlSchemaContentType SchemaContentType {
            get { 
                return contentType; 
            }
        } 

        internal void SetQualifiedName(XmlQualifiedName value) {
            qname = value;
        } 

        internal void SetFinalResolved(XmlSchemaDerivationMethod value) { 
             finalResolved = value; 
        }
 
        internal void SetBaseSchemaType(XmlSchemaType value) {
            baseSchemaType = value;
        }
 
        internal void SetDerivedBy(XmlSchemaDerivationMethod value) {
            derivedBy = value; 
        } 

        internal void SetDatatype(XmlSchemaDatatype value) { 
            datatype = value;
        }

        internal SchemaElementDecl ElementDecl { 
            get { return elementDecl; }
            set { elementDecl = value; } 
        } 

        [XmlIgnore] 
        internal XmlSchemaType Redefined {
            get { return redefined; }
            set { redefined = value; }
        } 

        internal virtual XmlQualifiedName DerivedFrom { 
            get { return XmlQualifiedName.Empty; } 
        }
 
        internal void SetContentType(XmlSchemaContentType value) {
            contentType = value;
        }
 
        public static bool IsDerivedFrom(XmlSchemaType derivedType, XmlSchemaType baseType, XmlSchemaDerivationMethod except) {
            if (derivedType == null || baseType == null) { 
                return false; 
            }
 
            if (derivedType == baseType) {
                return true;
            }
 
            if (baseType == XmlSchemaComplexType.AnyType) { //Not checking for restriction blocked since all types are implicitly derived by restriction from xs:anyType
                return true; 
            } 
            do {
                XmlSchemaSimpleType dt = derivedType as XmlSchemaSimpleType; 
                XmlSchemaSimpleType bt = baseType as XmlSchemaSimpleType;
                if (bt != null && dt != null) { //SimpleTypes
                    if (bt == DatatypeImplementation.AnySimpleType) { //Not checking block=restriction
                        return true; 
                    }
                    if ((except & derivedType.DerivedBy) != 0 || !dt.Datatype.IsDerivedFrom(bt.Datatype)) { 
                        return false; 
                    }
                    return true; 
                }
                else { //Complex types
                    if ((except & derivedType.DerivedBy) != 0) {
                        return false; 
                    }
                    derivedType = derivedType.BaseXmlSchemaType; 
                    if (derivedType == baseType) { 
                        return true;
                    } 
                }

            } while(derivedType != null);
 
            return false;
        } 
 

        internal static bool IsDerivedFromDatatype(XmlSchemaDatatype derivedDataType, XmlSchemaDatatype baseDataType, XmlSchemaDerivationMethod except) { 
            if (DatatypeImplementation.AnySimpleType.Datatype == baseDataType) {
                return true;
            }
            return derivedDataType.IsDerivedFrom(baseDataType); 
        }
 
        [XmlIgnore] 
        internal override string NameAttribute {
            get { return Name; } 
            set { Name = value; }
        }
    }
 
}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
using System.Collections; 
using System.ComponentModel;
using System.Xml.Serialization; 

namespace System.Xml.Schema {

 
    /// 
    ///  
    ///    [To be supplied.] 
    /// 
    public class XmlSchemaType : XmlSchemaAnnotated { 
        string name;
        XmlSchemaDerivationMethod final = XmlSchemaDerivationMethod.None;
        XmlSchemaDerivationMethod derivedBy;
        XmlSchemaType baseSchemaType; 
        XmlSchemaDatatype datatype;
        XmlSchemaDerivationMethod finalResolved; 
        SchemaElementDecl elementDecl; 
        XmlQualifiedName qname = XmlQualifiedName.Empty;
        XmlSchemaType redefined; 

        //compiled information
        XmlSchemaContentType contentType;
 
        /// 
        ///  
        ///    [To be supplied.] 
        /// 
        public static XmlSchemaSimpleType GetBuiltInSimpleType(XmlQualifiedName qualifiedName) { 
            if (qualifiedName == null) {
                throw new ArgumentNullException("qualifiedName");
            }
            return DatatypeImplementation.GetSimpleTypeFromXsdType(qualifiedName); 
        }
 
        ///  
        /// 
        ///    [To be supplied.] 
        /// 
        public static XmlSchemaSimpleType GetBuiltInSimpleType(XmlTypeCode typeCode) {
            return DatatypeImplementation.GetSimpleTypeFromTypeCode(typeCode);
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        public static XmlSchemaComplexType GetBuiltInComplexType(XmlTypeCode typeCode) {
            if (typeCode == XmlTypeCode.Item) {
                return XmlSchemaComplexType.AnyType;
            } 
            return null;
        } 
 
        /// 
        ///  
        ///    [To be supplied.]
        /// 
        public static XmlSchemaComplexType GetBuiltInComplexType(XmlQualifiedName qualifiedName) {
            if (qualifiedName == null) { 
                throw new ArgumentNullException("qualifiedName");
            } 
            if (qualifiedName.Equals(XmlSchemaComplexType.AnyType.QualifiedName)) { 
                return XmlSchemaComplexType.AnyType;
            } 
            if (qualifiedName.Equals(XmlSchemaComplexType.UntypedAnyType.QualifiedName)) {
                return XmlSchemaComplexType.UntypedAnyType;
            }
            return null; 
        }
 
        ///  
        /// 
        ///    [To be supplied.] 
        /// 
        [XmlAttribute("name")]
        public string Name {
            get { return name; } 
            set { name = value; }
        } 
 
        /// 
        ///  
        ///    [To be supplied.]
        /// 
        [XmlAttribute("final"), DefaultValue(XmlSchemaDerivationMethod.None)]
        public XmlSchemaDerivationMethod Final { 
             get { return final; }
             set { final = value; } 
        } 

        ///  
        /// 
        ///    [To be supplied.]
        /// 
        [XmlIgnore] 
        public XmlQualifiedName QualifiedName {
            get { return qname; } 
        } 

        ///  
        /// 
        ///    [To be supplied.]
        /// 
        [XmlIgnore] 
        public XmlSchemaDerivationMethod FinalResolved {
             get { return finalResolved; } 
        } 

        ///  
        /// 
        ///    [To be supplied.]
        /// 
        [XmlIgnore] 
        [Obsolete("This property has been deprecated. Please use BaseXmlSchemaType property that returns a strongly typed base schema type. http://go.microsoft.com/fwlink/?linkid=14202")]
        public object BaseSchemaType { 
            get { 
                if (baseSchemaType.QualifiedName.Namespace == XmlReservedNs.NsXs) {
                    return baseSchemaType.Datatype; 
                }
                return baseSchemaType;
            }
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        [XmlIgnore]
        public XmlSchemaType BaseXmlSchemaType {
            get { return baseSchemaType;}
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        [XmlIgnore]
        public XmlSchemaDerivationMethod DerivedBy {
            get { return derivedBy; }
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        [XmlIgnore]
        public XmlSchemaDatatype Datatype {
            get { return datatype;}
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        [XmlIgnore]
        public virtual bool IsMixed {
            get { return false; }
            set {;} 
        }
 
        [XmlIgnore] 
        public XmlTypeCode TypeCode {
            get { 
                if (this == XmlSchemaComplexType.AnyType) {
                    return XmlTypeCode.Item;
                }
                if (datatype == null) { 
                    return XmlTypeCode.None;
                } 
                return datatype.TypeCode; 
            }
        } 

        [XmlIgnore]
        internal XmlValueConverter ValueConverter {
            get { 
                if (datatype == null) { //Default converter
                    return XmlUntypedConverter.Untyped; 
                } 
                return datatype.ValueConverter;
            } 
        }

        internal XmlReader Validate(XmlReader reader, XmlResolver resolver, XmlSchemaSet schemaSet, ValidationEventHandler valEventHandler) {
            if (schemaSet != null) { 
                XmlReaderSettings readerSettings = new XmlReaderSettings();
                readerSettings.ValidationType = ValidationType.Schema; 
                readerSettings.Schemas = schemaSet; 
                readerSettings.ValidationEventHandler += valEventHandler;
                return new XsdValidatingReader(reader, resolver, readerSettings, this); 
            }
            return null;
        }
 
        internal XmlSchemaContentType SchemaContentType {
            get { 
                return contentType; 
            }
        } 

        internal void SetQualifiedName(XmlQualifiedName value) {
            qname = value;
        } 

        internal void SetFinalResolved(XmlSchemaDerivationMethod value) { 
             finalResolved = value; 
        }
 
        internal void SetBaseSchemaType(XmlSchemaType value) {
            baseSchemaType = value;
        }
 
        internal void SetDerivedBy(XmlSchemaDerivationMethod value) {
            derivedBy = value; 
        } 

        internal void SetDatatype(XmlSchemaDatatype value) { 
            datatype = value;
        }

        internal SchemaElementDecl ElementDecl { 
            get { return elementDecl; }
            set { elementDecl = value; } 
        } 

        [XmlIgnore] 
        internal XmlSchemaType Redefined {
            get { return redefined; }
            set { redefined = value; }
        } 

        internal virtual XmlQualifiedName DerivedFrom { 
            get { return XmlQualifiedName.Empty; } 
        }
 
        internal void SetContentType(XmlSchemaContentType value) {
            contentType = value;
        }
 
        public static bool IsDerivedFrom(XmlSchemaType derivedType, XmlSchemaType baseType, XmlSchemaDerivationMethod except) {
            if (derivedType == null || baseType == null) { 
                return false; 
            }
 
            if (derivedType == baseType) {
                return true;
            }
 
            if (baseType == XmlSchemaComplexType.AnyType) { //Not checking for restriction blocked since all types are implicitly derived by restriction from xs:anyType
                return true; 
            } 
            do {
                XmlSchemaSimpleType dt = derivedType as XmlSchemaSimpleType; 
                XmlSchemaSimpleType bt = baseType as XmlSchemaSimpleType;
                if (bt != null && dt != null) { //SimpleTypes
                    if (bt == DatatypeImplementation.AnySimpleType) { //Not checking block=restriction
                        return true; 
                    }
                    if ((except & derivedType.DerivedBy) != 0 || !dt.Datatype.IsDerivedFrom(bt.Datatype)) { 
                        return false; 
                    }
                    return true; 
                }
                else { //Complex types
                    if ((except & derivedType.DerivedBy) != 0) {
                        return false; 
                    }
                    derivedType = derivedType.BaseXmlSchemaType; 
                    if (derivedType == baseType) { 
                        return true;
                    } 
                }

            } while(derivedType != null);
 
            return false;
        } 
 

        internal static bool IsDerivedFromDatatype(XmlSchemaDatatype derivedDataType, XmlSchemaDatatype baseDataType, XmlSchemaDerivationMethod except) { 
            if (DatatypeImplementation.AnySimpleType.Datatype == baseDataType) {
                return true;
            }
            return derivedDataType.IsDerivedFrom(baseDataType); 
        }
 
        [XmlIgnore] 
        internal override string NameAttribute {
            get { return Name; } 
            set { Name = value; }
        }
    }
 
}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK