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