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