XmlSchemaType.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Xml / System / Xml / schema / XmlSchemaType.cs / 1305376 / 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 == null)
                    return null; 

                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
XmlSchemaType.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
