XmlValueConverter.cs :  » 2.6.4-mono-.net-core » System.Xml » System » Xml » Schema » C# / CSharp Open Source

//
// XmlValueConverter.cs
//
// Author:
//  Atsushi Enomoto <atsushi@ximian.com>
//
// (C)2004 Novell Inc,
//

//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

#if NET_2_0

using System;

namespace System.Xml.Schema{
  public abstract class XmlValueConverter
  {
    [MonoTODO]
    protected XmlValueConverter ()
    {
    }

    public abstract object ChangeType (bool value, Type type);

    public abstract object ChangeType (DateTime value, Type type);

    public abstract object ChangeType (decimal value, Type type);

    public abstract object ChangeType (double value, Type type);

    public abstract object ChangeType (int value, Type type);

    public abstract object ChangeType (long value, Type type);

    public abstract object ChangeType (object value, Type type);

    public abstract object ChangeType (float value, Type type);

    public abstract object ChangeType (string value, Type type);

    public abstract object ChangeType (object value, Type type, IXmlNamespaceResolver nsResolver);

    public abstract object ChangeType (string value, Type type, IXmlNamespaceResolver nsResolver);

    public abstract bool ToBoolean (bool value);

    public abstract bool ToBoolean (DateTime value);

    public abstract bool ToBoolean (decimal value);

    public abstract bool ToBoolean (double value);

    public abstract bool ToBoolean (int value);

    public abstract bool ToBoolean (long value);

    public abstract bool ToBoolean (object value);

    public abstract bool ToBoolean (float value);

    public abstract bool ToBoolean (string value);

    public abstract DateTime ToDateTime (bool value);

    public abstract DateTime ToDateTime (DateTime value);

    public abstract DateTime ToDateTime (decimal value);

    public abstract DateTime ToDateTime (double value);

    public abstract DateTime ToDateTime (int value);

    public abstract DateTime ToDateTime (long value);

    public abstract DateTime ToDateTime (object value);

    public abstract DateTime ToDateTime (float value);

    public abstract DateTime ToDateTime (string value);

    public abstract decimal ToDecimal (bool value);

    public abstract decimal ToDecimal (DateTime value);

    public abstract decimal ToDecimal (decimal value);

    public abstract decimal ToDecimal (double value);

    public abstract decimal ToDecimal (int value);

    public abstract decimal ToDecimal (long value);

    public abstract decimal ToDecimal (object value);

    public abstract decimal ToDecimal (float value);

    public abstract decimal ToDecimal (string value);

    public abstract double ToDouble (bool value);

    public abstract double ToDouble (DateTime value);

    public abstract double ToDouble (decimal value);

    public abstract double ToDouble (double value);

    public abstract double ToDouble (int value);

    public abstract double ToDouble (long value);

    public abstract double ToDouble (object value);

    public abstract double ToDouble (float value);

    public abstract double ToDouble (string value);

    public abstract int ToInt32 (bool value);

    public abstract int ToInt32 (DateTime value);

    public abstract int ToInt32 (decimal value);

    public abstract int ToInt32 (double value);

    public abstract int ToInt32 (int value);

    public abstract int ToInt32 (long value);

    public abstract int ToInt32 (object value);

    public abstract int ToInt32 (float value);

    public abstract int ToInt32 (string value);

    public abstract long ToInt64 (bool value);

    public abstract long ToInt64 (DateTime value);

    public abstract long ToInt64 (decimal value);

    public abstract long ToInt64 (double value);

    public abstract long ToInt64 (int value);

    public abstract long ToInt64 (long value);

    public abstract long ToInt64 (object value);

    public abstract long ToInt64 (float value);

    public abstract long ToInt64 (string value);

    public abstract float ToSingle (bool value);

    public abstract float ToSingle (DateTime value);

    public abstract float ToSingle (decimal value);

    public abstract float ToSingle (double value);

    public abstract float ToSingle (int value);

    public abstract float ToSingle (long value);

    public abstract float ToSingle (object value);

    public abstract float ToSingle (float value);

    public abstract float ToSingle (string value);

    public abstract string ToString (bool value);

    public abstract string ToString (DateTime value);

    public abstract string ToString (decimal value);

    public abstract string ToString (double value);

    public abstract string ToString (int value);

    public abstract string ToString (long value);

    public abstract string ToString (object value);

    public abstract string ToString (object value, IXmlNamespaceResolver nsResolver);

