mcs/class/System.XML/System.Xml.Schema/BuiltInDatatype.cs

   1 //\r
   2 // System.Xml.Schema.XmlSchemaDatatype.cs\r
   3 //\r
   4 // Author:\r
   5 //      Atsushi Enomoto\r
   6 //\r
   7 // (C)2003 Atsushi Enomoto\r
   8 //\r
   9
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30 using System;\r
  31 using System.Collections;\r
  32 using System.Text;\r
  33 using System.Xml;\r
  34 using System.Xml.Schema;\r
  35 using System.Globalization;\r
  36 using System.Security.Cryptography;\r
  37 \r
  38 #if NET_2_0\r
  39 using NSResolver = System.Xml.IXmlNamespaceResolver;\r
  40 #else\r
  41 using NSResolver = System.Xml.XmlNamespaceManager;\r
  42 #endif\r
  43 \r
  44 \r
  45 namespace Mono.Xml.Schema\r
  46 {\r
  47         internal enum XsdWhitespaceFacet\r
  48         {\r
  49                 Preserve,\r
  50                 Replace,\r
  51                 Collapse\r
  52         }\r
  53 \r
  54         internal enum XsdOrderedFacet\r
  55         {\r
  56                 False,\r
  57                 Partial,\r
  58                 Total\r
  59         }\r
  60 \r
  61         internal enum XsdOrdering \r
  62         {\r
  63                 LessThan = -1,\r
  64                 Equal = 0,\r
  65                 GreaterThan = 1,\r
  66                 Indeterminate = 2\r
  67         }\r
  68         \r
  69         internal class XsdAnySimpleType : XmlSchemaDatatype\r
  70         {\r
  71                 static XsdAnySimpleType instance;\r
  72                 static XsdAnySimpleType ()\r
  73                 {\r
  74                         instance = new XsdAnySimpleType ();\r
  75                 }\r
  76 \r
  77                 public static XsdAnySimpleType Instance {\r
  78                         get { return instance; }\r
  79                 }\r
  80 \r
  81 #if NET_2_0\r
  82                 public override XmlTypeCode TypeCode {\r
  83                         get { return XmlTypeCode.AnyAtomicType; }\r
  84                 }\r
  85 #endif\r
  86 \r
  87                 static readonly char [] whitespaceArray = new char [] {' '};\r
  88 \r
  89                 // Fundamental Facets\r
  90                 public virtual bool Bounded {\r
  91                         get { return false; }\r
  92                 }\r
  93 \r
  94                 public virtual bool Finite {\r
  95                         get { return false; }\r
  96                 }\r
  97 \r
  98                 public virtual bool Numeric { \r
  99                         get { return false; }\r
 100                 }\r
 101 \r
 102                 public virtual XsdOrderedFacet Ordered { \r
 103                         get { return XsdOrderedFacet.False; }\r
 104                 }\r
 105 \r
 106                 public override Type ValueType {\r
 107 #if BUGGY_MS_COMPLIANT\r
 108                         get { return typeof (string); }\r
 109 #else\r
 110                         get { return typeof (object); }\r
 111 #endif\r
 112                 }\r
 113 \r
 114                 public override XmlTokenizedType TokenizedType {\r
 115                         get {\r
 116                                 return XmlTokenizedType.None;\r
 117                         }\r
 118                 }\r
 119 \r
 120                 public override object ParseValue (string s,\r
 121                         XmlNameTable nameTable, NSResolver nsmgr)\r
 122                 {\r
 123                         return Normalize (s);\r
 124                 }\r
 125 \r
 126                 internal override ValueType ParseValueType (string s,\r
 127                         XmlNameTable nameTable, NSResolver nsmgr)\r
 128                 {\r
 129                         return new StringValueType (Normalize (s));\r
 130                 }\r
 131 \r
 132                 internal string [] ParseListValue (string s, XmlNameTable nameTable)\r
 133                 {\r
 134                         return this.Normalize (s, XsdWhitespaceFacet.Collapse).Split (whitespaceArray);\r
 135                 }\r
 136                 \r
 137         \r
 138 \r
 139                         // Can you even use XsdAnySimpleType in a schema?\r
 140                         // -> Yes. See E1-22 of http://www.w3.org/2001/05/xmlschema-errata#Errata1 (somewhat paranoid ;-)\r
 141                 \r
 142                 internal bool AllowsFacet(XmlSchemaFacet xsf) {\r
 143                         return (AllowedFacets & xsf.ThisFacet)!=0;\r
 144                 }\r
 145 \r
 146 \r
 147 \r
 148                 internal virtual XsdOrdering Compare(object x, object y) {\r
 149                         return XsdOrdering.Indeterminate;\r
 150                         }\r
 151         \r
 152                 internal virtual int Length(string s) {\r
 153                         return s.Length;\r
 154                 }\r
 155 \r
 156                 \r
 157                 // anySimpleType allows any facet\r
 158                 internal virtual XmlSchemaFacet.Facet AllowedFacets {\r
 159                         get { return XmlSchemaFacet.AllFacets ;}\r
 160                 }\r
 161 \r
 162                 /* Matches facets allowed on boolean type\r
 163                  */\r
 164                 internal static readonly XmlSchemaFacet.Facet booleanAllowedFacets = \r
 165                                          XmlSchemaFacet.Facet.pattern | XmlSchemaFacet.Facet.whiteSpace;\r
 166 \r
 167                 /* Matches facets allowed on decimal type. \r
 168                  */\r
 169                 internal static readonly XmlSchemaFacet.Facet decimalAllowedFacets = \r
 170                                                         XmlSchemaFacet.Facet.pattern | XmlSchemaFacet.Facet.enumeration | \r
 171                                                         XmlSchemaFacet.Facet.whiteSpace | XmlSchemaFacet.Facet.maxInclusive | \r
 172                                                         XmlSchemaFacet.Facet.minInclusive | XmlSchemaFacet.Facet.maxExclusive | \r
 173                                                         XmlSchemaFacet.Facet.minExclusive | XmlSchemaFacet.Facet.fractionDigits | \r
 174                                                         XmlSchemaFacet.Facet.totalDigits ;\r
 175 \r
 176                 /* Matches facets allowed on float, double, duration, dateTime, time, date,\r
 177                  * gYearMonth, gYear, gMonthDay, gMonth, and gDay types\r
 178                  */\r
 179 \r
 180                 internal static readonly XmlSchemaFacet.Facet durationAllowedFacets = \r
 181                                                         XmlSchemaFacet.Facet.pattern | XmlSchemaFacet.Facet.enumeration | \r
 182                                                         XmlSchemaFacet.Facet.whiteSpace | XmlSchemaFacet.Facet.maxInclusive |\r
 183                                                         XmlSchemaFacet.Facet.minInclusive | XmlSchemaFacet.Facet.maxExclusive |\r
 184                                                         XmlSchemaFacet.Facet.minExclusive ;\r
 185 \r
 186                 /* Matches facet allowed on string, hexBinary, base64Binary,\r
 187                  * anyURI, QName and NOTATION types \r
 188                  *\r
 189                  * Also used on list types\r
 190                  */\r
 191 \r
 192                 internal static readonly XmlSchemaFacet.Facet stringAllowedFacets = \r
 193                                                  XmlSchemaFacet.Facet.length | XmlSchemaFacet.Facet.minLength |\r
 194                                                  XmlSchemaFacet.Facet.maxLength | XmlSchemaFacet.Facet.pattern | \r
 195                                                  XmlSchemaFacet.Facet.enumeration | XmlSchemaFacet.Facet.whiteSpace; \r
 196         }\r
 197 \r
 198 #if NET_2_0\r
 199         internal class XdtAnyAtomicType : XsdAnySimpleType\r
 200         {\r
 201                 internal XdtAnyAtomicType ()\r
 202                 {\r
 203                 }\r
 204 \r
 205                 public override XmlTypeCode TypeCode {\r
 206                         get { return XmlTypeCode.AnyAtomicType; }\r
 207                 }\r
 208         }\r
 209 \r
 210         internal class XdtUntypedAtomic : XdtAnyAtomicType\r
 211         {\r
 212                 internal XdtUntypedAtomic ()\r
 213                 {\r
 214                 }\r
 215 \r
 216                 public override XmlTypeCode TypeCode {\r
 217                         get { return XmlTypeCode.UntypedAtomic; }\r
 218                 }\r
 219         }\r
 220 #endif\r
 221 \r
 222         // xs:string\r
 223         internal class XsdString : XsdAnySimpleType\r
 224         {\r
 225                 internal XsdString ()\r
 226                 {\r
 227                 }\r
 228 \r
 229                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
 230                         get { return stringAllowedFacets; } \r
 231                 }\r
 232 \r
 233                 public override XmlTokenizedType TokenizedType {\r
 234                         get { return XmlTokenizedType.CDATA; }\r
 235                 }\r
 236 \r
 237 #if NET_2_0\r
 238                 public override XmlTypeCode TypeCode {\r
 239                         get { return XmlTypeCode.String; }\r
 240                 }\r
 241 #endif\r
 242 \r
 243                 public override Type ValueType {\r
 244                         get { return typeof (string); }\r
 245                 }\r
 246 \r
 247                 // Fundamental Facets\r
 248                 public override bool Bounded {\r
 249                         get { return false; }\r
 250                 }\r
 251                 public override bool Finite {\r
 252                         get { return false; }\r
 253                 }\r
 254                 public override bool Numeric {\r
 255                         get { return false; }\r
 256                 }\r
 257                 public override XsdOrderedFacet Ordered {\r
 258                         get { return XsdOrderedFacet.False; }\r
 259                 }\r
 260 \r
 261         }\r
 262 \r
 263         // xs:normalizedString\r
 264         internal class XsdNormalizedString : XsdString\r
 265         {\r
 266                 internal XsdNormalizedString ()\r
 267                 {\r
 268                         this.WhitespaceValue = XsdWhitespaceFacet.Replace;\r
 269                 }\r
 270 \r
 271                 public override XmlTokenizedType TokenizedType {\r
 272 \r
 273                         get { return XmlTokenizedType.CDATA; }\r
 274                 }\r
 275 \r
 276 #if NET_2_0\r
 277                 public override XmlTypeCode TypeCode {\r
 278                         get { return XmlTypeCode.NormalizedString; }\r
 279                 }\r
 280 #endif\r
 281 \r
 282                 public override Type ValueType {\r
 283                         get { return typeof (string); }\r
 284                 }\r
 285 \r
 286                 // ParseValue () method is as same as that of xs:string\r
 287         }\r
 288 \r
 289         // xs:token\r
 290         internal class XsdToken : XsdNormalizedString\r
 291         {\r
 292                 internal XsdToken ()\r
 293                 {\r
 294                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
 295                 }\r
 296 \r
 297                 public override XmlTokenizedType TokenizedType {\r
 298                         get { return XmlTokenizedType.CDATA; }\r
 299                 }\r
 300 \r
 301 #if NET_2_0\r
 302                 public override XmlTypeCode TypeCode {\r
 303                         get { return XmlTypeCode.Token; }\r
 304                 }\r
 305 #endif\r
 306 \r
 307                 public override Type ValueType {\r
 308                         get { return typeof (string); }\r
 309                 }\r
 310 \r
 311                 // ParseValue () method is as same as that of xs:string\r
 312         }\r
 313 \r
 314         // xs:language\r
 315         internal class XsdLanguage : XsdToken\r
 316         {\r
 317                 internal XsdLanguage ()\r
 318                 {\r
 319                 }\r
 320 \r
 321                 public override XmlTokenizedType TokenizedType {\r
 322                         get { return XmlTokenizedType.CDATA; }\r
 323                 }\r
 324 \r
 325 #if NET_2_0\r
 326                 public override XmlTypeCode TypeCode {\r
 327                         get { return XmlTypeCode.Language; }\r
 328                 }\r
 329 #endif\r
 330 \r
 331                 public override Type ValueType {\r
 332                         get { return typeof (string); }\r
 333                 }\r
 334 \r
 335                 // ParseValue () method is as same as that of xs:string\r
 336         }\r
 337 \r
 338         // xs;NMTOKEN\r
 339         internal class XsdNMToken : XsdToken\r
 340         {\r
 341                 internal XsdNMToken ()\r
 342                 {\r
 343                 }\r
 344 \r
 345                 public override XmlTokenizedType TokenizedType {\r
 346                         get { return XmlTokenizedType.NMTOKEN; }\r
 347                 }\r
 348 \r
 349 #if NET_2_0\r
 350                 public override XmlTypeCode TypeCode {\r
 351                         get { return XmlTypeCode.NmToken; }\r
 352                 }\r
 353 #endif\r
 354 \r
 355                 public override Type ValueType {\r
 356                         get { return typeof (string); }\r
 357                 }\r
 358 \r
 359                 public override object ParseValue (string s,\r
 360                         XmlNameTable nameTable, NSResolver nsmgr)\r
 361                 {\r
 362                         if (!XmlChar.IsNmToken (s))\r
 363                                 throw new ArgumentException ("'" + s + "' is an invalid NMTOKEN.");\r
 364                         return s;\r
 365                 }\r
 366 \r
 367                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 368                 {\r
 369                         return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);\r
 370                 }\r
 371         }\r
 372 \r
 373         // xs:NMTOKENS\r
 374         internal class XsdNMTokens : XsdNMToken\r
 375         {\r
 376                 internal XsdNMTokens ()\r
 377                 {\r
 378                 }\r
 379 \r
 380                 public override XmlTokenizedType TokenizedType {\r
 381                         get { return XmlTokenizedType.NMTOKENS; }\r
 382                 }\r
 383 \r
 384 #if NET_2_0\r
 385                 [MonoTODO]\r
 386                 public override XmlTypeCode TypeCode {\r
 387                         get { return XmlTypeCode.Item; }\r
 388                 }\r
 389 #endif\r
 390 \r
 391                 public override Type ValueType {\r
 392                         get { return typeof (string []); }\r
 393                 }\r
 394 \r
 395                 public override object ParseValue (string value, XmlNameTable nt, NSResolver nsmgr)\r
 396                 {\r
 397                         return GetValidatedArray (value, nt);\r
 398                 }\r
 399 \r
 400                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 401                 {\r
 402                         return new StringArrayValueType (GetValidatedArray (s, nameTable));\r
 403                 }\r
 404 \r
 405                 private string [] GetValidatedArray (string value, XmlNameTable nt)\r
 406                 {\r
 407                         string [] nmtokens = ParseListValue (value, nt);\r
 408                         for (int i = 0; i < nmtokens.Length; i++)\r
 409                                 if (!XmlChar.IsNmToken (nmtokens [i]))\r
 410                                         throw new ArgumentException ("Invalid name token.");\r
 411                         return nmtokens;\r
 412                 }\r
 413         }\r
 414 \r
 415         // xs:Name\r
 416         internal class XsdName : XsdToken\r
 417         {\r
 418                 internal XsdName ()\r
 419                 {\r
 420                 }\r
 421 \r
 422                 public override XmlTokenizedType TokenizedType {\r
 423                         get { return XmlTokenizedType.CDATA; }\r
 424                 }\r
 425 \r
 426 #if NET_2_0\r
 427                 public override XmlTypeCode TypeCode {\r
 428                         get { return XmlTypeCode.Name; }\r
 429                 }\r
 430 #endif\r
 431 \r
 432                 public override Type ValueType {\r
 433                         get { return typeof (string); }\r
 434                 }\r
 435 \r
 436                 public override object ParseValue (string s,\r
 437                         XmlNameTable nameTable, NSResolver nsmgr)\r
 438                 {\r
 439                         if (!XmlChar.IsName (s))\r
 440                                 throw new ArgumentException ("'" + s + "' is an invalid name.");\r
 441                         return s;\r
 442                 }\r
 443 \r
 444                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 445                 {\r
 446                         return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);\r
 447                 }\r
 448         }\r
 449 \r
 450         // xs:NCName\r
 451         internal class XsdNCName : XsdName\r
 452         {\r
 453                 internal XsdNCName ()\r
 454                 {\r
 455                 }\r
 456 \r
 457                 public override XmlTokenizedType TokenizedType {\r
 458                         get { return XmlTokenizedType.NCName; }\r
 459                 }\r
 460 \r
 461 #if NET_2_0\r
 462                 public override XmlTypeCode TypeCode {\r
 463                         get { return XmlTypeCode.NCName; }\r
 464                 }\r
 465 #endif\r
 466 \r
 467                 public override Type ValueType {\r
 468                         get { return typeof (string); }\r
 469                 }\r
 470 \r
 471                 public override object ParseValue (string s,\r
 472                         XmlNameTable nameTable, NSResolver nsmgr)\r
 473                 {\r
 474                         if (!XmlChar.IsNCName (s))\r
 475                                 throw new ArgumentException ("'" + s + "' is an invalid NCName.");\r
 476                         return s;\r
 477                 }\r
 478 \r
 479                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 480                 {\r
 481                         return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);\r
 482                 }\r
 483         }\r
 484 \r
 485         // xs:ID\r
 486         internal class XsdID : XsdName\r
 487         {\r
 488                 internal XsdID ()\r
 489                 {\r
 490                 }\r
 491 \r
 492                 public override XmlTokenizedType TokenizedType {\r
 493                         get { return XmlTokenizedType.ID; }\r
 494                 }\r
 495 \r
 496 #if NET_2_0\r
 497                 public override XmlTypeCode TypeCode {\r
 498                         get { return XmlTypeCode.Id; }\r
 499                 }\r
 500 #endif\r
 501 \r
 502                 public override Type ValueType {\r
 503                         get { return typeof (string); }\r
 504                 }\r
 505 \r
 506                 public override object ParseValue (string s, XmlNameTable nt, NSResolver nsmgr)\r
 507                 {\r
 508                         if (!XmlChar.IsNCName (s))\r
 509                                 throw new ArgumentException ("'" + s + "' is an invalid NCName.");\r
 510                         return s;\r
 511                 }\r
 512         }\r
 513 \r
 514         // xs:IDREF\r
 515         internal class XsdIDRef : XsdName\r
 516         {\r
 517                 internal XsdIDRef ()\r
 518                 {\r
 519                 }\r
 520 \r
 521                 public override XmlTokenizedType TokenizedType {\r
 522                         get { return XmlTokenizedType.IDREF; }\r
 523                 }\r
 524 \r
 525 #if NET_2_0\r
 526                 public override XmlTypeCode TypeCode {\r
 527                         get { return XmlTypeCode.Idref; }\r
 528                 }\r
 529 #endif\r
 530 \r
 531                 public override Type ValueType {\r
 532                         get { return typeof (string); }\r
 533                 }\r
 534 \r
 535                 public override object ParseValue (string s, XmlNameTable nt, NSResolver nsmgr)\r
 536                 {\r
 537                         if (!XmlChar.IsNCName (s))\r
 538                                 throw new ArgumentException ("'" + s + "' is an invalid NCName.");\r
 539                         return s;\r
 540                 }\r
 541         }\r
 542 \r
 543         // xs:IDREFS\r
 544         internal class XsdIDRefs : XsdName\r
 545         {\r
 546                 internal XsdIDRefs ()\r
 547                 {\r
 548                 }\r
 549 \r
 550                 public override XmlTokenizedType TokenizedType {\r
 551                         get { return XmlTokenizedType.IDREFS; }\r
 552                 }\r
 553 \r
 554 #if NET_2_0\r
 555                 [MonoTODO]\r
 556                 public override XmlTypeCode TypeCode {\r
 557                         get { return XmlTypeCode.Item; }\r
 558                 }\r
 559 #endif\r
 560 \r
 561                 public override Type ValueType {\r
 562                         get { return typeof (string []); }\r
 563                 }\r
 564 \r
 565                 public override object ParseValue (string value, XmlNameTable nt, NSResolver nsmgr)\r
 566                 {\r
 567                         return GetValidatedArray (value, nt);\r
 568                 }\r
 569 \r
 570                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 571                 {\r
 572                         return new StringArrayValueType (GetValidatedArray (s, nameTable));\r
 573                 }\r
 574 \r
 575                 private string [] GetValidatedArray (string value, XmlNameTable nt)\r
 576                 {\r
 577                         string [] idrefs = ParseListValue (value, nt);\r
 578                         for (int i = 0; i < idrefs.Length; i++)\r
 579                                 XmlConvert.VerifyNCName (idrefs [i]);\r
 580                         return idrefs;\r
 581                 }\r
 582         }\r
 583 \r
 584         // xs:ENTITY\r
 585         internal class XsdEntity : XsdName\r
 586         {\r
 587                 internal XsdEntity ()\r
 588                 {\r
 589                 }\r
 590 \r
 591                 public override XmlTokenizedType TokenizedType {\r
 592                         get { return XmlTokenizedType.ENTITY; }\r
 593                 }\r
 594 \r
 595 #if NET_2_0\r
 596                 public override XmlTypeCode TypeCode {\r
 597                         get { return XmlTypeCode.Entity; }\r
 598                 }\r
 599 #endif\r
 600 \r
 601                 public override Type ValueType {\r
 602                         get { return typeof (string); }\r
 603                 }\r
 604 \r
 605 \r
 606         }\r
 607 \r
 608 \r
 609         // xs:ENTITIES\r
 610         internal class XsdEntities : XsdName\r
 611         {\r
 612                 internal XsdEntities ()\r
 613                 {\r
 614                 }\r
 615 \r
 616                 public override XmlTokenizedType TokenizedType {\r
 617                         get { return XmlTokenizedType.ENTITIES; }\r
 618                 }\r
 619 \r
 620 #if NET_2_0\r
 621                 [MonoTODO]\r
 622                 public override XmlTypeCode TypeCode {\r
 623                         get { return XmlTypeCode.Item; }\r
 624                 }\r
 625 #endif\r
 626 \r
 627                 public override Type ValueType {\r
 628                         get { return typeof (string []); }\r
 629                 }\r
 630 \r
 631                 public override object ParseValue (string value, XmlNameTable nt, NSResolver nsmgr)\r
 632                 {\r
 633                         return GetValidatedArray (value, nt);\r
 634                 }\r
 635 \r
 636                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 637                 {\r
 638                         return new StringArrayValueType (GetValidatedArray (s, nameTable));\r
 639                 }\r
 640 \r
 641                 private string [] GetValidatedArray (string value, XmlNameTable nt)\r
 642                 {\r
 643                         string [] entities = ParseListValue (value, nt);\r
 644                         for (int i = 0; i < entities.Length; i++)\r
 645                                 if (!XmlChar.IsName (entities [i]))\r
 646                                         throw new ArgumentException ("Invalid entitiy name.");\r
 647                         return entities;\r
 648                 }\r
 649         }\r
 650 \r
 651         // xs:NOTATION\r
 652         internal class XsdNotation : XsdAnySimpleType\r
 653         {\r
 654                 internal XsdNotation ()\r
 655                 {\r
 656                 }\r
 657 \r
 658                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
 659                         get { return stringAllowedFacets; } \r
 660                 }\r
 661 \r
 662                 public override XmlTokenizedType TokenizedType {\r
 663                         get { return XmlTokenizedType.NOTATION; }\r
 664                 }\r
 665 \r
 666 #if NET_2_0\r
 667                 public override XmlTypeCode TypeCode {\r
 668                         get { return XmlTypeCode.Notation; }\r
 669                 }\r
 670 #endif\r
 671 \r
 672                 public override Type ValueType {\r
 673                         get { return typeof (string); }\r
 674                 }\r
 675 \r
 676                 public override object ParseValue (string s,\r
 677                         XmlNameTable nameTable, NSResolver nsmgr)\r
 678                 {\r
 679                         return Normalize (s);\r
 680                 }\r
 681 \r
 682                 // Fundamental Facets\r
 683                 public override bool Bounded {\r
 684                         get { return false; }\r
 685                 }\r
 686                 public override bool Finite {\r
 687                         get { return false; }\r
 688                 }\r
 689                 public override bool Numeric {\r
 690                         get { return false; }\r
 691                 }\r
 692                 public override XsdOrderedFacet Ordered {\r
 693                         get { return XsdOrderedFacet.False; }\r
 694                 }\r
 695 \r
 696         }\r
 697 \r
 698         // xs:decimal\r
 699         internal class XsdDecimal : XsdAnySimpleType\r
 700         {\r
 701                 internal XsdDecimal ()\r
 702                 {\r
 703                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
 704                 }\r
 705 \r
 706                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
 707                         get { return decimalAllowedFacets; } \r
 708                 }\r
 709 \r
 710                 public override XmlTokenizedType TokenizedType {\r
 711                         get { return XmlTokenizedType.None; }\r
 712                 }\r
 713 \r
 714 #if NET_2_0\r
 715                 public override XmlTypeCode TypeCode {\r
 716                         get { return XmlTypeCode.Decimal; }\r
 717                 }\r
 718 #endif\r
 719 \r
 720                 public override Type ValueType {\r
 721                         get { return typeof (decimal); }\r
 722                 }\r
 723 \r
 724                 public override object ParseValue (string s,\r
 725                         XmlNameTable nameTable, NSResolver nsmgr)\r
 726                 {\r
 727                         return ParseValueType (s, nameTable, nsmgr);\r
 728                 }\r
 729 \r
 730                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 731                 {\r
 732                         return XmlConvert.ToDecimal (this.Normalize (s));\r
 733                 }\r
 734          \r
 735                 internal override XsdOrdering Compare(object x, object y) {\r
 736                         if ((x is Decimal) && (y is Decimal)) {\r
 737                                 int ret = Decimal.Compare((Decimal)x, (Decimal)y);\r
 738                                 if (ret < 0) { \r
 739                                         return XsdOrdering.LessThan;\r
 740                                 }\r
 741                                 else if (ret > 0) {\r
 742                                         return XsdOrdering.GreaterThan;\r
 743                                 }\r
 744                                 else {\r
 745                                         return XsdOrdering.Equal;\r
 746                                 }\r
 747                         }\r
 748                         return XsdOrdering.Indeterminate;\r
 749                 }\r
 750                 \r
 751                 // Fundamental Facets\r
 752                 public override bool Bounded {\r
 753                         get { return false; }\r
 754                 }\r
 755                 public override bool Finite {\r
 756                         get { return false; }\r
 757                 }\r
 758                 public override bool Numeric {\r
 759                         get { return true; }\r
 760                 }\r
 761                 public override XsdOrderedFacet Ordered {\r
 762                         get { return XsdOrderedFacet.Total; }\r
 763                 }\r
 764 \r
 765         }\r
 766 \r
 767         // xs:integer\r
 768         internal class XsdInteger : XsdDecimal\r
 769         {\r
 770                 public XsdInteger ()\r
 771                 {\r
 772                 }\r
 773 \r
 774 #if NET_2_0\r
 775                 public override XmlTypeCode TypeCode {\r
 776                         get { return XmlTypeCode.Integer; }\r
 777                 }\r
 778 #endif\r
 779 \r
 780                 // Here it may be bigger than int's (or long's) MaxValue.\r
 781                 public override Type ValueType {\r
 782                         get { return typeof (decimal); }\r
 783                 }\r
 784 \r
 785                 public override object ParseValue (string s,\r
 786                         XmlNameTable nameTable, NSResolver nsmgr)\r
 787                 {\r
 788                         return ParseValueType (s, nameTable, nsmgr);\r
 789                 }\r
 790 \r
 791                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 792                 {\r
 793                         decimal d = XmlConvert.ToDecimal (Normalize (s));\r
 794                         if (Decimal.Floor (d) != d)\r
 795                                 throw new FormatException ("Integer contains point number.");\r
 796                         return d;\r
 797                 }\r
 798          \r
 799                 \r
 800         \r
 801         }\r
 802 \r
 803         // xs:Long\r
 804         internal class XsdLong : XsdInteger\r
 805         {\r
 806 #if NET_2_0\r
 807                 public override XmlTypeCode TypeCode {\r
 808                         get { return XmlTypeCode.Long; }\r
 809                 }\r
 810 #endif\r
 811 \r
 812                 public override Type ValueType {\r
 813                         get { return typeof (long); }\r
 814                 }\r
 815 \r
 816                 public override object ParseValue (string s,\r
 817                         XmlNameTable nameTable, NSResolver nsmgr)\r
 818                 {\r
 819                         return ParseValueType (s, nameTable, nsmgr);\r
 820                 }\r
 821 \r
 822                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 823                 {\r
 824                         return XmlConvert.ToInt64 (Normalize (s));\r
 825                 }\r
 826                 \r
 827                 internal override XsdOrdering Compare(object x, object y) {\r
 828                         if ((x is long) && (y is long)) {\r
 829                                 if ((long)x==(long)y) {\r
 830                                         return XsdOrdering.Equal;\r
 831                                 }\r
 832                                 else if ((long)x<(long)y) {\r
 833                                         return XsdOrdering.LessThan;\r
 834                                 }\r
 835                                 else {\r
 836                                         return XsdOrdering.GreaterThan;\r
 837                                 }\r
 838                         }\r
 839                         return XsdOrdering.Indeterminate;\r
 840                 }\r
 841         }\r
 842 \r
 843         // xs:Int\r
 844         internal class XsdInt : XsdLong\r
 845         {\r
 846 #if NET_2_0\r
 847                 public override XmlTypeCode TypeCode {\r
 848                         get { return XmlTypeCode.Int; }\r
 849                 }\r
 850 #endif\r
 851 \r
 852                 public override Type ValueType {\r
 853                         get { return typeof (int); }\r
 854                 }\r
 855 \r
 856                 public override object ParseValue (string s,\r
 857                         XmlNameTable nameTable, NSResolver nsmgr)\r
 858                 {\r
 859                         return ParseValueType (s, nameTable, nsmgr);\r
 860                 }\r
 861 \r
 862                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 863                 {\r
 864                         return XmlConvert.ToInt32 (Normalize (s));\r
 865                 }\r
 866 \r
 867                 internal override XsdOrdering Compare(object x, object y) {\r
 868                         if ((x is int) && (y is int)) {\r
 869                                 if ((int)x==(int)y) {\r
 870                                         return XsdOrdering.Equal;\r
 871                                 }\r
 872                                 else if ((int)x<(int)y) {\r
 873                                         return XsdOrdering.LessThan;\r
 874                                 }\r
 875                                 else {\r
 876                                         return XsdOrdering.GreaterThan;\r
 877                                 }\r
 878                         }\r
 879                         return XsdOrdering.Indeterminate;\r
 880                 }\r
 881         }\r
 882 \r
 883 \r
 884         // xs:Short\r
 885         internal class XsdShort : XsdInt\r
 886         {\r
 887 #if NET_2_0\r
 888                 public override XmlTypeCode TypeCode {\r
 889                         get { return XmlTypeCode.Short; }\r
 890                 }\r
 891 #endif\r
 892 \r
 893                 public override Type ValueType {\r
 894                         get { return typeof (short); }\r
 895                 }\r
 896 \r
 897                 public override object ParseValue (string s,\r
 898                         XmlNameTable nameTable, NSResolver nsmgr)\r
 899                 {\r
 900                         return ParseValueType (s, nameTable, nsmgr);\r
 901                 }\r
 902 \r
 903                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 904                 {\r
 905                         return XmlConvert.ToInt16 (Normalize (s));\r
 906                 }\r
 907 \r
 908                 internal override XsdOrdering Compare(object x, object y) {\r
 909                         if ((x is short) && (y is short)) {\r
 910                                 if ((short)x==(short)y) {\r
 911                                         return XsdOrdering.Equal;\r
 912                                 }\r
 913                                 else if ((short)x<(short)y) {\r
 914                                         return XsdOrdering.LessThan;\r
 915                                 }\r
 916                                 else {\r
 917                                         return XsdOrdering.GreaterThan;\r
 918                                 }\r
 919                         }\r
 920                         return XsdOrdering.Indeterminate;\r
 921                 }\r
 922         }\r
 923 \r
 924         // xs:Byte\r
 925         internal class XsdByte : XsdShort\r
 926         {\r
 927 #if NET_2_0\r
 928                 public override XmlTypeCode TypeCode {\r
 929                         get { return XmlTypeCode.Byte; }\r
 930                 }\r
 931 #endif\r
 932 \r
 933                 public override Type ValueType {\r
 934                         get { return typeof (sbyte); }\r
 935                 }\r
 936 \r
 937                 public override object ParseValue (string s,\r
 938                         XmlNameTable nameTable, NSResolver nsmgr)\r
 939                 {\r
 940                         return ParseValueType (s, nameTable, nsmgr);\r
 941                 }\r
 942 \r
 943                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 944                 {\r
 945                         return XmlConvert.ToSByte (Normalize (s));\r
 946                 }\r
 947 \r
 948                 internal override XsdOrdering Compare(object x, object y) {\r
 949                         if ((x is sbyte) && (y is sbyte)) {\r
 950                                 if ((sbyte)x==(sbyte)y) {\r
 951                                         return XsdOrdering.Equal;\r
 952                                 }\r
 953                                 else if ((sbyte)x<(sbyte)y) {\r
 954                                         return XsdOrdering.LessThan;\r
 955                                 }\r
 956                                 else {\r
 957                                         return XsdOrdering.GreaterThan;\r
 958                                 }\r
 959                         }\r
 960                         return XsdOrdering.Indeterminate;\r
 961                 }\r
 962         }\r
 963 \r
 964         // xs:nonNegativeInteger\r
 965 //      [CLSCompliant (false)]\r
 966         internal class XsdNonNegativeInteger : XsdInteger\r
 967         {\r
 968 #if NET_2_0\r
 969                 public override XmlTypeCode TypeCode {\r
 970                         get { return XmlTypeCode.NonNegativeInteger; }\r
 971                 }\r
 972 #endif\r
 973 \r
 974                 public override Type ValueType {\r
 975                         get { return typeof (decimal); }\r
 976                 }\r
 977 \r
 978 //              [CLSCompliant (false)]\r
 979                 public override object ParseValue (string s,\r
 980                         XmlNameTable nameTable, NSResolver nsmgr)\r
 981                 {\r
 982                         return ParseValueType (s, nameTable, nsmgr);\r
 983                 }\r
 984 \r
 985                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
 986                 {\r
 987                         return XmlConvert.ToDecimal (Normalize (s));\r
 988                 }\r
 989         }\r
 990 \r
 991         // xs:unsignedLong\r
 992 //      [CLSCompliant (false)]\r
 993         internal class XsdUnsignedLong : XsdNonNegativeInteger\r
 994         {\r
 995 #if NET_2_0\r
 996                 public override XmlTypeCode TypeCode {\r
 997                         get { return XmlTypeCode.UnsignedLong; }\r
 998                 }\r
 999 #endif\r
1000 \r
1001                 public override Type ValueType {\r
1002                         get { return typeof (ulong); }\r
1003                 }\r
1004 \r
1005                 public override object ParseValue (string s,\r
1006                         XmlNameTable nameTable, NSResolver nsmgr)\r
1007                 {\r
1008                         return ParseValueType (s, nameTable, nsmgr);\r
1009                 }\r
1010 \r
1011                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1012                 {\r
1013                         return XmlConvert.ToUInt64 (Normalize (s));\r
1014                 }\r
1015 \r
1016                 internal override XsdOrdering Compare(object x, object y) {\r
1017                         if ((x is ulong) && (y is ulong)) {\r
1018                                 if ((ulong)x==(ulong)y) {\r
1019                                         return XsdOrdering.Equal;\r
1020                                 }\r
1021                                 else if ((ulong)x<(ulong)y) {\r
1022                                         return XsdOrdering.LessThan;\r
1023                                 }\r
1024                                 else {\r
1025                                         return XsdOrdering.GreaterThan;\r
1026                                 }\r
1027                         }\r
1028                         return XsdOrdering.Indeterminate;\r
1029                 }\r
1030         }\r
1031 \r
1032         // xs:unsignedInt\r
1033 //      [CLSCompliant (false)]\r
1034         internal class XsdUnsignedInt : XsdUnsignedLong\r
1035         {\r
1036 #if NET_2_0\r
1037                 public override XmlTypeCode TypeCode {\r
1038                         get { return XmlTypeCode.UnsignedInt; }\r
1039                 }\r
1040 #endif\r
1041 \r
1042                 public override Type ValueType {\r
1043                         get { return typeof (uint); }\r
1044                 }\r
1045 \r
1046                 public override object ParseValue (string s,\r
1047                         XmlNameTable nameTable, NSResolver nsmgr)\r
1048                 {\r
1049                         return ParseValueType (s, nameTable, nsmgr);\r
1050                 }\r
1051 \r
1052                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1053                 {\r
1054                         return XmlConvert.ToUInt32 (Normalize (s));\r
1055                 }\r
1056 \r
1057                 internal override XsdOrdering Compare(object x, object y) {\r
1058                         if ((x is uint) && (y is uint)) {\r
1059                                 if ((uint)x==(uint)y) {\r
1060                                         return XsdOrdering.Equal;\r
1061                                 }\r
1062                                 else if ((uint)x<(uint)y) {\r
1063                                         return XsdOrdering.LessThan;\r
1064                                 }\r
1065                                 else {\r
1066                                         return XsdOrdering.GreaterThan;\r
1067                                 }\r
1068                         }\r
1069                         return XsdOrdering.Indeterminate;\r
1070                 }\r
1071         }\r
1072 \r
1073 \r
1074         // xs:unsignedShort\r
1075 //      [CLSCompliant (false)]\r
1076         internal class XsdUnsignedShort : XsdUnsignedInt\r
1077         {\r
1078 #if NET_2_0\r
1079                 public override XmlTypeCode TypeCode {\r
1080                         get { return XmlTypeCode.UnsignedShort; }\r
1081                 }\r
1082 #endif\r
1083 \r
1084                 public override Type ValueType {\r
1085                         get { return typeof (ushort); }\r
1086                 }\r
1087 \r
1088                 public override object ParseValue (string s,\r
1089                         XmlNameTable nameTable, NSResolver nsmgr)\r
1090                 {\r
1091                         return ParseValueType (s, nameTable, nsmgr);\r
1092                 }\r
1093 \r
1094                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1095                 {\r
1096                         return XmlConvert.ToUInt16 (Normalize (s));\r
1097                 }\r
1098 \r
1099                 internal override XsdOrdering Compare(object x, object y) {\r
1100                         if ((x is ushort) && (y is ushort)) {\r
1101                                 if ((ushort)x==(ushort)y) {\r
1102                                         return XsdOrdering.Equal;\r
1103                                 }\r
1104                                 else if ((ushort)x<(ushort)y) {\r
1105                                         return XsdOrdering.LessThan;\r
1106                                 }\r
1107                                 else {\r
1108                                         return XsdOrdering.GreaterThan;\r
1109                                 }\r
1110                         }\r
1111                         return XsdOrdering.Indeterminate;\r
1112                 }\r
1113         }\r
1114 \r
1115         // xs:unsignedByte\r
1116 //      [CLSCompliant (false)]\r
1117         internal class XsdUnsignedByte : XsdUnsignedShort\r
1118         {\r
1119 #if NET_2_0\r
1120                 public override XmlTypeCode TypeCode {\r
1121                         get { return XmlTypeCode.UnsignedByte; }\r
1122                 }\r
1123 #endif\r
1124 \r
1125                 public override Type ValueType {\r
1126                         get { return typeof (byte); }\r
1127                 }\r
1128 \r
1129                 public override object ParseValue (string s,\r
1130                         XmlNameTable nameTable, NSResolver nsmgr)\r
1131                 {\r
1132                         return ParseValueType (s, nameTable, nsmgr);\r
1133                 }\r
1134 \r
1135                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1136                 {\r
1137                         return XmlConvert.ToByte(Normalize (s));\r
1138                 }\r
1139 \r
1140                 internal override XsdOrdering Compare(object x, object y) {\r
1141                         if ((x is byte) && (y is byte)) {\r
1142                                 if ((byte)x==(byte)y) {\r
1143                                         return XsdOrdering.Equal;\r
1144                                 }\r
1145                                 else if ((byte)x<(byte)y) {\r
1146                                         return XsdOrdering.LessThan;\r
1147                                 }\r
1148                                 else {\r
1149                                         return XsdOrdering.GreaterThan;\r
1150                                 }\r
1151                         }\r
1152                         return XsdOrdering.Indeterminate;\r
1153                 }\r
1154         }\r
1155 \r
1156 \r
1157         // xs:positiveInteger\r
1158 //      [CLSCompliant (false)]\r
1159         internal class XsdPositiveInteger : XsdNonNegativeInteger\r
1160         {\r
1161 #if NET_2_0\r
1162                 public override XmlTypeCode TypeCode {\r
1163                         get { return XmlTypeCode.PositiveInteger; }\r
1164                 }\r
1165 #endif\r
1166 \r
1167                 // It returns decimal, instead of int or long.\r
1168                 // Maybe MS developers thought about big integer...\r
1169                 public override Type ValueType {\r
1170                         get { return typeof (decimal); }\r
1171                 }\r
1172 \r
1173                 public override object ParseValue (string s,\r
1174                         XmlNameTable nameTable, NSResolver nsmgr)\r
1175                 {\r
1176                         return ParseValueType (s, nameTable, nsmgr);\r
1177                 }\r
1178 \r
1179                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1180                 {\r
1181                         return XmlConvert.ToDecimal (Normalize (s));\r
1182                 }\r
1183         }\r
1184 \r
1185         // xs:nonPositiveInteger\r
1186         internal class XsdNonPositiveInteger : XsdInteger\r
1187         {\r
1188 #if NET_2_0\r
1189                 public override XmlTypeCode TypeCode {\r
1190                         get { return XmlTypeCode.NonPositiveInteger; }\r
1191                 }\r
1192 #endif\r
1193 \r
1194                 public override Type ValueType {\r
1195                         get { return typeof (decimal); }\r
1196                 }\r
1197 \r
1198                 public override object ParseValue (string s,\r
1199                         XmlNameTable nameTable, NSResolver nsmgr)\r
1200                 {\r
1201                         return ParseValueType (s, nameTable, nsmgr);\r
1202                 }\r
1203 \r
1204                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1205                 {\r
1206                         return XmlConvert.ToDecimal (Normalize (s));\r
1207                 }\r
1208         }\r
1209 \r
1210         // xs:negativeInteger\r
1211         internal class XsdNegativeInteger : XsdNonPositiveInteger\r
1212         {\r
1213 #if NET_2_0\r
1214                 public override XmlTypeCode TypeCode {\r
1215                         get { return XmlTypeCode.NegativeInteger; }\r
1216                 }\r
1217 #endif\r
1218 \r
1219                 public override Type ValueType {\r
1220 \r
1221                         get { return typeof (decimal); }\r
1222                 }\r
1223 \r
1224                 public override object ParseValue (string s,\r
1225                         XmlNameTable nameTable, NSResolver nsmgr)\r
1226                 {\r
1227                         return ParseValueType (s, nameTable, nsmgr);\r
1228                 }\r
1229 \r
1230                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1231                 {\r
1232                         return XmlConvert.ToDecimal (Normalize (s));\r
1233                 }\r
1234         }\r
1235 \r
1236         // xs:float\r
1237         internal class XsdFloat : XsdAnySimpleType\r
1238         {\r
1239 #if NET_2_0\r
1240                 public override XmlTypeCode TypeCode {\r
1241                         get { return XmlTypeCode.Float; }\r
1242                 }\r
1243 #endif\r
1244 \r
1245                 internal XsdFloat ()\r
1246                 {\r
1247                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
1248                 }\r
1249     \r
1250                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
1251                         get { return durationAllowedFacets; } \r
1252                 }\r
1253                 \r
1254                 // Fundamental Facets\r
1255                 public override bool Bounded {\r
1256                         get { return true; }\r
1257                 }\r
1258                 public override bool Finite {\r
1259                         get { return true; }\r
1260                 }\r
1261                 public override bool Numeric {\r
1262                         get { return true; }\r
1263                 }\r
1264                 public override XsdOrderedFacet Ordered {\r
1265                         get { return XsdOrderedFacet.Total; }\r
1266                 }\r
1267 \r
1268                 public override Type ValueType {\r
1269                         get { return typeof (float); }\r
1270                 }\r
1271 \r
1272                 public override object ParseValue (string s,\r
1273                         XmlNameTable nameTable, NSResolver nsmgr)\r
1274                 {\r
1275                         return ParseValueType (s, nameTable, nsmgr);\r
1276                 }\r
1277 \r
1278                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1279                 {\r
1280                         return XmlConvert.ToSingle (Normalize (s));\r
1281                 }\r
1282 \r
1283                 internal override XsdOrdering Compare(object x, object y) {\r
1284                         if ((x is float) && (y is float)) {\r
1285                                 if ((float)x==(float)y) {\r
1286                                         return XsdOrdering.Equal;\r
1287                                 }\r
1288                                 else if ((float)x<(float)y) {\r
1289                                         return XsdOrdering.LessThan;\r
1290                                 }\r
1291                                 else {\r
1292                                         return XsdOrdering.GreaterThan;\r
1293                                 }\r
1294                 }\r
1295                         return XsdOrdering.Indeterminate;\r
1296                 }\r
1297                 \r
1298         }\r
1299 \r
1300         // xs:double\r
1301         internal class XsdDouble : XsdAnySimpleType\r
1302         {\r
1303                 internal XsdDouble ()\r
1304                 {\r
1305                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
1306                 }\r
1307     \r
1308                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
1309                         get { return durationAllowedFacets; } \r
1310                 }\r
1311                 \r
1312                 // Fundamental Facets\r
1313                 public override bool Bounded {\r
1314                         get { return true; }\r
1315                 }\r
1316                 public override bool Finite {\r
1317                         get { return true; }\r
1318                 }\r
1319                 public override bool Numeric {\r
1320                         get { return true; }\r
1321                 }\r
1322                 public override XsdOrderedFacet Ordered {\r
1323                         get { return XsdOrderedFacet.Total; }\r
1324                 }\r
1325 \r
1326 #if NET_2_0\r
1327                 public override XmlTypeCode TypeCode {\r
1328                         get { return XmlTypeCode.Double; }\r
1329                 }\r
1330 #endif\r
1331 \r
1332                 public override Type ValueType {\r
1333                         get { return typeof (double); }\r
1334                 }\r
1335 \r
1336                 public override object ParseValue (string s,\r
1337                         XmlNameTable nameTable, NSResolver nsmgr)\r
1338                 {\r
1339                         return ParseValueType (s, nameTable, nsmgr);\r
1340                 }\r
1341 \r
1342                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1343                 {\r
1344                         return XmlConvert.ToDouble (Normalize (s));\r
1345                 }\r
1346 \r
1347                 internal override XsdOrdering Compare(object x, object y) {\r
1348                         if ((x is double) && (y is double)) {\r
1349                                 if ((double)x==(double)y) {\r
1350                                         return XsdOrdering.Equal;\r
1351                                 }\r
1352                                 else if ((double)x<(double)y) {\r
1353                                         return XsdOrdering.LessThan;\r
1354                 }\r
1355                                 else {\r
1356                                         return XsdOrdering.GreaterThan;\r
1357                                 }\r
1358                         }\r
1359                         return XsdOrdering.Indeterminate;\r
1360                 }\r
1361                 \r
1362         }\r
1363 \r
1364         // xs:base64Binary\r
1365         internal class XsdBase64Binary : XsdString\r
1366         {\r
1367                 internal XsdBase64Binary ()\r
1368                 {\r
1369                 }\r
1370 \r
1371 #if NET_2_0\r
1372                 public override XmlTypeCode TypeCode {\r
1373                         get { return XmlTypeCode.Base64Binary; }\r
1374                 }\r
1375 #endif\r
1376 \r
1377                 public override Type ValueType {\r
1378                         get { return typeof (byte[]); }\r
1379                 }\r
1380 \r
1381                 public override object ParseValue (string s,\r
1382                         XmlNameTable nameTable, NSResolver nsmgr)\r
1383                 {\r
1384                         // If it isnt ASCII it isnt valid base64 data\r
1385                         byte[] inArr = new System.Text.ASCIIEncoding().GetBytes(s);\r
1386                         FromBase64Transform t = new FromBase64Transform();\r
1387                         return t.TransformFinalBlock(inArr, 0, inArr.Length);\r
1388                 }\r
1389 \r
1390 \r
1391                 internal override int Length(string s) {\r
1392                         int length = 0;\r
1393                         int pad = 0;\r
1394                         int end = s.Length;\r
1395                         for (int i = 0; i < end; i++) {\r
1396                           char c = s[i];\r
1397                                 if (!Char.IsWhiteSpace(c)) {\r
1398                                         if (isData(c))\r
1399                                                 length ++;\r
1400                                         else if (isPad(c)) \r
1401                                                 pad++;                                  \r
1402                                         else \r
1403                                           return -1;   // Invalid characters\r
1404                                 }       \r
1405                         }\r
1406                         if (pad > 2) \r
1407                           return -1; // Max 2 padding at the end.\r
1408                         if (pad > 0) \r
1409                           pad = 3-pad;                          \r
1410                         \r
1411                   return ((length/4)*3)+pad;\r
1412                 }       \r
1413 \r
1414 /* TODO: Use the Base64Table and similar code when it makes it \r
1415  * out of System.Security.Cryptography (currently internal so I \r
1416  * don't think we can use it).\r
1417  * \r
1418  */\r
1419                         private static string ALPHABET =\r
1420                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";\r
1421 \r
1422                         private static byte[] decodeTable;\r
1423                         static XsdBase64Binary ()\r
1424                         {\r
1425                                 int len = ALPHABET.Length;\r
1426 \r
1427                                 decodeTable = new byte [1 + (int)'z'];\r
1428 \r
1429                                 for (int i=0; i < decodeTable.Length; i++) {\r
1430                                         decodeTable [i] = Byte.MaxValue;\r
1431                                 }\r
1432 \r
1433                                 for (int i=0; i < len; i++) {\r
1434                                         char ch = ALPHABET [i];\r
1435                                         decodeTable [(int)ch] = (byte) i;\r
1436                                 }\r
1437                         }\r
1438         \r
1439                 protected static bool isPad(char octect) {\r
1440                         return (octect == '=');\r
1441                 }\r
1442                                                                                         \r
1443                 protected static bool isData(char octect) {\r
1444                         return ((octect <= 'z') && (decodeTable[octect] != Byte.MaxValue));\r
1445                 }\r
1446 \r
1447 \r
1448                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1449                 {\r
1450                         return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);\r
1451                 }\r
1452         }\r
1453 \r
1454         \r
1455         // xs:hexBinary\r
1456         internal class XsdHexBinary : XsdAnySimpleType\r
1457         {\r
1458                 internal XsdHexBinary ()\r
1459                 {\r
1460                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
1461                 }\r
1462 \r
1463                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
1464                         get { return stringAllowedFacets; } \r
1465                 }\r
1466 \r
1467 #if NET_2_0\r
1468                 public override XmlTypeCode TypeCode {\r
1469                         get { return XmlTypeCode.HexBinary; }\r
1470                 }\r
1471 #endif\r
1472 \r
1473                 public override XmlTokenizedType TokenizedType {\r
1474                         get { return XmlTokenizedType.None; }\r
1475                 }\r
1476 \r
1477                 public override Type ValueType {\r
1478                         get { return typeof (byte []); }\r
1479                 }\r
1480 \r
1481                 public override object ParseValue (string s,\r
1482                         XmlNameTable nameTable, NSResolver nsmgr)\r
1483                 {\r
1484                         return XmlConvert.FromBinHexString (Normalize (s));\r
1485                 }\r
1486                 \r
1487                 internal override int Length(string s) {\r
1488                   return s.Length / 2 + s.Length % 2 ;   // Not sure if odd lengths are even allowed\r
1489     }\r
1490 \r
1491                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1492                 {\r
1493                         return new StringValueType (ParseValue (s, nameTable, nsmgr) as string);\r
1494                 }\r
1495 \r
1496                 // Fundamental Facets ... no need to override\r
1497         }\r
1498 \r
1499         // xs:QName\r
1500         internal class XsdQName : XsdName\r
1501         {\r
1502                 internal XsdQName ()\r
1503                 {\r
1504                 }\r
1505 \r
1506                 // Fundamental facets are the same as anySimpleType.\r
1507 \r
1508                 public override XmlTokenizedType TokenizedType {\r
1509                         get { return XmlTokenizedType.QName; }\r
1510                 }\r
1511 \r
1512 #if NET_2_0\r
1513                 public override XmlTypeCode TypeCode {\r
1514                         get { return XmlTypeCode.QName; }\r
1515                 }\r
1516 #endif\r
1517 \r
1518                 public override Type ValueType {\r
1519                         get { return typeof (XmlQualifiedName); }\r
1520                 }\r
1521 \r
1522                 // ParseValue () method is as same as that of xs:string\r
1523                 public override object ParseValue (string s,\r
1524                         XmlNameTable nameTable, NSResolver nsmgr)\r
1525                 {\r
1526                         if (nameTable == null)\r
1527                                 throw new ArgumentNullException ("name table");\r
1528                         if (nsmgr == null)\r
1529                                 throw new ArgumentNullException ("namespace manager");\r
1530                         XmlQualifiedName name = XmlQualifiedName.Parse (s, nsmgr);\r
1531                         nameTable.Add (name.Name);\r
1532                         nameTable.Add (name.Namespace);\r
1533                         return name;\r
1534                 }\r
1535 \r
1536                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1537                 {\r
1538                         return new QNameValueType (ParseValue (s, nameTable, nsmgr) as XmlQualifiedName);\r
1539                 }\r
1540         }\r
1541 \r
1542         // xs:boolean\r
1543         internal class XsdBoolean : XsdAnySimpleType\r
1544         {\r
1545                 internal XsdBoolean ()\r
1546                 {\r
1547                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
1548                 }\r
1549 \r
1550                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
1551                         get { return booleanAllowedFacets; } \r
1552                 }\r
1553 \r
1554                 public override XmlTokenizedType TokenizedType {\r
1555 #if BUGGY_MS_COMPLIANT\r
1556                         get { return XmlTokenizedType.None; }\r
1557 #else\r
1558                         get { return XmlTokenizedType.CDATA; }\r
1559 #endif\r
1560                 }\r
1561 \r
1562 #if NET_2_0\r
1563                 public override XmlTypeCode TypeCode {\r
1564                         get { return XmlTypeCode.Boolean; }\r
1565                 }\r
1566 #endif\r
1567 \r
1568                 public override Type ValueType {\r
1569                         get { return typeof (bool); }\r
1570                 }\r
1571 \r
1572                 public override object ParseValue (string s,\r
1573                         XmlNameTable nameTable, NSResolver nsmgr)\r
1574                 {\r
1575                         return ParseValueType (s, nameTable, nsmgr);\r
1576                 }\r
1577 \r
1578                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1579                 {\r
1580                         return XmlConvert.ToBoolean (this.Normalize (s));\r
1581                 }\r
1582 \r
1583                 // Fundamental Facets\r
1584                 public override bool Bounded {\r
1585                         get { return false; }\r
1586                 }\r
1587                 public override bool Finite {\r
1588                         get { return true; }\r
1589                 }\r
1590                 public override bool Numeric {\r
1591                         get { return false; }\r
1592                 }\r
1593                 public override XsdOrderedFacet Ordered {\r
1594                         get { return XsdOrderedFacet.Total; }\r
1595                 }\r
1596                 \r
1597                 \r
1598         }\r
1599 \r
1600         // xs:anyURI\r
1601         internal class XsdAnyURI : XsdString\r
1602         {\r
1603                 public override XmlTokenizedType TokenizedType {\r
1604 \r
1605                         get { return XmlTokenizedType.CDATA; }\r
1606                 }\r
1607 \r
1608 #if NET_2_0\r
1609                 public override XmlTypeCode TypeCode {\r
1610                         get { return XmlTypeCode.AnyUri; }\r
1611                 }\r
1612 #endif\r
1613 \r
1614                 public override Type ValueType {\r
1615                         get { return typeof (Uri); }\r
1616                 }\r
1617 \r
1618                 public override object ParseValue (string s,\r
1619                         XmlNameTable nameTable, NSResolver nsmgr)\r
1620                 {\r
1621                         return new XmlSchemaUri (Normalize (s));\r
1622                 }\r
1623 \r
1624                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1625                 {\r
1626                         return new UriValueType ((XmlSchemaUri) ParseValue (s, nameTable, nsmgr));\r
1627                 }\r
1628         }\r
1629 \r
1630         internal class XmlSchemaUri : Uri\r
1631         {\r
1632                 public string value;\r
1633 \r
1634                 // LAMESPEC: In this way, some strings that contain ':' might\r
1635                 // result in exception (MS.NET looks implemented as such).\r
1636                 public XmlSchemaUri (string src)\r
1637                         : this (src, src.IndexOf (':') > 0)\r
1638                 {\r
1639                 }\r
1640 \r
1641                 private XmlSchemaUri (string src, bool formal)\r
1642                         : base (formal ? src : "anyuri:" + src, !formal)\r
1643                 {\r
1644                         value = src;\r
1645                 }\r
1646 \r
1647                 public static bool operator == (XmlSchemaUri v1, XmlSchemaUri v2)\r
1648                 {\r
1649                         return v1.value == v2.value;\r
1650                 }\r
1651 \r
1652                 public static bool operator != (XmlSchemaUri v1, XmlSchemaUri v2)\r
1653                 {\r
1654                         return v1.value != v2.value;\r
1655                 }\r
1656 \r
1657                 public override bool Equals (object obj)\r
1658                 {\r
1659                         if (obj is XmlSchemaUri)\r
1660                                 return (XmlSchemaUri) obj == this;\r
1661                         else\r
1662                                 return false;\r
1663                 }\r
1664 \r
1665                 public override int GetHashCode () \r
1666                 {\r
1667                         return value.GetHashCode ();\r
1668                 }\r
1669 \r
1670                 public override string ToString ()\r
1671                 {\r
1672                         return value;\r
1673                 }\r
1674         }\r
1675 \r
1676         // xs:duration\r
1677         internal class XsdDuration : XsdAnySimpleType\r
1678         {\r
1679                 internal XsdDuration ()\r
1680                 {\r
1681       this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
1682                 }\r
1683 \r
1684                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
1685                         get { return durationAllowedFacets; } \r
1686                 }\r
1687 \r
1688                 public override XmlTokenizedType TokenizedType {\r
1689                         get { return XmlTokenizedType.CDATA; }\r
1690                 }\r
1691 \r
1692 #if NET_2_0\r
1693                 public override XmlTypeCode TypeCode {\r
1694                         get { return XmlTypeCode.Duration; }\r
1695                 }\r
1696 #endif\r
1697 \r
1698                 public override Type ValueType {\r
1699                         get { return typeof (TimeSpan); }\r
1700                 }\r
1701 \r
1702                 public override object ParseValue (string s,\r
1703                         XmlNameTable nameTable, NSResolver nsmgr)\r
1704                 {\r
1705                         return ParseValueType (s, nameTable, nsmgr);\r
1706                 }\r
1707 \r
1708                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1709                 {\r
1710                         return XmlConvert.ToTimeSpan (Normalize (s));\r
1711                 }\r
1712 \r
1713                 internal override XsdOrdering Compare(object x, object y) {\r
1714                         /* FIXME: This is really simple so far \r
1715                          *\r
1716                          * In fact in order to do this correctly in XmlSchema, we cannot use TimeSpan as the base type\r
1717                          * Though it turns out that MS .NET is a little broken in this regard too. Not doing comparisons \r
1718                          * correctly.\r
1719                          */\r
1720                         if ((x is TimeSpan) && (y is TimeSpan)) {\r
1721                                 int ret = TimeSpan.Compare((TimeSpan)x, (TimeSpan)y);\r
1722                                 if (ret < 0) { \r
1723                                         return XsdOrdering.LessThan;\r
1724                                 }\r
1725                                 else if (ret > 0) {\r
1726                                         return XsdOrdering.GreaterThan;\r
1727                                 }\r
1728                                 else {\r
1729                                         return XsdOrdering.Equal;\r
1730                                 }\r
1731                         }\r
1732                         return XsdOrdering.Indeterminate;\r
1733                 }\r
1734 \r
1735                 \r
1736                 // Fundamental Facets\r
1737                 public override bool Bounded {\r
1738                         get { return false; }\r
1739                 }\r
1740                 public override bool Finite {\r
1741                         get { return false; }\r
1742                 }\r
1743                 public override bool Numeric {\r
1744                         get { return false; }\r
1745                 }\r
1746                 public override XsdOrderedFacet Ordered {\r
1747                         get { return XsdOrderedFacet.Partial; }\r
1748          \r
1749                 }\r
1750         }\r
1751 \r
1752 #if NET_2_0\r
1753         // xdt:dayTimeDuration\r
1754         internal class XdtDayTimeDuration : XsdDuration\r
1755         {\r
1756                 internal XdtDayTimeDuration ()\r
1757                 {\r
1758                 }\r
1759 \r
1760                 public override XmlTypeCode TypeCode {\r
1761                         get { return XmlTypeCode.DayTimeDuration; }\r
1762                 }\r
1763 \r
1764                 public override Type ValueType {\r
1765                         get { return typeof (TimeSpan); }\r
1766                 }\r
1767 \r
1768                 public override object ParseValue (string s,\r
1769                         XmlNameTable nameTable, NSResolver nsmgr)\r
1770                 {\r
1771                         return ParseValueType (s, nameTable, nsmgr);\r
1772                 }\r
1773 \r
1774                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1775                 {\r
1776                         return XmlConvert.ToTimeSpan (Normalize (s));\r
1777                 }\r
1778 \r
1779                 // FIXME: Fundamental Facets\r
1780                 public override bool Bounded {\r
1781                         get { return false; }\r
1782                 }\r
1783                 public override bool Finite {\r
1784                         get { return false; }\r
1785                 }\r
1786                 public override bool Numeric {\r
1787                         get { return false; }\r
1788                 }\r
1789                 public override XsdOrderedFacet Ordered {\r
1790                         get { return XsdOrderedFacet.Partial; }\r
1791          \r
1792                 }\r
1793         }\r
1794 \r
1795         // xdt:yearMonthDuration\r
1796         internal class XdtYearMonthDuration : XsdDuration\r
1797         {\r
1798                 internal XdtYearMonthDuration ()\r
1799                 {\r
1800                 }\r
1801 \r
1802                 public override XmlTypeCode TypeCode {\r
1803                         get { return XmlTypeCode.YearMonthDuration; }\r
1804                 }\r
1805 \r
1806                 public override Type ValueType {\r
1807                         get { return typeof (TimeSpan); }\r
1808                 }\r
1809 \r
1810                 public override object ParseValue (string s,\r
1811                         XmlNameTable nameTable, NSResolver nsmgr)\r
1812                 {\r
1813                         return ParseValueType (s, nameTable, nsmgr);\r
1814                 }\r
1815 \r
1816                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1817                 {\r
1818                         return XmlConvert.ToTimeSpan (Normalize (s));\r
1819                 }\r
1820 \r
1821                 // FIXME: Fundamental Facets\r
1822                 public override bool Bounded {\r
1823                         get { return false; }\r
1824                 }\r
1825                 public override bool Finite {\r
1826                         get { return false; }\r
1827                 }\r
1828                 public override bool Numeric {\r
1829                         get { return false; }\r
1830                 }\r
1831                 public override XsdOrderedFacet Ordered {\r
1832                         get { return XsdOrderedFacet.Partial; }\r
1833          \r
1834                 }\r
1835         }\r
1836 #endif\r
1837 \r
1838         // xs:dateTime\r
1839         internal class XsdDateTime : XsdAnySimpleType\r
1840         {\r
1841                 internal XsdDateTime ()\r
1842                 {\r
1843                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
1844                 }\r
1845 \r
1846                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
1847                         get { return durationAllowedFacets; } \r
1848                 }\r
1849 \r
1850                 public override XmlTokenizedType TokenizedType {\r
1851                         get { return XmlTokenizedType.CDATA; }\r
1852                 }\r
1853 \r
1854 #if NET_2_0\r
1855                 public override XmlTypeCode TypeCode {\r
1856                         get { return XmlTypeCode.DateTime; }\r
1857                 }\r
1858 #endif\r
1859 \r
1860                 public override Type ValueType {\r
1861                         get { return typeof (DateTime); }\r
1862                 }\r
1863 \r
1864                 public override object ParseValue (string s,\r
1865                         XmlNameTable nameTable, NSResolver nsmgr)\r
1866                 {\r
1867                         return ParseValueType (s, nameTable, nsmgr);\r
1868                 }\r
1869 \r
1870                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1871                 {\r
1872                         return XmlConvert.ToDateTime (Normalize (s));\r
1873                 }\r
1874 \r
1875                 internal override XsdOrdering Compare(object x, object y) {\r
1876                         /* Really simple so far */\r
1877                         if ((x is DateTime) && (y is DateTime)) {\r
1878                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);\r
1879                                 if (ret < 0) { \r
1880                                         return XsdOrdering.LessThan;\r
1881                                 }\r
1882                                 else if (ret > 0) {\r
1883                                         return XsdOrdering.GreaterThan;\r
1884                                 }\r
1885                                 else {\r
1886                                         return XsdOrdering.Equal;\r
1887                                 }\r
1888                         }\r
1889                         return XsdOrdering.Indeterminate;\r
1890                 }\r
1891 \r
1892                 // Fundamental Facets\r
1893                 public override bool Bounded {\r
1894                         get { return false; }\r
1895                 }\r
1896                 public override bool Finite {\r
1897                         get { return false; }\r
1898                 }\r
1899                 public override bool Numeric {\r
1900                         get { return false; }\r
1901                 }\r
1902                 public override XsdOrderedFacet Ordered {\r
1903                         get { return XsdOrderedFacet.Partial; }\r
1904                 }\r
1905                 \r
1906         }\r
1907 \r
1908         // xs:date\r
1909         internal class XsdDate : XsdAnySimpleType\r
1910         {\r
1911                 internal XsdDate ()\r
1912                 {\r
1913                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
1914                 }\r
1915     \r
1916                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
1917                         get { return durationAllowedFacets; } \r
1918                 }\r
1919                 \r
1920                 public override XmlTokenizedType TokenizedType {\r
1921                         get { return XmlTokenizedType.CDATA; }\r
1922                 }\r
1923 \r
1924 #if NET_2_0\r
1925                 public override XmlTypeCode TypeCode {\r
1926                         get { return XmlTypeCode.Date; }\r
1927                 }\r
1928 #endif\r
1929 \r
1930                 public override Type ValueType {\r
1931                         get { return typeof (DateTime); }\r
1932                 }\r
1933 \r
1934                 public override object ParseValue (string s,\r
1935                         XmlNameTable nameTable, NSResolver nsmgr)\r
1936                 {\r
1937                         return ParseValueType (s, nameTable, nsmgr);\r
1938                 }\r
1939 \r
1940                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
1941                 {\r
1942                         return DateTime.ParseExact (Normalize (s), "yyyy-MM-dd", null);\r
1943                 }\r
1944 \r
1945                 internal override XsdOrdering Compare(object x, object y) {\r
1946                         /* Really simple so far */\r
1947                         if ((x is DateTime) && (y is DateTime)) {\r
1948                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);\r
1949                                 if (ret < 0) { \r
1950                                         return XsdOrdering.LessThan;\r
1951                                 }\r
1952                                 else if (ret > 0) {\r
1953                                         return XsdOrdering.GreaterThan;\r
1954                                 }\r
1955                                 else {\r
1956                                         return XsdOrdering.Equal;\r
1957                                 }\r
1958                         }\r
1959                         return XsdOrdering.Indeterminate;\r
1960                 }\r
1961                 // Fundamental Facets ... no need to override except for Ordered.\r
1962                 public override XsdOrderedFacet Ordered {\r
1963                         get { return XsdOrderedFacet.Partial; }\r
1964                 }\r
1965                 \r
1966         }\r
1967 \r
1968         // xs:time\r
1969         internal class XsdTime : XsdAnySimpleType\r
1970         {\r
1971                 static string [] timeFormats = new string [] {\r
1972                           // copied from XmlConvert.\r
1973                           "HH:mm:ss",\r
1974                           "HH:mm:ss.f",\r
1975                           "HH:mm:ss.ff",\r
1976                           "HH:mm:ss.fff",\r
1977                           "HH:mm:ss.ffff",\r
1978                           "HH:mm:ss.fffff",\r
1979                           "HH:mm:ss.ffffff",\r
1980                           "HH:mm:ss.fffffff",\r
1981                           "HH:mm:sszzz",\r
1982                           "HH:mm:ss.fzzz",\r
1983                           "HH:mm:ss.ffzzz",\r
1984                           "HH:mm:ss.fffzzz",\r
1985                           "HH:mm:ss.ffffzzz",\r
1986                           "HH:mm:ss.fffffzzz",\r
1987                           "HH:mm:ss.ffffffzzz",\r
1988                           "HH:mm:ss.fffffffzzz",\r
1989                           "HH:mm:ssZ",\r
1990                           "HH:mm:ss.fZ",\r
1991                           "HH:mm:ss.ffZ",\r
1992                           "HH:mm:ss.fffZ",\r
1993                           "HH:mm:ss.ffffZ",\r
1994                           "HH:mm:ss.fffffZ",\r
1995                           "HH:mm:ss.ffffffZ",\r
1996                           "HH:mm:ss.fffffffZ"};\r
1997 \r
1998                 internal XsdTime ()\r
1999                 {\r
2000                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
2001                 }\r
2002 \r
2003                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
2004                         get { return durationAllowedFacets; } \r
2005                 }\r
2006 \r
2007                 public override XmlTokenizedType TokenizedType {\r
2008                         get { return XmlTokenizedType.CDATA; }\r
2009                 }\r
2010 \r
2011 #if NET_2_0\r
2012                 public override XmlTypeCode TypeCode {\r
2013                         get { return XmlTypeCode.Time; }\r
2014                 }\r
2015 #endif\r
2016 \r
2017                 public override Type ValueType {\r
2018                         get { return typeof (DateTime); }\r
2019                 }\r
2020 \r
2021                 public override object ParseValue (string s,\r
2022                         XmlNameTable nameTable, NSResolver nsmgr)\r
2023                 {\r
2024                         return ParseValueType (s, nameTable, nsmgr);\r
2025                 }\r
2026 \r
2027                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
2028                 {\r
2029                         return DateTime.ParseExact (Normalize (s), timeFormats, null, DateTimeStyles.None);\r
2030                 }\r
2031 \r
2032                 internal override XsdOrdering Compare(object x, object y) {\r
2033                         /* Really simple so far */\r
2034                         if ((x is DateTime) && (y is DateTime)) {\r
2035                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);\r
2036                                 if (ret < 0) { \r
2037                                         return XsdOrdering.LessThan;\r
2038                                 }\r
2039                                 else if (ret > 0) {\r
2040                                         return XsdOrdering.GreaterThan;\r
2041                                 }\r
2042                                 else {\r
2043                                         return XsdOrdering.Equal;\r
2044                                 }\r
2045                         }\r
2046                         return XsdOrdering.Indeterminate;\r
2047                 }\r
2048                 // Fundamental Facets ... no need to override except for Ordered.\r
2049                 public override XsdOrderedFacet Ordered {\r
2050                         get { return XsdOrderedFacet.Partial; }\r
2051                 }\r
2052                 \r
2053         }\r
2054 \r
2055         // xs:gYearMonth\r
2056         internal class XsdGYearMonth : XsdAnySimpleType\r
2057         {\r
2058                 internal XsdGYearMonth ()\r
2059                 {\r
2060                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
2061                 }\r
2062     \r
2063                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
2064                         get { return durationAllowedFacets; } \r
2065                 }\r
2066                 \r
2067 #if NET_2_0\r
2068                 public override XmlTypeCode TypeCode {\r
2069                         get { return XmlTypeCode.GYearMonth; }\r
2070                 }\r
2071 #endif\r
2072 \r
2073                 public override Type ValueType {\r
2074                         get { return typeof (DateTime); }\r
2075                 }\r
2076 \r
2077                 public override object ParseValue (string s,\r
2078                         XmlNameTable nameTable, NSResolver nsmgr)\r
2079                 {\r
2080                         return ParseValueType (s, nameTable, nsmgr);\r
2081                 }\r
2082 \r
2083                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
2084                 {\r
2085                         return DateTime.ParseExact (Normalize (s), "yyyy-MM", null);\r
2086                 }\r
2087                 \r
2088                 internal override XsdOrdering Compare(object x, object y) {\r
2089                         /* Really simple so far */\r
2090                         if ((x is DateTime) && (y is DateTime)) {\r
2091                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);\r
2092                                 if (ret < 0) { \r
2093                                         return XsdOrdering.LessThan;\r
2094                                 }\r
2095                                 else if (ret > 0) {\r
2096                                         return XsdOrdering.GreaterThan;\r
2097                                 }\r
2098                                 else {\r
2099                                         return XsdOrdering.Equal;\r
2100                                 }\r
2101                         }\r
2102                         return XsdOrdering.Indeterminate;\r
2103                 }\r
2104         }\r
2105 \r
2106         // xs:gMonthDay\r
2107         internal class XsdGMonthDay : XsdAnySimpleType\r
2108         {\r
2109                 internal XsdGMonthDay ()\r
2110                 {\r
2111                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
2112                 }\r
2113     \r
2114                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
2115                         get { return durationAllowedFacets; } \r
2116                 }\r
2117                 \r
2118 #if NET_2_0\r
2119                 public override XmlTypeCode TypeCode {\r
2120                         get { return XmlTypeCode.GMonthDay; }\r
2121                 }\r
2122 #endif\r
2123 \r
2124                 public override Type ValueType {\r
2125                         get { return typeof (DateTime); }\r
2126                 }\r
2127 \r
2128                 public override object ParseValue (string s,\r
2129                         XmlNameTable nameTable, NSResolver nsmgr)\r
2130                 {\r
2131                         return ParseValueType (s, nameTable, nsmgr);\r
2132                 }\r
2133 \r
2134                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
2135                 {\r
2136                         return DateTime.ParseExact (Normalize (s), "--MM-dd", null);\r
2137                 }\r
2138                 \r
2139                 internal override XsdOrdering Compare(object x, object y) {\r
2140                         /* Really simple so far */\r
2141                         if ((x is DateTime) && (y is DateTime)) {\r
2142                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);\r
2143                                 if (ret < 0) { \r
2144                                         return XsdOrdering.LessThan;\r
2145                                 }\r
2146                                 else if (ret > 0) {\r
2147                                         return XsdOrdering.GreaterThan;\r
2148                                 }\r
2149                                 else {\r
2150                                         return XsdOrdering.Equal;\r
2151                                 }\r
2152                         }\r
2153                         return XsdOrdering.Indeterminate;\r
2154                 }\r
2155         }\r
2156 \r
2157         // xs:gYear\r
2158         internal class XsdGYear : XsdAnySimpleType\r
2159         {\r
2160                 internal XsdGYear ()\r
2161                 {\r
2162                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
2163                 }\r
2164                 \r
2165                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
2166                         get { return durationAllowedFacets; } \r
2167                 }\r
2168                 \r
2169 #if NET_2_0\r
2170                 public override XmlTypeCode TypeCode {\r
2171                         get { return XmlTypeCode.GYear; }\r
2172                 }\r
2173 #endif\r
2174 \r
2175                 public override Type ValueType {\r
2176                         get { return typeof (DateTime); }\r
2177                 }\r
2178 \r
2179                 // LAMESPEC: XML Schema Datatypes allows leading '-' to identify B.C. years,\r
2180                 // but CLR DateTime does not allow such expression.\r
2181                 public override object ParseValue (string s,\r
2182                         XmlNameTable nameTable, NSResolver nsmgr)\r
2183                 {\r
2184                         return ParseValueType (s, nameTable, nsmgr);\r
2185                 }\r
2186 \r
2187                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
2188                 {\r
2189                         return DateTime.ParseExact (Normalize(s), "yyyy", null);\r
2190                 }\r
2191                 \r
2192                 internal override XsdOrdering Compare(object x, object y) {\r
2193                         /* Really simple so far */\r
2194                         if ((x is DateTime) && (y is DateTime)) {\r
2195                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);\r
2196                                 if (ret < 0) { \r
2197                                         return XsdOrdering.LessThan;\r
2198                                 }\r
2199                                 else if (ret > 0) {\r
2200                                         return XsdOrdering.GreaterThan;\r
2201                                 }\r
2202                                 else {\r
2203                                         return XsdOrdering.Equal;\r
2204                                 }\r
2205                         }\r
2206                         return XsdOrdering.Indeterminate;\r
2207                 }\r
2208         }\r
2209 \r
2210         // xs:gMonth\r
2211         internal class XsdGMonth : XsdAnySimpleType\r
2212         {\r
2213                 internal XsdGMonth ()\r
2214                 {\r
2215                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
2216                 }\r
2217                 \r
2218                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
2219                         get { return durationAllowedFacets; } \r
2220                 }\r
2221                 \r
2222 #if NET_2_0\r
2223                 public override XmlTypeCode TypeCode {\r
2224                         get { return XmlTypeCode.GMonth; }\r
2225                 }\r
2226 #endif\r
2227 \r
2228                 public override Type ValueType {\r
2229                         get { return typeof (DateTime); }\r
2230                 }\r
2231 \r
2232                 public override object ParseValue (string s,\r
2233                         XmlNameTable nameTable, NSResolver nsmgr)\r
2234                 {\r
2235                         return ParseValueType (s, nameTable, nsmgr);\r
2236                 }\r
2237 \r
2238                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
2239                 {\r
2240                         return DateTime.ParseExact (Normalize(s), "--MM--", null);\r
2241                 }\r
2242                 \r
2243                 internal override XsdOrdering Compare(object x, object y) {\r
2244                         /* Really simple so far */\r
2245                         if ((x is DateTime) && (y is DateTime)) {\r
2246                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);\r
2247                                 if (ret < 0) { \r
2248                                         return XsdOrdering.LessThan;\r
2249                                 }\r
2250                                 else if (ret > 0) {\r
2251                                         return XsdOrdering.GreaterThan;\r
2252                                 }\r
2253                                 else {\r
2254                                         return XsdOrdering.Equal;\r
2255                                 }\r
2256                         }\r
2257                         return XsdOrdering.Indeterminate;\r
2258                 }\r
2259         }\r
2260 \r
2261         // xs:gDay\r
2262         internal class XsdGDay : XsdAnySimpleType\r
2263         {\r
2264                 internal XsdGDay ()\r
2265                 {\r
2266                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
2267                 }\r
2268                 \r
2269                 internal override XmlSchemaFacet.Facet AllowedFacets {\r
2270                         get { return durationAllowedFacets; } \r
2271                 }\r
2272                 \r
2273 #if NET_2_0\r
2274                 public override XmlTypeCode TypeCode {\r
2275                         get { return XmlTypeCode.GDay; }\r
2276                 }\r
2277 #endif\r
2278 \r
2279                 public override Type ValueType {\r
2280                         get { return typeof (DateTime); }\r
2281                 }\r
2282 \r
2283                 public override object ParseValue (string s,\r
2284                         XmlNameTable nameTable, NSResolver nsmgr)\r
2285                 {\r
2286                         return ParseValueType (s, nameTable, nsmgr);\r
2287                 }\r
2288 \r
2289                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr) \r
2290                 {\r
2291                         return DateTime.ParseExact (Normalize(s), "---dd", null);\r
2292                 }\r
2293                 \r
2294                 internal override XsdOrdering Compare(object x, object y) {\r
2295                         /* Really simple so far */\r
2296                         if ((x is DateTime) && (y is DateTime)) {\r
2297                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);\r
2298                                 if (ret < 0) { \r
2299                                         return XsdOrdering.LessThan;\r
2300                                 }\r
2301                                 else if (ret > 0) {\r
2302                                         return XsdOrdering.GreaterThan;\r
2303                                 }\r
2304                                 else {\r
2305                                         return XsdOrdering.Equal;\r
2306                                 }\r
2307                         }\r
2308                         return XsdOrdering.Indeterminate;\r
2309                 }\r
2310         }\r
2311 \r
2312 }\r