mcs/class/Mono.Xml.Ext/Mono.Xml.XPath2/XQueryConvert.cs

   1 //
   2 // System.Xml.Query.XQueryConvert
   3 //
   4 // Author:
   5 //      Atsushi Enomoto <atsushi@ximian.com>
   6 //
   7 // Copyright (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 using System;
  32 using System.Globalization;
  33 using System.IO;
  34 using System.Text;
  35 using System.Xml;
  36 using System.Xml.Schema;
  37 using System.Xml.XPath;
  38
  39 namespace System.Xml
  40 {
  41         internal class XQueryConvert // Won't be public in the final stage
  42         {
  43                 [MonoTODO]
  44                 public static bool ShouldCheckValueFacets (XmlSchemaType schemaTypeDest)
  45                 {
  46                         throw new NotImplementedException ();
  47                 }
  48
  49                 public static XmlTypeCode GetFallbackType (XmlTypeCode type)
  50                 {
  51                         switch (type) {
  52                         case XmlTypeCode.AnyAtomicType:
  53                                 return XmlTypeCode.Item;
  54                         case XmlTypeCode.UntypedAtomic:
  55                                 return XmlTypeCode.String;
  56                         case XmlTypeCode.Notation:
  57                                 return XmlTypeCode.QName;
  58                         case XmlTypeCode.NormalizedString:
  59                         case XmlTypeCode.Token:
  60                         case XmlTypeCode.Language:
  61                         case XmlTypeCode.NmToken:
  62                         case XmlTypeCode.Name:
  63                         case XmlTypeCode.NCName:
  64                         case XmlTypeCode.Id:
  65                         case XmlTypeCode.Idref:
  66                         case XmlTypeCode.Entity:
  67                                 return XmlTypeCode.String;
  68                         case XmlTypeCode.NonPositiveInteger:
  69                                 return XmlTypeCode.Decimal;
  70                         case XmlTypeCode.NegativeInteger:
  71                                 return XmlTypeCode.NonPositiveInteger;
  72                         case XmlTypeCode.Long:
  73                                 return XmlTypeCode.Integer;
  74                         case XmlTypeCode.Short:
  75                                 return XmlTypeCode.Int;
  76                         case XmlTypeCode.Byte:
  77                                 return XmlTypeCode.Int;
  78                         case XmlTypeCode.NonNegativeInteger:
  79                                 return XmlTypeCode.Decimal;
  80                         case XmlTypeCode.UnsignedLong:
  81                                 return XmlTypeCode.NonNegativeInteger;
  82                         case XmlTypeCode.UnsignedInt:
  83                                 return XmlTypeCode.Integer;
  84                         case XmlTypeCode.UnsignedShort:
  85                                 return XmlTypeCode.Int;
  86                         case XmlTypeCode.UnsignedByte:
  87                                 return XmlTypeCode.UnsignedShort;
  88                         case XmlTypeCode.PositiveInteger:
  89                                 return XmlTypeCode.NonNegativeInteger;
  90                         default:
  91                                 return XmlTypeCode.None;
  92                         }
  93                 }
  94
  95                 [MonoTODO]
  96                 // See XQuery & XPath 2.0 functions & operators section 17.
  97                 public static bool CanConvert (XPathItem item, XmlSchemaType schemaTypeDest)
  98                 {
  99                         if (item == null)
 100                                 throw new ArgumentNullException ("item");
 101                         if (schemaTypeDest == null)
 102                                 throw new ArgumentNullException ("schemaTypeDest");
 103                         XmlTypeCode src = item.XmlType.TypeCode;
 104                         XmlTypeCode dst = schemaTypeDest.TypeCode;
 105
 106                         // Notation cannot be converted from other than Notation
 107                         if (src == XmlTypeCode.Notation && dst != XmlTypeCode.Notation)
 108                                 return false;
 109
 110                         // untypedAtomic and string are convertable unless source type is QName.
 111                         switch (dst) {
 112                         case XmlTypeCode.UntypedAtomic:
 113                         case XmlTypeCode.String:
 114                                 return src != XmlTypeCode.QName;
 115                         }
 116
 117                         switch (src) {
 118                         case XmlTypeCode.None:
 119                         case XmlTypeCode.Item:
 120                         case XmlTypeCode.Node:
 121                         case XmlTypeCode.Document:
 122                         case XmlTypeCode.Element:
 123                         case XmlTypeCode.Attribute:
 124                         case XmlTypeCode.Namespace:
 125                         case XmlTypeCode.ProcessingInstruction:
 126                         case XmlTypeCode.Comment:
 127                         case XmlTypeCode.Text:
 128                                 throw new NotImplementedException (); // FIXME: check what happens
 129
 130                         case XmlTypeCode.AnyAtomicType:
 131                                 throw new NotImplementedException (); // FIXME: check what happens
 132                         case XmlTypeCode.UntypedAtomic:
 133                         case XmlTypeCode.String:
 134                                 // 'M'
 135                                 throw new NotImplementedException (); // FIXME: check what happens
 136
 137                         case XmlTypeCode.Boolean:
 138                         case XmlTypeCode.Decimal:
 139                                 switch (dst) {
 140                                 case XmlTypeCode.Float:
 141                                 case XmlTypeCode.Double:
 142                                 case XmlTypeCode.Decimal:
 143                                 case XmlTypeCode.Boolean:
 144                                         return true;
 145                                 }
 146                                 return false;
 147
 148                         case XmlTypeCode.Float:
 149                         case XmlTypeCode.Double:
 150                                 if (dst == XmlTypeCode.Decimal)
 151                                         // 'M'
 152                                         throw new NotImplementedException (); // FIXME: check what happens
 153                                 goto case XmlTypeCode.Decimal;
 154
 155                         case XmlTypeCode.Duration:
 156                                 switch (dst) {
 157                                 case XmlTypeCode.Duration:
 158                                 case XmlTypeCode.YearMonthDuration:
 159                                 case XmlTypeCode.DayTimeDuration:
 160                                         return true;
 161                                 }
 162                                 return false;
 163
 164                         case XmlTypeCode.DateTime:
 165                                 switch (dst) {
 166                                 case XmlTypeCode.DateTime:
 167                                 case XmlTypeCode.Time:
 168                                 case XmlTypeCode.Date:
 169                                 case XmlTypeCode.GYearMonth:
 170                                 case XmlTypeCode.GYear:
 171                                 case XmlTypeCode.GMonthDay:
 172                                 case XmlTypeCode.GDay:
 173                                 case XmlTypeCode.GMonth:
 174                                         return true;
 175                                 }
 176                                 return false;
 177
 178                         case XmlTypeCode.Time:
 179                                 switch (dst) {
 180                                 case XmlTypeCode.Time:
 181                                 case XmlTypeCode.Date:
 182                                         return true;
 183                                 }
 184                                 return false;
 185
 186                         case XmlTypeCode.Date:
 187                                 if (dst == XmlTypeCode.Time)
 188                                         return false;
 189                                 goto case XmlTypeCode.DateTime;
 190
 191                         case XmlTypeCode.GYearMonth:
 192                         case XmlTypeCode.GYear:
 193                         case XmlTypeCode.GMonthDay:
 194                         case XmlTypeCode.GDay:
 195                         case XmlTypeCode.GMonth:
 196                                 return src == dst;
 197
 198                         case XmlTypeCode.HexBinary:
 199                         case XmlTypeCode.Base64Binary:
 200                                 if (src == dst)
 201                                         return true;
 202                                 switch (dst) {
 203                                 case XmlTypeCode.HexBinary:
 204                                 case XmlTypeCode.Base64Binary:
 205                                         return true;
 206                                 }
 207                                 return false;
 208
 209                         case XmlTypeCode.AnyUri:
 210                         case XmlTypeCode.QName:
 211                         case XmlTypeCode.Notation:
 212                                 return src == dst;
 213
 214                         case XmlTypeCode.NormalizedString:
 215                         case XmlTypeCode.Token:
 216                         case XmlTypeCode.Language:
 217                         case XmlTypeCode.NmToken:
 218                         case XmlTypeCode.Name:
 219                         case XmlTypeCode.NCName:
 220                         case XmlTypeCode.Id:
 221                         case XmlTypeCode.Idref:
 222                         case XmlTypeCode.Entity:
 223                         case XmlTypeCode.Integer:
 224                         case XmlTypeCode.NonPositiveInteger:
 225                         case XmlTypeCode.NegativeInteger:
 226                         case XmlTypeCode.Long:
 227                         case XmlTypeCode.Int:
 228                         case XmlTypeCode.Short:
 229                         case XmlTypeCode.Byte:
 230                         case XmlTypeCode.NonNegativeInteger:
 231                         case XmlTypeCode.UnsignedLong:
 232                         case XmlTypeCode.UnsignedInt:
 233                         case XmlTypeCode.UnsignedShort:
 234                         case XmlTypeCode.UnsignedByte:
 235                         case XmlTypeCode.PositiveInteger:
 236                                 throw new NotImplementedException ();
 237
 238                         // xdt:*
 239                         case XmlTypeCode.YearMonthDuration:
 240                                 if (dst == XmlTypeCode.DayTimeDuration)
 241                                         return false;
 242                                 goto case XmlTypeCode.Duration;
 243                         case XmlTypeCode.DayTimeDuration:
 244                                 if (dst == XmlTypeCode.YearMonthDuration)
 245                                         return false;
 246                                 goto case XmlTypeCode.Duration;
 247                         }
 248
 249                         throw new NotImplementedException ();
 250                 }
 251
 252                 // Individual conversion
 253
 254                 public static string AnyUriToString (string value)
 255                 {
 256                         return value;
 257                 }
 258
 259                 public static byte [] Base64BinaryToHexBinary (byte [] value)
 260                 {
 261                         return XmlConvert.FromBinHexString (Convert.ToBase64String (value));
 262                 }
 263
 264                 public static string Base64BinaryToString (byte [] value)
 265                 {
 266                         return Convert.ToBase64String (value);
 267                 }
 268
 269                 public static decimal BooleanToDecimal (bool value)
 270                 {
 271                         return Convert.ToDecimal (value);
 272                 }
 273
 274                 public static double BooleanToDouble (bool value)
 275                 {
 276                         return Convert.ToDouble (value);
 277                 }
 278
 279                 public static float BooleanToFloat (bool value)
 280                 {
 281                         return Convert.ToSingle (value);
 282                 }
 283
 284                 public static int BooleanToInt (bool value)
 285                 {
 286                         return Convert.ToInt32 (value);
 287                 }
 288
 289                 public static long BooleanToInteger (bool value)
 290                 {
 291                         return Convert.ToInt64 (value);
 292                 }
 293
 294                 public static string BooleanToString (bool value)
 295                 {
 296                         // It looks not returning "True"
 297                         return value ? "true" : "false";
 298                 }
 299
 300                 [MonoTODO]
 301                 public static DateTime DateTimeToDate (DateTime value)
 302                 {
 303                         return value.Date;
 304                 }
 305
 306                 [MonoTODO]
 307                 public static DateTime DateTimeToGDay (DateTime value)
 308                 {
 309                         return new DateTime (0, 0, value.Day);
 310                 }
 311
 312                 [MonoTODO]
 313                 public static DateTime DateTimeToGMonth (DateTime value)
 314                 {
 315                         return new DateTime (0, value.Month, 0);
 316                 }
 317
 318                 [MonoTODO]
 319                 public static DateTime DateTimeToGYear (DateTime value)
 320                 {
 321                         return new DateTime (value.Year, 0, 0);
 322                 }
 323
 324                 [MonoTODO]
 325                 public static DateTime DateTimeToGYearMonth (DateTime value)
 326                 {
 327                         return new DateTime (value.Year, value.Month, 0);
 328                 }
 329
 330                 [MonoTODO]
 331                 public static DateTime DateToDateTime (DateTime value)
 332                 {
 333                         return value.Date;
 334                 }
 335
 336                 [MonoTODO]
 337                 public static DateTime DateToGDay (DateTime value)
 338                 {
 339                         return new DateTime (0, 0, value.Day);
 340                 }
 341
 342                 [MonoTODO]
 343                 public static DateTime DateToGMonth (DateTime value)
 344                 {
 345                         return new DateTime (0, value.Month, 0);
 346                 }
 347
 348                 [MonoTODO]
 349                 public static DateTime DateToGYear (DateTime value)
 350                 {
 351                         return new DateTime (value.Year, 0, 0);
 352                 }
 353
 354                 [MonoTODO]
 355                 public static DateTime DateToGYearMonth (DateTime value)
 356                 {
 357                         return new DateTime (value.Year, value.Month, 0);
 358                 }
 359
 360                 [MonoTODO]
 361                 public static string DateToString (DateTime value)
 362                 {
 363                         return XmlConvert.ToString (value);
 364                 }
 365
 366                 [MonoTODO]
 367                 public static string DateTimeToString (DateTime value)
 368                 {
 369                         return XmlConvert.ToString (value);
 370                 }
 371
 372                 [MonoTODO]
 373                 public static string DayTimeDurationToDuration (TimeSpan value)
 374                 {
 375                         return XmlConvert.ToString (value);
 376                 }
 377
 378                 [MonoTODO]
 379                 public static string DayTimeDurationToString (TimeSpan value)
 380                 {
 381                         return DayTimeDurationToDuration (value);
 382                 }
 383
 384                 [MonoTODO]
 385                 public static bool DecimalToBoolean (decimal value)
 386                 {
 387                         return value != 0;
 388                 }
 389
 390                 [MonoTODO]
 391                 public static double DecimalToDouble (decimal value)
 392                 {
 393                         return (double) value;
 394                 }
 395
 396                 [MonoTODO]
 397                 public static float DecimalToFloat (decimal value)
 398                 {
 399                         return (float) value;
 400                 }
 401
 402                 [MonoTODO]
 403                 public static int DecimalToInt (decimal value)
 404                 {
 405                         return (int) value;
 406                 }
 407
 408                 [MonoTODO]
 409                 public static long DecimalToInteger (decimal value)
 410                 {
 411                         return (long) value;
 412                 }
 413
 414                 [MonoTODO] // what if value was negative?
 415                 public static decimal DecimalToNonNegativeInteger (decimal value)
 416                 {
 417                         throw new NotImplementedException ();
 418                 }
 419
 420                 [MonoTODO] // what if value was positive?
 421                 public static decimal DecimalToNonPositiveInteger (decimal value)
 422                 {
 423                         throw new NotImplementedException ();
 424                 }
 425
 426                 [MonoTODO]
 427                 public static string DecimalToString (decimal value)
 428                 {
 429                         return XmlConvert.ToString (value);
 430                 }
 431
 432                 [MonoTODO]
 433                 public static bool DoubleToBoolean (double value)
 434                 {
 435                         return value != 0;
 436                 }
 437
 438                 [MonoTODO]
 439                 public static decimal DoubleToDecimal (double value)
 440                 {
 441                         return (decimal) value;
 442                 }
 443
 444                 [MonoTODO]
 445                 public static float DoubleToFloat (double value)
 446                 {
 447                         return (float) value;
 448                 }
 449
 450                 [MonoTODO]
 451                 public static int DoubleToInt (double value)
 452                 {
 453                         return (int) value;
 454                 }
 455
 456                 [MonoTODO]
 457                 public static long DoubleToInteger (double value)
 458                 {
 459                         return (long) value;
 460                 }
 461
 462                 [MonoTODO] // what if value was negative?
 463                 public static decimal DoubleToNonNegativeInteger (double value)
 464                 {
 465                         throw new NotImplementedException ();
 466                 }
 467
 468                 [MonoTODO] // what if value was positive?
 469                 public static decimal DoubleToNonPositiveInteger (double value)
 470                 {
 471                         throw new NotImplementedException ();
 472                 }
 473
 474                 [MonoTODO]
 475                 public static string DoubleToString (double value)
 476                 {
 477                         return XmlConvert.ToString (value);
 478                 }
 479
 480                 [MonoTODO]
 481                 public static TimeSpan DurationToDayTimeDuration (string value)
 482                 {
 483                         return XmlConvert.ToTimeSpan (value);
 484                 }
 485
 486                 [MonoTODO]
 487                 public static string DurationToString (string value)
 488                 {
 489                         return XmlConvert.ToString (XmlConvert.ToTimeSpan (value));
 490                 }
 491
 492                 [MonoTODO]
 493                 public static TimeSpan DurationToYearMonthDuration (string value)
 494                 {
 495                         return XmlConvert.ToTimeSpan (value);
 496                 }
 497
 498
 499                 [MonoTODO]
 500                 public static bool FloatToBoolean (float value)
 501                 {
 502                         return value != 0;
 503                 }
 504
 505                 [MonoTODO]
 506                 public static decimal FloatToDecimal (float value)
 507                 {
 508                         return (decimal) value;
 509                 }
 510
 511                 [MonoTODO]
 512                 public static double FloatToDouble (float value)
 513                 {
 514                         return (double) value;
 515                 }
 516
 517                 [MonoTODO]
 518                 public static int FloatToInt (float value)
 519                 {
 520                         return (int) value;
 521                 }
 522
 523                 [MonoTODO]
 524                 public static long FloatToInteger (float value)
 525                 {
 526                         return (long) value;
 527                 }
 528
 529                 [MonoTODO] // what if value was negative?
 530                 public static decimal FloatToNonNegativeInteger (float value)
 531                 {
 532                         throw new NotImplementedException ();
 533                 }
 534
 535                 [MonoTODO] // what if value was positive?
 536                 public static decimal FloatToNonPositiveInteger (float value)
 537                 {
 538                         throw new NotImplementedException ();
 539                 }
 540
 541                 [MonoTODO]
 542                 public static string FloatToString (float value)
 543                 {
 544                         return XmlConvert.ToString (value);
 545                 }
 546
 547                 [MonoTODO]
 548                 public static string GDayToString (DateTime value)
 549                 {
 550                         return XmlConvert.ToString (TimeSpan.FromDays (value.Day));
 551                 }
 552
 553                 [MonoTODO]
 554                 public static string GMonthDayToString (DateTime value)
 555                 {
 556                         return XmlConvert.ToString (new TimeSpan (value.Day, value.Hour, value.Minute, value.Second));
 557                 }
 558
 559                 [MonoTODO]
 560                 public static string GMonthToString (DateTime value)
 561                 {
 562                         return XmlConvert.ToString (new TimeSpan (0, value.Month, 0));
 563                 }
 564
 565                 [MonoTODO]
 566                 public static string GYearMonthToString (DateTime value)
 567                 {
 568                         return XmlConvert.ToString (new TimeSpan (value.Year, value.Month, 0));
 569                 }
 570
 571                 [MonoTODO]
 572                 public static string GYearToString (DateTime value)
 573                 {
 574                         return XmlConvert.ToString (new TimeSpan (new DateTime (value.Year, 0, 0).Ticks));
 575                 }
 576
 577                 public static string HexBinaryToString (byte [] data)
 578                 {
 579                         return XmlConvert.ToBinHexString (data);
 580                 }
 581
 582                 public static string HexBinaryToBase64String (byte [] data)
 583                 {
 584                         return XmlConvert.ToBinHexString (data);
 585                 }
 586
 587
 588                 [MonoTODO]
 589                 public static bool IntegerToBoolean (long value)
 590                 {
 591                         return value != 0;
 592                 }
 593
 594                 [MonoTODO]
 595                 public static decimal IntegerToDecimal (long value)
 596                 {
 597                         return (decimal) value;
 598                 }
 599
 600                 [MonoTODO]
 601                 public static double IntegerToDouble (long value)
 602                 {
 603                         return (double) value;
 604                 }
 605
 606                 [MonoTODO]
 607                 public static float IntegerToFloat (long value)
 608                 {
 609                         return (float) value;
 610                 }
 611
 612                 [MonoTODO]
 613                 public static int IntegerToInt (long value)
 614                 {
 615                         return (int) value;
 616                 }
 617
 618                 [MonoTODO]
 619                 public static string IntegerToString (long value)
 620                 {
 621                         return XmlConvert.ToString (value);
 622                 }
 623
 624                 [MonoTODO]
 625                 public static bool IntToBoolean (int value)
 626                 {
 627                         return value != 0;
 628                 }
 629
 630                 [MonoTODO]
 631                 public static decimal IntToDecimal (int value)
 632                 {
 633                         return (decimal) value;
 634                 }
 635
 636                 [MonoTODO]
 637                 public static double IntToDouble (int value)
 638                 {
 639                         return (double) value;
 640                 }
 641
 642                 [MonoTODO]
 643                 public static float IntToFloat (int value)
 644                 {
 645                         return (float) value;
 646                 }
 647
 648                 [MonoTODO]
 649                 public static long IntToInteger (int value)
 650                 {
 651                         return (long) value;
 652                 }
 653
 654                 [MonoTODO]
 655                 public static string IntToString (int value)
 656                 {
 657                         return XmlConvert.ToString (value);
 658                 }
 659
 660                 [MonoTODO]
 661                 public static string NonNegativeIntegerToString (decimal value)
 662                 {
 663                         return XmlConvert.ToString (value);
 664                 }
 665
 666                 [MonoTODO]
 667                 public static string NonPositiveIntegerToString (decimal value)
 668                 {
 669                         return XmlConvert.ToString (value);
 670                 }
 671
 672                 [MonoTODO]
 673                 public static DateTime TimeToDateTime (DateTime value)
 674                 {
 675                         return value;
 676                 }
 677
 678                 [MonoTODO]
 679                 public static string TimeToString (DateTime value)
 680                 {
 681                         return XmlConvert.ToString (value, "HH:mm:ssZ");
 682                 }
 683
 684                 [MonoTODO]
 685                 public static string YearMonthDurationToDuration (TimeSpan value)
 686                 {
 687                         return XmlConvert.ToString (value);
 688                 }
 689
 690                 [MonoTODO]
 691                 public static string YearMonthDurationToString (TimeSpan value)
 692                 {
 693                         return YearMonthDurationToDuration (value);
 694                 }
 695
 696                 [MonoTODO]
 697                 public static string StringToAnyUri (string value)
 698                 {
 699                         return value;
 700                 }
 701
 702                 [MonoTODO]
 703                 public static byte [] StringToBase64Binary (string value)
 704                 {
 705                         return Convert.FromBase64String (value);
 706                 }
 707
 708                 [MonoTODO]
 709                 public static bool StringToBoolean (string value)
 710                 {
 711                         return XmlConvert.ToBoolean (value);
 712                 }
 713
 714                 [MonoTODO]
 715                 public static DateTime StringToDate (string value)
 716                 {
 717                         return XmlConvert.ToDateTime (value);
 718                 }
 719
 720                 [MonoTODO]
 721                 public static DateTime StringToDateTime (string value)
 722                 {
 723                         return XmlConvert.ToDateTime (value);
 724                 }
 725
 726                 [MonoTODO]
 727                 public static TimeSpan StringToDayTimeDuration (string value)
 728                 {
 729                         return XmlConvert.ToTimeSpan (value);
 730                 }
 731
 732                 [MonoTODO]
 733                 public static decimal StringToDecimal (string value)
 734                 {
 735                         return XmlConvert.ToDecimal (value);
 736                 }
 737
 738                 [MonoTODO]
 739                 public static double StringToDouble (string value)
 740                 {
 741                         return XmlConvert.ToDouble (value);
 742                 }
 743
 744                 [MonoTODO]
 745                 public static string StringToDuration (string value)
 746                 {
 747                         return XmlConvert.ToString (XmlConvert.ToTimeSpan (value));
 748                 }
 749
 750                 [MonoTODO]
 751                 public static float StringToFloat (string value)
 752                 {
 753                         return XmlConvert.ToSingle (value);
 754                 }
 755
 756                 [MonoTODO]
 757                 public static DateTime StringToGDay (string value)
 758                 {
 759                         return XmlConvert.ToDateTime (value);
 760                 }
 761
 762                 [MonoTODO]
 763                 public static DateTime StringToGMonth (string value)
 764                 {
 765                         return XmlConvert.ToDateTime (value);
 766                 }
 767
 768                 [MonoTODO]
 769                 public static DateTime StringToGMonthDay (string value)
 770                 {
 771                         return XmlConvert.ToDateTime (value);
 772                 }
 773
 774                 [MonoTODO]
 775                 public static DateTime StringToGYear (string value)
 776                 {
 777                         return XmlConvert.ToDateTime (value);
 778                 }
 779
 780                 [MonoTODO]
 781                 public static DateTime StringToGYearMonth (string value)
 782                 {
 783                         return XmlConvert.ToDateTime (value);
 784                 }
 785
 786                 [MonoTODO]
 787                 public static byte [] StringToHexBinary (string value)
 788                 {
 789                         return XmlConvert.FromBinHexString (value);
 790                 }
 791
 792                 [MonoTODO]
 793                 public static int StringToInt (string value)
 794                 {
 795                         return XmlConvert.ToInt32 (value);
 796                 }
 797
 798                 [MonoTODO]
 799                 public static long StringToInteger (string value)
 800                 {
 801                         return XmlConvert.ToInt64 (value);
 802                 }
 803
 804                 [MonoTODO]
 805                 public static decimal StringToNonNegativeInteger (string value)
 806                 {
 807                         return XmlConvert.ToDecimal (value);
 808                 }
 809
 810                 [MonoTODO]
 811                 public static decimal StringToNonPositiveInteger (string value)
 812                 {
 813                         return XmlConvert.ToDecimal (value);
 814                 }
 815
 816                 [MonoTODO]
 817                 public static DateTime StringToTime (string value)
 818                 {
 819                         return XmlConvert.ToDateTime (value);
 820                 }
 821
 822                 [MonoTODO]
 823                 public static long StringToUnsignedInt (string value)
 824                 {
 825                         return XmlConvert.ToInt32 (value);
 826                 }
 827
 828                 [MonoTODO]
 829                 public static decimal StringToUnsignedLong (string value)
 830                 {
 831                         return XmlConvert.ToInt32 (value);
 832                 }
 833
 834                 [MonoTODO]
 835                 public static int StringToUnsignedShort (string value)
 836                 {
 837                         return XmlConvert.ToInt32 (value);
 838                 }
 839
 840                 [MonoTODO]
 841                 public static TimeSpan StringToYearMonthDuration (string value)
 842                 {
 843                         return XmlConvert.ToTimeSpan (value);
 844                 }
 845
 846                 [MonoTODO]
 847                 public static string ItemToAnyUri (XPathItem value)
 848                 {
 849                         return value.Value;
 850                 }
 851
 852                 [MonoTODO]
 853                 public static byte [] ItemToBase64Binary (XPathItem value)
 854                 {
 855                         return Convert.FromBase64String (value.Value);
 856                 }
 857
 858                 [MonoTODO]
 859                 public static bool ItemToBoolean (XPathItem value)
 860                 {
 861                         return XmlConvert.ToBoolean (value.Value);
 862                 }
 863
 864                 [MonoTODO]
 865                 public static DateTime ItemToDate (XPathItem value)
 866                 {
 867                         return XmlConvert.ToDateTime (value.Value);
 868                 }
 869
 870                 [MonoTODO]
 871                 public static DateTime ItemToDateTime (XPathItem value)
 872                 {
 873                         return XmlConvert.ToDateTime (value.Value);
 874                 }
 875
 876                 [MonoTODO]
 877                 public static TimeSpan ItemToDayTimeDuration (XPathItem value)
 878                 {
 879                         return XmlConvert.ToTimeSpan (value.Value);
 880                 }
 881
 882                 [MonoTODO]
 883                 public static decimal ItemToDecimal (XPathItem value)
 884                 {
 885                         return XmlConvert.ToDecimal (value.Value);
 886                 }
 887
 888                 [MonoTODO]
 889                 public static double ItemToDouble (XPathItem value)
 890                 {
 891                         return XmlConvert.ToDouble (value.Value);
 892                 }
 893
 894                 [MonoTODO]
 895                 public static string ItemToDuration (XPathItem value)
 896                 {
 897                         return XmlConvert.ToString (XmlConvert.ToTimeSpan (value.Value));
 898                 }
 899
 900                 [MonoTODO]
 901                 public static float ItemToFloat (XPathItem value)
 902                 {
 903                         return XmlConvert.ToSingle (value.Value);
 904                 }
 905
 906                 [MonoTODO]
 907                 public static DateTime ItemToGDay (XPathItem value)
 908                 {
 909                         return XmlConvert.ToDateTime (value.Value);
 910                 }
 911
 912                 [MonoTODO]
 913                 public static DateTime ItemToGMonth (XPathItem value)
 914                 {
 915                         return XmlConvert.ToDateTime (value.Value);
 916                 }
 917
 918                 [MonoTODO]
 919                 public static DateTime ItemToGMonthDay (XPathItem value)
 920                 {
 921                         return XmlConvert.ToDateTime (value.Value);
 922                 }
 923
 924                 [MonoTODO]
 925                 public static DateTime ItemToGYear (XPathItem value)
 926                 {
 927                         return XmlConvert.ToDateTime (value.Value);
 928                 }
 929
 930                 [MonoTODO]
 931                 public static DateTime ItemToGYearMonth (XPathItem value)
 932                 {
 933                         return XmlConvert.ToDateTime (value.Value);
 934                 }
 935
 936                 [MonoTODO]
 937                 public static byte [] ItemToHexBinary (XPathItem value)
 938                 {
 939                         return XmlConvert.FromBinHexString (value.Value);
 940                 }
 941
 942                 [MonoTODO]
 943                 public static int ItemToInt (XPathItem value)
 944                 {
 945                         return XmlConvert.ToInt32 (value.Value);
 946                 }
 947
 948                 [MonoTODO]
 949                 public static long ItemToInteger (XPathItem value)
 950                 {
 951                         return XmlConvert.ToInt64 (value.Value);
 952                 }
 953
 954                 [MonoTODO]
 955                 public static XPathItem ItemToItem (XPathItem value, XmlSchemaType schemaTypeDest)
 956                 {
 957                         return new XPathAtomicValue (value.Value, schemaTypeDest);
 958                 }
 959
 960                 [MonoTODO]
 961                 public static decimal ItemToNonNegativeInteger (XPathItem value)
 962                 {
 963                         return XmlConvert.ToDecimal (value.Value);
 964                 }
 965
 966                 [MonoTODO]
 967                 public static decimal ItemToNonPositiveInteger (XPathItem value)
 968                 {
 969                         return XmlConvert.ToDecimal (value.Value);
 970                 }
 971
 972                 [MonoTODO]
 973                 public static XmlQualifiedName ItemToQName (XPathItem value)
 974                 {
 975                         return (XmlQualifiedName) value.TypedValue;
 976                 }
 977
 978                 [MonoTODO]
 979                 public static string ItemToString (XPathItem value)
 980                 {
 981                         if (value.ValueType == typeof (DateTime))
 982                                 return XmlConvert.ToString ((DateTime) value.TypedValue);
 983                         if (value.TypedValue is XmlQualifiedName)
 984                                 throw new ArgumentException ("Invalid cast from schema QName type to string type.");
 985                         return value.Value;
 986                 }
 987
 988                 [MonoTODO]
 989                 public static DateTime ItemToTime (XPathItem value)
 990                 {
 991                         return XmlConvert.ToDateTime (value.Value);
 992                 }
 993
 994                 [MonoTODO]
 995                 public static long ItemToUnsignedInt (XPathItem value)
 996                 {
 997                         return XmlConvert.ToInt32 (value.Value);
 998                 }
 999
1000                 [MonoTODO]
1001                 public static decimal ItemToUnsignedLong (XPathItem value)
1002                 {
1003                         return XmlConvert.ToInt32 (value.Value);
1004                 }
1005
1006                 [MonoTODO]
1007                 public static int ItemToUnsignedShort (XPathItem value)
1008                 {
1009                         return XmlConvert.ToInt32 (value.Value);
1010                 }
1011
1012                 [MonoTODO]
1013                 public static TimeSpan ItemToYearMonthDuration (XPathItem value)
1014                 {
1015                         return XmlConvert.ToTimeSpan (value.Value);
1016                 }
1017         }
1018 }
1019