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 using System;\r
  10 using System.Collections;\r
  11 using System.Text;\r
  12 using System.Xml;\r
  13 using System.Xml.Schema;\r
  14 using System.Globalization;\r
  15 \r
  16 namespace Mono.Xml.Schema\r
  17 {\r
  18         public enum XsdWhitespaceFacet\r
  19         {\r
  20                 Preserve,\r
  21                 Replace,\r
  22                 Collapse\r
  23         }\r
  24 \r
  25         public enum XsdOrderedFacet\r
  26         {\r
  27                 False,\r
  28                 Partial,\r
  29                 Total\r
  30         }\r
  31 \r
  32         public class XsdAnySimpleType : XmlSchemaDatatype\r
  33         {\r
  34                 static XsdAnySimpleType instance;\r
  35                 static XsdAnySimpleType ()\r
  36                 {\r
  37                         instance = new XsdAnySimpleType ();\r
  38                 }\r
  39 \r
  40                 public static XsdAnySimpleType Instance {\r
  41                         get { return instance; }\r
  42                 }\r
  43 \r
  44                 readonly char [] whitespaceArray = new char [] {' '};\r
  45 \r
  46                 // Fundamental Facets\r
  47                 public virtual bool Bounded {\r
  48                         get { return false; }\r
  49                 }\r
  50 \r
  51                 public virtual bool Finite {\r
  52                         get { return false; }\r
  53                 }\r
  54 \r
  55                 public virtual bool Numeric { \r
  56                         get { return false; }\r
  57                 }\r
  58 \r
  59                 public virtual XsdOrderedFacet Ordered { \r
  60                         get { return XsdOrderedFacet.False; }\r
  61                 }\r
  62 \r
  63                 public override Type ValueType {\r
  64                         get { return typeof (object); }\r
  65                 }\r
  66 \r
  67                 public override XmlTokenizedType TokenizedType {\r
  68                         get {\r
  69                                 return XmlTokenizedType.None;\r
  70                         }\r
  71                 }\r
  72 \r
  73                 public override object ParseValue (string s,\r
  74                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
  75                 {\r
  76                         return Normalize (s);\r
  77                 }\r
  78 \r
  79                 internal string [] ParseListValue (string s, XmlNameTable nameTable)\r
  80                 {\r
  81                         return this.Normalize (s, XsdWhitespaceFacet.Collapse).Split (whitespaceArray);\r
  82                 }\r
  83         }\r
  84 \r
  85         // xs:string\r
  86         public class XsdString : XsdAnySimpleType\r
  87         {\r
  88                 internal XsdString ()\r
  89                 {\r
  90                 }\r
  91 \r
  92                 public override XmlTokenizedType TokenizedType {\r
  93                         get { return XmlTokenizedType.CDATA; }\r
  94                 }\r
  95 \r
  96                 public override Type ValueType {\r
  97                         get { return typeof (string); }\r
  98                 }\r
  99 \r
 100                 // Fundamental Facets\r
 101                 public override bool Bounded {\r
 102                         get { return false; }\r
 103                 }\r
 104                 public override bool Finite {\r
 105                         get { return false; }\r
 106                 }\r
 107                 public override bool Numeric {\r
 108                         get { return false; }\r
 109                 }\r
 110                 public override XsdOrderedFacet Ordered {\r
 111                         get { return XsdOrderedFacet.False; }\r
 112                 }\r
 113 \r
 114                 /* Freeze their use now.\r
 115                 // Constraining Facets\r
 116                 public bool HasLengthFacet;\r
 117                 public bool HasMaxLengthFacet;\r
 118                 public bool HasMinLengthFacet;\r
 119                 public int Length;\r
 120                 public int MaxLength;\r
 121                 public int MinLength;\r
 122                 public string Pattern;\r
 123                 public ICollection Enumeration;\r
 124                 */\r
 125         }\r
 126 \r
 127         // xs:normalizedString\r
 128         public class XsdNormalizedString : XsdString\r
 129         {\r
 130                 internal XsdNormalizedString ()\r
 131                 {\r
 132                         this.WhitespaceValue = XsdWhitespaceFacet.Replace;\r
 133                 }\r
 134 \r
 135                 public override XmlTokenizedType TokenizedType {\r
 136 \r
 137                         get { return XmlTokenizedType.CDATA; }\r
 138                 }\r
 139 \r
 140                 public override Type ValueType {\r
 141                         get { return typeof (string); }\r
 142                 }\r
 143 \r
 144                 // ParseValue () method is as same as that of xs:string\r
 145         }\r
 146 \r
 147         // xs:token\r
 148         public class XsdToken : XsdNormalizedString\r
 149         {\r
 150                 internal XsdToken ()\r
 151                 {\r
 152                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
 153                 }\r
 154 \r
 155                 public override XmlTokenizedType TokenizedType {\r
 156                         get { return XmlTokenizedType.CDATA; }\r
 157                 }\r
 158 \r
 159                 public override Type ValueType {\r
 160                         get { return typeof (string); }\r
 161                 }\r
 162 \r
 163                 // ParseValue () method is as same as that of xs:string\r
 164         }\r
 165 \r
 166         // xs:language\r
 167         public class XsdLanguage : XsdToken\r
 168         {\r
 169                 internal XsdLanguage ()\r
 170                 {\r
 171                 }\r
 172 \r
 173                 public override XmlTokenizedType TokenizedType {\r
 174                         get { return XmlTokenizedType.CDATA; }\r
 175                 }\r
 176 \r
 177                 public override Type ValueType {\r
 178                         get { return typeof (string); }\r
 179                 }\r
 180 \r
 181                 // ParseValue () method is as same as that of xs:string\r
 182         }\r
 183 \r
 184         // xs;NMTOKEN\r
 185         public class XsdNMToken : XsdToken\r
 186         {\r
 187                 internal XsdNMToken ()\r
 188                 {\r
 189                 }\r
 190 \r
 191                 public override XmlTokenizedType TokenizedType {\r
 192                         get { return XmlTokenizedType.NMTOKEN; }\r
 193                 }\r
 194 \r
 195                 public override Type ValueType {\r
 196                         get { return typeof (string); }\r
 197                 }\r
 198 \r
 199                 public override object ParseValue (string s,\r
 200                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 201                 {\r
 202                         if (!XmlChar.IsNmToken (s))\r
 203                                 throw new ArgumentException ("'" + s + "' is an invalid NMTOKEN.");\r
 204                         return s;\r
 205                 }\r
 206 \r
 207         }\r
 208 \r
 209         // xs:NMTOKENS\r
 210         public class XsdNMTokens : XsdNMToken\r
 211         {\r
 212                 internal XsdNMTokens ()\r
 213                 {\r
 214                 }\r
 215 \r
 216                 public override XmlTokenizedType TokenizedType {\r
 217                         get { return XmlTokenizedType.NMTOKENS; }\r
 218                 }\r
 219 \r
 220                 public override Type ValueType {\r
 221                         get { return typeof (string []); }\r
 222                 }\r
 223 \r
 224                 public override object ParseValue (string value, XmlNameTable nt, XmlNamespaceManager nsmgr)\r
 225                 {\r
 226                         return ParseListValue (value, nt);\r
 227                 }\r
 228         }\r
 229 \r
 230         // xs:Name\r
 231         public class XsdName : XsdToken\r
 232         {\r
 233                 internal XsdName ()\r
 234                 {\r
 235                 }\r
 236 \r
 237                 public override XmlTokenizedType TokenizedType {\r
 238                         get { return XmlTokenizedType.CDATA; }\r
 239                 }\r
 240 \r
 241                 public override Type ValueType {\r
 242                         get { return typeof (string); }\r
 243                 }\r
 244 \r
 245                 public override object ParseValue (string s,\r
 246                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 247                 {\r
 248                         if (!XmlChar.IsName (s))\r
 249                                 throw new ArgumentException ("'" + s + "' is an invalid name.");\r
 250                         return s;\r
 251                 }\r
 252         }\r
 253 \r
 254         // xs:NCName\r
 255         public class XsdNCName : XsdName\r
 256         {\r
 257                 internal XsdNCName ()\r
 258                 {\r
 259                 }\r
 260 \r
 261                 public override XmlTokenizedType TokenizedType {\r
 262                         get { return XmlTokenizedType.NCName; }\r
 263                 }\r
 264 \r
 265                 public override Type ValueType {\r
 266                         get { return typeof (string); }\r
 267                 }\r
 268 \r
 269                 public override object ParseValue (string s,\r
 270                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 271                 {\r
 272                         if (!XmlChar.IsNCName (s))\r
 273                                 throw new ArgumentException ("'" + s + "' is an invalid NCName.");\r
 274                         return s;\r
 275                 }\r
 276 \r
 277         }\r
 278 \r
 279         // xs:ID\r
 280         public class XsdID : XsdName\r
 281         {\r
 282                 internal XsdID ()\r
 283                 {\r
 284                 }\r
 285 \r
 286                 public override XmlTokenizedType TokenizedType {\r
 287                         get { return XmlTokenizedType.ID; }\r
 288                 }\r
 289 \r
 290                 public override Type ValueType {\r
 291                         get { return typeof (string); }\r
 292                 }\r
 293 \r
 294                 // ParseValue () method is as same as that of xs:string\r
 295         }\r
 296 \r
 297         // xs:IDREF\r
 298         public class XsdIDRef : XsdName\r
 299         {\r
 300                 internal XsdIDRef ()\r
 301                 {\r
 302                 }\r
 303 \r
 304                 public override XmlTokenizedType TokenizedType {\r
 305                         get { return XmlTokenizedType.IDREF; }\r
 306                 }\r
 307 \r
 308                 public override Type ValueType {\r
 309                         get { return typeof (string); }\r
 310                 }\r
 311 \r
 312                 // ParseValue () method is as same as that of xs:string\r
 313         }\r
 314 \r
 315         // xs:IDREFS\r
 316         public class XsdIDRefs : XsdName\r
 317         {\r
 318                 internal XsdIDRefs ()\r
 319                 {\r
 320                 }\r
 321 \r
 322                 public override XmlTokenizedType TokenizedType {\r
 323                         get { return XmlTokenizedType.IDREFS; }\r
 324                 }\r
 325 \r
 326                 public override Type ValueType {\r
 327                         get { return typeof (string []); }\r
 328                 }\r
 329 \r
 330                 public override object ParseValue (string value, XmlNameTable nt, XmlNamespaceManager nsmgr)\r
 331                 {\r
 332                         return ParseListValue (value, nt);\r
 333                 }\r
 334         }\r
 335 \r
 336         // xs:ENTITY\r
 337         public class XsdEntity : XsdName\r
 338         {\r
 339                 internal XsdEntity ()\r
 340 \r
 341                 {\r
 342                 }\r
 343 \r
 344                 public override XmlTokenizedType TokenizedType {\r
 345                         get { return XmlTokenizedType.ENTITY; }\r
 346                 }\r
 347 \r
 348                 public override Type ValueType {\r
 349                         get { return typeof (string); }\r
 350                 }\r
 351 \r
 352                 // ParseValue () method is as same as that of xs:string\r
 353         }\r
 354 \r
 355 \r
 356         // xs:ENTITIES\r
 357         public class XsdEntities : XsdName\r
 358         {\r
 359                 internal XsdEntities ()\r
 360                 {\r
 361                 }\r
 362 \r
 363                 public override XmlTokenizedType TokenizedType {\r
 364                         get { return XmlTokenizedType.ENTITIES; }\r
 365                 }\r
 366 \r
 367                 public override Type ValueType {\r
 368                         get { return typeof (string []); }\r
 369                 }\r
 370 \r
 371                 public override object ParseValue (string value, XmlNameTable nt, XmlNamespaceManager nsmgr)\r
 372                 {\r
 373                         return ParseListValue (value, nt);\r
 374                 }\r
 375         }\r
 376 \r
 377         // xs:NOTATION\r
 378         public class XsdNotation : XsdAnySimpleType\r
 379         {\r
 380                 internal XsdNotation ()\r
 381                 {\r
 382                 }\r
 383 \r
 384                 public override XmlTokenizedType TokenizedType {\r
 385                         get { return XmlTokenizedType.NOTATION; }\r
 386                 }\r
 387 \r
 388                 public override Type ValueType {\r
 389                         get { return typeof (string); }\r
 390                 }\r
 391 \r
 392                 public override object ParseValue (string s,\r
 393                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 394                 {\r
 395                         return Normalize (s);\r
 396                 }\r
 397 \r
 398                 // Fundamental Facets\r
 399                 public override bool Bounded {\r
 400                         get { return false; }\r
 401                 }\r
 402                 public override bool Finite {\r
 403                         get { return false; }\r
 404                 }\r
 405                 public override bool Numeric {\r
 406                         get { return false; }\r
 407                 }\r
 408                 public override XsdOrderedFacet Ordered {\r
 409                         get { return XsdOrderedFacet.False; }\r
 410                 }\r
 411 \r
 412                 // Constraining Facets\r
 413                 public bool HasLengthFacet;\r
 414                 public bool HasMaxLengthFacet;\r
 415                 public bool HasMinLengthFacet;\r
 416                 public int Length;\r
 417                 public int MaxLength;\r
 418                 public int MinLength;\r
 419                 public string Pattern;\r
 420                 public ICollection Enumeration;\r
 421         }\r
 422 \r
 423         // xs:decimal\r
 424         public class XsdDecimal : XsdAnySimpleType\r
 425         {\r
 426                 internal XsdDecimal ()\r
 427                 {\r
 428                 }\r
 429 \r
 430                 public override XmlTokenizedType TokenizedType {\r
 431                         get { return XmlTokenizedType.None; }\r
 432                 }\r
 433 \r
 434                 public override Type ValueType {\r
 435                         get { return typeof (decimal); }\r
 436                 }\r
 437 \r
 438                 public override object ParseValue (string s,\r
 439                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 440                 {\r
 441                         return XmlConvert.ToDecimal (this.Normalize (s));\r
 442                 }\r
 443 \r
 444                 // Fundamental Facets\r
 445                 public override bool Bounded {\r
 446                         get { return false; }\r
 447                 }\r
 448                 public override bool Finite {\r
 449                         get { return false; }\r
 450                 }\r
 451                 public override bool Numeric {\r
 452                         get { return true; }\r
 453                 }\r
 454                 public override XsdOrderedFacet Ordered {\r
 455                         get { return XsdOrderedFacet.Total; }\r
 456                 }\r
 457 \r
 458                 // Constraining Facets\r
 459                 public bool HasLengthFacet;\r
 460                 public bool HasMaxLengthFacet;\r
 461                 public bool HasMinLengthFacet;\r
 462                 public int Length;\r
 463                 public int MaxLength;\r
 464                 public int MinLength;\r
 465                 public string Pattern;\r
 466                 public ICollection Enumeration;\r
 467         }\r
 468 \r
 469         // xs:integer\r
 470         public class XsdInteger : XsdDecimal\r
 471         {\r
 472                 public XsdInteger ()\r
 473                 {\r
 474                         this.WhitespaceValue = XsdWhitespaceFacet.Collapse;\r
 475                 }\r
 476 \r
 477                 // Here it may be bigger than int's (or long's) MaxValue.\r
 478                 public override Type ValueType {\r
 479                         get { return typeof (decimal); }\r
 480                 }\r
 481 \r
 482                 public override object ParseValue (string s,\r
 483                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 484                 {\r
 485                         decimal d = XmlConvert.ToDecimal (Normalize (s));\r
 486                         if (Decimal.Floor (d) != d)\r
 487                                 throw new FormatException ("Integer contains point number.");\r
 488                         return d;\r
 489                 }\r
 490         }\r
 491 \r
 492         // xs:Long\r
 493         public class XsdLong : XsdInteger\r
 494         {\r
 495                 public override Type ValueType {\r
 496                         get { return typeof (long); }\r
 497                 }\r
 498 \r
 499                 public override object ParseValue (string s,\r
 500                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 501                 {\r
 502                         return XmlConvert.ToInt64 (Normalize (s));\r
 503                 }\r
 504         }\r
 505 \r
 506         // xs:Int\r
 507         public class XsdInt : XsdLong\r
 508         {\r
 509                 public override Type ValueType {\r
 510                         get { return typeof (int); }\r
 511                 }\r
 512 \r
 513                 public override object ParseValue (string s,\r
 514                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 515                 {\r
 516                         return XmlConvert.ToInt32 (Normalize (s));\r
 517                 }\r
 518         }\r
 519 \r
 520 \r
 521         // xs:Short\r
 522         public class XsdShort : XsdInt\r
 523         {\r
 524                 public override Type ValueType {\r
 525                         get { return typeof (short); }\r
 526                 }\r
 527 \r
 528                 public override object ParseValue (string s,\r
 529                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 530                 {\r
 531                         return XmlConvert.ToInt16 (Normalize (s));\r
 532                 }\r
 533         }\r
 534 \r
 535         // xs:Byte\r
 536         public class XsdByte : XsdShort\r
 537         {\r
 538                 public override Type ValueType {\r
 539                         get { return typeof (byte); }\r
 540                 }\r
 541 \r
 542                 public override object ParseValue (string s,\r
 543                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 544                 {\r
 545                         return XmlConvert.ToByte (Normalize (s));\r
 546                 }\r
 547         }\r
 548 \r
 549         // xs:nonNegativeInteger\r
 550         [CLSCompliant (false)]\r
 551         public class XsdNonNegativeInteger : XsdInteger\r
 552         {\r
 553                 public override Type ValueType {\r
 554                         get { return typeof (decimal); }\r
 555                 }\r
 556 \r
 557                 [CLSCompliant (false)]\r
 558                 public override object ParseValue (string s,\r
 559                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 560                 {\r
 561                         return XmlConvert.ToDecimal (Normalize (s));\r
 562                 }\r
 563         }\r
 564 \r
 565         // xs:unsignedLong\r
 566         [CLSCompliant (false)]\r
 567         public class XsdUnsignedLong : XsdNonNegativeInteger\r
 568         {\r
 569                 public override Type ValueType {\r
 570                         get { return typeof (ulong); }\r
 571                 }\r
 572 \r
 573                 public override object ParseValue (string s,\r
 574                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 575                 {\r
 576                         return XmlConvert.ToUInt64 (Normalize (s));\r
 577                 }\r
 578         }\r
 579 \r
 580         // xs:unsignedInt\r
 581         [CLSCompliant (false)]\r
 582         public class XsdUnsignedInt : XsdUnsignedLong\r
 583         {\r
 584                 public override Type ValueType {\r
 585                         get { return typeof (uint); }\r
 586                 }\r
 587 \r
 588                 public override object ParseValue (string s,\r
 589                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 590                 {\r
 591                         return XmlConvert.ToUInt32 (Normalize (s));\r
 592                 }\r
 593         }\r
 594 \r
 595 \r
 596         // xs:unsignedShort\r
 597         [CLSCompliant (false)]\r
 598         public class XsdUnsignedShort : XsdUnsignedInt\r
 599         {\r
 600                 public override Type ValueType {\r
 601                         get { return typeof (ushort); }\r
 602                 }\r
 603 \r
 604                 public override object ParseValue (string s,\r
 605                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 606                 {\r
 607                         return XmlConvert.ToUInt16 (Normalize (s));\r
 608                 }\r
 609         }\r
 610 \r
 611         // xs:unsignedByte\r
 612         [CLSCompliant (false)]\r
 613         public class XsdUnsignedByte : XsdUnsignedShort\r
 614         {\r
 615                 public override Type ValueType {\r
 616                         get { return typeof (byte); }\r
 617                 }\r
 618 \r
 619                 public override object ParseValue (string s,\r
 620                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 621                 {\r
 622                         return XmlConvert.ToByte(Normalize (s));\r
 623                 }\r
 624         }\r
 625 \r
 626 \r
 627         // xs:positiveInteger\r
 628         [CLSCompliant (false)]\r
 629         public class XsdPositiveInteger : XsdNonNegativeInteger\r
 630         {\r
 631                 // It returns decimal, instead of int or long.\r
 632                 // Maybe MS developers thought about big integer...\r
 633                 public override Type ValueType {\r
 634                         get { return typeof (decimal); }\r
 635                 }\r
 636 \r
 637                 public override object ParseValue (string s,\r
 638                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 639                 {\r
 640                         return XmlConvert.ToDecimal (Normalize (s));\r
 641                 }\r
 642         }\r
 643 \r
 644         // xs:nonPositiveInteger\r
 645         public class XsdNonPositiveInteger : XsdInteger\r
 646         {\r
 647                 public override Type ValueType {\r
 648                         get { return typeof (decimal); }\r
 649                 }\r
 650 \r
 651                 public override object ParseValue (string s,\r
 652                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 653                 {\r
 654                         return XmlConvert.ToDecimal (Normalize (s));\r
 655                 }\r
 656         }\r
 657 \r
 658         // xs:negativeInteger\r
 659         public class XsdNegativeInteger : XsdNonPositiveInteger\r
 660         {\r
 661                 public override Type ValueType {\r
 662 \r
 663                         get { return typeof (decimal); }\r
 664                 }\r
 665 \r
 666                 public override object ParseValue (string s,\r
 667                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 668                 {\r
 669                         return XmlConvert.ToDecimal (Normalize (s));\r
 670                 }\r
 671         }\r
 672 \r
 673         // xs:float\r
 674         public class XsdFloat : XsdAnySimpleType\r
 675         {\r
 676                 // Fundamental Facets\r
 677                 public override bool Bounded {\r
 678                         get { return true; }\r
 679                 }\r
 680                 public override bool Finite {\r
 681                         get { return true; }\r
 682                 }\r
 683                 public override bool Numeric {\r
 684                         get { return true; }\r
 685                 }\r
 686                 public override XsdOrderedFacet Ordered {\r
 687                         get { return XsdOrderedFacet.Total; }\r
 688                 }\r
 689 \r
 690                 public override Type ValueType {\r
 691                         get { return typeof (float); }\r
 692                 }\r
 693 \r
 694                 public override object ParseValue (string s,\r
 695                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 696                 {\r
 697                         return XmlConvert.ToSingle (Normalize (s));\r
 698                 }\r
 699         }\r
 700 \r
 701         // xs:double\r
 702         public class XsdDouble : XsdAnySimpleType\r
 703         {\r
 704                 // Fundamental Facets\r
 705                 public override bool Bounded {\r
 706                         get { return true; }\r
 707                 }\r
 708                 public override bool Finite {\r
 709                         get { return true; }\r
 710                 }\r
 711                 public override bool Numeric {\r
 712                         get { return true; }\r
 713                 }\r
 714                 public override XsdOrderedFacet Ordered {\r
 715                         get { return XsdOrderedFacet.Total; }\r
 716                 }\r
 717 \r
 718                 public override Type ValueType {\r
 719                         get { return typeof (double); }\r
 720                 }\r
 721 \r
 722                 public override object ParseValue (string s,\r
 723                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 724                 {\r
 725                         return XmlConvert.ToDouble (Normalize (s));\r
 726                 }\r
 727         }\r
 728 \r
 729         // xs:base64Binary\r
 730         public class XsdBase64Binary : XsdString\r
 731         {\r
 732                 internal XsdBase64Binary ()\r
 733                 {\r
 734                 }\r
 735 \r
 736                 public override Type ValueType {\r
 737                         get { return typeof (byte[]); }\r
 738                 }\r
 739 \r
 740                 public override object ParseValue (string s,\r
 741                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 742                 {\r
 743                         return Convert.FromBase64String (Normalize (s));\r
 744                 }\r
 745         }\r
 746 \r
 747         // xs:hexBinary\r
 748         public class XsdHexBinary : XsdAnySimpleType\r
 749         {\r
 750                 internal XsdHexBinary ()\r
 751                 {\r
 752                 }\r
 753 \r
 754                 public override XmlTokenizedType TokenizedType {\r
 755                         get { return XmlTokenizedType.None; }\r
 756                 }\r
 757 \r
 758                 public override Type ValueType {\r
 759                         get { return typeof (byte []); }\r
 760                 }\r
 761 \r
 762                 public override object ParseValue (string s,\r
 763                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 764                 {\r
 765                         return XmlConvert.FromBinHexString (Normalize (s));\r
 766                 }\r
 767 \r
 768                 // Fundamental Facets ... no need to override\r
 769         }\r
 770
 771         // xs:QName\r
 772         public class XsdQName : XsdName\r
 773         {\r
 774                 internal XsdQName ()\r
 775                 {\r
 776                 }\r
 777 \r
 778                 // Fundamental facets are the same as anySimpleType.\r
 779 \r
 780                 public override XmlTokenizedType TokenizedType {\r
 781                         get { return XmlTokenizedType.QName; }\r
 782                 }\r
 783 \r
 784                 public override Type ValueType {\r
 785                         get { return typeof (XmlQualifiedName); }\r
 786                 }\r
 787 \r
 788                 // ParseValue () method is as same as that of xs:string\r
 789                 public override object ParseValue (string s,\r
 790                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 791                 {\r
 792                         if (nameTable == null)\r
 793                                 throw new ArgumentNullException ("name table");\r
 794                         if (nsmgr == null)\r
 795                                 throw new ArgumentNullException ("namespace manager");\r
 796                         int colonAt = s.IndexOf (':');\r
 797                         string localName = \r
 798                                 nameTable.Add (colonAt < 0 ? s : s.Substring (colonAt + 1));\r
 799                         return new XmlQualifiedName (localName, nsmgr.LookupNamespace (\r
 800                                 colonAt < 0 ? "" : s.Substring (0, colonAt - 1)));\r
 801                 }\r
 802         }\r
 803 \r
 804         // xs:boolean\r
 805         public class XsdBoolean : XsdAnySimpleType\r
 806         {\r
 807                 internal XsdBoolean ()\r
 808                 {\r
 809                 }\r
 810 \r
 811                 public override XmlTokenizedType TokenizedType {\r
 812                         get { return XmlTokenizedType.CDATA; }\r
 813                 }\r
 814 \r
 815                 public override Type ValueType {\r
 816                         get { return typeof (bool); }\r
 817                 }\r
 818 \r
 819                 public override object ParseValue (string s,\r
 820                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 821                 {\r
 822                         return XmlConvert.ToBoolean (this.Normalize (s));\r
 823                 }\r
 824 \r
 825                 // Fundamental Facets\r
 826                 public override bool Bounded {\r
 827                         get { return false; }\r
 828                 }\r
 829                 public override bool Finite {\r
 830                         get { return true; }\r
 831                 }\r
 832                 public override bool Numeric {\r
 833                         get { return false; }\r
 834                 }\r
 835                 public override XsdOrderedFacet Ordered {\r
 836                         get { return XsdOrderedFacet.Total; }\r
 837                 }\r
 838         }\r
 839 \r
 840         // xs:anyURI\r
 841         public class XsdAnyURI : XsdString\r
 842         {\r
 843                 public override XmlTokenizedType TokenizedType {\r
 844 \r
 845                         get { return XmlTokenizedType.CDATA; }\r
 846                 }\r
 847 \r
 848                 public override Type ValueType {\r
 849                         get { return typeof (Uri); }\r
 850                 }\r
 851 \r
 852                 public override object ParseValue (string s,\r
 853                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 854                 {\r
 855                         return new Uri (Normalize (s));\r
 856                 }\r
 857         }\r
 858         \r
 859         // xs:duration\r
 860         public class XsdDuration : XsdAnySimpleType\r
 861         {\r
 862                 internal XsdDuration ()\r
 863                 {\r
 864                 }\r
 865 \r
 866                 public override XmlTokenizedType TokenizedType {\r
 867                         get { return XmlTokenizedType.CDATA; }\r
 868                 }\r
 869 \r
 870                 public override Type ValueType {\r
 871                         get { return typeof (TimeSpan); }\r
 872                 }\r
 873 \r
 874                 public override object ParseValue (string s,\r
 875                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 876                 {\r
 877                         return XmlConvert.ToTimeSpan (Normalize (s));\r
 878                 }\r
 879 \r
 880                 // Fundamental Facets\r
 881                 public override bool Bounded {\r
 882                         get { return false; }\r
 883                 }\r
 884                 public override bool Finite {\r
 885                         get { return false; }\r
 886                 }\r
 887                 public override bool Numeric {\r
 888                         get { return false; }\r
 889                 }\r
 890                 public override XsdOrderedFacet Ordered {\r
 891                         get { return XsdOrderedFacet.Partial; }\r
 892                 }\r
 893         }\r
 894 \r
 895         // xs:dateTime\r
 896         public class XsdDateTime : XsdAnySimpleType\r
 897         {\r
 898                 internal XsdDateTime ()\r
 899                 {\r
 900                 }\r
 901 \r
 902                 public override XmlTokenizedType TokenizedType {\r
 903                         get { return XmlTokenizedType.CDATA; }\r
 904                 }\r
 905 \r
 906                 public override Type ValueType {\r
 907                         get { return typeof (DateTime); }\r
 908                 }\r
 909 \r
 910                 public override object ParseValue (string s,\r
 911                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 912                 {\r
 913                         return XmlConvert.ToDateTime (Normalize (s));\r
 914                 }\r
 915 \r
 916                 // Fundamental Facets\r
 917                 public override bool Bounded {\r
 918                         get { return false; }\r
 919                 }\r
 920                 public override bool Finite {\r
 921                         get { return false; }\r
 922                 }\r
 923                 public override bool Numeric {\r
 924                         get { return false; }\r
 925                 }\r
 926                 public override XsdOrderedFacet Ordered {\r
 927                         get { return XsdOrderedFacet.Partial; }\r
 928                 }\r
 929         }\r
 930 \r
 931         // xs:date\r
 932         public class XsdDate : XsdAnySimpleType\r
 933         {\r
 934                 public override XmlTokenizedType TokenizedType {\r
 935                         get { return XmlTokenizedType.CDATA; }\r
 936                 }\r
 937 \r
 938                 public override Type ValueType {\r
 939                         get { return typeof (DateTime); }\r
 940                 }\r
 941 \r
 942                 public override object ParseValue (string s,\r
 943                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 944                 {\r
 945                         return DateTime.ParseExact (Normalize (s), "yyyy-MM-dd", null);\r
 946                 }\r
 947 \r
 948                 // Fundamental Facets ... no need to override except for Ordered.\r
 949                 public override XsdOrderedFacet Ordered {\r
 950                         get { return XsdOrderedFacet.Partial; }\r
 951                 }\r
 952         }\r
 953 \r
 954         // xs:time\r
 955         public class XsdTime : XsdAnySimpleType\r
 956         {\r
 957                 static string [] timeFormats = new string [] {\r
 958                           // copied from XmlConvert.
 959                           "HH:mm:ss",
 960                           "HH:mm:ss.f",
 961                           "HH:mm:ss.ff",
 962                           "HH:mm:ss.fff",
 963                           "HH:mm:ss.ffff",
 964                           "HH:mm:ss.fffff",
 965                           "HH:mm:ss.ffffff",
 966                           "HH:mm:ss.fffffff",
 967                           "HH:mm:sszzz",
 968                           "HH:mm:ss.fzzz",
 969                           "HH:mm:ss.ffzzz",
 970                           "HH:mm:ss.fffzzz",
 971                           "HH:mm:ss.ffffzzz",
 972                           "HH:mm:ss.fffffzzz",
 973                           "HH:mm:ss.ffffffzzz",
 974                           "HH:mm:ss.fffffffzzz",
 975                           "HH:mm:ssZ",
 976                           "HH:mm:ss.fZ",
 977                           "HH:mm:ss.ffZ",
 978                           "HH:mm:ss.fffZ",
 979                           "HH:mm:ss.ffffZ",
 980                           "HH:mm:ss.fffffZ",
 981                           "HH:mm:ss.ffffffZ",
 982                           "HH:mm:ss.fffffffZ"};
 983 \r
 984                 public override XmlTokenizedType TokenizedType {\r
 985                         get { return XmlTokenizedType.CDATA; }\r
 986                 }\r
 987 \r
 988                 public override Type ValueType {\r
 989                         get { return typeof (DateTime); }\r
 990                 }\r
 991 \r
 992                 public override object ParseValue (string s,\r
 993                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
 994                 {\r
 995                         return DateTime.ParseExact (Normalize (s), timeFormats, null, DateTimeStyles.None);\r
 996                 }\r
 997 \r
 998                 // Fundamental Facets ... no need to override except for Ordered.\r
 999                 public override XsdOrderedFacet Ordered {\r
1000                         get { return XsdOrderedFacet.Partial; }\r
1001                 }\r
1002         }\r
1003
1004         // xs:gYearMonth\r
1005         public class XsdGYearMonth : XsdAnySimpleType\r
1006         {\r
1007                 public override Type ValueType {\r
1008                         get { return typeof (DateTime); }\r
1009                 }\r
1010 \r
1011                 public override object ParseValue (string s,\r
1012                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
1013                 {\r
1014                         return DateTime.ParseExact (Normalize (s), "yyyy-MM", null);\r
1015                 }\r
1016         }\r
1017 \r
1018         // xs:gMonthDay\r
1019         public class XsdGMonthDay : XsdAnySimpleType\r
1020         {\r
1021                 public override Type ValueType {\r
1022                         get { return typeof (DateTime); }\r
1023                 }\r
1024 \r
1025                 public override object ParseValue (string s,\r
1026                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
1027                 {\r
1028                         return DateTime.ParseExact (Normalize (s), "--MM-dd", null);\r
1029                 }\r
1030         }\r
1031 \r
1032         // xs:gYear\r
1033         public class XsdGYear : XsdAnySimpleType\r
1034         {\r
1035                 public override Type ValueType {\r
1036                         get { return typeof (DateTime); }\r
1037                 }\r
1038 \r
1039                 // LAMESPEC: XML Schema Datatypes allows leading '-' to identify B.C. years,\r
1040                 // but CLR DateTime does not allow such expression.\r
1041                 public override object ParseValue (string s,\r
1042                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
1043                 {\r
1044                         return DateTime.ParseExact (s, "yyyy", null);\r
1045                 }\r
1046         }\r
1047 \r
1048         // xs:gMonth\r
1049         public class XsdGMonth : XsdAnySimpleType\r
1050         {\r
1051                 public override Type ValueType {\r
1052                         get { return typeof (DateTime); }\r
1053                 }\r
1054 \r
1055                 public override object ParseValue (string s,\r
1056                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
1057                 {\r
1058                         return DateTime.ParseExact (s, "--MM--", null);\r
1059                 }\r
1060         }\r
1061 \r
1062         // xs:gDay\r
1063         public class XsdGDay : XsdAnySimpleType\r
1064         {\r
1065                 public override Type ValueType {\r
1066                         get { return typeof (DateTime); }\r
1067                 }\r
1068 \r
1069                 public override object ParseValue (string s,\r
1070                         XmlNameTable nameTable, XmlNamespaceManager nsmgr)\r
1071                 {\r
1072                         return DateTime.ParseExact (s, "---dd", null);\r
1073                 }\r
1074         }\r
1075 \r
1076 }