DatatypeImplementation.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / Xml / System / Xml / schema / DatatypeImplementation.cs / 1 / DatatypeImplementation.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
namespace System.Xml.Schema { 

    using System; 
    using System.IO;
    using System.Collections;
    using System.Diagnostics;
    using System.Globalization; 
    using System.Text;
    using System.Text.RegularExpressions; 
    using System.Xml; 
    using System.Xml.XPath;
    using System.Xml.Serialization; 

    /// 
    public enum XmlSchemaDatatypeVariety {
        ///  
        Atomic,
        ///  
        List, 
        /// 
        Union 
    }

    internal class XsdSimpleValue { //Wrapper to store XmlType and TypedValue together
        XmlSchemaSimpleType xmlType; 
        object  typedValue;
 
        public XsdSimpleValue(XmlSchemaSimpleType st, object value) { 
            xmlType = st;
            typedValue = value; 
        }

        public XmlSchemaSimpleType XmlType {
            get { 
                return xmlType;
            } 
        } 

        public object TypedValue { 
            get {
                return typedValue;
            }
        } 
    }
 
 
    [Flags]
    internal enum RestrictionFlags { 
        Length              = 0x0001,
        MinLength           = 0x0002,
        MaxLength           = 0x0004,
        Pattern             = 0x0008, 
        Enumeration         = 0x0010,
        WhiteSpace          = 0x0020, 
        MaxInclusive        = 0x0040, 
        MaxExclusive        = 0x0080,
        MinInclusive        = 0x0100, 
        MinExclusive        = 0x0200,
        TotalDigits         = 0x0400,
        FractionDigits      = 0x0800,
    } 

    internal enum XmlSchemaWhiteSpace { 
        Preserve, 
        Replace,
        Collapse, 
    }

    internal class RestrictionFacets {
        internal int Length; 
        internal int MinLength;
        internal int MaxLength; 
        internal ArrayList Patterns; 
        internal ArrayList Enumeration;
        internal XmlSchemaWhiteSpace WhiteSpace; 
        internal object MaxInclusive;
        internal object MaxExclusive;
        internal object MinInclusive;
        internal object MinExclusive; 
        internal int TotalDigits;
        internal int FractionDigits; 
        internal RestrictionFlags Flags = 0; 
        internal RestrictionFlags FixedFlags = 0;
    } 

    internal abstract class DatatypeImplementation : XmlSchemaDatatype {
        private XmlSchemaDatatypeVariety variety = XmlSchemaDatatypeVariety.Atomic;
        private RestrictionFacets restriction = null; 
        private DatatypeImplementation baseType = null;
        private XmlValueConverter valueConverter; 
        private XmlSchemaType parentSchemaType; 

        private static Hashtable builtinTypes = new Hashtable(); 
        private static XmlSchemaSimpleType[] enumToTypeCode = new XmlSchemaSimpleType[(int) XmlTypeCode.DayTimeDuration + 1];
        private static XmlSchemaSimpleType anySimpleType;
        private static XmlSchemaSimpleType anyAtomicType;
        private static XmlSchemaSimpleType untypedAtomicType; 
        private static XmlSchemaSimpleType yearMonthDurationType;
        private static XmlSchemaSimpleType dayTimeDurationType; 
        private static XmlSchemaSimpleType normalizedStringTypeV1Compat; 
        private static XmlSchemaSimpleType tokenTypeV1Compat;
 
        private const int anySimpleTypeIndex = 11;

        internal static XmlQualifiedName QnAnySimpleType = new XmlQualifiedName("anySimpleType",XmlReservedNs.NsXs);
        internal static XmlQualifiedName QnAnyType = new XmlQualifiedName("anyType",XmlReservedNs.NsXs); 

        //Create facet checkers 
        internal static FacetsChecker stringFacetsChecker = new StringFacetsChecker(); 
        internal static FacetsChecker miscFacetsChecker = new MiscFacetsChecker();
        internal static FacetsChecker numeric2FacetsChecker = new Numeric2FacetsChecker(); 
        internal static FacetsChecker binaryFacetsChecker = new BinaryFacetsChecker();
        internal static FacetsChecker dateTimeFacetsChecker = new DateTimeFacetsChecker();
        internal static FacetsChecker durationFacetsChecker = new DurationFacetsChecker();
        internal static FacetsChecker listFacetsChecker = new ListFacetsChecker(); 
        internal static FacetsChecker qnameFacetsChecker = new QNameFacetsChecker();
        internal static FacetsChecker unionFacetsChecker = new UnionFacetsChecker(); 
 
        static DatatypeImplementation() {
            CreateBuiltinTypes(); 
        }

        internal static XmlSchemaSimpleType AnySimpleType { get { return anySimpleType; } }
 
        // Additional built-in XQuery simple types
        internal static XmlSchemaSimpleType AnyAtomicType { get { return anyAtomicType; } } 
        internal static XmlSchemaSimpleType UntypedAtomicType { get { return untypedAtomicType; } } 
        internal static XmlSchemaSimpleType YearMonthDurationType { get { return yearMonthDurationType; } }
        internal static XmlSchemaSimpleType DayTimeDurationType { get { return dayTimeDurationType; } } 

        internal new static DatatypeImplementation FromXmlTokenizedType(XmlTokenizedType token) {
            return c_tokenizedTypes[(int)token];
        } 

        internal new static DatatypeImplementation FromXmlTokenizedTypeXsd(XmlTokenizedType token) { 
            return c_tokenizedTypesXsd[(int)token]; 
        }
 
        internal new static DatatypeImplementation FromXdrName(string name) {
            int i = Array.BinarySearch(c_XdrTypes, name, null);
            return i < 0 ? null : (DatatypeImplementation)c_XdrTypes[i];
        } 

        private static DatatypeImplementation FromTypeName(string name) { 
            int i = Array.BinarySearch(c_XsdTypes, name, null); 
            return i < 0 ? null : (DatatypeImplementation)c_XsdTypes[i];
        } 

        /// 
        /// Begin the creation of an XmlSchemaSimpleType object that will be used to represent a static built-in type.
        /// Once StartBuiltinType has been called for all built-in types, FinishBuiltinType should be called in order 
        /// to create links between the types.
        ///  
        internal static XmlSchemaSimpleType StartBuiltinType(XmlQualifiedName qname, XmlSchemaDatatype dataType) { 
            XmlSchemaSimpleType simpleType;
            Debug.Assert(qname != null && dataType != null); 

            simpleType = new XmlSchemaSimpleType();
            simpleType.SetQualifiedName(qname);
            simpleType.SetDatatype(dataType); 
            simpleType.ElementDecl = new SchemaElementDecl(dataType);
            simpleType.ElementDecl.SchemaType = simpleType; 
 
            return simpleType;
        } 

        /// 
        /// Finish constructing built-in types by setting up derivation and list links.
        ///  
        internal static void FinishBuiltinType(XmlSchemaSimpleType derivedType, XmlSchemaSimpleType baseType) {
            Debug.Assert(derivedType != null && baseType != null); 
 
            // Create link from the derived type to the base type
            derivedType.SetBaseSchemaType(baseType); 
            derivedType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction);
            if (derivedType.Datatype.Variety == XmlSchemaDatatypeVariety.Atomic) { //Content is restriction
                XmlSchemaSimpleTypeRestriction restContent = new XmlSchemaSimpleTypeRestriction();
                restContent.BaseTypeName = baseType.QualifiedName; 
                derivedType.Content = restContent;
            } 
 
            // Create link from a list type to its member type
            if (derivedType.Datatype.Variety == XmlSchemaDatatypeVariety.List) { 
                XmlSchemaSimpleTypeList listContent = new XmlSchemaSimpleTypeList();
                derivedType.SetDerivedBy(XmlSchemaDerivationMethod.List);
                switch (derivedType.Datatype.TypeCode) {
                    case XmlTypeCode.NmToken: 
                        listContent.ItemType = listContent.BaseItemType = enumToTypeCode[(int) XmlTypeCode.NmToken];
                        break; 
 
                    case XmlTypeCode.Entity:
                        listContent.ItemType = listContent.BaseItemType = enumToTypeCode[(int) XmlTypeCode.Entity]; 
                        break;

                    case XmlTypeCode.Idref:
                        listContent.ItemType = listContent.BaseItemType = enumToTypeCode[(int) XmlTypeCode.Idref]; 
                        break;
                } 
                derivedType.Content = listContent; 
            }
        } 

        internal static void CreateBuiltinTypes() {
            XmlQualifiedName qname;
 
            //Build anySimpleType
            SchemaDatatypeMap sdm = c_XsdTypes[anySimpleTypeIndex]; //anySimpleType 
            qname = new XmlQualifiedName(sdm.Name, XmlReservedNs.NsXs); 
            DatatypeImplementation dt = FromTypeName(qname.Name);
            anySimpleType = StartBuiltinType(qname, dt); 
            dt.parentSchemaType = anySimpleType;
            builtinTypes.Add(qname, anySimpleType);

            // Start construction of each built-in Xsd type 
            XmlSchemaSimpleType simpleType;
            for (int i = 0; i < c_XsdTypes.Length; i++) { //Create all types 
                if (i == anySimpleTypeIndex) { //anySimpleType 
                    continue;
                } 
                sdm = c_XsdTypes[i];

                qname = new XmlQualifiedName(sdm.Name, XmlReservedNs.NsXs);
                dt = FromTypeName(qname.Name); 
                simpleType = StartBuiltinType(qname, dt);
                dt.parentSchemaType = simpleType; 
 
                builtinTypes.Add(qname, simpleType);
                if (dt.variety == XmlSchemaDatatypeVariety.Atomic) { 
                    enumToTypeCode[(int)dt.TypeCode] = simpleType;
                }
            }
 
            // Finish construction of each built-in Xsd type
            for (int i = 0; i < c_XsdTypes.Length; i++) { 
                if (i == anySimpleTypeIndex) { //anySimpleType 
                    continue;
                } 
                sdm = c_XsdTypes[i];
                XmlSchemaSimpleType derivedType = (XmlSchemaSimpleType) builtinTypes[new XmlQualifiedName(sdm.Name, XmlReservedNs.NsXs)];
                XmlSchemaSimpleType baseType;
 
                if (sdm.ParentIndex == anySimpleTypeIndex) {
                    FinishBuiltinType(derivedType, anySimpleType); 
                } 
                else { //derived types whose index > 0
                    baseType = (XmlSchemaSimpleType) builtinTypes[new XmlQualifiedName( ((SchemaDatatypeMap)(c_XsdTypes[sdm.ParentIndex])).Name, XmlReservedNs.NsXs)]; 
                    FinishBuiltinType(derivedType, baseType);
                }
            }
 
            // Construct xdt:anyAtomicType type (derived from xs:anySimpleType)
            qname = new XmlQualifiedName("anyAtomicType", XmlReservedNs.NsXQueryDataType); 
            anyAtomicType = StartBuiltinType(qname, c_anyAtomicType); 
            c_anyAtomicType.parentSchemaType = anyAtomicType;
            FinishBuiltinType(anyAtomicType, anySimpleType); 
            builtinTypes.Add(qname, anyAtomicType);
            enumToTypeCode[(int)XmlTypeCode.AnyAtomicType] = anyAtomicType;

            // Construct xdt:untypedAtomic type (derived from xdt:anyAtomicType) 
            qname = new XmlQualifiedName("untypedAtomic", XmlReservedNs.NsXQueryDataType);
            untypedAtomicType = StartBuiltinType(qname, c_untypedAtomicType); 
            c_untypedAtomicType.parentSchemaType = untypedAtomicType; 
            FinishBuiltinType(untypedAtomicType, anyAtomicType);
            builtinTypes.Add(qname, untypedAtomicType); 
            enumToTypeCode[(int)XmlTypeCode.UntypedAtomic] = untypedAtomicType;

            // Construct xdt:yearMonthDuration type (derived from xs:duration)
            qname = new XmlQualifiedName("yearMonthDuration", XmlReservedNs.NsXQueryDataType); 
            yearMonthDurationType = StartBuiltinType(qname, c_yearMonthDuration);
            c_yearMonthDuration.parentSchemaType = yearMonthDurationType; 
            FinishBuiltinType(yearMonthDurationType, enumToTypeCode[(int) XmlTypeCode.Duration]); 
            builtinTypes.Add(qname, yearMonthDurationType);
            enumToTypeCode[(int)XmlTypeCode.YearMonthDuration] = yearMonthDurationType; 

            // Construct xdt:dayTimeDuration type (derived from xs:duration)
            qname = new XmlQualifiedName("dayTimeDuration", XmlReservedNs.NsXQueryDataType);
            dayTimeDurationType = StartBuiltinType(qname, c_dayTimeDuration); 
            c_dayTimeDuration.parentSchemaType = dayTimeDurationType;
            FinishBuiltinType(dayTimeDurationType, enumToTypeCode[(int) XmlTypeCode.Duration]); 
            builtinTypes.Add(qname, dayTimeDurationType); 
            enumToTypeCode[(int)XmlTypeCode.DayTimeDuration] = dayTimeDurationType;
        } 

        internal static XmlSchemaSimpleType GetSimpleTypeFromTypeCode(XmlTypeCode typeCode) {
            return enumToTypeCode[(int) typeCode];
        } 

        internal static XmlSchemaSimpleType GetSimpleTypeFromXsdType(XmlQualifiedName qname) { 
            return (XmlSchemaSimpleType)builtinTypes[qname]; 
        }
 
        internal static XmlSchemaSimpleType GetNormalizedStringTypeV1Compat() {
            if (normalizedStringTypeV1Compat == null) {
                XmlSchemaSimpleType correctType = GetSimpleTypeFromTypeCode(XmlTypeCode.NormalizedString);
                normalizedStringTypeV1Compat = correctType.Clone() as XmlSchemaSimpleType; 
                normalizedStringTypeV1Compat.SetDatatype(c_normalizedStringV1Compat);
                normalizedStringTypeV1Compat.ElementDecl = new SchemaElementDecl(c_normalizedStringV1Compat); 
                normalizedStringTypeV1Compat.ElementDecl.SchemaType = normalizedStringTypeV1Compat; 
            }
            return normalizedStringTypeV1Compat; 
        }

        internal static XmlSchemaSimpleType GetTokenTypeV1Compat() {
            if (tokenTypeV1Compat == null) { 
                XmlSchemaSimpleType correctType = GetSimpleTypeFromTypeCode(XmlTypeCode.Token);
                tokenTypeV1Compat = correctType.Clone() as XmlSchemaSimpleType; 
                tokenTypeV1Compat.SetDatatype(c_tokenV1Compat); 
                tokenTypeV1Compat.ElementDecl = new SchemaElementDecl(c_tokenV1Compat);
                tokenTypeV1Compat.ElementDecl.SchemaType = tokenTypeV1Compat; 
            }
            return tokenTypeV1Compat;
        }
 
        internal static XmlSchemaSimpleType[] GetBuiltInTypes() {
            return enumToTypeCode; 
        } 

        internal static XmlTypeCode GetPrimitiveTypeCode(XmlTypeCode typeCode) { 
            XmlSchemaSimpleType currentType = enumToTypeCode[(int)typeCode];
            while (currentType.BaseXmlSchemaType != DatatypeImplementation.AnySimpleType) {
                currentType = currentType.BaseXmlSchemaType as XmlSchemaSimpleType;
                Debug.Assert(currentType != null); 
            }
            return currentType.TypeCode; 
        } 

        internal override XmlSchemaDatatype DeriveByRestriction(XmlSchemaObjectCollection facets, XmlNameTable nameTable, XmlSchemaType schemaType) { 
            DatatypeImplementation dt = (DatatypeImplementation)MemberwiseClone();
            dt.restriction = this.FacetsChecker.ConstructRestriction(this, facets, nameTable);
            dt.baseType = this;
            dt.parentSchemaType = schemaType; 
            dt.valueConverter = null; //re-set old datatype's valueconverter
            return dt; 
        } 

        internal override XmlSchemaDatatype DeriveByList(XmlSchemaType schemaType) { 
            return DeriveByList(0, schemaType);
        }

        internal XmlSchemaDatatype DeriveByList(int minSize, XmlSchemaType schemaType) { 
            if (variety == XmlSchemaDatatypeVariety.List) {
                throw new XmlSchemaException(Res.Sch_ListFromNonatomic, string.Empty); 
            } 
            else if (variety == XmlSchemaDatatypeVariety.Union && !((Datatype_union)this).HasAtomicMembers()) {
                throw new XmlSchemaException(Res.Sch_ListFromNonatomic, string.Empty); 
            }
            DatatypeImplementation dt = new Datatype_List(this, minSize);
            dt.variety = XmlSchemaDatatypeVariety.List;
            dt.restriction = null; 
            dt.baseType = c_anySimpleType; //Base type of a union is anySimpleType
            dt.parentSchemaType = schemaType; 
            return dt; 
        }
 
        internal new static DatatypeImplementation DeriveByUnion(XmlSchemaSimpleType[] types, XmlSchemaType schemaType) {
            DatatypeImplementation dt = new Datatype_union(types);
            dt.baseType = c_anySimpleType; //Base type of a union is anySimpleType
            dt.variety = XmlSchemaDatatypeVariety.Union; 
            dt.parentSchemaType = schemaType;
            return dt; 
        } 