    public abstract string ToString (float value);

    public abstract string ToString (string value);

    public abstract string ToString (string value, IXmlNamespaceResolver nsResolver);
  }

  internal class XsdNonPermissiveConverter : XmlValueConverter
  {
    readonly XmlTypeCode typeCode;

    public XsdNonPermissiveConverter (XmlTypeCode typeCode)
    {
      this.typeCode = typeCode;
    }

    public XmlTypeCode Code {
      get { return typeCode; }
    }

    public override object ChangeType (bool value, Type type)
    {
      return ChangeType ((object) value, type);
    }

    public override object ChangeType (DateTime value, Type type)
    {
      return ChangeType ((object) value, type);
    }

    public override object ChangeType (decimal value, Type type)
    {
      return ChangeType ((object) value, type);
    }

    public override object ChangeType (double value, Type type)
    {
      return ChangeType ((object) value, type);
    }

    public override object ChangeType (int value, Type type)
    {
      return ChangeType ((object) value, type);
    }

    public override object ChangeType (long value, Type type)
    {
      return ChangeType ((object) value, type);
    }

    public override object ChangeType (float value, Type type)
    {
      return ChangeType ((object) value, type);
    }

    public override object ChangeType (string value, Type type)
    {
      return ChangeType ((object) value, type);
    }

    public override object ChangeType (object value, Type type)
    {
      return ChangeType (value, type, null);
    }

