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

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