        internal override void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller) {/*noop*/} 

        public override bool IsDerivedFrom(XmlSchemaDatatype datatype) {
            if (datatype == null) {
                return false; 
            }
 
            //Common case - Derived by restriction 
            for(DatatypeImplementation dt = this; dt != null; dt = dt.baseType) {
                if (dt == datatype) { 
                    return true;
                }
            }
            if (((DatatypeImplementation)datatype).baseType == null) { //Both are built-in types 
                Type derivedType = this.GetType();
                Type baseType = datatype.GetType(); 
                return baseType == derivedType || derivedType.IsSubclassOf(baseType); 
            }
            else if (datatype.Variety == XmlSchemaDatatypeVariety.Union && !datatype.HasLexicalFacets && !datatype.HasValueFacets && variety != XmlSchemaDatatypeVariety.Union) { //base type is union (not a restriction of union) and derived type is not union 
                return ((Datatype_union)datatype).IsUnionBaseOf(this);
            }
            else if ((variety == XmlSchemaDatatypeVariety.Union || variety == XmlSchemaDatatypeVariety.List) && restriction == null) { //derived type is union (not a restriction)
                return (datatype == anySimpleType.Datatype); 
            }
            return false; 
        } 

        internal override bool IsEqual(object o1, object o2) { 
            //Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceVerbose, string.Format("\t\tSchemaDatatype.IsEqual({0}, {1})", o1, o2));
            return Compare(o1, o2) == 0;
        }
 
        internal override bool IsComparable(XmlSchemaDatatype dtype) {
            XmlTypeCode thisCode = this.TypeCode; 
            XmlTypeCode otherCode = dtype.TypeCode; 

            if (thisCode == otherCode) { //They are both same built-in type or one is list and the other is list's itemType 
                return true;
            }
            if (GetPrimitiveTypeCode(thisCode) == GetPrimitiveTypeCode(otherCode)) {
                return true; 
            }
            if (this.IsDerivedFrom(dtype) || dtype.IsDerivedFrom(this)) { //One is union and the other is a member of the union 
                return true; 
            }
            return false; 
        }

        internal virtual XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { return null; }
 
        internal override FacetsChecker FacetsChecker { get { return miscFacetsChecker; } }
 
        internal override XmlValueConverter ValueConverter { 
            get {
                if (valueConverter == null) { 
                    valueConverter = CreateValueConverter(this.parentSchemaType);
                }
                return valueConverter;
            } 
        }
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.None;}} 

        public override Type ValueType { get { return typeof(string); }} 

        public override XmlSchemaDatatypeVariety Variety { get { return variety;}}

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.None; } } 

        internal override RestrictionFacets Restriction { 
            get { 
                return restriction;
            } 
            set {
                restriction = value;
            }
        } 
        internal override bool HasLexicalFacets {
            get { 
                RestrictionFlags flags = restriction != null ? restriction.Flags : 0; 
                if (flags != 0 && (flags & (RestrictionFlags.Pattern|RestrictionFlags.WhiteSpace|RestrictionFlags.TotalDigits|RestrictionFlags.FractionDigits)) != 0) {
                    return true; 
                }
                return false;
            }
        } 
        internal override bool HasValueFacets {
            get { 
                RestrictionFlags flags = restriction != null ? restriction.Flags : 0; 
                if (flags != 0 && (flags & (RestrictionFlags.Length | RestrictionFlags.MinLength | RestrictionFlags.MaxLength | RestrictionFlags.MaxExclusive | RestrictionFlags.MaxInclusive | RestrictionFlags.MinExclusive | RestrictionFlags.MinInclusive | RestrictionFlags.TotalDigits | RestrictionFlags.FractionDigits | RestrictionFlags.Enumeration)) != 0)
                { 
                    return true;
                }
                return false;
            } 
        }
 
        protected DatatypeImplementation Base { get { return baseType; }} 

        internal abstract Type ListValueType { get; } 

        internal abstract RestrictionFlags ValidRestrictionFlags { get; }

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Preserve; } } 

        internal override object ParseValue(string s, Type typDest, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) { 
            return ValueConverter.ChangeType(ParseValue(s, nameTable, nsmgr), typDest, nsmgr); 
        }
 
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) {
            object typedValue;
            Exception exception = TryParseValue(s, nameTable, nsmgr, out typedValue);
            if (exception != null) { 
                throw new XmlSchemaException(Res.Sch_InvalidValueDetailed, new string[] { s, GetTypeName(), exception.Message }, exception, null, 0, 0, null);
            } 
            if (this.Variety == XmlSchemaDatatypeVariety.Union) { 
                XsdSimpleValue simpleValue = typedValue as XsdSimpleValue;
                return simpleValue.TypedValue; 
            }
            return typedValue;
        }
 
        internal override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, bool createAtomicValue) {
            if (createAtomicValue) { 
                object typedValue; 
                Exception exception = TryParseValue(s, nameTable, nsmgr, out typedValue);
                if (exception != null) { 
                    throw new XmlSchemaException(Res.Sch_InvalidValueDetailed, new string[] { s, GetTypeName(), exception.Message }, exception, null, 0, 0, null);
                }
                return typedValue;
            } 
            else {
                return ParseValue(s, nameTable, nsmgr); 
            } 
        }
 
        internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver namespaceResolver, out object typedValue) {
            Exception exception = null;
            typedValue = null;
            if (value == null) { 
                return new ArgumentNullException("value");
            } 
            string s = value as string; 
            if (s != null) {
                return TryParseValue(s, nameTable, namespaceResolver, out typedValue); 
            }
            try {
                object valueToCheck = value;
                if (value.GetType() != this.ValueType) { 
                    valueToCheck = this.ValueConverter.ChangeType(value, this.ValueType, namespaceResolver);
                } 
                if (this.HasLexicalFacets) { 
                    string s1 = (string)this.ValueConverter.ChangeType(value, typeof(System.String), namespaceResolver); //Using value here to avoid info loss
                    exception = this.FacetsChecker.CheckLexicalFacets(ref s1, this); 
                    if (exception != null) goto Error;
                }
                if (this.HasValueFacets) {
                    exception = this.FacetsChecker.CheckValueFacets(valueToCheck, this); 
                    if (exception != null) goto Error;
                } 
                typedValue = valueToCheck; 
                return null;
            } 
            catch (FormatException e) { //Catching for exceptions thrown by ValueConverter
                exception = e;
            }
            catch (InvalidCastException e) { //Catching for exceptions thrown by ValueConverter 
                exception = e;
            } 
            catch (OverflowException e) { //Catching for exceptions thrown by ValueConverter 
                exception = e;
            } 
            catch (ArgumentException e) { //Catching for exceptions thrown by ValueConverter
                exception = e;
            }
 
        Error:
           return exception; 
        } 

        internal string GetTypeName() { 
            XmlSchemaType simpleType = this.parentSchemaType;
            string typeName;
            if (simpleType == null || simpleType.QualifiedName.IsEmpty) { //If no QName, get typecode, no line info since it is not pertinent without file name
                typeName = TypeCodeString; 
            }
            else { 
                typeName = simpleType.QualifiedName.ToString(); 
            }
            return typeName; 
        }

        // XSD types
        static private readonly DatatypeImplementation c_anySimpleType       = new Datatype_anySimpleType(); 
        static private readonly DatatypeImplementation c_anyURI              = new Datatype_anyURI();
        static private readonly DatatypeImplementation c_base64Binary        = new Datatype_base64Binary(); 
        static private readonly DatatypeImplementation c_boolean             = new Datatype_boolean(); 
        static private readonly DatatypeImplementation c_byte                = new Datatype_byte();
        static private readonly DatatypeImplementation c_char                = new Datatype_char(); // XDR 
        static private readonly DatatypeImplementation c_date                = new Datatype_date();
        static private readonly DatatypeImplementation c_dateTime            = new Datatype_dateTime();
        static private readonly DatatypeImplementation c_dateTimeNoTz        = new Datatype_dateTimeNoTimeZone(); // XDR
        static private readonly DatatypeImplementation c_dateTimeTz          = new Datatype_dateTimeTimeZone(); // XDR 
        static private readonly DatatypeImplementation c_day                 = new Datatype_day();
        static private readonly DatatypeImplementation c_decimal             = new Datatype_decimal(); 
        static private readonly DatatypeImplementation c_double              = new Datatype_double(); 
        static private readonly DatatypeImplementation c_doubleXdr           = new Datatype_doubleXdr();     // XDR
        static private readonly DatatypeImplementation c_duration            = new Datatype_duration(); 
        static private readonly DatatypeImplementation c_ENTITY              = new Datatype_ENTITY();
        static private readonly DatatypeImplementation c_ENTITIES            = (DatatypeImplementation)c_ENTITY.DeriveByList(1, null);
        static private readonly DatatypeImplementation c_ENUMERATION         = new Datatype_ENUMERATION(); // XDR
        static private readonly DatatypeImplementation c_fixed               = new Datatype_fixed(); 
        static private readonly DatatypeImplementation c_float               = new Datatype_float();
        static private readonly DatatypeImplementation c_floatXdr            = new Datatype_floatXdr(); // XDR 
        static private readonly DatatypeImplementation c_hexBinary           = new Datatype_hexBinary(); 
        static private readonly DatatypeImplementation c_ID                  = new Datatype_ID();
        static private readonly DatatypeImplementation c_IDREF               = new Datatype_IDREF(); 
        static private readonly DatatypeImplementation c_IDREFS              = (DatatypeImplementation)c_IDREF.DeriveByList(1, null);
        static private readonly DatatypeImplementation c_int                 = new Datatype_int();
        static private readonly DatatypeImplementation c_integer             = new Datatype_integer();
        static private readonly DatatypeImplementation c_language            = new Datatype_language(); 
        static private readonly DatatypeImplementation c_long                = new Datatype_long();
        static private readonly DatatypeImplementation c_month               = new Datatype_month(); 
        static private readonly DatatypeImplementation c_monthDay            = new Datatype_monthDay(); 
        static private readonly DatatypeImplementation c_Name                = new Datatype_Name();
        static private readonly DatatypeImplementation c_NCName              = new Datatype_NCName(); 
        static private readonly DatatypeImplementation c_negativeInteger     = new Datatype_negativeInteger();
        static private readonly DatatypeImplementation c_NMTOKEN             = new Datatype_NMTOKEN();
        static private readonly DatatypeImplementation c_NMTOKENS            = (DatatypeImplementation)c_NMTOKEN.DeriveByList(1, null);
        static private readonly DatatypeImplementation c_nonNegativeInteger  = new Datatype_nonNegativeInteger(); 
        static private readonly DatatypeImplementation c_nonPositiveInteger  = new Datatype_nonPositiveInteger();
        static private readonly DatatypeImplementation c_normalizedString    = new Datatype_normalizedString(); 
        static private readonly DatatypeImplementation c_NOTATION            = new Datatype_NOTATION(); 
        static private readonly DatatypeImplementation c_positiveInteger     = new Datatype_positiveInteger();
        static private readonly DatatypeImplementation c_QName               = new Datatype_QName(); 
        static private readonly DatatypeImplementation c_QNameXdr            = new Datatype_QNameXdr(); //XDR
        static private readonly DatatypeImplementation c_short               = new Datatype_short();
        static private readonly DatatypeImplementation c_string              = new Datatype_string();
        static private readonly DatatypeImplementation c_time                = new Datatype_time(); 
        static private readonly DatatypeImplementation c_timeNoTz            = new Datatype_timeNoTimeZone(); // XDR
        static private readonly DatatypeImplementation c_timeTz              = new Datatype_timeTimeZone(); // XDR 
        static private readonly DatatypeImplementation c_token               = new Datatype_token(); 
        static private readonly DatatypeImplementation c_unsignedByte        = new Datatype_unsignedByte();
        static private readonly DatatypeImplementation c_unsignedInt         = new Datatype_unsignedInt(); 
        static private readonly DatatypeImplementation c_unsignedLong        = new Datatype_unsignedLong();
        static private readonly DatatypeImplementation c_unsignedShort       = new Datatype_unsignedShort();
        static private readonly DatatypeImplementation c_uuid                = new Datatype_uuid(); // XDR
        static private readonly DatatypeImplementation c_year                = new Datatype_year(); 
        static private readonly DatatypeImplementation c_yearMonth           = new Datatype_yearMonth();
 
        //V1 compat types 
        static internal readonly DatatypeImplementation c_normalizedStringV1Compat = new Datatype_normalizedStringV1Compat();
        static internal readonly DatatypeImplementation c_tokenV1Compat = new Datatype_tokenV1Compat(); 

        // XQuery types
        static private readonly DatatypeImplementation c_anyAtomicType       = new Datatype_anyAtomicType();
        static private readonly DatatypeImplementation c_dayTimeDuration     = new Datatype_dayTimeDuration(); 
        static private readonly DatatypeImplementation c_untypedAtomicType   = new Datatype_untypedAtomicType();
        static private readonly DatatypeImplementation c_yearMonthDuration   = new Datatype_yearMonthDuration(); 
 

        private class SchemaDatatypeMap : IComparable { 
            string name;
            DatatypeImplementation type;
            int parentIndex;
 
            internal SchemaDatatypeMap(string name, DatatypeImplementation type) {
                this.name = name; 
                this.type = type; 
            }
 
            internal SchemaDatatypeMap(string name, DatatypeImplementation type, int parentIndex) {
                this.name = name;
                this.type = type;
                this.parentIndex = parentIndex; 
            }
            public static explicit operator DatatypeImplementation(SchemaDatatypeMap sdm) { return sdm.type; } 
 
            public string Name {
                get { 
                    return name;
                }
            }
 
            public int ParentIndex {
                get { 
                    return parentIndex; 
                }
            } 

            public int CompareTo(object obj) { return string.Compare(name, (string)obj, StringComparison.Ordinal); }
        }
 
        private static readonly DatatypeImplementation[] c_tokenizedTypes = {
            c_string,               // CDATA 
            c_ID,                   // ID 
            c_IDREF,                // IDREF
            c_IDREFS,               // IDREFS 
            c_ENTITY,               // ENTITY
            c_ENTITIES,             // ENTITIES
            c_NMTOKEN,              // NMTOKEN
            c_NMTOKENS,             // NMTOKENS 
            c_NOTATION,             // NOTATION
            c_ENUMERATION,          // ENUMERATION 
            c_QNameXdr,             // QName 
            c_NCName,               // NCName
            null 
        };

        private static readonly DatatypeImplementation[] c_tokenizedTypesXsd = {
            c_string,               // CDATA 
            c_ID,                   // ID
            c_IDREF,                // IDREF 
            c_IDREFS,               // IDREFS 
            c_ENTITY,               // ENTITY
            c_ENTITIES,             // ENTITIES 
            c_NMTOKEN,              // NMTOKEN
            c_NMTOKENS,             // NMTOKENS
            c_NOTATION,             // NOTATION
            c_ENUMERATION,          // ENUMERATION 
            c_QName,                // QName
            c_NCName,               // NCName 
            null 
        };
 
        private static readonly SchemaDatatypeMap[] c_XdrTypes = {
            new SchemaDatatypeMap("bin.base64",          c_base64Binary),
            new SchemaDatatypeMap("bin.hex",             c_hexBinary),
            new SchemaDatatypeMap("boolean",             c_boolean), 
            new SchemaDatatypeMap("char",                c_char),
            new SchemaDatatypeMap("date",                c_date), 
            new SchemaDatatypeMap("dateTime",            c_dateTimeNoTz), 
            new SchemaDatatypeMap("dateTime.tz",         c_dateTimeTz),
            new SchemaDatatypeMap("decimal",             c_decimal), 
            new SchemaDatatypeMap("entities",            c_ENTITIES),
            new SchemaDatatypeMap("entity",              c_ENTITY),
            new SchemaDatatypeMap("enumeration",         c_ENUMERATION),
            new SchemaDatatypeMap("fixed.14.4",          c_fixed), 
            new SchemaDatatypeMap("float",               c_doubleXdr),
            new SchemaDatatypeMap("float.ieee.754.32",   c_floatXdr), 
            new SchemaDatatypeMap("float.ieee.754.64",   c_doubleXdr), 
            new SchemaDatatypeMap("i1",                  c_byte),
            new SchemaDatatypeMap("i2",                  c_short), 
            new SchemaDatatypeMap("i4",                  c_int),
            new SchemaDatatypeMap("i8",                  c_long),
            new SchemaDatatypeMap("id",                  c_ID),
            new SchemaDatatypeMap("idref",               c_IDREF), 
            new SchemaDatatypeMap("idrefs",              c_IDREFS),
            new SchemaDatatypeMap("int",                 c_int), 
            new SchemaDatatypeMap("nmtoken",             c_NMTOKEN), 
            new SchemaDatatypeMap("nmtokens",            c_NMTOKENS),
            new SchemaDatatypeMap("notation",            c_NOTATION), 
            new SchemaDatatypeMap("number",              c_doubleXdr),
            new SchemaDatatypeMap("r4",                  c_floatXdr),
            new SchemaDatatypeMap("r8",                  c_doubleXdr),
            new SchemaDatatypeMap("string",              c_string), 
            new SchemaDatatypeMap("time",                c_timeNoTz),
            new SchemaDatatypeMap("time.tz",             c_timeTz), 
            new SchemaDatatypeMap("ui1",                 c_unsignedByte), 
            new SchemaDatatypeMap("ui2",                 c_unsignedShort),
            new SchemaDatatypeMap("ui4",                 c_unsignedInt), 
            new SchemaDatatypeMap("ui8",                 c_unsignedLong),
            new SchemaDatatypeMap("uri",                 c_anyURI),
            new SchemaDatatypeMap("uuid",                c_uuid)
        }; 

 
        private static readonly SchemaDatatypeMap[] c_XsdTypes = { 
            new SchemaDatatypeMap("ENTITIES",           c_ENTITIES, 11),
            new SchemaDatatypeMap("ENTITY",             c_ENTITY, 11), 
            new SchemaDatatypeMap("ID",                 c_ID, 5),
            new SchemaDatatypeMap("IDREF",              c_IDREF, 5),
            new SchemaDatatypeMap("IDREFS",             c_IDREFS, 11),
 
            new SchemaDatatypeMap("NCName",             c_NCName, 9),
            new SchemaDatatypeMap("NMTOKEN",            c_NMTOKEN, 40), 
            new SchemaDatatypeMap("NMTOKENS",           c_NMTOKENS, 11), 
            new SchemaDatatypeMap("NOTATION",           c_NOTATION, 11),
 
            new SchemaDatatypeMap("Name",               c_Name, 40),
            new SchemaDatatypeMap("QName",              c_QName, 11), //-> 10

            new SchemaDatatypeMap("anySimpleType",      c_anySimpleType, -1), 
            new SchemaDatatypeMap("anyURI",             c_anyURI, 11),
            new SchemaDatatypeMap("base64Binary",       c_base64Binary, 11), 
            new SchemaDatatypeMap("boolean",            c_boolean, 11), 
            new SchemaDatatypeMap("byte",               c_byte, 37),
            new SchemaDatatypeMap("date",               c_date, 11), 
            new SchemaDatatypeMap("dateTime",           c_dateTime, 11),
            new SchemaDatatypeMap("decimal",            c_decimal, 11),
            new SchemaDatatypeMap("double",             c_double, 11),
            new SchemaDatatypeMap("duration",           c_duration, 11), //->20 

            new SchemaDatatypeMap("float",              c_float, 11), 
            new SchemaDatatypeMap("gDay",               c_day, 11), 
            new SchemaDatatypeMap("gMonth",             c_month, 11),
            new SchemaDatatypeMap("gMonthDay",          c_monthDay, 11), 
            new SchemaDatatypeMap("gYear",              c_year, 11),
            new SchemaDatatypeMap("gYearMonth",         c_yearMonth, 11),
            new SchemaDatatypeMap("hexBinary",          c_hexBinary, 11),
            new SchemaDatatypeMap("int",                c_int, 31), 
            new SchemaDatatypeMap("integer",            c_integer, 18),
            new SchemaDatatypeMap("language",           c_language, 40), //->30 
            new SchemaDatatypeMap("long",               c_long, 29), 

            new SchemaDatatypeMap("negativeInteger",    c_negativeInteger, 34), 

            new SchemaDatatypeMap("nonNegativeInteger", c_nonNegativeInteger, 29),
            new SchemaDatatypeMap("nonPositiveInteger", c_nonPositiveInteger, 29),
            new SchemaDatatypeMap("normalizedString",   c_normalizedString, 38), 

            new SchemaDatatypeMap("positiveInteger",    c_positiveInteger, 33), 
 
            new SchemaDatatypeMap("short",              c_short, 28),
            new SchemaDatatypeMap("string",             c_string, 11), 
            new SchemaDatatypeMap("time",               c_time, 11),
            new SchemaDatatypeMap("token",              c_token, 35), //->40
            new SchemaDatatypeMap("unsignedByte",       c_unsignedByte, 44),
            new SchemaDatatypeMap("unsignedInt",        c_unsignedInt, 43), 
            new SchemaDatatypeMap("unsignedLong",       c_unsignedLong, 33),
            new SchemaDatatypeMap("unsignedShort",      c_unsignedShort, 42), 
        }; 

        protected int Compare(byte[] value1, byte[] value2) { 
            int length = value1.Length;
            if (length != value2.Length) {
                return -1;
            } 
            for (int i = 0; i < length; i ++) {
                if (value1[i] != value2[i]) { 
                    return -1; 
                }
            } 
            return 0;
        }

#if [....] 
        protected object GetValueToCheck(object value, IXmlNamespaceResolver nsmgr) {
            object valueToCheck = value; 
            string resId; 
            if (CanConvert(value, value.GetType(), this.ValueType, out resId)) {
                valueToCheck = this.ValueConverter.ChangeType(value, this.ValueType, nsmgr); 
            }
            else {
                throw new XmlSchemaException(resId, string.Empty);
            } 
            return valueToCheck;
        } 
