class/System.XML/System.Xml.Schema/XmlValueConverter.cs

   1 //
   2 // XmlValueConverter.cs
   3 //
   4 // Author:
   5 //      Atsushi Enomoto <atsushi@ximian.com>
   6 //
   7 // (C)2004 Novell Inc,
   8 //
   9
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 #if NET_2_0
  32
  33 using System;
  34
  35 namespace System.Xml.Schema
  36 {
  37         public abstract class XmlValueConverter
  38         {
  39                 [MonoTODO]
  40                 protected XmlValueConverter ()
  41                 {
  42                 }
  43
  44                 public abstract object ChangeType (bool value, Type type);
  45
  46                 public abstract object ChangeType (DateTime value, Type type);
  47
  48                 public abstract object ChangeType (decimal value, Type type);
  49
  50                 public abstract object ChangeType (double value, Type type);
  51
  52                 public abstract object ChangeType (int value, Type type);
  53
  54                 public abstract object ChangeType (long value, Type type);
  55
  56                 public abstract object ChangeType (object value, Type type);
  57
  58                 public abstract object ChangeType (float value, Type type);
  59
  60                 public abstract object ChangeType (string value, Type type);
  61
  62                 public abstract object ChangeType (object value, Type type, IXmlNamespaceResolver nsResolver);
  63
  64                 public abstract object ChangeType (string value, Type type, IXmlNamespaceResolver nsResolver);
  65
  66                 public abstract bool ToBoolean (bool value);
  67
  68                 public abstract bool ToBoolean (DateTime value);
  69
  70                 public abstract bool ToBoolean (decimal value);
  71
  72                 public abstract bool ToBoolean (double value);
  73
  74                 public abstract bool ToBoolean (int value);
  75
  76                 public abstract bool ToBoolean (long value);
  77
  78                 public abstract bool ToBoolean (object value);
  79
  80                 public abstract bool ToBoolean (float value);
  81
  82                 public abstract bool ToBoolean (string value);
  83
  84                 public abstract DateTime ToDateTime (bool value);
  85
  86                 public abstract DateTime ToDateTime (DateTime value);
  87
  88                 public abstract DateTime ToDateTime (decimal value);
  89
  90                 public abstract DateTime ToDateTime (double value);
  91
  92                 public abstract DateTime ToDateTime (int value);
  93
  94                 public abstract DateTime ToDateTime (long value);
  95
  96                 public abstract DateTime ToDateTime (object value);
  97
  98                 public abstract DateTime ToDateTime (float value);
  99
 100                 public abstract DateTime ToDateTime (string value);
 101
 102                 public abstract decimal ToDecimal (bool value);
 103
 104                 public abstract decimal ToDecimal (DateTime value);
 105
 106                 public abstract decimal ToDecimal (decimal value);
 107
 108                 public abstract decimal ToDecimal (double value);
 109
 110                 public abstract decimal ToDecimal (int value);
 111
 112                 public abstract decimal ToDecimal (long value);
 113
 114                 public abstract decimal ToDecimal (object value);
 115
 116                 public abstract decimal ToDecimal (float value);
 117
 118                 public abstract decimal ToDecimal (string value);
 119
 120                 public abstract double ToDouble (bool value);
 121
 122                 public abstract double ToDouble (DateTime value);
 123
 124                 public abstract double ToDouble (decimal value);
 125
 126                 public abstract double ToDouble (double value);
 127
 128                 public abstract double ToDouble (int value);
 129
 130                 public abstract double ToDouble (long value);
 131
 132                 public abstract double ToDouble (object value);
 133
 134                 public abstract double ToDouble (float value);
 135
 136                 public abstract double ToDouble (string value);
 137
 138                 public abstract int ToInt32 (bool value);
 139
 140                 public abstract int ToInt32 (DateTime value);
 141
 142                 public abstract int ToInt32 (decimal value);
 143
 144                 public abstract int ToInt32 (double value);
 145
 146                 public abstract int ToInt32 (int value);
 147
 148                 public abstract int ToInt32 (long value);
 149
 150                 public abstract int ToInt32 (object value);
 151
 152                 public abstract int ToInt32 (float value);
 153
 154                 public abstract int ToInt32 (string value);
 155
 156                 public abstract long ToInt64 (bool value);
 157
 158                 public abstract long ToInt64 (DateTime value);
 159
 160                 public abstract long ToInt64 (decimal value);
 161
 162                 public abstract long ToInt64 (double value);
 163
 164                 public abstract long ToInt64 (int value);
 165
 166                 public abstract long ToInt64 (long value);
 167
 168                 public abstract long ToInt64 (object value);
 169
 170                 public abstract long ToInt64 (float value);
 171
 172                 public abstract long ToInt64 (string value);
 173
 174                 public abstract float ToSingle (bool value);
 175
 176                 public abstract float ToSingle (DateTime value);
 177
 178                 public abstract float ToSingle (decimal value);
 179
 180                 public abstract float ToSingle (double value);
 181
 182                 public abstract float ToSingle (int value);
 183
 184                 public abstract float ToSingle (long value);
 185
 186                 public abstract float ToSingle (object value);
 187
 188                 public abstract float ToSingle (float value);
 189
 190                 public abstract float ToSingle (string value);
 191
 192                 public abstract string ToString (bool value);
 193
 194                 public abstract string ToString (DateTime value);
 195
 196                 public abstract string ToString (decimal value);
 197
 198                 public abstract string ToString (double value);
 199
 200                 public abstract string ToString (int value);
 201
 202                 public abstract string ToString (long value);
 203
 204                 public abstract string ToString (object value);
 205
 206                 public abstract string ToString (object value, IXmlNamespaceResolver nsResolver);
 207
 208                 public abstract string ToString (float value);
 209
 210                 public abstract string ToString (string value);
 211
 212                 public abstract string ToString (string value, IXmlNamespaceResolver nsResolver);
 213         }
 214
 215         internal class XsdNonPermissiveConverter : XmlValueConverter
 216         {
 217                 readonly XmlTypeCode typeCode;
 218
 219                 public XsdNonPermissiveConverter (XmlTypeCode typeCode)
 220                 {
 221                         this.typeCode = typeCode;
 222                 }
 223
 224                 public XmlTypeCode Code {
 225                         get { return typeCode; }
 226                 }
 227
 228                 public override object ChangeType (bool value, Type type)
 229                 {
 230                         return ChangeType ((object) value, type);
 231                 }
 232
 233                 public override object ChangeType (DateTime value, Type type)
 234                 {
 235                         return ChangeType ((object) value, type);
 236                 }
 237
 238                 public override object ChangeType (decimal value, Type type)
 239                 {
 240                         return ChangeType ((object) value, type);
 241                 }
 242
 243                 public override object ChangeType (double value, Type type)
 244                 {
 245                         return ChangeType ((object) value, type);
 246                 }
 247
 248                 public override object ChangeType (int value, Type type)
 249                 {
 250                         return ChangeType ((object) value, type);
 251                 }
 252
 253                 public override object ChangeType (long value, Type type)
 254                 {
 255                         return ChangeType ((object) value, type);
 256                 }
 257
 258                 public override object ChangeType (float value, Type type)
 259                 {
 260                         return ChangeType ((object) value, type);
 261                 }
 262
 263                 public override object ChangeType (string value, Type type)
 264                 {
 265                         return ChangeType ((object) value, type);
 266                 }
 267
 268                 public override object ChangeType (object value, Type type)
 269                 {
 270                         return ChangeType (value, type, null);
 271                 }
 272
 273                 [MonoTODO]
 274                 public override object ChangeType (object value, Type type, IXmlNamespaceResolver nsResolver)
 275                 {
 276                         if (value == null)
 277                                 throw new ArgumentNullException ("value");
 278                         if (type == null)
 279                                 throw new ArgumentNullException ("type");
 280                         switch (Type.GetTypeCode (value.GetType ())) {
 281                         case TypeCode.Boolean:
 282                                 bool bvalue = (bool) value;
 283                                 switch (Type.GetTypeCode (type)) {
 284                                 case TypeCode.Boolean:
 285                                         return ToBoolean (bvalue);
 286                                 case TypeCode.DateTime:
 287                                         return ToDateTime (bvalue);
 288                                 case TypeCode.Decimal:
 289                                         return ToDecimal (bvalue);
 290                                 case TypeCode.Double:
 291                                         return ToDouble (bvalue);
 292                                 case TypeCode.Int32:
 293                                         return ToInt32 (bvalue);
 294                                 case TypeCode.Int64:
 295                                         return ToInt64 (bvalue);
 296                                 case TypeCode.Single:
 297                                         return ToSingle (bvalue);
 298                                 case TypeCode.String:
 299                                         return ToString (bvalue);
 300                                 }
 301                                 break;
 302 //                      case TypeCode.Byte:
 303 //                      case TypeCode.Char:
 304                         case TypeCode.DateTime:
 305                                 DateTime dtvalue = (DateTime) value;
 306                                 switch (Type.GetTypeCode (type)) {
 307                                 case TypeCode.Boolean:
 308                                         return ToBoolean (dtvalue);
 309                                 case TypeCode.DateTime:
 310                                         return ToDateTime (dtvalue);
 311                                 case TypeCode.Decimal:
 312                                         return ToDecimal (dtvalue);
 313                                 case TypeCode.Double:
 314                                         return ToDouble (dtvalue);
 315                                 case TypeCode.Int32:
 316                                         return ToInt32 (dtvalue);
 317                                 case TypeCode.Int64:
 318                                         return ToInt64 (dtvalue);
 319                                 case TypeCode.Single:
 320                                         return ToSingle (dtvalue);
 321                                 case TypeCode.String:
 322                                         return ToString (dtvalue);
 323                                 }
 324                                 break;
 325 //                      case TypeCode.DBNull:
 326                         case TypeCode.Decimal:
 327                                 decimal decvalue = (decimal) value;
 328                                 switch (Type.GetTypeCode (type)) {
 329                                 case TypeCode.Boolean:
 330                                         return ToBoolean (decvalue);
 331                                 case TypeCode.DateTime:
 332                                         return ToDateTime (decvalue);
 333                                 case TypeCode.Decimal:
 334                                         return ToDecimal (decvalue);
 335                                 case TypeCode.Double:
 336                                         return ToDouble (decvalue);
 337                                 case TypeCode.Int32:
 338                                         return ToInt32 (decvalue);
 339                                 case TypeCode.Int64:
 340                                         return ToInt64 (decvalue);
 341                                 case TypeCode.Single:
 342                                         return ToSingle (decvalue);
 343                                 case TypeCode.String:
 344                                         return ToString (decvalue);
 345                                 }
 346                                 break;
 347                         case TypeCode.Double:
 348                                 double dblvalue = (double) value;
 349                                 switch (Type.GetTypeCode (type)) {
 350                                 case TypeCode.Boolean:
 351                                         return ToBoolean (dblvalue);
 352                                 case TypeCode.DateTime:
 353                                         return ToDateTime (dblvalue);
 354                                 case TypeCode.Decimal:
 355                                         return ToDecimal (dblvalue);
 356                                 case TypeCode.Double:
 357                                         return ToDouble (dblvalue);
 358                                 case TypeCode.Int32:
 359                                         return ToInt32 (dblvalue);
 360                                 case TypeCode.Int64:
 361                                         return ToInt64 (dblvalue);
 362                                 case TypeCode.Single:
 363                                         return ToSingle (dblvalue);
 364                                 case TypeCode.String:
 365                                         return ToString (dblvalue);
 366                                 }
 367                                 break;
 368 //                      case TypeCode.Empty:
 369 //                      case TypeCode.Int16:
 370                         case TypeCode.Int32:
 371                                 int ivalue = (int) value;
 372                                 switch (Type.GetTypeCode (type)) {
 373                                 case TypeCode.Boolean:
 374                                         return ToBoolean (ivalue);
 375                                 case TypeCode.DateTime:
 376                                         return ToDateTime (ivalue);
 377                                 case TypeCode.Decimal:
 378                                         return ToDecimal (ivalue);
 379                                 case TypeCode.Double:
 380                                         return ToDouble (ivalue);
 381                                 case TypeCode.Int32:
 382                                         return ToInt32 (ivalue);
 383                                 case TypeCode.Int64:
 384                                         return ToInt64 (ivalue);
 385                                 case TypeCode.Single:
 386                                         return ToSingle (ivalue);
 387                                 case TypeCode.String:
 388                                         return ToString (ivalue);
 389                                 }
 390                                 break;
 391                         case TypeCode.Int64:
 392                                 long lvalue = (long) value;
 393                                 switch (Type.GetTypeCode (type)) {
 394                                 case TypeCode.Boolean:
 395                                         return ToBoolean (lvalue);
 396                                 case TypeCode.DateTime:
 397                                         return ToDateTime (lvalue);
 398                                 case TypeCode.Decimal:
 399                                         return ToDecimal (lvalue);
 400                                 case TypeCode.Double:
 401                                         return ToDouble (lvalue);
 402                                 case TypeCode.Int32:
 403                                         return ToInt32 (lvalue);
 404                                 case TypeCode.Int64:
 405                                         return ToInt64 (lvalue);
 406                                 case TypeCode.Single:
 407                                         return ToSingle (lvalue);
 408                                 case TypeCode.String:
 409                                         return ToString (lvalue);
 410                                 }
 411                                 break;
 412 //                      case TypeCode.Object:
 413 //                      case TypeCode.SByte:
 414                         case TypeCode.Single:
 415                                 float fvalue = (float) value;
 416                                 switch (Type.GetTypeCode (type)) {
 417                                 case TypeCode.Boolean:
 418                                         return ToBoolean (fvalue);
 419                                 case TypeCode.DateTime:
 420                                         return ToDateTime (fvalue);
 421                                 case TypeCode.Decimal:
 422                                         return ToDecimal (fvalue);
 423                                 case TypeCode.Double:
 424                                         return ToDouble (fvalue);
 425                                 case TypeCode.Int32:
 426                                         return ToInt32 (fvalue);
 427                                 case TypeCode.Int64:
 428                                         return ToInt64 (fvalue);
 429                                 case TypeCode.Single:
 430                                         return ToSingle (fvalue);
 431                                 case TypeCode.String:
 432                                         return ToString (fvalue);
 433                                 }
 434                                 break;
 435                         case TypeCode.String:
 436                                 string svalue = (string) value;
 437                                 switch (Type.GetTypeCode (type)) {
 438                                 case TypeCode.Boolean:
 439                                         return ToBoolean (svalue);
 440                                 case TypeCode.DateTime:
 441                                         return ToDateTime (svalue);
 442                                 case TypeCode.Decimal:
 443                                         return ToDecimal (svalue);
 444                                 case TypeCode.Double:
 445                                         return ToDouble (svalue);
 446                                 case TypeCode.Int32:
 447                                         return ToInt32 (svalue);
 448                                 case TypeCode.Int64:
 449                                         return ToInt64 (svalue);
 450                                 case TypeCode.Single:
 451                                         return ToSingle (svalue);
 452                                 case TypeCode.String:
 453                                         return ToString (svalue);
 454                                 }
 455                                 break;
 456 //                      case TypeCode.UInt16:
 457 //                      case TypeCode.UInt32:
 458 //                      case TypeCode.UInt64:
 459                         default:
 460                                 if (type == typeof (TimeSpan))
 461                                         // xs:duration, xdt:yearMonthDuration,
 462                                         // xdt:dayTimeDuration. FIXME: yMD to
 463                                         // dTD and dTD to yMD are not allowed.
 464                                         return ToTimeSpan (value);
 465                                 if (value.GetType () == typeof (byte [])) {
 466                                         // xs:base64 by default
 467                                         if (type == typeof (string))
 468                                                 return XQueryConvert.Base64BinaryToString ((byte []) value);
 469                                         else if (type == typeof (byte []))
 470                                                 return value;
 471                                 }
 472                                 if (value.GetType () == type) {
 473                                         if (type == typeof (XmlQualifiedName)) {
 474                                                 // xs:QName and xs:NOTATION
 475                                                 throw new NotImplementedException ();
 476                                         }
 477                                 }
 478                                 break;
 479                         }
 480                         throw Error (value.GetType (), type);
 481                 }
 482
 483                 public override object ChangeType (string value, Type type, IXmlNamespaceResolver nsResolver)
 484                 {
 485                         return ChangeType ((object) value, type, nsResolver);
 486                 }
 487
 488                 public TimeSpan ToTimeSpan (bool value)
 489                 {
 490                         throw Error (typeof (bool), typeof (TimeSpan));
 491                 }
 492
 493                 public TimeSpan ToTimeSpan (DateTime value)
 494                 {
 495                         throw Error (typeof (bool), typeof (TimeSpan));
 496                 }
 497
 498                 public TimeSpan ToTimeSpan (decimal value)
 499                 {
 500                         throw Error (typeof (bool), typeof (TimeSpan));
 501                 }
 502
 503                 public TimeSpan ToTimeSpan (double value)
 504                 {
 505                         throw Error (typeof (bool), typeof (TimeSpan));
 506                 }
 507
 508                 public TimeSpan ToTimeSpan (int value)
 509                 {
 510                         throw Error (typeof (bool), typeof (TimeSpan));
 511                 }
 512
 513                 public TimeSpan ToTimeSpan (long value)
 514                 {
 515                         throw Error (typeof (bool), typeof (TimeSpan));
 516                 }
 517
 518                 public virtual TimeSpan ToTimeSpan (object value)
 519                 {
 520                         // Allow on overriden converter for xs:duration,
 521                         // xdt:dayTimeDuration and xdt:yearMonthDuration.
 522                         throw Error (typeof (bool), typeof (TimeSpan));
 523                 }
 524
 525                 public TimeSpan ToTimeSpan (float value)
 526                 {
 527                         throw Error (typeof (bool), typeof (TimeSpan));
 528                 }
 529
 530                 public TimeSpan ToTimeSpan (string value)
 531                 {
 532                         throw Error (typeof (bool), typeof (TimeSpan));
 533                 }
 534
 535                 protected InvalidCastException Error (Type valueType, Type destType)
 536                 {
 537                         return new InvalidCastException (String.Format ("The conversion from {0} value to {1} type via {2} type is not allowed.", valueType, destType, typeCode));
 538                 }
 539
 540                 public override bool ToBoolean (bool value)
 541                 {
 542                         throw Error (typeof (bool), typeof (bool));
 543                 }
 544
 545                 public override bool ToBoolean (DateTime value)
 546                 {
 547                         throw Error (typeof (DateTime), typeof (bool));
 548                 }
 549
 550                 public override bool ToBoolean (decimal value)
 551                 {
 552                         throw Error (typeof (decimal), typeof (bool));
 553                 }
 554
 555                 public override bool ToBoolean (double value)
 556                 {
 557                         throw Error (typeof (double), typeof (bool));
 558                 }
 559
 560                 public override bool ToBoolean (int value)
 561                 {
 562                         throw Error (typeof (int), typeof (bool));
 563                 }
 564
 565                 public override bool ToBoolean (long value)
 566                 {
 567                         throw Error (typeof (long), typeof (bool));
 568                 }
 569
 570                 public override bool ToBoolean (object value)
 571                 {
 572                         if (value == null)
 573                                 throw new ArgumentNullException ("value");
 574                         throw Error (value.GetType (), typeof (bool));
 575                 }
 576
 577                 public override bool ToBoolean (float value)
 578                 {
 579                         throw Error (typeof (float), typeof (bool));
 580                 }
 581
 582                 public override bool ToBoolean (string value)
 583                 {
 584                         throw Error (typeof (string), typeof (bool));
 585                 }
 586
 587                 public override DateTime ToDateTime (bool value)
 588                 {
 589                         throw Error (typeof (bool), typeof (DateTime));
 590                 }
 591
 592                 public override DateTime ToDateTime (DateTime value)
 593                 {
 594                         throw Error (typeof (DateTime), typeof (DateTime));
 595                 }
 596
 597                 public override DateTime ToDateTime (decimal value)
 598                 {
 599                         throw Error (typeof (decimal), typeof (DateTime));
 600                 }
 601
 602                 public override DateTime ToDateTime (double value)
 603                 {
 604                         throw Error (typeof (double), typeof (DateTime));
 605                 }
 606
 607                 public override DateTime ToDateTime (int value)
 608                 {
 609                         throw Error (typeof (int), typeof (DateTime));
 610                 }
 611
 612                 public override DateTime ToDateTime (long value)
 613                 {
 614                         throw Error (typeof (long), typeof (DateTime));
 615                 }
 616
 617                 public override DateTime ToDateTime (object value)
 618                 {
 619                         if (value == null)
 620                                 throw new ArgumentNullException ("value");
 621                         throw Error (value.GetType (), typeof (DateTime));
 622                 }
 623
 624                 public override DateTime ToDateTime (float value)
 625                 {
 626                         throw Error (typeof (float), typeof (DateTime));
 627                 }
 628
 629                 public override DateTime ToDateTime (string value)
 630                 {
 631                         throw Error (typeof (string), typeof (DateTime));
 632                 }
 633
 634                 public override decimal ToDecimal (bool value)
 635                 {
 636                         throw Error (typeof (bool), typeof (decimal));
 637                 }
 638
 639                 public override decimal ToDecimal (DateTime value)
 640                 {
 641                         throw Error (typeof (DateTime), typeof (decimal));
 642                 }
 643
 644                 public override decimal ToDecimal (decimal value)
 645                 {
 646                         throw Error (typeof (decimal), typeof (decimal));
 647                 }
 648
 649                 public override decimal ToDecimal (double value)
 650                 {
 651                         throw Error (typeof (double), typeof (decimal));
 652                 }
 653
 654                 public override decimal ToDecimal (int value)
 655                 {
 656                         throw Error (typeof (int), typeof (decimal));
 657                 }
 658
 659                 public override decimal ToDecimal (long value)
 660                 {
 661                         throw Error (typeof (long), typeof (decimal));
 662                 }
 663
 664                 public override decimal ToDecimal (object value)
 665                 {
 666                         if (value == null)
 667                                 throw new ArgumentNullException ("value");
 668                         throw Error (value.GetType (), typeof (decimal));
 669                 }
 670
 671                 public override decimal ToDecimal (float value)
 672                 {
 673                         throw Error (typeof (float), typeof (decimal));
 674                 }
 675
 676                 public override decimal ToDecimal (string value)
 677                 {
 678                         throw Error (typeof (string), typeof (decimal));
 679                 }
 680
 681                 public override double ToDouble (bool value)
 682                 {
 683                         throw Error (typeof (bool), typeof (double));
 684                 }
 685
 686                 public override double ToDouble (DateTime value)
 687                 {
 688                         throw Error (typeof (DateTime), typeof (double));
 689                 }
 690
 691                 public override double ToDouble (decimal value)
 692                 {
 693                         throw Error (typeof (decimal), typeof (double));
 694                 }
 695
 696                 public override double ToDouble (double value)
 697                 {
 698                         throw Error (typeof (double), typeof (double));
 699                 }
 700
 701                 public override double ToDouble (int value)
 702                 {
 703                         throw Error (typeof (int), typeof (double));
 704                 }
 705
 706                 public override double ToDouble (long value)
 707                 {
 708                         throw Error (typeof (long), typeof (double));
 709                 }
 710
 711                 public override double ToDouble (object value)
 712                 {
 713                         if (value == null)
 714                                 throw new ArgumentNullException ("value");
 715                         throw Error (value.GetType (), typeof (double));
 716                 }
 717
 718                 public override double ToDouble (float value)
 719                 {
 720                         throw Error (typeof (float), typeof (double));
 721                 }
 722
 723                 public override double ToDouble (string value)
 724                 {
 725                         throw Error (typeof (string), typeof (double));
 726                 }
 727
 728                 public override float ToSingle (bool value)
 729                 {
 730                         throw Error (typeof (bool), typeof (float));
 731                 }
 732
 733                 public override float ToSingle (DateTime value)
 734                 {
 735                         throw Error (typeof (DateTime), typeof (float));
 736                 }
 737
 738                 public override float ToSingle (decimal value)
 739                 {
 740                         throw Error (typeof (decimal), typeof (float));
 741                 }
 742
 743                 public override float ToSingle (double value)
 744                 {
 745                         throw Error (typeof (double), typeof (float));
 746                 }
 747
 748                 public override float ToSingle (int value)
 749                 {
 750                         throw Error (typeof (int), typeof (float));
 751                 }
 752
 753                 public override float ToSingle (long value)
 754                 {
 755                         throw Error (typeof (long), typeof (float));
 756                 }
 757
 758                 public override float ToSingle (object value)
 759                 {
 760                         if (value == null)
 761                                 throw new ArgumentNullException ("value");
 762                         throw Error (value.GetType (), typeof (float));
 763                 }
 764
 765                 public override float ToSingle (float value)
 766                 {
 767                         throw Error (typeof (float), typeof (float));
 768                 }
 769
 770                 public override float ToSingle (string value)
 771                 {
 772                         throw Error (typeof (string), typeof (float));
 773                 }
 774
 775                 public override int ToInt32 (bool value)
 776                 {
 777                         throw Error (typeof (bool), typeof (int));
 778                 }
 779
 780                 public override int ToInt32 (DateTime value)
 781                 {
 782                         throw Error (typeof (DateTime), typeof (int));
 783                 }
 784
 785                 public override int ToInt32 (decimal value)
 786                 {
 787                         throw Error (typeof (decimal), typeof (int));
 788                 }
 789
 790                 public override int ToInt32 (double value)
 791                 {
 792                         throw Error (typeof (double), typeof (int));
 793                 }
 794
 795                 public override int ToInt32 (int value)
 796                 {
 797                         throw Error (typeof (int), typeof (int));
 798                 }
 799
 800                 public override int ToInt32 (long value)
 801                 {
 802                         throw Error (typeof (long), typeof (int));
 803                 }
 804
 805                 public override int ToInt32 (object value)
 806                 {
 807                         if (value == null)
 808                                 throw new ArgumentNullException ("value");
 809                         throw Error (value.GetType (), typeof (int));
 810                 }
 811
 812                 public override int ToInt32 (float value)
 813                 {
 814                         throw Error (typeof (float), typeof (int));
 815                 }
 816
 817                 public override int ToInt32 (string value)
 818                 {
 819                         throw Error (typeof (string), typeof (int));
 820                 }
 821
 822                 public override long ToInt64 (bool value)
 823                 {
 824                         throw Error (typeof (bool), typeof (long));
 825                 }
 826
 827                 public override long ToInt64 (DateTime value)
 828                 {
 829                         throw Error (typeof (DateTime), typeof (long));
 830                 }
 831
 832                 public override long ToInt64 (decimal value)
 833                 {
 834                         throw Error (typeof (decimal), typeof (long));
 835                 }
 836
 837                 public override long ToInt64 (double value)
 838                 {
 839                         throw Error (typeof (double), typeof (long));
 840                 }
 841
 842                 public override long ToInt64 (int value)
 843                 {
 844                         throw Error (typeof (int), typeof (long));
 845                 }
 846
 847                 public override long ToInt64 (long value)
 848                 {
 849                         throw Error (typeof (long), typeof (long));
 850                 }
 851
 852                 public override long ToInt64 (object value)
 853                 {
 854                         if (value == null)
 855                                 throw new ArgumentNullException ("value");
 856                         throw Error (value.GetType (), typeof (long));
 857                 }
 858
 859                 public override long ToInt64 (float value)
 860                 {
 861                         throw Error (typeof (float), typeof (long));
 862                 }
 863
 864                 public override long ToInt64 (string value)
 865                 {
 866                         throw Error (typeof (string), typeof (long));
 867                 }
 868
 869                 public override string ToString (bool value)
 870                 {
 871                         throw Error (typeof (bool), typeof (string));
 872                 }
 873
 874                 public override string ToString (DateTime value)
 875                 {
 876                         throw Error (typeof (DateTime), typeof (string));
 877                 }
 878
 879                 public override string ToString (decimal value)
 880                 {
 881                         throw Error (typeof (decimal), typeof (string));
 882                 }
 883
 884                 public override string ToString (double value)
 885                 {
 886                         throw Error (typeof (double), typeof (string));
 887                 }
 888
 889                 public override string ToString (int value)
 890                 {
 891                         throw Error (typeof (int), typeof (string));
 892                 }
 893
 894                 public override string ToString (long value)
 895                 {
 896                         throw Error (typeof (long), typeof (string));
 897                 }
 898
 899                 public override string ToString (object value)
 900                 {
 901                         return ToString (value, null);
 902                 }
 903
 904                 public override string ToString (object value, IXmlNamespaceResolver nsResolver)
 905                 {
 906                         if (value == null)
 907                                 throw new ArgumentNullException ("value");
 908                         throw Error (value.GetType (), typeof (string));
 909                 }
 910
 911                 public override string ToString (float value)
 912                 {
 913                         throw Error (typeof (float), typeof (string));
 914                 }
 915
 916                 public override string ToString (string value)
 917                 {
 918                         return ToString (value, null);
 919                 }
 920
 921                 public override string ToString (string value, IXmlNamespaceResolver nsResolver)
 922                 {
 923                         throw Error (typeof (string), typeof (string));
 924                 }
 925         }
 926
 927         internal class XsdLaxConverter : XsdNonPermissiveConverter
 928         {
 929                 public XsdLaxConverter (XmlTypeCode code)
 930                         : base (code)
 931                 {
 932                 }
 933
 934                 public override string ToString (bool value)
 935                 {
 936                         return XmlConvert.ToString (value);
 937                 }
 938
 939                 public override string ToString (decimal value)
 940                 {
 941                         return XmlConvert.ToString (value);
 942                 }
 943
 944                 public override string ToString (double value)
 945                 {
 946                         return XmlConvert.ToString (value);
 947                 }
 948
 949                 public override string ToString (int value)
 950                 {
 951                         return XmlConvert.ToString (value);
 952                 }
 953
 954                 public override string ToString (long value)
 955                 {
 956                         return XmlConvert.ToString (value);
 957                 }
 958
 959                 public override string ToString (object value)
 960                 {
 961                         return ChangeType (value, typeof (string)) as string;
 962                 }
 963
 964                 public override string ToString (float value)
 965                 {
 966                         return XmlConvert.ToString (value);
 967                 }
 968
 969                 public override bool ToBoolean (bool value)
 970                 {
 971                         return value;
 972                 }
 973
 974                 public override decimal ToDecimal (decimal value)
 975                 {
 976                         return value;
 977                 }
 978
 979                 public override decimal ToDecimal (double value)
 980                 {
 981                         return (decimal) value;
 982                 }
 983
 984                 public override decimal ToDecimal (int value)
 985                 {
 986                         return (decimal) value;
 987                 }
 988
 989                 public override decimal ToDecimal (long value)
 990                 {
 991                         return (decimal) value;
 992                 }
 993
 994                 [MonoTODO]
 995                 public override decimal ToDecimal (object value)
 996                 {
 997                         return (decimal) ChangeType (value, typeof (decimal));
 998                 }
 999
1000                 public override decimal ToDecimal (float value)
1001                 {
1002                         return (decimal) value;
1003                 }
1004
1005                 public override double ToDouble (decimal value)
1006                 {
1007                         return (double) value;
1008                 }
1009
1010                 public override double ToDouble (double value)
1011                 {
1012                         return (double) value;
1013                 }
1014
1015                 public override double ToDouble (int value)
1016                 {
1017                         return (double) value;
1018                 }
1019
1020                 public override double ToDouble (long value)
1021                 {
1022                         return (double) value;
1023                 }
1024
1025                 [MonoTODO]
1026                 public override double ToDouble (object value)
1027                 {
1028                         return (double) ChangeType (value, typeof (double));
1029                 }
1030
1031                 public override double ToDouble (float value)
1032                 {
1033                         return (double) value;
1034                 }
1035
1036                 public override float ToSingle (decimal value)
1037                 {
1038                         return (float) value;
1039                 }
1040
1041                 public override float ToSingle (double value)
1042                 {
1043                         return (float) value;
1044                 }
1045
1046                 public override float ToSingle (int value)
1047                 {
1048                         return (float) value;
1049                 }
1050
1051                 public override float ToSingle (long value)
1052                 {
1053                         return (float) value;
1054                 }
1055
1056                 [MonoTODO]
1057                 public override float ToSingle (object value)
1058                 {
1059                         return (float) ChangeType (value, typeof (float));
1060                 }
1061
1062                 public override float ToSingle (float value)
1063                 {
1064                         return (float) value;
1065                 }
1066
1067                 public override int ToInt32 (int value)
1068                 {
1069                         return value;
1070                 }
1071
1072                 public override int ToInt32 (long value)
1073                 {
1074                         return XQueryConvert.IntegerToInt (value);
1075                 }
1076
1077                 [MonoTODO]
1078                 public override int ToInt32 (object value)
1079                 {
1080                         return (int) ChangeType (value, typeof (int));
1081                 }
1082
1083                 public override long ToInt64 (int value)
1084                 {
1085                         return value;
1086                 }
1087
1088                 public override long ToInt64 (long value)
1089                 {
1090                         return value;
1091                 }
1092
1093                 [MonoTODO]
1094                 public override long ToInt64 (object value)
1095                 {
1096                         return (long) ChangeType (value, typeof (long));
1097                 }
1098         }
1099
1100         internal class XsdAnyTypeConverter : XsdNumericConverter
1101         {
1102                 public XsdAnyTypeConverter (XmlTypeCode code)
1103                         : base (code)
1104                 {
1105                 }
1106
1107                 #region boolean
1108                 public override bool ToBoolean (decimal value)
1109                 {
1110                         return value != 0;
1111                 }
1112
1113                 public override bool ToBoolean (double value)
1114                 {
1115                         return value != 0;
1116                 }
1117
1118                 public override bool ToBoolean (int value)
1119                 {
1120                         return value != 0;
1121                 }
1122
1123                 public override bool ToBoolean (long value)
1124                 {
1125                         return value != 0;
1126                 }
1127
1128                 [MonoTODO]
1129                 public override bool ToBoolean (object value)
1130                 {
1131                         return (bool) ChangeType (value, typeof (bool));
1132                 }
1133
1134                 public override bool ToBoolean (float value)
1135                 {
1136                         return value != 0;
1137                 }
1138
1139                 public override decimal ToDecimal (bool value)
1140                 {
1141                         return value ? 1 : 0;
1142                 }
1143
1144                 public override double ToDouble (bool value)
1145                 {
1146                         return value ? 1 : 0;
1147                 }
1148
1149                 public override float ToSingle (bool value)
1150                 {
1151                         return value ? 1 : 0;
1152                 }
1153
1154                 public override int ToInt32 (bool value)
1155                 {
1156                         return value ? 1 : 0;
1157                 }
1158
1159                 public override long ToInt64 (bool value)
1160                 {
1161                         return value ? 1 : 0;
1162                 }
1163                 #endregion
1164
1165                 #region string
1166
1167                 public override DateTime ToDateTime (DateTime value)
1168                 {
1169                         return value;
1170                 }
1171
1172                 public override string ToString (DateTime value)
1173                 {
1174                         return XmlConvert.ToString (value);
1175                 }
1176
1177                 public override string ToString (string value)
1178                 {
1179                         return value;
1180                 }
1181                 #endregion
1182         }
1183
1184         internal class XsdStringConverter : XsdLaxConverter
1185         {
1186                 public XsdStringConverter (XmlTypeCode code)
1187                         : base (code)
1188                 {
1189                 }
1190
1191                 public override DateTime ToDateTime (DateTime value)
1192                 {
1193                         return value;
1194                 }
1195
1196                 public override string ToString (DateTime value)
1197                 {
1198                         return XmlConvert.ToString (value);
1199                 }
1200
1201                 public override string ToString (string value)
1202                 {
1203                         return value;
1204                 }
1205         }
1206
1207         internal class XsdNumericConverter : XsdLaxConverter
1208         {
1209                 public XsdNumericConverter (XmlTypeCode code)
1210                         : base (code)
1211                 {
1212                 }
1213
1214                 #region boolean
1215                 public override bool ToBoolean (decimal value)
1216                 {
1217                         return value != 0;
1218                 }
1219
1220                 public override bool ToBoolean (double value)
1221                 {
1222                         return value != 0;
1223                 }
1224
1225                 public override bool ToBoolean (int value)
1226                 {
1227                         return value != 0;
1228                 }
1229
1230                 public override bool ToBoolean (long value)
1231                 {
1232                         return value != 0;
1233                 }
1234
1235                 [MonoTODO]
1236                 public override bool ToBoolean (object value)
1237                 {
1238                         return (bool) ChangeType (value, typeof (bool));
1239                 }
1240
1241                 public override bool ToBoolean (float value)
1242                 {
1243                         return value != 0;
1244                 }
1245
1246                 public override decimal ToDecimal (bool value)
1247                 {
1248                         return value ? 1 : 0;
1249                 }
1250
1251                 public override double ToDouble (bool value)
1252                 {
1253                         return value ? 1 : 0;
1254                 }
1255
1256                 public override float ToSingle (bool value)
1257                 {
1258                         return value ? 1 : 0;
1259                 }
1260
1261                 public override int ToInt32 (bool value)
1262                 {
1263                         return value ? 1 : 0;
1264                 }
1265
1266                 public override long ToInt64 (bool value)
1267                 {
1268                         return value ? 1 : 0;
1269                 }
1270                 #endregion
1271
1272                 #region numeric with point to without point
1273                 public override int ToInt32 (decimal value)
1274                 {
1275                         return XQueryConvert.DecimalToInt (value);
1276                 }
1277
1278                 public override int ToInt32 (double value)
1279                 {
1280                         return XQueryConvert.DoubleToInt (value);
1281                 }
1282
1283                 public override int ToInt32 (float value)
1284                 {
1285                         return XQueryConvert.FloatToInt (value);
1286                 }
1287
1288                 public override long ToInt64 (decimal value)
1289                 {
1290                         return XQueryConvert.DecimalToInteger (value);
1291                 }
1292
1293                 public override long ToInt64 (double value)
1294                 {
1295                         return XQueryConvert.DoubleToInteger (value);
1296                 }
1297
1298                 public override long ToInt64 (float value)
1299                 {
1300                         return XQueryConvert.FloatToInteger (value);
1301                 }
1302                 #endregion
1303         }
1304
1305         internal class XsdDateTimeConverter : XsdNonPermissiveConverter
1306         {
1307                 public XsdDateTimeConverter (XmlTypeCode code)
1308                         : base (code)
1309                 {
1310                 }
1311
1312                 public override string ToString (DateTime value)
1313                 {
1314                         return XmlConvert.ToString (value);
1315                 }
1316
1317                 public override DateTime ToDateTime (DateTime value)
1318                 {
1319                         return value;
1320                 }
1321         }
1322
1323         internal class XsdBooleanConverter : XsdNumericConverter
1324         {
1325                 public XsdBooleanConverter (XmlTypeCode code)
1326                         : base (code)
1327                 {
1328                 }
1329         }
1330
1331         internal class XsdMiscBaseConverter : XsdNonPermissiveConverter
1332         {
1333                 public XsdMiscBaseConverter (XmlTypeCode code)
1334                         : base (code)
1335                 {
1336                 }
1337
1338                 public override string ToString (string value)
1339                 {
1340                         return value;
1341                 }
1342
1343                 public override object ChangeType (object value, Type type, IXmlNamespaceResolver nsResolver)
1344                 {
1345                         if (Code == XmlTypeCode.HexBinary) {
1346                                 if (value == null)
1347                                         throw new ArgumentNullException ("value");
1348                                 if (type == null)
1349                                         throw new ArgumentNullException ("type");
1350                                 if (value.GetType () == typeof (byte [])) {
1351                                         if (type == typeof (string))
1352                                                 return XQueryConvert.HexBinaryToString ((byte []) value);
1353                                         else if (type == typeof (byte []))
1354                                                 return value;
1355                                 }
1356                         }
1357                         return base.ChangeType (value, type, nsResolver);
1358                 }
1359         }
1360 }
1361
1362 #endif