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                 static bool HasValidScheme (string src)
1635                 {
1636                         int idx = src.IndexOf (':');
1637                         if (idx < 0)
1638                                 return false;
1639                         for (int i = 0; i < idx; i++) {
1640                                 switch (src [i]) {
1641                                 case '+':
1642                                 case '-':
1643                                 case '.':
1644                                         continue;
1645                                 default:
1646                                         if (Char.IsLetterOrDigit (src [i]))
1647                                                 continue;
1648                                         return false;
1649                                 }
1650                         }
1651                         return true;
1652                 }
1653
1654                 // MS BUG: Some strings that contain ':' might result in
1655                 // exception (MS.NET looks implemented as such).
1656                 public XmlSchemaUri (string src)
1657                         : this (src, HasValidScheme (src))
1658                 {
1659                 }
1660
1661                 private XmlSchemaUri (string src, bool formal)
1662                         : base (formal ? src : "anyuri:" + src, !formal)
1663                 {
1664                         value = src;
1665                 }
1666
1667                 public static bool operator == (XmlSchemaUri v1, XmlSchemaUri v2)
1668                 {
1669                         return v1.value == v2.value;
1670                 }
1671
1672                 public static bool operator != (XmlSchemaUri v1, XmlSchemaUri v2)
1673                 {
1674                         return v1.value != v2.value;
1675                 }
1676
1677                 public override bool Equals (object obj)
1678                 {
1679                         if (obj is XmlSchemaUri)
1680                                 return (XmlSchemaUri) obj == this;
1681                         else
1682                                 return false;
1683                 }
1684
1685                 public override int GetHashCode ()
1686                 {
1687                         return value.GetHashCode ();
1688                 }
1689
1690                 public override string ToString ()
1691                 {
1692                         return value;
1693                 }
1694         }
1695
1696         // xs:duration
1697         internal class XsdDuration : XsdAnySimpleType
1698         {
1699                 internal XsdDuration ()
1700                 {
1701       this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
1702                 }
1703
1704                 internal override XmlSchemaFacet.Facet AllowedFacets {
1705                         get { return durationAllowedFacets; }
1706                 }
1707
1708                 public override XmlTokenizedType TokenizedType {
1709                         get { return XmlTokenizedType.CDATA; }
1710                 }
1711
1712 #if NET_2_0
1713                 public override XmlTypeCode TypeCode {
1714                         get { return XmlTypeCode.Duration; }
1715                 }
1716 #endif
1717
1718                 public override Type ValueType {
1719                         get { return typeof (TimeSpan); }
1720                 }
1721
1722                 public override object ParseValue (string s,
1723                         XmlNameTable nameTable, NSResolver nsmgr)
1724                 {
1725                         return ParseValueType (s, nameTable, nsmgr);
1726                 }
1727
1728                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
1729                 {
1730                         return XmlConvert.ToTimeSpan (Normalize (s));
1731                 }
1732
1733                 internal override XsdOrdering Compare(object x, object y) {
1734                         /* FIXME: This is really simple so far
1735                          *
1736                          * In fact in order to do this correctly in XmlSchema, we cannot use TimeSpan as the base type
1737                          * Though it turns out that MS .NET is a little broken in this regard too. Not doing comparisons
1738                          * correctly.
1739                          */
1740                         if ((x is TimeSpan) && (y is TimeSpan)) {
1741                                 int ret = TimeSpan.Compare((TimeSpan)x, (TimeSpan)y);
1742                                 if (ret < 0) {
1743                                         return XsdOrdering.LessThan;
1744                                 }
1745                                 else if (ret > 0) {
1746                                         return XsdOrdering.GreaterThan;
1747                                 }
1748                                 else {
1749                                         return XsdOrdering.Equal;
1750                                 }
1751                         }
1752                         return XsdOrdering.Indeterminate;
1753                 }
1754
1755
1756                 // Fundamental Facets
1757                 public override bool Bounded {
1758                         get { return false; }
1759                 }
1760                 public override bool Finite {
1761                         get { return false; }
1762                 }
1763                 public override bool Numeric {
1764                         get { return false; }
1765                 }
1766                 public override XsdOrderedFacet Ordered {
1767                         get { return XsdOrderedFacet.Partial; }
1768
1769                 }
1770         }
1771
1772 #if NET_2_0
1773         // xdt:dayTimeDuration
1774         internal class XdtDayTimeDuration : XsdDuration
1775         {
1776                 internal XdtDayTimeDuration ()
1777                 {
1778                 }
1779
1780                 public override XmlTypeCode TypeCode {
1781                         get { return XmlTypeCode.DayTimeDuration; }
1782                 }
1783
1784                 public override Type ValueType {
1785                         get { return typeof (TimeSpan); }
1786                 }
1787
1788                 public override object ParseValue (string s,
1789                         XmlNameTable nameTable, NSResolver nsmgr)
1790                 {
1791                         return ParseValueType (s, nameTable, nsmgr);
1792                 }
1793
1794                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
1795                 {
1796                         return XmlConvert.ToTimeSpan (Normalize (s));
1797                 }
1798
1799                 // FIXME: Fundamental Facets
1800                 public override bool Bounded {
1801                         get { return false; }
1802                 }
1803                 public override bool Finite {
1804                         get { return false; }
1805                 }
1806                 public override bool Numeric {
1807                         get { return false; }
1808                 }
1809                 public override XsdOrderedFacet Ordered {
1810                         get { return XsdOrderedFacet.Partial; }
1811
1812                 }
1813         }
1814
1815         // xdt:yearMonthDuration
1816         internal class XdtYearMonthDuration : XsdDuration
1817         {
1818                 internal XdtYearMonthDuration ()
1819                 {
1820                 }
1821
1822                 public override XmlTypeCode TypeCode {
1823                         get { return XmlTypeCode.YearMonthDuration; }
1824                 }
1825
1826                 public override Type ValueType {
1827                         get { return typeof (TimeSpan); }
1828                 }
1829
1830                 public override object ParseValue (string s,
1831                         XmlNameTable nameTable, NSResolver nsmgr)
1832                 {
1833                         return ParseValueType (s, nameTable, nsmgr);
1834                 }
1835
1836                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
1837                 {
1838                         return XmlConvert.ToTimeSpan (Normalize (s));
1839                 }
1840
1841                 // FIXME: Fundamental Facets
1842                 public override bool Bounded {
1843                         get { return false; }
1844                 }
1845                 public override bool Finite {
1846                         get { return false; }
1847                 }
1848                 public override bool Numeric {
1849                         get { return false; }
1850                 }
1851                 public override XsdOrderedFacet Ordered {
1852                         get { return XsdOrderedFacet.Partial; }
1853
1854                 }
1855         }
1856 #endif
1857
1858         // xs:dateTime
1859         internal class XsdDateTime : XsdAnySimpleType
1860         {
1861                 internal XsdDateTime ()
1862                 {
1863                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
1864                 }
1865
1866                 internal override XmlSchemaFacet.Facet AllowedFacets {
1867                         get { return durationAllowedFacets; }
1868                 }
1869
1870                 public override XmlTokenizedType TokenizedType {
1871                         get { return XmlTokenizedType.CDATA; }
1872                 }
1873
1874 #if NET_2_0
1875                 public override XmlTypeCode TypeCode {
1876                         get { return XmlTypeCode.DateTime; }
1877                 }
1878 #endif
1879
1880                 public override Type ValueType {
1881                         get { return typeof (DateTime); }
1882                 }
1883
1884                 public override object ParseValue (string s,
1885                         XmlNameTable nameTable, NSResolver nsmgr)
1886                 {
1887                         return ParseValueType (s, nameTable, nsmgr);
1888                 }
1889
1890                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
1891                 {
1892                         return XmlConvert.ToDateTime (Normalize (s));
1893                 }
1894
1895                 internal override XsdOrdering Compare(object x, object y) {
1896                         /* Really simple so far */
1897                         if ((x is DateTime) && (y is DateTime)) {
1898                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
1899                                 if (ret < 0) {
1900                                         return XsdOrdering.LessThan;
1901                                 }
1902                                 else if (ret > 0) {
1903                                         return XsdOrdering.GreaterThan;
1904                                 }
1905                                 else {
1906                                         return XsdOrdering.Equal;
1907                                 }
1908                         }
1909                         return XsdOrdering.Indeterminate;
1910                 }
1911
1912                 // Fundamental Facets
1913                 public override bool Bounded {
1914                         get { return false; }
1915                 }
1916                 public override bool Finite {
1917                         get { return false; }
1918                 }
1919                 public override bool Numeric {
1920                         get { return false; }
1921                 }
1922                 public override XsdOrderedFacet Ordered {
1923                         get { return XsdOrderedFacet.Partial; }
1924                 }
1925
1926         }
1927
1928         // xs:date
1929         internal class XsdDate : XsdAnySimpleType
1930         {
1931                 internal XsdDate ()
1932                 {
1933                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
1934                 }
1935
1936                 internal override XmlSchemaFacet.Facet AllowedFacets {
1937                         get { return durationAllowedFacets; }
1938                 }
1939
1940                 public override XmlTokenizedType TokenizedType {
1941                         get { return XmlTokenizedType.CDATA; }
1942                 }
1943
1944 #if NET_2_0
1945                 public override XmlTypeCode TypeCode {
1946                         get { return XmlTypeCode.Date; }
1947                 }
1948 #endif
1949
1950                 public override Type ValueType {
1951                         get { return typeof (DateTime); }
1952                 }
1953
1954                 public override object ParseValue (string s,
1955                         XmlNameTable nameTable, NSResolver nsmgr)
1956                 {
1957                         return ParseValueType (s, nameTable, nsmgr);
1958                 }
1959
1960                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
1961                 {
1962                         return DateTime.ParseExact (Normalize (s), "yyyy-MM-dd", null);
1963                 }
1964
1965                 internal override XsdOrdering Compare(object x, object y) {
1966                         /* Really simple so far */
1967                         if ((x is DateTime) && (y is DateTime)) {
1968                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
1969                                 if (ret < 0) {
1970                                         return XsdOrdering.LessThan;
1971                                 }
1972                                 else if (ret > 0) {
1973                                         return XsdOrdering.GreaterThan;
1974                                 }
1975                                 else {
1976                                         return XsdOrdering.Equal;
1977                                 }
1978                         }
1979                         return XsdOrdering.Indeterminate;
1980                 }
1981                 // Fundamental Facets ... no need to override except for Ordered.
1982                 public override XsdOrderedFacet Ordered {
1983                         get { return XsdOrderedFacet.Partial; }
1984                 }
1985
1986         }
1987
1988         // xs:time
1989         internal class XsdTime : XsdAnySimpleType
1990         {
1991                 static string [] timeFormats = new string [] {
1992                           // copied from XmlConvert.
1993                           "HH:mm:ss",
1994                           "HH:mm:ss.f",
1995                           "HH:mm:ss.ff",
1996                           "HH:mm:ss.fff",
1997                           "HH:mm:ss.ffff",
1998                           "HH:mm:ss.fffff",
1999                           "HH:mm:ss.ffffff",
2000                           "HH:mm:ss.fffffff",
2001                           "HH:mm:sszzz",
2002                           "HH:mm:ss.fzzz",
2003                           "HH:mm:ss.ffzzz",
2004                           "HH:mm:ss.fffzzz",
2005                           "HH:mm:ss.ffffzzz",
2006                           "HH:mm:ss.fffffzzz",
2007                           "HH:mm:ss.ffffffzzz",
2008                           "HH:mm:ss.fffffffzzz",
2009                           "HH:mm:ssZ",
2010                           "HH:mm:ss.fZ",
2011                           "HH:mm:ss.ffZ",
2012                           "HH:mm:ss.fffZ",
2013                           "HH:mm:ss.ffffZ",
2014                           "HH:mm:ss.fffffZ",
2015                           "HH:mm:ss.ffffffZ",
2016                           "HH:mm:ss.fffffffZ"};
2017
2018                 internal XsdTime ()
2019                 {
2020                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
2021                 }
2022
2023                 internal override XmlSchemaFacet.Facet AllowedFacets {
2024                         get { return durationAllowedFacets; }
2025                 }
2026
2027                 public override XmlTokenizedType TokenizedType {
2028                         get { return XmlTokenizedType.CDATA; }
2029                 }
2030
2031 #if NET_2_0
2032                 public override XmlTypeCode TypeCode {
2033                         get { return XmlTypeCode.Time; }
2034                 }
2035 #endif
2036
2037                 public override Type ValueType {
2038                         get { return typeof (DateTime); }
2039                 }
2040
2041                 public override object ParseValue (string s,
2042                         XmlNameTable nameTable, NSResolver nsmgr)
2043                 {
2044                         return ParseValueType (s, nameTable, nsmgr);
2045                 }
2046
2047                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
2048                 {
2049                         return DateTime.ParseExact (Normalize (s), timeFormats, null, DateTimeStyles.None);
2050                 }
2051
2052                 internal override XsdOrdering Compare(object x, object y) {
2053                         /* Really simple so far */
2054                         if ((x is DateTime) && (y is DateTime)) {
2055                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
2056                                 if (ret < 0) {
2057                                         return XsdOrdering.LessThan;
2058                                 }
2059                                 else if (ret > 0) {
2060                                         return XsdOrdering.GreaterThan;
2061                                 }
2062                                 else {
2063                                         return XsdOrdering.Equal;
2064                                 }
2065                         }
2066                         return XsdOrdering.Indeterminate;
2067                 }
2068                 // Fundamental Facets ... no need to override except for Ordered.
2069                 public override XsdOrderedFacet Ordered {
2070                         get { return XsdOrderedFacet.Partial; }
2071                 }
2072
2073         }
2074
2075         // xs:gYearMonth
2076         internal class XsdGYearMonth : XsdAnySimpleType
2077         {
2078                 internal XsdGYearMonth ()
2079                 {
2080                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
2081                 }
2082
2083                 internal override XmlSchemaFacet.Facet AllowedFacets {
2084                         get { return durationAllowedFacets; }
2085                 }
2086
2087 #if NET_2_0
2088                 public override XmlTypeCode TypeCode {
2089                         get { return XmlTypeCode.GYearMonth; }
2090                 }
2091 #endif
2092
2093                 public override Type ValueType {
2094                         get { return typeof (DateTime); }
2095                 }
2096
2097                 public override object ParseValue (string s,
2098                         XmlNameTable nameTable, NSResolver nsmgr)
2099                 {
2100                         return ParseValueType (s, nameTable, nsmgr);
2101                 }
2102
2103                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
2104                 {
2105                         return DateTime.ParseExact (Normalize (s), "yyyy-MM", null);
2106                 }
2107
2108                 internal override XsdOrdering Compare(object x, object y) {
2109                         /* Really simple so far */
2110                         if ((x is DateTime) && (y is DateTime)) {
2111                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
2112                                 if (ret < 0) {
2113                                         return XsdOrdering.LessThan;
2114                                 }
2115                                 else if (ret > 0) {
2116                                         return XsdOrdering.GreaterThan;
2117                                 }
2118                                 else {
2119                                         return XsdOrdering.Equal;
2120                                 }
2121                         }
2122                         return XsdOrdering.Indeterminate;
2123                 }
2124         }
2125
2126         // xs:gMonthDay
2127         internal class XsdGMonthDay : XsdAnySimpleType
2128         {
2129                 internal XsdGMonthDay ()
2130                 {
2131                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
2132                 }
2133
2134                 internal override XmlSchemaFacet.Facet AllowedFacets {
2135                         get { return durationAllowedFacets; }
2136                 }
2137
2138 #if NET_2_0
2139                 public override XmlTypeCode TypeCode {
2140                         get { return XmlTypeCode.GMonthDay; }
2141                 }
2142 #endif
2143
2144                 public override Type ValueType {
2145                         get { return typeof (DateTime); }
2146                 }
2147
2148                 public override object ParseValue (string s,
2149                         XmlNameTable nameTable, NSResolver nsmgr)
2150                 {
2151                         return ParseValueType (s, nameTable, nsmgr);
2152                 }
2153
2154                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
2155                 {
2156                         return DateTime.ParseExact (Normalize (s), "--MM-dd", null);
2157                 }
2158
2159                 internal override XsdOrdering Compare(object x, object y) {
2160                         /* Really simple so far */
2161                         if ((x is DateTime) && (y is DateTime)) {
2162                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
2163                                 if (ret < 0) {
2164                                         return XsdOrdering.LessThan;
2165                                 }
2166                                 else if (ret > 0) {
2167                                         return XsdOrdering.GreaterThan;
2168                                 }
2169                                 else {
2170                                         return XsdOrdering.Equal;
2171                                 }
2172                         }
2173                         return XsdOrdering.Indeterminate;
2174                 }
2175         }
2176
2177         // xs:gYear
2178         internal class XsdGYear : XsdAnySimpleType
2179         {
2180                 internal XsdGYear ()
2181                 {
2182                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
2183                 }
2184
2185                 internal override XmlSchemaFacet.Facet AllowedFacets {
2186                         get { return durationAllowedFacets; }
2187                 }
2188
2189 #if NET_2_0
2190                 public override XmlTypeCode TypeCode {
2191                         get { return XmlTypeCode.GYear; }
2192                 }
2193 #endif
2194
2195                 public override Type ValueType {
2196                         get { return typeof (DateTime); }
2197                 }
2198
2199                 // LAMESPEC: XML Schema Datatypes allows leading '-' to identify B.C. years,
2200                 // but CLR DateTime does not allow such expression.
2201                 public override object ParseValue (string s,
2202                         XmlNameTable nameTable, NSResolver nsmgr)
2203                 {
2204                         return ParseValueType (s, nameTable, nsmgr);
2205                 }
2206
2207                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
2208                 {
2209                         return DateTime.ParseExact (Normalize(s), "yyyy", null);
2210                 }
2211
2212                 internal override XsdOrdering Compare(object x, object y) {
2213                         /* Really simple so far */
2214                         if ((x is DateTime) && (y is DateTime)) {
2215                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
2216                                 if (ret < 0) {
2217                                         return XsdOrdering.LessThan;
2218                                 }
2219                                 else if (ret > 0) {
2220                                         return XsdOrdering.GreaterThan;
2221                                 }
2222                                 else {
2223                                         return XsdOrdering.Equal;
2224                                 }
2225                         }
2226                         return XsdOrdering.Indeterminate;
2227                 }
2228         }
2229
2230         // xs:gMonth
2231         internal class XsdGMonth : XsdAnySimpleType
2232         {
2233                 internal XsdGMonth ()
2234                 {
2235                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
2236                 }
2237
2238                 internal override XmlSchemaFacet.Facet AllowedFacets {
2239                         get { return durationAllowedFacets; }
2240                 }
2241
2242 #if NET_2_0
2243                 public override XmlTypeCode TypeCode {
2244                         get { return XmlTypeCode.GMonth; }
2245                 }
2246 #endif
2247
2248                 public override Type ValueType {
2249                         get { return typeof (DateTime); }
2250                 }
2251
2252                 public override object ParseValue (string s,
2253                         XmlNameTable nameTable, NSResolver nsmgr)
2254                 {
2255                         return ParseValueType (s, nameTable, nsmgr);
2256                 }
2257
2258                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
2259                 {
2260                         return DateTime.ParseExact (Normalize(s), "--MM--", null);
2261                 }
2262
2263                 internal override XsdOrdering Compare(object x, object y) {
2264                         /* Really simple so far */
2265                         if ((x is DateTime) && (y is DateTime)) {
2266                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
2267                                 if (ret < 0) {
2268                                         return XsdOrdering.LessThan;
2269                                 }
2270                                 else if (ret > 0) {
2271                                         return XsdOrdering.GreaterThan;
2272                                 }
2273                                 else {
2274                                         return XsdOrdering.Equal;
2275                                 }
2276                         }
2277                         return XsdOrdering.Indeterminate;
2278                 }
2279         }
2280
2281         // xs:gDay
2282         internal class XsdGDay : XsdAnySimpleType
2283         {
2284                 internal XsdGDay ()
2285                 {
2286                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;
2287                 }
2288
2289                 internal override XmlSchemaFacet.Facet AllowedFacets {
2290                         get { return durationAllowedFacets; }
2291                 }
2292
2293 #if NET_2_0
2294                 public override XmlTypeCode TypeCode {
2295                         get { return XmlTypeCode.GDay; }
2296                 }
2297 #endif
2298
2299                 public override Type ValueType {
2300                         get { return typeof (DateTime); }
2301                 }
2302
2303                 public override object ParseValue (string s,
2304                         XmlNameTable nameTable, NSResolver nsmgr)
2305                 {
2306                         return ParseValueType (s, nameTable, nsmgr);
2307                 }
2308
2309                 internal override ValueType ParseValueType (string s, XmlNameTable nameTable, NSResolver nsmgr)
2310                 {
2311                         return DateTime.ParseExact (Normalize(s), "---dd", null);
2312                 }
2313
2314                 internal override XsdOrdering Compare(object x, object y) {
2315                         /* Really simple so far */
2316                         if ((x is DateTime) && (y is DateTime)) {
2317                                 int ret = DateTime.Compare((DateTime)x, (DateTime)y);
2318                                 if (ret < 0) {
2319                                         return XsdOrdering.LessThan;
2320                                 }
2321                                 else if (ret > 0) {
2322                                         return XsdOrdering.GreaterThan;
2323                                 }
2324                                 else {
2325                                         return XsdOrdering.Equal;
2326                                 }
2327                         }
2328                         return XsdOrdering.Indeterminate;
2329                 }
2330         }
2331
2332 }