#endif 

    } 


    //List type
    internal class Datatype_List : Datatype_anySimpleType { 
        DatatypeImplementation itemType;
        int minListSize; 
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            XmlSchemaType listItemType = null; 
            XmlSchemaSimpleType simpleType;
            XmlSchemaComplexType complexType;
            complexType = schemaType as XmlSchemaComplexType;
 
            if (complexType != null) {
                do { 
                    simpleType = complexType.BaseXmlSchemaType as XmlSchemaSimpleType; 
                    if (simpleType != null) {
                        break; 
                    }
                    complexType = complexType.BaseXmlSchemaType as XmlSchemaComplexType;
                } while(complexType != null && complexType != XmlSchemaComplexType.AnyType);
            } 
            else {
                simpleType = schemaType as XmlSchemaSimpleType; 
            } 
            if (simpleType != null) {
                do { 
                    XmlSchemaSimpleTypeList listType = simpleType.Content as XmlSchemaSimpleTypeList;
                    if (listType != null) {
                        listItemType = listType.BaseItemType;
                        break; 
                    }
                    simpleType = simpleType.BaseXmlSchemaType as XmlSchemaSimpleType; 
                } while (simpleType != null && simpleType != DatatypeImplementation.AnySimpleType); 
            }
 
            if (listItemType == null) { //Get built-in simple type for the typecode
                listItemType = DatatypeImplementation.GetSimpleTypeFromTypeCode(schemaType.Datatype.TypeCode);
            }
 
            return XmlListConverter.Create(listItemType.ValueConverter);
        } 
 
        internal Datatype_List(DatatypeImplementation type) : this(type, 0) {
        } 
        internal Datatype_List(DatatypeImplementation type, int minListSize) {
            this.itemType = type;
            this.minListSize = minListSize;
        } 

        internal override int Compare(object value1, object value2) { 
            System.Array arr1 = (System.Array)value1; 
            System.Array arr2 = (System.Array)value2;
 
            Debug.Assert(arr1 != null && arr2 != null);
            int length = arr1.Length;
            if (length != arr2.Length) {
                return -1; 
            }
            XmlAtomicValue[] atomicValues1 = arr1 as XmlAtomicValue[]; 
            if (atomicValues1 != null) { 
                XmlAtomicValue[] atomicValues2 = arr2 as XmlAtomicValue[];
                Debug.Assert(atomicValues2 != null); 
                XmlSchemaType xmlType1;
                for (int i =0; i < atomicValues1.Length; i++) {
                    xmlType1 = atomicValues1[i].XmlType;
                    if (xmlType1 != atomicValues2[i].XmlType || !xmlType1.Datatype.IsEqual(atomicValues1[i].TypedValue, atomicValues2[i].TypedValue) ) { 
                        return -1;
                    } 
                } 
                return 0;
            } 
            else {
                for (int i = 0; i < arr1.Length; i ++) {
                    if ( itemType.Compare(arr1.GetValue(i), arr2.GetValue(i)) != 0) {
                        return -1; 
                    }
                } 
                return 0; 
            }
        } 

        public override Type ValueType { get { return  ListValueType; }}

        public override XmlTokenizedType TokenizedType { get { return itemType.TokenizedType;}} 

        internal override Type ListValueType { get { return itemType.ListValueType; }} 
 
        internal override FacetsChecker FacetsChecker { get { return listFacetsChecker; } }
 
        public override XmlTypeCode TypeCode {
            get {
                return itemType.TypeCode;
            } 
        }
 
        internal override RestrictionFlags ValidRestrictionFlags { 
            get {
                return RestrictionFlags.Length|RestrictionFlags.MinLength|RestrictionFlags.MaxLength|RestrictionFlags.Enumeration|RestrictionFlags.WhiteSpace | RestrictionFlags.Pattern; 
            }
        }
        internal DatatypeImplementation ItemType { get { return itemType; }}
 
        internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver namespaceResolver, out object typedValue) {
            Exception exception; 
            if (value == null) { 
                throw new ArgumentNullException("value");
            } 
            string s = value as string;
            typedValue = null;
            if (s != null) {
                return TryParseValue(s, nameTable, namespaceResolver, out typedValue); 
            }
 
            try { 
                object valueToCheck = this.ValueConverter.ChangeType(value, this.ValueType, namespaceResolver);
                Array valuesToCheck = valueToCheck as Array; 
                Debug.Assert(valuesToCheck != null);

                bool checkItemLexical = itemType.HasLexicalFacets;
                bool checkItemValue = itemType.HasValueFacets; 
                object item;
                FacetsChecker itemFacetsChecker = itemType.FacetsChecker; 
                XmlValueConverter itemValueConverter = itemType.ValueConverter; 

                for (int i =0; i < valuesToCheck.Length; i++) { 
                    item = valuesToCheck.GetValue(i);
                    if (checkItemLexical) {
                        string s1 = (string)itemValueConverter.ChangeType(item, typeof(System.String), namespaceResolver);
                        exception = itemFacetsChecker.CheckLexicalFacets(ref s1, itemType); 
                        if (exception != null) goto Error;
                    } 
                    if (checkItemValue) { 
                        exception = itemFacetsChecker.CheckValueFacets(item, itemType);
                        if (exception != null) goto Error; 
                    }
                }

                //Check facets on the list itself 
                if (this.HasLexicalFacets) {
                    string s1 = (string)this.ValueConverter.ChangeType(valueToCheck, typeof(System.String), namespaceResolver); 
                    exception = listFacetsChecker.CheckLexicalFacets(ref s1, this); 
                    if (exception != null) goto Error;
                } 
                if (this.HasValueFacets) {
                    exception = listFacetsChecker.CheckValueFacets(valueToCheck, this);
                    if (exception != null) goto Error;
                } 
                typedValue = valueToCheck;
                return null; 
            } 
            catch (FormatException e) { //Catching for exceptions thrown by ValueConverter
                exception = e; 
            }
            catch (InvalidCastException e) { //Catching for exceptions thrown by ValueConverter
                exception = e;
            } 
            catch (OverflowException e) { //Catching for exceptions thrown by ValueConverter
                exception = e; 
            } 
            catch (ArgumentException e) { //Catching for exceptions thrown by ValueConverter
                exception = e; 
            }

        Error:
            return exception; 
        }
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
 
            typedValue = null;

            exception = listFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            ArrayList values = new ArrayList(); 
            object array; 
            if (itemType.Variety == XmlSchemaDatatypeVariety.Union) {
                object unionTypedValue; 
                foreach (string s1 in XmlConvert.SplitString(s)) {
                    //Parse items in list according to the itemType
                    exception = itemType.TryParseValue(s1, nameTable, nsmgr, out unionTypedValue);
                    if (exception != null) goto Error; 

                    XsdSimpleValue simpleValue = (XsdSimpleValue)unionTypedValue; 
                    values.Add(new XmlAtomicValue(simpleValue.XmlType, simpleValue.TypedValue, nsmgr)); 
                }
                array = values.ToArray(typeof(XmlAtomicValue)); 
            }
            else { //Variety == List or Atomic
                foreach (string s1 in XmlConvert.SplitString(s)) {
                    exception = itemType.TryParseValue(s1, nameTable, nsmgr, out typedValue); 
                    if (exception != null) goto Error;
 
                    values.Add(typedValue); 
                }
                array = values.ToArray(itemType.ValueType); 
                Debug.Assert(array.GetType() == ListValueType);
            }
            if (values.Count < minListSize) {
                return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty); 
            }
 
            exception = listFacetsChecker.CheckValueFacets(array, this); 
            if (exception != null) goto Error;
 
            typedValue = array;

            return null;
 
        Error:
            return exception; 
        } 

    } 

    //Union datatype
    internal class Datatype_union : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(object); 
        static readonly Type listValueType = typeof(object[]);
        XmlSchemaSimpleType[] types; 
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlUnionConverter.Create(schemaType); 
        }

        internal Datatype_union(XmlSchemaSimpleType[] types) {
            this.types = types; 
        }
 
        internal override int Compare(object value1, object value2) { 
            XsdSimpleValue simpleValue1 = value1 as XsdSimpleValue;
            XsdSimpleValue simpleValue2 = value2 as XsdSimpleValue; 

            if (simpleValue1 == null || simpleValue2 == null) {
                return -1;
            } 
            XmlSchemaType schemaType1 = simpleValue1.XmlType;
            XmlSchemaType schemaType2 = simpleValue2.XmlType; 
 
            if (schemaType1 == schemaType2) {
                XmlSchemaDatatype datatype = schemaType1.Datatype; 
                return datatype.Compare(simpleValue1.TypedValue, simpleValue2.TypedValue);
            }
            return -1;
        } 

        public override Type ValueType { get { return atomicValueType; }} 
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.AnyAtomicType; }}
 
        internal override FacetsChecker FacetsChecker { get { return unionFacetsChecker; } }

        internal override Type ListValueType { get { return listValueType; }}
 
        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.Pattern| 
                    RestrictionFlags.Enumeration;
            } 
        }

        internal XmlSchemaSimpleType[] BaseMemberTypes {
            get { 
                return types;
            } 
        } 

        internal bool HasAtomicMembers() { 
            foreach(XmlSchemaSimpleType st in types) {
                if (st.Datatype.Variety == XmlSchemaDatatypeVariety.List) {
                    return false;
                } 
            }
            return true; 
        } 

        internal bool IsUnionBaseOf(DatatypeImplementation derivedType) { 
            foreach(XmlSchemaSimpleType st in types) {
                if (derivedType.IsDerivedFrom(st.Datatype)) {
                    return true;
                } 
            }
            return false; 
        } 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
            XmlSchemaSimpleType memberType = null;

            typedValue = null; 

            exception = unionFacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error; 

            //Parse string to CLR value 
            foreach(XmlSchemaSimpleType st in types) {
                exception = st.Datatype.TryParseValue(s, nameTable, nsmgr, out typedValue);
                if (exception == null) {
                    memberType = st; 
                    break;
                } 
            } 
            if (memberType == null) {
                exception = new XmlSchemaException(Res.Sch_UnionFailedEx, s); 
                goto Error;
            }

            typedValue = new XsdSimpleValue(memberType, typedValue); 
            exception = unionFacetsChecker.CheckValueFacets(typedValue, this);
            if (exception != null) goto Error; 
 
            return null;
 
        Error:
            return exception;
        }
 
        internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 
            if (value == null) { 
                throw new ArgumentNullException("value");
            } 
            typedValue = null;
            string s = value as string;
            if (s != null) {
                return TryParseValue(s, nameTable, nsmgr, out typedValue); 
            }
 
            object valueToCheck = null; 
            XmlSchemaSimpleType memberType = null;
            foreach(XmlSchemaSimpleType st in types) { 
                if (st.Datatype.TryParseValue(value, nameTable, nsmgr, out valueToCheck) == null) { //no error
                    memberType = st;
                    break;
                } 
            }
            if (valueToCheck == null) { 
                exception = new XmlSchemaException(Res.Sch_UnionFailedEx, value.ToString()); 
                goto Error;
            } 
            try {
                if (this.HasLexicalFacets) {
                    string s1 = (string)this.ValueConverter.ChangeType(valueToCheck, typeof(System.String), nsmgr); //Using value here to avoid info loss
                    exception = unionFacetsChecker.CheckLexicalFacets(ref s1, this); 
                    if (exception != null) goto Error;
                } 
                typedValue = new XsdSimpleValue(memberType, valueToCheck); 
                if (this.HasValueFacets) {
                    exception = unionFacetsChecker.CheckValueFacets(typedValue, this); 
                    if (exception != null) goto Error;
                }
                return null;
            } 
            catch (FormatException e) { //Catching for exceptions thrown by ValueConverter
                exception = e; 
            } 
            catch (InvalidCastException e) { //Catching for exceptions thrown by ValueConverter
                exception = e; 
            }
            catch (OverflowException e) { //Catching for exceptions thrown by ValueConverter
                exception = e;
            } 
            catch (ArgumentException e) { //Catching for exceptions thrown by ValueConverter
                exception = e; 
            } 

        Error: 
            return exception;
        }
    }
 

    // Primitive datatypes 
    internal class Datatype_anySimpleType : DatatypeImplementation { 
        static readonly Type atomicValueType = typeof(string);
        static readonly Type listValueType = typeof(string[]); 

        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlUntypedConverter.Untyped;
        } 

        internal override FacetsChecker FacetsChecker { get { return miscFacetsChecker; } } 
 
        public override Type ValueType { get { return atomicValueType; }}
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.AnyAtomicType; }}

        internal override Type ListValueType { get { return listValueType; }}
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.None;}}
 
        internal override RestrictionFlags ValidRestrictionFlags { get { return 0;}} 

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 

        internal override int Compare(object value1, object value2) {
            //Changed StringComparison.CurrentCulture to StringComparison.Ordinal to handle zero-weight code points like the cyrillic E
            return String.Compare(value1.ToString(), value2.ToString(), StringComparison.Ordinal); 
        }
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            typedValue = XmlComplianceUtil.NonCDataNormalize(s); //Whitespace facet is treated as collapse since thats the way it was in Everett
            return null; 
        }
    }

    internal class Datatype_anyAtomicType : Datatype_anySimpleType { 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlAnyConverter.AnyAtomic; 
        } 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Preserve; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.AnyAtomicType; } }

    }
 
    internal class Datatype_untypedAtomicType : Datatype_anyAtomicType {
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlUntypedConverter.Untyped; 
        }
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Preserve; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.UntypedAtomic; } }

    } 

 
    /* 
      
         
          
            
            
             
            
             
             
            
             
            
            
          
          
         
         
          
         
      
    */
    internal class Datatype_string : Datatype_anySimpleType {
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlStringConverter.Create(schemaType);
        } 
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Preserve; } }
 
        internal override FacetsChecker FacetsChecker { get { return stringFacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.String; }}
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.CDATA;}}
 
        internal override RestrictionFlags ValidRestrictionFlags { 
            get {
                return RestrictionFlags.Length| 
                       RestrictionFlags.MinLength|
                       RestrictionFlags.MaxLength|
                       RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration| 
                       RestrictionFlags.WhiteSpace;
            } 
        } 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;

            typedValue = null;
 
            exception = stringFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 
 
            exception = stringFacetsChecker.CheckValueFacets(s, this);
            if (exception != null) goto Error; 

            typedValue = s;
            return null;
 
        Error:
            return exception; 
        } 
    }
 
    /*
      
        
           
            
             
             
            
             
            
          
           
        
         
          
         
      
    */
    internal class Datatype_boolean : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(bool); 
        static readonly Type listValueType = typeof(bool[]);
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlBooleanConverter.Create(schemaType);
        } 

        internal override FacetsChecker FacetsChecker { get { return miscFacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Boolean; }} 

        public override Type ValueType { get { return atomicValueType; }} 
 
        internal override Type ListValueType { get { return listValueType; }}
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } }

        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.Pattern|
                       RestrictionFlags.WhiteSpace; 
            } 
        }
 
        internal override int Compare(object value1, object value2) {
            return ((bool)value1).CompareTo(value2);
        }
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 
            typedValue = null; 

            exception = miscFacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error;

            bool boolValue;
            exception = XmlConvert.TryToBoolean(s, out boolValue); 
            if (exception != null) goto Error;
 
            typedValue = boolValue; 

            return null; 

        Error:
            return exception;
        } 
    }
 
    /* 
      
         
          
            
            
             
            
             
             
            
             
            
            
            
           
           
         
        
          
        
      
    */ 
    internal class Datatype_float : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(float); 
        static readonly Type listValueType = typeof(float[]); 

        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlNumeric2Converter.Create(schemaType);
        }

        internal override FacetsChecker FacetsChecker { get { return numeric2FacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Float; }} 
 
        public override Type ValueType { get { return atomicValueType; }}
 
        internal override Type ListValueType { get { return listValueType; }}

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } }
 
        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.Pattern| 
                       RestrictionFlags.Enumeration|
                       RestrictionFlags.WhiteSpace| 
                       RestrictionFlags.MinExclusive|
                       RestrictionFlags.MinInclusive|
                       RestrictionFlags.MaxExclusive|
                       RestrictionFlags.MaxInclusive; 
            }
        } 
 
        internal override int Compare(object value1, object value2) {
            return ((float)value1).CompareTo(value2); 
        }

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 

            typedValue = null; 
 
            exception = numeric2FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            float singleValue;
            exception = XmlConvert.TryToSingle(s, out singleValue);
            if (exception != null) goto Error; 

            exception = numeric2FacetsChecker.CheckValueFacets(singleValue, this); 
            if (exception != null) goto Error; 

            typedValue = singleValue; 

            return null;

        Error: 
            return exception;
        } 
    } 

    /* 
      
        
          
             
            
             
             
            
             
            
            
            
             
            
           
          
         
        
          
         
      
    */ 
    internal class Datatype_double : Datatype_anySimpleType { 
        static readonly Type atomicValueType = typeof(double);
        static readonly Type listValueType = typeof(double[]); 

        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlNumeric2Converter.Create(schemaType);
        } 

        internal override FacetsChecker FacetsChecker { get { return numeric2FacetsChecker; } } 
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Double; }}
 
        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }}
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } }
 
        internal override RestrictionFlags ValidRestrictionFlags { 
            get {
                return RestrictionFlags.Pattern| 
                       RestrictionFlags.Enumeration|
                       RestrictionFlags.WhiteSpace|
                       RestrictionFlags.MinExclusive|
                       RestrictionFlags.MinInclusive| 
                       RestrictionFlags.MaxExclusive|
                       RestrictionFlags.MaxInclusive; 
            } 
        }
 
        internal override int Compare(object value1, object value2) {
            return ((double)value1).CompareTo(value2);
        }
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 
            typedValue = null; 

            exception = numeric2FacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error;

            double doubleValue;
            exception = XmlConvert.TryToDouble(s, out doubleValue); 
            if (exception != null) goto Error;
 
            exception = numeric2FacetsChecker.CheckValueFacets(doubleValue, this); 
            if (exception != null) goto Error;
 
            typedValue = doubleValue;

            return null;
 
        Error:
            return exception; 
        } 
    }
 
    /*
      
        
           
            
             
             
            
             
            
            
            
             
            
             
            
             
          
          
         
        
           
        
        
    */
    internal class Datatype_decimal : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(decimal);
        static readonly Type listValueType = typeof(decimal[]); 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.MinValue, decimal.MaxValue);
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlNumeric10Converter.Create(schemaType);
        } 

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Decimal; }} 

        public override Type ValueType { get { return atomicValueType; }} 
 
        internal override Type ListValueType { get { return listValueType; }}
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } }

        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.TotalDigits|
                       RestrictionFlags.FractionDigits| 
                       RestrictionFlags.Pattern| 
                       RestrictionFlags.Enumeration|
                       RestrictionFlags.WhiteSpace| 
                       RestrictionFlags.MinExclusive|
                       RestrictionFlags.MinInclusive|
                       RestrictionFlags.MaxExclusive|
                       RestrictionFlags.MaxInclusive; 
            }
        } 
 
        internal override int Compare(object value1, object value2) {
            return ((decimal)value1).CompareTo(value2); 
        }

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 

            typedValue = null; 
 
            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            decimal decimalValue;
            exception = XmlConvert.TryToDecimal(s, out decimalValue);
            if (exception != null) goto Error; 

            exception = numeric10FacetsChecker.CheckValueFacets(decimalValue, this); 
            if (exception != null) goto Error; 

            typedValue = decimalValue; 

            return null;

        Error: 
            return exception;
        } 
    } 

    /* 
       
        
          
             
            
             
             
            
             
            
            
            
            
             
           
           
        
        
           
        
        
    */ 
    internal class Datatype_duration : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(TimeSpan); 
        static readonly Type listValueType = typeof(TimeSpan[]);

        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlMiscConverter.Create(schemaType); 
        }
 
        internal override FacetsChecker FacetsChecker { get { return durationFacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Duration; }} 

        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }} 

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 
 
        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration|
                       RestrictionFlags.WhiteSpace|
                       RestrictionFlags.MinExclusive| 
                       RestrictionFlags.MinInclusive|
                       RestrictionFlags.MaxExclusive| 
                       RestrictionFlags.MaxInclusive; 
            }
        } 

        internal override int Compare(object value1, object value2) {
            return ((TimeSpan)value1).CompareTo(value2);
        } 

 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
            typedValue = null; 

            if (s == null || s.Length == 0) {
                return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
            } 

            exception = durationFacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error; 

            TimeSpan timeSpanValue; 
            exception = XmlConvert.TryToTimeSpan(s, out timeSpanValue);
            if (exception != null) goto Error;

            exception = durationFacetsChecker.CheckValueFacets(timeSpanValue, this); 
            if (exception != null) goto Error;
 
            typedValue = timeSpanValue; 

            return null; 

        Error:
            return exception;
        } 
    }
 
    internal class Datatype_yearMonthDuration : Datatype_duration { 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
            typedValue = null;

            if (s == null || s.Length == 0) { 
                return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
            } 
 
            exception = durationFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            XsdDuration duration;
            exception = XsdDuration.TryParse(s, XsdDuration.DurationType.YearMonthDuration, out duration);
            if (exception != null) goto Error; 

            TimeSpan timeSpanValue; 
 
            exception = duration.TryToTimeSpan(XsdDuration.DurationType.YearMonthDuration, out timeSpanValue);
            if (exception != null) goto Error; 

            exception = durationFacetsChecker.CheckValueFacets(timeSpanValue, this);
            if (exception != null) goto Error;
 
            typedValue = timeSpanValue;
 
            return null; 

        Error: 
            return exception;
        }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.YearMonthDuration; } } 

    } 
 
    internal class Datatype_dayTimeDuration : Datatype_duration {
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception;

            typedValue = null; 

            if (s == null || s.Length == 0) { 
                return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty); 
            }
 
            exception = durationFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;

            XsdDuration duration; 
            exception = XsdDuration.TryParse(s, XsdDuration.DurationType.DayTimeDuration, out duration);
            if (exception != null) goto Error; 
 
            TimeSpan timeSpanValue;
            exception = duration.TryToTimeSpan(XsdDuration.DurationType.DayTimeDuration, out timeSpanValue); 
            if (exception != null) goto Error;

            exception = durationFacetsChecker.CheckValueFacets(timeSpanValue, this);
            if (exception != null) goto Error; 

            typedValue = timeSpanValue; 
 
            return null;
 
        Error:
            return exception;
        }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.DayTimeDuration; } }
 
    } 

    internal class Datatype_dateTimeBase : Datatype_anySimpleType { 
        static readonly Type atomicValueType = typeof(DateTime);
        static readonly Type listValueType = typeof(DateTime[]);
        private XsdDateTimeFlags dateTimeFlags;
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlDateTimeConverter.Create(schemaType); 
        } 

        internal override FacetsChecker FacetsChecker { get { return dateTimeFacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.DateTime; }}

        internal Datatype_dateTimeBase() { 
        }
 
        internal Datatype_dateTimeBase(XsdDateTimeFlags dateTimeFlags) { 
            this.dateTimeFlags = dateTimeFlags;
        } 

        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }} 

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 
 
        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration|
                       RestrictionFlags.WhiteSpace|
                       RestrictionFlags.MinExclusive| 
                       RestrictionFlags.MinInclusive|
                       RestrictionFlags.MaxExclusive| 
                       RestrictionFlags.MaxInclusive; 
            }
        } 

        internal override int Compare(object value1, object value2) {
            DateTime dateTime1 = (DateTime)value1;
            DateTime dateTime2 = (DateTime)value2; 
            if (dateTime1.Kind == DateTimeKind.Unspecified || dateTime2.Kind == DateTimeKind.Unspecified) { //If either of them are unspecified, do not convert zones
                return dateTime1.CompareTo(dateTime2); 
            } 
            dateTime1 = dateTime1.ToUniversalTime();
            return dateTime1.CompareTo(dateTime2.ToUniversalTime()); 
        }

         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 
            typedValue = null;
 
            exception = dateTimeFacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error;
 
            XsdDateTime dateTime;
            if (!XsdDateTime.TryParse(s, dateTimeFlags, out dateTime)) {
                exception = new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "XsdDateTime"));
                goto Error; 
            }
 
            DateTime dateTimeValue = DateTime.MinValue; 
            try {
                dateTimeValue = (DateTime)dateTime; 
            }
            catch (ArgumentException e) {
                exception = e;
                goto Error; 
            }
 
            exception = dateTimeFacetsChecker.CheckValueFacets(dateTimeValue, this); 
            if (exception != null) goto Error;
 
            typedValue = dateTimeValue;

            return null;
 
        Error:
            return exception; 
        } 
    }
 
    internal class Datatype_dateTimeNoTimeZone : Datatype_dateTimeBase {
        internal Datatype_dateTimeNoTimeZone() : base(XsdDateTimeFlags.XdrDateTimeNoTz) { }
    }
 
    internal class Datatype_dateTimeTimeZone : Datatype_dateTimeBase {
        internal Datatype_dateTimeTimeZone() : base(XsdDateTimeFlags.XdrDateTime) {} 
    } 

    /* 
      
       
        
             
            
             
             
            
             
            
            
            
            
             
           
           
        
        
           
        
       
    */ 
    internal class Datatype_dateTime : Datatype_dateTimeBase {
        internal Datatype_dateTime() : base(XsdDateTimeFlags.DateTime) {} 
    }

    internal class Datatype_timeNoTimeZone : Datatype_dateTimeBase {
        internal Datatype_timeNoTimeZone() : base(XsdDateTimeFlags.XdrTimeNoTz) { } 
    }
 
    internal class Datatype_timeTimeZone : Datatype_dateTimeBase { 
        internal Datatype_timeTimeZone() : base(XsdDateTimeFlags.Time) { }
    } 

    /*
      
         
        
             
             
            
             
            
            
            
             
            
             
            
           
          
        
         
           
         
      
    */ 
    internal class Datatype_time : Datatype_dateTimeBase {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Time; }}

        internal Datatype_time() : base(XsdDateTimeFlags.Time) {} 
    }
 
    /* 
      
        
        
            
            
             
            
             
             
            
             
            
            
             
          
           
        
         
          
        
       
    */
    internal class Datatype_date : Datatype_dateTimeBase { 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Date; }} 

        internal Datatype_date() : base(XsdDateTimeFlags.Date) { } 
    }

    /*
       
       
         
             
            
             
            
            
            
             
            
             
            
             
          
          
         
        
           
        
       
    */
    internal class Datatype_yearMonth : Datatype_dateTimeBase {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.GYearMonth; }}
 
        internal Datatype_yearMonth() : base(XsdDateTimeFlags.GYearMonth) { }
    } 
 

    /* 
      
        
        
             
            
             
             
            
             
            
            
            
            
             
           
           
        
        
           
        
       
    */ 
    internal class Datatype_year : Datatype_dateTimeBase {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.GYear; }} 

        internal Datatype_year() : base(XsdDateTimeFlags.GYear) { }
    }
 
    /*
      
         
          
             
            
            
            
             
            
             
             
            
            
            
          
           
         
         
              
        
      
    */
    internal class Datatype_monthDay : Datatype_dateTimeBase { 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.GMonthDay; }}
 
        internal Datatype_monthDay() : base(XsdDateTimeFlags.GMonthDay) { } 
    }
 
    /*
      
        
           
            
             
             
            
             
            
            
            
             
             
             
          
          
        
        
             
         
       
    */
    internal class Datatype_day : Datatype_dateTimeBase { 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.GDay; }}

        internal Datatype_day() : base(XsdDateTimeFlags.GDay) { }
    } 

 
    /* 
     
         
      
            
            
             
            
             
             
            
             
            
            
             
          
           
        
         
             
        
       
    */
    internal class Datatype_month : Datatype_dateTimeBase { 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.GMonth; }} 

        internal Datatype_month() : base(XsdDateTimeFlags.GMonth) { } 
    }

    /*
        
        
           
             
            
             
            
            
            
             
            
             
            
           
          
        
         
           
         
       
    */ 
    internal class Datatype_hexBinary : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(byte[]);
        static readonly Type listValueType = typeof(byte[][]);
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlMiscConverter.Create(schemaType); 
        } 

        internal override FacetsChecker FacetsChecker { get { return binaryFacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.HexBinary; }}

        public override Type ValueType { get { return atomicValueType; }} 

        internal override Type ListValueType { get { return listValueType; }} 
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } }
 
        internal override RestrictionFlags ValidRestrictionFlags {
            get {
                return RestrictionFlags.Length|
                       RestrictionFlags.MinLength| 
                       RestrictionFlags.MaxLength|
                       RestrictionFlags.Pattern| 
                       RestrictionFlags.Enumeration| 
                       RestrictionFlags.WhiteSpace;
            } 
        }

        internal override int Compare(object value1, object value2) {
            return Compare((byte[])value1, (byte[])value2); 
        }
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
 
            typedValue = null;

            exception = binaryFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            byte[] byteArrayValue = null; 
            try { 
                byteArrayValue = XmlConvert.FromBinHexString(s, false);
            } 
            catch (ArgumentException e) {
                exception = e;
                goto Error;
            } 
            catch (XmlException e) {
                exception = e; 
                goto Error; 
            }
 
            exception = binaryFacetsChecker.CheckValueFacets(byteArrayValue, this);
            if (exception != null) goto Error;

            typedValue = byteArrayValue; 

            return null; 
 
        Error:
            return exception; 
        }
    }

 
    /*
      
         
          
             
            
            
            
             
            
             
             
             
            
          
           
        
         
          
         
       
    */
    internal class Datatype_base64Binary : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(byte[]); 
        static readonly Type listValueType = typeof(byte[][]);
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlMiscConverter.Create(schemaType);
        } 

        internal override FacetsChecker FacetsChecker { get { return binaryFacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Base64Binary; }} 

        public override Type ValueType { get { return atomicValueType; }} 
 
        internal override Type ListValueType { get { return listValueType; }}
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } }

        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.Length|
                       RestrictionFlags.MinLength| 
                       RestrictionFlags.MaxLength| 
                       RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration| 
                       RestrictionFlags.WhiteSpace;
            }
        }
 
        internal override int Compare(object value1, object value2) {
            return Compare((byte[])value1, (byte[])value2); 
        } 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;

            typedValue = null;
 
            exception = binaryFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 
 
            byte[] byteArrayValue = null;
            try { 
                byteArrayValue = Convert.FromBase64String(s);
            }
            catch (ArgumentException e) {
                exception = e; 
                goto Error;
            } 
            catch (FormatException e) { 
                exception = e;
                goto Error; 
            }

            exception = binaryFacetsChecker.CheckValueFacets(byteArrayValue, this);
            if (exception != null) goto Error; 

            typedValue = byteArrayValue; 
 
            return null;
 
        Error:
            return exception;
        }
    } 

    /* 
        
        
           
            
            
            
             
            
             
             
            
            
            
          
          
         
         
           
        
       
    */
    internal class Datatype_anyURI : Datatype_anySimpleType { 
        static readonly Type atomicValueType = typeof(Uri);
        static readonly Type listValueType = typeof(Uri[]); 
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlMiscConverter.Create(schemaType); 
        }

        internal override FacetsChecker FacetsChecker { get { return stringFacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.AnyUri; }}
 
        public override Type ValueType { get { return atomicValueType; }} 

        internal override bool HasValueFacets { 
            get {
                return true; //Built-in facet to check validity of Uri
            }
        } 
        internal override Type ListValueType { get { return listValueType; }}
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 

        internal override RestrictionFlags ValidRestrictionFlags { 
            get {
                return RestrictionFlags.Length|
                       RestrictionFlags.MinLength|
                       RestrictionFlags.MaxLength| 
                       RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration| 
                       RestrictionFlags.WhiteSpace; 
            }
        } 

        internal override int Compare(object value1, object value2) {
            return ((Uri)value1).Equals((Uri)value2) ? 0 : -1;
        } 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            exception = stringFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;
 
            Uri uri;
            exception = XmlConvert.TryToUri(s, out uri); 
            if (exception != null) goto Error; 

            string stringValue = uri.OriginalString; 
            exception = ((StringFacetsChecker)stringFacetsChecker).CheckValueFacets(stringValue, this, false);
            if (exception != null) goto Error;

            typedValue = uri; 

            return null; 
 
        Error:
            return exception; 
        }
    }

    /* 
      
         
             
            
             
            
            
            
             
            
             
            
             
          
          
         
        
           
        
       
    */
    internal class Datatype_QName : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(XmlQualifiedName);
        static readonly Type listValueType = typeof(XmlQualifiedName[]); 

        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlMiscConverter.Create(schemaType); 
        }
 
        internal override FacetsChecker FacetsChecker { get { return qnameFacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.QName; }}
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.QName;}}
 
        internal override RestrictionFlags ValidRestrictionFlags { 
            get {
                return RestrictionFlags.Length| 
                       RestrictionFlags.MinLength|
                       RestrictionFlags.MaxLength|
                       RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration| 
                       RestrictionFlags.WhiteSpace;
            } 
        } 

        public override Type ValueType { get { return atomicValueType; }} 

        internal override Type ListValueType { get { return listValueType; }}

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            if (s == null || s.Length == 0) {
                return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
            } 

            exception = qnameFacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error; 

            XmlQualifiedName qname = null; 
            try {
                string prefix;
                qname = XmlQualifiedName.Parse(s, nsmgr, out prefix);
            } 
            catch (ArgumentException e) {
                exception = e; 
                goto Error; 
            }
            catch (XmlException e) { 
                exception = e;
                goto Error;
            }
 
            exception = qnameFacetsChecker.CheckValueFacets(qname, this);
            if (exception != null) goto Error; 
 
            typedValue = qname;
 
            return null;

        Error:
            return exception; 
        }
    } 
 
    /*
       
        
          
         
        
           
        
       
    */
    internal class Datatype_normalizedString : Datatype_string {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NormalizedString; }}
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Replace; } }
 
        internal override bool HasValueFacets { 
            get {
                return true; //Built-in facet to check validity of NormalizedString 
            }
        }
    }
 
    internal class Datatype_normalizedStringV1Compat : Datatype_string {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NormalizedString; }} 
        internal override bool HasValueFacets { 
            get {
                return true; //Built-in facet to check validity of NormalizedString 
            }
        }
    }
 
    /*
       
         
           
        
        
          
         
      
    */ 
    internal class Datatype_token : Datatype_normalizedString { 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Token; }}
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 
    }

    internal class Datatype_tokenV1Compat : Datatype_normalizedStringV1Compat {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Token; }} 
    }
 
    /* 
      
         
          
        
         
           
            
              
                pattern specifies the content of section 2.12 of XML 1.0e2
                and RFC 1766
               
            
           
         
      
    */ 
    internal class Datatype_language : Datatype_token {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Language; }}
    }
 
    /*
       
         
           
        
        
          
             
               
                pattern matches production 7 from the XML spec 
              
             
          
        
      
    */ 
    internal class Datatype_NMTOKEN : Datatype_token {
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NmToken; }} 

        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.NMTOKEN;}} 
    }

    /*
       
        
           
        
         
          
            
               
                pattern matches production 5 from the XML spec
               
             
          
         
      
    */
    internal class Datatype_Name : Datatype_token {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Name; }} 
    }
 
    /* 
      
         
          
        
         
          
             
              
                pattern matches production 4 from the Namespaces in XML spec 
              
            
          
         
      
    */ 
    internal class Datatype_NCName : Datatype_Name { 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NCName; }} 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception;
 
            typedValue = null;
 
            exception = stringFacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error;
 
            exception = stringFacetsChecker.CheckValueFacets(s, this);
            if (exception != null) goto Error;

            nameTable.Add(s); 

            typedValue = s; 
            return null; 

        Error: 
            return exception;
        }
    }
 
    /*
        
         
           
        
        
       
    */ 
    internal class Datatype_ID : Datatype_NCName {
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Id; }} 

        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.ID;}} 
    }

    /*
        
        
           
        
         
       
    */
    internal class Datatype_IDREF : Datatype_NCName {
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Idref; }}
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.IDREF;}} 
    }
 
    /*
       
        
          
         
         
       
    */ 
    internal class Datatype_ENTITY : Datatype_NCName {

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Entity; }}
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.ENTITY;}}
 
    } 

    /* 
       
        
            
             
            
             
             
            
             
            
            
             
            
           
          
           
            NOTATION cannot be used directly in a schema; rather a type
            must be derived from it by specifying at least one enumeration
            facet whose value is the name of a NOTATION declared in the
            schema. 
          
         
         
           
        
      
    */
    internal class Datatype_NOTATION : Datatype_anySimpleType { 
        static readonly Type atomicValueType = typeof(XmlQualifiedName);
        static readonly Type listValueType = typeof(XmlQualifiedName[]); 
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlMiscConverter.Create(schemaType); 
        }

        internal override FacetsChecker FacetsChecker { get { return qnameFacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Notation; }}
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.NOTATION;}} 

        internal override RestrictionFlags ValidRestrictionFlags { 
            get {
                return RestrictionFlags.Length|
                       RestrictionFlags.MinLength|
                       RestrictionFlags.MaxLength| 
                       RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration| 
                       RestrictionFlags.WhiteSpace; 
            }
        } 

        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }} 

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 

            typedValue = null;

            if (s == null || s.Length == 0) { 
                return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
            } 
 
            exception = qnameFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            XmlQualifiedName qname = null;
            try {
                string prefix; 
                qname = XmlQualifiedName.Parse(s, nsmgr, out prefix);
            } 
            catch (ArgumentException e) { 
                exception = e;
                goto Error; 
            }
            catch (XmlException e) {
                exception = e;
                goto Error; 
            }
 
            exception = qnameFacetsChecker.CheckValueFacets(qname, this); 
            if (exception != null) goto Error;
 
            typedValue = qname;

            return null;
 
        Error:
            return exception; 
        } 

        internal override void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller) { 

            // Only datatypes that are derived from NOTATION by specifying a value for enumeration can be used in a schema.
            // Furthermore, the value of all enumeration facets must match the name of a notation declared in the current schema.                    //
            for(Datatype_NOTATION dt = this; dt != null; dt = (Datatype_NOTATION)dt.Base) { 
                if (dt.Restriction != null && (dt.Restriction.Flags & RestrictionFlags.Enumeration) != 0) {
                    foreach(XmlQualifiedName notation in dt.Restriction.Enumeration) { 
                        if (!notations.Contains(notation)) { 
                            throw new XmlSchemaException(Res.Sch_NotationRequired, caller);
                        } 
                    }
                    return;
                }
            } 
            throw new XmlSchemaException(Res.Sch_NotationRequired, caller);
        } 
    } 

    /* 
      
        
           
        
         
           
        
       
    */
    internal class Datatype_integer : Datatype_decimal {

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Integer; }} 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            exception = FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;
 
            decimal decimalValue;
            exception = XmlConvert.TryToInteger(s, out decimalValue); 
            if (exception != null) goto Error; 

            exception = FacetsChecker.CheckValueFacets(decimalValue, this); 
            if (exception != null) goto Error;

            typedValue = decimalValue;
 
            return null;
 
        Error: 
            return exception;
        } 
    }

    /*
       
        
           
        
         
          
        
      
    */ 
    internal class Datatype_nonPositiveInteger : Datatype_integer {
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.MinValue, decimal.Zero); 
 
        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NonPositiveInteger; }}

        internal override bool HasValueFacets {
            get { 
                return true; //Built-in facet to check range
            } 
        } 
    }
 

    /*
      
         
           
         
        
           
        
      
    */
    internal class Datatype_negativeInteger : Datatype_nonPositiveInteger { 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.MinValue, decimal.MinusOne);
 
        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NegativeInteger; }} 
    }


    /* 
      
         
           
            
             
          
          
         
        
           
           
        
       
    */
    internal class Datatype_long : Datatype_integer {
        static readonly Type atomicValueType = typeof(long);
        static readonly Type listValueType = typeof(long[]); 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(long.MinValue, long.MaxValue);
 
        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } } 

        internal override bool HasValueFacets { 
            get {
                return true; //Built-in facet to check range
            }
        } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Long; }} 
 
        internal override int Compare(object value1, object value2) {
            return ((long)value1).CompareTo(value2); 
        }

        public override Type ValueType { get { return atomicValueType; }}
 
        internal override Type ListValueType { get { return listValueType; }}
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
 
            typedValue = null;

            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            long int64Value; 
            exception = XmlConvert.TryToInt64(s, out int64Value); 
            if (exception != null) goto Error;
 
            exception = numeric10FacetsChecker.CheckValueFacets(int64Value, this);
            if (exception != null) goto Error;

            typedValue = int64Value; 

            return null; 
 
        Error:
            return exception; 
        }
    }

    /* 
      
         
          
         
        
          
          
         
      
    */ 
    internal class Datatype_int : Datatype_long { 
        static readonly Type atomicValueType = typeof(int);
        static readonly Type listValueType = typeof(int[]); 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(int.MinValue, int.MaxValue);

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Int; }}
 
        internal override int Compare(object value1, object value2) { 
            return ((int)value1).CompareTo(value2);
        } 

        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }} 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;
 
            int int32Value;
            exception = XmlConvert.TryToInt32(s, out int32Value); 
            if (exception != null) goto Error; 

            exception = numeric10FacetsChecker.CheckValueFacets(int32Value, this); 
            if (exception != null) goto Error;

            typedValue = int32Value;
 
            return null;
 
        Error: 
            return exception;
        } 
    }


    /* 
      
         
          
         
        
          
          
         
      
    */ 
    internal class Datatype_short : Datatype_int { 
        static readonly Type atomicValueType = typeof(short);
        static readonly Type listValueType = typeof(short[]); 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(short.MinValue, short.MaxValue);

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Short; }}
 
        internal override int Compare(object value1, object value2) { 
            return ((short)value1).CompareTo(value2);
        } 

        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }} 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;
 
            short int16Value;
            exception = XmlConvert.TryToInt16(s, out int16Value); 
            if (exception != null) goto Error; 

            exception = numeric10FacetsChecker.CheckValueFacets(int16Value, this); 
            if (exception != null) goto Error;

            typedValue = int16Value;
 
            return null;
 
        Error: 
            return exception;
        } 
    }

    /*
       
        
           
        
         
          
          
        
       
    */
    internal class Datatype_byte : Datatype_short { 
        static readonly Type atomicValueType = typeof(sbyte); 
        static readonly Type listValueType = typeof(sbyte[]);
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(sbyte.MinValue, sbyte.MaxValue); 

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Byte; }} 

        internal override int Compare(object value1, object value2) { 
            return ((sbyte)value1).CompareTo(value2); 
        }
 
        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }}
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 
 
            typedValue = null;
 
            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;

            sbyte sbyteValue; 
            exception = XmlConvert.TryToSByte(s, out sbyteValue);
            if (exception != null) goto Error; 
 
            exception = numeric10FacetsChecker.CheckValueFacets((short)sbyteValue, this);
            if (exception != null) goto Error; 

            typedValue = sbyteValue;

            return null; 

        Error: 
            return exception; 
        }
    } 

    /*
      
         
           
         
        
           
        
      
    */
    internal class Datatype_nonNegativeInteger : Datatype_integer { 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.Zero,decimal.MaxValue);
 
        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NonNegativeInteger; }} 

        internal override bool HasValueFacets {
            get {
                return true; //Built-in facet to check range 
            }
        } 
    } 

    /* 
      
        
          
             
            
           
          
         
        
          
         
      
    */ 
    internal class Datatype_unsignedLong : Datatype_nonNegativeInteger { 
        static readonly Type atomicValueType = typeof(ulong);
        static readonly Type listValueType = typeof(ulong[]); 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(ulong.MinValue, ulong.MaxValue);

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.UnsignedLong; }}
 
        internal override int Compare(object value1, object value2) { 
            return ((ulong)value1).CompareTo(value2);
        } 

        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }} 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;
 
            ulong uint64Value;
            exception = XmlConvert.TryToUInt64(s, out uint64Value); 
            if (exception != null) goto Error; 

            exception = numeric10FacetsChecker.CheckValueFacets((decimal)uint64Value, this); 
            if (exception != null) goto Error;

            typedValue = uint64Value;
 
            return null;
 
        Error: 
            return exception;
        } 
    }

    /*
       
        
           
        
         
          
        
       
    */
    internal class Datatype_unsignedInt : Datatype_unsignedLong { 
        static readonly Type atomicValueType = typeof(uint); 
        static readonly Type listValueType = typeof(uint[]);
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(uint.MinValue, uint.MaxValue); 

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.UnsignedInt; }} 

        internal override int Compare(object value1, object value2) { 
            return ((uint)value1).CompareTo(value2); 
        }
 
        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }}
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 
 
            typedValue = null;
 
            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;

            uint uint32Value; 
            exception = XmlConvert.TryToUInt32(s, out uint32Value);
            if (exception != null) goto Error; 
 
            exception = numeric10FacetsChecker.CheckValueFacets((long)uint32Value, this);
            if (exception != null) goto Error; 

            typedValue = uint32Value;

            return null; 

        Error: 
            return exception; 
        }
    } 

    /*
      
         
           
         
        
          
        
      
    */ 
    internal class Datatype_unsignedShort : Datatype_unsignedInt {
        static readonly Type atomicValueType = typeof(ushort); 
        static readonly Type listValueType = typeof(ushort[]); 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(ushort.MinValue, ushort.MaxValue);
 
        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.UnsignedShort; }}
 
        internal override int Compare(object value1, object value2) {
            return ((ushort)value1).CompareTo(value2); 
        } 

        public override Type ValueType { get { return atomicValueType; }} 

        internal override Type ListValueType { get { return listValueType; }}

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
 
            typedValue = null; 

            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error;

            ushort uint16Value;
            exception = XmlConvert.TryToUInt16(s, out uint16Value); 
            if (exception != null) goto Error;
 
            exception = numeric10FacetsChecker.CheckValueFacets((int)uint16Value, this); 
            if (exception != null) goto Error;
 
            typedValue = uint16Value;

            return null;
 
        Error:
            return exception; 
        } 
    }
 
    /*
      
        
          
         
         
          
         
      
    */
    internal class Datatype_unsignedByte : Datatype_unsignedShort {
        static readonly Type atomicValueType = typeof(byte); 
        static readonly Type listValueType = typeof(byte[]);
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(byte.MinValue, byte.MaxValue); 
 
        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.UnsignedByte; }}

        internal override int Compare(object value1, object value2) {
            return ((byte)value1).CompareTo(value2); 
        }
 
        public override Type ValueType { get { return atomicValueType; }} 

        internal override Type ListValueType { get { return listValueType; }} 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception;
 
            typedValue = null;
 
            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error;
 
            byte byteValue;
            exception = XmlConvert.TryToByte(s, out byteValue);
            if (exception != null) goto Error;
 
            exception = numeric10FacetsChecker.CheckValueFacets((short)byteValue, this);
            if (exception != null) goto Error; 
 
            typedValue = byteValue;
 
            return null;

        Error:
            return exception; 
        }
    } 
 
    /*
       
        
          
         
        
           
         
      
    */ 
    internal class Datatype_positiveInteger : Datatype_nonNegativeInteger {
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.One, decimal.MaxValue);

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.PositiveInteger; }} 
    } 

    /* 
        XDR
    */
    internal class Datatype_doubleXdr : Datatype_double {
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) { 
             double value;
            try { 
               value = XmlConvert.ToDouble(s); 
            }
            catch(Exception e) { 
                throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
            }
            if (double.IsInfinity(value) || double.IsNaN(value)) {
                throw new XmlSchemaException(Res.Sch_InvalidValue, s); 
            }
            return value; 
        } 
    }
 
    internal class Datatype_floatXdr : Datatype_float {
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) {
            float value;
            try { 
                value = XmlConvert.ToSingle(s);
            } 
            catch(Exception e) { 
                throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
            } 
            if (float.IsInfinity(value) || float.IsNaN(value)) {
                throw new XmlSchemaException(Res.Sch_InvalidValue, s);
            }
            return value; 
        }
    } 
 
    internal class Datatype_QNameXdr : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(XmlQualifiedName); 
        static readonly Type listValueType = typeof(XmlQualifiedName[]);

        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.QName;}}
 
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) {
            if (s == null || s.Length == 0) { 
                throw new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty); 
            }
            if (nsmgr == null) { 
                throw new ArgumentNullException("nsmgr");
            }
            string prefix;
            try { 
                return XmlQualifiedName.Parse(s.Trim(), nsmgr, out prefix);
            } 
            catch (XmlSchemaException e) { 
                throw e;
            } 
            catch (Exception e) {
                throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
            }
        } 

        public override Type ValueType { get { return atomicValueType; }} 
 
        internal override Type ListValueType { get { return listValueType; }}
    } 

    internal class Datatype_ENUMERATION : Datatype_NMTOKEN {
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.ENUMERATION;}}
    } 

    internal class Datatype_char : Datatype_anySimpleType { 
        static readonly Type atomicValueType = typeof(char); 
        static readonly Type listValueType = typeof(char[]);
 
        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }}
 
        internal override RestrictionFlags ValidRestrictionFlags { get { return 0; }} //XDR only
 
        internal override int Compare(object value1, object value2) { 
            // this should be culture sensitive - comparing values
            return ((char)value1).CompareTo(value2); 
        }

        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) {
            try { 
                return XmlConvert.ToChar(s);
            } 
            catch (XmlSchemaException e) { 
                throw e;
            } 
            catch (Exception e) {
                throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
            }
        } 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            char charValue;
            exception = XmlConvert.TryToChar(s, out charValue);
            if (exception != null) goto Error; 

            typedValue = charValue; 
 
            return null;
 
        Error:
            return exception;
        }
    } 

    internal class Datatype_fixed : Datatype_decimal { 
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) { 
            Exception exception;
 
            try {
                Numeric10FacetsChecker facetsChecker = this.FacetsChecker as Numeric10FacetsChecker;
                decimal value = XmlConvert.ToDecimal(s);
                exception = facetsChecker.CheckTotalAndFractionDigits(value, 14 + 4, 4, true, true); 
                if (exception != null) goto Error;
 
                return value; 
            }
            catch (XmlSchemaException e) { 
                throw e;
            }
            catch (Exception e) {
                throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e); 
            }
        Error: 
            throw exception; 
        }
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception;

            typedValue = null; 

            decimal decimalValue; 
            exception = XmlConvert.TryToDecimal(s, out decimalValue); 
            if (exception != null) goto Error;
 
            Numeric10FacetsChecker facetsChecker = this.FacetsChecker as Numeric10FacetsChecker;
            exception = facetsChecker.CheckTotalAndFractionDigits(decimalValue, 14 + 4, 4, true, true);
            if (exception != null) goto Error;
 
            typedValue = decimalValue;
 
            return null; 

        Error: 
            return exception;
        }
    }
 
    internal class Datatype_uuid : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(Guid); 
        static readonly Type listValueType = typeof(Guid[]); 

        public override Type ValueType { get { return atomicValueType; }} 

        internal override Type ListValueType { get { return listValueType; }}

        internal override RestrictionFlags ValidRestrictionFlags { get { return 0; }} 

        internal override int Compare(object value1, object value2) { 
            return ((Guid)value1).Equals(value2) ? 0 : -1; 
        }
 
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) {
            try {
                return XmlConvert.ToGuid(s);
            } 
            catch (XmlSchemaException e) {
                throw e; 
            } 
            catch (Exception e) {
                throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e); 
            }
        }

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
 
            typedValue = null; 

            Guid guid; 
            exception = XmlConvert.TryToGuid(s, out guid);
            if (exception != null) goto Error;

            typedValue = guid; 

            return null; 
 
        Error:
            return exception; 
        }
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
namespace System.Xml.Schema { 

