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

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