    [MonoTODO]
    public override object ChangeType (object value, Type type, IXmlNamespaceResolver nsResolver)
    {
      if (value == null)
        throw new ArgumentNullException ("value");
      if (type == null)
        throw new ArgumentNullException ("type");
      switch (Type.GetTypeCode (value.GetType ())) {
      case TypeCode.Boolean:
        bool bvalue = (bool) value;
        switch (Type.GetTypeCode (type)) {
        case TypeCode.Boolean:
          return ToBoolean (bvalue);
        case TypeCode.DateTime:
          return ToDateTime (bvalue);
        case TypeCode.Decimal:
          return ToDecimal (bvalue);
        case TypeCode.Double:
          return ToDouble (bvalue);
        case TypeCode.Int32:
          return ToInt32 (bvalue);
        case TypeCode.Int64:
          return ToInt64 (bvalue);
        case TypeCode.Single:
          return ToSingle (bvalue);
        case TypeCode.String:
          return ToString (bvalue);
        }
        break;
//      case TypeCode.Byte:
//      case TypeCode.Char:
      case TypeCode.DateTime:
        DateTime dtvalue = (DateTime) value;
        switch (Type.GetTypeCode (type)) {
        case TypeCode.Boolean:
          return ToBoolean (dtvalue);
        case TypeCode.DateTime:
          return ToDateTime (dtvalue);
        case TypeCode.Decimal:
          return ToDecimal (dtvalue);
        case TypeCode.Double:
          return ToDouble (dtvalue);
        case TypeCode.Int32:
          return ToInt32 (dtvalue);
        case TypeCode.Int64:
          return ToInt64 (dtvalue);
        case TypeCode.Single:
          return ToSingle (dtvalue);
        case TypeCode.String:
          return ToString (dtvalue);
        }
        break;
//      case TypeCode.DBNull:
      case TypeCode.Decimal:
        decimal decvalue = (decimal) value;
        switch (Type.GetTypeCode (type)) {
        case TypeCode.Boolean:
          return ToBoolean (decvalue);
        case TypeCode.DateTime:
          return ToDateTime (decvalue);
        case TypeCode.Decimal:
          return ToDecimal (decvalue);
        case TypeCode.Double:
          return ToDouble (decvalue);
        case TypeCode.Int32:
          return ToInt32 (decvalue);
        case TypeCode.Int64:
          return ToInt64 (decvalue);
        case TypeCode.Single:
          return ToSingle (decvalue);
        case TypeCode.String:
          return ToString (decvalue);
        }
        break;
      case TypeCode.Double:
        double dblvalue = (double) value;
        switch (Type.GetTypeCode (type)) {
        case TypeCode.Boolean:
          return ToBoolean (dblvalue);
        case TypeCode.DateTime:
          return ToDateTime (dblvalue);
        case TypeCode.Decimal:
          return ToDecimal (dblvalue);
        case TypeCode.Double:
          return ToDouble (dblvalue);
        case TypeCode.Int32:
          return ToInt32 (dblvalue);
        case TypeCode.Int64:
          return ToInt64 (dblvalue);
        case TypeCode.Single:
          return ToSingle (dblvalue);
        case TypeCode.String:
          return ToString (dblvalue);
        }
        break;
//      case TypeCode.Empty:
//      case TypeCode.Int16:
      case TypeCode.Int32:
        int ivalue = (int) value;
        switch (Type.GetTypeCode (type)) {
        case TypeCode.Boolean:
          return ToBoolean (ivalue);
        case TypeCode.DateTime:
          return ToDateTime (ivalue);
        case TypeCode.Decimal:
          return ToDecimal (ivalue);
        case TypeCode.Double:
          return ToDouble (ivalue);
        case TypeCode.Int32:
          return ToInt32 (ivalue);
        case TypeCode.Int64:
          return ToInt64 (ivalue);
        case TypeCode.Single:
          return ToSingle (ivalue);
        case TypeCode.String:
          return ToString (ivalue);
        }
        break;
      case TypeCode.Int64:
        long lvalue = (long) value;
        switch (Type.GetTypeCode (type)) {
        case TypeCode.Boolean:
          return ToBoolean (lvalue);
        case TypeCode.DateTime:
          return ToDateTime (lvalue);
        case TypeCode.Decimal:
          return ToDecimal (lvalue);
        case TypeCode.Double:
          return ToDouble (lvalue);
        case TypeCode.Int32:
          return ToInt32 (lvalue);
        case TypeCode.Int64:
          return ToInt64 (lvalue);
        case TypeCode.Single:
          return ToSingle (lvalue);
        case TypeCode.String:
          return ToString (lvalue);
        }
        break;
//      case TypeCode.Object:
//      case TypeCode.SByte:
      case TypeCode.Single:
        float fvalue = (float) value;
        switch (Type.GetTypeCode (type)) {
        case TypeCode.Boolean:
          return ToBoolean (fvalue);
        case TypeCode.DateTime:
          return ToDateTime (fvalue);
        case TypeCode.Decimal:
          return ToDecimal (fvalue);
        case TypeCode.Double:
          return ToDouble (fvalue);
        case TypeCode.Int32:
          return ToInt32 (fvalue);
        case TypeCode.Int64:
          return ToInt64 (fvalue);
        case TypeCode.Single:
          return ToSingle (fvalue);
        case TypeCode.String:
          return ToString (fvalue);
        }
        break;
      case TypeCode.String:
        string svalue = (string) value;
        switch (Type.GetTypeCode (type)) {
        case TypeCode.Boolean:
          return ToBoolean (svalue);
        case TypeCode.DateTime:
          return ToDateTime (svalue);
        case TypeCode.Decimal:
          return ToDecimal (svalue);
        case TypeCode.Double:
          return ToDouble (svalue);
        case TypeCode.Int32:
          return ToInt32 (svalue);
        case TypeCode.Int64:
          return ToInt64 (svalue);
        case TypeCode.Single:
          return ToSingle (svalue);
        case TypeCode.String:
          return ToString (svalue);
        }
        break;
//      case TypeCode.UInt16:
//      case TypeCode.UInt32:
//      case TypeCode.UInt64:
      default:
        if (type == typeof (TimeSpan))
          // xs:duration, xdt:yearMonthDuration,
          // xdt:dayTimeDuration. FIXME: yMD to
          // dTD and dTD to yMD are not allowed.
          return ToTimeSpan (value);
        if (value.GetType () == typeof (byte [])) {
          // xs:base64 by default
          if (type == typeof (string))
            return XQueryConvert.Base64BinaryToString ((byte []) value);
          else if (type == typeof (byte []))
            return value;
        }
        if (value.GetType () == type) {
          if (type == typeof (XmlQualifiedName)) {
            // xs:QName and xs:NOTATION
            throw new NotImplementedException ();
          }
        }
        break;
      }
      throw Error (value.GetType (), type);
    }

    public override object ChangeType (string value, Type type, IXmlNamespaceResolver nsResolver)
    {
      return ChangeType ((object) value, type, nsResolver);
    }

    public TimeSpan ToTimeSpan (bool value)
    {
      throw Error (typeof (bool), typeof (TimeSpan));
    }

    public TimeSpan ToTimeSpan (DateTime value)
    {
      throw Error (typeof (bool), typeof (TimeSpan));
    }