    using System; 
    using System.IO;
    using System.Collections;
    using System.Diagnostics;
    using System.Globalization; 
    using System.Text;
    using System.Text.RegularExpressions; 
    using System.Xml; 
    using System.Xml.XPath;
    using System.Xml.Serialization; 

    /// 
    public enum XmlSchemaDatatypeVariety {
        ///  
        Atomic,
        ///  
        List, 
        /// 
        Union 
    }

    internal class XsdSimpleValue { //Wrapper to store XmlType and TypedValue together
        XmlSchemaSimpleType xmlType; 
        object  typedValue;
 
        public XsdSimpleValue(XmlSchemaSimpleType st, object value) { 
            xmlType = st;
            typedValue = value; 
        }

        public XmlSchemaSimpleType XmlType {
            get { 
                return xmlType;
            } 
        } 

        public object TypedValue { 
            get {
                return typedValue;
            }
        } 
    }
 
 
    [Flags]
    internal enum RestrictionFlags { 
        Length              = 0x0001,
        MinLength           = 0x0002,
        MaxLength           = 0x0004,
        Pattern             = 0x0008, 
        Enumeration         = 0x0010,
        WhiteSpace          = 0x0020, 
        MaxInclusive        = 0x0040, 
        MaxExclusive        = 0x0080,
        MinInclusive        = 0x0100, 
        MinExclusive        = 0x0200,
        TotalDigits         = 0x0400,
        FractionDigits      = 0x0800,
    } 

