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