    public TimeSpan ToTimeSpan (decimal value)
    {
      throw Error (typeof (bool), typeof (TimeSpan));
    }

    public TimeSpan ToTimeSpan (double value)
    {
      throw Error (typeof (bool), typeof (TimeSpan));
    }

    public TimeSpan ToTimeSpan (int value)
    {
      throw Error (typeof (bool), typeof (TimeSpan));
    }

    public TimeSpan ToTimeSpan (long value)
    {
      throw Error (typeof (bool), typeof (TimeSpan));
    }

    public virtual TimeSpan ToTimeSpan (object value)
    {
      // Allow on overriden converter for xs:duration,
      // xdt:dayTimeDuration and xdt:yearMonthDuration.
      throw Error (typeof (bool), typeof (TimeSpan));
    }

    public TimeSpan ToTimeSpan (float value)
    {
      throw Error (typeof (bool), typeof (TimeSpan));
    }

    public TimeSpan ToTimeSpan (string value)
    {
      throw Error (typeof (bool), typeof (TimeSpan));
    }

    protected InvalidCastException Error (Type valueType, Type destType)
    {
      return new InvalidCastException (String.Format ("The conversion from {0} value to {1} type via {2} type is not allowed.", valueType, destType, typeCode));
    }

    public override bool ToBoolean (bool value)
    {
      throw Error (typeof (bool), typeof (bool));
    }

    public override bool ToBoolean (DateTime value)
    {
      throw Error (typeof (DateTime), typeof (bool));
    }

    public override bool ToBoolean (decimal value)
    {
      throw Error (typeof (decimal), typeof (bool));
    }

    public override bool ToBoolean (double value)
    {
      throw Error (typeof (double), typeof (bool));
    }

    public override bool ToBoolean (int value)
    {
      throw Error (typeof (int), typeof (bool));
    }

    public override bool ToBoolean (long value)
    {
      throw Error (typeof (long), typeof (bool));
    }

    public override bool ToBoolean (object value)
    {
      if (value == null)
        throw new ArgumentNullException ("value");
      throw Error (value.GetType (), typeof (bool));
    }

    public override bool ToBoolean (float value)
    {
      throw Error (typeof (float), typeof (bool));
    }

    public override bool ToBoolean (string value)
    {
      throw Error (typeof (string), typeof (bool));
    }

    public override DateTime ToDateTime (bool value)
    {
      throw Error (typeof (bool), typeof (DateTime));
    }

    public override DateTime ToDateTime (DateTime value)
    {
      throw Error (typeof (DateTime), typeof (DateTime));
    }

    public override DateTime ToDateTime (decimal value)
    {
      throw Error (typeof (decimal), typeof (DateTime));
    }

    public override DateTime ToDateTime (double value)
    {
      throw Error (typeof (double), typeof (DateTime));
    }

    public override DateTime ToDateTime (int value)
    {
      throw Error (typeof (int), typeof (DateTime));
    }

    public override DateTime ToDateTime (long value)
    {
      throw Error (typeof (long), typeof (DateTime));
    }

    public override DateTime ToDateTime (object value)
    {
      if (value == null)
        throw new ArgumentNullException ("value");
      throw Error (value.GetType (), typeof (DateTime));
    }

    public override DateTime ToDateTime (float value)
    {
      throw Error (typeof (float), typeof (DateTime));
    }

    public override DateTime ToDateTime (string value)
    {
      throw Error (typeof (string), typeof (DateTime));
    }

    public override decimal ToDecimal (bool value)
    {
      throw Error (typeof (bool), typeof (decimal));
    }

    public override decimal ToDecimal (DateTime value)
    {
      throw Error (typeof (DateTime), typeof (decimal));
    }

    public override decimal ToDecimal (decimal value)
    {
      throw Error (typeof (decimal), typeof (decimal));
    }

    public override decimal ToDecimal (double value)
    {
      throw Error (typeof (double), typeof (decimal));
    }

    public override decimal ToDecimal (int value)
    {
      throw Error (typeof (int), typeof (decimal));
    }

    public override decimal ToDecimal (long value)
    {
      throw Error (typeof (long), typeof (decimal));
    }

    public override decimal ToDecimal (object value)
    {
      if (value == null)
        throw new ArgumentNullException ("value");
      throw Error (value.GetType (), typeof (decimal));
    }

    public override decimal ToDecimal (float value)
    {
      throw Error (typeof (float), typeof (decimal));
    }