    internal enum XmlSchemaWhiteSpace { 
        Preserve, 
        Replace,
        Collapse, 
    }

    internal class RestrictionFacets {
        internal int Length; 
        internal int MinLength;
        internal int MaxLength; 
        internal ArrayList Patterns; 
        internal ArrayList Enumeration;
        internal XmlSchemaWhiteSpace WhiteSpace; 
        internal object MaxInclusive;
        internal object MaxExclusive;
        internal object MinInclusive;
        internal object MinExclusive; 
        internal int TotalDigits;
        internal int FractionDigits; 
        internal RestrictionFlags Flags = 0; 
        internal RestrictionFlags FixedFlags = 0;
    } 

    internal abstract class DatatypeImplementation : XmlSchemaDatatype {
        private XmlSchemaDatatypeVariety variety = XmlSchemaDatatypeVariety.Atomic;
        private RestrictionFacets restriction = null; 
        private DatatypeImplementation baseType = null;
        private XmlValueConverter valueConverter; 
        private XmlSchemaType parentSchemaType; 

        private static Hashtable builtinTypes = new Hashtable(); 
        private static XmlSchemaSimpleType[] enumToTypeCode = new XmlSchemaSimpleType[(int) XmlTypeCode.DayTimeDuration + 1];
        private static XmlSchemaSimpleType anySimpleType;
        private static XmlSchemaSimpleType anyAtomicType;
        private static XmlSchemaSimpleType untypedAtomicType; 
        private static XmlSchemaSimpleType yearMonthDurationType;
        private static XmlSchemaSimpleType dayTimeDurationType; 
        private static XmlSchemaSimpleType normalizedStringTypeV1Compat; 
        private static XmlSchemaSimpleType tokenTypeV1Compat;
 
        private const int anySimpleTypeIndex = 11;

        internal static XmlQualifiedName QnAnySimpleType = new XmlQualifiedName("anySimpleType",XmlReservedNs.NsXs);
        internal static XmlQualifiedName QnAnyType = new XmlQualifiedName("anyType",XmlReservedNs.NsXs); 

        //Create facet checkers 
        internal static FacetsChecker stringFacetsChecker = new StringFacetsChecker(); 
        internal static FacetsChecker miscFacetsChecker = new MiscFacetsChecker();
        internal static FacetsChecker numeric2FacetsChecker = new Numeric2FacetsChecker(); 
        internal static FacetsChecker binaryFacetsChecker = new BinaryFacetsChecker();
        internal static FacetsChecker dateTimeFacetsChecker = new DateTimeFacetsChecker();
        internal static FacetsChecker durationFacetsChecker = new DurationFacetsChecker();
        internal static FacetsChecker listFacetsChecker = new ListFacetsChecker(); 
        internal static FacetsChecker qnameFacetsChecker = new QNameFacetsChecker();
        internal static FacetsChecker unionFacetsChecker = new UnionFacetsChecker(); 
 
        static DatatypeImplementation() {
            CreateBuiltinTypes(); 
        }

        internal static XmlSchemaSimpleType AnySimpleType { get { return anySimpleType; } }
 
        // Additional built-in XQuery simple types
        internal static XmlSchemaSimpleType AnyAtomicType { get { return anyAtomicType; } } 
        internal static XmlSchemaSimpleType UntypedAtomicType { get { return untypedAtomicType; } } 
        internal static XmlSchemaSimpleType YearMonthDurationType { get { return yearMonthDurationType; } }
        internal static XmlSchemaSimpleType DayTimeDurationType { get { return dayTimeDurationType; } } 

        internal new static DatatypeImplementation FromXmlTokenizedType(XmlTokenizedType token) {
            return c_tokenizedTypes[(int)token];
        } 

        internal new static DatatypeImplementation FromXmlTokenizedTypeXsd(XmlTokenizedType token) { 
            return c_tokenizedTypesXsd[(int)token]; 
        }
 
        internal new static DatatypeImplementation FromXdrName(string name) {
            int i = Array.BinarySearch(c_XdrTypes, name, null);
            return i < 0 ? null : (DatatypeImplementation)c_XdrTypes[i];
        } 

        private static DatatypeImplementation FromTypeName(string name) { 
            int i = Array.BinarySearch(c_XsdTypes, name, null); 
            return i < 0 ? null : (DatatypeImplementation)c_XsdTypes[i];
        } 

        /// 
        /// Begin the creation of an XmlSchemaSimpleType object that will be used to represent a static built-in type.
        /// Once StartBuiltinType has been called for all built-in types, FinishBuiltinType should be called in order 
        /// to create links between the types.
        ///  
        internal static XmlSchemaSimpleType StartBuiltinType(XmlQualifiedName qname, XmlSchemaDatatype dataType) { 
            XmlSchemaSimpleType simpleType;
            Debug.Assert(qname != null && dataType != null); 

            simpleType = new XmlSchemaSimpleType();
            simpleType.SetQualifiedName(qname);
            simpleType.SetDatatype(dataType); 
            simpleType.ElementDecl = new SchemaElementDecl(dataType);
            simpleType.ElementDecl.SchemaType = simpleType; 
 
            return simpleType;
        } 

        /// 
        /// Finish constructing built-in types by setting up derivation and list links.
        ///  
        internal static void FinishBuiltinType(XmlSchemaSimpleType derivedType, XmlSchemaSimpleType baseType) {
            Debug.Assert(derivedType != null && baseType != null); 
 
            // Create link from the derived type to the base type
            derivedType.SetBaseSchemaType(baseType); 
            derivedType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction);
            if (derivedType.Datatype.Variety == XmlSchemaDatatypeVariety.Atomic) { //Content is restriction
                XmlSchemaSimpleTypeRestriction restContent = new XmlSchemaSimpleTypeRestriction();
                restContent.BaseTypeName = baseType.QualifiedName; 
                derivedType.Content = restContent;
            } 
 
            // Create link from a list type to its member type
            if (derivedType.Datatype.Variety == XmlSchemaDatatypeVariety.List) { 
                XmlSchemaSimpleTypeList listContent = new XmlSchemaSimpleTypeList();
                derivedType.SetDerivedBy(XmlSchemaDerivationMethod.List);
                switch (derivedType.Datatype.TypeCode) {
                    case XmlTypeCode.NmToken: 
                        listContent.ItemType = listContent.BaseItemType = enumToTypeCode[(int) XmlTypeCode.NmToken];
                        break; 
 
                    case XmlTypeCode.Entity:
                        listContent.ItemType = listContent.BaseItemType = enumToTypeCode[(int) XmlTypeCode.Entity]; 
                        break;

                    case XmlTypeCode.Idref:
                        listContent.ItemType = listContent.BaseItemType = enumToTypeCode[(int) XmlTypeCode.Idref]; 
                        break;
                } 
                derivedType.Content = listContent; 
            }
        } 

        internal static void CreateBuiltinTypes() {
            XmlQualifiedName qname;
 
            //Build anySimpleType
            SchemaDatatypeMap sdm = c_XsdTypes[anySimpleTypeIndex]; //anySimpleType 
            qname = new XmlQualifiedName(sdm.Name, XmlReservedNs.NsXs); 
            DatatypeImplementation dt = FromTypeName(qname.Name);
            anySimpleType = StartBuiltinType(qname, dt); 
            dt.parentSchemaType = anySimpleType;
            builtinTypes.Add(qname, anySimpleType);

            // Start construction of each built-in Xsd type 
            XmlSchemaSimpleType simpleType;
            for (int i = 0; i < c_XsdTypes.Length; i++) { //Create all types 
                if (i == anySimpleTypeIndex) { //anySimpleType 
                    continue;
                } 
                sdm = c_XsdTypes[i];

                qname = new XmlQualifiedName(sdm.Name, XmlReservedNs.NsXs);
                dt = FromTypeName(qname.Name); 
                simpleType = StartBuiltinType(qname, dt);
                dt.parentSchemaType = simpleType; 
 
                builtinTypes.Add(qname, simpleType);
                if (dt.variety == XmlSchemaDatatypeVariety.Atomic) { 
                    enumToTypeCode[(int)dt.TypeCode] = simpleType;
                }
            }
 
            // Finish construction of each built-in Xsd type
            for (int i = 0; i < c_XsdTypes.Length; i++) { 
                if (i == anySimpleTypeIndex) { //anySimpleType 
                    continue;
                } 
                sdm = c_XsdTypes[i];
                XmlSchemaSimpleType derivedType = (XmlSchemaSimpleType) builtinTypes[new XmlQualifiedName(sdm.Name, XmlReservedNs.NsXs)];
                XmlSchemaSimpleType baseType;
 
                if (sdm.ParentIndex == anySimpleTypeIndex) {
                    FinishBuiltinType(derivedType, anySimpleType); 
                } 
                else { //derived types whose index > 0
                    baseType = (XmlSchemaSimpleType) builtinTypes[new XmlQualifiedName( ((SchemaDatatypeMap)(c_XsdTypes[sdm.ParentIndex])).Name, XmlReservedNs.NsXs)]; 
                    FinishBuiltinType(derivedType, baseType);
                }
            }
 
            // Construct xdt:anyAtomicType type (derived from xs:anySimpleType)
            qname = new XmlQualifiedName("anyAtomicType", XmlReservedNs.NsXQueryDataType); 
            anyAtomicType = StartBuiltinType(qname, c_anyAtomicType); 
            c_anyAtomicType.parentSchemaType = anyAtomicType;
            FinishBuiltinType(anyAtomicType, anySimpleType); 
            builtinTypes.Add(qname, anyAtomicType);
            enumToTypeCode[(int)XmlTypeCode.AnyAtomicType] = anyAtomicType;

            // Construct xdt:untypedAtomic type (derived from xdt:anyAtomicType) 
            qname = new XmlQualifiedName("untypedAtomic", XmlReservedNs.NsXQueryDataType);
            untypedAtomicType = StartBuiltinType(qname, c_untypedAtomicType); 
            c_untypedAtomicType.parentSchemaType = untypedAtomicType; 
            FinishBuiltinType(untypedAtomicType, anyAtomicType);
            builtinTypes.Add(qname, untypedAtomicType); 
            enumToTypeCode[(int)XmlTypeCode.UntypedAtomic] = untypedAtomicType;

            // Construct xdt:yearMonthDuration type (derived from xs:duration)
            qname = new XmlQualifiedName("yearMonthDuration", XmlReservedNs.NsXQueryDataType); 
            yearMonthDurationType = StartBuiltinType(qname, c_yearMonthDuration);
            c_yearMonthDuration.parentSchemaType = yearMonthDurationType; 
            FinishBuiltinType(yearMonthDurationType, enumToTypeCode[(int) XmlTypeCode.Duration]); 
            builtinTypes.Add(qname, yearMonthDurationType);
            enumToTypeCode[(int)XmlTypeCode.YearMonthDuration] = yearMonthDurationType; 

            // Construct xdt:dayTimeDuration type (derived from xs:duration)
            qname = new XmlQualifiedName("dayTimeDuration", XmlReservedNs.NsXQueryDataType);
            dayTimeDurationType = StartBuiltinType(qname, c_dayTimeDuration); 
            c_dayTimeDuration.parentSchemaType = dayTimeDurationType;
            FinishBuiltinType(dayTimeDurationType, enumToTypeCode[(int) XmlTypeCode.Duration]); 
            builtinTypes.Add(qname, dayTimeDurationType); 
            enumToTypeCode[(int)XmlTypeCode.DayTimeDuration] = dayTimeDurationType;
        } 

        internal static XmlSchemaSimpleType GetSimpleTypeFromTypeCode(XmlTypeCode typeCode) {
            return enumToTypeCode[(int) typeCode];
        } 

        internal static XmlSchemaSimpleType GetSimpleTypeFromXsdType(XmlQualifiedName qname) { 
            return (XmlSchemaSimpleType)builtinTypes[qname]; 
        }
 
        internal static XmlSchemaSimpleType GetNormalizedStringTypeV1Compat() {
            if (normalizedStringTypeV1Compat == null) {
                XmlSchemaSimpleType correctType = GetSimpleTypeFromTypeCode(XmlTypeCode.NormalizedString);
                normalizedStringTypeV1Compat = correctType.Clone() as XmlSchemaSimpleType; 
                normalizedStringTypeV1Compat.SetDatatype(c_normalizedStringV1Compat);
                normalizedStringTypeV1Compat.ElementDecl = new SchemaElementDecl(c_normalizedStringV1Compat); 
                normalizedStringTypeV1Compat.ElementDecl.SchemaType = normalizedStringTypeV1Compat; 
            }
            return normalizedStringTypeV1Compat; 
        }

        internal static XmlSchemaSimpleType GetTokenTypeV1Compat() {
            if (tokenTypeV1Compat == null) { 
                XmlSchemaSimpleType correctType = GetSimpleTypeFromTypeCode(XmlTypeCode.Token);
                tokenTypeV1Compat = correctType.Clone() as XmlSchemaSimpleType; 
                tokenTypeV1Compat.SetDatatype(c_tokenV1Compat); 
                tokenTypeV1Compat.ElementDecl = new SchemaElementDecl(c_tokenV1Compat);
                tokenTypeV1Compat.ElementDecl.SchemaType = tokenTypeV1Compat; 
            }
            return tokenTypeV1Compat;
        }
 
        internal static XmlSchemaSimpleType[] GetBuiltInTypes() {
            return enumToTypeCode; 
        } 

        internal static XmlTypeCode GetPrimitiveTypeCode(XmlTypeCode typeCode) { 
            XmlSchemaSimpleType currentType = enumToTypeCode[(int)typeCode];
            while (currentType.BaseXmlSchemaType != DatatypeImplementation.AnySimpleType) {
                currentType = currentType.BaseXmlSchemaType as XmlSchemaSimpleType;
                Debug.Assert(currentType != null); 
            }
            return currentType.TypeCode; 
        } 

        internal override XmlSchemaDatatype DeriveByRestriction(XmlSchemaObjectCollection facets, XmlNameTable nameTable, XmlSchemaType schemaType) { 
            DatatypeImplementation dt = (DatatypeImplementation)MemberwiseClone();
            dt.restriction = this.FacetsChecker.ConstructRestriction(this, facets, nameTable);
            dt.baseType = this;
            dt.parentSchemaType = schemaType; 
            dt.valueConverter = null; //re-set old datatype's valueconverter
            return dt; 
        } 

        internal override XmlSchemaDatatype DeriveByList(XmlSchemaType schemaType) { 
            return DeriveByList(0, schemaType);
        }

        internal XmlSchemaDatatype DeriveByList(int minSize, XmlSchemaType schemaType) { 
            if (variety == XmlSchemaDatatypeVariety.List) {
                throw new XmlSchemaException(Res.Sch_ListFromNonatomic, string.Empty); 
            } 
            else if (variety == XmlSchemaDatatypeVariety.Union && !((Datatype_union)this).HasAtomicMembers()) {
                throw new XmlSchemaException(Res.Sch_ListFromNonatomic, string.Empty); 
            }
            DatatypeImplementation dt = new Datatype_List(this, minSize);
            dt.variety = XmlSchemaDatatypeVariety.List;
            dt.restriction = null; 
            dt.baseType = c_anySimpleType; //Base type of a union is anySimpleType
            dt.parentSchemaType = schemaType; 
            return dt; 
        }
 
        internal new static DatatypeImplementation DeriveByUnion(XmlSchemaSimpleType[] types, XmlSchemaType schemaType) {
            DatatypeImplementation dt = new Datatype_union(types);
            dt.baseType = c_anySimpleType; //Base type of a union is anySimpleType
            dt.variety = XmlSchemaDatatypeVariety.Union; 
            dt.parentSchemaType = schemaType;
            return dt; 
        } 

