The Labs \ Source Viewer \ SSCLI \ System.Xml.Schema \ Datatype_day

  1. //------------------------------------------------------------------------------
  2. // <copyright file="DatatypeImplementation.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Xml.Schema
  16. {
  17.    
  18.     using System;
  19.     using System.IO;
  20.     using System.Collections;
  21.     using System.Diagnostics;
  22.     using System.Globalization;
  23.     using System.Text;
  24.     using System.Text.RegularExpressions;
  25.     using System.Xml;
  26.     using System.Xml.XPath;
  27.     using System.Xml.Serialization;
  28.    
  29.     /// <include file='doc\DatatypeImplementation.uex' path='docs/doc[@for="XmlSchemaDatatypeVariety"]/*' />
  30.     public enum XmlSchemaDatatypeVariety
  31.     {
  32.         /// <include file='doc\DatatypeImplementation.uex' path='docs/doc[@for="XmlSchemaDatatypeVariety.Atomic"]/*' />
  33.         Atomic,
  34.         /// <include file='doc\DatatypeImplementation.uex' path='docs/doc[@for="XmlSchemaDatatypeVariety.List"]/*' />
  35.         List,
  36.         /// <include file='doc\DatatypeImplementation.uex' path='docs/doc[@for="XmlSchemaDatatypeVariety.Union"]/*' />
  37.         Union
  38.     }
  39.    
  40.     internal class XsdSimpleValue
  41.     {
  42.         //Wrapper to store XmlType and TypedValue together
  43.         XmlSchemaSimpleType xmlType;
  44.         object typedValue;
  45.        
  46.         public XsdSimpleValue(XmlSchemaSimpleType st, object value)
  47.         {
  48.             xmlType = st;
  49.             typedValue = value;
  50.         }
  51.        
  52.         public XmlSchemaSimpleType XmlType {
  53.             get { return xmlType; }
  54.         }
  55.        
  56.         public object TypedValue {
  57.             get { return typedValue; }
  58.         }
  59.     }
  60.    
  61.    
  62.     [Flags()]
  63.     internal enum RestrictionFlags
  64.     {
  65.         Length = 1,
  66.         MinLength = 2,
  67.         MaxLength = 4,
  68.         Pattern = 8,
  69.         Enumeration = 16,
  70.         WhiteSpace = 32,
  71.         MaxInclusive = 64,
  72.         MaxExclusive = 128,
  73.         MinInclusive = 256,
  74.         MinExclusive = 512,
  75.         TotalDigits = 1024,
  76.         FractionDigits = 2048
  77.     }
  78.    
  79.     internal enum XmlSchemaWhiteSpace
  80.     {
  81.         Preserve,
  82.         Replace,
  83.         Collapse
  84.     }
  85.    
  86.     internal class RestrictionFacets
  87.     {
  88.         internal int Length;
  89.         internal int MinLength;
  90.         internal int MaxLength;
  91.         internal ArrayList Patterns;
  92.         internal ArrayList Enumeration;
  93.         internal XmlSchemaWhiteSpace WhiteSpace;
  94.         internal object MaxInclusive;
  95.         internal object MaxExclusive;
  96.         internal object MinInclusive;
  97.         internal object MinExclusive;
  98.         internal int TotalDigits;
  99.         internal int FractionDigits;
  100.         internal RestrictionFlags Flags = 0;
  101.         internal RestrictionFlags FixedFlags = 0;
  102.     }
  103.    
  104.     internal abstract class DatatypeImplementation : XmlSchemaDatatype
  105.     {
  106.         private XmlSchemaDatatypeVariety variety = XmlSchemaDatatypeVariety.Atomic;
  107.         private RestrictionFacets restriction = null;
  108.         private DatatypeImplementation baseType = null;
  109.         private XmlValueConverter valueConverter;
  110.         private XmlSchemaType parentSchemaType;
  111.        
  112.         private static Hashtable builtinTypes = new Hashtable();
  113.         private static XmlSchemaSimpleType[] enumToTypeCode = new XmlSchemaSimpleType[(int)XmlTypeCode.DayTimeDuration + 1];
  114.         private static XmlSchemaSimpleType anySimpleType;
  115.         private static XmlSchemaSimpleType anyAtomicType;
  116.         private static XmlSchemaSimpleType untypedAtomicType;
  117.         private static XmlSchemaSimpleType yearMonthDurationType;
  118.         private static XmlSchemaSimpleType dayTimeDurationType;
  119.         private static XmlSchemaSimpleType normalizedStringTypeV1Compat;
  120.         private static XmlSchemaSimpleType tokenTypeV1Compat;
  121.        
  122.         private const int anySimpleTypeIndex = 11;
  123.        
  124.         static internal XmlQualifiedName QnAnySimpleType = new XmlQualifiedName("anySimpleType", XmlReservedNs.NsXs);
  125.         static internal XmlQualifiedName QnAnyType = new XmlQualifiedName("anyType", XmlReservedNs.NsXs);
  126.        
  127.         //Create facet checkers
  128.         static internal FacetsChecker stringFacetsChecker = new StringFacetsChecker();
  129.         static internal FacetsChecker miscFacetsChecker = new MiscFacetsChecker();
  130.         static internal FacetsChecker numeric2FacetsChecker = new Numeric2FacetsChecker();
  131.         static internal FacetsChecker binaryFacetsChecker = new BinaryFacetsChecker();
  132.         static internal FacetsChecker dateTimeFacetsChecker = new DateTimeFacetsChecker();
  133.         static internal FacetsChecker durationFacetsChecker = new DurationFacetsChecker();
  134.         static internal FacetsChecker listFacetsChecker = new ListFacetsChecker();
  135.         static internal FacetsChecker qnameFacetsChecker = new QNameFacetsChecker();
  136.         static internal FacetsChecker unionFacetsChecker = new UnionFacetsChecker();
  137.        
  138.         static DatatypeImplementation()
  139.         {
  140.             CreateBuiltinTypes();
  141.         }
  142.        
  143.         static internal XmlSchemaSimpleType AnySimpleType {
  144.             get { return anySimpleType; }
  145.         }
  146.        
  147.         // Additional built-in XQuery simple types
  148.         static internal XmlSchemaSimpleType AnyAtomicType {
  149.             get { return anyAtomicType; }
  150.         }
  151.         static internal XmlSchemaSimpleType UntypedAtomicType {
  152.             get { return untypedAtomicType; }
  153.         }
  154.         static internal XmlSchemaSimpleType YearMonthDurationType {
  155.             get { return yearMonthDurationType; }
  156.         }
  157.         static internal XmlSchemaSimpleType DayTimeDurationType {
  158.             get { return dayTimeDurationType; }
  159.         }
  160.        
  161.         static internal new DatatypeImplementation FromXmlTokenizedType(XmlTokenizedType token)
  162.         {
  163.             return c_tokenizedTypes[(int)token];
  164.         }
  165.        
  166.         static internal new DatatypeImplementation FromXmlTokenizedTypeXsd(XmlTokenizedType token)
  167.         {
  168.             return c_tokenizedTypesXsd[(int)token];
  169.         }
  170.        
  171.         static internal new DatatypeImplementation FromXdrName(string name)
  172.         {
  173.             int i = Array.BinarySearch(c_XdrTypes, name, null);
  174.             return i < 0 ? null : (DatatypeImplementation)c_XdrTypes[i];
  175.         }
  176.        
  177.         private static DatatypeImplementation FromTypeName(string name)
  178.         {
  179.             int i = Array.BinarySearch(c_XsdTypes, name, null);
  180.             return i < 0 ? null : (DatatypeImplementation)c_XsdTypes[i];
  181.         }
  182.        
  183.         /// <summary>
  184.         /// Begin the creation of an XmlSchemaSimpleType object that will be used to represent a static built-in type.
  185.         /// Once StartBuiltinType has been called for all built-in types, FinishBuiltinType should be called in order
  186.         /// to create links between the types.
  187.         /// </summary>
  188.         static internal XmlSchemaSimpleType StartBuiltinType(XmlQualifiedName qname, XmlSchemaDatatype dataType)
  189.         {
  190.             XmlSchemaSimpleType simpleType;
  191.             Debug.Assert(qname != null && dataType != null);
  192.            
  193.             simpleType = new XmlSchemaSimpleType();
  194.             simpleType.SetQualifiedName(qname);
  195.             simpleType.SetDatatype(dataType);
  196.             simpleType.ElementDecl = new SchemaElementDecl(dataType);
  197.             simpleType.ElementDecl.SchemaType = simpleType;
  198.            
  199.             return simpleType;
  200.         }
  201.        
  202.         /// <summary>
  203.         /// Finish constructing built-in types by setting up derivation and list links.
  204.         /// </summary>
  205.         static internal void FinishBuiltinType(XmlSchemaSimpleType derivedType, XmlSchemaSimpleType baseType)
  206.         {
  207.             Debug.Assert(derivedType != null && baseType != null);
  208.            
  209.             // Create link from the derived type to the base type
  210.             derivedType.SetBaseSchemaType(baseType);
  211.             derivedType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction);
  212.             if (derivedType.Datatype.Variety == XmlSchemaDatatypeVariety.Atomic) {
  213.                 //Content is restriction
  214.                 XmlSchemaSimpleTypeRestriction restContent = new XmlSchemaSimpleTypeRestriction();
  215.                 restContent.BaseTypeName = baseType.QualifiedName;
  216.                 derivedType.Content = restContent;
  217.             }
  218.            
  219.             // Create link from a list type to its member type
  220.             if (derivedType.Datatype.Variety == XmlSchemaDatatypeVariety.List) {
  221.                 XmlSchemaSimpleTypeList listContent = new XmlSchemaSimpleTypeList();
  222.                 derivedType.SetDerivedBy(XmlSchemaDerivationMethod.List);
  223.                 switch (derivedType.Datatype.TypeCode) {
  224.                     case XmlTypeCode.NmToken:
  225.                         listContent.ItemType = listContent.BaseItemType = enumToTypeCode[(int)XmlTypeCode.NmToken];
  226.                         break;
  227.                     case XmlTypeCode.Entity:
  228.                        
  229.                         listContent.ItemType = listContent.BaseItemType = enumToTypeCode[(int)XmlTypeCode.Entity];
  230.                         break;
  231.                     case XmlTypeCode.Idref:
  232.                        
  233.                         listContent.ItemType = listContent.BaseItemType = enumToTypeCode[(int)XmlTypeCode.Idref];
  234.                         break;
  235.                 }
  236.                 derivedType.Content = listContent;
  237.             }
  238.         }
  239.        
  240.         static internal void CreateBuiltinTypes()
  241.         {
  242.             XmlQualifiedName qname;
  243.            
  244.             //Build anySimpleType
  245.             SchemaDatatypeMap sdm = c_XsdTypes[anySimpleTypeIndex];
  246.             //anySimpleType
  247.             qname = new XmlQualifiedName(sdm.Name, XmlReservedNs.NsXs);
  248.             DatatypeImplementation dt = FromTypeName(qname.Name);
  249.             anySimpleType = StartBuiltinType(qname, dt);
  250.             dt.parentSchemaType = anySimpleType;
  251.             builtinTypes.Add(qname, anySimpleType);
  252.            
  253.             // Start construction of each built-in Xsd type
  254.             XmlSchemaSimpleType simpleType;
  255.             for (int i = 0; i < c_XsdTypes.Length; i++) {
  256.                 //Create all types
  257.                 if (i == anySimpleTypeIndex) {
  258.                     //anySimpleType
  259.                     continue;
  260.                 }
  261.                 sdm = c_XsdTypes[i];
  262.                
  263.                 qname = new XmlQualifiedName(sdm.Name, XmlReservedNs.NsXs);
  264.                 dt = FromTypeName(qname.Name);
  265.                 simpleType = StartBuiltinType(qname, dt);
  266.                 dt.parentSchemaType = simpleType;
  267.                
  268.                 builtinTypes.Add(qname, simpleType);
  269.                 if (dt.variety == XmlSchemaDatatypeVariety.Atomic) {
  270.                     enumToTypeCode[(int)dt.TypeCode] = simpleType;
  271.                 }
  272.             }
  273.            
  274.             // Finish construction of each built-in Xsd type
  275.             for (int i = 0; i < c_XsdTypes.Length; i++) {
  276.                 if (i == anySimpleTypeIndex) {
  277.                     //anySimpleType
  278.                     continue;
  279.                 }
  280.                 sdm = c_XsdTypes[i];
  281.                 XmlSchemaSimpleType derivedType = (XmlSchemaSimpleType)builtinTypes[new XmlQualifiedName(sdm.Name, XmlReservedNs.NsXs)];
  282.                 XmlSchemaSimpleType baseType;
  283.                
  284.                 if (sdm.ParentIndex == anySimpleTypeIndex) {
  285.                     FinishBuiltinType(derivedType, anySimpleType);
  286.                 }
  287.                 else {
  288.                     //derived types whose index > 0
  289.                     baseType = (XmlSchemaSimpleType)builtinTypes[new XmlQualifiedName(((SchemaDatatypeMap)(c_XsdTypes[sdm.ParentIndex])).Name, XmlReservedNs.NsXs)];
  290.                     FinishBuiltinType(derivedType, baseType);
  291.                 }
  292.             }
  293.            
  294.             // Construct xdt:anyAtomicType type (derived from xs:anySimpleType)
  295.             qname = new XmlQualifiedName("anyAtomicType", XmlReservedNs.NsXQueryDataType);
  296.             anyAtomicType = StartBuiltinType(qname, c_anyAtomicType);
  297.             c_anyAtomicType.parentSchemaType = anyAtomicType;
  298.             FinishBuiltinType(anyAtomicType, anySimpleType);
  299.             builtinTypes.Add(qname, anyAtomicType);
  300.             enumToTypeCode[(int)XmlTypeCode.AnyAtomicType] = anyAtomicType;
  301.            
  302.             // Construct xdt:untypedAtomic type (derived from xdt:anyAtomicType)
  303.             qname = new XmlQualifiedName("untypedAtomic", XmlReservedNs.NsXQueryDataType);
  304.             untypedAtomicType = StartBuiltinType(qname, c_untypedAtomicType);
  305.             c_untypedAtomicType.parentSchemaType = untypedAtomicType;
  306.             FinishBuiltinType(untypedAtomicType, anyAtomicType);
  307.             builtinTypes.Add(qname, untypedAtomicType);
  308.             enumToTypeCode[(int)XmlTypeCode.UntypedAtomic] = untypedAtomicType;
  309.            
  310.             // Construct xdt:yearMonthDuration type (derived from xs:duration)
  311.             qname = new XmlQualifiedName("yearMonthDuration", XmlReservedNs.NsXQueryDataType);
  312.             yearMonthDurationType = StartBuiltinType(qname, c_yearMonthDuration);
  313.             c_yearMonthDuration.parentSchemaType = yearMonthDurationType;
  314.             FinishBuiltinType(yearMonthDurationType, enumToTypeCode[(int)XmlTypeCode.Duration]);
  315.             builtinTypes.Add(qname, yearMonthDurationType);
  316.             enumToTypeCode[(int)XmlTypeCode.YearMonthDuration] = yearMonthDurationType;
  317.            
  318.             // Construct xdt:dayTimeDuration type (derived from xs:duration)
  319.             qname = new XmlQualifiedName("dayTimeDuration", XmlReservedNs.NsXQueryDataType);
  320.             dayTimeDurationType = StartBuiltinType(qname, c_dayTimeDuration);
  321.             c_dayTimeDuration.parentSchemaType = dayTimeDurationType;
  322.             FinishBuiltinType(dayTimeDurationType, enumToTypeCode[(int)XmlTypeCode.Duration]);
  323.             builtinTypes.Add(qname, dayTimeDurationType);
  324.             enumToTypeCode[(int)XmlTypeCode.DayTimeDuration] = dayTimeDurationType;
  325.         }
  326.        
  327.         static internal XmlSchemaSimpleType GetSimpleTypeFromTypeCode(XmlTypeCode typeCode)
  328.         {
  329.             return enumToTypeCode[(int)typeCode];
  330.         }
  331.        
  332.         static internal XmlSchemaSimpleType GetSimpleTypeFromXsdType(XmlQualifiedName qname)
  333.         {
  334.             return (XmlSchemaSimpleType)builtinTypes[qname];
  335.         }
  336.        
  337.         static internal XmlSchemaSimpleType GetNormalizedStringTypeV1Compat()
  338.         {
  339.             if (normalizedStringTypeV1Compat == null) {
  340.                 XmlSchemaSimpleType correctType = GetSimpleTypeFromTypeCode(XmlTypeCode.NormalizedString);
  341.                 normalizedStringTypeV1Compat = correctType.Clone() as XmlSchemaSimpleType;
  342.                 normalizedStringTypeV1Compat.SetDatatype(c_normalizedStringV1Compat);
  343.                 normalizedStringTypeV1Compat.ElementDecl = new SchemaElementDecl(c_normalizedStringV1Compat);
  344.                 normalizedStringTypeV1Compat.ElementDecl.SchemaType = normalizedStringTypeV1Compat;
  345.             }
  346.             return normalizedStringTypeV1Compat;
  347.         }
  348.        
  349.         static internal XmlSchemaSimpleType GetTokenTypeV1Compat()
  350.         {
  351.             if (tokenTypeV1Compat == null) {
  352.                 XmlSchemaSimpleType correctType = GetSimpleTypeFromTypeCode(XmlTypeCode.Token);
  353.                 tokenTypeV1Compat = correctType.Clone() as XmlSchemaSimpleType;
  354.                 tokenTypeV1Compat.SetDatatype(c_tokenV1Compat);
  355.                 tokenTypeV1Compat.ElementDecl = new SchemaElementDecl(c_tokenV1Compat);
  356.                 tokenTypeV1Compat.ElementDecl.SchemaType = tokenTypeV1Compat;
  357.             }
  358.             return tokenTypeV1Compat;
  359.         }
  360.        
  361.         static internal XmlSchemaSimpleType[] GetBuiltInTypes()
  362.         {
  363.             return enumToTypeCode;
  364.         }
  365.        
  366.         static internal XmlTypeCode GetPrimitiveTypeCode(XmlTypeCode typeCode)
  367.         {
  368.             XmlSchemaSimpleType currentType = enumToTypeCode[(int)typeCode];
  369.             while (currentType.BaseXmlSchemaType != DatatypeImplementation.AnySimpleType) {
  370.                 currentType = currentType.BaseXmlSchemaType as XmlSchemaSimpleType;
  371.                 Debug.Assert(currentType != null);
  372.             }
  373.             return currentType.TypeCode;
  374.         }
  375.        
  376.         internal override XmlSchemaDatatype DeriveByRestriction(XmlSchemaObjectCollection facets, XmlNameTable nameTable, XmlSchemaType schemaType)
  377.         {
  378.             DatatypeImplementation dt = (DatatypeImplementation)MemberwiseClone();
  379.             dt.restriction = this.FacetsChecker.ConstructRestriction(this, facets, nameTable);
  380.             dt.baseType = this;
  381.             dt.parentSchemaType = schemaType;
  382.             dt.valueConverter = null;
  383.             //re-set old datatype's valueconverter
  384.             return dt;
  385.         }
  386.        
  387.         internal override XmlSchemaDatatype DeriveByList(XmlSchemaType schemaType)
  388.         {
  389.             return DeriveByList(0, schemaType);
  390.         }
  391.        
  392.         internal XmlSchemaDatatype DeriveByList(int minSize, XmlSchemaType schemaType)
  393.         {
  394.             if (variety == XmlSchemaDatatypeVariety.List) {
  395.                 throw new XmlSchemaException(Res.Sch_ListFromNonatomic, string.Empty);
  396.             }
  397.             else if (variety == XmlSchemaDatatypeVariety.Union && !((Datatype_union)this).HasAtomicMembers()) {
  398.                 throw new XmlSchemaException(Res.Sch_ListFromNonatomic, string.Empty);
  399.             }
  400.             DatatypeImplementation dt = new Datatype_List(this, minSize);
  401.             dt.variety = XmlSchemaDatatypeVariety.List;
  402.             dt.restriction = null;
  403.             dt.baseType = c_anySimpleType;
  404.             //Base type of a union is anySimpleType
  405.             dt.parentSchemaType = schemaType;
  406.             return dt;
  407.         }
  408.        
  409.         static internal new DatatypeImplementation DeriveByUnion(XmlSchemaSimpleType[] types, XmlSchemaType schemaType)
  410.         {
  411.             DatatypeImplementation dt = new Datatype_union(types);
  412.             dt.baseType = c_anySimpleType;
  413.             //Base type of a union is anySimpleType
  414.             dt.variety = XmlSchemaDatatypeVariety.Union;
  415.             dt.parentSchemaType = schemaType;
  416.             return dt;
  417.         }
  418.        
  419.         internal override void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller)
  420.         {
  421.             /*noop*/        }
  422.        
  423.         public override bool IsDerivedFrom(XmlSchemaDatatype datatype)
  424.         {
  425.             if (datatype == null) {
  426.                 return false;
  427.             }
  428.            
  429.             //Common case - Derived by restriction
  430.             for (DatatypeImplementation dt = this; dt != null; dt = dt.baseType) {
  431.                 if (dt == datatype) {
  432.                     return true;
  433.                 }
  434.             }
  435.             if (((DatatypeImplementation)datatype).baseType == null) {
  436.                 //Both are built-in types
  437.                 Type derivedType = this.GetType();
  438.                 Type baseType = datatype.GetType();
  439.                 return baseType == derivedType || derivedType.IsSubclassOf(baseType);
  440.             }
  441.             else if (datatype.Variety == XmlSchemaDatatypeVariety.Union && !datatype.HasLexicalFacets && !datatype.HasValueFacets && variety != XmlSchemaDatatypeVariety.Union) {
  442.                 //base type is union (not a restriction of union) and derived type is not union
  443.                 return ((Datatype_union)datatype).IsUnionBaseOf(this);
  444.             }
  445.             else if ((variety == XmlSchemaDatatypeVariety.Union || variety == XmlSchemaDatatypeVariety.List) && restriction == null) {
  446.                 //derived type is union (not a restriction)
  447.                 return (datatype == anySimpleType.Datatype);
  448.             }
  449.             return false;
  450.         }
  451.        
  452.         internal override bool IsEqual(object o1, object o2)
  453.         {
  454.             //Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceVerbose, string.Format("\t\tSchemaDatatype.IsEqual({0}, {1})", o1, o2));
  455.             return Compare(o1, o2) == 0;
  456.         }
  457.        
  458.         internal override bool IsComparable(XmlSchemaDatatype dtype)
  459.         {
  460.             XmlTypeCode thisCode = this.TypeCode;
  461.             XmlTypeCode otherCode = dtype.TypeCode;
  462.            
  463.             if (thisCode == otherCode) {
  464.                 //They are both same built-in type or one is list and the other is list's itemType
  465.                 return true;
  466.             }
  467.             if (GetPrimitiveTypeCode(thisCode) == GetPrimitiveTypeCode(otherCode)) {
  468.                 return true;
  469.             }
  470.             if (this.IsDerivedFrom(dtype) || dtype.IsDerivedFrom(this)) {
  471.                 //One is union and the other is a member of the union
  472.                 return true;
  473.             }
  474.             return false;
  475.         }
  476.        
  477.         internal virtual XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  478.         {
  479.             return null;
  480.         }
  481.        
  482.         internal override FacetsChecker FacetsChecker {
  483.             get { return miscFacetsChecker; }
  484.         }
  485.        
  486.         internal override XmlValueConverter ValueConverter {
  487.             get {
  488.                 if (valueConverter == null) {
  489.                     valueConverter = CreateValueConverter(this.parentSchemaType);
  490.                 }
  491.                 return valueConverter;
  492.             }
  493.         }
  494.        
  495.         public override XmlTokenizedType TokenizedType {
  496.             get { return XmlTokenizedType.None; }
  497.         }
  498.        
  499.         public override Type ValueType {
  500.             get { return typeof(string); }
  501.         }
  502.        
  503.         public override XmlSchemaDatatypeVariety Variety {
  504.             get { return variety; }
  505.         }
  506.        
  507.         public override XmlTypeCode TypeCode {
  508.             get { return XmlTypeCode.None; }
  509.         }
  510.        
  511.         internal override RestrictionFacets Restriction {
  512.             get { return restriction; }
  513.             set { restriction = value; }
  514.         }
  515.         internal override bool HasLexicalFacets {
  516.             get {
  517.                 RestrictionFlags flags = restriction != null ? restriction.Flags : 0;
  518.                 if (flags != 0 && (flags & (RestrictionFlags.Pattern | RestrictionFlags.WhiteSpace | RestrictionFlags.TotalDigits | RestrictionFlags.FractionDigits)) != 0) {
  519.                     return true;
  520.                 }
  521.                 return false;
  522.             }
  523.         }
  524.         internal override bool HasValueFacets {
  525.             get {
  526.                 RestrictionFlags flags = restriction != null ? restriction.Flags : 0;
  527.                 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) {
  528.                     return true;
  529.                 }
  530.                 return false;
  531.             }
  532.         }
  533.        
  534.         protected DatatypeImplementation Base {
  535.             get { return baseType; }
  536.         }
  537.        
  538.         internal abstract Type ListValueType {
  539.             get;
  540.         }
  541.        
  542.         internal abstract RestrictionFlags ValidRestrictionFlags {
  543.             get;
  544.         }
  545.        
  546.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  547.             get { return XmlSchemaWhiteSpace.Preserve; }
  548.         }
  549.        
  550.         internal override object ParseValue(string s, Type typDest, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
  551.         {
  552.             return ValueConverter.ChangeType(ParseValue(s, nameTable, nsmgr), typDest, nsmgr);
  553.         }
  554.        
  555.         public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
  556.         {
  557.             object typedValue;
  558.             Exception exception = TryParseValue(s, nameTable, nsmgr, out typedValue);
  559.             if (exception != null) {
  560.                 throw new XmlSchemaException(Res.Sch_InvalidValueDetailed, new string[] {s, GetTypeName(), exception.Message}, exception, null, 0, 0, null);
  561.             }
  562.             if (this.Variety == XmlSchemaDatatypeVariety.Union) {
  563.                 XsdSimpleValue simpleValue = typedValue as XsdSimpleValue;
  564.                 return simpleValue.TypedValue;
  565.             }
  566.             return typedValue;
  567.         }
  568.        
  569.         internal override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, bool createAtomicValue)
  570.         {
  571.             if (createAtomicValue) {
  572.                 object typedValue;
  573.                 Exception exception = TryParseValue(s, nameTable, nsmgr, out typedValue);
  574.                 if (exception != null) {
  575.                     throw new XmlSchemaException(Res.Sch_InvalidValueDetailed, new string[] {s, GetTypeName(), exception.Message}, exception, null, 0, 0, null);
  576.                 }
  577.                 return typedValue;
  578.             }
  579.             else {
  580.                 return ParseValue(s, nameTable, nsmgr);
  581.             }
  582.         }
  583.        
  584.         internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver namespaceResolver, out object typedValue)
  585.         {
  586.             Exception exception = null;
  587.             typedValue = null;
  588.             if (value == null) {
  589.                 return new ArgumentNullException("value");
  590.             }
  591.             string s = value as string;
  592.             if (s != null) {
  593.                 return TryParseValue(s, nameTable, namespaceResolver, out typedValue);
  594.             }
  595.             try {
  596.                 object valueToCheck = value;
  597.                 if (value.GetType() != this.ValueType) {
  598.                     valueToCheck = this.ValueConverter.ChangeType(value, this.ValueType, namespaceResolver);
  599.                 }
  600.                 if (this.HasLexicalFacets) {
  601.                     string s1 = (string)this.ValueConverter.ChangeType(value, typeof(string), namespaceResolver);
  602.                     //Using value here to avoid info loss
  603.                     exception = this.FacetsChecker.CheckLexicalFacets(ref s1, this);
  604.                     if (exception != null)
  605.                         goto Error;
  606.                 }
  607.                 if (this.HasValueFacets) {
  608.                     exception = this.FacetsChecker.CheckValueFacets(valueToCheck, this);
  609.                     if (exception != null)
  610.                         goto Error;
  611.                 }
  612.                 typedValue = valueToCheck;
  613.                 return null;
  614.             }
  615.             catch (FormatException e) {
  616.                 //Catching for exceptions thrown by ValueConverter
  617.                 exception = e;
  618.             }
  619.             catch (InvalidCastException e) {
  620.                 //Catching for exceptions thrown by ValueConverter
  621.                 exception = e;
  622.             }
  623.             catch (OverflowException e) {
  624.                 //Catching for exceptions thrown by ValueConverter
  625.                 exception = e;
  626.             }
  627.             catch (ArgumentException e) {
  628.                 //Catching for exceptions thrown by ValueConverter
  629.                 exception = e;
  630.             }
  631.             Error:
  632.            
  633.             return exception;
  634.         }
  635.        
  636.         internal string GetTypeName()
  637.         {
  638.             XmlSchemaType simpleType = this.parentSchemaType;
  639.             string typeName;
  640.             if (simpleType == null || simpleType.QualifiedName.IsEmpty) {
  641.                 //If no QName, get typecode, no line info since it is not pertinent without file name
  642.                 typeName = TypeCodeString;
  643.             }
  644.             else {
  645.                 typeName = simpleType.QualifiedName.ToString();
  646.             }
  647.             return typeName;
  648.         }
  649.        
  650.         // XSD types
  651.         private static readonly DatatypeImplementation c_anySimpleType = new Datatype_anySimpleType();
  652.         private static readonly DatatypeImplementation c_anyURI = new Datatype_anyURI();
  653.         private static readonly DatatypeImplementation c_base64Binary = new Datatype_base64Binary();
  654.         private static readonly DatatypeImplementation c_boolean = new Datatype_boolean();
  655.         private static readonly DatatypeImplementation c_byte = new Datatype_byte();
  656.         private static readonly DatatypeImplementation c_char = new Datatype_char();
  657.         // XDR
  658.         private static readonly DatatypeImplementation c_date = new Datatype_date();
  659.         private static readonly DatatypeImplementation c_dateTime = new Datatype_dateTime();
  660.         private static readonly DatatypeImplementation c_dateTimeNoTz = new Datatype_dateTimeNoTimeZone();
  661.         // XDR
  662.         private static readonly DatatypeImplementation c_dateTimeTz = new Datatype_dateTimeTimeZone();
  663.         // XDR
  664.         private static readonly DatatypeImplementation c_day = new Datatype_day();
  665.         private static readonly DatatypeImplementation c_decimal = new Datatype_decimal();
  666.         private static readonly DatatypeImplementation c_double = new Datatype_double();
  667.         private static readonly DatatypeImplementation c_doubleXdr = new Datatype_doubleXdr();
  668.         // XDR
  669.         private static readonly DatatypeImplementation c_duration = new Datatype_duration();
  670.         private static readonly DatatypeImplementation c_ENTITY = new Datatype_ENTITY();
  671.         private static readonly DatatypeImplementation c_ENTITIES = (DatatypeImplementation)c_ENTITY.DeriveByList(1, null);
  672.         private static readonly DatatypeImplementation c_ENUMERATION = new Datatype_ENUMERATION();
  673.         // XDR
  674.         private static readonly DatatypeImplementation c_fixed = new Datatype_fixed();
  675.         private static readonly DatatypeImplementation c_float = new Datatype_float();
  676.         private static readonly DatatypeImplementation c_floatXdr = new Datatype_floatXdr();
  677.         // XDR
  678.         private static readonly DatatypeImplementation c_hexBinary = new Datatype_hexBinary();
  679.         private static readonly DatatypeImplementation c_ID = new Datatype_ID();
  680.         private static readonly DatatypeImplementation c_IDREF = new Datatype_IDREF();
  681.         private static readonly DatatypeImplementation c_IDREFS = (DatatypeImplementation)c_IDREF.DeriveByList(1, null);
  682.         private static readonly DatatypeImplementation c_int = new Datatype_int();
  683.         private static readonly DatatypeImplementation c_integer = new Datatype_integer();
  684.         private static readonly DatatypeImplementation c_language = new Datatype_language();
  685.         private static readonly DatatypeImplementation c_long = new Datatype_long();
  686.         private static readonly DatatypeImplementation c_month = new Datatype_month();
  687.         private static readonly DatatypeImplementation c_monthDay = new Datatype_monthDay();
  688.         private static readonly DatatypeImplementation c_Name = new Datatype_Name();
  689.         private static readonly DatatypeImplementation c_NCName = new Datatype_NCName();
  690.         private static readonly DatatypeImplementation c_negativeInteger = new Datatype_negativeInteger();
  691.         private static readonly DatatypeImplementation c_NMTOKEN = new Datatype_NMTOKEN();
  692.         private static readonly DatatypeImplementation c_NMTOKENS = (DatatypeImplementation)c_NMTOKEN.DeriveByList(1, null);
  693.         private static readonly DatatypeImplementation c_nonNegativeInteger = new Datatype_nonNegativeInteger();
  694.         private static readonly DatatypeImplementation c_nonPositiveInteger = new Datatype_nonPositiveInteger();
  695.         private static readonly DatatypeImplementation c_normalizedString = new Datatype_normalizedString();
  696.         private static readonly DatatypeImplementation c_NOTATION = new Datatype_NOTATION();
  697.         private static readonly DatatypeImplementation c_positiveInteger = new Datatype_positiveInteger();
  698.         private static readonly DatatypeImplementation c_QName = new Datatype_QName();
  699.         private static readonly DatatypeImplementation c_QNameXdr = new Datatype_QNameXdr();
  700.         //XDR
  701.         private static readonly DatatypeImplementation c_short = new Datatype_short();
  702.         private static readonly DatatypeImplementation c_string = new Datatype_string();
  703.         private static readonly DatatypeImplementation c_time = new Datatype_time();
  704.         private static readonly DatatypeImplementation c_timeNoTz = new Datatype_timeNoTimeZone();
  705.         // XDR
  706.         private static readonly DatatypeImplementation c_timeTz = new Datatype_timeTimeZone();
  707.         // XDR
  708.         private static readonly DatatypeImplementation c_token = new Datatype_token();
  709.         private static readonly DatatypeImplementation c_unsignedByte = new Datatype_unsignedByte();
  710.         private static readonly DatatypeImplementation c_unsignedInt = new Datatype_unsignedInt();
  711.         private static readonly DatatypeImplementation c_unsignedLong = new Datatype_unsignedLong();
  712.         private static readonly DatatypeImplementation c_unsignedShort = new Datatype_unsignedShort();
  713.         private static readonly DatatypeImplementation c_uuid = new Datatype_uuid();
  714.         // XDR
  715.         private static readonly DatatypeImplementation c_year = new Datatype_year();
  716.         private static readonly DatatypeImplementation c_yearMonth = new Datatype_yearMonth();
  717.        
  718.         //V1 compat types
  719.         static internal readonly DatatypeImplementation c_normalizedStringV1Compat = new Datatype_normalizedStringV1Compat();
  720.         static internal readonly DatatypeImplementation c_tokenV1Compat = new Datatype_tokenV1Compat();
  721.        
  722.         // XQuery types
  723.         private static readonly DatatypeImplementation c_anyAtomicType = new Datatype_anyAtomicType();
  724.         private static readonly DatatypeImplementation c_dayTimeDuration = new Datatype_dayTimeDuration();
  725.         private static readonly DatatypeImplementation c_untypedAtomicType = new Datatype_untypedAtomicType();
  726.         private static readonly DatatypeImplementation c_yearMonthDuration = new Datatype_yearMonthDuration();
  727.        
  728.        
  729.         private class SchemaDatatypeMap : IComparable
  730.         {
  731.             string name;
  732.             DatatypeImplementation type;
  733.             int parentIndex;
  734.            
  735.             internal SchemaDatatypeMap(string name, DatatypeImplementation type)
  736.             {
  737.                 this.name = name;
  738.                 this.type = type;
  739.             }
  740.            
  741.             internal SchemaDatatypeMap(string name, DatatypeImplementation type, int parentIndex)
  742.             {
  743.                 this.name = name;
  744.                 this.type = type;
  745.                 this.parentIndex = parentIndex;
  746.             }
  747.             public static explicit operator DatatypeImplementation(SchemaDatatypeMap sdm)
  748.             {
  749.                 return sdm.type;
  750.             }
  751.            
  752.             public string Name {
  753.                 get { return name; }
  754.             }
  755.            
  756.             public int ParentIndex {
  757.                 get { return parentIndex; }
  758.             }
  759.            
  760.             public int CompareTo(object obj)
  761.             {
  762.                 return string.Compare(name, (string)obj, StringComparison.Ordinal);
  763.             }
  764.         }
  765.        
  766.         private static readonly DatatypeImplementation[] c_tokenizedTypes = {c_string, c_ID, c_IDREF, c_IDREFS, c_ENTITY, c_ENTITIES, c_NMTOKEN, c_NMTOKENS, c_NOTATION, c_ENUMERATION,
  767.             // CDATA
  768.             // ID
  769.             // IDREF
  770.             // IDREFS
  771.             // ENTITY
  772.             // ENTITIES
  773.             // NMTOKEN
  774.             // NMTOKENS
  775.             // NOTATION
  776.             // ENUMERATION
  777.             // QName
  778.             // NCName
  779.         c_QNameXdr, c_NCName, null};
  780.        
  781.         private static readonly DatatypeImplementation[] c_tokenizedTypesXsd = {c_string, c_ID, c_IDREF, c_IDREFS, c_ENTITY, c_ENTITIES, c_NMTOKEN, c_NMTOKENS, c_NOTATION, c_ENUMERATION,
  782.             // CDATA
  783.             // ID
  784.             // IDREF
  785.             // IDREFS
  786.             // ENTITY
  787.             // ENTITIES
  788.             // NMTOKEN
  789.             // NMTOKENS
  790.             // NOTATION
  791.             // ENUMERATION
  792.             // QName
  793.             // NCName
  794.         c_QName, c_NCName, null};
  795.        
  796.         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),
  797.         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),
  798.         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),
  799.         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)};
  800.        
  801.        
  802.         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),
  803.         new SchemaDatatypeMap("QName", c_QName, 11), 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),
  804.         new SchemaDatatypeMap("duration", c_duration, 11), 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),
  805.         new SchemaDatatypeMap("language", c_language, 40), 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),
  806.            
  807.            
  808.             //-> 10
  809.             //->20
  810.             //->30
  811.            
  812.            
  813.            
  814.            
  815.             //->40
  816.         new SchemaDatatypeMap("token", c_token, 35), new SchemaDatatypeMap("unsignedByte", c_unsignedByte, 44), new SchemaDatatypeMap("unsignedInt", c_unsignedInt, 43), new SchemaDatatypeMap("unsignedLong", c_unsignedLong, 33), new SchemaDatatypeMap("unsignedShort", c_unsignedShort, 42)};
  817.        
  818.         protected int Compare(byte[] value1, byte[] value2)
  819.         {
  820.             int length = value1.Length;
  821.             if (length != value2.Length) {
  822.                 return -1;
  823.             }
  824.             for (int i = 0; i < length; i++) {
  825.                 if (value1[i] != value2[i]) {
  826.                     return -1;
  827.                 }
  828.             }
  829.             return 0;
  830.         }
  831.        
  832.        
  833.     }
  834.    
  835.    
  836.     //List type
  837.     internal class Datatype_List : Datatype_anySimpleType
  838.     {
  839.         DatatypeImplementation itemType;
  840.         int minListSize;
  841.        
  842.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  843.         {
  844.             XmlSchemaType listItemType = null;
  845.             XmlSchemaSimpleType simpleType;
  846.             XmlSchemaComplexType complexType;
  847.             complexType = schemaType as XmlSchemaComplexType;
  848.            
  849.             if (complexType != null) {
  850.                 do {
  851.                     simpleType = complexType.BaseXmlSchemaType as XmlSchemaSimpleType;
  852.                     if (simpleType != null) {
  853.                         break;
  854.                     }
  855.                     complexType = complexType.BaseXmlSchemaType as XmlSchemaComplexType;
  856.                 }
  857.                 while (complexType != null && complexType != XmlSchemaComplexType.AnyType);
  858.             }
  859.             else {
  860.                 simpleType = schemaType as XmlSchemaSimpleType;
  861.             }
  862.             if (simpleType != null) {
  863.                 do {
  864.                     XmlSchemaSimpleTypeList listType = simpleType.Content as XmlSchemaSimpleTypeList;
  865.                     if (listType != null) {
  866.                         listItemType = listType.BaseItemType;
  867.                         break;
  868.                     }
  869.                     simpleType = simpleType.BaseXmlSchemaType as XmlSchemaSimpleType;
  870.                 }
  871.                 while (simpleType != null && simpleType != DatatypeImplementation.AnySimpleType);
  872.             }
  873.            
  874.             if (listItemType == null) {
  875.                 //Get built-in simple type for the typecode
  876.                 listItemType = DatatypeImplementation.GetSimpleTypeFromTypeCode(schemaType.Datatype.TypeCode);
  877.             }
  878.            
  879.             return XmlListConverter.Create(listItemType.ValueConverter);
  880.         }
  881.        
  882.         internal Datatype_List(DatatypeImplementation type) : this(type, 0)
  883.         {
  884.         }
  885.         internal Datatype_List(DatatypeImplementation type, int minListSize)
  886.         {
  887.             this.itemType = type;
  888.             this.minListSize = minListSize;
  889.         }
  890.        
  891.         internal override int Compare(object value1, object value2)
  892.         {
  893.             System.Array arr1 = (System.Array)value1;
  894.             System.Array arr2 = (System.Array)value2;
  895.            
  896.             Debug.Assert(arr1 != null && arr2 != null);
  897.             int length = arr1.Length;
  898.             if (length != arr2.Length) {
  899.                 return -1;
  900.             }
  901.             XmlAtomicValue[] atomicValues1 = arr1 as XmlAtomicValue[];
  902.             if (atomicValues1 != null) {
  903.                 XmlAtomicValue[] atomicValues2 = arr2 as XmlAtomicValue[];
  904.                 Debug.Assert(atomicValues2 != null);
  905.                 XmlSchemaType xmlType1;
  906.                 for (int i = 0; i < atomicValues1.Length; i++) {
  907.                     xmlType1 = atomicValues1[i].XmlType;
  908.                     if (xmlType1 != atomicValues2[i].XmlType || !xmlType1.Datatype.IsEqual(atomicValues1[i].TypedValue, atomicValues2[i].TypedValue)) {
  909.                         return -1;
  910.                     }
  911.                 }
  912.                 return 0;
  913.             }
  914.             else {
  915.                 for (int i = 0; i < arr1.Length; i++) {
  916.                     if (itemType.Compare(arr1.GetValue(i), arr2.GetValue(i)) != 0) {
  917.                         return -1;
  918.                     }
  919.                 }
  920.                 return 0;
  921.             }
  922.         }
  923.        
  924.         public override Type ValueType {
  925.             get { return ListValueType; }
  926.         }
  927.        
  928.         public override XmlTokenizedType TokenizedType {
  929.             get { return itemType.TokenizedType; }
  930.         }
  931.        
  932.         internal override Type ListValueType {
  933.             get { return itemType.ListValueType; }
  934.         }
  935.        
  936.         internal override FacetsChecker FacetsChecker {
  937.             get { return listFacetsChecker; }
  938.         }
  939.        
  940.         public override XmlTypeCode TypeCode {
  941.             get { return itemType.TypeCode; }
  942.         }
  943.        
  944.         internal override RestrictionFlags ValidRestrictionFlags {
  945.             get { return RestrictionFlags.Length | RestrictionFlags.MinLength | RestrictionFlags.MaxLength | RestrictionFlags.Enumeration | RestrictionFlags.WhiteSpace | RestrictionFlags.Pattern; }
  946.         }
  947.         internal DatatypeImplementation ItemType {
  948.             get { return itemType; }
  949.         }
  950.        
  951.         internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver namespaceResolver, out object typedValue)
  952.         {
  953.             Exception exception;
  954.             if (value == null) {
  955.                 throw new ArgumentNullException("value");
  956.             }
  957.             string s = value as string;
  958.             typedValue = null;
  959.             if (s != null) {
  960.                 return TryParseValue(s, nameTable, namespaceResolver, out typedValue);
  961.             }
  962.            
  963.             try {
  964.                 object valueToCheck = this.ValueConverter.ChangeType(value, this.ValueType, namespaceResolver);
  965.                 Array valuesToCheck = valueToCheck as Array;
  966.                 Debug.Assert(valuesToCheck != null);
  967.                
  968.                 bool checkItemLexical = itemType.HasLexicalFacets;
  969.                 bool checkItemValue = itemType.HasValueFacets;
  970.                 object item;
  971.                 FacetsChecker itemFacetsChecker = itemType.FacetsChecker;
  972.                 XmlValueConverter itemValueConverter = itemType.ValueConverter;
  973.                
  974.                 for (int i = 0; i < valuesToCheck.Length; i++) {
  975.                     item = valuesToCheck.GetValue(i);
  976.                     if (checkItemLexical) {
  977.                         string s1 = (string)itemValueConverter.ChangeType(item, typeof(string), namespaceResolver);
  978.                         exception = itemFacetsChecker.CheckLexicalFacets(ref s1, itemType);
  979.                         if (exception != null)
  980.                             goto Error;
  981.                     }
  982.                     if (checkItemValue) {
  983.                         exception = itemFacetsChecker.CheckValueFacets(item, itemType);
  984.                         if (exception != null)
  985.                             goto Error;
  986.                     }
  987.                 }
  988.                
  989.                 //Check facets on the list itself
  990.                 if (this.HasLexicalFacets) {
  991.                     string s1 = (string)this.ValueConverter.ChangeType(valueToCheck, typeof(string), namespaceResolver);
  992.                     exception = listFacetsChecker.CheckLexicalFacets(ref s1, this);
  993.                     if (exception != null)
  994.                         goto Error;
  995.                 }
  996.                 if (this.HasValueFacets) {
  997.                     exception = listFacetsChecker.CheckValueFacets(valueToCheck, this);
  998.                     if (exception != null)
  999.                         goto Error;
  1000.                 }
  1001.                 typedValue = valueToCheck;
  1002.                 return null;
  1003.             }
  1004.             catch (FormatException e) {
  1005.                 //Catching for exceptions thrown by ValueConverter
  1006.                 exception = e;
  1007.             }
  1008.             catch (InvalidCastException e) {
  1009.                 //Catching for exceptions thrown by ValueConverter
  1010.                 exception = e;
  1011.             }
  1012.             catch (OverflowException e) {
  1013.                 //Catching for exceptions thrown by ValueConverter
  1014.                 exception = e;
  1015.             }
  1016.             catch (ArgumentException e) {
  1017.                 //Catching for exceptions thrown by ValueConverter
  1018.                 exception = e;
  1019.             }
  1020.             Error:
  1021.            
  1022.             return exception;
  1023.         }
  1024.        
  1025.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  1026.         {
  1027.             Exception exception;
  1028.            
  1029.             typedValue = null;
  1030.            
  1031.             exception = listFacetsChecker.CheckLexicalFacets(ref s, this);
  1032.             if (exception != null)
  1033.                 goto Error;
  1034.            
  1035.             ArrayList values = new ArrayList();
  1036.             object array;
  1037.             if (itemType.Variety == XmlSchemaDatatypeVariety.Union) {
  1038.                 object unionTypedValue;
  1039.                 foreach (string s1 in XmlConvert.SplitString(s)) {
  1040.                     //Parse items in list according to the itemType
  1041.                     exception = itemType.TryParseValue(s1, nameTable, nsmgr, out unionTypedValue);
  1042.                     if (exception != null)
  1043.                         goto Error;
  1044.                    
  1045.                     XsdSimpleValue simpleValue = (XsdSimpleValue)unionTypedValue;
  1046.                     values.Add(new XmlAtomicValue(simpleValue.XmlType, simpleValue.TypedValue, nsmgr));
  1047.                 }
  1048.                 array = values.ToArray(typeof(XmlAtomicValue));
  1049.             }
  1050.             else {
  1051.                 //Variety == List or Atomic
  1052.                 foreach (string s1 in XmlConvert.SplitString(s)) {
  1053.                     exception = itemType.TryParseValue(s1, nameTable, nsmgr, out typedValue);
  1054.                     if (exception != null)
  1055.                         goto Error;
  1056.                    
  1057.                     values.Add(typedValue);
  1058.                 }
  1059.                 array = values.ToArray(itemType.ValueType);
  1060.                 Debug.Assert(array.GetType() == ListValueType);
  1061.             }
  1062.             if (values.Count < minListSize) {
  1063.                 return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
  1064.             }
  1065.            
  1066.             exception = listFacetsChecker.CheckValueFacets(array, this);
  1067.             if (exception != null)
  1068.                 goto Error;
  1069.            
  1070.             typedValue = array;
  1071.            
  1072.             return null;
  1073.             Error:
  1074.            
  1075.             return exception;
  1076.         }
  1077.        
  1078.     }
  1079.    
  1080.     //Union datatype
  1081.     internal class Datatype_union : Datatype_anySimpleType
  1082.     {
  1083.         static readonly Type atomicValueType = typeof(object);
  1084.         static readonly Type listValueType = typeof(object[]);
  1085.         XmlSchemaSimpleType[] types;
  1086.        
  1087.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  1088.         {
  1089.             return XmlUnionConverter.Create(schemaType);
  1090.         }
  1091.        
  1092.         internal Datatype_union(XmlSchemaSimpleType[] types)
  1093.         {
  1094.             this.types = types;
  1095.         }
  1096.        
  1097.         internal override int Compare(object value1, object value2)
  1098.         {
  1099.             XsdSimpleValue simpleValue1 = value1 as XsdSimpleValue;
  1100.             XsdSimpleValue simpleValue2 = value2 as XsdSimpleValue;
  1101.            
  1102.             if (simpleValue1 == null || simpleValue2 == null) {
  1103.                 return -1;
  1104.             }
  1105.             XmlSchemaType schemaType1 = simpleValue1.XmlType;
  1106.             XmlSchemaType schemaType2 = simpleValue2.XmlType;
  1107.            
  1108.             if (schemaType1 == schemaType2) {
  1109.                 XmlSchemaDatatype datatype = schemaType1.Datatype;
  1110.                 return datatype.Compare(simpleValue1.TypedValue, simpleValue2.TypedValue);
  1111.             }
  1112.             return -1;
  1113.         }
  1114.        
  1115.         public override Type ValueType {
  1116.             get { return atomicValueType; }
  1117.         }
  1118.        
  1119.         public override XmlTypeCode TypeCode {
  1120.             get { return XmlTypeCode.AnyAtomicType; }
  1121.         }
  1122.        
  1123.         internal override FacetsChecker FacetsChecker {
  1124.             get { return unionFacetsChecker; }
  1125.         }
  1126.        
  1127.         internal override Type ListValueType {
  1128.             get { return listValueType; }
  1129.         }
  1130.        
  1131.         internal override RestrictionFlags ValidRestrictionFlags {
  1132.             get { return RestrictionFlags.Pattern | RestrictionFlags.Enumeration; }
  1133.         }
  1134.        
  1135.         internal XmlSchemaSimpleType[] BaseMemberTypes {
  1136.             get { return types; }
  1137.         }
  1138.        
  1139.         internal bool HasAtomicMembers()
  1140.         {
  1141.             foreach (XmlSchemaSimpleType st in types) {
  1142.                 if (st.Datatype.Variety == XmlSchemaDatatypeVariety.List) {
  1143.                     return false;
  1144.                 }
  1145.             }
  1146.             return true;
  1147.         }
  1148.        
  1149.         internal bool IsUnionBaseOf(DatatypeImplementation derivedType)
  1150.         {
  1151.             foreach (XmlSchemaSimpleType st in types) {
  1152.                 if (derivedType.IsDerivedFrom(st.Datatype)) {
  1153.                     return true;
  1154.                 }
  1155.             }
  1156.             return false;
  1157.         }
  1158.        
  1159.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  1160.         {
  1161.             Exception exception;
  1162.             XmlSchemaSimpleType memberType = null;
  1163.            
  1164.             typedValue = null;
  1165.            
  1166.             exception = unionFacetsChecker.CheckLexicalFacets(ref s, this);
  1167.             if (exception != null)
  1168.                 goto Error;
  1169.            
  1170.             //Parse string to CLR value
  1171.             foreach (XmlSchemaSimpleType st in types) {
  1172.                 exception = st.Datatype.TryParseValue(s, nameTable, nsmgr, out typedValue);
  1173.                 if (exception == null) {
  1174.                     memberType = st;
  1175.                     break;
  1176.                 }
  1177.             }
  1178.             if (memberType == null) {
  1179.                 exception = new XmlSchemaException(Res.Sch_UnionFailedEx, s);
  1180.                 goto Error;
  1181.             }
  1182.            
  1183.             typedValue = new XsdSimpleValue(memberType, typedValue);
  1184.             exception = unionFacetsChecker.CheckValueFacets(typedValue, this);
  1185.             if (exception != null)
  1186.                 goto Error;
  1187.            
  1188.             return null;
  1189.             Error:
  1190.            
  1191.             return exception;
  1192.         }
  1193.        
  1194.         internal override Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  1195.         {
  1196.             Exception exception;
  1197.             if (value == null) {
  1198.                 throw new ArgumentNullException("value");
  1199.             }
  1200.             typedValue = null;
  1201.             string s = value as string;
  1202.             if (s != null) {
  1203.                 return TryParseValue(s, nameTable, nsmgr, out typedValue);
  1204.             }
  1205.            
  1206.             object valueToCheck = null;
  1207.             XmlSchemaSimpleType memberType = null;
  1208.             foreach (XmlSchemaSimpleType st in types) {
  1209.                 if (st.Datatype.TryParseValue(value, nameTable, nsmgr, out valueToCheck) == null) {
  1210.                     //no error
  1211.                     memberType = st;
  1212.                     break;
  1213.                 }
  1214.             }
  1215.             if (valueToCheck == null) {
  1216.                 exception = new XmlSchemaException(Res.Sch_UnionFailedEx, value.ToString());
  1217.                 goto Error;
  1218.             }
  1219.             try {
  1220.                 if (this.HasLexicalFacets) {
  1221.                     string s1 = (string)this.ValueConverter.ChangeType(valueToCheck, typeof(string), nsmgr);
  1222.                     //Using value here to avoid info loss
  1223.                     exception = unionFacetsChecker.CheckLexicalFacets(ref s1, this);
  1224.                     if (exception != null)
  1225.                         goto Error;
  1226.                 }
  1227.                 typedValue = new XsdSimpleValue(memberType, valueToCheck);
  1228.                 if (this.HasValueFacets) {
  1229.                     exception = unionFacetsChecker.CheckValueFacets(typedValue, this);
  1230.                     if (exception != null)
  1231.                         goto Error;
  1232.                 }
  1233.                 return null;
  1234.             }
  1235.             catch (FormatException e) {
  1236.                 //Catching for exceptions thrown by ValueConverter
  1237.                 exception = e;
  1238.             }
  1239.             catch (InvalidCastException e) {
  1240.                 //Catching for exceptions thrown by ValueConverter
  1241.                 exception = e;
  1242.             }
  1243.             catch (OverflowException e) {
  1244.                 //Catching for exceptions thrown by ValueConverter
  1245.                 exception = e;
  1246.             }
  1247.             catch (ArgumentException e) {
  1248.                 //Catching for exceptions thrown by ValueConverter
  1249.                 exception = e;
  1250.             }
  1251.             Error:
  1252.            
  1253.             return exception;
  1254.         }
  1255.     }
  1256.    
  1257.    
  1258.     // Primitive datatypes
  1259.     internal class Datatype_anySimpleType : DatatypeImplementation
  1260.     {
  1261.         static readonly Type atomicValueType = typeof(string);
  1262.         static readonly Type listValueType = typeof(string[]);
  1263.        
  1264.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  1265.         {
  1266.             return XmlUntypedConverter.Untyped;
  1267.         }
  1268.        
  1269.         internal override FacetsChecker FacetsChecker {
  1270.             get { return miscFacetsChecker; }
  1271.         }
  1272.        
  1273.         public override Type ValueType {
  1274.             get { return atomicValueType; }
  1275.         }
  1276.        
  1277.         public override XmlTypeCode TypeCode {
  1278.             get { return XmlTypeCode.AnyAtomicType; }
  1279.         }
  1280.        
  1281.         internal override Type ListValueType {
  1282.             get { return listValueType; }
  1283.         }
  1284.        
  1285.         public override XmlTokenizedType TokenizedType {
  1286.             get { return XmlTokenizedType.None; }
  1287.         }
  1288.        
  1289.         internal override RestrictionFlags ValidRestrictionFlags {
  1290.             get { return 0; }
  1291.         }
  1292.        
  1293.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  1294.             get { return XmlSchemaWhiteSpace.Collapse; }
  1295.         }
  1296.        
  1297.         internal override int Compare(object value1, object value2)
  1298.         {
  1299.             //Changed StringComparison.CurrentCulture to StringComparison.Ordinal to handle zero-weight code points like the cyrillic E
  1300.             return String.Compare(value1.ToString(), value2.ToString(), StringComparison.Ordinal);
  1301.         }
  1302.        
  1303.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  1304.         {
  1305.             typedValue = XmlComplianceUtil.NonCDataNormalize(s);
  1306.             return null;
  1307.         }
  1308.     }
  1309.    
  1310.     internal class Datatype_anyAtomicType : Datatype_anySimpleType
  1311.     {
  1312.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  1313.         {
  1314.             return XmlAnyConverter.AnyAtomic;
  1315.         }
  1316.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  1317.             get { return XmlSchemaWhiteSpace.Preserve; }
  1318.         }
  1319.        
  1320.         public override XmlTypeCode TypeCode {
  1321.             get { return XmlTypeCode.AnyAtomicType; }
  1322.         }
  1323.        
  1324.     }
  1325.    
  1326.     internal class Datatype_untypedAtomicType : Datatype_anyAtomicType
  1327.     {
  1328.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  1329.         {
  1330.             return XmlUntypedConverter.Untyped;
  1331.         }
  1332.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  1333.             get { return XmlSchemaWhiteSpace.Preserve; }
  1334.         }
  1335.        
  1336.         public override XmlTypeCode TypeCode {
  1337.             get { return XmlTypeCode.UntypedAtomic; }
  1338.         }
  1339.        
  1340.     }
  1341.    
  1342.    
  1343. /*
  1344.       <xs:simpleType name="string" id="string">
  1345.         <xs:annotation>
  1346.           <xs:appinfo>
  1347.             <hfp:hasFacet name="length"/>
  1348.             <hfp:hasFacet name="minLength"/>
  1349.             <hfp:hasFacet name="maxLength"/>
  1350.             <hfp:hasFacet name="pattern"/>
  1351.             <hfp:hasFacet name="enumeration"/>
  1352.             <hfp:hasFacet name="whiteSpace"/>
  1353.             <hfp:hasProperty name="ordered" value="false"/>
  1354.             <hfp:hasProperty name="bounded" value="false"/>
  1355.             <hfp:hasProperty name="cardinality" value="countably infinite"/>
  1356.             <hfp:hasProperty name="numeric" value="false"/>
  1357.           </xs:appinfo>
  1358.           <xs:documentation
  1359.                     source="http://www.w3.org/TR/xmlschema-2/#string"/>
  1360.         </xs:annotation>
  1361.         <xs:restriction base="xs:anySimpleType">
  1362.           <xs:whiteSpace value="preserve" id="string.preserve"/>
  1363.         </xs:restriction>
  1364.       </xs:simpleType>
  1365.     */   
  1366.     internal class Datatype_string : Datatype_anySimpleType
  1367.     {
  1368.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  1369.         {
  1370.             return XmlStringConverter.Create(schemaType);
  1371.         }
  1372.        
  1373.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  1374.             get { return XmlSchemaWhiteSpace.Preserve; }
  1375.         }
  1376.        
  1377.         internal override FacetsChecker FacetsChecker {
  1378.             get { return stringFacetsChecker; }
  1379.         }
  1380.        
  1381.         public override XmlTypeCode TypeCode {
  1382.             get { return XmlTypeCode.String; }
  1383.         }
  1384.        
  1385.         public override XmlTokenizedType TokenizedType {
  1386.             get { return XmlTokenizedType.CDATA; }
  1387.         }
  1388.        
  1389.         internal override RestrictionFlags ValidRestrictionFlags {
  1390.             get { return RestrictionFlags.Length | RestrictionFlags.MinLength | RestrictionFlags.MaxLength | RestrictionFlags.Pattern | RestrictionFlags.Enumeration | RestrictionFlags.WhiteSpace; }
  1391.         }
  1392.        
  1393.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  1394.         {
  1395.             Exception exception;
  1396.            
  1397.             typedValue = null;
  1398.            
  1399.             exception = stringFacetsChecker.CheckLexicalFacets(ref s, this);
  1400.             if (exception != null)
  1401.                 goto Error;
  1402.            
  1403.             exception = stringFacetsChecker.CheckValueFacets(s, this);
  1404.             if (exception != null)
  1405.                 goto Error;
  1406.            
  1407.             typedValue = s;
  1408.             return null;
  1409.             Error:
  1410.            
  1411.             return exception;
  1412.         }
  1413.     }
  1414.    
  1415. /*
  1416.       <xs:simpleType name="boolean" id="boolean">
  1417.         <xs:annotation>
  1418.           <xs:appinfo>
  1419.             <hfp:hasFacet name="pattern"/>
  1420.             <hfp:hasFacet name="whiteSpace"/>
  1421.             <hfp:hasProperty name="ordered" value="false"/>
  1422.             <hfp:hasProperty name="bounded" value="false"/>
  1423.             <hfp:hasProperty name="cardinality" value="finite"/>
  1424.             <hfp:hasProperty name="numeric" value="false"/>
  1425.           </xs:appinfo>
  1426.           <xs:documentation
  1427.             source="http://www.w3.org/TR/xmlschema-2/#boolean"/>
  1428.         </xs:annotation>
  1429.         <xs:restriction base="xs:anySimpleType">
  1430.           <xs:whiteSpace value="collapse" fixed="true"
  1431.             id="boolean.whiteSpace"/>
  1432.         </xs:restriction>
  1433.       </xs:simpleType>
  1434.     */   
  1435.     internal class Datatype_boolean : Datatype_anySimpleType
  1436.     {
  1437.         static readonly Type atomicValueType = typeof(bool);
  1438.         static readonly Type listValueType = typeof(bool[]);
  1439.        
  1440.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  1441.         {
  1442.             return XmlBooleanConverter.Create(schemaType);
  1443.         }
  1444.        
  1445.         internal override FacetsChecker FacetsChecker {
  1446.             get { return miscFacetsChecker; }
  1447.         }
  1448.        
  1449.         public override XmlTypeCode TypeCode {
  1450.             get { return XmlTypeCode.Boolean; }
  1451.         }
  1452.        
  1453.         public override Type ValueType {
  1454.             get { return atomicValueType; }
  1455.         }
  1456.        
  1457.         internal override Type ListValueType {
  1458.             get { return listValueType; }
  1459.         }
  1460.        
  1461.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  1462.             get { return XmlSchemaWhiteSpace.Collapse; }
  1463.         }
  1464.        
  1465.         internal override RestrictionFlags ValidRestrictionFlags {
  1466.             get { return RestrictionFlags.Pattern | RestrictionFlags.WhiteSpace; }
  1467.         }
  1468.        
  1469.         internal override int Compare(object value1, object value2)
  1470.         {
  1471.             return ((bool)value1).CompareTo(value2);
  1472.         }
  1473.        
  1474.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  1475.         {
  1476.             Exception exception;
  1477.             typedValue = null;
  1478.            
  1479.             exception = miscFacetsChecker.CheckLexicalFacets(ref s, this);
  1480.             if (exception != null)
  1481.                 goto Error;
  1482.            
  1483.             bool boolValue;
  1484.             exception = XmlConvert.TryToBoolean(s, out boolValue);
  1485.             if (exception != null)
  1486.                 goto Error;
  1487.            
  1488.             typedValue = boolValue;
  1489.            
  1490.             return null;
  1491.             Error:
  1492.            
  1493.             return exception;
  1494.         }
  1495.     }
  1496.    
  1497. /*
  1498.       <xs:simpleType name="float" id="float">
  1499.         <xs:annotation>
  1500.           <xs:appinfo>
  1501.             <hfp:hasFacet name="pattern"/>
  1502.             <hfp:hasFacet name="enumeration"/>
  1503.             <hfp:hasFacet name="whiteSpace"/>
  1504.             <hfp:hasFacet name="maxInclusive"/>
  1505.             <hfp:hasFacet name="maxExclusive"/>
  1506.             <hfp:hasFacet name="minInclusive"/>
  1507.             <hfp:hasFacet name="minExclusive"/>
  1508.             <hfp:hasProperty name="ordered" value="total"/>
  1509.             <hfp:hasProperty name="bounded" value="true"/>
  1510.             <hfp:hasProperty name="cardinality" value="finite"/>
  1511.             <hfp:hasProperty name="numeric" value="true"/>
  1512.           </xs:appinfo>
  1513.           <xs:documentation
  1514.             source="http://www.w3.org/TR/xmlschema-2/#float"/>
  1515.         </xs:annotation>
  1516.         <xs:restriction base="xs:anySimpleType">
  1517.           <xs:whiteSpace value="collapse" fixed="true"
  1518.             id="float.whiteSpace"/>
  1519.         </xs:restriction>
  1520.       </xs:simpleType>
  1521.     */   
  1522.     internal class Datatype_float : Datatype_anySimpleType
  1523.     {
  1524.         static readonly Type atomicValueType = typeof(float);
  1525.         static readonly Type listValueType = typeof(float[]);
  1526.        
  1527.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  1528.         {
  1529.             return XmlNumeric2Converter.Create(schemaType);
  1530.         }
  1531.        
  1532.         internal override FacetsChecker FacetsChecker {
  1533.             get { return numeric2FacetsChecker; }
  1534.         }
  1535.        
  1536.         public override XmlTypeCode TypeCode {
  1537.             get { return XmlTypeCode.Float; }
  1538.         }
  1539.        
  1540.         public override Type ValueType {
  1541.             get { return atomicValueType; }
  1542.         }
  1543.        
  1544.         internal override Type ListValueType {
  1545.             get { return listValueType; }
  1546.         }
  1547.        
  1548.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  1549.             get { return XmlSchemaWhiteSpace.Collapse; }
  1550.         }
  1551.        
  1552.         internal override RestrictionFlags ValidRestrictionFlags {
  1553.             get { return RestrictionFlags.Pattern | RestrictionFlags.Enumeration | RestrictionFlags.WhiteSpace | RestrictionFlags.MinExclusive | RestrictionFlags.MinInclusive | RestrictionFlags.MaxExclusive | RestrictionFlags.MaxInclusive; }
  1554.         }
  1555.        
  1556.         internal override int Compare(object value1, object value2)
  1557.         {
  1558.             return ((float)value1).CompareTo(value2);
  1559.         }
  1560.        
  1561.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  1562.         {
  1563.             Exception exception;
  1564.            
  1565.             typedValue = null;
  1566.            
  1567.             exception = numeric2FacetsChecker.CheckLexicalFacets(ref s, this);
  1568.             if (exception != null)
  1569.                 goto Error;
  1570.            
  1571.             float singleValue;
  1572.             exception = XmlConvert.TryToSingle(s, out singleValue);
  1573.             if (exception != null)
  1574.                 goto Error;
  1575.            
  1576.             exception = numeric2FacetsChecker.CheckValueFacets(singleValue, this);
  1577.             if (exception != null)
  1578.                 goto Error;
  1579.            
  1580.             typedValue = singleValue;
  1581.            
  1582.             return null;
  1583.             Error:
  1584.            
  1585.             return exception;
  1586.         }
  1587.     }
  1588.    
  1589. /*
  1590.       <xs:simpleType name="double" id="double">
  1591.         <xs:annotation>
  1592.           <xs:appinfo>
  1593.             <hfp:hasFacet name="pattern"/>
  1594.             <hfp:hasFacet name="enumeration"/>
  1595.             <hfp:hasFacet name="whiteSpace"/>
  1596.             <hfp:hasFacet name="maxInclusive"/>
  1597.             <hfp:hasFacet name="maxExclusive"/>
  1598.             <hfp:hasFacet name="minInclusive"/>
  1599.             <hfp:hasFacet name="minExclusive"/>
  1600.             <hfp:hasProperty name="ordered" value="total"/>
  1601.             <hfp:hasProperty name="bounded" value="true"/>
  1602.             <hfp:hasProperty name="cardinality" value="finite"/>
  1603.             <hfp:hasProperty name="numeric" value="true"/>
  1604.           </xs:appinfo>
  1605.           <xs:documentation
  1606.             source="http://www.w3.org/TR/xmlschema-2/#double"/>
  1607.         </xs:annotation>
  1608.         <xs:restriction base="xs:anySimpleType">
  1609.           <xs:whiteSpace value="collapse"  fixed="true"
  1610.             id="double.whiteSpace"/>
  1611.         </xs:restriction>
  1612.       </xs:simpleType>
  1613.     */   
  1614.     internal class Datatype_double : Datatype_anySimpleType
  1615.     {
  1616.         static readonly Type atomicValueType = typeof(double);
  1617.         static readonly Type listValueType = typeof(double[]);
  1618.        
  1619.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  1620.         {
  1621.             return XmlNumeric2Converter.Create(schemaType);
  1622.         }
  1623.        
  1624.         internal override FacetsChecker FacetsChecker {
  1625.             get { return numeric2FacetsChecker; }
  1626.         }
  1627.        
  1628.         public override XmlTypeCode TypeCode {
  1629.             get { return XmlTypeCode.Double; }
  1630.         }
  1631.        
  1632.         public override Type ValueType {
  1633.             get { return atomicValueType; }
  1634.         }
  1635.        
  1636.         internal override Type ListValueType {
  1637.             get { return listValueType; }
  1638.         }
  1639.        
  1640.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  1641.             get { return XmlSchemaWhiteSpace.Collapse; }
  1642.         }
  1643.        
  1644.         internal override RestrictionFlags ValidRestrictionFlags {
  1645.             get { return RestrictionFlags.Pattern | RestrictionFlags.Enumeration | RestrictionFlags.WhiteSpace | RestrictionFlags.MinExclusive | RestrictionFlags.MinInclusive | RestrictionFlags.MaxExclusive | RestrictionFlags.MaxInclusive; }
  1646.         }
  1647.        
  1648.         internal override int Compare(object value1, object value2)
  1649.         {
  1650.             return ((double)value1).CompareTo(value2);
  1651.         }
  1652.        
  1653.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  1654.         {
  1655.             Exception exception;
  1656.             typedValue = null;
  1657.            
  1658.             exception = numeric2FacetsChecker.CheckLexicalFacets(ref s, this);
  1659.             if (exception != null)
  1660.                 goto Error;
  1661.            
  1662.             double doubleValue;
  1663.             exception = XmlConvert.TryToDouble(s, out doubleValue);
  1664.             if (exception != null)
  1665.                 goto Error;
  1666.            
  1667.             exception = numeric2FacetsChecker.CheckValueFacets(doubleValue, this);
  1668.             if (exception != null)
  1669.                 goto Error;
  1670.            
  1671.             typedValue = doubleValue;
  1672.            
  1673.             return null;
  1674.             Error:
  1675.            
  1676.             return exception;
  1677.         }
  1678.     }
  1679.    
  1680. /*
  1681.       <xs:simpleType name="decimal" id="decimal">
  1682.         <xs:annotation>
  1683.           <xs:appinfo>
  1684.             <hfp:hasFacet name="totalDigits"/>
  1685.             <hfp:hasFacet name="fractionDigits"/>
  1686.             <hfp:hasFacet name="pattern"/>
  1687.             <hfp:hasFacet name="whiteSpace"/>
  1688.             <hfp:hasFacet name="enumeration"/>
  1689.             <hfp:hasFacet name="maxInclusive"/>
  1690.             <hfp:hasFacet name="maxExclusive"/>
  1691.             <hfp:hasFacet name="minInclusive"/>
  1692.             <hfp:hasFacet name="minExclusive"/>
  1693.             <hfp:hasProperty name="ordered" value="total"/>
  1694.             <hfp:hasProperty name="bounded" value="false"/>
  1695.             <hfp:hasProperty name="cardinality"
  1696.                     value="countably infinite"/>
  1697.             <hfp:hasProperty name="numeric" value="true"/>
  1698.           </xs:appinfo>
  1699.           <xs:documentation
  1700.             source="http://www.w3.org/TR/xmlschema-2/#decimal"/>
  1701.         </xs:annotation>
  1702.         <xs:restriction base="xs:anySimpleType">
  1703.           <xs:whiteSpace value="collapse"  fixed="true"
  1704.             id="decimal.whiteSpace"/>
  1705.         </xs:restriction>
  1706.       </xs:simpleType>
  1707.     */   
  1708.     internal class Datatype_decimal : Datatype_anySimpleType
  1709.     {
  1710.         static readonly Type atomicValueType = typeof(decimal);
  1711.         static readonly Type listValueType = typeof(decimal[]);
  1712.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.MinValue, decimal.MaxValue);
  1713.        
  1714.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  1715.         {
  1716.             return XmlNumeric10Converter.Create(schemaType);
  1717.         }
  1718.        
  1719.         internal override FacetsChecker FacetsChecker {
  1720.             get { return numeric10FacetsChecker; }
  1721.         }
  1722.        
  1723.         public override XmlTypeCode TypeCode {
  1724.             get { return XmlTypeCode.Decimal; }
  1725.         }
  1726.        
  1727.         public override Type ValueType {
  1728.             get { return atomicValueType; }
  1729.         }
  1730.        
  1731.         internal override Type ListValueType {
  1732.             get { return listValueType; }
  1733.         }
  1734.        
  1735.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  1736.             get { return XmlSchemaWhiteSpace.Collapse; }
  1737.         }
  1738.        
  1739.         internal override RestrictionFlags ValidRestrictionFlags {
  1740.             get { return RestrictionFlags.TotalDigits | RestrictionFlags.FractionDigits | RestrictionFlags.Pattern | RestrictionFlags.Enumeration | RestrictionFlags.WhiteSpace | RestrictionFlags.MinExclusive | RestrictionFlags.MinInclusive | RestrictionFlags.MaxExclusive | RestrictionFlags.MaxInclusive; }
  1741.         }
  1742.        
  1743.         internal override int Compare(object value1, object value2)
  1744.         {
  1745.             return ((decimal)value1).CompareTo(value2);
  1746.         }
  1747.        
  1748.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  1749.         {
  1750.             Exception exception;
  1751.            
  1752.             typedValue = null;
  1753.            
  1754.             exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
  1755.             if (exception != null)
  1756.                 goto Error;
  1757.            
  1758.             decimal decimalValue;
  1759.             exception = XmlConvert.TryToDecimal(s, out decimalValue);
  1760.             if (exception != null)
  1761.                 goto Error;
  1762.            
  1763.             exception = numeric10FacetsChecker.CheckValueFacets(decimalValue, this);
  1764.             if (exception != null)
  1765.                 goto Error;
  1766.            
  1767.             typedValue = decimalValue;
  1768.            
  1769.             return null;
  1770.             Error:
  1771.            
  1772.             return exception;
  1773.         }
  1774.     }
  1775.    
  1776. /*
  1777.       <xs:simpleType name="duration" id="duration">
  1778.         <xs:annotation>
  1779.           <xs:appinfo>
  1780.             <hfp:hasFacet name="pattern"/>
  1781.             <hfp:hasFacet name="enumeration"/>
  1782.             <hfp:hasFacet name="whiteSpace"/>
  1783.             <hfp:hasFacet name="maxInclusive"/>
  1784.             <hfp:hasFacet name="maxExclusive"/>
  1785.             <hfp:hasFacet name="minInclusive"/>
  1786.             <hfp:hasFacet name="minExclusive"/>
  1787.             <hfp:hasProperty name="ordered" value="partial"/>
  1788.             <hfp:hasProperty name="bounded" value="false"/>
  1789.             <hfp:hasProperty name="cardinality"
  1790.                     value="countably infinite"/>
  1791.             <hfp:hasProperty name="numeric" value="false"/>
  1792.           </xs:appinfo>
  1793.           <xs:documentation
  1794.             source="http://www.w3.org/TR/xmlschema-2/#duration"/>
  1795.         </xs:annotation>
  1796.         <xs:restriction base="xs:anySimpleType">
  1797.           <xs:whiteSpace value="collapse"  fixed="true"
  1798.             id="duration.whiteSpace"/>
  1799.         </xs:restriction>
  1800.       </xs:simpleType>
  1801.     */   
  1802.     internal class Datatype_duration : Datatype_anySimpleType
  1803.     {
  1804.         static readonly Type atomicValueType = typeof(TimeSpan);
  1805.         static readonly Type listValueType = typeof(TimeSpan[]);
  1806.        
  1807.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  1808.         {
  1809.             return XmlMiscConverter.Create(schemaType);
  1810.         }
  1811.        
  1812.         internal override FacetsChecker FacetsChecker {
  1813.             get { return durationFacetsChecker; }
  1814.         }
  1815.        
  1816.         public override XmlTypeCode TypeCode {
  1817.             get { return XmlTypeCode.Duration; }
  1818.         }
  1819.        
  1820.         public override Type ValueType {
  1821.             get { return atomicValueType; }
  1822.         }
  1823.        
  1824.         internal override Type ListValueType {
  1825.             get { return listValueType; }
  1826.         }
  1827.        
  1828.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  1829.             get { return XmlSchemaWhiteSpace.Collapse; }
  1830.         }
  1831.        
  1832.         internal override RestrictionFlags ValidRestrictionFlags {
  1833.             get { return RestrictionFlags.Pattern | RestrictionFlags.Enumeration | RestrictionFlags.WhiteSpace | RestrictionFlags.MinExclusive | RestrictionFlags.MinInclusive | RestrictionFlags.MaxExclusive | RestrictionFlags.MaxInclusive; }
  1834.         }
  1835.        
  1836.         internal override int Compare(object value1, object value2)
  1837.         {
  1838.             return ((TimeSpan)value1).CompareTo(value2);
  1839.         }
  1840.        
  1841.        
  1842.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  1843.         {
  1844.             Exception exception;
  1845.             typedValue = null;
  1846.            
  1847.             if (s == null || s.Length == 0) {
  1848.                 return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
  1849.             }
  1850.            
  1851.             exception = durationFacetsChecker.CheckLexicalFacets(ref s, this);
  1852.             if (exception != null)
  1853.                 goto Error;
  1854.            
  1855.             TimeSpan timeSpanValue;
  1856.             exception = XmlConvert.TryToTimeSpan(s, out timeSpanValue);
  1857.             if (exception != null)
  1858.                 goto Error;
  1859.            
  1860.             exception = durationFacetsChecker.CheckValueFacets(timeSpanValue, this);
  1861.             if (exception != null)
  1862.                 goto Error;
  1863.            
  1864.             typedValue = timeSpanValue;
  1865.            
  1866.             return null;
  1867.             Error:
  1868.            
  1869.             return exception;
  1870.         }
  1871.     }
  1872.    
  1873.     internal class Datatype_yearMonthDuration : Datatype_duration
  1874.     {
  1875.        
  1876.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  1877.         {
  1878.             Exception exception;
  1879.             typedValue = null;
  1880.            
  1881.             if (s == null || s.Length == 0) {
  1882.                 return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
  1883.             }
  1884.            
  1885.             exception = durationFacetsChecker.CheckLexicalFacets(ref s, this);
  1886.             if (exception != null)
  1887.                 goto Error;
  1888.            
  1889.             XsdDuration duration;
  1890.             exception = XsdDuration.TryParse(s, XsdDuration.DurationType.YearMonthDuration, out duration);
  1891.             if (exception != null)
  1892.                 goto Error;
  1893.            
  1894.             TimeSpan timeSpanValue;
  1895.            
  1896.             exception = duration.TryToTimeSpan(XsdDuration.DurationType.YearMonthDuration, out timeSpanValue);
  1897.             if (exception != null)
  1898.                 goto Error;
  1899.            
  1900.             exception = durationFacetsChecker.CheckValueFacets(timeSpanValue, this);
  1901.             if (exception != null)
  1902.                 goto Error;
  1903.            
  1904.             typedValue = timeSpanValue;
  1905.            
  1906.             return null;
  1907.             Error:
  1908.            
  1909.             return exception;
  1910.         }
  1911.        
  1912.         public override XmlTypeCode TypeCode {
  1913.             get { return XmlTypeCode.YearMonthDuration; }
  1914.         }
  1915.        
  1916.     }
  1917.    
  1918.     internal class Datatype_dayTimeDuration : Datatype_duration
  1919.     {
  1920.        
  1921.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  1922.         {
  1923.             Exception exception;
  1924.            
  1925.             typedValue = null;
  1926.            
  1927.             if (s == null || s.Length == 0) {
  1928.                 return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
  1929.             }
  1930.            
  1931.             exception = durationFacetsChecker.CheckLexicalFacets(ref s, this);
  1932.             if (exception != null)
  1933.                 goto Error;
  1934.            
  1935.             XsdDuration duration;
  1936.             exception = XsdDuration.TryParse(s, XsdDuration.DurationType.DayTimeDuration, out duration);
  1937.             if (exception != null)
  1938.                 goto Error;
  1939.            
  1940.             TimeSpan timeSpanValue;
  1941.             exception = duration.TryToTimeSpan(XsdDuration.DurationType.DayTimeDuration, out timeSpanValue);
  1942.             if (exception != null)
  1943.                 goto Error;
  1944.            
  1945.             exception = durationFacetsChecker.CheckValueFacets(timeSpanValue, this);
  1946.             if (exception != null)
  1947.                 goto Error;
  1948.            
  1949.             typedValue = timeSpanValue;
  1950.            
  1951.             return null;
  1952.             Error:
  1953.            
  1954.             return exception;
  1955.         }
  1956.        
  1957.         public override XmlTypeCode TypeCode {
  1958.             get { return XmlTypeCode.DayTimeDuration; }
  1959.         }
  1960.        
  1961.     }
  1962.    
  1963.     internal class Datatype_dateTimeBase : Datatype_anySimpleType
  1964.     {
  1965.         static readonly Type atomicValueType = typeof(DateTime);
  1966.         static readonly Type listValueType = typeof(DateTime[]);
  1967.         private XsdDateTimeFlags dateTimeFlags;
  1968.        
  1969.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  1970.         {
  1971.             return XmlDateTimeConverter.Create(schemaType);
  1972.         }
  1973.        
  1974.         internal override FacetsChecker FacetsChecker {
  1975.             get { return dateTimeFacetsChecker; }
  1976.         }
  1977.        
  1978.         public override XmlTypeCode TypeCode {
  1979.             get { return XmlTypeCode.DateTime; }
  1980.         }
  1981.        
  1982.         internal Datatype_dateTimeBase()
  1983.         {
  1984.         }
  1985.        
  1986.         internal Datatype_dateTimeBase(XsdDateTimeFlags dateTimeFlags)
  1987.         {
  1988.             this.dateTimeFlags = dateTimeFlags;
  1989.         }
  1990.        
  1991.         public override Type ValueType {
  1992.             get { return atomicValueType; }
  1993.         }
  1994.        
  1995.         internal override Type ListValueType {
  1996.             get { return listValueType; }
  1997.         }
  1998.        
  1999.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  2000.             get { return XmlSchemaWhiteSpace.Collapse; }
  2001.         }
  2002.        
  2003.         internal override RestrictionFlags ValidRestrictionFlags {
  2004.             get { return RestrictionFlags.Pattern | RestrictionFlags.Enumeration | RestrictionFlags.WhiteSpace | RestrictionFlags.MinExclusive | RestrictionFlags.MinInclusive | RestrictionFlags.MaxExclusive | RestrictionFlags.MaxInclusive; }
  2005.         }
  2006.        
  2007.         internal override int Compare(object value1, object value2)
  2008.         {
  2009.             DateTime dateTime1 = (DateTime)value1;
  2010.             DateTime dateTime2 = (DateTime)value2;
  2011.             if (dateTime1.Kind == DateTimeKind.Unspecified || dateTime2.Kind == DateTimeKind.Unspecified) {
  2012.                 //If either of them are unspecified, do not convert zones
  2013.                 return dateTime1.CompareTo(dateTime2);
  2014.             }
  2015.             dateTime1 = dateTime1.ToUniversalTime();
  2016.             return dateTime1.CompareTo(dateTime2.ToUniversalTime());
  2017.         }
  2018.        
  2019.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  2020.         {
  2021.             Exception exception;
  2022.             typedValue = null;
  2023.            
  2024.             exception = dateTimeFacetsChecker.CheckLexicalFacets(ref s, this);
  2025.             if (exception != null)
  2026.                 goto Error;
  2027.            
  2028.             XsdDateTime dateTime;
  2029.             if (!XsdDateTime.TryParse(s, dateTimeFlags, out dateTime)) {
  2030.                 exception = new FormatException(Res.GetString(Res.XmlConvert_BadFormat, s, "XsdDateTime"));
  2031.                 goto Error;
  2032.             }
  2033.            
  2034.             DateTime dateTimeValue = DateTime.MinValue;
  2035.             try {
  2036.                 dateTimeValue = (DateTime)dateTime;
  2037.             }
  2038.             catch (ArgumentException e) {
  2039.                 exception = e;
  2040.                 goto Error;
  2041.             }
  2042.            
  2043.             exception = dateTimeFacetsChecker.CheckValueFacets(dateTimeValue, this);
  2044.             if (exception != null)
  2045.                 goto Error;
  2046.            
  2047.             typedValue = dateTimeValue;
  2048.            
  2049.             return null;
  2050.             Error:
  2051.            
  2052.             return exception;
  2053.         }
  2054.     }
  2055.    
  2056.     internal class Datatype_dateTimeNoTimeZone : Datatype_dateTimeBase
  2057.     {
  2058.         internal Datatype_dateTimeNoTimeZone() : base(XsdDateTimeFlags.XdrDateTimeNoTz)
  2059.         {
  2060.         }
  2061.     }
  2062.    
  2063.     internal class Datatype_dateTimeTimeZone : Datatype_dateTimeBase
  2064.     {
  2065.         internal Datatype_dateTimeTimeZone() : base(XsdDateTimeFlags.XdrDateTime)
  2066.         {
  2067.         }
  2068.     }
  2069.    
  2070. /*
  2071.       <xs:simpleType name="dateTime" id="dateTime">
  2072.       <xs:annotation>
  2073.         <xs:appinfo>
  2074.             <hfp:hasFacet name="pattern"/>
  2075.             <hfp:hasFacet name="enumeration"/>
  2076.             <hfp:hasFacet name="whiteSpace"/>
  2077.             <hfp:hasFacet name="maxInclusive"/>
  2078.             <hfp:hasFacet name="maxExclusive"/>
  2079.             <hfp:hasFacet name="minInclusive"/>
  2080.             <hfp:hasFacet name="minExclusive"/>
  2081.             <hfp:hasProperty name="ordered" value="partial"/>
  2082.             <hfp:hasProperty name="bounded" value="false"/>
  2083.             <hfp:hasProperty name="cardinality"
  2084.                     value="countably infinite"/>
  2085.             <hfp:hasProperty name="numeric" value="false"/>
  2086.           </xs:appinfo>
  2087.           <xs:documentation
  2088.             source="http://www.w3.org/TR/xmlschema-2/#dateTime"/>
  2089.         </xs:annotation>
  2090.         <xs:restriction base="xs:anySimpleType">
  2091.           <xs:whiteSpace value="collapse"  fixed="true"
  2092.             id="dateTime.whiteSpace"/>
  2093.         </xs:restriction>
  2094.       </xs:simpleType>
  2095.     */   
  2096.     internal class Datatype_dateTime : Datatype_dateTimeBase
  2097.     {
  2098.         internal Datatype_dateTime() : base(XsdDateTimeFlags.DateTime)
  2099.         {
  2100.         }
  2101.     }
  2102.    
  2103.     internal class Datatype_timeNoTimeZone : Datatype_dateTimeBase
  2104.     {
  2105.         internal Datatype_timeNoTimeZone() : base(XsdDateTimeFlags.XdrTimeNoTz)
  2106.         {
  2107.         }
  2108.     }
  2109.    
  2110.     internal class Datatype_timeTimeZone : Datatype_dateTimeBase
  2111.     {
  2112.         internal Datatype_timeTimeZone() : base(XsdDateTimeFlags.Time)
  2113.         {
  2114.         }
  2115.     }
  2116.    
  2117. /*
  2118.       <xs:simpleType name="time" id="time">
  2119.         <xs:annotation>
  2120.         <xs:appinfo>
  2121.             <hfp:hasFacet name="pattern"/>
  2122.             <hfp:hasFacet name="enumeration"/>
  2123.             <hfp:hasFacet name="whiteSpace"/>
  2124.             <hfp:hasFacet name="maxInclusive"/>
  2125.             <hfp:hasFacet name="maxExclusive"/>
  2126.             <hfp:hasFacet name="minInclusive"/>
  2127.             <hfp:hasFacet name="minExclusive"/>
  2128.             <hfp:hasProperty name="ordered" value="partial"/>
  2129.             <hfp:hasProperty name="bounded" value="false"/>
  2130.             <hfp:hasProperty name="cardinality"
  2131.                     value="countably infinite"/>
  2132.             <hfp:hasProperty name="numeric" value="false"/>
  2133.           </xs:appinfo>
  2134.           <xs:documentation
  2135.             source="http://www.w3.org/TR/xmlschema-2/#time"/>
  2136.         </xs:annotation>
  2137.         <xs:restriction base="xs:anySimpleType">
  2138.           <xs:whiteSpace value="collapse"  fixed="true"
  2139.             id="time.whiteSpace"/>
  2140.         </xs:restriction>
  2141.       </xs:simpleType>
  2142.     */   
  2143.     internal class Datatype_time : Datatype_dateTimeBase
  2144.     {
  2145.         public override XmlTypeCode TypeCode {
  2146.             get { return XmlTypeCode.Time; }
  2147.         }
  2148.        
  2149.         internal Datatype_time() : base(XsdDateTimeFlags.Time)
  2150.         {
  2151.         }
  2152.     }
  2153.    
  2154. /*
  2155.       <xs:simpleType name="date" id="date">
  2156.       <xs:annotation>
  2157.         <xs:appinfo>
  2158.             <hfp:hasFacet name="pattern"/>
  2159.             <hfp:hasFacet name="enumeration"/>
  2160.             <hfp:hasFacet name="whiteSpace"/>
  2161.             <hfp:hasFacet name="maxInclusive"/>
  2162.             <hfp:hasFacet name="maxExclusive"/>
  2163.             <hfp:hasFacet name="minInclusive"/>
  2164.             <hfp:hasFacet name="minExclusive"/>
  2165.             <hfp:hasProperty name="ordered" value="partial"/>
  2166.             <hfp:hasProperty name="bounded" value="false"/>
  2167.             <hfp:hasProperty name="cardinality"
  2168.                     value="countably infinite"/>
  2169.             <hfp:hasProperty name="numeric" value="false"/>
  2170.           </xs:appinfo>
  2171.           <xs:documentation
  2172.             source="http://www.w3.org/TR/xmlschema-2/#date"/>
  2173.         </xs:annotation>
  2174.         <xs:restriction base="xs:anySimpleType">
  2175.           <xs:whiteSpace value="collapse"  fixed="true"
  2176.             id="date.whiteSpace"/>
  2177.         </xs:restriction>
  2178.       </xs:simpleType>
  2179.     */   
  2180.     internal class Datatype_date : Datatype_dateTimeBase
  2181.     {
  2182.         public override XmlTypeCode TypeCode {
  2183.             get { return XmlTypeCode.Date; }
  2184.         }
  2185.        
  2186.         internal Datatype_date() : base(XsdDateTimeFlags.Date)
  2187.         {
  2188.         }
  2189.     }
  2190.    
  2191. /*
  2192.       <xs:simpleType name="gYearMonth" id="gYearMonth">
  2193.       <xs:annotation>
  2194.         <xs:appinfo>
  2195.             <hfp:hasFacet name="pattern"/>
  2196.             <hfp:hasFacet name="enumeration"/>
  2197.             <hfp:hasFacet name="whiteSpace"/>
  2198.             <hfp:hasFacet name="maxInclusive"/>
  2199.             <hfp:hasFacet name="maxExclusive"/>
  2200.             <hfp:hasFacet name="minInclusive"/>
  2201.             <hfp:hasFacet name="minExclusive"/>
  2202.             <hfp:hasProperty name="ordered" value="partial"/>
  2203.             <hfp:hasProperty name="bounded" value="false"/>
  2204.             <hfp:hasProperty name="cardinality"
  2205.                     value="countably infinite"/>
  2206.             <hfp:hasProperty name="numeric" value="false"/>
  2207.           </xs:appinfo>
  2208.           <xs:documentation
  2209.             source="http://www.w3.org/TR/xmlschema-2/#gYearMonth"/>
  2210.         </xs:annotation>
  2211.         <xs:restriction base="xs:anySimpleType">
  2212.           <xs:whiteSpace value="collapse"  fixed="true"
  2213.             id="gYearMonth.whiteSpace"/>
  2214.         </xs:restriction>
  2215.       </xs:simpleType>
  2216.     */   
  2217.     internal class Datatype_yearMonth : Datatype_dateTimeBase
  2218.     {
  2219.         public override XmlTypeCode TypeCode {
  2220.             get { return XmlTypeCode.GYearMonth; }
  2221.         }
  2222.        
  2223.         internal Datatype_yearMonth() : base(XsdDateTimeFlags.GYearMonth)
  2224.         {
  2225.         }
  2226.     }
  2227.    
  2228.    
  2229. /*
  2230.       <xs:simpleType name="gYear" id="gYear">
  2231.         <xs:annotation>
  2232.         <xs:appinfo>
  2233.             <hfp:hasFacet name="pattern"/>
  2234.             <hfp:hasFacet name="enumeration"/>
  2235.             <hfp:hasFacet name="whiteSpace"/>
  2236.             <hfp:hasFacet name="maxInclusive"/>
  2237.             <hfp:hasFacet name="maxExclusive"/>
  2238.             <hfp:hasFacet name="minInclusive"/>
  2239.             <hfp:hasFacet name="minExclusive"/>
  2240.             <hfp:hasProperty name="ordered" value="partial"/>
  2241.             <hfp:hasProperty name="bounded" value="false"/>
  2242.             <hfp:hasProperty name="cardinality"
  2243.                     value="countably infinite"/>
  2244.             <hfp:hasProperty name="numeric" value="false"/>
  2245.           </xs:appinfo>
  2246.           <xs:documentation
  2247.             source="http://www.w3.org/TR/xmlschema-2/#gYear"/>
  2248.         </xs:annotation>
  2249.         <xs:restriction base="xs:anySimpleType">
  2250.           <xs:whiteSpace value="collapse"  fixed="true"
  2251.             id="gYear.whiteSpace"/>
  2252.         </xs:restriction>
  2253.       </xs:simpleType>
  2254.     */   
  2255.     internal class Datatype_year : Datatype_dateTimeBase
  2256.     {
  2257.         public override XmlTypeCode TypeCode {
  2258.             get { return XmlTypeCode.GYear; }
  2259.         }
  2260.        
  2261.         internal Datatype_year() : base(XsdDateTimeFlags.GYear)
  2262.         {
  2263.         }
  2264.     }
  2265.    
  2266. /*
  2267.     <xs:simpleType name="gMonthDay" id="gMonthDay">
  2268.         <xs:annotation>
  2269.           <xs:appinfo>
  2270.             <hfp:hasFacet name="pattern"/>
  2271.             <hfp:hasFacet name="enumeration"/>
  2272.             <hfp:hasFacet name="whiteSpace"/>
  2273.             <hfp:hasFacet name="maxInclusive"/>
  2274.             <hfp:hasFacet name="maxExclusive"/>
  2275.             <hfp:hasFacet name="minInclusive"/>
  2276.             <hfp:hasFacet name="minExclusive"/>
  2277.             <hfp:hasProperty name="ordered" value="partial"/>
  2278.             <hfp:hasProperty name="bounded" value="false"/>
  2279.             <hfp:hasProperty name="cardinality"
  2280.                     value="countably infinite"/>
  2281.             <hfp:hasProperty name="numeric" value="false"/>
  2282.           </xs:appinfo>
  2283.           <xs:documentation
  2284.             source="http://www.w3.org/TR/xmlschema-2/#gMonthDay"/>
  2285.         </xs:annotation>
  2286.         <xs:restriction base="xs:anySimpleType">
  2287.             <xs:whiteSpace value="collapse" fixed="true"
  2288.                     id="gMonthDay.whiteSpace"/>
  2289.         </xs:restriction>
  2290.       </xs:simpleType>
  2291.     */   
  2292.     internal class Datatype_monthDay : Datatype_dateTimeBase
  2293.     {
  2294.         public override XmlTypeCode TypeCode {
  2295.             get { return XmlTypeCode.GMonthDay; }
  2296.         }
  2297.        
  2298.         internal Datatype_monthDay() : base(XsdDateTimeFlags.GMonthDay)
  2299.         {
  2300.         }
  2301.     }
  2302.    
  2303. /*
  2304.       <xs:simpleType name="gDay" id="gDay">
  2305.         <xs:annotation>
  2306.           <xs:appinfo>
  2307.             <hfp:hasFacet name="pattern"/>
  2308.             <hfp:hasFacet name="enumeration"/>
  2309.             <hfp:hasFacet name="whiteSpace"/>
  2310.             <hfp:hasFacet name="maxInclusive"/>
  2311.             <hfp:hasFacet name="maxExclusive"/>
  2312.             <hfp:hasFacet name="minInclusive"/>
  2313.             <hfp:hasFacet name="minExclusive"/>
  2314.             <hfp:hasProperty name="ordered" value="partial"/>
  2315.             <hfp:hasProperty name="bounded" value="false"/>
  2316.             <hfp:hasProperty name="cardinality"
  2317.                     value="countably infinite"/>
  2318.             <hfp:hasProperty name="numeric" value="false"/>
  2319.           </xs:appinfo>
  2320.           <xs:documentation
  2321.             source="http://www.w3.org/TR/xmlschema-2/#gDay"/>
  2322.         </xs:annotation>
  2323.         <xs:restriction base="xs:anySimpleType">
  2324.             <xs:whiteSpace value="collapse"  fixed="true"
  2325.                     id="gDay.whiteSpace"/>
  2326.         </xs:restriction>
  2327.       </xs:simpleType>
  2328.     */   
  2329.     internal class Datatype_day : Datatype_dateTimeBase
  2330.     {
  2331.         public override XmlTypeCode TypeCode {
  2332.             get { return XmlTypeCode.GDay; }
  2333.         }
  2334.        
  2335.         internal Datatype_day() : base(XsdDateTimeFlags.GDay)
  2336.         {
  2337.         }
  2338.     }
  2339.    
  2340.    
  2341. /*
  2342.     <xs:simpleType name="gMonth" id="gMonth">
  2343.         <xs:annotation>
  2344.       <xs:appinfo>
  2345.             <hfp:hasFacet name="pattern"/>
  2346.             <hfp:hasFacet name="enumeration"/>
  2347.             <hfp:hasFacet name="whiteSpace"/>
  2348.             <hfp:hasFacet name="maxInclusive"/>
  2349.             <hfp:hasFacet name="maxExclusive"/>
  2350.             <hfp:hasFacet name="minInclusive"/>
  2351.             <hfp:hasFacet name="minExclusive"/>
  2352.             <hfp:hasProperty name="ordered" value="partial"/>
  2353.             <hfp:hasProperty name="bounded" value="false"/>
  2354.             <hfp:hasProperty name="cardinality"
  2355.                     value="countably infinite"/>
  2356.             <hfp:hasProperty name="numeric" value="false"/>
  2357.           </xs:appinfo>
  2358.           <xs:documentation
  2359.             source="http://www.w3.org/TR/xmlschema-2/#gMonth"/>
  2360.         </xs:annotation>
  2361.         <xs:restriction base="xs:anySimpleType">
  2362.             <xs:whiteSpace value="collapse"  fixed="true"
  2363.                     id="gMonth.whiteSpace"/>
  2364.         </xs:restriction>
  2365.       </xs:simpleType>
  2366.     */   
  2367.     internal class Datatype_month : Datatype_dateTimeBase
  2368.     {
  2369.         public override XmlTypeCode TypeCode {
  2370.             get { return XmlTypeCode.GMonth; }
  2371.         }
  2372.        
  2373.         internal Datatype_month() : base(XsdDateTimeFlags.GMonth)
  2374.         {
  2375.         }
  2376.     }
  2377.    
  2378. /*
  2379.       <xs:simpleType name="hexBinary" id="hexBinary">
  2380.         <xs:annotation>
  2381.           <xs:appinfo>
  2382.             <hfp:hasFacet name="length"/>
  2383.             <hfp:hasFacet name="minLength"/>
  2384.             <hfp:hasFacet name="maxLength"/>
  2385.             <hfp:hasFacet name="pattern"/>
  2386.             <hfp:hasFacet name="enumeration"/>
  2387.             <hfp:hasFacet name="whiteSpace"/>
  2388.             <hfp:hasProperty name="ordered" value="false"/>
  2389.             <hfp:hasProperty name="bounded" value="false"/>
  2390.             <hfp:hasProperty name="cardinality"
  2391.                     value="countably infinite"/>
  2392.             <hfp:hasProperty name="numeric" value="false"/>
  2393.           </xs:appinfo>
  2394.           <xs:documentation
  2395.             source="http://www.w3.org/TR/xmlschema-2/#binary"/>
  2396.         </xs:annotation>
  2397.         <xs:restriction base="xs:anySimpleType">
  2398.           <xs:whiteSpace value="collapse" fixed="true"
  2399.             id="hexBinary.whiteSpace"/>
  2400.         </xs:restriction>
  2401.       </xs:simpleType>
  2402.     */   
  2403.     internal class Datatype_hexBinary : Datatype_anySimpleType
  2404.     {
  2405.         static readonly Type atomicValueType = typeof(byte[]);
  2406.         static readonly Type listValueType = typeof(byte[][]);
  2407.        
  2408.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  2409.         {
  2410.             return XmlMiscConverter.Create(schemaType);
  2411.         }
  2412.        
  2413.         internal override FacetsChecker FacetsChecker {
  2414.             get { return binaryFacetsChecker; }
  2415.         }
  2416.        
  2417.         public override XmlTypeCode TypeCode {
  2418.             get { return XmlTypeCode.HexBinary; }
  2419.         }
  2420.        
  2421.         public override Type ValueType {
  2422.             get { return atomicValueType; }
  2423.         }
  2424.        
  2425.         internal override Type ListValueType {
  2426.             get { return listValueType; }
  2427.         }
  2428.        
  2429.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  2430.             get { return XmlSchemaWhiteSpace.Collapse; }
  2431.         }
  2432.        
  2433.         internal override RestrictionFlags ValidRestrictionFlags {
  2434.             get { return RestrictionFlags.Length | RestrictionFlags.MinLength | RestrictionFlags.MaxLength | RestrictionFlags.Pattern | RestrictionFlags.Enumeration | RestrictionFlags.WhiteSpace; }
  2435.         }
  2436.        
  2437.         internal override int Compare(object value1, object value2)
  2438.         {
  2439.             return Compare((byte[])value1, (byte[])value2);
  2440.         }
  2441.        
  2442.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  2443.         {
  2444.             Exception exception;
  2445.            
  2446.             typedValue = null;
  2447.            
  2448.             exception = binaryFacetsChecker.CheckLexicalFacets(ref s, this);
  2449.             if (exception != null)
  2450.                 goto Error;
  2451.            
  2452.             byte[] byteArrayValue = null;
  2453.             try {
  2454.                 byteArrayValue = XmlConvert.FromBinHexString(s, false);
  2455.             }
  2456.             catch (ArgumentException e) {
  2457.                 exception = e;
  2458.                 goto Error;
  2459.             }
  2460.             catch (XmlException e) {
  2461.                 exception = e;
  2462.                 goto Error;
  2463.             }
  2464.            
  2465.             exception = binaryFacetsChecker.CheckValueFacets(byteArrayValue, this);
  2466.             if (exception != null)
  2467.                 goto Error;
  2468.            
  2469.             typedValue = byteArrayValue;
  2470.            
  2471.             return null;
  2472.             Error:
  2473.            
  2474.             return exception;
  2475.         }
  2476.     }
  2477.    
  2478.    
  2479. /*
  2480.     <xs:simpleType name="base64Binary" id="base64Binary">
  2481.         <xs:annotation>
  2482.           <xs:appinfo>
  2483.             <hfp:hasFacet name="length"/>
  2484.             <hfp:hasFacet name="minLength"/>
  2485.             <hfp:hasFacet name="maxLength"/>
  2486.             <hfp:hasFacet name="pattern"/>
  2487.             <hfp:hasFacet name="enumeration"/>
  2488.             <hfp:hasFacet name="whiteSpace"/>
  2489.             <hfp:hasProperty name="ordered" value="false"/>
  2490.             <hfp:hasProperty name="bounded" value="false"/>
  2491.             <hfp:hasProperty name="cardinality"
  2492.                     value="countably infinite"/>
  2493.             <hfp:hasProperty name="numeric" value="false"/>
  2494.           </xs:appinfo>
  2495.           <xs:documentation
  2496.                     source="http://www.w3.org/TR/xmlschema-2/#base64Binary"/>
  2497.         </xs:annotation>
  2498.         <xs:restriction base="xs:anySimpleType">
  2499.           <xs:whiteSpace value="collapse" fixed="true"
  2500.             id="base64Binary.whiteSpace"/>
  2501.         </xs:restriction>
  2502.       </xs:simpleType>
  2503.     */   
  2504.     internal class Datatype_base64Binary : Datatype_anySimpleType
  2505.     {
  2506.         static readonly Type atomicValueType = typeof(byte[]);
  2507.         static readonly Type listValueType = typeof(byte[][]);
  2508.        
  2509.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  2510.         {
  2511.             return XmlMiscConverter.Create(schemaType);
  2512.         }
  2513.        
  2514.         internal override FacetsChecker FacetsChecker {
  2515.             get { return binaryFacetsChecker; }
  2516.         }
  2517.        
  2518.         public override XmlTypeCode TypeCode {
  2519.             get { return XmlTypeCode.Base64Binary; }
  2520.         }
  2521.        
  2522.         public override Type ValueType {
  2523.             get { return atomicValueType; }
  2524.         }
  2525.        
  2526.         internal override Type ListValueType {
  2527.             get { return listValueType; }
  2528.         }
  2529.        
  2530.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  2531.             get { return XmlSchemaWhiteSpace.Collapse; }
  2532.         }
  2533.        
  2534.         internal override RestrictionFlags ValidRestrictionFlags {
  2535.             get { return RestrictionFlags.Length | RestrictionFlags.MinLength | RestrictionFlags.MaxLength | RestrictionFlags.Pattern | RestrictionFlags.Enumeration | RestrictionFlags.WhiteSpace; }
  2536.         }
  2537.        
  2538.         internal override int Compare(object value1, object value2)
  2539.         {
  2540.             return Compare((byte[])value1, (byte[])value2);
  2541.         }
  2542.        
  2543.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  2544.         {
  2545.             Exception exception;
  2546.            
  2547.             typedValue = null;
  2548.            
  2549.             exception = binaryFacetsChecker.CheckLexicalFacets(ref s, this);
  2550.             if (exception != null)
  2551.                 goto Error;
  2552.            
  2553.             byte[] byteArrayValue = null;
  2554.             try {
  2555.                 byteArrayValue = Convert.FromBase64String(s);
  2556.             }
  2557.             catch (ArgumentException e) {
  2558.                 exception = e;
  2559.                 goto Error;
  2560.             }
  2561.             catch (FormatException e) {
  2562.                 exception = e;
  2563.                 goto Error;
  2564.             }
  2565.            
  2566.             exception = binaryFacetsChecker.CheckValueFacets(byteArrayValue, this);
  2567.             if (exception != null)
  2568.                 goto Error;
  2569.            
  2570.             typedValue = byteArrayValue;
  2571.            
  2572.             return null;
  2573.             Error:
  2574.            
  2575.             return exception;
  2576.         }
  2577.     }
  2578.    
  2579. /*
  2580.       <xs:simpleType name="anyURI" id="anyURI">
  2581.         <xs:annotation>
  2582.           <xs:appinfo>
  2583.             <hfp:hasFacet name="length"/>
  2584.             <hfp:hasFacet name="minLength"/>
  2585.             <hfp:hasFacet name="maxLength"/>
  2586.             <hfp:hasFacet name="pattern"/>
  2587.             <hfp:hasFacet name="enumeration"/>
  2588.             <hfp:hasFacet name="whiteSpace"/>
  2589.             <hfp:hasProperty name="ordered" value="false"/>
  2590.             <hfp:hasProperty name="bounded" value="false"/>
  2591.             <hfp:hasProperty name="cardinality"
  2592.                     value="countably infinite"/>
  2593.             <hfp:hasProperty name="numeric" value="false"/>
  2594.           </xs:appinfo>
  2595.           <xs:documentation
  2596.             source="http://www.w3.org/TR/xmlschema-2/#anyURI"/>
  2597.         </xs:annotation>
  2598.         <xs:restriction base="xs:anySimpleType">
  2599.           <xs:whiteSpace value="collapse"  fixed="true"
  2600.             id="anyURI.whiteSpace"/>
  2601.         </xs:restriction>
  2602.       </xs:simpleType>
  2603.     */   
  2604.     internal class Datatype_anyURI : Datatype_anySimpleType
  2605.     {
  2606.         static readonly Type atomicValueType = typeof(Uri);
  2607.         static readonly Type listValueType = typeof(Uri[]);
  2608.        
  2609.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  2610.         {
  2611.             return XmlMiscConverter.Create(schemaType);
  2612.         }
  2613.        
  2614.         internal override FacetsChecker FacetsChecker {
  2615.             get { return stringFacetsChecker; }
  2616.         }
  2617.        
  2618.         public override XmlTypeCode TypeCode {
  2619.             get { return XmlTypeCode.AnyUri; }
  2620.         }
  2621.        
  2622.         public override Type ValueType {
  2623.             get { return atomicValueType; }
  2624.         }
  2625.        
  2626.         internal override bool HasValueFacets {
  2627.                 //Built-in facet to check validity of Uri
  2628.             get { return true; }
  2629.         }
  2630.         internal override Type ListValueType {
  2631.             get { return listValueType; }
  2632.         }
  2633.        
  2634.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  2635.             get { return XmlSchemaWhiteSpace.Collapse; }
  2636.         }
  2637.        
  2638.         internal override RestrictionFlags ValidRestrictionFlags {
  2639.             get { return RestrictionFlags.Length | RestrictionFlags.MinLength | RestrictionFlags.MaxLength | RestrictionFlags.Pattern | RestrictionFlags.Enumeration | RestrictionFlags.WhiteSpace; }
  2640.         }
  2641.        
  2642.         internal override int Compare(object value1, object value2)
  2643.         {
  2644.             return ((Uri)value1).Equals((Uri)value2) ? 0 : -1;
  2645.         }
  2646.        
  2647.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  2648.         {
  2649.             Exception exception;
  2650.            
  2651.             typedValue = null;
  2652.            
  2653.             exception = stringFacetsChecker.CheckLexicalFacets(ref s, this);
  2654.             if (exception != null)
  2655.                 goto Error;
  2656.            
  2657.             Uri uri;
  2658.             exception = XmlConvert.TryToUri(s, out uri);
  2659.             if (exception != null)
  2660.                 goto Error;
  2661.            
  2662.             string stringValue = uri.OriginalString;
  2663.             exception = ((StringFacetsChecker)stringFacetsChecker).CheckValueFacets(stringValue, this, false);
  2664.             if (exception != null)
  2665.                 goto Error;
  2666.            
  2667.             typedValue = uri;
  2668.            
  2669.             return null;
  2670.             Error:
  2671.            
  2672.             return exception;
  2673.         }
  2674.     }
  2675.    
  2676. /*
  2677.       <xs:simpleType name="QName" id="QName">
  2678.         <xs:annotation>
  2679.             <xs:appinfo>
  2680.             <hfp:hasFacet name="length"/>
  2681.             <hfp:hasFacet name="minLength"/>
  2682.             <hfp:hasFacet name="maxLength"/>
  2683.             <hfp:hasFacet name="pattern"/>
  2684.             <hfp:hasFacet name="enumeration"/>
  2685.             <hfp:hasFacet name="whiteSpace"/>
  2686.             <hfp:hasProperty name="ordered" value="false"/>
  2687.             <hfp:hasProperty name="bounded" value="false"/>
  2688.             <hfp:hasProperty name="cardinality"
  2689.                     value="countably infinite"/>
  2690.             <hfp:hasProperty name="numeric" value="false"/>
  2691.           </xs:appinfo>
  2692.           <xs:documentation
  2693.             source="http://www.w3.org/TR/xmlschema-2/#QName"/>
  2694.         </xs:annotation>
  2695.         <xs:restriction base="xs:anySimpleType">
  2696.           <xs:whiteSpace value="collapse"  fixed="true"
  2697.             id="QName.whiteSpace"/>
  2698.         </xs:restriction>
  2699.       </xs:simpleType>
  2700.     */   
  2701.     internal class Datatype_QName : Datatype_anySimpleType
  2702.     {
  2703.         static readonly Type atomicValueType = typeof(XmlQualifiedName);
  2704.         static readonly Type listValueType = typeof(XmlQualifiedName[]);
  2705.        
  2706.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  2707.         {
  2708.             return XmlMiscConverter.Create(schemaType);
  2709.         }
  2710.        
  2711.         internal override FacetsChecker FacetsChecker {
  2712.             get { return qnameFacetsChecker; }
  2713.         }
  2714.        
  2715.         public override XmlTypeCode TypeCode {
  2716.             get { return XmlTypeCode.QName; }
  2717.         }
  2718.        
  2719.         public override XmlTokenizedType TokenizedType {
  2720.             get { return XmlTokenizedType.QName; }
  2721.         }
  2722.        
  2723.         internal override RestrictionFlags ValidRestrictionFlags {
  2724.             get { return RestrictionFlags.Length | RestrictionFlags.MinLength | RestrictionFlags.MaxLength | RestrictionFlags.Pattern | RestrictionFlags.Enumeration | RestrictionFlags.WhiteSpace; }
  2725.         }
  2726.        
  2727.         public override Type ValueType {
  2728.             get { return atomicValueType; }
  2729.         }
  2730.        
  2731.         internal override Type ListValueType {
  2732.             get { return listValueType; }
  2733.         }
  2734.        
  2735.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  2736.             get { return XmlSchemaWhiteSpace.Collapse; }
  2737.         }
  2738.        
  2739.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  2740.         {
  2741.             Exception exception;
  2742.            
  2743.             typedValue = null;
  2744.            
  2745.             if (s == null || s.Length == 0) {
  2746.                 return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
  2747.             }
  2748.            
  2749.             exception = qnameFacetsChecker.CheckLexicalFacets(ref s, this);
  2750.             if (exception != null)
  2751.                 goto Error;
  2752.            
  2753.             XmlQualifiedName qname = null;
  2754.             try {
  2755.                 string prefix;
  2756.                 qname = XmlQualifiedName.Parse(s, nsmgr, out prefix);
  2757.             }
  2758.             catch (ArgumentException e) {
  2759.                 exception = e;
  2760.                 goto Error;
  2761.             }
  2762.             catch (XmlException e) {
  2763.                 exception = e;
  2764.                 goto Error;
  2765.             }
  2766.            
  2767.             exception = qnameFacetsChecker.CheckValueFacets(qname, this);
  2768.             if (exception != null)
  2769.                 goto Error;
  2770.            
  2771.             typedValue = qname;
  2772.            
  2773.             return null;
  2774.             Error:
  2775.            
  2776.             return exception;
  2777.         }
  2778.     }
  2779.    
  2780. /*
  2781.       <xs:simpleType name="normalizedString" id="normalizedString">
  2782.         <xs:annotation>
  2783.           <xs:documentation
  2784.             source="http://www.w3.org/TR/xmlschema-2/#normalizedString"/>
  2785.         </xs:annotation>
  2786.         <xs:restriction base="xs:string">
  2787.           <xs:whiteSpace value="replace"
  2788.             id="normalizedString.whiteSpace"/>
  2789.         </xs:restriction>
  2790.       </xs:simpleType>
  2791.     */   
  2792.     internal class Datatype_normalizedString : Datatype_string
  2793.     {
  2794.         public override XmlTypeCode TypeCode {
  2795.             get { return XmlTypeCode.NormalizedString; }
  2796.         }
  2797.        
  2798.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  2799.             get { return XmlSchemaWhiteSpace.Replace; }
  2800.         }
  2801.        
  2802.         internal override bool HasValueFacets {
  2803.                 //Built-in facet to check validity of NormalizedString
  2804.             get { return true; }
  2805.         }
  2806.     }
  2807.    
  2808.     internal class Datatype_normalizedStringV1Compat : Datatype_string
  2809.     {
  2810.         public override XmlTypeCode TypeCode {
  2811.             get { return XmlTypeCode.NormalizedString; }
  2812.         }
  2813.         internal override bool HasValueFacets {
  2814.                 //Built-in facet to check validity of NormalizedString
  2815.             get { return true; }
  2816.         }
  2817.     }
  2818.    
  2819. /*
  2820.       <xs:simpleType name="token" id="token">
  2821.         <xs:annotation>
  2822.           <xs:documentation
  2823.             source="http://www.w3.org/TR/xmlschema-2/#token"/>
  2824.         </xs:annotation>
  2825.         <xs:restriction base="xs:normalizedString">
  2826.           <xs:whiteSpace value="collapse" id="token.whiteSpace"/>
  2827.         </xs:restriction>
  2828.       </xs:simpleType>
  2829.     */   
  2830.     internal class Datatype_token : Datatype_normalizedString
  2831.     {
  2832.         public override XmlTypeCode TypeCode {
  2833.             get { return XmlTypeCode.Token; }
  2834.         }
  2835.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  2836.             get { return XmlSchemaWhiteSpace.Collapse; }
  2837.         }
  2838.     }
  2839.    
  2840.     internal class Datatype_tokenV1Compat : Datatype_normalizedStringV1Compat
  2841.     {
  2842.         public override XmlTypeCode TypeCode {
  2843.             get { return XmlTypeCode.Token; }
  2844.         }
  2845.     }
  2846.    
  2847. /*
  2848.       <xs:simpleType name="language" id="language">
  2849.         <xs:annotation>
  2850.           <xs:documentation
  2851.             source="http://www.w3.org/TR/xmlschema-2/#language"/>
  2852.         </xs:annotation>
  2853.         <xs:restriction base="xs:token">
  2854.           <xs:pattern
  2855.             value="([a-zA-Z]{2}|[iI]-[a-zA-Z]+|[xX]-[a-zA-Z]{1,8})(-[a-zA-Z]{1,8})*"
  2856.                     id="language.pattern">
  2857.             <xs:annotation>
  2858.               <xs:documentation
  2859.                     source="http://www.w3.org/TR/REC-xml#NT-LanguageID">
  2860.                 pattern specifies the content of section 2.12 of XML 1.0e2
  2861.                 and RFC 1766
  2862.               </xs:documentation>
  2863.             </xs:annotation>
  2864.           </xs:pattern>
  2865.         </xs:restriction>
  2866.       </xs:simpleType>
  2867.     */   
  2868.     internal class Datatype_language : Datatype_token
  2869.     {
  2870.         public override XmlTypeCode TypeCode {
  2871.             get { return XmlTypeCode.Language; }
  2872.         }
  2873.     }
  2874.    
  2875. /*
  2876.       <xs:simpleType name="NMTOKEN" id="NMTOKEN">
  2877.         <xs:annotation>
  2878.           <xs:documentation
  2879.             source="http://www.w3.org/TR/xmlschema-2/#NMTOKEN"/>
  2880.         </xs:annotation>
  2881.         <xs:restriction base="xs:token">
  2882.           <xs:pattern value="\c+" id="NMTOKEN.pattern">
  2883.             <xs:annotation>
  2884.               <xs:documentation
  2885.                     source="http://www.w3.org/TR/REC-xml#NT-Nmtoken">
  2886.                 pattern matches production 7 from the XML spec
  2887.               </xs:documentation>
  2888.             </xs:annotation>
  2889.           </xs:pattern>
  2890.         </xs:restriction>
  2891.       </xs:simpleType>
  2892.     */   
  2893.     internal class Datatype_NMTOKEN : Datatype_token
  2894.     {
  2895.        
  2896.         public override XmlTypeCode TypeCode {
  2897.             get { return XmlTypeCode.NmToken; }
  2898.         }
  2899.        
  2900.         public override XmlTokenizedType TokenizedType {
  2901.             get { return XmlTokenizedType.NMTOKEN; }
  2902.         }
  2903.     }
  2904.    
  2905. /*
  2906.       <xs:simpleType name="Name" id="Name">
  2907.         <xs:annotation>
  2908.           <xs:documentation
  2909.             source="http://www.w3.org/TR/xmlschema-2/#Name"/>
  2910.         </xs:annotation>
  2911.         <xs:restriction base="xs:token">
  2912.           <xs:pattern value="\i\c*" id="Name.pattern">
  2913.             <xs:annotation>
  2914.               <xs:documentation
  2915.                             source="http://www.w3.org/TR/REC-xml#NT-Name">
  2916.                 pattern matches production 5 from the XML spec
  2917.               </xs:documentation>
  2918.             </xs:annotation>
  2919.           </xs:pattern>
  2920.         </xs:restriction>
  2921.       </xs:simpleType>
  2922.     */   
  2923.     internal class Datatype_Name : Datatype_token
  2924.     {
  2925.         public override XmlTypeCode TypeCode {
  2926.             get { return XmlTypeCode.Name; }
  2927.         }
  2928.     }
  2929.    
  2930. /*
  2931.       <xs:simpleType name="NCName" id="NCName">
  2932.         <xs:annotation>
  2933.           <xs:documentation
  2934.             source="http://www.w3.org/TR/xmlschema-2/#NCName"/>
  2935.         </xs:annotation>
  2936.         <xs:restriction base="xs:Name">
  2937.           <xs:pattern value="[\i-[:]][\c-[:]]*" id="NCName.pattern">
  2938.             <xs:annotation>
  2939.               <xs:documentation
  2940.                     source="http://www.w3.org/TR/REC-xml-names/#NT-NCName">
  2941.                 pattern matches production 4 from the Namespaces in XML spec
  2942.               </xs:documentation>
  2943.             </xs:annotation>
  2944.           </xs:pattern>
  2945.         </xs:restriction>
  2946.       </xs:simpleType>
  2947.     */   
  2948.     internal class Datatype_NCName : Datatype_Name
  2949.     {
  2950.        
  2951.         public override XmlTypeCode TypeCode {
  2952.             get { return XmlTypeCode.NCName; }
  2953.         }
  2954.        
  2955.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  2956.         {
  2957.             Exception exception;
  2958.            
  2959.             typedValue = null;
  2960.            
  2961.             exception = stringFacetsChecker.CheckLexicalFacets(ref s, this);
  2962.             if (exception != null)
  2963.                 goto Error;
  2964.            
  2965.             exception = stringFacetsChecker.CheckValueFacets(s, this);
  2966.             if (exception != null)
  2967.                 goto Error;
  2968.            
  2969.             nameTable.Add(s);
  2970.            
  2971.             typedValue = s;
  2972.             return null;
  2973.             Error:
  2974.            
  2975.             return exception;
  2976.         }
  2977.     }
  2978.    
  2979. /*
  2980.       <xs:simpleType name="ID" id="ID">
  2981.         <xs:annotation>
  2982.           <xs:documentation
  2983.             source="http://www.w3.org/TR/xmlschema-2/#ID"/>
  2984.         </xs:annotation>
  2985.         <xs:restriction base="xs:NCName"/>
  2986.       </xs:simpleType>
  2987.     */   
  2988.     internal class Datatype_ID : Datatype_NCName
  2989.     {
  2990.        
  2991.         public override XmlTypeCode TypeCode {
  2992.             get { return XmlTypeCode.Id; }
  2993.         }
  2994.        
  2995.         public override XmlTokenizedType TokenizedType {
  2996.             get { return XmlTokenizedType.ID; }
  2997.         }
  2998.     }
  2999.    
  3000. /*
  3001.       <xs:simpleType name="IDREF" id="IDREF">
  3002.         <xs:annotation>
  3003.           <xs:documentation
  3004.             source="http://www.w3.org/TR/xmlschema-2/#IDREF"/>
  3005.         </xs:annotation>
  3006.         <xs:restriction base="xs:NCName"/>
  3007.       </xs:simpleType>
  3008.     */   
  3009.     internal class Datatype_IDREF : Datatype_NCName
  3010.     {
  3011.        
  3012.         public override XmlTypeCode TypeCode {
  3013.             get { return XmlTypeCode.Idref; }
  3014.         }
  3015.        
  3016.         public override XmlTokenizedType TokenizedType {
  3017.             get { return XmlTokenizedType.IDREF; }
  3018.         }
  3019.     }
  3020.    
  3021. /*
  3022.       <xs:simpleType name="ENTITY" id="ENTITY">
  3023.         <xs:annotation>
  3024.           <xs:documentation
  3025.             source="http://www.w3.org/TR/xmlschema-2/#ENTITY"/>
  3026.         </xs:annotation>
  3027.         <xs:restriction base="xs:NCName"/>
  3028.       </xs:simpleType>
  3029.     */   
  3030.     internal class Datatype_ENTITY : Datatype_NCName
  3031.     {
  3032.        
  3033.         public override XmlTypeCode TypeCode {
  3034.             get { return XmlTypeCode.Entity; }
  3035.         }
  3036.        
  3037.         public override XmlTokenizedType TokenizedType {
  3038.             get { return XmlTokenizedType.ENTITY; }
  3039.         }
  3040.        
  3041.     }
  3042.    
  3043. /*
  3044.       <xs:simpleType name="NOTATION" id="NOTATION">
  3045.         <xs:annotation>
  3046.             <xs:appinfo>
  3047.             <hfp:hasFacet name="length"/>
  3048.             <hfp:hasFacet name="minLength"/>
  3049.             <hfp:hasFacet name="maxLength"/>
  3050.             <hfp:hasFacet name="pattern"/>
  3051.             <hfp:hasFacet name="enumeration"/>
  3052.             <hfp:hasFacet name="whiteSpace"/>
  3053.             <hfp:hasProperty name="ordered" value="false"/>
  3054.             <hfp:hasProperty name="bounded" value="false"/>
  3055.             <hfp:hasProperty name="cardinality"
  3056.                     value="countably infinite"/>
  3057.             <hfp:hasProperty name="numeric" value="false"/>
  3058.           </xs:appinfo>
  3059.           <xs:documentation
  3060.             source="http://www.w3.org/TR/xmlschema-2/#NOTATION"/>
  3061.           <xs:documentation>
  3062.             NOTATION cannot be used directly in a schema; rather a type
  3063.             must be derived from it by specifying at least one enumeration
  3064.             facet whose value is the name of a NOTATION declared in the
  3065.             schema.
  3066.           </xs:documentation>
  3067.         </xs:annotation>
  3068.         <xs:restriction base="xs:anySimpleType">
  3069.           <xs:whiteSpace value="collapse"  fixed="true"
  3070.             id="NOTATION.whiteSpace"/>
  3071.         </xs:restriction>
  3072.       </xs:simpleType>
  3073.     */   
  3074.     internal class Datatype_NOTATION : Datatype_anySimpleType
  3075.     {
  3076.         static readonly Type atomicValueType = typeof(XmlQualifiedName);
  3077.         static readonly Type listValueType = typeof(XmlQualifiedName[]);
  3078.        
  3079.         internal override XmlValueConverter CreateValueConverter(XmlSchemaType schemaType)
  3080.         {
  3081.             return XmlMiscConverter.Create(schemaType);
  3082.         }
  3083.        
  3084.         internal override FacetsChecker FacetsChecker {
  3085.             get { return qnameFacetsChecker; }
  3086.         }
  3087.        
  3088.         public override XmlTypeCode TypeCode {
  3089.             get { return XmlTypeCode.Notation; }
  3090.         }
  3091.        
  3092.         public override XmlTokenizedType TokenizedType {
  3093.             get { return XmlTokenizedType.NOTATION; }
  3094.         }
  3095.        
  3096.         internal override RestrictionFlags ValidRestrictionFlags {
  3097.             get { return RestrictionFlags.Length | RestrictionFlags.MinLength | RestrictionFlags.MaxLength | RestrictionFlags.Pattern | RestrictionFlags.Enumeration | RestrictionFlags.WhiteSpace; }
  3098.         }
  3099.        
  3100.         public override Type ValueType {
  3101.             get { return atomicValueType; }
  3102.         }
  3103.        
  3104.         internal override Type ListValueType {
  3105.             get { return listValueType; }
  3106.         }
  3107.        
  3108.         internal override XmlSchemaWhiteSpace BuiltInWhitespaceFacet {
  3109.             get { return XmlSchemaWhiteSpace.Collapse; }
  3110.         }
  3111.        
  3112.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  3113.         {
  3114.             Exception exception;
  3115.            
  3116.             typedValue = null;
  3117.            
  3118.             if (s == null || s.Length == 0) {
  3119.                 return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
  3120.             }
  3121.            
  3122.             exception = qnameFacetsChecker.CheckLexicalFacets(ref s, this);
  3123.             if (exception != null)
  3124.                 goto Error;
  3125.            
  3126.             XmlQualifiedName qname = null;
  3127.             try {
  3128.                 string prefix;
  3129.                 qname = XmlQualifiedName.Parse(s, nsmgr, out prefix);
  3130.             }
  3131.             catch (ArgumentException e) {
  3132.                 exception = e;
  3133.                 goto Error;
  3134.             }
  3135.             catch (XmlException e) {
  3136.                 exception = e;
  3137.                 goto Error;
  3138.             }
  3139.            
  3140.             exception = qnameFacetsChecker.CheckValueFacets(qname, this);
  3141.             if (exception != null)
  3142.                 goto Error;
  3143.            
  3144.             typedValue = qname;
  3145.            
  3146.             return null;
  3147.             Error:
  3148.            
  3149.             return exception;
  3150.         }
  3151.        
  3152.         internal override void VerifySchemaValid(XmlSchemaObjectTable notations, XmlSchemaObject caller)
  3153.         {
  3154.            
  3155.             // Only datatypes that are derived from NOTATION by specifying a value for enumeration can be used in a schema.
  3156.             // Furthermore, the value of all enumeration facets must match the name of a notation declared in the current schema. //
  3157.             for (Datatype_NOTATION dt = this; dt != null; dt = (Datatype_NOTATION)dt.Base) {
  3158.                 if (dt.Restriction != null && (dt.Restriction.Flags & RestrictionFlags.Enumeration) != 0) {
  3159.                     foreach (XmlQualifiedName notation in dt.Restriction.Enumeration) {
  3160.                         if (!notations.Contains(notation)) {
  3161.                             throw new XmlSchemaException(Res.Sch_NotationRequired, caller);
  3162.                         }
  3163.                     }
  3164.                     return;
  3165.                 }
  3166.             }
  3167.             throw new XmlSchemaException(Res.Sch_NotationRequired, caller);
  3168.         }
  3169.     }
  3170.    
  3171. /*
  3172.       <xs:simpleType name="integer" id="integer">
  3173.         <xs:annotation>
  3174.           <xs:documentation
  3175.             source="http://www.w3.org/TR/xmlschema-2/#integer"/>
  3176.         </xs:annotation>
  3177.         <xs:restriction base="xs:decimal">
  3178.           <xs:fractionDigits value="0" fixed="true" id="integer.fractionDigits"/>
  3179.         </xs:restriction>
  3180.       </xs:simpleType>
  3181.     */   
  3182.     internal class Datatype_integer : Datatype_decimal
  3183.     {
  3184.        
  3185.         public override XmlTypeCode TypeCode {
  3186.             get { return XmlTypeCode.Integer; }
  3187.         }
  3188.        
  3189.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  3190.         {
  3191.             Exception exception;
  3192.            
  3193.             typedValue = null;
  3194.            
  3195.             exception = FacetsChecker.CheckLexicalFacets(ref s, this);
  3196.             if (exception != null)
  3197.                 goto Error;
  3198.            
  3199.             decimal decimalValue;
  3200.             exception = XmlConvert.TryToInteger(s, out decimalValue);
  3201.             if (exception != null)
  3202.                 goto Error;
  3203.            
  3204.             exception = FacetsChecker.CheckValueFacets(decimalValue, this);
  3205.             if (exception != null)
  3206.                 goto Error;
  3207.            
  3208.             typedValue = decimalValue;
  3209.            
  3210.             return null;
  3211.             Error:
  3212.            
  3213.             return exception;
  3214.         }
  3215.     }
  3216.    
  3217. /*
  3218.       <xs:simpleType name="nonPositiveInteger" id="nonPostiveInteger">
  3219.         <xs:annotation>
  3220.           <xs:documentation
  3221.             source="http://www.w3.org/TR/xmlschema-2/#negativeInteger"/>
  3222.         </xs:annotation>
  3223.         <xs:restriction base="xs:nonPositiveInteger">
  3224.           <xs:maxInclusive value="-1" id="negativeInteger.maxInclusive"/>
  3225.         </xs:restriction>
  3226.       </xs:simpleType>
  3227.     */   
  3228.     internal class Datatype_nonPositiveInteger : Datatype_integer
  3229.     {
  3230.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.MinValue, decimal.Zero);
  3231.        
  3232.         internal override FacetsChecker FacetsChecker {
  3233.             get { return numeric10FacetsChecker; }
  3234.         }
  3235.        
  3236.         public override XmlTypeCode TypeCode {
  3237.             get { return XmlTypeCode.NonPositiveInteger; }
  3238.         }
  3239.        
  3240.         internal override bool HasValueFacets {
  3241.                 //Built-in facet to check range
  3242.             get { return true; }
  3243.         }
  3244.     }
  3245.    
  3246.    
  3247. /*
  3248.       <xs:simpleType name="negativeInteger" id="negativeInteger">
  3249.         <xs:annotation>
  3250.           <xs:documentation
  3251.             source="http://www.w3.org/TR/xmlschema-2/#negativeInteger"/>
  3252.         </xs:annotation>
  3253.         <xs:restriction base="xs:nonPositiveInteger">
  3254.           <xs:maxInclusive value="-1" id="negativeInteger.maxInclusive"/>
  3255.         </xs:restriction>
  3256.       </xs:simpleType>
  3257.     */   
  3258.     internal class Datatype_negativeInteger : Datatype_nonPositiveInteger
  3259.     {
  3260.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.MinValue, decimal.MinusOne);
  3261.        
  3262.         internal override FacetsChecker FacetsChecker {
  3263.             get { return numeric10FacetsChecker; }
  3264.         }
  3265.        
  3266.         public override XmlTypeCode TypeCode {
  3267.             get { return XmlTypeCode.NegativeInteger; }
  3268.         }
  3269.     }
  3270.    
  3271.    
  3272. /*
  3273.       <xs:simpleType name="long" id="long">
  3274.         <xs:annotation>
  3275.           <xs:appinfo>
  3276.             <hfp:hasProperty name="bounded" value="true"/>
  3277.             <hfp:hasProperty name="cardinality" value="finite"/>
  3278.           </xs:appinfo>
  3279.           <xs:documentation
  3280.             source="http://www.w3.org/TR/xmlschema-2/#long"/>
  3281.         </xs:annotation>
  3282.         <xs:restriction base="xs:integer">
  3283.           <xs:minInclusive value="-9223372036854775808" id="long.minInclusive"/>
  3284.           <xs:maxInclusive value="9223372036854775807" id="long.maxInclusive"/>
  3285.         </xs:restriction>
  3286.       </xs:simpleType>
  3287.     */   
  3288.     internal class Datatype_long : Datatype_integer
  3289.     {
  3290.         static readonly Type atomicValueType = typeof(long);
  3291.         static readonly Type listValueType = typeof(long[]);
  3292.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(long.MinValue, long.MaxValue);
  3293.        
  3294.         internal override FacetsChecker FacetsChecker {
  3295.             get { return numeric10FacetsChecker; }
  3296.         }
  3297.        
  3298.         internal override bool HasValueFacets {
  3299.                 //Built-in facet to check range
  3300.             get { return true; }
  3301.         }
  3302.        
  3303.         public override XmlTypeCode TypeCode {
  3304.             get { return XmlTypeCode.Long; }
  3305.         }
  3306.        
  3307.         internal override int Compare(object value1, object value2)
  3308.         {
  3309.             return ((long)value1).CompareTo(value2);
  3310.         }
  3311.        
  3312.         public override Type ValueType {
  3313.             get { return atomicValueType; }
  3314.         }
  3315.        
  3316.         internal override Type ListValueType {
  3317.             get { return listValueType; }
  3318.         }
  3319.        
  3320.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  3321.         {
  3322.             Exception exception;
  3323.            
  3324.             typedValue = null;
  3325.            
  3326.             exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
  3327.             if (exception != null)
  3328.                 goto Error;
  3329.            
  3330.             long int64Value;
  3331.             exception = XmlConvert.TryToInt64(s, out int64Value);
  3332.             if (exception != null)
  3333.                 goto Error;
  3334.            
  3335.             exception = numeric10FacetsChecker.CheckValueFacets(int64Value, this);
  3336.             if (exception != null)
  3337.                 goto Error;
  3338.            
  3339.             typedValue = int64Value;
  3340.            
  3341.             return null;
  3342.             Error:
  3343.            
  3344.             return exception;
  3345.         }
  3346.     }
  3347.    
  3348. /*
  3349.       <xs:simpleType name="int" id="int">
  3350.         <xs:annotation>
  3351.           <xs:documentation
  3352.             source="http://www.w3.org/TR/xmlschema-2/#int"/>
  3353.         </xs:annotation>
  3354.         <xs:restriction base="xs:long">
  3355.           <xs:minInclusive value="-2147483648" id="int.minInclusive"/>
  3356.           <xs:maxInclusive value="2147483647" id="int.maxInclusive"/>
  3357.         </xs:restriction>
  3358.       </xs:simpleType>
  3359.     */   
  3360.     internal class Datatype_int : Datatype_long
  3361.     {
  3362.         static readonly Type atomicValueType = typeof(int);
  3363.         static readonly Type listValueType = typeof(int[]);
  3364.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(int.MinValue, int.MaxValue);
  3365.        
  3366.         internal override FacetsChecker FacetsChecker {
  3367.             get { return numeric10FacetsChecker; }
  3368.         }
  3369.        
  3370.         public override XmlTypeCode TypeCode {
  3371.             get { return XmlTypeCode.Int; }
  3372.         }
  3373.        
  3374.         internal override int Compare(object value1, object value2)
  3375.         {
  3376.             return ((int)value1).CompareTo(value2);
  3377.         }
  3378.        
  3379.         public override Type ValueType {
  3380.             get { return atomicValueType; }
  3381.         }
  3382.        
  3383.         internal override Type ListValueType {
  3384.             get { return listValueType; }
  3385.         }
  3386.        
  3387.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  3388.         {
  3389.             Exception exception;
  3390.            
  3391.             typedValue = null;
  3392.            
  3393.             exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
  3394.             if (exception != null)
  3395.                 goto Error;
  3396.            
  3397.             int int32Value;
  3398.             exception = XmlConvert.TryToInt32(s, out int32Value);
  3399.             if (exception != null)
  3400.                 goto Error;
  3401.            
  3402.             exception = numeric10FacetsChecker.CheckValueFacets(int32Value, this);
  3403.             if (exception != null)
  3404.                 goto Error;
  3405.            
  3406.             typedValue = int32Value;
  3407.            
  3408.             return null;
  3409.             Error:
  3410.            
  3411.             return exception;
  3412.         }
  3413.     }
  3414.    
  3415.    
  3416. /*
  3417.       <xs:simpleType name="short" id="short">
  3418.         <xs:annotation>
  3419.           <xs:documentation
  3420.             source="http://www.w3.org/TR/xmlschema-2/#short"/>
  3421.         </xs:annotation>
  3422.         <xs:restriction base="xs:int">
  3423.           <xs:minInclusive value="-32768" id="short.minInclusive"/>
  3424.           <xs:maxInclusive value="32767" id="short.maxInclusive"/>
  3425.         </xs:restriction>
  3426.       </xs:simpleType>
  3427.     */   
  3428.     internal class Datatype_short : Datatype_int
  3429.     {
  3430.         static readonly Type atomicValueType = typeof(short);
  3431.         static readonly Type listValueType = typeof(short[]);
  3432.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(short.MinValue, short.MaxValue);
  3433.        
  3434.         internal override FacetsChecker FacetsChecker {
  3435.             get { return numeric10FacetsChecker; }
  3436.         }
  3437.        
  3438.         public override XmlTypeCode TypeCode {
  3439.             get { return XmlTypeCode.Short; }
  3440.         }
  3441.        
  3442.         internal override int Compare(object value1, object value2)
  3443.         {
  3444.             return ((short)value1).CompareTo(value2);
  3445.         }
  3446.        
  3447.         public override Type ValueType {
  3448.             get { return atomicValueType; }
  3449.         }
  3450.        
  3451.         internal override Type ListValueType {
  3452.             get { return listValueType; }
  3453.         }
  3454.        
  3455.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  3456.         {
  3457.             Exception exception;
  3458.            
  3459.             typedValue = null;
  3460.            
  3461.             exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
  3462.             if (exception != null)
  3463.                 goto Error;
  3464.            
  3465.             short int16Value;
  3466.             exception = XmlConvert.TryToInt16(s, out int16Value);
  3467.             if (exception != null)
  3468.                 goto Error;
  3469.            
  3470.             exception = numeric10FacetsChecker.CheckValueFacets(int16Value, this);
  3471.             if (exception != null)
  3472.                 goto Error;
  3473.            
  3474.             typedValue = int16Value;
  3475.            
  3476.             return null;
  3477.             Error:
  3478.            
  3479.             return exception;
  3480.         }
  3481.     }
  3482.    
  3483. /*
  3484.       <xs:simpleType name="byte" id="byte">
  3485.         <xs:annotation>
  3486.           <xs:documentation
  3487.             source="http://www.w3.org/TR/xmlschema-2/#byte"/>
  3488.         </xs:annotation>
  3489.         <xs:restriction base="xs:short">
  3490.           <xs:minInclusive value="-128" id="byte.minInclusive"/>
  3491.           <xs:maxInclusive value="127" id="byte.maxInclusive"/>
  3492.         </xs:restriction>
  3493.       </xs:simpleType>
  3494.     */   
  3495.     internal class Datatype_byte : Datatype_short
  3496.     {
  3497.         static readonly Type atomicValueType = typeof(sbyte);
  3498.         static readonly Type listValueType = typeof(sbyte[]);
  3499.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(sbyte.MinValue, sbyte.MaxValue);
  3500.        
  3501.         internal override FacetsChecker FacetsChecker {
  3502.             get { return numeric10FacetsChecker; }
  3503.         }
  3504.        
  3505.         public override XmlTypeCode TypeCode {
  3506.             get { return XmlTypeCode.Byte; }
  3507.         }
  3508.        
  3509.         internal override int Compare(object value1, object value2)
  3510.         {
  3511.             return ((sbyte)value1).CompareTo(value2);
  3512.         }
  3513.        
  3514.         public override Type ValueType {
  3515.             get { return atomicValueType; }
  3516.         }
  3517.        
  3518.         internal override Type ListValueType {
  3519.             get { return listValueType; }
  3520.         }
  3521.        
  3522.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  3523.         {
  3524.             Exception exception;
  3525.            
  3526.             typedValue = null;
  3527.            
  3528.             exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
  3529.             if (exception != null)
  3530.                 goto Error;
  3531.            
  3532.             sbyte sbyteValue;
  3533.             exception = XmlConvert.TryToSByte(s, out sbyteValue);
  3534.             if (exception != null)
  3535.                 goto Error;
  3536.            
  3537.             exception = numeric10FacetsChecker.CheckValueFacets((short)sbyteValue, this);
  3538.             if (exception != null)
  3539.                 goto Error;
  3540.            
  3541.             typedValue = sbyteValue;
  3542.            
  3543.             return null;
  3544.             Error:
  3545.            
  3546.             return exception;
  3547.         }
  3548.     }
  3549.    
  3550. /*
  3551.       <xs:simpleType name="nonNegativeInteger" id="nonNegativeInteger">
  3552.         <xs:annotation>
  3553.           <xs:documentation
  3554.             source="http://www.w3.org/TR/xmlschema-2/#nonNegativeInteger"/>
  3555.         </xs:annotation>
  3556.         <xs:restriction base="xs:integer">
  3557.           <xs:minInclusive value="0" id="nonNegativeInteger.minInclusive"/>
  3558.         </xs:restriction>
  3559.       </xs:simpleType>
  3560.     */   
  3561.     internal class Datatype_nonNegativeInteger : Datatype_integer
  3562.     {
  3563.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.Zero, decimal.MaxValue);
  3564.        
  3565.         internal override FacetsChecker FacetsChecker {
  3566.             get { return numeric10FacetsChecker; }
  3567.         }
  3568.        
  3569.         public override XmlTypeCode TypeCode {
  3570.             get { return XmlTypeCode.NonNegativeInteger; }
  3571.         }
  3572.        
  3573.         internal override bool HasValueFacets {
  3574.                 //Built-in facet to check range
  3575.             get { return true; }
  3576.         }
  3577.     }
  3578.    
  3579. /*
  3580.       <xs:simpleType name="unsignedLong" id="unsignedLong">
  3581.         <xs:annotation>
  3582.           <xs:appinfo>
  3583.             <hfp:hasProperty name="bounded" value="true"/>
  3584.             <hfp:hasProperty name="cardinality" value="finite"/>
  3585.           </xs:appinfo>
  3586.           <xs:documentation
  3587.             source="http://www.w3.org/TR/xmlschema-2/#unsignedLong"/>
  3588.         </xs:annotation>
  3589.         <xs:restriction base="xs:nonNegativeInteger">
  3590.           <xs:maxInclusive value="18446744073709551615"
  3591.             id="unsignedLong.maxInclusive"/>
  3592.         </xs:restriction>
  3593.       </xs:simpleType>
  3594.     */   
  3595.     internal class Datatype_unsignedLong : Datatype_nonNegativeInteger
  3596.     {
  3597.         static readonly Type atomicValueType = typeof(ulong);
  3598.         static readonly Type listValueType = typeof(ulong[]);
  3599.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(ulong.MinValue, ulong.MaxValue);
  3600.        
  3601.         internal override FacetsChecker FacetsChecker {
  3602.             get { return numeric10FacetsChecker; }
  3603.         }
  3604.        
  3605.         public override XmlTypeCode TypeCode {
  3606.             get { return XmlTypeCode.UnsignedLong; }
  3607.         }
  3608.        
  3609.         internal override int Compare(object value1, object value2)
  3610.         {
  3611.             return ((ulong)value1).CompareTo(value2);
  3612.         }
  3613.        
  3614.         public override Type ValueType {
  3615.             get { return atomicValueType; }
  3616.         }
  3617.        
  3618.         internal override Type ListValueType {
  3619.             get { return listValueType; }
  3620.         }
  3621.        
  3622.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  3623.         {
  3624.             Exception exception;
  3625.            
  3626.             typedValue = null;
  3627.            
  3628.             exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
  3629.             if (exception != null)
  3630.                 goto Error;
  3631.            
  3632.             ulong uint64Value;
  3633.             exception = XmlConvert.TryToUInt64(s, out uint64Value);
  3634.             if (exception != null)
  3635.                 goto Error;
  3636.            
  3637.             exception = numeric10FacetsChecker.CheckValueFacets((decimal)uint64Value, this);
  3638.             if (exception != null)
  3639.                 goto Error;
  3640.            
  3641.             typedValue = uint64Value;
  3642.            
  3643.             return null;
  3644.             Error:
  3645.            
  3646.             return exception;
  3647.         }
  3648.     }
  3649.    
  3650. /*
  3651.       <xs:simpleType name="unsignedInt" id="unsignedInt">
  3652.         <xs:annotation>
  3653.           <xs:documentation
  3654.             source="http://www.w3.org/TR/xmlschema-2/#unsignedInt"/>
  3655.         </xs:annotation>
  3656.         <xs:restriction base="xs:unsignedLong">
  3657.           <xs:maxInclusive value="4294967295"
  3658.             id="unsignedInt.maxInclusive"/>
  3659.         </xs:restriction>
  3660.       </xs:simpleType>
  3661.     */   
  3662.     internal class Datatype_unsignedInt : Datatype_unsignedLong
  3663.     {
  3664.         static readonly Type atomicValueType = typeof(uint);
  3665.         static readonly Type listValueType = typeof(uint[]);
  3666.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(uint.MinValue, uint.MaxValue);
  3667.        
  3668.         internal override FacetsChecker FacetsChecker {
  3669.             get { return numeric10FacetsChecker; }
  3670.         }
  3671.        
  3672.         public override XmlTypeCode TypeCode {
  3673.             get { return XmlTypeCode.UnsignedInt; }
  3674.         }
  3675.        
  3676.         internal override int Compare(object value1, object value2)
  3677.         {
  3678.             return ((uint)value1).CompareTo(value2);
  3679.         }
  3680.        
  3681.         public override Type ValueType {
  3682.             get { return atomicValueType; }
  3683.         }
  3684.        
  3685.         internal override Type ListValueType {
  3686.             get { return listValueType; }
  3687.         }
  3688.        
  3689.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  3690.         {
  3691.             Exception exception;
  3692.            
  3693.             typedValue = null;
  3694.            
  3695.             exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
  3696.             if (exception != null)
  3697.                 goto Error;
  3698.            
  3699.             uint uint32Value;
  3700.             exception = XmlConvert.TryToUInt32(s, out uint32Value);
  3701.             if (exception != null)
  3702.                 goto Error;
  3703.            
  3704.             exception = numeric10FacetsChecker.CheckValueFacets((long)uint32Value, this);
  3705.             if (exception != null)
  3706.                 goto Error;
  3707.            
  3708.             typedValue = uint32Value;
  3709.            
  3710.             return null;
  3711.             Error:
  3712.            
  3713.             return exception;
  3714.         }
  3715.     }
  3716.    
  3717. /*
  3718.       <xs:simpleType name="unsignedShort" id="unsignedShort">
  3719.         <xs:annotation>
  3720.           <xs:documentation
  3721.             source="http://www.w3.org/TR/xmlschema-2/#unsignedShort"/>
  3722.         </xs:annotation>
  3723.         <xs:restriction base="xs:unsignedInt">
  3724.           <xs:maxInclusive value="65535"
  3725.             id="unsignedShort.maxInclusive"/>
  3726.         </xs:restriction>
  3727.       </xs:simpleType>
  3728.     */   
  3729.     internal class Datatype_unsignedShort : Datatype_unsignedInt
  3730.     {
  3731.         static readonly Type atomicValueType = typeof(ushort);
  3732.         static readonly Type listValueType = typeof(ushort[]);
  3733.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(ushort.MinValue, ushort.MaxValue);
  3734.        
  3735.         internal override FacetsChecker FacetsChecker {
  3736.             get { return numeric10FacetsChecker; }
  3737.         }
  3738.        
  3739.         public override XmlTypeCode TypeCode {
  3740.             get { return XmlTypeCode.UnsignedShort; }
  3741.         }
  3742.        
  3743.         internal override int Compare(object value1, object value2)
  3744.         {
  3745.             return ((ushort)value1).CompareTo(value2);
  3746.         }
  3747.        
  3748.         public override Type ValueType {
  3749.             get { return atomicValueType; }
  3750.         }
  3751.        
  3752.         internal override Type ListValueType {
  3753.             get { return listValueType; }
  3754.         }
  3755.        
  3756.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  3757.         {
  3758.             Exception exception;
  3759.            
  3760.             typedValue = null;
  3761.            
  3762.             exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
  3763.             if (exception != null)
  3764.                 goto Error;
  3765.            
  3766.             ushort uint16Value;
  3767.             exception = XmlConvert.TryToUInt16(s, out uint16Value);
  3768.             if (exception != null)
  3769.                 goto Error;
  3770.            
  3771.             exception = numeric10FacetsChecker.CheckValueFacets((int)uint16Value, this);
  3772.             if (exception != null)
  3773.                 goto Error;
  3774.            
  3775.             typedValue = uint16Value;
  3776.            
  3777.             return null;
  3778.             Error:
  3779.            
  3780.             return exception;
  3781.         }
  3782.     }
  3783.    
  3784. /*
  3785.       <xs:simpleType name="unsignedByte" id="unsignedBtype">
  3786.         <xs:annotation>
  3787.           <xs:documentation
  3788.             source="http://www.w3.org/TR/xmlschema-2/#unsignedByte"/>
  3789.         </xs:annotation>
  3790.         <xs:restriction base="xs:unsignedShort">
  3791.           <xs:maxInclusive value="255" id="unsignedByte.maxInclusive"/>
  3792.         </xs:restriction>
  3793.       </xs:simpleType>
  3794.     */   
  3795.     internal class Datatype_unsignedByte : Datatype_unsignedShort
  3796.     {
  3797.         static readonly Type atomicValueType = typeof(byte);
  3798.         static readonly Type listValueType = typeof(byte[]);
  3799.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(byte.MinValue, byte.MaxValue);
  3800.        
  3801.         internal override FacetsChecker FacetsChecker {
  3802.             get { return numeric10FacetsChecker; }
  3803.         }
  3804.        
  3805.         public override XmlTypeCode TypeCode {
  3806.             get { return XmlTypeCode.UnsignedByte; }
  3807.         }
  3808.        
  3809.         internal override int Compare(object value1, object value2)
  3810.         {
  3811.             return ((byte)value1).CompareTo(value2);
  3812.         }
  3813.        
  3814.         public override Type ValueType {
  3815.             get { return atomicValueType; }
  3816.         }
  3817.        
  3818.         internal override Type ListValueType {
  3819.             get { return listValueType; }
  3820.         }
  3821.        
  3822.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  3823.         {
  3824.             Exception exception;
  3825.            
  3826.             typedValue = null;
  3827.            
  3828.             exception = numeric10FacetsChecker.CheckLexicalFacets(ref s, this);
  3829.             if (exception != null)
  3830.                 goto Error;
  3831.            
  3832.             byte byteValue;
  3833.             exception = XmlConvert.TryToByte(s, out byteValue);
  3834.             if (exception != null)
  3835.                 goto Error;
  3836.            
  3837.             exception = numeric10FacetsChecker.CheckValueFacets((short)byteValue, this);
  3838.             if (exception != null)
  3839.                 goto Error;
  3840.            
  3841.             typedValue = byteValue;
  3842.            
  3843.             return null;
  3844.             Error:
  3845.            
  3846.             return exception;
  3847.         }
  3848.     }
  3849.    
  3850. /*
  3851.       <xs:simpleType name="positiveInteger" id="positiveInteger">
  3852.         <xs:annotation>
  3853.           <xs:documentation
  3854.             source="http://www.w3.org/TR/xmlschema-2/#positiveInteger"/>
  3855.         </xs:annotation>
  3856.         <xs:restriction base="xs:nonNegativeInteger">
  3857.           <xs:minInclusive value="1" id="positiveInteger.minInclusive"/>
  3858.         </xs:restriction>
  3859.       </xs:simpleType>
  3860.     */   
  3861.     internal class Datatype_positiveInteger : Datatype_nonNegativeInteger
  3862.     {
  3863.         static readonly FacetsChecker numeric10FacetsChecker = new Numeric10FacetsChecker(decimal.One, decimal.MaxValue);
  3864.        
  3865.         internal override FacetsChecker FacetsChecker {
  3866.             get { return numeric10FacetsChecker; }
  3867.         }
  3868.        
  3869.         public override XmlTypeCode TypeCode {
  3870.             get { return XmlTypeCode.PositiveInteger; }
  3871.         }
  3872.     }
  3873.    
  3874. /*
  3875.         XDR
  3876.     */   
  3877.     internal class Datatype_doubleXdr : Datatype_double
  3878.     {
  3879.         public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
  3880.         {
  3881.             double value;
  3882.             try {
  3883.                 value = XmlConvert.ToDouble(s);
  3884.             }
  3885.             catch (Exception e) {
  3886.                 throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
  3887.             }
  3888.             if (double.IsInfinity(value) || double.IsNaN(value)) {
  3889.                 throw new XmlSchemaException(Res.Sch_InvalidValue, s);
  3890.             }
  3891.             return value;
  3892.         }
  3893.     }
  3894.    
  3895.     internal class Datatype_floatXdr : Datatype_float
  3896.     {
  3897.         public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
  3898.         {
  3899.             float value;
  3900.             try {
  3901.                 value = XmlConvert.ToSingle(s);
  3902.             }
  3903.             catch (Exception e) {
  3904.                 throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
  3905.             }
  3906.             if (float.IsInfinity(value) || float.IsNaN(value)) {
  3907.                 throw new XmlSchemaException(Res.Sch_InvalidValue, s);
  3908.             }
  3909.             return value;
  3910.         }
  3911.     }
  3912.    
  3913.     internal class Datatype_QNameXdr : Datatype_anySimpleType
  3914.     {
  3915.         static readonly Type atomicValueType = typeof(XmlQualifiedName);
  3916.         static readonly Type listValueType = typeof(XmlQualifiedName[]);
  3917.        
  3918.         public override XmlTokenizedType TokenizedType {
  3919.             get { return XmlTokenizedType.QName; }
  3920.         }
  3921.        
  3922.         public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
  3923.         {
  3924.             if (s == null || s.Length == 0) {
  3925.                 throw new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
  3926.             }
  3927.             if (nsmgr == null) {
  3928.                 throw new ArgumentNullException("nsmgr");
  3929.             }
  3930.             string prefix;
  3931.             try {
  3932.                 return XmlQualifiedName.Parse(s.Trim(), nsmgr, out prefix);
  3933.             }
  3934.             catch (XmlSchemaException e) {
  3935.                 throw e;
  3936.             }
  3937.             catch (Exception e) {
  3938.                 throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
  3939.             }
  3940.         }
  3941.        
  3942.         public override Type ValueType {
  3943.             get { return atomicValueType; }
  3944.         }
  3945.        
  3946.         internal override Type ListValueType {
  3947.             get { return listValueType; }
  3948.         }
  3949.     }
  3950.    
  3951.     internal class Datatype_ENUMERATION : Datatype_NMTOKEN
  3952.     {
  3953.         public override XmlTokenizedType TokenizedType {
  3954.             get { return XmlTokenizedType.ENUMERATION; }
  3955.         }
  3956.     }
  3957.    
  3958.     internal class Datatype_char : Datatype_anySimpleType
  3959.     {
  3960.         static readonly Type atomicValueType = typeof(char);
  3961.         static readonly Type listValueType = typeof(char[]);
  3962.        
  3963.         public override Type ValueType {
  3964.             get { return atomicValueType; }
  3965.         }
  3966.        
  3967.         internal override Type ListValueType {
  3968.             get { return listValueType; }
  3969.         }
  3970.        
  3971.         internal override RestrictionFlags ValidRestrictionFlags {
  3972.             get { return 0; }
  3973.         }
  3974.         //XDR only
  3975.         internal override int Compare(object value1, object value2)
  3976.         {
  3977.             // this should be culture sensitive - comparing values
  3978.             return ((char)value1).CompareTo(value2);
  3979.         }
  3980.        
  3981.         public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
  3982.         {
  3983.             try {
  3984.                 return XmlConvert.ToChar(s);
  3985.             }
  3986.             catch (XmlSchemaException e) {
  3987.                 throw e;
  3988.             }
  3989.             catch (Exception e) {
  3990.                 throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
  3991.             }
  3992.         }
  3993.        
  3994.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  3995.         {
  3996.             Exception exception;
  3997.            
  3998.             typedValue = null;
  3999.            
  4000.             char charValue;
  4001.             exception = XmlConvert.TryToChar(s, out charValue);
  4002.             if (exception != null)
  4003.                 goto Error;
  4004.            
  4005.             typedValue = charValue;
  4006.            
  4007.             return null;
  4008.             Error:
  4009.            
  4010.             return exception;
  4011.         }
  4012.     }
  4013.    
  4014.     internal class Datatype_fixed : Datatype_decimal
  4015.     {
  4016.         public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
  4017.         {
  4018.             Exception exception;
  4019.            
  4020.             try {
  4021.                 Numeric10FacetsChecker facetsChecker = this.FacetsChecker as Numeric10FacetsChecker;
  4022.                 decimal value = XmlConvert.ToDecimal(s);
  4023.                 exception = facetsChecker.CheckTotalAndFractionDigits(value, 14 + 4, 4, true, true);
  4024.                 if (exception != null)
  4025.                     goto Error;
  4026.                
  4027.                 return value;
  4028.             }
  4029.             catch (XmlSchemaException e) {
  4030.                 throw e;
  4031.             }
  4032.             catch (Exception e) {
  4033.                 throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
  4034.             }
  4035.             Error:
  4036.             throw exception;
  4037.         }
  4038.        
  4039.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  4040.         {
  4041.             Exception exception;
  4042.            
  4043.             typedValue = null;
  4044.            
  4045.             decimal decimalValue;
  4046.             exception = XmlConvert.TryToDecimal(s, out decimalValue);
  4047.             if (exception != null)
  4048.                 goto Error;
  4049.            
  4050.             Numeric10FacetsChecker facetsChecker = this.FacetsChecker as Numeric10FacetsChecker;
  4051.             exception = facetsChecker.CheckTotalAndFractionDigits(decimalValue, 14 + 4, 4, true, true);
  4052.             if (exception != null)
  4053.                 goto Error;
  4054.            
  4055.             typedValue = decimalValue;
  4056.            
  4057.             return null;
  4058.             Error:
  4059.            
  4060.             return exception;
  4061.         }
  4062.     }
  4063.    
  4064.     internal class Datatype_uuid : Datatype_anySimpleType
  4065.     {
  4066.         static readonly Type atomicValueType = typeof(Guid);
  4067.         static readonly Type listValueType = typeof(Guid[]);
  4068.        
  4069.         public override Type ValueType {
  4070.             get { return atomicValueType; }
  4071.         }
  4072.        
  4073.         internal override Type ListValueType {
  4074.             get { return listValueType; }
  4075.         }
  4076.        
  4077.         internal override RestrictionFlags ValidRestrictionFlags {
  4078.             get { return 0; }
  4079.         }
  4080.        
  4081.         internal override int Compare(object value1, object value2)
  4082.         {
  4083.             return ((Guid)value1).Equals(value2) ? 0 : -1;
  4084.         }
  4085.        
  4086.         public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
  4087.         {
  4088.             try {
  4089.                 return XmlConvert.ToGuid(s);
  4090.             }
  4091.             catch (XmlSchemaException e) {
  4092.                 throw e;
  4093.             }
  4094.             catch (Exception e) {
  4095.                 throw new XmlSchemaException(Res.GetString(Res.Sch_InvalidValue, s), e);
  4096.             }
  4097.         }
  4098.        
  4099.         internal override Exception TryParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, out object typedValue)
  4100.         {
  4101.             Exception exception;
  4102.            
  4103.             typedValue = null;
  4104.            
  4105.             Guid guid;
  4106.             exception = XmlConvert.TryToGuid(s, out guid);
  4107.             if (exception != null)
  4108.                 goto Error;
  4109.            
  4110.             typedValue = guid;
  4111.            
  4112.             return null;
  4113.             Error:
  4114.            
  4115.             return exception;
  4116.         }
  4117.     }
  4118. }

Developer Fusion