    public override decimal ToDecimal (string value)
    {
      throw Error (typeof (string), typeof (decimal));
    }

    public override double ToDouble (bool value)
    {
      throw Error (typeof (bool), typeof (double));
    }

    public override double ToDouble (DateTime value)
    {
      throw Error (typeof (DateTime), typeof (double));
    }

    public override double ToDouble (decimal value)
    {
      throw Error (typeof (decimal), typeof (double));
    }

    public override double ToDouble (double value)
    {
      throw Error (typeof (double), typeof (double));
    }

    public override double ToDouble (int value)
    {
      throw Error (typeof (int), typeof (double));
    }

    public override double ToDouble (long value)
    {
      throw Error (typeof (long), typeof (double));
    }

    public override double ToDouble (object value)
    {
      if (value == null)
        throw new ArgumentNullException ("value");
      throw Error (value.GetType (), typeof (double));
    }

    public override double ToDouble (float value)
    {
      throw Error (typeof (float), typeof (double));
    }

    public override double ToDouble (string value)
    {
      throw Error (typeof (string), typeof (double));
    }

    public override float ToSingle (bool value)
    {
      throw Error (typeof (bool), typeof (float));
    }

    public override float ToSingle (DateTime value)
    {
      throw Error (typeof (DateTime), typeof (float));
    }

    public override float ToSingle (decimal value)
    {
      throw Error (typeof (decimal), typeof (float));
    }

    public override float ToSingle (double value)
    {
      throw Error (typeof (double), typeof (float));
    }

    public override float ToSingle (int value)
    {
      throw Error (typeof (int), typeof (float));
    }

    public override float ToSingle (long value)
    {
      throw Error (typeof (long), typeof (float));
    }

    public override float ToSingle (object value)
    {
      if (value == null)
        throw new ArgumentNullException ("value");
      throw Error (value.GetType (), typeof (float));
    }

    public override float ToSingle (float value)
    {
      throw Error (typeof (float), typeof (float));
    }

    public override float ToSingle (string value)
    {
      throw Error (typeof (string), typeof (float));
    }

    public override int ToInt32 (bool value)
    {
      throw Error (typeof (bool), typeof (int));
    }

    public override int ToInt32 (DateTime value)
    {
      throw Error (typeof (DateTime), typeof (int));
    }

    public override int ToInt32 (decimal value)
    {
      throw Error (typeof (decimal), typeof (int));
    }

    public override int ToInt32 (double value)
    {
      throw Error (typeof (double), typeof (int));
    }

    public override int ToInt32 (int value)
    {
      throw Error (typeof (int), typeof (int));
    }

    public override int ToInt32 (long value)
    {
      throw Error (typeof (long), typeof (int));
    }

    public override int ToInt32 (object value)
    {
      if (value == null)
        throw new ArgumentNullException ("value");
      throw Error (value.GetType (), typeof (int));
    }

    public override int ToInt32 (float value)
    {
      throw Error (typeof (float), typeof (int));
    }

    public override int ToInt32 (string value)
    {
      throw Error (typeof (string), typeof (int));
    }

    public override long ToInt64 (bool value)
    {
      throw Error (typeof (bool), typeof (long));
    }

    public override long ToInt64 (DateTime value)
    {
      throw Error (typeof (DateTime), typeof (long));
    }

    public override long ToInt64 (decimal value)
    {
      throw Error (typeof (decimal), typeof (long));
    }

    public override long ToInt64 (double value)
    {
      throw Error (typeof (double), typeof (long));
    }

    public override long ToInt64 (int value)
    {
      throw Error (typeof (int), typeof (long));
    }

    public override long ToInt64 (long value)
    {
      throw Error (typeof (long), typeof (long));
    }

    public override long ToInt64 (object value)
    {
      if (value == null)
        throw new ArgumentNullException ("value");
      throw Error (value.GetType (), typeof (long));
    }

    public override long ToInt64 (float value)
    {
      throw Error (typeof (float), typeof (long));
    }

    public override long ToInt64 (string value)
    {
      throw Error (typeof (string), typeof (long));
    }

    public override string ToString (bool value)
    {
      throw Error (typeof (bool), typeof (string));
    }

    public override string ToString (DateTime value)
    {
      throw Error (typeof (DateTime), typeof (string));
    }

    public override string ToString (decimal value)
    {
      throw Error (typeof (decimal), typeof (string));
    }