        internal override void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller) {/*noop*/} 

        public override bool IsDerivedFrom(XmlSchemaDatatype datatype) {
            if (datatype == null) {
                return false; 
            }
 
            //Common case - Derived by restriction 
            for(DatatypeImplementation dt = this; dt != null; dt = dt.baseType) {
                if (dt == datatype) { 
                    return true;
                }
            }
            if (((DatatypeImplementation)datatype).baseType == null) { //Both are built-in types 
                Type derivedType = this.GetType();
                Type baseType = datatype.GetType(); 
                return baseType == derivedType || derivedType.IsSubclassOf(baseType); 
            }
            else if (datatype.Variety == XmlSchemaDatatypeVariety.Union && !datatype.HasLexicalFacets && !datatype.HasValueFacets && variety != XmlSchemaDatatypeVariety.Union) { //base type is union (not a restriction of union) and derived type is not union 
                return ((Datatype_union)datatype).IsUnionBaseOf(this);
            }
            else if ((variety == XmlSchemaDatatypeVariety.Union || variety == XmlSchemaDatatypeVariety.List) && restriction == null) { //derived type is union (not a restriction)
                return (datatype == anySimpleType.Datatype); 
            }
            return false; 
        } 

        internal override bool IsEqual(object o1, object o2) { 
            //Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceVerbose, string.Format("\t\tSchemaDatatype.IsEqual({0}, {1})", o1, o2));
            return Compare(o1, o2) == 0;
        }
 
        internal override bool IsComparable(XmlSchemaDatatype dtype) {
            XmlTypeCode thisCode = this.TypeCode; 
            XmlTypeCode otherCode = dtype.TypeCode; 

            if (thisCode == otherCode) { //They are both same built-in type or one is list and the other is list's itemType 
                return true;
            }
            if (GetPrimitiveTypeCode(thisCode) == GetPrimitiveTypeCode(otherCode)) {
                return true; 
            }
            if (this.IsDerivedFrom(dtype) || dtype.IsDerivedFrom(this)) { //One is union and the other is a member of the union 
                return true; 
            }
            return false; 
        }

        internal virtual XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { return null; }
 
        internal override FacetsChecker FacetsChecker { get { return miscFacetsChecker; } }
 
        internal override XmlValueConverter ValueConverter { 
            get {
                if (valueConverter == null) { 
                    valueConverter = CreateValueConverter(this.parentSchemaType);
                }
                return valueConverter;
            } 
        }
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.None;}} 

        public override Type ValueType { get { return typeof(string); }} 

        public override XmlSchemaDatatypeVariety Variety { get { return variety;}}

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.None; } } 

        internal override RestrictionFacets Restriction { 
            get { 
                return restriction;
            } 
            set {
                restriction = value;
            }
        } 
        internal override bool HasLexicalFacets {
            get { 
                RestrictionFlags flags = restriction != null ? restriction.Flags : 0; 
                if (flags != 0 && (flags & (RestrictionFlags.Pattern|RestrictionFlags.WhiteSpace|RestrictionFlags.TotalDigits|RestrictionFlags.FractionDigits)) != 0) {
                    return true; 
                }
                return false;
            }
        } 
        internal override bool HasValueFacets {
            get { 
                RestrictionFlags flags = restriction != null ? restriction.Flags : 0; 
                if (flags != 0 && (flags & (RestrictionFlags.Length | RestrictionFlags.MinLength | RestrictionFlags.MaxLength | RestrictionFlags.MaxExclusive | RestrictionFlags.MaxInclusive | RestrictionFlags.MinExclusive | RestrictionFlags.MinInclusive | RestrictionFlags.TotalDigits | RestrictionFlags.FractionDigits | RestrictionFlags.Enumeration)) != 0)
                { 
                    return true;
                }
                return false;
            } 
        }
 
        protected DatatypeImplementation Base { get { return baseType; }} 

        internal abstract Type ListValueType { get; } 

        internal abstract RestrictionFlags ValidRestrictionFlags { get; }

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Preserve; } } 

        internal override object ParseValue(string s, Type typDest, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) { 
            return ValueConverter.ChangeType(ParseValue(s, nameTable, nsmgr), typDest, nsmgr); 
        }
 
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) {
            object typedValue;
            Exception exception = TryParseValue(s, nameTable, nsmgr, out typedValue);
            if (exception != null) { 
                throw new XmlSchemaException(Res.Sch_InvalidValueDetailed, new string[] { s, GetTypeName(), exception.Message }, exception, null, 0, 0, null);
            } 
            if (this.Variety == XmlSchemaDatatypeVariety.Union) { 
                XsdSimpleValue simpleValue = typedValue as XsdSimpleValue;
                return simpleValue.TypedValue; 
            }
            return typedValue;
        }
 
        internal override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, bool createAtomicValue) {
            if (createAtomicValue) { 
                object typedValue; 
                Exception exception = TryParseValue(s, nameTable, nsmgr, out typedValue);
                if (exception != null) { 
                    throw new XmlSchemaException(Res.Sch_InvalidValueDetailed, new string[] { s, GetTypeName(), exception.Message }, exception, null, 0, 0, null);
                }
                return typedValue;
            } 
            else {
                return ParseValue(s, nameTable, nsmgr); 
            } 
        }
 
        internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver namespaceResolver, out object typedValue) {
            Exception exception = null;
            typedValue = null;
            if (value == null) { 
                return new ArgumentNullException("value");
            } 
            string s = value as string; 
            if (s != null) {
                return TryParseValue(s, nameTable, namespaceResolver, out typedValue); 
            }
            try {
                object valueToCheck = value;
                if (value.GetType() != this.ValueType) { 
                    valueToCheck = this.ValueConverter.ChangeType(value, this.ValueType, namespaceResolver);
                } 
                if (this.HasLexicalFacets) { 
                    string s1 = (string)this.ValueConverter.ChangeType(value, typeof(System.String), namespaceResolver); //Using value here to avoid info loss
                    exception = this.FacetsChecker.CheckLexicalFacets(ref s1, this); 
                    if (exception != null) goto Error;
                }
                if (this.HasValueFacets) {
                    exception = this.FacetsChecker.CheckValueFacets(valueToCheck, this); 
                    if (exception != null) goto Error;
                } 
                typedValue = valueToCheck; 
                return null;
            } 
            catch (FormatException e) { //Catching for exceptions thrown by ValueConverter
                exception = e;
            }
            catch (InvalidCastException e) { //Catching for exceptions thrown by ValueConverter 
                exception = e;
            } 
            catch (OverflowException e) { //Catching for exceptions thrown by ValueConverter 
                exception = e;
            } 
            catch (ArgumentException e) { //Catching for exceptions thrown by ValueConverter
                exception = e;
            }
 
        Error:
           return exception; 
        } 

        internal string GetTypeName() { 
            XmlSchemaType simpleType = this.parentSchemaType;
            string typeName;
            if (simpleType == null || simpleType.QualifiedName.IsEmpty) { //If no QName, get typecode, no line info since it is not pertinent without file name
                typeName = TypeCodeString; 
            }
            else { 
                typeName = simpleType.QualifiedName.ToString(); 
            }
            return typeName; 
        }

        // XSD types
        static private readonly DatatypeImplementation c_anySimpleType       = new Datatype_anySimpleType(); 
        static private readonly DatatypeImplementation c_anyURI              = new Datatype_anyURI();
        static private readonly DatatypeImplementation c_base64Binary        = new Datatype_base64Binary(); 
        static private readonly DatatypeImplementation c_boolean             = new Datatype_boolean(); 
        static private readonly DatatypeImplementation c_byte                = new Datatype_byte();
        static private readonly DatatypeImplementation c_char                = new Datatype_char(); // XDR 
        static private readonly DatatypeImplementation c_date                = new Datatype_date();
        static private readonly DatatypeImplementation c_dateTime            = new Datatype_dateTime();
        static private readonly DatatypeImplementation c_dateTimeNoTz        = new Datatype_dateTimeNoTimeZone(); // XDR
        static private readonly DatatypeImplementation c_dateTimeTz          = new Datatype_dateTimeTimeZone(); // XDR 
        static private readonly DatatypeImplementation c_day                 = new Datatype_day();
        static private readonly DatatypeImplementation c_decimal             = new Datatype_decimal(); 
        static private readonly DatatypeImplementation c_double              = new Datatype_double(); 
        static private readonly DatatypeImplementation c_doubleXdr           = new Datatype_doubleXdr();     // XDR
        static private readonly DatatypeImplementation c_duration            = new Datatype_duration(); 
        static private readonly DatatypeImplementation c_ENTITY              = new Datatype_ENTITY();
        static private readonly DatatypeImplementation c_ENTITIES            = (DatatypeImplementation)c_ENTITY.DeriveByList(1, null);
        static private readonly DatatypeImplementation c_ENUMERATION         = new Datatype_ENUMERATION(); // XDR
        static private readonly DatatypeImplementation c_fixed               = new Datatype_fixed(); 
        static private readonly DatatypeImplementation c_float               = new Datatype_float();
        static private readonly DatatypeImplementation c_floatXdr            = new Datatype_floatXdr(); // XDR 
        static private readonly DatatypeImplementation c_hexBinary           = new Datatype_hexBinary(); 
        static private readonly DatatypeImplementation c_ID                  = new Datatype_ID();
        static private readonly DatatypeImplementation c_IDREF               = new Datatype_IDREF(); 
        static private readonly DatatypeImplementation c_IDREFS              = (DatatypeImplementation)c_IDREF.DeriveByList(1, null);
        static private readonly DatatypeImplementation c_int                 = new Datatype_int();
        static private readonly DatatypeImplementation c_integer             = new Datatype_integer();
        static private readonly DatatypeImplementation c_language            = new Datatype_language(); 
        static private readonly DatatypeImplementation c_long                = new Datatype_long();
        static private readonly DatatypeImplementation c_month               = new Datatype_month(); 
        static private readonly DatatypeImplementation c_monthDay            = new Datatype_monthDay(); 
        static private readonly DatatypeImplementation c_Name                = new Datatype_Name();
        static private readonly DatatypeImplementation c_NCName              = new Datatype_NCName(); 
        static private readonly DatatypeImplementation c_negativeInteger     = new Datatype_negativeInteger();
        static private readonly DatatypeImplementation c_NMTOKEN             = new Datatype_NMTOKEN();
        static private readonly DatatypeImplementation c_NMTOKENS            = (DatatypeImplementation)c_NMTOKEN.DeriveByList(1, null);
        static private readonly DatatypeImplementation c_nonNegativeInteger  = new Datatype_nonNegativeInteger(); 
        static private readonly DatatypeImplementation c_nonPositiveInteger  = new Datatype_nonPositiveInteger();
        static private readonly DatatypeImplementation c_normalizedString    = new Datatype_normalizedString(); 
        static private readonly DatatypeImplementation c_NOTATION            = new Datatype_NOTATION(); 
        static private readonly DatatypeImplementation c_positiveInteger     = new Datatype_positiveInteger();
        static private readonly DatatypeImplementation c_QName               = new Datatype_QName(); 
        static private readonly DatatypeImplementation c_QNameXdr            = new Datatype_QNameXdr(); //XDR
        static private readonly DatatypeImplementation c_short               = new Datatype_short();
        static private readonly DatatypeImplementation c_string              = new Datatype_string();
        static private readonly DatatypeImplementation c_time                = new Datatype_time(); 
        static private readonly DatatypeImplementation c_timeNoTz            = new Datatype_timeNoTimeZone(); // XDR
        static private readonly DatatypeImplementation c_timeTz              = new Datatype_timeTimeZone(); // XDR 
        static private readonly DatatypeImplementation c_token               = new Datatype_token(); 
        static private readonly DatatypeImplementation c_unsignedByte        = new Datatype_unsignedByte();
        static private readonly DatatypeImplementation c_unsignedInt         = new Datatype_unsignedInt(); 
        static private readonly DatatypeImplementation c_unsignedLong        = new Datatype_unsignedLong();
        static private readonly DatatypeImplementation c_unsignedShort       = new Datatype_unsignedShort();
        static private readonly DatatypeImplementation c_uuid                = new Datatype_uuid(); // XDR
        static private readonly DatatypeImplementation c_year                = new Datatype_year(); 
        static private readonly DatatypeImplementation c_yearMonth           = new Datatype_yearMonth();
 
        //V1 compat types 
        static internal readonly DatatypeImplementation c_normalizedStringV1Compat = new Datatype_normalizedStringV1Compat();
        static internal readonly DatatypeImplementation c_tokenV1Compat = new Datatype_tokenV1Compat(); 

        // XQuery types
        static private readonly DatatypeImplementation c_anyAtomicType       = new Datatype_anyAtomicType();
        static private readonly DatatypeImplementation c_dayTimeDuration     = new Datatype_dayTimeDuration(); 
        static private readonly DatatypeImplementation c_untypedAtomicType   = new Datatype_untypedAtomicType();
        static private readonly DatatypeImplementation c_yearMonthDuration   = new Datatype_yearMonthDuration(); 
 

        private class SchemaDatatypeMap : IComparable { 
            string name;
            DatatypeImplementation type;
            int parentIndex;
 
            internal SchemaDatatypeMap(string name, DatatypeImplementation type) {
                this.name = name; 
                this.type = type; 
            }
 
            internal SchemaDatatypeMap(string name, DatatypeImplementation type, int parentIndex) {
                this.name = name;
                this.type = type;
                this.parentIndex = parentIndex; 
            }
            public static explicit operator DatatypeImplementation(SchemaDatatypeMap sdm) { return sdm.type; } 
 
            public string Name {
                get { 
                    return name;
                }
            }
 
            public int ParentIndex {
                get { 
                    return parentIndex; 
                }
            } 

            public int CompareTo(object obj) { return string.Compare(name, (string)obj, StringComparison.Ordinal); }
        }
 
        private static readonly DatatypeImplementation[] c_tokenizedTypes = {
            c_string,               // CDATA 
            c_ID,                   // ID 
            c_IDREF,                // IDREF
            c_IDREFS,               // IDREFS 
            c_ENTITY,               // ENTITY
            c_ENTITIES,             // ENTITIES
            c_NMTOKEN,              // NMTOKEN
            c_NMTOKENS,             // NMTOKENS 
            c_NOTATION,             // NOTATION
            c_ENUMERATION,          // ENUMERATION 
            c_QNameXdr,             // QName 
            c_NCName,               // NCName
            null 
        };

        private static readonly DatatypeImplementation[] c_tokenizedTypesXsd = {
            c_string,               // CDATA 
            c_ID,                   // ID
            c_IDREF,                // IDREF 
            c_IDREFS,               // IDREFS 
            c_ENTITY,               // ENTITY
            c_ENTITIES,             // ENTITIES 
            c_NMTOKEN,              // NMTOKEN
            c_NMTOKENS,             // NMTOKENS
            c_NOTATION,             // NOTATION
            c_ENUMERATION,          // ENUMERATION 
            c_QName,                // QName
            c_NCName,               // NCName 
            null 
        };
 
        private static readonly SchemaDatatypeMap[] c_XdrTypes = {
            new SchemaDatatypeMap("bin.base64",          c_base64Binary),
            new SchemaDatatypeMap("bin.hex",             c_hexBinary),
            new SchemaDatatypeMap("boolean",             c_boolean), 
            new SchemaDatatypeMap("char",                c_char),
            new SchemaDatatypeMap("date",                c_date), 
            new SchemaDatatypeMap("dateTime",            c_dateTimeNoTz), 
            new SchemaDatatypeMap("dateTime.tz",         c_dateTimeTz),
            new SchemaDatatypeMap("decimal",             c_decimal), 
            new SchemaDatatypeMap("entities",            c_ENTITIES),
            new SchemaDatatypeMap("entity",              c_ENTITY),
            new SchemaDatatypeMap("enumeration",         c_ENUMERATION),
            new SchemaDatatypeMap("fixed.14.4",          c_fixed), 
            new SchemaDatatypeMap("float",               c_doubleXdr),
            new SchemaDatatypeMap("float.ieee.754.32",   c_floatXdr), 
            new SchemaDatatypeMap("float.ieee.754.64",   c_doubleXdr), 
            new SchemaDatatypeMap("i1",                  c_byte),
            new SchemaDatatypeMap("i2",                  c_short), 
            new SchemaDatatypeMap("i4",                  c_int),
            new SchemaDatatypeMap("i8",                  c_long),
            new SchemaDatatypeMap("id",                  c_ID),
            new SchemaDatatypeMap("idref",               c_IDREF), 
            new SchemaDatatypeMap("idrefs",              c_IDREFS),
            new SchemaDatatypeMap("int",                 c_int), 
            new SchemaDatatypeMap("nmtoken",             c_NMTOKEN), 
            new SchemaDatatypeMap("nmtokens",            c_NMTOKENS),
            new SchemaDatatypeMap("notation",            c_NOTATION), 
            new SchemaDatatypeMap("number",              c_doubleXdr),
            new SchemaDatatypeMap("r4",                  c_floatXdr),
            new SchemaDatatypeMap("r8",                  c_doubleXdr),
            new SchemaDatatypeMap("string",              c_string), 
            new SchemaDatatypeMap("time",                c_timeNoTz),
            new SchemaDatatypeMap("time.tz",             c_timeTz), 
            new SchemaDatatypeMap("ui1",                 c_unsignedByte), 
            new SchemaDatatypeMap("ui2",                 c_unsignedShort),
            new SchemaDatatypeMap("ui4",                 c_unsignedInt), 
            new SchemaDatatypeMap("ui8",                 c_unsignedLong),
            new SchemaDatatypeMap("uri",                 c_anyURI),
            new SchemaDatatypeMap("uuid",                c_uuid)
        }; 

 
        private static readonly SchemaDatatypeMap[] c_XsdTypes = { 
            new SchemaDatatypeMap("ENTITIES",           c_ENTITIES, 11),
            new SchemaDatatypeMap("ENTITY",             c_ENTITY, 11), 
            new SchemaDatatypeMap("ID",                 c_ID, 5),
            new SchemaDatatypeMap("IDREF",              c_IDREF, 5),
            new SchemaDatatypeMap("IDREFS",             c_IDREFS, 11),
 
            new SchemaDatatypeMap("NCName",             c_NCName, 9),
            new SchemaDatatypeMap("NMTOKEN",            c_NMTOKEN, 40), 
            new SchemaDatatypeMap("NMTOKENS",           c_NMTOKENS, 11), 
            new SchemaDatatypeMap("NOTATION",           c_NOTATION, 11),
 
            new SchemaDatatypeMap("Name",               c_Name, 40),
            new SchemaDatatypeMap("QName",              c_QName, 11), //-> 10

            new SchemaDatatypeMap("anySimpleType",      c_anySimpleType, -1), 
            new SchemaDatatypeMap("anyURI",             c_anyURI, 11),
            new SchemaDatatypeMap("base64Binary",       c_base64Binary, 11), 
            new SchemaDatatypeMap("boolean",            c_boolean, 11), 
            new SchemaDatatypeMap("byte",               c_byte, 37),
            new SchemaDatatypeMap("date",               c_date, 11), 
            new SchemaDatatypeMap("dateTime",           c_dateTime, 11),
            new SchemaDatatypeMap("decimal",            c_decimal, 11),
            new SchemaDatatypeMap("double",             c_double, 11),
            new SchemaDatatypeMap("duration",           c_duration, 11), //->20 

            new SchemaDatatypeMap("float",              c_float, 11), 
            new SchemaDatatypeMap("gDay",               c_day, 11), 
            new SchemaDatatypeMap("gMonth",             c_month, 11),
            new SchemaDatatypeMap("gMonthDay",          c_monthDay, 11), 
            new SchemaDatatypeMap("gYear",              c_year, 11),
            new SchemaDatatypeMap("gYearMonth",         c_yearMonth, 11),
            new SchemaDatatypeMap("hexBinary",          c_hexBinary, 11),
            new SchemaDatatypeMap("int",                c_int, 31), 
            new SchemaDatatypeMap("integer",            c_integer, 18),
            new SchemaDatatypeMap("language",           c_language, 40), //->30 
            new SchemaDatatypeMap("long",               c_long, 29), 

            new SchemaDatatypeMap("negativeInteger",    c_negativeInteger, 34), 

            new SchemaDatatypeMap("nonNegativeInteger", c_nonNegativeInteger, 29),
            new SchemaDatatypeMap("nonPositiveInteger", c_nonPositiveInteger, 29),
            new SchemaDatatypeMap("normalizedString",   c_normalizedString, 38), 

            new SchemaDatatypeMap("positiveInteger",    c_positiveInteger, 33), 
 
            new SchemaDatatypeMap("short",              c_short, 28),
            new SchemaDatatypeMap("string",             c_string, 11), 
            new SchemaDatatypeMap("time",               c_time, 11),
            new SchemaDatatypeMap("token",              c_token, 35), //->40
            new SchemaDatatypeMap("unsignedByte",       c_unsignedByte, 44),
            new SchemaDatatypeMap("unsignedInt",        c_unsignedInt, 43), 
            new SchemaDatatypeMap("unsignedLong",       c_unsignedLong, 33),
            new SchemaDatatypeMap("unsignedShort",      c_unsignedShort, 42), 
        }; 

        protected int Compare(byte[] value1, byte[] value2) { 
            int length = value1.Length;
            if (length != value2.Length) {
                return -1;
            } 
            for (int i = 0; i < length; i ++) {
                if (value1[i] != value2[i]) { 
                    return -1; 
                }
            } 
            return 0;
        }

#if [....] 
        protected object GetValueToCheck(object value, IXmlNamespaceResolver nsmgr) {
            object valueToCheck = value; 
            string resId; 
            if (CanConvert(value, value.GetType(), this.ValueType, out resId)) {
                valueToCheck = this.ValueConverter.ChangeType(value, this.ValueType, nsmgr); 
            }
            else {
                throw new XmlSchemaException(resId, string.Empty);
            } 
            return valueToCheck;
        } 
