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