    public override string ToString (double value)
    {
      throw Error (typeof (double), typeof (string));
    }

    public override string ToString (int value)
    {
      throw Error (typeof (int), typeof (string));
    }

    public override string ToString (long value)
    {
      throw Error (typeof (long), typeof (string));
    }

    public override string ToString (object value)
    {
      return ToString (value, null);
    }

    public override string ToString (object value, IXmlNamespaceResolver nsResolver)
    {
      if (value == null)
        throw new ArgumentNullException ("value");
      throw Error (value.GetType (), typeof (string));
    }

    public override string ToString (float value)
    {
      throw Error (typeof (float), typeof (string));
    }

    public override string ToString (string value)
    {
      return ToString (value, null);
    }
    
    public override string ToString (string value, IXmlNamespaceResolver nsResolver)
    {
      throw Error (typeof (string), typeof (string));
    }
  }

  internal class XsdLaxConverter : XsdNonPermissiveConverter
  {
    public XsdLaxConverter (XmlTypeCode code)
      : base (code)
    {
    }

    public override string ToString (bool value)
    {
      return XmlConvert.ToString (value);
    }

    public override string ToString (decimal value)
    {
      return XmlConvert.ToString (value);
    }

    public override string ToString (double value)
    {
      return XmlConvert.ToString (value);
    }

    public override string ToString (int value)
    {
      return XmlConvert.ToString (value);
    }

    public override string ToString (long value)
    {
      return XmlConvert.ToString (value);
    }

    public override string ToString (object value)
    {
      return ChangeType (value, typeof (string)) as string;
    }

    public override string ToString (float value)
    {
      return XmlConvert.ToString (value);
    }

    public override bool ToBoolean (bool value)
    {
      return value;
    }

    public override decimal ToDecimal (decimal value)
    {
      return value;
    }

    public override decimal ToDecimal (double value)
    {
      return (decimal) value;
    }

    public override decimal ToDecimal (int value)
    {
      return (decimal) value;
    }

    public override decimal ToDecimal (long value)
    {
      return (decimal) value;
    }

    [MonoTODO]
    public override decimal ToDecimal (object value)
    {
      return (decimal) ChangeType (value, typeof (decimal));
    }

    public override decimal ToDecimal (float value)
    {
      return (decimal) value;
    }

    public override double ToDouble (decimal value)
    {
      return (double) value;
    }

    public override double ToDouble (double value)
    {
      return (double) value;
    }

    public override double ToDouble (int value)
    {
      return (double) value;
    }

    public override double ToDouble (long value)
    {
      return (double) value;
    }

    [MonoTODO]
    public override double ToDouble (object value)
    {
      return (double) ChangeType (value, typeof (double));
    }

    public override double ToDouble (float value)
    {
      return (double) value;
    }

    public override float ToSingle (decimal value)
    {
      return (float) value;
    }

    public override float ToSingle (double value)
    {
      return (float) value;
    }

    public override float ToSingle (int value)
    {
      return (float) value;
    }

    public override float ToSingle (long value)
    {
      return (float) value;
    }

    [MonoTODO]
    public override float ToSingle (object value)
    {
      return (float) ChangeType (value, typeof (float));
    }

    public override float ToSingle (float value)
    {
      return (float) value;
    }

    public override int ToInt32 (int value)
    {
      return value;
    }

    public override int ToInt32 (long value)
    {
      return XQueryConvert.IntegerToInt (value);
    }

    [MonoTODO]
    public override int ToInt32 (object value)
    {
      return (int) ChangeType (value, typeof (int));
    }

    public override long ToInt64 (int value)
    {
      return value;
    }

    public override long ToInt64 (long value)
    {
      return value;
    }

    [MonoTODO]
    public override long ToInt64 (object value)
    {
      return (long) ChangeType (value, typeof (long));
    }
  }

  internal class XsdAnyTypeConverter : XsdNumericConverter
  {
    public XsdAnyTypeConverter (XmlTypeCode code)
      : base (code)
    {
    }

    #region boolean
    public override bool ToBoolean (decimal value)
    {
      return value != 0;
    }

    public override bool ToBoolean (double value)
    {
      return value != 0;
    }

    public override bool ToBoolean (int value)
    {
      return value != 0;
    }

    public override bool ToBoolean (long value)
    {
      return value != 0;
    }

    [MonoTODO]
    public override bool ToBoolean (object value)
    {
      return (bool) ChangeType (value, typeof (bool));
    }