#endif 

    } 


    //List type
    internal class Datatype_List : Datatype_anySimpleType { 
        DatatypeImplementation itemType;
        int minListSize; 
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            XmlSchemaType listItemType = null; 
            XmlSchemaSimpleType simpleType;
            XmlSchemaComplexType complexType;
            complexType = schemaType as XmlSchemaComplexType;
 
            if (complexType != null) {
                do { 
                    simpleType = complexType.BaseXmlSchemaType as XmlSchemaSimpleType; 
                    if (simpleType != null) {
                        break; 
                    }
                    complexType = complexType.BaseXmlSchemaType as XmlSchemaComplexType;
                } while(complexType != null && complexType != XmlSchemaComplexType.AnyType);
            } 
            else {
                simpleType = schemaType as XmlSchemaSimpleType; 
            } 
            if (simpleType != null) {
                do { 
                    XmlSchemaSimpleTypeList listType = simpleType.Content as XmlSchemaSimpleTypeList;
                    if (listType != null) {
                        listItemType = listType.BaseItemType;
                        break; 
                    }
                    simpleType = simpleType.BaseXmlSchemaType as XmlSchemaSimpleType; 
                } while (simpleType != null && simpleType != DatatypeImplementation.AnySimpleType); 
            }
 
            if (listItemType == null) { //Get built-in simple type for the typecode
                listItemType = DatatypeImplementation.GetSimpleTypeFromTypeCode(schemaType.Datatype.TypeCode);
            }
 
            return XmlListConverter.Create(listItemType.ValueConverter);
        } 
 
        internal Datatype_List(DatatypeImplementation type) : this(type, 0) {
        } 
        internal Datatype_List(DatatypeImplementation type, int minListSize) {
            this.itemType = type;
            this.minListSize = minListSize;
        } 

        internal override int Compare(object value1, object value2) { 
            System.Array arr1 = (System.Array)value1; 
            System.Array arr2 = (System.Array)value2;
 
            Debug.Assert(arr1 != null && arr2 != null);
            int length = arr1.Length;
            if (length != arr2.Length) {
                return -1; 
            }
            XmlAtomicValue[] atomicValues1 = arr1 as XmlAtomicValue[]; 
            if (atomicValues1 != null) { 
                XmlAtomicValue[] atomicValues2 = arr2 as XmlAtomicValue[];
                Debug.Assert(atomicValues2 != null); 
                XmlSchemaType xmlType1;
                for (int i =0; i < atomicValues1.Length; i++) {
                    xmlType1 = atomicValues1[i].XmlType;
                    if (xmlType1 != atomicValues2[i].XmlType || !xmlType1.Datatype.IsEqual(atomicValues1[i].TypedValue, atomicValues2[i].TypedValue) ) { 
                        return -1;
                    } 
                } 
                return 0;
            } 
            else {
                for (int i = 0; i < arr1.Length; i ++) {
                    if ( itemType.Compare(arr1.GetValue(i), arr2.GetValue(i)) != 0) {
                        return -1; 
                    }
                } 
                return 0; 
            }
        } 

        public override Type ValueType { get { return  ListValueType; }}

        public override XmlTokenizedType TokenizedType { get { return itemType.TokenizedType;}} 

        internal override Type ListValueType { get { return itemType.ListValueType; }} 
 
        internal override FacetsChecker FacetsChecker { get { return listFacetsChecker; } }
 
        public override XmlTypeCode TypeCode {
            get {
                return itemType.TypeCode;
            } 
        }
 
        internal override RestrictionFlags ValidRestrictionFlags { 
            get {
                return RestrictionFlags.Length|RestrictionFlags.MinLength|RestrictionFlags.MaxLength|RestrictionFlags.Enumeration|RestrictionFlags.WhiteSpace | RestrictionFlags.Pattern; 
            }
        }
        internal DatatypeImplementation ItemType { get { return itemType; }}
 
        internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver namespaceResolver, out object typedValue) {
            Exception exception; 
            if (value == null) { 
                throw new ArgumentNullException("value");
            } 
            string s = value as string;
            typedValue = null;
            if (s != null) {
                return TryParseValue(s, nameTable, namespaceResolver, out typedValue); 
            }
 
            try { 
                object valueToCheck = this.ValueConverter.ChangeType(value, this.ValueType, namespaceResolver);
                Array valuesToCheck = valueToCheck as Array; 
                Debug.Assert(valuesToCheck != null);

                bool checkItemLexical = itemType.HasLexicalFacets;
                bool checkItemValue = itemType.HasValueFacets; 
                object item;
                FacetsChecker itemFacetsChecker = itemType.FacetsChecker; 
                XmlValueConverter itemValueConverter = itemType.ValueConverter; 

                for (int i =0; i < valuesToCheck.Length; i++) { 
                    item = valuesToCheck.GetValue(i);
                    if (checkItemLexical) {
                        string s1 = (string)itemValueConverter.ChangeType(item, typeof(System.String), namespaceResolver);
                        exception = itemFacetsChecker.CheckLexicalFacets(ref s1, itemType); 
                        if (exception != null) goto Error;
                    } 
                    if (checkItemValue) { 
                        exception = itemFacetsChecker.CheckValueFacets(item, itemType);
                        if (exception != null) goto Error; 
                    }
                }

                //Check facets on the list itself 
                if (this.HasLexicalFacets) {
                    string s1 = (string)this.ValueConverter.ChangeType(valueToCheck, typeof(System.String), namespaceResolver); 
                    exception = listFacetsChecker.CheckLexicalFacets(ref s1, this); 
                    if (exception != null) goto Error;
                } 
                if (this.HasValueFacets) {
                    exception = listFacetsChecker.CheckValueFacets(valueToCheck, this);
                    if (exception != null) goto Error;
                } 
                typedValue = valueToCheck;
                return null; 
            } 
            catch (FormatException e) { //Catching for exceptions thrown by ValueConverter
                exception = e; 
            }
            catch (InvalidCastException e) { //Catching for exceptions thrown by ValueConverter
                exception = e;
            } 
            catch (OverflowException e) { //Catching for exceptions thrown by ValueConverter
                exception = e; 
            } 
            catch (ArgumentException e) { //Catching for exceptions thrown by ValueConverter
                exception = e; 
            }

        Error:
            return exception; 
        }
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
 
            typedValue = null;

            exception = listFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            ArrayList values = new ArrayList(); 
            object array; 
            if (itemType.Variety == XmlSchemaDatatypeVariety.Union) {
                object unionTypedValue; 
                foreach (string s1 in XmlConvert.SplitString(s)) {
                    //Parse items in list according to the itemType
                    exception = itemType.TryParseValue(s1, nameTable, nsmgr, out unionTypedValue);
                    if (exception != null) goto Error; 

                    XsdSimpleValue simpleValue = (XsdSimpleValue)unionTypedValue; 
                    values.Add(new XmlAtomicValue(simpleValue.XmlType, simpleValue.TypedValue, nsmgr)); 
                }
                array = values.ToArray(typeof(XmlAtomicValue)); 
            }
            else { //Variety == List or Atomic
                foreach (string s1 in XmlConvert.SplitString(s)) {
                    exception = itemType.TryParseValue(s1, nameTable, nsmgr, out typedValue); 
                    if (exception != null) goto Error;
 
                    values.Add(typedValue); 
                }
                array = values.ToArray(itemType.ValueType); 
                Debug.Assert(array.GetType() == ListValueType);
            }
            if (values.Count < minListSize) {
                return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty); 
            }
 
            exception = listFacetsChecker.CheckValueFacets(array, this); 
            if (exception != null) goto Error;
 
            typedValue = array;

            return null;
 
        Error:
            return exception; 
        } 

    } 

    //Union datatype
    internal class Datatype_union : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(object); 
        static readonly Type listValueType = typeof(object[]);
        XmlSchemaSimpleType[] types; 
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlUnionConverter.Create(schemaType); 
        }

        internal Datatype_union(XmlSchemaSimpleType[] types) {
            this.types = types; 
        }
 
        internal override int Compare(object value1, object value2) { 
            XsdSimpleValue simpleValue1 = value1 as XsdSimpleValue;
            XsdSimpleValue simpleValue2 = value2 as XsdSimpleValue; 

            if (simpleValue1 == null || simpleValue2 == null) {
                return -1;
            } 
            XmlSchemaType schemaType1 = simpleValue1.XmlType;
            XmlSchemaType schemaType2 = simpleValue2.XmlType; 
 
            if (schemaType1 == schemaType2) {
                XmlSchemaDatatype datatype = schemaType1.Datatype; 
                return datatype.Compare(simpleValue1.TypedValue, simpleValue2.TypedValue);
            }
            return -1;
        } 

        public override Type ValueType { get { return atomicValueType; }} 
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.AnyAtomicType; }}
 
        internal override FacetsChecker FacetsChecker { get { return unionFacetsChecker; } }

        internal override Type ListValueType { get { return listValueType; }}
 
        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.Pattern| 
                    RestrictionFlags.Enumeration;
            } 
        }

        internal XmlSchemaSimpleType[] BaseMemberTypes {
            get { 
                return types;
            } 
        } 

        internal bool HasAtomicMembers() { 
            foreach(XmlSchemaSimpleType st in types) {
                if (st.Datatype.Variety == XmlSchemaDatatypeVariety.List) {
                    return false;
                } 
            }
            return true; 
        } 

        internal bool IsUnionBaseOf(DatatypeImplementation derivedType) { 
            foreach(XmlSchemaSimpleType st in types) {
                if (derivedType.IsDerivedFrom(st.Datatype)) {
                    return true;
                } 
            }
            return false; 
        } 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
            XmlSchemaSimpleType memberType = null;

            typedValue = null; 

            exception = unionFacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error; 

            //Parse string to CLR value 
            foreach(XmlSchemaSimpleType st in types) {
                exception = st.Datatype.TryParseValue(s, nameTable, nsmgr, out typedValue);
                if (exception == null) {
                    memberType = st; 
                    break;
                } 
            } 
            if (memberType == null) {
                exception = new XmlSchemaException(Res.Sch_UnionFailedEx, s); 
                goto Error;
            }

            typedValue = new XsdSimpleValue(memberType, typedValue); 
            exception = unionFacetsChecker.CheckValueFacets(typedValue, this);
            if (exception != null) goto Error; 
 
            return null;
 
        Error:
            return exception;
        }
 
        internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 
            if (value == null) { 
                throw new ArgumentNullException("value");
            } 
            typedValue = null;
            string s = value as string;
            if (s != null) {
                return TryParseValue(s, nameTable, nsmgr, out typedValue); 
            }
 
            object valueToCheck = null; 
            XmlSchemaSimpleType memberType = null;
            foreach(XmlSchemaSimpleType st in types) { 
                if (st.Datatype.TryParseValue(value, nameTable, nsmgr, out valueToCheck) == null) { //no error
                    memberType = st;
                    break;
                } 
            }
            if (valueToCheck == null) { 
                exception = new XmlSchemaException(Res.Sch_UnionFailedEx, value.ToString()); 
                goto Error;
            } 
            try {
                if (this.HasLexicalFacets) {
                    string s1 = (string)this.ValueConverter.ChangeType(valueToCheck, typeof(System.String), nsmgr); //Using value here to avoid info loss
                    exception = unionFacetsChecker.CheckLexicalFacets(ref s1, this); 
                    if (exception != null) goto Error;
                } 
                typedValue = new XsdSimpleValue(memberType, valueToCheck); 
                if (this.HasValueFacets) {
                    exception = unionFacetsChecker.CheckValueFacets(typedValue, this); 
                    if (exception != null) goto Error;
                }
                return null;
            } 
            catch (FormatException e) { //Catching for exceptions thrown by ValueConverter
                exception = e; 
            } 
            catch (InvalidCastException e) { //Catching for exceptions thrown by ValueConverter
                exception = e; 
            }
            catch (OverflowException e) { //Catching for exceptions thrown by ValueConverter
                exception = e;
            } 
            catch (ArgumentException e) { //Catching for exceptions thrown by ValueConverter
                exception = e; 
            } 

        Error: 
            return exception;
        }
    }
 

    // Primitive datatypes 
    internal class Datatype_anySimpleType : DatatypeImplementation { 
        static readonly Type atomicValueType = typeof(string);
        static readonly Type listValueType = typeof(string[]); 

        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlUntypedConverter.Untyped;
        } 

        internal override FacetsChecker FacetsChecker { get { return miscFacetsChecker; } } 
 
        public override Type ValueType { get { return atomicValueType; }}
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.AnyAtomicType; }}

        internal override Type ListValueType { get { return listValueType; }}
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.None;}}
 
        internal override RestrictionFlags ValidRestrictionFlags { get { return 0;}} 

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 

        internal override int Compare(object value1, object value2) {
            //Changed StringComparison.CurrentCulture to StringComparison.Ordinal to handle zero-weight code points like the cyrillic E
            return String.Compare(value1.ToString(), value2.ToString(), StringComparison.Ordinal); 
        }
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            typedValue = XmlComplianceUtil.NonCDataNormalize(s); //Whitespace facet is treated as collapse since thats the way it was in Everett
            return null; 
        }
    }

    internal class Datatype_anyAtomicType : Datatype_anySimpleType { 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlAnyConverter.AnyAtomic; 
        } 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Preserve; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.AnyAtomicType; } }

    }
 
    internal class Datatype_untypedAtomicType : Datatype_anyAtomicType {
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlUntypedConverter.Untyped; 
        }
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Preserve; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.UntypedAtomic; } }

    } 

 
    /* 
      
         
          
            
            
             
            
             
             
            
             
            
            
          
          
         
         
          
         
      
    */
    internal class Datatype_string : Datatype_anySimpleType {
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlStringConverter.Create(schemaType);
        } 
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Preserve; } }
 
        internal override FacetsChecker FacetsChecker { get { return stringFacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.String; }}
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.CDATA;}}
 
        internal override RestrictionFlags ValidRestrictionFlags { 
            get {
                return RestrictionFlags.Length| 
                       RestrictionFlags.MinLength|
                       RestrictionFlags.MaxLength|
                       RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration| 
                       RestrictionFlags.WhiteSpace;
            } 
        } 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;

            typedValue = null;
 
            exception = stringFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 
 
            exception = stringFacetsChecker.CheckValueFacets(s, this);
            if (exception != null) goto Error; 

            typedValue = s;
            return null;
 
        Error:
            return exception; 
        } 
    }
 
    /*
      
        
           
            
             
             
            
             
            
          
           
        
         
          
         
      
    */
    internal class Datatype_boolean : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(bool); 
        static readonly Type listValueType = typeof(bool[]);
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlBooleanConverter.Create(schemaType);
        } 

        internal override FacetsChecker FacetsChecker { get { return miscFacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Boolean; }} 

        public override Type ValueType { get { return atomicValueType; }} 
 
        internal override Type ListValueType { get { return listValueType; }}
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } }

        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.Pattern|
                       RestrictionFlags.WhiteSpace; 
            } 
        }
 
        internal override int Compare(object value1, object value2) {
            return ((bool)value1).CompareTo(value2);
        }
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 
            typedValue = null; 

            exception = miscFacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error;

            bool boolValue;
            exception = XmlConvert.TryToBoolean(s, out boolValue); 
            if (exception != null) goto Error;
 
            typedValue = boolValue; 

            return null; 

        Error:
            return exception;
        } 
    }
 
    /* 
      
         
          
            
            
             
            
             
             
            
             
            
            
            
           
           
         
        
          
        
      
    */ 
    internal class Datatype_float : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(float); 
        static readonly Type listValueType = typeof(float[]); 

        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlNumeric2Converter.Create(schemaType);
        }

        internal override FacetsChecker FacetsChecker { get { return numeric2FacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Float; }} 
 
        public override Type ValueType { get { return atomicValueType; }}
 
        internal override Type ListValueType { get { return listValueType; }}

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } }
 
        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.Pattern| 
                       RestrictionFlags.Enumeration|
                       RestrictionFlags.WhiteSpace| 
                       RestrictionFlags.MinExclusive|
                       RestrictionFlags.MinInclusive|
                       RestrictionFlags.MaxExclusive|
                       RestrictionFlags.MaxInclusive; 
            }
        } 
 
        internal override int Compare(object value1, object value2) {
            return ((float)value1).CompareTo(value2); 
        }

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 

            typedValue = null; 
 
            exception = numeric2FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            float singleValue;
            exception = XmlConvert.TryToSingle(s, out singleValue);
            if (exception != null) goto Error; 

            exception = numeric2FacetsChecker.CheckValueFacets(singleValue, this); 
            if (exception != null) goto Error; 

            typedValue = singleValue; 

            return null;

        Error: 
            return exception;
        } 
    } 

    /* 
      
        
          
             
            
             
             
            
             
            
            
            
             
            
           
          
         
        
          
         
      
    */ 
    internal class Datatype_double : Datatype_anySimpleType { 
        static readonly Type atomicValueType = typeof(double);
        static readonly Type listValueType = typeof(double[]); 

        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlNumeric2Converter.Create(schemaType);
        } 

        internal override FacetsChecker FacetsChecker { get { return numeric2FacetsChecker; } } 
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Double; }}
 
        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }}
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } }
 
        internal override RestrictionFlags ValidRestrictionFlags { 
            get {
                return RestrictionFlags.Pattern| 
                       RestrictionFlags.Enumeration|
                       RestrictionFlags.WhiteSpace|
                       RestrictionFlags.MinExclusive|
                       RestrictionFlags.MinInclusive| 
                       RestrictionFlags.MaxExclusive|
                       RestrictionFlags.MaxInclusive; 
            } 
        }
 
        internal override int Compare(object value1, object value2) {
            return ((double)value1).CompareTo(value2);
        }
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 
            typedValue = null; 

            exception = numeric2FacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error;

            double doubleValue;
            exception = XmlConvert.TryToDouble(s, out doubleValue); 
            if (exception != null) goto Error;
 
            exception = numeric2FacetsChecker.CheckValueFacets(doubleValue, this); 
            if (exception != null) goto Error;
 
            typedValue = doubleValue;

            return null;
 
        Error:
            return exception; 
        } 
    }
 
    /*
      
        
           
            
             
             
            
             
            
            
            
             
            
             
            
             
          
          
         
        
           
        
        
    */
    internal class Datatype_decimal : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(decimal);
        static readonly Type listValueType = typeof(decimal[]); 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.MinValue, decimal.MaxValue);
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlNumeric10Converter.Create(schemaType);
        } 

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Decimal; }} 

        public override Type ValueType { get { return atomicValueType; }} 
 
        internal override Type ListValueType { get { return listValueType; }}
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } }

        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.TotalDigits|
                       RestrictionFlags.FractionDigits| 
                       RestrictionFlags.Pattern| 
                       RestrictionFlags.Enumeration|
                       RestrictionFlags.WhiteSpace| 
                       RestrictionFlags.MinExclusive|
                       RestrictionFlags.MinInclusive|
                       RestrictionFlags.MaxExclusive|
                       RestrictionFlags.MaxInclusive; 
            }
        } 
 
        internal override int Compare(object value1, object value2) {
            return ((decimal)value1).CompareTo(value2); 
        }

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 

            typedValue = null; 
 
            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            decimal decimalValue;
            exception = XmlConvert.TryToDecimal(s, out decimalValue);
            if (exception != null) goto Error; 

            exception = numeric10FacetsChecker.CheckValueFacets(decimalValue, this); 
            if (exception != null) goto Error; 

            typedValue = decimalValue; 

            return null;

        Error: 
            return exception;
        } 
    } 

    /* 
       
        
          
             
            
             
             
            
             
            
            
            
            
             
           
           
        
        
           
        
        
    */ 
    internal class Datatype_duration : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(TimeSpan); 
        static readonly Type listValueType = typeof(TimeSpan[]);

        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlMiscConverter.Create(schemaType); 
        }
 
        internal override FacetsChecker FacetsChecker { get { return durationFacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Duration; }} 

        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }} 

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 
 
        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration|
                       RestrictionFlags.WhiteSpace|
                       RestrictionFlags.MinExclusive| 
                       RestrictionFlags.MinInclusive|
                       RestrictionFlags.MaxExclusive| 
                       RestrictionFlags.MaxInclusive; 
            }
        } 

        internal override int Compare(object value1, object value2) {
            return ((TimeSpan)value1).CompareTo(value2);
        } 

 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
            typedValue = null; 

            if (s == null || s.Length == 0) {
                return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
            } 

            exception = durationFacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error; 

            TimeSpan timeSpanValue; 
            exception = XmlConvert.TryToTimeSpan(s, out timeSpanValue);
            if (exception != null) goto Error;

            exception = durationFacetsChecker.CheckValueFacets(timeSpanValue, this); 
            if (exception != null) goto Error;
 
            typedValue = timeSpanValue; 

            return null; 

        Error:
            return exception;
        } 
    }
 
    internal class Datatype_yearMonthDuration : Datatype_duration { 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
            typedValue = null;

            if (s == null || s.Length == 0) { 
                return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
            } 
 
            exception = durationFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            XsdDuration duration;
            exception = XsdDuration.TryParse(s, XsdDuration.DurationType.YearMonthDuration, out duration);
            if (exception != null) goto Error; 

            TimeSpan timeSpanValue; 
 
            exception = duration.TryToTimeSpan(XsdDuration.DurationType.YearMonthDuration, out timeSpanValue);
            if (exception != null) goto Error; 

            exception = durationFacetsChecker.CheckValueFacets(timeSpanValue, this);
            if (exception != null) goto Error;
 
            typedValue = timeSpanValue;
 
            return null; 

        Error: 
            return exception;
        }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.YearMonthDuration; } } 

    } 
 
    internal class Datatype_dayTimeDuration : Datatype_duration {
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception;

            typedValue = null; 

            if (s == null || s.Length == 0) { 
                return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty); 
            }
 
            exception = durationFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;

            XsdDuration duration; 
            exception = XsdDuration.TryParse(s, XsdDuration.DurationType.DayTimeDuration, out duration);
            if (exception != null) goto Error; 
 
            TimeSpan timeSpanValue;
            exception = duration.TryToTimeSpan(XsdDuration.DurationType.DayTimeDuration, out timeSpanValue); 
            if (exception != null) goto Error;

            exception = durationFacetsChecker.CheckValueFacets(timeSpanValue, this);
            if (exception != null) goto Error; 

            typedValue = timeSpanValue; 
 
            return null;
 
        Error:
            return exception;
        }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.DayTimeDuration; } }
 
    } 

    internal class Datatype_dateTimeBase : Datatype_anySimpleType { 
        static readonly Type atomicValueType = typeof(DateTime);
        static readonly Type listValueType = typeof(DateTime[]);
        private XsdDateTimeFlags dateTimeFlags;
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlDateTimeConverter.Create(schemaType); 
        } 

        internal override FacetsChecker FacetsChecker { get { return dateTimeFacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.DateTime; }}

        internal Datatype_dateTimeBase() { 
        }
 
        internal Datatype_dateTimeBase(XsdDateTimeFlags dateTimeFlags) { 
            this.dateTimeFlags = dateTimeFlags;
        } 

        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }} 

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 
 
        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration|
                       RestrictionFlags.WhiteSpace|
                       RestrictionFlags.MinExclusive| 
                       RestrictionFlags.MinInclusive|
                       RestrictionFlags.MaxExclusive| 
                       RestrictionFlags.MaxInclusive; 
            }
        } 

        internal override int Compare(object value1, object value2) {
            DateTime dateTime1 = (DateTime)value1;
            DateTime dateTime2 = (DateTime)value2; 
            if (dateTime1.Kind == DateTimeKind.Unspecified || dateTime2.Kind == DateTimeKind.Unspecified) { //If either of them are unspecified, do not convert zones
                return dateTime1.CompareTo(dateTime2); 
            } 
            dateTime1 = dateTime1.ToUniversalTime();
            return dateTime1.CompareTo(dateTime2.ToUniversalTime()); 
        }

         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 
            typedValue = null;
 
            exception = dateTimeFacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error;
 
            XsdDateTime dateTime;
            if (!XsdDateTime.TryParse(s, dateTimeFlags, out dateTime)) {
                exception = new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "XsdDateTime"));
                goto Error; 
            }
 
            DateTime dateTimeValue = DateTime.MinValue; 
            try {
                dateTimeValue = (DateTime)dateTime; 
            }
            catch (ArgumentException e) {
                exception = e;
                goto Error; 
            }
 
            exception = dateTimeFacetsChecker.CheckValueFacets(dateTimeValue, this); 
            if (exception != null) goto Error;
 
            typedValue = dateTimeValue;

            return null;
 
        Error:
            return exception; 
        } 
    }
 
    internal class Datatype_dateTimeNoTimeZone : Datatype_dateTimeBase {
        internal Datatype_dateTimeNoTimeZone() : base(XsdDateTimeFlags.XdrDateTimeNoTz) { }
    }
 
    internal class Datatype_dateTimeTimeZone : Datatype_dateTimeBase {
        internal Datatype_dateTimeTimeZone() : base(XsdDateTimeFlags.XdrDateTime) {} 
    } 

    /* 
      
       
        
             
            
             
             
            
             
            
            
            
            
             
           
           
        
        
           
        
       
    */ 
    internal class Datatype_dateTime : Datatype_dateTimeBase {
        internal Datatype_dateTime() : base(XsdDateTimeFlags.DateTime) {} 
    }

    internal class Datatype_timeNoTimeZone : Datatype_dateTimeBase {
        internal Datatype_timeNoTimeZone() : base(XsdDateTimeFlags.XdrTimeNoTz) { } 
    }
 
    internal class Datatype_timeTimeZone : Datatype_dateTimeBase { 
        internal Datatype_timeTimeZone() : base(XsdDateTimeFlags.Time) { }
    } 

    /*
      
         
        
             
             
            
             
            
            
            
             
            
             
            
           
          
        
         
           
         
      
    */ 
    internal class Datatype_time : Datatype_dateTimeBase {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Time; }}

        internal Datatype_time() : base(XsdDateTimeFlags.Time) {} 
    }
 
    /* 
      
        
        
            
            
             
            
             
             
            
             
            
            
             
          
           
        
         
          
        
       
    */
    internal class Datatype_date : Datatype_dateTimeBase { 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Date; }} 

        internal Datatype_date() : base(XsdDateTimeFlags.Date) { } 
    }

    /*
       
       
         
             
            
             
            
            
            
             
            
             
            
             
          
          
         
        
           
        
       
    */
    internal class Datatype_yearMonth : Datatype_dateTimeBase {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.GYearMonth; }}
 
        internal Datatype_yearMonth() : base(XsdDateTimeFlags.GYearMonth) { }
    } 
 

    /* 
      
        
        
             
            
             
             
            
             
            
            
            
            
             
           
           
        
        
           
        
       
    */ 
    internal class Datatype_year : Datatype_dateTimeBase {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.GYear; }} 

        internal Datatype_year() : base(XsdDateTimeFlags.GYear) { }
    }
 
    /*
      
         
          
             
            
            
            
             
            
             
             
            
            
            
          
           
         
         
              
        
      
    */
    internal class Datatype_monthDay : Datatype_dateTimeBase { 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.GMonthDay; }}
 
        internal Datatype_monthDay() : base(XsdDateTimeFlags.GMonthDay) { } 
    }
 
    /*
      
        
           
            
             
             
            
             
            
            
            
             
             
             
          
          
        
        
             
         
       
    */
    internal class Datatype_day : Datatype_dateTimeBase { 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.GDay; }}

        internal Datatype_day() : base(XsdDateTimeFlags.GDay) { }
    } 

 
    /* 
     
         
      
            
            
             
            
             
             
            
             
            
            
             
          
           
        
         
             
        
       
    */
    internal class Datatype_month : Datatype_dateTimeBase { 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.GMonth; }} 

        internal Datatype_month() : base(XsdDateTimeFlags.GMonth) { } 
    }

    /*
        
        
           
             
            
             
            
            
            
             
            
             
            
           
          
        
         
           
         
       
    */ 
    internal class Datatype_hexBinary : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(byte[]);
        static readonly Type listValueType = typeof(byte[][]);
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlMiscConverter.Create(schemaType); 
        } 

        internal override FacetsChecker FacetsChecker { get { return binaryFacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.HexBinary; }}

        public override Type ValueType { get { return atomicValueType; }} 

        internal override Type ListValueType { get { return listValueType; }} 
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } }
 
        internal override RestrictionFlags ValidRestrictionFlags {
            get {
                return RestrictionFlags.Length|
                       RestrictionFlags.MinLength| 
                       RestrictionFlags.MaxLength|
                       RestrictionFlags.Pattern| 
                       RestrictionFlags.Enumeration| 
                       RestrictionFlags.WhiteSpace;
            } 
        }

        internal override int Compare(object value1, object value2) {
            return Compare((byte[])value1, (byte[])value2); 
        }
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
 
            typedValue = null;

            exception = binaryFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            byte[] byteArrayValue = null; 
            try { 
                byteArrayValue = XmlConvert.FromBinHexString(s, false);
            } 
            catch (ArgumentException e) {
                exception = e;
                goto Error;
            } 
            catch (XmlException e) {
                exception = e; 
                goto Error; 
            }
 
            exception = binaryFacetsChecker.CheckValueFacets(byteArrayValue, this);
            if (exception != null) goto Error;

            typedValue = byteArrayValue; 

            return null; 
 
        Error:
            return exception; 
        }
    }

 
    /*
      
         
          
             
            
            
            
             
            
             
             
             
            
          
           
        
         
          
         
       
    */
    internal class Datatype_base64Binary : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(byte[]); 
        static readonly Type listValueType = typeof(byte[][]);
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlMiscConverter.Create(schemaType);
        } 

        internal override FacetsChecker FacetsChecker { get { return binaryFacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Base64Binary; }} 

        public override Type ValueType { get { return atomicValueType; }} 
 
        internal override Type ListValueType { get { return listValueType; }}
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } }

        internal override RestrictionFlags ValidRestrictionFlags {
            get { 
                return RestrictionFlags.Length|
                       RestrictionFlags.MinLength| 
                       RestrictionFlags.MaxLength| 
                       RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration| 
                       RestrictionFlags.WhiteSpace;
            }
        }
 
        internal override int Compare(object value1, object value2) {
            return Compare((byte[])value1, (byte[])value2); 
        } 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;

            typedValue = null;
 
            exception = binaryFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 
 
            byte[] byteArrayValue = null;
            try { 
                byteArrayValue = Convert.FromBase64String(s);
            }
            catch (ArgumentException e) {
                exception = e; 
                goto Error;
            } 
            catch (FormatException e) { 
                exception = e;
                goto Error; 
            }

            exception = binaryFacetsChecker.CheckValueFacets(byteArrayValue, this);
            if (exception != null) goto Error; 

            typedValue = byteArrayValue; 
 
            return null;
 
        Error:
            return exception;
        }
    } 

    /* 
        
        
           
            
            
            
             
            
             
             
            
            
            
          
          
         
         
           
        
       
    */
    internal class Datatype_anyURI : Datatype_anySimpleType { 
        static readonly Type atomicValueType = typeof(Uri);
        static readonly Type listValueType = typeof(Uri[]); 
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlMiscConverter.Create(schemaType); 
        }

        internal override FacetsChecker FacetsChecker { get { return stringFacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.AnyUri; }}
 
        public override Type ValueType { get { return atomicValueType; }} 

        internal override bool HasValueFacets { 
            get {
                return true; //Built-in facet to check validity of Uri
            }
        } 
        internal override Type ListValueType { get { return listValueType; }}
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 

        internal override RestrictionFlags ValidRestrictionFlags { 
            get {
                return RestrictionFlags.Length|
                       RestrictionFlags.MinLength|
                       RestrictionFlags.MaxLength| 
                       RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration| 
                       RestrictionFlags.WhiteSpace; 
            }
        } 

        internal override int Compare(object value1, object value2) {
            return ((Uri)value1).Equals((Uri)value2) ? 0 : -1;
        } 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            exception = stringFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;
 
            Uri uri;
            exception = XmlConvert.TryToUri(s, out uri); 
            if (exception != null) goto Error; 

            string stringValue = uri.OriginalString; 
            exception = ((StringFacetsChecker)stringFacetsChecker).CheckValueFacets(stringValue, this, false);
            if (exception != null) goto Error;

            typedValue = uri; 

            return null; 
 
        Error:
            return exception; 
        }
    }

    /* 
      
         
             
            
             
            
            
            
             
            
             
            
             
          
          
         
        
           
        
       
    */
    internal class Datatype_QName : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(XmlQualifiedName);
        static readonly Type listValueType = typeof(XmlQualifiedName[]); 

        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) { 
            return XmlMiscConverter.Create(schemaType); 
        }
 
        internal override FacetsChecker FacetsChecker { get { return qnameFacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.QName; }}
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.QName;}}
 
        internal override RestrictionFlags ValidRestrictionFlags { 
            get {
                return RestrictionFlags.Length| 
                       RestrictionFlags.MinLength|
                       RestrictionFlags.MaxLength|
                       RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration| 
                       RestrictionFlags.WhiteSpace;
            } 
        } 

        public override Type ValueType { get { return atomicValueType; }} 

        internal override Type ListValueType { get { return listValueType; }}

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            if (s == null || s.Length == 0) {
                return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
            } 

            exception = qnameFacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error; 

            XmlQualifiedName qname = null; 
            try {
                string prefix;
                qname = XmlQualifiedName.Parse(s, nsmgr, out prefix);
            } 
            catch (ArgumentException e) {
                exception = e; 
                goto Error; 
            }
            catch (XmlException e) { 
                exception = e;
                goto Error;
            }
 
            exception = qnameFacetsChecker.CheckValueFacets(qname, this);
            if (exception != null) goto Error; 
 
            typedValue = qname;
 
            return null;

        Error:
            return exception; 
        }
    } 
 
    /*
       
        
          
         
        
           
        
       
    */
    internal class Datatype_normalizedString : Datatype_string {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NormalizedString; }}
 
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Replace; } }
 
        internal override bool HasValueFacets { 
            get {
                return true; //Built-in facet to check validity of NormalizedString 
            }
        }
    }
 
    internal class Datatype_normalizedStringV1Compat : Datatype_string {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NormalizedString; }} 
        internal override bool HasValueFacets { 
            get {
                return true; //Built-in facet to check validity of NormalizedString 
            }
        }
    }
 
    /*
       
         
           
        
        
          
         
      
    */ 
    internal class Datatype_token : Datatype_normalizedString { 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Token; }}
        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 
    }

    internal class Datatype_tokenV1Compat : Datatype_normalizedStringV1Compat {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Token; }} 
    }
 
    /* 
      
         
          
        
         
           
            
              
                pattern specifies the content of section 2.12 of XML 1.0e2
                and RFC 1766
               
            
           
         
      
    */ 
    internal class Datatype_language : Datatype_token {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Language; }}
    }
 
    /*
       
         
           
        
        
          
             
               
                pattern matches production 7 from the XML spec 
              
             
          
        
      
    */ 
    internal class Datatype_NMTOKEN : Datatype_token {
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NmToken; }} 

        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.NMTOKEN;}} 
    }

    /*
       
        
           
        
         
          
            
               
                pattern matches production 5 from the XML spec
               
             
          
         
      
    */
    internal class Datatype_Name : Datatype_token {
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Name; }} 
    }
 
    /* 
      
         
          
        
         
          
             
              
                pattern matches production 4 from the Namespaces in XML spec 
              
            
          
         
      
    */ 
    internal class Datatype_NCName : Datatype_Name { 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NCName; }} 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception;
 
            typedValue = null;
 
            exception = stringFacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error;
 
            exception = stringFacetsChecker.CheckValueFacets(s, this);
            if (exception != null) goto Error;

            nameTable.Add(s); 

            typedValue = s; 
            return null; 

        Error: 
            return exception;
        }
    }
 
    /*
        
         
           
        
        
       
    */ 
    internal class Datatype_ID : Datatype_NCName {
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Id; }} 

        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.ID;}} 
    }

    /*
        
        
           
        
         
       
    */
    internal class Datatype_IDREF : Datatype_NCName {
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Idref; }}
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.IDREF;}} 
    }
 
    /*
       
        
          
         
         
       
    */ 
    internal class Datatype_ENTITY : Datatype_NCName {

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Entity; }}
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.ENTITY;}}
 
    } 

    /* 
       
        
            
             
            
             
             
            
             
            
            
             
            
           
          
           
            NOTATION cannot be used directly in a schema; rather a type
            must be derived from it by specifying at least one enumeration
            facet whose value is the name of a NOTATION declared in the
            schema. 
          
         
         
           
        
      
    */
    internal class Datatype_NOTATION : Datatype_anySimpleType { 
        static readonly Type atomicValueType = typeof(XmlQualifiedName);
        static readonly Type listValueType = typeof(XmlQualifiedName[]); 
 
        internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType) {
            return XmlMiscConverter.Create(schemaType); 
        }

        internal override FacetsChecker FacetsChecker { get { return qnameFacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Notation; }}
 
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.NOTATION;}} 

        internal override RestrictionFlags ValidRestrictionFlags { 
            get {
                return RestrictionFlags.Length|
                       RestrictionFlags.MinLength|
                       RestrictionFlags.MaxLength| 
                       RestrictionFlags.Pattern|
                       RestrictionFlags.Enumeration| 
                       RestrictionFlags.WhiteSpace; 
            }
        } 

        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }} 

        internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet { get { return XmlSchemaWhiteSpace.Collapse; } } 
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 

            typedValue = null;

            if (s == null || s.Length == 0) { 
                return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
            } 
 
            exception = qnameFacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            XmlQualifiedName qname = null;
            try {
                string prefix; 
                qname = XmlQualifiedName.Parse(s, nsmgr, out prefix);
            } 
            catch (ArgumentException e) { 
                exception = e;
                goto Error; 
            }
            catch (XmlException e) {
                exception = e;
                goto Error; 
            }
 
            exception = qnameFacetsChecker.CheckValueFacets(qname, this); 
            if (exception != null) goto Error;
 
            typedValue = qname;

            return null;
 
        Error:
            return exception; 
        } 

        internal override void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller) { 

            // Only datatypes that are derived from NOTATION by specifying a value for enumeration can be used in a schema.
            // Furthermore, the value of all enumeration facets must match the name of a notation declared in the current schema.                    //
            for(Datatype_NOTATION dt = this; dt != null; dt = (Datatype_NOTATION)dt.Base) { 
                if (dt.Restriction != null && (dt.Restriction.Flags & RestrictionFlags.Enumeration) != 0) {
                    foreach(XmlQualifiedName notation in dt.Restriction.Enumeration) { 
                        if (!notations.Contains(notation)) { 
                            throw new XmlSchemaException(Res.Sch_NotationRequired, caller);
                        } 
                    }
                    return;
                }
            } 
            throw new XmlSchemaException(Res.Sch_NotationRequired, caller);
        } 
    } 

    /* 
      
        
           
        
         
           
        
       
    */
    internal class Datatype_integer : Datatype_decimal {

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Integer; }} 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            exception = FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;
 
            decimal decimalValue;
            exception = XmlConvert.TryToInteger(s, out decimalValue); 
            if (exception != null) goto Error; 

            exception = FacetsChecker.CheckValueFacets(decimalValue, this); 
            if (exception != null) goto Error;

            typedValue = decimalValue;
 
            return null;
 
        Error: 
            return exception;
        } 
    }

    /*
       
        
           
        
         
          
        
      
    */ 
    internal class Datatype_nonPositiveInteger : Datatype_integer {
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.MinValue, decimal.Zero); 
 
        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NonPositiveInteger; }}

        internal override bool HasValueFacets {
            get { 
                return true; //Built-in facet to check range
            } 
        } 
    }
 

    /*
      
         
           
         
        
           
        
      
    */
    internal class Datatype_negativeInteger : Datatype_nonPositiveInteger { 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.MinValue, decimal.MinusOne);
 
        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NegativeInteger; }} 
    }


    /* 
      
         
           
            
             
          
          
         
        
           
           
        
       
    */
    internal class Datatype_long : Datatype_integer {
        static readonly Type atomicValueType = typeof(long);
        static readonly Type listValueType = typeof(long[]); 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(long.MinValue, long.MaxValue);
 
        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } } 

        internal override bool HasValueFacets { 
            get {
                return true; //Built-in facet to check range
            }
        } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Long; }} 
 
        internal override int Compare(object value1, object value2) {
            return ((long)value1).CompareTo(value2); 
        }

        public override Type ValueType { get { return atomicValueType; }}
 
        internal override Type ListValueType { get { return listValueType; }}
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
 
            typedValue = null;

            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error; 

            long int64Value; 
            exception = XmlConvert.TryToInt64(s, out int64Value); 
            if (exception != null) goto Error;
 
            exception = numeric10FacetsChecker.CheckValueFacets(int64Value, this);
            if (exception != null) goto Error;

            typedValue = int64Value; 

            return null; 
 
        Error:
            return exception; 
        }
    }

    /* 
      
         
          
         
        
          
          
         
      
    */ 
    internal class Datatype_int : Datatype_long { 
        static readonly Type atomicValueType = typeof(int);
        static readonly Type listValueType = typeof(int[]); 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(int.MinValue, int.MaxValue);

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Int; }}
 
        internal override int Compare(object value1, object value2) { 
            return ((int)value1).CompareTo(value2);
        } 

        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }} 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;
 
            int int32Value;
            exception = XmlConvert.TryToInt32(s, out int32Value); 
            if (exception != null) goto Error; 

            exception = numeric10FacetsChecker.CheckValueFacets(int32Value, this); 
            if (exception != null) goto Error;

            typedValue = int32Value;
 
            return null;
 
        Error: 
            return exception;
        } 
    }


    /* 
      
         
          
         
        
          
          
         
      
    */ 
    internal class Datatype_short : Datatype_int { 
        static readonly Type atomicValueType = typeof(short);
        static readonly Type listValueType = typeof(short[]); 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(short.MinValue, short.MaxValue);

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Short; }}
 
        internal override int Compare(object value1, object value2) { 
            return ((short)value1).CompareTo(value2);
        } 

        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }} 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;
 
            short int16Value;
            exception = XmlConvert.TryToInt16(s, out int16Value); 
            if (exception != null) goto Error; 

            exception = numeric10FacetsChecker.CheckValueFacets(int16Value, this); 
            if (exception != null) goto Error;

            typedValue = int16Value;
 
            return null;
 
        Error: 
            return exception;
        } 
    }

    /*
       
        
           
        
         
          
          
        
       
    */
    internal class Datatype_byte : Datatype_short { 
        static readonly Type atomicValueType = typeof(sbyte); 
        static readonly Type listValueType = typeof(sbyte[]);
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(sbyte.MinValue, sbyte.MaxValue); 

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.Byte; }} 

        internal override int Compare(object value1, object value2) { 
            return ((sbyte)value1).CompareTo(value2); 
        }
 
        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }}
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 
 
            typedValue = null;
 
            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;

            sbyte sbyteValue; 
            exception = XmlConvert.TryToSByte(s, out sbyteValue);
            if (exception != null) goto Error; 
 
            exception = numeric10FacetsChecker.CheckValueFacets((short)sbyteValue, this);
            if (exception != null) goto Error; 

            typedValue = sbyteValue;

            return null; 

        Error: 
            return exception; 
        }
    } 

    /*
      
         
           
         
        
           
        
      
    */
    internal class Datatype_nonNegativeInteger : Datatype_integer { 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.Zero,decimal.MaxValue);
 
        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.NonNegativeInteger; }} 

        internal override bool HasValueFacets {
            get {
                return true; //Built-in facet to check range 
            }
        } 
    } 

    /* 
      
        
          
             
            
           
          
         
        
          
         
      
    */ 
    internal class Datatype_unsignedLong : Datatype_nonNegativeInteger { 
        static readonly Type atomicValueType = typeof(ulong);
        static readonly Type listValueType = typeof(ulong[]); 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(ulong.MinValue, ulong.MaxValue);

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.UnsignedLong; }}
 
        internal override int Compare(object value1, object value2) { 
            return ((ulong)value1).CompareTo(value2);
        } 

        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }} 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;
 
            ulong uint64Value;
            exception = XmlConvert.TryToUInt64(s, out uint64Value); 
            if (exception != null) goto Error; 

            exception = numeric10FacetsChecker.CheckValueFacets((decimal)uint64Value, this); 
            if (exception != null) goto Error;

            typedValue = uint64Value;
 
            return null;
 
        Error: 
            return exception;
        } 
    }

    /*
       
        
           
        
         
          
        
       
    */
    internal class Datatype_unsignedInt : Datatype_unsignedLong { 
        static readonly Type atomicValueType = typeof(uint); 
        static readonly Type listValueType = typeof(uint[]);
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(uint.MinValue, uint.MaxValue); 

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.UnsignedInt; }} 

        internal override int Compare(object value1, object value2) { 
            return ((uint)value1).CompareTo(value2); 
        }
 
        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }}
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception; 
 
            typedValue = null;
 
            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
            if (exception != null) goto Error;

            uint uint32Value; 
            exception = XmlConvert.TryToUInt32(s, out uint32Value);
            if (exception != null) goto Error; 
 
            exception = numeric10FacetsChecker.CheckValueFacets((long)uint32Value, this);
            if (exception != null) goto Error; 

            typedValue = uint32Value;

            return null; 

        Error: 
            return exception; 
        }
    } 

    /*
      
         
           
         
        
          
        
      
    */ 
    internal class Datatype_unsignedShort : Datatype_unsignedInt {
        static readonly Type atomicValueType = typeof(ushort); 
        static readonly Type listValueType = typeof(ushort[]); 
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(ushort.MinValue, ushort.MaxValue);
 
        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.UnsignedShort; }}
 
        internal override int Compare(object value1, object value2) {
            return ((ushort)value1).CompareTo(value2); 
        } 

        public override Type ValueType { get { return atomicValueType; }} 

        internal override Type ListValueType { get { return listValueType; }}

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
 
            typedValue = null; 

            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error;

            ushort uint16Value;
            exception = XmlConvert.TryToUInt16(s, out uint16Value); 
            if (exception != null) goto Error;
 
            exception = numeric10FacetsChecker.CheckValueFacets((int)uint16Value, this); 
            if (exception != null) goto Error;
 
            typedValue = uint16Value;

            return null;
 
        Error:
            return exception; 
        } 
    }
 
    /*
      
        
          
         
         
          
         
      
    */
    internal class Datatype_unsignedByte : Datatype_unsignedShort {
        static readonly Type atomicValueType = typeof(byte); 
        static readonly Type listValueType = typeof(byte[]);
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(byte.MinValue, byte.MaxValue); 
 
        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } }
 
        public override XmlTypeCode TypeCode { get { return XmlTypeCode.UnsignedByte; }}

        internal override int Compare(object value1, object value2) {
            return ((byte)value1).CompareTo(value2); 
        }
 
        public override Type ValueType { get { return atomicValueType; }} 

        internal override Type ListValueType { get { return listValueType; }} 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception;
 
            typedValue = null;
 
            exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this); 
            if (exception != null) goto Error;
 
            byte byteValue;
            exception = XmlConvert.TryToByte(s, out byteValue);
            if (exception != null) goto Error;
 
            exception = numeric10FacetsChecker.CheckValueFacets((short)byteValue, this);
            if (exception != null) goto Error; 
 
            typedValue = byteValue;
 
            return null;

        Error:
            return exception; 
        }
    } 
 
    /*
       
        
          
         
        
           
         
      
    */ 
    internal class Datatype_positiveInteger : Datatype_nonNegativeInteger {
        static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.One, decimal.MaxValue);

        internal override FacetsChecker FacetsChecker { get { return numeric10FacetsChecker; } } 

        public override XmlTypeCode TypeCode { get { return XmlTypeCode.PositiveInteger; }} 
    } 

    /* 
        XDR
    */
    internal class Datatype_doubleXdr : Datatype_double {
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) { 
             double value;
            try { 
               value = XmlConvert.ToDouble(s); 
            }
            catch(Exception e) { 
                throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
            }
            if (double.IsInfinity(value) || double.IsNaN(value)) {
                throw new XmlSchemaException(Res.Sch_InvalidValue, s); 
            }
            return value; 
        } 
    }
 
    internal class Datatype_floatXdr : Datatype_float {
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) {
            float value;
            try { 
                value = XmlConvert.ToSingle(s);
            } 
            catch(Exception e) { 
                throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
            } 
            if (float.IsInfinity(value) || float.IsNaN(value)) {
                throw new XmlSchemaException(Res.Sch_InvalidValue, s);
            }
            return value; 
        }
    } 
 
    internal class Datatype_QNameXdr : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(XmlQualifiedName); 
        static readonly Type listValueType = typeof(XmlQualifiedName[]);

        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.QName;}}
 
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) {
            if (s == null || s.Length == 0) { 
                throw new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty); 
            }
            if (nsmgr == null) { 
                throw new ArgumentNullException("nsmgr");
            }
            string prefix;
            try { 
                return XmlQualifiedName.Parse(s.Trim(), nsmgr, out prefix);
            } 
            catch (XmlSchemaException e) { 
                throw e;
            } 
            catch (Exception e) {
                throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
            }
        } 

        public override Type ValueType { get { return atomicValueType; }} 
 
        internal override Type ListValueType { get { return listValueType; }}
    } 

    internal class Datatype_ENUMERATION : Datatype_NMTOKEN {
        public override XmlTokenizedType TokenizedType { get { return XmlTokenizedType.ENUMERATION;}}
    } 

    internal class Datatype_char : Datatype_anySimpleType { 
        static readonly Type atomicValueType = typeof(char); 
        static readonly Type listValueType = typeof(char[]);
 
        public override Type ValueType { get { return atomicValueType; }}

        internal override Type ListValueType { get { return listValueType; }}
 
        internal override RestrictionFlags ValidRestrictionFlags { get { return 0; }} //XDR only
 
        internal override int Compare(object value1, object value2) { 
            // this should be culture sensitive - comparing values
            return ((char)value1).CompareTo(value2); 
        }

        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) {
            try { 
                return XmlConvert.ToChar(s);
            } 
            catch (XmlSchemaException e) { 
                throw e;
            } 
            catch (Exception e) {
                throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
            }
        } 

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception; 

            typedValue = null; 

            char charValue;
            exception = XmlConvert.TryToChar(s, out charValue);
            if (exception != null) goto Error; 

            typedValue = charValue; 
 
            return null;
 
        Error:
            return exception;
        }
    } 

    internal class Datatype_fixed : Datatype_decimal { 
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) { 
            Exception exception;
 
            try {
                Numeric10FacetsChecker facetsChecker = this.FacetsChecker as Numeric10FacetsChecker;
                decimal value = XmlConvert.ToDecimal(s);
                exception = facetsChecker.CheckTotalAndFractionDigits(value, 14 + 4, 4, true, true); 
                if (exception != null) goto Error;
 
                return value; 
            }
            catch (XmlSchemaException e) { 
                throw e;
            }
            catch (Exception e) {
                throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e); 
            }
        Error: 
            throw exception; 
        }
 
        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) {
            Exception exception;

            typedValue = null; 

            decimal decimalValue; 
            exception = XmlConvert.TryToDecimal(s, out decimalValue); 
            if (exception != null) goto Error;
 
            Numeric10FacetsChecker facetsChecker = this.FacetsChecker as Numeric10FacetsChecker;
            exception = facetsChecker.CheckTotalAndFractionDigits(decimalValue, 14 + 4, 4, true, true);
            if (exception != null) goto Error;
 
            typedValue = decimalValue;
 
            return null; 

        Error: 
            return exception;
        }
    }
 
    internal class Datatype_uuid : Datatype_anySimpleType {
        static readonly Type atomicValueType = typeof(Guid); 
        static readonly Type listValueType = typeof(Guid[]); 

        public override Type ValueType { get { return atomicValueType; }} 

        internal override Type ListValueType { get { return listValueType; }}

        internal override RestrictionFlags ValidRestrictionFlags { get { return 0; }} 

        internal override int Compare(object value1, object value2) { 
            return ((Guid)value1).Equals(value2) ? 0 : -1; 
        }
 
        public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr) {
            try {
                return XmlConvert.ToGuid(s);
            } 
            catch (XmlSchemaException e) {
                throw e; 
            } 
            catch (Exception e) {
                throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e); 
            }
        }

        internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue) { 
            Exception exception;
 
            typedValue = null; 

            Guid guid; 
            exception = XmlConvert.TryToGuid(s, out guid);
            if (exception != null) goto Error;

            typedValue = guid; 

            return null; 
 
        Error:
            return exception; 
        }
    }
}

// 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