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