    public override bool ToBoolean (float value)
    {
      return value != 0;
    }

    public override decimal ToDecimal (bool value)
    {
      return value ? 1 : 0;
    }

    public override double ToDouble (bool value)
    {
      return value ? 1 : 0;
    }

    public override float ToSingle (bool value)
    {
      return value ? 1 : 0;
    }

    public override int ToInt32 (bool value)
    {
      return value ? 1 : 0;
    }

    public override long ToInt64 (bool value)
    {
      return value ? 1 : 0;
    }
    #endregion

    #region string

    public override DateTime ToDateTime (DateTime value)
    {
      return value;
    }

    public override string ToString (DateTime value)
    {
      return XmlConvert.ToString (value);
    }

    public override string ToString (string value)
    {
      return value;
    }
    #endregion
  }

  internal class XsdStringConverter : XsdLaxConverter
  {
    public XsdStringConverter (XmlTypeCode code)
      : base (code)
    {
    }

    public override DateTime ToDateTime (DateTime value)
    {
      return value;
    }

    public override string ToString (DateTime value)
    {
      return XmlConvert.ToString (value);
    }

    public override string ToString (string value)
    {
      return value;
    }
  }

  internal class XsdNumericConverter : XsdLaxConverter
  {
    public XsdNumericConverter (XmlTypeCode code)
      : base (code)
    {
    }

    #region boolean
    public override bool ToBoolean (decimal value)
    {
      return value != 0;
    }

    public override bool ToBoolean (double value)
    {
      return value != 0;
    }

    public override bool ToBoolean (int value)
    {
      return value != 0;
    }

    public override bool ToBoolean (long value)
    {
      return value != 0;
    }

    [MonoTODO]
    public override bool ToBoolean (object value)
    {
      return (bool) ChangeType (value, typeof (bool));
    }

    public override bool ToBoolean (float value)
    {
      return value != 0;
    }

    public override decimal ToDecimal (bool value)
    {
      return value ? 1 : 0;
    }

    public override double ToDouble (bool value)
    {
      return value ? 1 : 0;
    }

    public override float ToSingle (bool value)
    {
      return value ? 1 : 0;
    }

    public override int ToInt32 (bool value)
    {
      return value ? 1 : 0;
    }

    public override long ToInt64 (bool value)
    {
      return value ? 1 : 0;
    }
    #endregion

    #region numeric with point to without point
    public override int ToInt32 (decimal value)
    {
      return XQueryConvert.DecimalToInt (value);
    }

    public override int ToInt32 (double value)
    {
      return XQueryConvert.DoubleToInt (value);
    }

    public override int ToInt32 (float value)
    {
      return XQueryConvert.FloatToInt (value);
    }

    public override long ToInt64 (decimal value)
    {
      return XQueryConvert.DecimalToInteger (value);
    }

    public override long ToInt64 (double value)
    {
      return XQueryConvert.DoubleToInteger (value);
    }

    public override long ToInt64 (float value)
    {
      return XQueryConvert.FloatToInteger (value);
    }
    #endregion
  }

  internal class XsdDateTimeConverter : XsdNonPermissiveConverter
  {
    public XsdDateTimeConverter (XmlTypeCode code)
      : base (code)
    {
    }

    public override string ToString (DateTime value)
    {
      return XmlConvert.ToString (value);
    }

    public override DateTime ToDateTime (DateTime value)
    {
      return value;
    }
  }

  internal class XsdBooleanConverter : XsdNumericConverter
  {
    public XsdBooleanConverter (XmlTypeCode code)
      : base (code)
    {
    }
  }

  internal class XsdMiscBaseConverter : XsdNonPermissiveConverter
  {
    public XsdMiscBaseConverter (XmlTypeCode code)
      : base (code)
    {
    }

    public override string ToString (string value)
    {
      return value;
    }

    public override object ChangeType (object value, Type type, IXmlNamespaceResolver nsResolver)
    {
      if (Code == XmlTypeCode.HexBinary) {
        if (value == null)
          throw new ArgumentNullException ("value");
        if (type == null)
          throw new ArgumentNullException ("type");
        if (value.GetType () == typeof (byte [])) {
          if (type == typeof (string))
            return XQueryConvert.HexBinaryToString ((byte []) value);
          else if (type == typeof (byte []))
            return value;
        }
      }
      return base.ChangeType (value, type, nsResolver);
    }
  }
}

#endif