-//
-// System.Convert.cs
-//
-// Author:
-// Derek Holden (dholden@draper.com)
-//
-// (C) Ximian, Inc. http://www.ximian.com
-//
-
-//
-// System.Convert class. This was written word for word off the
-// Library specification for System.Convert in the ECMA TC39 TG2
-// and TG3 working documents. The first page of which has a table
-// for all legal conversion scenerios.
-//
-// This header and the one above it can be formatted however, just trying
-// to keep it consistent w/ the existing mcs headers.
-//
-// This Convert class could be written another way, with each type
-// implementing IConvertible and defining their own conversion functions,
-// and this class just calling the type's implementation. Or, they can
-// be defined here and the implementing type can use these functions when
-// defining their IConvertible interface. Byte's ToBoolean() calls
-// Convert.ToBoolean(byte), or Convert.ToBoolean(byte) calls
-// byte.ToBoolean(). The first case is what is done here.
-//
-// There are also conversion functions that are not defined in
-// the ECMA draft, such as there is no bool ToBoolean(DateTime value),
-// and placing that somewhere won't compile w/ this Convert since the
-// function doesn't exist. However calling that when using Microsoft's
-// System.Convert doesn't produce any compiler errors, it just throws
-// an InvalidCastException at runtime.
-//
-// The .NET Framework SDK lists DBNull as a member of this class
-// as 'public static readonly object DBNull;'.
-//
-// It should also be decided if all the cast return values should be
-// returned as unchecked or not.
-//
-
-namespace System {
-
- /// <summary>
- /// Class to convert between data types.</summary>
- public sealed class Convert {
-
- // ========== Boolean Conversions ========== //
-
- public static bool ToBoolean(bool value) {
- return value;
- }
-
- public static bool ToBoolean(byte value) {
- return (value != 0);
- }
-
- public static bool ToBoolean(decimal value) {
- return (value != 0M);
- }
-
- public static bool ToBoolean(double value) {
- return (value != 0);
- }
-
- public static bool ToBoolean(float value) {
- return (value != 0f);
- }
-
- public static bool ToBoolean(int value) {
- return (value != 0);
- }
-
- public static bool ToBoolean(long value) {
- return (value != 0);
- }
-
- public static bool ToBoolean(sbyte value) {
- return (value != 0);
- }
-
- public static bool ToBoolean(short value) {
- return (value != 0);
- }
-
- public static bool ToBoolean(string value) {
- return Boolean.Parse(value);
- }
-
- public static bool ToBoolean(uint value) {
- return (value != 0);
- }
-
- public static bool ToBoolean(ulong value) {
- return (value != 0);
- }
-
- public static bool ToBoolean(ushort value) {
- return (value != 0);
- }
-
- // ========== Byte Conversions ========== //
-
- public static byte ToByte(bool value) {
- return (byte)(value ? 1 : 0);
- }
-
- public static byte ToByte(byte value) {
- return value;
- }
-
- public static byte ToByte(char value) {
- if(value > Byte.MaxValue)
- throw new OverflowException
- ("Value is greater than Byte.MaxValue");
-
- return (byte)value;
- }
-
- public static byte ToByte(decimal value) {
- if(value > Byte.MaxValue || value < Byte.MinValue)
- throw new OverflowException
- ("Value is greater than Byte.MaxValue or less than Byte.MinValue");
-
- return (byte)value;
- }
-
- public static byte ToByte(double value) {
- if(value > Byte.MaxValue || value < Byte.MinValue)
- throw new OverflowException
- ("Value is greater than Byte.MaxValue or less than Byte.MinValue");
-
- // This and the float version of ToByte are the only ones
- // the spec listed as checking for .NaN and Infinity overflow
- if(value == Double.NaN || value == Double.PositiveInfinity ||
- value == Double.NegativeInfinity)
- throw new OverflowException
- ("Value is equal to Double.NaN, Double.PositiveInfinity, or Double.NegativeInfinity");
-
- return (byte)value;
- }
-
- public static byte ToByte(float value) {
- if(value > Byte.MaxValue || value < Byte.MinValue)
- throw new OverflowException
- ("Value is greater than Byte.MaxValue or less than Byte.Minalue");
-
- // This and the double version of ToByte are the only ones
- // the spec listed as checking for .NaN and Infinity overflow
- if(value == Single.NaN || value == Single.PositiveInfinity ||
- value == Single.NegativeInfinity)
- throw new OverflowException
- ("Value is equal to Single.NaN, Single.PositiveInfinity, or Single.NegativeInfinity");
-
- return (byte)value;
- }
-
- public static byte ToByte(int value) {
- if(value > Byte.MaxValue || value < Byte.MinValue)
- throw new OverflowException
- ("Value is greater than Byte.MaxValue or less than Byte.MinValue");
-
- return (byte)value;
- }
-
- public static byte ToByte(long value) {
- if(value > Byte.MaxValue || value < Byte.MinValue)
- throw new OverflowException
- ("Value is greater than Byte.MaxValue or less than Byte.MinValue");
-
- return (byte)value;
- }
-
- public static byte ToByte(sbyte value) {
- if(value < Byte.MinValue)
- throw new OverflowException
- ("Value is less than Byte.MinValue");
-
- return (byte)value;
- }
-
- public static byte ToByte(short value) {
- if(value > Byte.MaxValue || value < Byte.MinValue)
- throw new OverflowException
- ("Value is greater than Byte.MaxValue or less than Byte.MinValue");
-
- return (byte)value;
- }
-
- public static byte ToByte(string value) {
- return Byte.Parse(value);
- }
-
- public static byte ToByte(string value, IFormatProvider provider) {
- return Byte.Parse(value, provider);
- }
-
- public static byte ToByte(uint value) {
- if(value > Byte.MaxValue)
- throw new OverflowException
- ("Value is greater than Byte.MaxValue");
-
- return (byte)value;
- }
-
- public static byte ToByte(ulong value) {
- if(value > Byte.MaxValue)
- throw new OverflowException
- ("Value is greater than Byte.MaxValue");
-
- return (byte)value;
- }
-
- public static byte ToByte(ushort value) {
- if(value > Byte.MaxValue)
- throw new OverflowException
- ("Value is greater than Byte.MaxValue");
-
- return (byte)value;
- }
-
- // ========== Char Conversions ========== //
-
- public static char ToChar(byte value) {
- return (char)value;
- }
-
- public static char ToChar(char value) {
- return value;
- }
-
- public static char ToChar(int value) {
- if(value > Char.MaxValue || value < Char.MinValue)
- throw new OverflowException
- ("Value is greater than Char.MaxValue or less than Char.MinValue");
-
- return (char)value;
- }
-
- public static char ToChar(long value) {
- if(value > Char.MaxValue || value < Char.MinValue)
- throw new OverflowException
- ("Value is greater than Char.MaxValue or less than Char.MinValue");
-
- return (char)value;
- }
-
- public static char ToChar(sbyte value) {
- if(value < Char.MinValue)
- throw new OverflowException
- ("Value is less than Char.MinValue");
-
- return (char)value;
- }
-
- public static char ToChar(short value) {
- if(value < Char.MinValue)
- throw new OverflowException
- ("Value is less than Char.MinValue");
-
- return (char)value;
- }
-
- public static char ToChar(string value) {
- return Char.Parse(value);
- }
-
- public static char ToChar(uint value) {
- if(value > Char.MaxValue)
- throw new OverflowException
- ("Value is greater than Char.MaxValue");
-
- return (char)value;
- }
-
- public static char ToChar(ulong value) {
- if(value > Char.MaxValue)
- throw new OverflowException
- ("Value is greater than Char.MaxValue");
-
- return (char)value;
- }
-
- public static char ToChar(ushort value) {
- if(value > Char.MaxValue)
- throw new OverflowException
- ("Value is greater than Char.MaxValue");
-
- return (char)value;
- }
-
- // ========== DateTime Conversions ========== //
-
- public static DateTime ToDateTime(string value) {
- return DateTime.Parse(value);
- }
-
- public static DateTime ToDateTime(string value, IFormatProvider provider) {
- return DateTime.Parse(value, provider);
- }
-
- // ========== Decimal Conversions ========== //
-
- public static decimal ToDecimal(bool value) {
- return value ? 1 : 0;
- }
-
- public static decimal ToDecimal(byte value) {
- return (decimal)value;
- }
-
- public static decimal ToDecimal(decimal value) {
- return value;
- }
-
- public static decimal ToDecimal(double value) {
- if(value > (double)Decimal.MaxValue || value < (double)Decimal.MinValue)
- throw new OverflowException
- ("Value is greater than Decimal.MaxValue or less than Decimal.MinValue");
-
- return (decimal)value;
- }
-
- public static decimal ToDecimal(float value) {
- if(value > (double)Decimal.MaxValue || value < (double)Decimal.MinValue)
- throw new OverflowException
- ("Value is greater than Decimal.MaxValue or less than Decimal.MinValue");
-
- return (decimal)value;
- }
-
- public static decimal ToDecimal(int value) {
- return (decimal)value;
- }
-
- public static decimal ToDecimal(long value) {
- return (decimal)value;
- }
-
- public static decimal ToDecimal(sbyte value) {
- return (decimal)value;
- }
-
- public static decimal ToDecimal(short value) {
- return (decimal)value;
- }
-
- public static decimal ToDecimal(string value) {
- return Decimal.Parse(value);
- }
-
- public static decimal ToDecimal(string value, IFormatProvider provider) {
- return Decimal.Parse(value, provider);
- }
-
- public static decimal ToDecimal(uint value) {
- return (decimal)value;
- }
-
- public static decimal ToDecimal(ulong value) {
- return (decimal)value;
- }
-
- public static decimal ToDecimal(ushort value) {
- return (decimal)value;
- }
-
- // ========== Double Conversions ========== //
-
- public static double ToDouble(bool value) {
- return value ? 1 : 0;
- }
-
- public static double ToDouble(byte value) {
- return (double)value;
- }
-
- public static double ToDouble(decimal value) {
- return (double)value;
- }
-
- public static double ToDouble(double value) {
- return value;
- }
-
- public static double ToDouble(float value) {
- return (double)value;
- }
-
- public static double ToDouble(int value) {
- return (double)value;
- }
-
- public static double ToDouble(long value) {
- return (double)value;
- }
-
- public static double ToDouble(sbyte value) {
- return (double)value;
- }
-
- public static double ToDouble(short value) {
- return (double)value;
- }
-
- public static double ToDouble(string value) {
- return Double.Parse(value);
- }
-
- public static double ToDouble(string value, IFormatProvider provider) {
- return Double.Parse(value, provider);
- }
-
- public static double ToDouble(uint value) {
- return (double)value;
- }
-
- public static double ToDouble(ulong value) {
- return (double)value;
- }
-
- public static double ToDouble(ushort value) {
- return (double)value;
- }
-
- // ========== Int16 Conversions ========== //
-
- public static short ToInt16(bool value) {
- return (short)(value ? 1 : 0);
- }
-
- public static short ToInt16(byte value) {
- return (short)value;
- }
-
- public static short ToInt16(char value) {
- if(value > Int16.MaxValue)
- throw new OverflowException
- ("Value is greater than Int16.MaxValue");
-
- return (short)value;
- }
-
- public static short ToInt16(decimal value) {
- if(value > Int16.MaxValue || value < Int16.MinValue)
- throw new OverflowException
- ("Value is greater than Int16.MaxValue or less than Int16.MinValue");
-
- return (short)value;
- }
-
- public static short ToInt16(double value) {
- if(value > Int16.MaxValue || value < Int16.MinValue)
- throw new OverflowException
- ("Value is greater than Int16.MaxValue or less than Int16.MinValue");
-
- return (short)value;
- }
-
- public static short ToInt16(float value) {
- if(value > Int16.MaxValue || value < Int16.MinValue)
- throw new OverflowException
- ("Value is greater than Int16.MaxValue or less than Int16.MinValue");
-
- return (short)value;
- }
-
- public static short ToInt16(int value) {
- if(value > Int16.MaxValue || value < Int16.MinValue)
- throw new OverflowException
- ("Value is greater than Int16.MaxValue or less than Int16.MinValue");
-
- return (short)value;
- }
-
- public static short ToInt16(long value) {
- if(value > Int16.MaxValue || value < Int16.MinValue)
- throw new OverflowException
- ("Value is greater than Int16.MaxValue or less than Int16.MinValue");
-
- return (short)value;
- }
-
- public static short ToInt16(sbyte value) {
- return (short)value;
- }
-
- public static short ToInt16(short value) {
- return value;
- }
-
- public static short ToInt16(string value) {
- return Int16.Parse(value);
- }
-
- public static short ToInt16(string value, IFormatProvider provider) {
- return Int16.Parse(value, provider);
- }
-
- public static short ToInt16(uint value) {
- if(value > Int16.MaxValue)
- throw new OverflowException
- ("Value is greater than Int16.MaxValue");
-
- return (short)value;
- }
-
- public static short ToInt16(ulong value) {
- if(value > (ulong)Int16.MaxValue)
- throw new OverflowException
- ("Value is greater than Int16.MaxValue");
-
- return (short)value;
- }
-
- public static short ToInt16(ushort value) {
- if(value > Int16.MaxValue)
- throw new OverflowException
- ("Value is greater than Int16.MaxValue");
-
- return (short)value;
- }
-
- // ========== Int32 Conversions ========== //
-
- public static int ToInt32(bool value) {
- return value ? 1 : 0;
- }
-
- public static int ToInt32(byte value) {
- return (int)value;
- }
-
- public static int ToInt32(char value) {
- return (int)value;
- }
-
- public static int ToInt32(decimal value) {
- if(value > Int32.MaxValue || value < Int32.MinValue)
- throw new OverflowException
- ("Value is greater than Int32.MaxValue or less than Int32.MinValue");
-
- return (int)value;
- }
-
- public static int ToInt32(double value) {
- if(value > Int32.MaxValue || value < Int32.MinValue)
- throw new OverflowException
- ("Value is greater than Int32.MaxValue or less than Int32.MinValue");
-
- return (int)value;
- }
-
- public static int ToInt32(float value) {
- if(value > Int32.MaxValue || value < Int32.MinValue)
- throw new OverflowException
- ("Value is greater than Int32.MaxValue or less than Int32.MinValue");
-
- return (int)value;
- }
-
- public static int ToInt32(int value) {
- return value;
- }
-
- public static int ToInt32(long value) {
- if(value > Int32.MaxValue || value < Int32.MinValue)
- throw new OverflowException
- ("Value is greater than Int32.MaxValue or less than Int32.MinValue");
-
- return (int)value;
- }
-
- public static int ToInt32(sbyte value) {
- return (int)value;
- }
-
- public static int ToInt32(short value) {
- return (int)value;
- }
-
- public static int ToInt32(string value) {
- return Int32.Parse(value);
- }
-
- public static int ToInt32(string value, IFormatProvider provider) {
- return Int32.Parse(value, provider);
- }
-
- public static int ToInt32(uint value) {
- if(value > Int32.MaxValue)
- throw new OverflowException
- ("Value is greater than Int32.MaxValue");
-
- return (int)value;
- }
-
- public static int ToInt32(ulong value) {
- if(value > Int32.MaxValue)
- throw new OverflowException
- ("Value is greater than Int32.MaxValue");
-
- return (int)value;
- }
-
- public static int ToInt32(ushort value) {
- return (int)value;
- }
-
- // ========== Int64 Conversions ========== //
-
- public static long ToInt64(bool value) {
- return value ? 1 : 0;
- }
-
- public static long ToInt64(byte value) {
- return (long)value;
- }
-
- public static long ToInt64(char value) {
- return (long)value;
- }
-
- public static long ToInt64(decimal value) {
- if(value > Int64.MaxValue || value < Int64.MinValue)
- throw new OverflowException
- ("Value is greater than Int64.MaxValue or less than Int64.MinValue");
-
- return (long)value;
- }
-
- public static long ToInt64(double value) {
- if(value > Int64.MaxValue || value < Int64.MinValue)
- throw new OverflowException
- ("Value is greater than Int64.MaxValue or less than Int64.MinValue");
-
- return (long)value;
- }
-
- public static long ToInt64(float value) {
- if(value > Int64.MaxValue || value < Int64.MinValue)
- throw new OverflowException
- ("Value is greater than Int64.MaxValue or less than Int64.MinValue");
-
- return (long)value;
- }
-
- public static long ToInt64(int value) {
- return (long)value;
- }
-
- public static long ToInt64(long value) {
- return value;
- }
-
- public static long ToInt64(sbyte value) {
- return (long)value;
- }
-
- public static long ToInt64(short value) {
- return (long)value;
- }
-
- public static long ToInt64(string value) {
- return Int64.Parse(value);
- }
-
- public static long ToInt64(string value, IFormatProvider provider) {
- return Int64.Parse(value, provider);
- }
-
- public static long ToInt64(uint value) {
- return (long)value;
- }
-
- public static long ToInt64(ulong value) {
- if(value > Int64.MaxValue)
- throw new OverflowException
- ("Value is greater than Int64.MaxValue");
-
- return (long)value;
- }
-
- public static long ToInt64(ushort value) {
- return (long)value;
- }
-
- // ========== SByte Conversions ========== //
-
- public static sbyte ToSByte(bool value) {
- return (sbyte)(value ? 1 : 0);
- }
-
- public static sbyte ToSByte(byte value) {
- if(value > SByte.MaxValue)
- throw new OverflowException
- ("Value is greater than SByte.MaxValue");
-
- return (sbyte)value;
- }
-
- public static sbyte ToSByte(char value) {
- if(value > SByte.MaxValue)
- throw new OverflowException
- ("Value is greater than SByte.MaxValue");
-
- return (sbyte)value;
- }
-
- public static sbyte ToSByte(decimal value) {
- if(value > SByte.MaxValue || value < SByte.MinValue)
- throw new OverflowException
- ("Value is greater than SByte.MaxValue or less than SByte.MinValue");
-
- return (sbyte)value;
- }
-
- public static sbyte ToSByte(double value) {
- if(value > SByte.MaxValue || value < SByte.MinValue)
- throw new OverflowException
- ("Value is greater than SByte.MaxValue or less than SByte.MinValue");
-
- return (sbyte)value;
- }
-
- public static sbyte ToSByte(float value) {
- if(value > SByte.MaxValue || value < SByte.MinValue)
- throw new OverflowException
- ("Value is greater than SByte.MaxValue or less than SByte.Minalue");
-
- return (sbyte)value;
- }
-
- public static sbyte ToSByte(int value) {
- if(value > SByte.MaxValue || value < SByte.MinValue)
- throw new OverflowException
- ("Value is greater than SByte.MaxValue or less than SByte.MinValue");
-
- return (sbyte)value;
- }
-
- public static sbyte ToSByte(long value) {
- if(value > SByte.MaxValue || value < SByte.MinValue)
- throw new OverflowException
- ("Value is greater than SByte.MaxValue or less than SByte.MinValue");
-
- return (sbyte)value;
- }
-
- public static sbyte ToSByte(sbyte value) {
- return value;
- }
-
- public static sbyte ToSByte(short value) {
- if(value > SByte.MaxValue || value < SByte.MinValue)
- throw new OverflowException
- ("Value is greater than SByte.MaxValue or less than SByte.MinValue");
-
- return (sbyte)value;
- }
-
- public static sbyte ToSByte(string value) {
- return SByte.Parse(value);
- }
-
- public static sbyte ToSByte(string value, IFormatProvider provider) {
- return SByte.Parse(value, provider);
- }
-
- public static sbyte ToSByte(uint value) {
- if(value > SByte.MaxValue)
- throw new OverflowException
- ("Value is greater than SByte.MaxValue");
-
- return (sbyte)value;
- }
-
- public static sbyte ToSByte(ulong value) {
- if(value > (ulong)SByte.MaxValue)
- throw new OverflowException
- ("Value is greater than SByte.MaxValue");
-
- return (sbyte)value;
- }
-
- public static sbyte ToSByte(ushort value) {
- if(value > SByte.MaxValue)
- throw new OverflowException
- ("Value is greater than SByte.MaxValue");
-
- return (sbyte)value;
- }
-
- // ========== Single Conversions ========== //
-
- public static float ToSingle(bool value) {
- return value ? 1 : 0;
- }
-
- public static float ToSingle(byte value) {
- return (float)value;
- }
-
- public static float ToSingle(decimal value) {
- return (float)value;
- }
-
- public static float ToSingle(double value) {
- if(value > Single.MaxValue || value < Single.MinValue)
- throw new OverflowException
- ("Value is greater than Single.MaxValue or less than Single.MinValue");
-
- return (float)value;
- }
-
- public static float ToSingle(float value) {
- return value;
- }
-
- public static float ToSingle(int value) {
- return (float)value;
- }
-
- public static float ToSingle(long value) {
- return (float)value;
- }
-
- public static float ToSingle(sbyte value) {
- return (float)value;
- }
-
- public static float ToSingle(short value) {
- return (float)value;
- }
-
- public static float ToSingle(string value) {
- return Single.Parse(value);
- }
-
- public static float ToSingle(string value, IFormatProvider provider) {
- return Single.Parse(value, provider);
- }
-
- public static float ToSingle(uint value) {
- return (float)value;
- }
-
- public static float ToSingle(ulong value) {
- return (float)value;
- }
-
- public static float ToSingle(ushort value) {
- return (float)value;
- }
-
- // ========== String Conversions ========== //
-
- public static string ToString(bool value) {
- return value.ToString();
- }
-
- public static string ToString(byte value) {
- return value.ToString();
- }
-
- public static string ToString(byte value, IFormatProvider provider) {
- return value.ToString(provider);
- }
-
- public static string ToString(char value) {
- return value.ToString();
- }
-
- public static string ToString(DateTime value) {
- return value.ToString();
- }
-
- public static string ToString(DateTime value, IFormatProvider provider) {
- return value.ToString(provider);
- }
-
- public static string ToString(decimal value) {
- return value.ToString();
- }
-
- public static string ToString(decimal value, IFormatProvider provider) {
- return value.ToString(provider);
- }
-
- public static string ToString(double value) {
- return value.ToString();
- }
-
- public static string ToString(double value, IFormatProvider provider) {
- return value.ToString(provider);
- }
-
- public static string ToString(float value) {
- return value.ToString();
- }
-
- public static string ToString(float value, IFormatProvider provider) {
- return value.ToString(provider);
- }
-
- public static string ToString(int value) {
- return value.ToString();
- }
-
- public static string ToString(int value, IFormatProvider provider) {
- return value.ToString(provider);
- }
-
- public static string ToString(long value) {
- return value.ToString();
- }
-
- public static string ToString(long value, IFormatProvider provider) {
- return value.ToString(provider);
- }
-
- public static string ToString(sbyte value) {
- return value.ToString();
- }
-
- public static string ToString(sbyte value, IFormatProvider provider) {
- return value.ToString(provider);
- }
-
- public static string ToString(short value) {
- return value.ToString();
- }
-
- public static string ToString(short value, IFormatProvider provider) {
- return value.ToString(provider);
- }
-
- public static string ToString(string value) {
- return value;
- }
-
- public static string ToString(uint value) {
- return value.ToString();
- }
-
- public static string ToString(uint value, IFormatProvider provider) {
- return value.ToString(provider);
- }
-
- public static string ToString(ulong value) {
- return value.ToString();
- }
-
- public static string ToString(ulong value, IFormatProvider provider) {
- return value.ToString(provider);
- }
-
- public static string ToString(ushort value) {
- return value.ToString();
- }
-
- public static string ToString(ushort value, IFormatProvider provider) {
- return value.ToString(provider);
- }
-
- // ========== UInt16 Conversions ========== //
-
- public static ushort ToUInt16(bool value) {
- return (ushort)(value ? 1 : 0);
- }
-
- public static ushort ToUInt16(byte value) {
- return (ushort)value;
- }
-
- public static ushort ToUInt16(char value) {
- return (ushort)value;
- }
-
- public static ushort ToUInt16(decimal value) {
- if(value > UInt16.MaxValue || value < UInt16.MinValue)
- throw new OverflowException
- ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");
-
- return (ushort)value;
- }
-
- public static ushort ToUInt16(double value) {
- if(value > UInt16.MaxValue || value < UInt16.MinValue)
- throw new OverflowException
- ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");
-
- return (ushort)value;
- }
-
- public static ushort ToUInt16(float value) {
- if(value > UInt16.MaxValue || value < UInt16.MinValue)
- throw new OverflowException
- ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");
-
- return (ushort)value;
- }
-
- public static ushort ToUInt16(int value) {
- if(value > UInt16.MaxValue || value < UInt16.MinValue)
- throw new OverflowException
- ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");
-
- return (ushort)value;
- }
-
- public static ushort ToUInt16(long value) {
- if(value > UInt16.MaxValue || value < UInt16.MinValue)
- throw new OverflowException
- ("Value is greater than UInt16.MaxValue or less than UInt16.MinValue");
-
- return (ushort)value;
- }
-
- public static ushort ToUInt16(sbyte value) {
- if(value < UInt16.MinValue)
- throw new OverflowException
- ("Value is less than UInt16.MinValue");
-
- return (ushort)value;
- }
-
- public static ushort ToUInt16(short value) {
- if(value < UInt16.MinValue)
- throw new OverflowException
- ("Value is less than UInt16.MinValue");
-
- return (ushort)value;
- }
-
- public static ushort ToUInt16(string value) {
- return UInt16.Parse(value);
- }
-
- public static ushort ToUInt16(string value, IFormatProvider provider) {
- return UInt16.Parse(value, provider);
- }
-
- public static ushort ToUInt16(uint value) {
- if(value > UInt16.MaxValue)
- throw new OverflowException
- ("Value is greater than UInt16.MaxValue");
-
- return (ushort)value;
- }
-
- public static ushort ToUInt16(ulong value) {
- if(value > (ulong)UInt16.MaxValue)
- throw new OverflowException
- ("Value is greater than UInt16.MaxValue");
-
- return (ushort)value;
- }
-
- public static ushort ToUInt16(ushort value) {
- return value;
- }
-
- // ========== UInt32 Conversions ========== //
-
- public static uint ToUInt32(bool value) {
- return (uint)(value ? 1 : 0);
- }
-
- public static uint ToUInt32(byte value) {
- return (uint)value;
- }
-
- public static uint ToUInt32(char value) {
- return (uint)value;
- }
-
- public static uint ToUInt32(decimal value) {
- if(value > UInt32.MaxValue || value < UInt32.MinValue)
- throw new OverflowException
- ("Value is greater than UInt32.MaxValue or less than UInt32.MinValue");
-
- return (uint)value;
- }
-
- public static uint ToUInt32(double value) {
- if(value > UInt32.MaxValue || value < UInt32.MinValue)
- throw new OverflowException
- ("Value is greater than UInt32.MaxValue or less than UInt32.MinValue");
-
- return (uint)value;
- }
-
- public static uint ToUInt32(float value) {
- if(value > UInt32.MaxValue || value < UInt32.MinValue)
- throw new OverflowException
- ("Value is greater than UInt32.MaxValue or less than UInt32.MinValue");
-
- return (uint)value;
- }
-
- public static uint ToUInt32(int value) {
- if(value < UInt32.MinValue)
- throw new OverflowException
- ("Value is less than UInt32.MinValue");
-
- return (uint)value;
- }
-
- public static uint ToUInt32(long value) {
- if(value > UInt32.MaxValue || value < UInt32.MinValue)
- throw new OverflowException
- ("Value is greater than UInt32.MaxValue or less than UInt32.MinValue");
-
- return (uint)value;
- }
-
- public static uint ToUInt32(sbyte value) {
- if(value < UInt32.MinValue)
- throw new OverflowException
- ("Value is less than UInt32.MinValue");
-
- return (uint)value;
- }
-
- public static uint ToUInt32(short value) {
- if(value < UInt32.MinValue)
- throw new OverflowException
- ("Value is less than UInt32.MinValue");
-
- return (uint)value;
- }
-
- public static uint ToUInt32(string value) {
- return UInt32.Parse(value);
- }
-
- public static uint ToUInt32(string value, IFormatProvider provider) {
- return UInt32.Parse(value, provider);
- }
-
- public static uint ToUInt32(uint value) {
- return value;
- }
-
- public static uint ToUInt32(ulong value) {
- if(value > UInt32.MaxValue)
- throw new OverflowException
- ("Value is greater than UInt32.MaxValue");
-
- return (uint)value;
- }
-
- public static uint ToUInt32(ushort value) {
- return (uint)value;
- }
-
- // ========== UInt64 Conversions ========== //
-
- public static ulong ToUInt64(bool value) {
- return (ulong)(value ? 1 : 0);
- }
-
- public static ulong ToUInt64(byte value) {
- return (ulong)value;
- }
-
- public static ulong ToUInt64(char value) {
- return (ulong)value;
- }
-
- public static ulong ToUInt64(decimal value) {
- if(value > UInt64.MaxValue || value < UInt64.MinValue)
- throw new OverflowException
- ("Value is greater than UInt64.MaxValue or less than UInt64.MinValue");
-
- return (ulong)value;
- }
-
- public static ulong ToUInt64(double value) {
- if(value > UInt64.MaxValue || value < UInt64.MinValue)
- throw new OverflowException
- ("Value is greater than UInt64.MaxValue or less than UInt64.MinValue");
-
- return (ulong)value;
- }
-
- public static ulong ToUInt64(float value) {
- if(value > UInt64.MaxValue || value < UInt64.MinValue)
- throw new OverflowException
- ("Value is greater than UInt64.MaxValue or less than UInt64.MinValue");
-
- return (ulong)value;
- }
-
- public static ulong ToUInt64(int value) {
- if(value < (int)UInt64.MinValue)
- throw new OverflowException
- ("Value is less than UInt64.MinValue");
-
- return (ulong)value;
- }
-
- public static ulong ToUInt64(long value) {
- if(value < (long)UInt64.MinValue)
- throw new OverflowException
- ("Value is less than UInt64.MinValue");
-
- return (ulong)value;
- }
-
- public static ulong ToUInt64(sbyte value) {
- if(value < (sbyte)UInt64.MinValue)
- throw new OverflowException
- ("Value is less than UInt64.MinValue");
-
- return (ulong)value;
- }
-
- public static ulong ToUInt64(short value) {
- if(value < (short)UInt64.MinValue)
- throw new OverflowException
- ("Value is less than UInt64.MinValue");
-
- return (ulong)value;
- }
-
- public static ulong ToUInt64(string value) {
- return UInt64.Parse(value);
- }
-
- public static ulong ToUInt64(string value, IFormatProvider provider) {
- return UInt64.Parse(value, provider);
- }
-
- public static ulong ToUInt64(uint value) {
- return (ulong)value;
- }
-
- public static ulong ToUInt64(ulong value) {
- return value;
- }
-
- public static ulong ToUInt64(ushort value) {
- return (ulong)value;
- }
- }
-}
+//\r
+// System.Convert.cs\r
+//\r
+// Author:\r
+// Derek Holden (dholden@draper.com)\r
+// Duncan Mak (duncan@ximian.com)\r
+//\r
+// (C) Ximian, Inc. http://www.ximian.com\r
+//\r
+\r
+//\r
+// System.Convert class. This was written word for word off the \r
+// Library specification for System.Convert in the ECMA TC39 TG2 \r
+// and TG3 working documents. The first page of which has a table\r
+// for all legal conversion scenerios.\r
+//\r
+// This header and the one above it can be formatted however, just trying\r
+// to keep it consistent w/ the existing mcs headers.\r
+//\r
+// This Convert class could be written another way, with each type \r
+// implementing IConvertible and defining their own conversion functions,\r
+// and this class just calling the type's implementation. Or, they can \r
+// be defined here and the implementing type can use these functions when \r
+// defining their IConvertible interface. Byte's ToBoolean() calls \r
+// Convert.ToBoolean(byte), or Convert.ToBoolean(byte) calls \r
+// byte.ToBoolean(). The first case is what is done here.\r
+//\r
+// See http://lists.ximian.com/archives/public/mono-list/2001-July/000525.html\r
+//\r
+// There are also conversion functions that are not defined in\r
+// the ECMA draft, such as there is no bool ToBoolean(DateTime value), \r
+// and placing that somewhere won't compile w/ this Convert since the\r
+// function doesn't exist. However calling that when using Microsoft's\r
+// System.Convert doesn't produce any compiler errors, it just throws\r
+// an InvalidCastException at runtime.\r
+//\r
+// Whenever a decimal, double, or single is converted to an integer\r
+// based type, it is even rounded. This uses Math.Round which only \r
+// has Round(decimal) and Round(double), so in the Convert from \r
+// single cases the value is passed to Math as a double. This \r
+// may not be completely necessary.\r
+//\r
+// The .NET Framework SDK lists DBNull as a member of this class\r
+// as 'public static readonly object DBNull;'. \r
+//\r
+// It should also be decided if all the cast return values should be\r
+// returned as unchecked or not.\r
+//\r
+// All the XML function comments were auto generated which is why they\r
+// sound someone redundant.\r
+//\r
+// TYPE | BOOL BYTE CHAR DT DEC DBL I16 I32 I64 SBYT SNGL STR UI16 UI32 UI64\r
+// -----+--------------------------------------------------------------------\r
+// BOOL | X X X X X X X X X X X X X\r
+// BYTE | X X X X X X X X X X X X X X\r
+// CHAR | X X X X X X X X X X\r
+// DT | X X\r
+// DEC | X X X X X X X X X X X X X\r
+// DBL | X X X X X X X X X X X X X\r
+// I16 | X X X X X X X X X X X X X X\r
+// I32 | X X X X X X X X X X X X X X\r
+// I64 | X X X X X X X X X X X X X X\r
+// SBYT | X X X X X X X X X X X X X X\r
+// SNGL | X X X X X X X X X X X X X\r
+// STR | X X X X X X X X X X X X X X X\r
+// UI16 | X X X X X X X X X X X X X X\r
+// UI32 | X X X X X X X X X X X X X X\r
+// UI64 | X X X X X X X X X X X X X X\r
+//\r
+\r
+using System.Globalization;\r
+using System.Security.Cryptography;\r
+using System.Text;\r
+\r
+namespace System {\r
+ \r
+// [CLSCompliant(false)]\r
+ public sealed class Convert {\r
+\r
+ // Fields\r
+ public static readonly object DBNull = System.DBNull.Value;\r
+ \r
+ private Convert () {}\r
+\r
+ // ========== BASE 64 Conversions ========== //\r
+ // the BASE64 convert methods are using the Base64 converting methods\r
+ // from System.Security.Cryptography.ToBase64Transform and\r
+ // System.Security.Cryptography.FromBase64Transform\r
+ //\r
+ // should be changed to a stand-alone class Base64Encoder & Base64Decoder\r
+ \r
+ public static byte[] FromBase64CharArray(char[] inArray, int offset, int length)\r
+ {\r
+ if (inArray == null)\r
+ throw new ArgumentNullException();\r
+ \r
+ if ((offset < 0) || (length < 0) || (offset + length > inArray.Length))\r
+ throw new ArgumentOutOfRangeException();\r
+ \r
+ if (length < 4 || length % 4 != 0)\r
+ throw new FormatException();\r
+ \r
+ byte[] inArr = new System.Text.UTF8Encoding().GetBytes(inArray, offset, length);\r
+ FromBase64Transform t = new FromBase64Transform();\r
+ \r
+ return t.TransformFinalBlock(inArr, 0, inArr.Length);\r
+ }\r
+ \r
+ public static byte[] FromBase64String(string s)\r
+ {\r
+ if (s == null)\r
+ throw new ArgumentNullException();\r
+ \r
+ char[] inArr = s.ToCharArray();\r
+\r
+ return FromBase64CharArray(inArr, 0, inArr.Length);\r
+ }\r
+\r
+ public static TypeCode GetTypeCode (object value)\r
+ {\r
+ if (value == null)\r
+ return TypeCode.Empty;\r
+ else \r
+ return Type.GetTypeCode (value.GetType ());\r
+ }\r
+\r
+ public static bool IsDBNull (object value)\r
+ {\r
+ if (value is DBNull)\r
+ return true;\r
+ else\r
+ return false;\r
+ }\r
+ \r
+ public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, \r
+ char[] outArray, int offsetOut)\r
+ {\r
+ if (inArray == null || outArray == null)\r
+ throw new ArgumentNullException();\r
+ \r
+ if (offsetIn < 0 || length < 0 || offsetOut < 0 || (offsetIn + length) > inArray.Length)\r
+ throw new ArgumentOutOfRangeException();\r
+ \r
+ ToBase64Transform t = new ToBase64Transform();\r
+ byte[] outArr = t.TransformFinalBlock(inArray, offsetIn, length);\r
+ \r
+ char[] cOutArr = new System.Text.ASCIIEncoding().GetChars(outArr);\r
+ \r
+ if ((offsetOut + cOutArr.Length) > outArray.Length)\r
+ throw new ArgumentOutOfRangeException();\r
+ \r
+ Array.Copy(cOutArr, 0, outArray, offsetOut, cOutArr.Length);\r
+ \r
+ return cOutArr.Length;\r
+ }\r
+ \r
+ public static string ToBase64String(byte[] inArray)\r
+ {\r
+ if (inArray == null)\r
+ throw new ArgumentNullException();\r
+\r
+ return ToBase64String(inArray, 0, inArray.Length);\r
+ }\r
+ \r
+ public static string ToBase64String(byte[] inArray, int offset, int length)\r
+ {\r
+ if (inArray == null)\r
+ throw new ArgumentNullException();\r
+ \r
+ if (offset < 0 || length < 0 || (offset + length) > inArray.Length)\r
+ throw new ArgumentOutOfRangeException();\r
+ \r
+ // FIXME: change to stand alone Base64 Encoder class\r
+ ToBase64Transform t = new ToBase64Transform();\r
+ byte[] outArr = t.TransformFinalBlock(inArray, offset, length);\r
+ \r
+ return (new System.Text.ASCIIEncoding().GetString(outArr));\r
+ }\r
+ \r
+ // ========== Boolean Conversions ========== //\r
+ \r
+ public static bool ToBoolean (bool value) \r
+ { \r
+ return value; \r
+ }\r
+\r
+ public static bool ToBoolean (byte value) \r
+ { \r
+ return (value != 0); \r
+ }\r
+ \r
+ public static bool ToBoolean (char value)\r
+ {\r
+ throw new InvalidCastException (Locale.GetText ("Can't convert char to bool"));\r
+ }\r
+ \r
+ public static bool ToBoolean (DateTime value)\r
+ {\r
+ throw new InvalidCastException (Locale.GetText ("Can't convert date to bool"));\r
+ }\r
+ \r
+ public static bool ToBoolean (decimal value) \r
+ { \r
+ return (value != 0M); \r
+ }\r
+\r
+ public static bool ToBoolean (double value) \r
+ { \r
+ return (value != 0); \r
+ }\r
+\r
+ public static bool ToBoolean (float value) \r
+ { \r
+ return (value != 0f); \r
+ }\r
+\r
+ public static bool ToBoolean (int value) \r
+ { \r
+ return (value != 0); \r
+ }\r
+\r
+ public static bool ToBoolean (long value) \r
+ { \r
+ return (value != 0); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static bool ToBoolean (sbyte value) \r
+ { \r
+ return (value != 0); \r
+ }\r
+ \r
+ public static bool ToBoolean (short value) \r
+ { \r
+ return (value != 0); \r
+ }\r
+\r
+ public static bool ToBoolean (string value) \r
+ {\r
+ return Boolean.Parse (value);\r
+ }\r
+\r
+ public static bool ToBoolean (string value, IFormatProvider provider)\r
+ {\r
+ return Boolean.Parse (value); // provider is ignored.\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static bool ToBoolean (uint value) \r
+ { \r
+ return (value != 0);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static bool ToBoolean (ulong value) \r
+ { \r
+ return (value != 0); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static bool ToBoolean (ushort value) \r
+ { \r
+ return (value != 0); \r
+ }\r
+\r
+ public static bool ToBoolean (object value)\r
+ {\r
+ return ToBoolean (value, null);\r
+ }\r
+\r
+ public static bool ToBoolean (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return false;\r
+ return ((IConvertible) value).ToBoolean (provider);\r
+ }\r
+\r
+ // ========== Byte Conversions ========== //\r
+ \r
+ public static byte ToByte (bool value) \r
+ { \r
+ return (byte)(value ? 1 : 0); \r
+ }\r
+ \r
+ public static byte ToByte (byte value) \r
+ { \r
+ return value; \r
+ }\r
+\r
+ public static byte ToByte (char value) \r
+ { \r
+ if (value > Byte.MaxValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Byte.MaxValue"));\r
+\r
+ return (byte)value;\r
+ }\r
+\r
+ public static byte ToByte (DateTime value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+ \r
+ public static byte ToByte (decimal value)\r
+ { \r
+ if (value > Byte.MaxValue || value < Byte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Byte.MaxValue or less than Byte.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (byte)(Math.Round (value));\r
+ }\r
+ \r
+ public static byte ToByte (double value) \r
+ { \r
+ if (value > Byte.MaxValue || value < Byte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Byte.MaxValue or less than Byte.MinValue"));\r
+ \r
+ // This and the float version of ToByte are the only ones\r
+ // the spec listed as checking for .NaN and Infinity overflow\r
+ if (Double.IsNaN(value) || Double.IsInfinity(value))\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is equal to Double.NaN, Double.PositiveInfinity, or Double.NegativeInfinity"));\r
+\r
+ // Returned Even-Rounded\r
+ return (byte)(Math.Round (value));\r
+ }\r
+\r
+ public static byte ToByte (float value) \r
+ { \r
+ if (value > Byte.MaxValue || value < Byte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Byte.MaxValue or less than Byte.Minalue"));\r
+\r
+ // This and the double version of ToByte are the only ones\r
+ // the spec listed as checking for .NaN and Infinity overflow\r
+ if (Single.IsNaN(value) || Single.IsInfinity(value))\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is equal to Single.NaN, Single.PositiveInfinity, or Single.NegativeInfinity"));\r
+ \r
+ // Returned Even-Rounded, pass it as a double, could have this\r
+ // method just call Convert.ToByte ( (double)value)\r
+ return (byte)(Math.Round ( (double)value));\r
+ }\r
+\r
+ public static byte ToByte (int value) \r
+ { \r
+ if (value > Byte.MaxValue || value < Byte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Byte.MaxValue or less than Byte.MinValue"));\r
+ \r
+ return (byte)value; \r
+ }\r
+\r
+ public static byte ToByte (long value) \r
+ { \r
+ if (value > Byte.MaxValue || value < Byte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Byte.MaxValue or less than Byte.MinValue"));\r
+ \r
+ return (byte)value;\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static byte ToByte (sbyte value) \r
+ { \r
+ if (value < Byte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is less than Byte.MinValue"));\r
+ \r
+ return (byte)value;\r
+ }\r
+ \r
+ public static byte ToByte (short value) \r
+ { \r
+ if (value > Byte.MaxValue || value < Byte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Byte.MaxValue or less than Byte.MinValue"));\r
+ \r
+ return (byte)value; \r
+ }\r
+\r
+ public static byte ToByte (string value) \r
+ {\r
+ return Byte.Parse (value);\r
+ }\r
+\r
+ public static byte ToByte (string value, IFormatProvider provider) \r
+ {\r
+ return Byte.Parse (value, provider);\r
+ }\r
+\r
+ public static byte ToByte (string value, int fromBase)\r
+ {\r
+\r
+ int retVal = ConvertFromBase (value, fromBase);\r
+\r
+ if (retVal < (int) Byte.MinValue || retVal > (int) Byte.MaxValue)\r
+ throw new OverflowException ();\r
+ else\r
+ return (byte) retVal;\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static byte ToByte (uint value) \r
+ { \r
+ if (value > Byte.MaxValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Byte.MaxValue"));\r
+\r
+ return (byte)value;\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static byte ToByte (ulong value) \r
+ { \r
+ if (value > Byte.MaxValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Byte.MaxValue"));\r
+\r
+ return (byte)value;\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static byte ToByte (ushort value) \r
+ { \r
+ if (value > Byte.MaxValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Byte.MaxValue"));\r
+\r
+ return (byte)value;\r
+ }\r
+\r
+ public static byte ToByte (object value)\r
+ {\r
+ return ToByte (value, null);\r
+ }\r
+\r
+ public static byte ToByte (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return 0;\r
+ return ((IConvertible) value).ToByte (provider);\r
+ }\r
+\r
+ // ========== Char Conversions ========== //\r
+\r
+ public static char ToChar (bool value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+ \r
+ public static char ToChar (byte value) \r
+ { \r
+ return (char)value;\r
+ }\r
+\r
+ public static char ToChar (char value) \r
+ { \r
+ return value;\r
+ }\r
+\r
+ public static char ToChar (DateTime value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static char ToChar (decimal value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static char ToChar (double value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+ \r
+ public static char ToChar (int value) \r
+ { \r
+ if (value > Char.MaxValue || value < Char.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Char.MaxValue or less than Char.MinValue"));\r
+ \r
+ return (char)value; \r
+ }\r
+\r
+ public static char ToChar (long value) \r
+ { \r
+ if (value > Char.MaxValue || value < Char.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Char.MaxValue or less than Char.MinValue"));\r
+ \r
+ return (char)value; \r
+ }\r
+\r
+ public static char ToChar (float value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static char ToChar (sbyte value) \r
+ { \r
+ if (value < Char.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is less than Char.MinValue"));\r
+ \r
+ return (char)value; \r
+ }\r
+ \r
+ public static char ToChar (short value) \r
+ { \r
+ if (value < Char.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is less than Char.MinValue"));\r
+ \r
+ return (char)value; \r
+ }\r
+\r
+ public static char ToChar (string value) \r
+ {\r
+ return Char.Parse (value);\r
+ }\r
+\r
+ public static char ToChar (string value, IFormatProvider provider)\r
+ {\r
+ return Char.Parse (value); // provider is ignored.\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static char ToChar (uint value) \r
+ { \r
+ if (value > Char.MaxValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Char.MaxValue"));\r
+ \r
+ return (char)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static char ToChar (ulong value) \r
+ { \r
+ if (value > Char.MaxValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Char.MaxValue"));\r
+ \r
+ return (char)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static char ToChar (ushort value) \r
+ { \r
+ if (value > Char.MaxValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Char.MaxValue"));\r
+ \r
+ return (char)value; \r
+ }\r
+\r
+ public static char ToChar (object value)\r
+ {\r
+ return ToChar (value, null);\r
+ }\r
+\r
+ public static char ToChar (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return (char) 0;\r
+ return ((IConvertible) value).ToChar (provider);\r
+ }\r
+\r
+ // ========== DateTime Conversions ========== //\r
+ \r
+ public static DateTime ToDateTime (string value) \r
+ { \r
+ return DateTime.Parse (value);\r
+ }\r
+ \r
+ public static DateTime ToDateTime (string value, IFormatProvider provider) \r
+ {\r
+ return DateTime.Parse (value, provider);\r
+ }\r
+\r
+ public static DateTime ToDateTime (bool value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static DateTime ToDateTime (byte value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static DateTime ToDateTime (char value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static DateTime ToDateTime (DateTime value)\r
+ {\r
+ return value;\r
+ }\r
+\r
+ public static DateTime ToDateTime (decimal value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static DateTime ToDateTime (double value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static DateTime ToDateTime (short value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static DateTime ToDateTime (int value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static DateTime ToDateTime (long value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static DateTime ToDateTime (float value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static DateTime ToDateTime (object value)\r
+ {\r
+ return ToDateTime (value, null);\r
+ }\r
+\r
+ public static DateTime ToDateTime (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return DateTime.MinValue;\r
+ return ((IConvertible) value).ToDateTime (provider);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static DateTime ToDateTime (sbyte value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+ [CLSCompliant (false)]\r
+ public static DateTime ToDateTime (ushort value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static DateTime ToDateTime (uint value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static DateTime ToDateTime (ulong value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ // ========== Decimal Conversions ========== //\r
+ \r
+ public static decimal ToDecimal (bool value) \r
+ { \r
+ return value ? 1 : 0; \r
+ }\r
+ \r
+ public static decimal ToDecimal (byte value) \r
+ { \r
+ return (decimal)value; \r
+ }\r
+\r
+ public static decimal ToDecimal (char value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static decimal ToDecimal (DateTime value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+ \r
+ public static decimal ToDecimal (decimal value) \r
+ { \r
+ return value; \r
+ }\r
+\r
+ public static decimal ToDecimal (double value) \r
+ { \r
+ if (value > (double)Decimal.MaxValue || value < (double)Decimal.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Decimal.MaxValue or less than Decimal.MinValue"));\r
+\r
+ return (decimal)value; \r
+ }\r
+\r
+ public static decimal ToDecimal (float value) \r
+ {\r
+ return (decimal) value;\r
+ }\r
+\r
+ public static decimal ToDecimal (int value) \r
+ { \r
+ return (decimal)value; \r
+ }\r
+ \r
+ public static decimal ToDecimal (long value) \r
+ { \r
+ return (decimal)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static decimal ToDecimal (sbyte value) \r
+ { \r
+ return (decimal)value; \r
+ }\r
+ \r
+ public static decimal ToDecimal (short value) \r
+ { \r
+ return (decimal)value; \r
+ }\r
+\r
+ public static decimal ToDecimal (string value) \r
+ {\r
+ return Decimal.Parse (value);\r
+ }\r
+\r
+ public static decimal ToDecimal (string value, IFormatProvider provider) \r
+ {\r
+ return Decimal.Parse (value, provider);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static decimal ToDecimal (uint value) \r
+ { \r
+ return (decimal)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static decimal ToDecimal (ulong value) \r
+ { \r
+ return (decimal)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static decimal ToDecimal (ushort value) \r
+ { \r
+ return (decimal)value; \r
+ }\r
+\r
+ public static decimal ToDecimal (object value)\r
+ {\r
+ return ToDecimal (value, null);\r
+ }\r
+\r
+ public static decimal ToDecimal (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return new Decimal (0);\r
+ return ((IConvertible) value).ToDecimal (provider);\r
+ }\r
+ \r
+\r
+ // ========== Double Conversions ========== //\r
+ \r
+ public static double ToDouble (bool value) \r
+ { \r
+ return value ? 1 : 0; \r
+ }\r
+ \r
+ public static double ToDouble (byte value) \r
+ { \r
+ return (double) value;\r
+ }\r
+\r
+ public static double ToDouble (char value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static double ToDouble (DateTime value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+ \r
+ public static double ToDouble (decimal value) \r
+ { \r
+ return (double)value; \r
+ }\r
+\r
+ public static double ToDouble (double value) \r
+ { \r
+ return value; \r
+ }\r
+\r
+ public static double ToDouble (float value) \r
+ { \r
+ return (double) value;\r
+ }\r
+\r
+ public static double ToDouble (int value) \r
+ { \r
+ return (double)value; \r
+ }\r
+ \r
+ public static double ToDouble (long value) \r
+ { \r
+ return (double)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static double ToDouble (sbyte value) \r
+ { \r
+ return (double)value; \r
+ }\r
+ \r
+ public static double ToDouble (short value) \r
+ { \r
+ return (double)value; \r
+ }\r
+\r
+ public static double ToDouble (string value) \r
+ {\r
+ return Double.Parse (value);\r
+ }\r
+\r
+ public static double ToDouble (string value, IFormatProvider provider) \r
+ {\r
+ return Double.Parse (value, provider);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static double ToDouble (uint value) \r
+ { \r
+ return (double)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static double ToDouble (ulong value) \r
+ { \r
+ return (double)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static double ToDouble (ushort value) \r
+ { \r
+ return (double)value; \r
+ }\r
+\r
+ public static double ToDouble (object value)\r
+ {\r
+ return ToDouble (value, null);\r
+ }\r
+\r
+ public static double ToDouble (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return 0.0;\r
+ return ((IConvertible) value).ToDouble (provider);\r
+ }\r
+\r
+ // ========== Int16 Conversions ========== //\r
+\r
+ public static short ToInt16 (bool value) \r
+ { \r
+ return (short)(value ? 1 : 0); \r
+ }\r
+ \r
+ public static short ToInt16 (byte value) \r
+ { \r
+ return (short)value; \r
+ }\r
+\r
+ public static short ToInt16 (char value) \r
+ {\r
+ if (value > Int16.MaxValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int16.MaxValue"));\r
+\r
+ return (short)value;\r
+ }\r
+\r
+ public static short ToInt16 (DateTime value) \r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+ \r
+ public static short ToInt16 (decimal value) \r
+ { \r
+ if (value > Int16.MaxValue || value < Int16.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int16.MaxValue or less than Int16.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (short)(Math.Round (value)); \r
+ }\r
+\r
+ public static short ToInt16 (double value) \r
+ { \r
+ if (value > Int16.MaxValue || value < Int16.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int16.MaxValue or less than Int16.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (short)(Math.Round (value)); \r
+ }\r
+ \r
+ public static short ToInt16 (float value) \r
+ { \r
+ if (value > Int16.MaxValue || value < Int16.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int16.MaxValue or less than Int16.MinValue"));\r
+ \r
+ // Returned Even-Rounded, use Math.Round pass as a double.\r
+ return (short)Math.Round ( (double)value);\r
+ }\r
+\r
+ public static short ToInt16 (int value) \r
+ { \r
+ if (value > Int16.MaxValue || value < Int16.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int16.MaxValue or less than Int16.MinValue"));\r
+\r
+ return (short)value; \r
+ }\r
+ \r
+ public static short ToInt16 (long value) \r
+ { \r
+ if (value > Int16.MaxValue || value < Int16.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int16.MaxValue or less than Int16.MinValue"));\r
+\r
+ return (short)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static short ToInt16 (sbyte value) \r
+ { \r
+ return (short)value; \r
+ }\r
+ \r
+ public static short ToInt16 (short value) \r
+ { \r
+ return value; \r
+ }\r
+\r
+ public static short ToInt16 (string value) \r
+ {\r
+ return Int16.Parse (value);\r
+ }\r
+\r
+ public static short ToInt16 (string value, IFormatProvider provider) \r
+ {\r
+ return Int16.Parse (value, provider);\r
+ }\r
+\r
+ \r
+ public static short ToInt16 (string value, int fromBase)\r
+ {\r
+ return Convert.ToInt16 (ConvertFromBase (value, fromBase));\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static short ToInt16 (uint value) \r
+ { \r
+ if (value > Int16.MaxValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int16.MaxValue"));\r
+\r
+ return (short)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static short ToInt16 (ulong value) \r
+ { \r
+ if (value > (ulong)Int16.MaxValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int16.MaxValue"));\r
+ return (short)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static short ToInt16 (ushort value) \r
+ { \r
+ if (value > Int16.MaxValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int16.MaxValue"));\r
+\r
+ return (short)value; \r
+ }\r
+\r
+ public static short ToInt16 (object value)\r
+ {\r
+ return ToInt16 (value, null);\r
+ }\r
+\r
+ public static short ToInt16 (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return 0;\r
+ return ((IConvertible) value).ToInt16 (provider);\r
+ }\r
+ \r
+ // ========== Int32 Conversions ========== //\r
+\r
+ public static int ToInt32 (bool value) \r
+ { \r
+ return value ? 1 : 0; \r
+ }\r
+ \r
+ public static int ToInt32 (byte value) \r
+ { \r
+ return (int)value; \r
+ }\r
+\r
+ public static int ToInt32 (char value) \r
+ { \r
+ return (int)value; \r
+ }\r
+\r
+ public static int ToInt32 (DateTime value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+ \r
+ public static int ToInt32 (decimal value) \r
+ { \r
+ if (value > Int32.MaxValue || value < Int32.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int32.MaxValue or less than Int32.MinValue"));\r
+\r
+ // Returned Even-Rounded\r
+ return (int)(Math.Round (value)); \r
+ }\r
+\r
+ public static int ToInt32 (double value) \r
+ { \r
+ if (value > Int32.MaxValue || value < Int32.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int32.MaxValue or less than Int32.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (int)(Math.Round (value)); \r
+ }\r
+ \r
+ public static int ToInt32 (float value) \r
+ { \r
+ if (value > Int32.MaxValue || value < Int32.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int32.MaxValue or less than Int32.MinValue"));\r
+ \r
+ // Returned Even-Rounded, pass as a double, could just call\r
+ // Convert.ToInt32 ( (double)value);\r
+ return (int)(Math.Round ( (double)value));\r
+ }\r
+\r
+ public static int ToInt32 (int value) \r
+ { \r
+ return value; \r
+ }\r
+ \r
+ public static int ToInt32 (long value) \r
+ { \r
+ if (value > Int32.MaxValue || value < Int32.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int32.MaxValue or less than Int32.MinValue"));\r
+\r
+ return (int)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static int ToInt32 (sbyte value) \r
+ { \r
+ return (int)value; \r
+ }\r
+ \r
+ public static int ToInt32 (short value) \r
+ { \r
+ return (int)value; \r
+ }\r
+\r
+ public static int ToInt32 (string value) \r
+ {\r
+ return Int32.Parse (value);\r
+ }\r
+\r
+ public static int ToInt32 (string value, IFormatProvider provider) \r
+ {\r
+ return Int32.Parse (value, provider);\r
+ }\r
+\r
+ \r
+ public static int ToInt32 (string value, int fromBase)\r
+ {\r
+ return ConvertFromBase (value, fromBase);\r
+ }\r
+ \r
+ [CLSCompliant (false)]\r
+ public static int ToInt32 (uint value) \r
+ { \r
+ if (value > Int32.MaxValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int32.MaxValue"));\r
+\r
+ return (int)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static int ToInt32 (ulong value) \r
+ { \r
+ if (value > Int32.MaxValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int32.MaxValue"));\r
+\r
+ return (int)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static int ToInt32 (ushort value) \r
+ { \r
+ return (int)value; \r
+ }\r
+\r
+ public static int ToInt32 (object value)\r
+ {\r
+ return ToInt32 (value, null);\r
+ }\r
+\r
+ public static int ToInt32 (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return 0;\r
+ return ((IConvertible) value).ToInt32 (provider);\r
+ }\r
+\r
+ // ========== Int64 Conversions ========== //\r
+\r
+ public static long ToInt64 (bool value) \r
+ { \r
+ return value ? 1 : 0; \r
+ }\r
+ \r
+ public static long ToInt64 (byte value) \r
+ { \r
+ return (long)(ulong)value; \r
+ }\r
+\r
+ public static long ToInt64 (char value) \r
+ { \r
+ return (long)value; \r
+ }\r
+\r
+ public static long ToInt64 (DateTime value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+ \r
+ public static long ToInt64 (decimal value) \r
+ { \r
+ if (value > Int64.MaxValue || value < Int64.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int64.MaxValue or less than Int64.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (long)(Math.Round (value)); \r
+ }\r
+\r
+ public static long ToInt64 (double value) \r
+ { \r
+ if (value > Int64.MaxValue || value < Int64.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int64.MaxValue or less than Int64.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (long)(Math.Round (value));\r
+ }\r
+ \r
+ public static long ToInt64 (float value) \r
+ { \r
+ if (value > Int64.MaxValue || value < Int64.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int64.MaxValue or less than Int64.MinValue"));\r
+ \r
+ // Returned Even-Rounded, pass to Math as a double, could\r
+ // just call Convert.ToInt64 ( (double)value);\r
+ return (long)(Math.Round ( (double)value));\r
+ }\r
+\r
+ public static long ToInt64 (int value) \r
+ { \r
+ return (long)value; \r
+ }\r
+ \r
+ public static long ToInt64 (long value) \r
+ { \r
+ return value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static long ToInt64 (sbyte value) \r
+ { \r
+ return (long)value; \r
+ }\r
+ \r
+ public static long ToInt64 (short value) \r
+ { \r
+ return (long)value; \r
+ }\r
+\r
+ public static long ToInt64 (string value) \r
+ {\r
+ return Int64.Parse (value);\r
+ }\r
+\r
+ public static long ToInt64 (string value, IFormatProvider provider) \r
+ {\r
+ return Int64.Parse (value, provider);\r
+ }\r
+\r
+ public static long ToInt64 (string value, int fromBase)\r
+ {\r
+ if (NotValidBase (fromBase))\r
+ throw new ArgumentException ("fromBase is not valid.");\r
+ \r
+ return ConvertFromBase64 (value, fromBase);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static long ToInt64 (uint value) \r
+ { \r
+ return (long)(ulong)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static long ToInt64 (ulong value) \r
+ { \r
+ if (value > Int64.MaxValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Int64.MaxValue"));\r
+\r
+ return (long)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static long ToInt64 (ushort value) \r
+ { \r
+ return (long)(ulong)value; \r
+ }\r
+\r
+ public static long ToInt64 (object value)\r
+ {\r
+ return ToInt64 (value, null);\r
+ }\r
+\r
+ public static long ToInt64 (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return 0;\r
+ return ((IConvertible) value).ToInt64 (provider);\r
+ }\r
+ \r
+ // ========== SByte Conversions ========== //\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (bool value) \r
+ { \r
+ return (sbyte)(value ? 1 : 0); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (byte value) \r
+ { \r
+ if (value > SByte.MaxValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than SByte.MaxValue"));\r
+\r
+ return (sbyte)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (char value) \r
+ { \r
+ if (value > SByte.MaxValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than SByte.MaxValue"));\r
+\r
+ return (sbyte)value;\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (DateTime value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+ \r
+ [CLSCompliant (false)] \r
+ public static sbyte ToSByte (decimal value) \r
+ { \r
+ if (value > SByte.MaxValue || value < SByte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than SByte.MaxValue or less than SByte.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (sbyte)(Math.Round (value));\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (double value) \r
+ { \r
+ if (value > SByte.MaxValue || value < SByte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than SByte.MaxValue or less than SByte.MinValue"));\r
+\r
+ // Returned Even-Rounded\r
+ return (sbyte)(Math.Round (value));\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (float value) \r
+ { \r
+ if (value > SByte.MaxValue || value < SByte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than SByte.MaxValue or less than SByte.Minalue"));\r
+\r
+ // Returned Even-Rounded, pass as double to Math\r
+ return (sbyte)(Math.Round ( (double)value));\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (int value) \r
+ { \r
+ if (value > SByte.MaxValue || value < SByte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than SByte.MaxValue or less than SByte.MinValue"));\r
+ \r
+ return (sbyte)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (long value) \r
+ { \r
+ if (value > SByte.MaxValue || value < SByte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than SByte.MaxValue or less than SByte.MinValue"));\r
+ \r
+ return (sbyte)value;\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (sbyte value) \r
+ { \r
+ return value;\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (short value) \r
+ { \r
+ if (value > SByte.MaxValue || value < SByte.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than SByte.MaxValue or less than SByte.MinValue"));\r
+ \r
+ return (sbyte)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (string value) \r
+ {\r
+ return SByte.Parse (value);\r
+ }\r
+ \r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (string value, IFormatProvider provider) \r
+ {\r
+ return SByte.Parse (value, provider);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (string value, int fromBase)\r
+ {\r
+ int retVal = ConvertFromBase (value, fromBase);\r
+\r
+ if (retVal == 255)\r
+ return (sbyte)-1;\r
+\r
+ if (retVal < (int) SByte.MinValue || retVal > (int) SByte.MaxValue)\r
+ throw new OverflowException ();\r
+ else\r
+ return (sbyte) retVal;\r
+ }\r
+ \r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (uint value) \r
+ { \r
+ if (value > SByte.MaxValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than SByte.MaxValue"));\r
+\r
+ return (sbyte)value;\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (ulong value) \r
+ { \r
+ if (value > (ulong)SByte.MaxValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than SByte.MaxValue"));\r
+\r
+ return (sbyte)value;\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (ushort value) \r
+ { \r
+ if (value > SByte.MaxValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than SByte.MaxValue"));\r
+\r
+ return (sbyte)value;\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (object value)\r
+ {\r
+ return ToSByte (value, null);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static sbyte ToSByte (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return 0;\r
+ return ((IConvertible) value).ToSByte (provider);\r
+ }\r
+\r
+ // ========== Single Conversions ========== //\r
+ \r
+ public static float ToSingle (bool value) \r
+ { \r
+ return value ? 1 : 0; \r
+ }\r
+ \r
+ public static float ToSingle (byte value) \r
+ { \r
+ return (float)value; \r
+ }\r
+\r
+ public static float ToSingle (Char value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ public static float ToSingle (DateTime value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+ \r
+ public static float ToSingle (decimal value) \r
+ { \r
+ return (float)value; \r
+ }\r
+\r
+ public static float ToSingle (double value) \r
+ { \r
+ if (value > Single.MaxValue || value < Single.MinValue)\r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than Single.MaxValue or less than Single.MinValue"));\r
+\r
+ return (float)value; \r
+ }\r
+ \r
+ public static float ToSingle (float value) \r
+ { \r
+ return value; \r
+ }\r
+\r
+ public static float ToSingle (int value) \r
+ { \r
+ return (float)value; \r
+ }\r
+ \r
+ public static float ToSingle (long value) \r
+ { \r
+ return (float)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static float ToSingle (sbyte value) \r
+ { \r
+ return (float)value; \r
+ }\r
+ \r
+ public static float ToSingle (short value) \r
+ { \r
+ return (float)value; \r
+ }\r
+\r
+ public static float ToSingle (string value) \r
+ {\r
+ return Single.Parse (value);\r
+ }\r
+\r
+ public static float ToSingle (string value, IFormatProvider provider) \r
+ {\r
+ return Single.Parse (value, provider);\r
+ } \r
+\r
+ [CLSCompliant (false)]\r
+ public static float ToSingle (uint value) \r
+ { \r
+ return (float)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static float ToSingle (ulong value) \r
+ { \r
+ return (float)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static float ToSingle (ushort value) \r
+ { \r
+ return (float)value; \r
+ }\r
+\r
+ public static float ToSingle (object value)\r
+ {\r
+ return ToSingle (value, null);\r
+ }\r
+\r
+// [CLSCompliant (false)]\r
+ public static float ToSingle (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return 0;\r
+ return ((IConvertible) value).ToSingle (provider);\r
+ }\r
+\r
+ // ========== String Conversions ========== //\r
+ \r
+ public static string ToString (bool value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+\r
+ public static string ToString (bool value, IFormatProvider provider)\r
+ {\r
+ return value.ToString (); // the same as ToString (bool).\r
+ }\r
+ \r
+ public static string ToString (byte value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+ \r
+ public static string ToString (byte value, IFormatProvider provider) \r
+ {\r
+ return value.ToString (provider); \r
+ }\r
+\r
+ public static string ToString (byte value, int toBase)\r
+ {\r
+ if (NotValidBase (toBase))\r
+ throw new ArgumentException ("toBase is not valid.");\r
+ \r
+ return ConvertToBase ((int) value, toBase);\r
+ }\r
+\r
+ public static string ToString (char value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+\r
+ public static string ToString (char value, IFormatProvider provider)\r
+ {\r
+ return value.ToString (); // the same as ToString (char)\r
+ }\r
+\r
+ public static string ToString (DateTime value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+\r
+ public static string ToString (DateTime value, IFormatProvider provider) \r
+ { \r
+ return value.ToString (provider); \r
+ }\r
+\r
+ public static string ToString (decimal value) \r
+ {\r
+ return value.ToString ();\r
+ }\r
+\r
+ public static string ToString (decimal value, IFormatProvider provider) \r
+ { \r
+ return value.ToString (provider); \r
+ }\r
+ \r
+ public static string ToString (double value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+\r
+ public static string ToString (double value, IFormatProvider provider) \r
+ { \r
+ return value.ToString (provider);\r
+ }\r
+ \r
+ public static string ToString (float value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+\r
+ public static string ToString (float value, IFormatProvider provider) \r
+ { \r
+ return value.ToString (provider); \r
+ }\r
+\r
+ public static string ToString (int value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+\r
+ public static string ToString (int value, int toBase)\r
+ {\r
+ if (NotValidBase (toBase))\r
+ throw new ArgumentException ("toBase is not valid.");\r
+ \r
+ return ConvertToBase ((int) value, toBase);\r
+ }\r
+\r
+ public static string ToString (int value, IFormatProvider provider) \r
+ { \r
+ return value.ToString (provider); \r
+ }\r
+ \r
+ public static string ToString (long value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+\r
+ public static string ToString (long value, int toBase)\r
+ {\r
+ if (NotValidBase (toBase))\r
+ throw new ArgumentException ("toBase is not valid.");\r
+ \r
+ return ConvertToBase (value, toBase);\r
+ }\r
+\r
+ public static string ToString (long value, IFormatProvider provider) \r
+ { \r
+ return value.ToString (provider); \r
+ }\r
+\r
+ public static string ToString (object value)\r
+ {\r
+ return ToString (value, null);\r
+ } \r
+\r
+ public static string ToString (object value, IFormatProvider provider)\r
+ {\r
+ if (value is IConvertible)\r
+ return ((IConvertible) value).ToString (provider);\r
+ else if (value != null)\r
+ return value.ToString ();\r
+ return String.Empty;\r
+ } \r
+\r
+ [CLSCompliant (false)]\r
+ public static string ToString (sbyte value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+\r
+ [CLSCompliant (false)] \r
+ public static string ToString (sbyte value, IFormatProvider provider) \r
+ { \r
+ return value.ToString (provider); \r
+ }\r
+ \r
+ public static string ToString (short value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+\r
+ public static string ToString (short value, int toBase)\r
+ {\r
+ if (NotValidBase (toBase))\r
+ throw new ArgumentException ("toBase is not valid.");\r
+ \r
+ return ConvertToBase ((int) value, toBase);\r
+ }\r
+\r
+ public static string ToString (short value, IFormatProvider provider) \r
+ { \r
+ return value.ToString (provider); \r
+ }\r
+\r
+ public static string ToString (string value) \r
+ {\r
+ return value;\r
+ }\r
+\r
+ public static string ToString (string value, IFormatProvider provider)\r
+ {\r
+ return value; // provider is ignored.\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static string ToString (uint value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static string ToString (uint value, IFormatProvider provider) \r
+ { \r
+ return value.ToString (provider); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static string ToString (ulong value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static string ToString (ulong value, IFormatProvider provider) \r
+ { \r
+ return value.ToString (provider); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static string ToString (ushort value) \r
+ { \r
+ return value.ToString (); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static string ToString (ushort value, IFormatProvider provider) \r
+ { \r
+ return value.ToString (provider); \r
+ }\r
+ \r
+ // ========== UInt16 Conversions ========== //\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (bool value) \r
+ { \r
+ return (ushort)(value ? 1 : 0); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (byte value) \r
+ { \r
+ return (ushort)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (char value) \r
+ { \r
+ return (ushort)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (DateTime value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (decimal value) \r
+ { \r
+ if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt16.MaxValue or less than UInt16.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (ushort)(Math.Round (value)); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (double value) \r
+ { \r
+ if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt16.MaxValue or less than UInt16.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (ushort)(Math.Round (value));\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (float value) \r
+ { \r
+ if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt16.MaxValue or less than UInt16.MinValue"));\r
+ \r
+ // Returned Even-Rounded, pass as double to Math\r
+ return (ushort)(Math.Round ( (double)value));\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (int value) \r
+ { \r
+ if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt16.MaxValue or less than UInt16.MinValue"));\r
+\r
+ return (ushort)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (long value) \r
+ { \r
+ if (value > UInt16.MaxValue || value < UInt16.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt16.MaxValue or less than UInt16.MinValue"));\r
+\r
+ return (ushort)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (sbyte value) \r
+ { \r
+ if (value < UInt16.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is less than UInt16.MinValue"));\r
+\r
+ return (ushort)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (short value) \r
+ { \r
+ if (value < UInt16.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is less than UInt16.MinValue"));\r
+\r
+ return (ushort)value; \r
+ }\r
+ \r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (string value) \r
+ {\r
+ return UInt16.Parse (value);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (string value, IFormatProvider provider) \r
+ {\r
+ return UInt16.Parse (value, provider);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (string value, int fromBase) \r
+ {\r
+ return (ushort) ConvertFromBase (value, fromBase);\r
+ } \r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (uint value) \r
+ { \r
+ if (value > UInt16.MaxValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt16.MaxValue"));\r
+\r
+ return (ushort)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (ulong value) \r
+ { \r
+ if (value > (ulong)UInt16.MaxValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt16.MaxValue"));\r
+\r
+ return (ushort)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (ushort value) \r
+ { \r
+ return value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (object value)\r
+ {\r
+ return ToUInt16 (value, null);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ushort ToUInt16 (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return 0;\r
+ return ((IConvertible) value).ToUInt16 (provider);\r
+ }\r
+\r
+ // ========== UInt32 Conversions ========== //\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (bool value) \r
+ { \r
+ return (uint)(value ? 1 : 0); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (byte value) \r
+ { \r
+ return (uint)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (char value) \r
+ { \r
+ return (uint)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (DateTime value)\r
+ {\r
+ throw new InvalidCastException ("This conversion is not supported.");\r
+ }\r
+ \r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (decimal value) \r
+ { \r
+ if (value > UInt32.MaxValue || value < UInt32.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt32.MaxValue or less than UInt32.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (uint)(Math.Round (value)); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (double value) \r
+ { \r
+ if (value > UInt32.MaxValue || value < UInt32.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt32.MaxValue or less than UInt32.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (uint)(Math.Round (value)); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (float value) \r
+ { \r
+ if (value > UInt32.MaxValue || value < UInt32.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt32.MaxValue or less than UInt32.MinValue"));\r
+ \r
+ // Returned Even-Rounded, pass as double to Math\r
+ return (uint)(Math.Round ( (double)value));\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (int value) \r
+ { \r
+ if (value < UInt32.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is less than UInt32.MinValue"));\r
+\r
+ return (uint)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (long value) \r
+ { \r
+ if (value > UInt32.MaxValue || value < UInt32.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt32.MaxValue or less than UInt32.MinValue"));\r
+\r
+ return (uint)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (sbyte value) \r
+ { \r
+ if (value < UInt32.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is less than UInt32.MinValue"));\r
+\r
+ return (uint)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (short value) \r
+ { \r
+ if (value < UInt32.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is less than UInt32.MinValue"));\r
+\r
+ return (uint)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (string value) \r
+ {\r
+ return UInt32.Parse (value);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (string value, IFormatProvider provider) \r
+ {\r
+ return UInt32.Parse (value, provider);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (string value, int fromBase)\r
+ {\r
+ return (uint) ConvertFromBase (value, fromBase);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (uint value) \r
+ { \r
+ return value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (ulong value) \r
+ { \r
+ if (value > UInt32.MaxValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt32.MaxValue"));\r
+\r
+ return (uint)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (ushort value) \r
+ { \r
+ return (uint)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (object value)\r
+ {\r
+ return ToUInt32 (value, null);\r
+ } \r
+\r
+ [CLSCompliant (false)]\r
+ public static uint ToUInt32 (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return 0;\r
+ return ((IConvertible) value).ToUInt32 (provider);\r
+ } \r
+ \r
+\r
+ // ========== UInt64 Conversions ========== //\r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (bool value) \r
+ { \r
+ return (ulong)(value ? 1 : 0); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (byte value) \r
+ { \r
+ return (ulong)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (char value) \r
+ { \r
+ return (ulong)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (DateTime value)\r
+ {\r
+ throw new InvalidCastException ("The conversion is not supported.");\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (decimal value) \r
+ { \r
+ if (value > UInt64.MaxValue || value < UInt64.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt64.MaxValue or less than UInt64.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (ulong)(Math.Round (value)); \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (double value) \r
+ { \r
+ if (value > UInt64.MaxValue || value < UInt64.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt64.MaxValue or less than UInt64.MinValue"));\r
+ \r
+ // Returned Even-Rounded\r
+ return (ulong)(Math.Round (value)); \r
+ }\r
+ \r
+ [CLSCompliant (false)] \r
+ public static ulong ToUInt64 (float value) \r
+ { \r
+ if (value > UInt64.MaxValue || value < UInt64.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is greater than UInt64.MaxValue or less than UInt64.MinValue"));\r
+ \r
+ // Returned Even-Rounded, pass as a double to Math\r
+ return (ulong)(Math.Round ( (double)value));\r
+ }\r
+ \r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (int value) \r
+ { \r
+ if (value < (int)UInt64.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is less than UInt64.MinValue"));\r
+\r
+ return (ulong)value; \r
+ }\r
+ \r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (long value) \r
+ { \r
+ if (value < (long)UInt64.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is less than UInt64.MinValue"));\r
+\r
+ return (ulong)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (sbyte value) \r
+ { \r
+ if (value < (sbyte)UInt64.MinValue) \r
+ throw new OverflowException\r
+ ("Value is less than UInt64.MinValue");\r
+\r
+ return (ulong)value; \r
+ }\r
+ \r
+ [CLSCompliant (false)] \r
+ public static ulong ToUInt64 (short value) \r
+ { \r
+ if (value < (short)UInt64.MinValue) \r
+ throw new OverflowException (Locale.GetText (\r
+ "Value is less than UInt64.MinValue"));\r
+\r
+ return (ulong)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (string value) \r
+ {\r
+ return UInt64.Parse (value);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (string value, IFormatProvider provider) \r
+ {\r
+ return UInt64.Parse (value, provider);\r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (string value, int fromBase)\r
+ {\r
+ return (ulong) ConvertFromBase (value, fromBase);\r
+ } \r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (uint value) \r
+ { \r
+ return (ulong)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (ulong value) \r
+ { \r
+ return value; \r
+ }\r
+ \r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (ushort value) \r
+ { \r
+ return (ulong)value; \r
+ }\r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (object value)\r
+ {\r
+ return ToUInt64 (value, null);\r
+ } \r
+\r
+ [CLSCompliant (false)]\r
+ public static ulong ToUInt64 (object value, IFormatProvider provider)\r
+ {\r
+ if (value == null)\r
+ return 0;\r
+ return ((IConvertible) value).ToUInt64 (provider);\r
+ } \r
+ \r
+\r
+ // ========== Conversion / Helper Functions ========== //\r
+\r
+ public static object ChangeType (object value, Type conversionType)\r
+ {\r
+ CultureInfo ci = CultureInfo.CurrentCulture;\r
+ NumberFormatInfo number = ci.NumberFormat;\r
+ return ToType (value, conversionType, number);\r
+ }\r
+ \r
+ public static object ChangeType (object value, TypeCode typeCode)\r
+ {\r
+ CultureInfo ci = CultureInfo.CurrentCulture;\r
+ Type conversionType = conversionTable [(int)typeCode];\r
+ NumberFormatInfo number = ci.NumberFormat;\r
+ return ToType (value, conversionType, number);\r
+ }\r
+\r
+ public static object ChangeType (object value, Type conversionType, IFormatProvider provider)\r
+ {\r
+ return ToType (value, conversionType, provider);\r
+ }\r
+ \r
+ public static object ChangeType (object value, TypeCode typeCode, IFormatProvider provider)\r
+ {\r
+ Type conversionType = conversionTable [(int)typeCode];\r
+ return ToType (value, conversionType, provider);\r
+ }\r
+\r
+ private static bool NotValidBase (int value)\r
+ {\r
+ if ((value == 2) || (value == 8) ||\r
+ (value == 10) || (value == 16))\r
+ return false;\r
+ \r
+ return true;\r
+ }\r
+\r
+ private static int ConvertFromBase (string value, int fromBase)\r
+ {\r
+ if (NotValidBase (fromBase))\r
+ throw new ArgumentException ("fromBase is not valid.");\r
+\r
+ int chars = 0;\r
+ int result = 0;\r
+ int digitValue;\r
+\r
+ foreach (char c in value) {\r
+ if (Char.IsNumber (c))\r
+ digitValue = c - '0';\r
+ else if (Char.IsLetter (c))\r
+ digitValue = Char.ToLower(c) - 'a' + 10;\r
+ else\r
+ throw new FormatException ("This is an invalid string: " + value);\r
+\r
+ if (digitValue >= fromBase)\r
+ throw new FormatException ("the digits are invalid.");\r
+\r
+ result = (fromBase) * result + digitValue;\r
+ chars ++;\r
+ }\r
+\r
+ if (chars == 0)\r
+ throw new FormatException ("Could not find any digits.");\r
+\r
+ if (result > Int32.MaxValue || result < Int32.MinValue)\r
+ throw new OverflowException ("There is an overflow.");\r
+ \r
+ return result;\r
+ }\r
+\r
+ private static long ConvertFromBase64 (string value, int fromBase)\r
+ {\r
+ if (NotValidBase (fromBase))\r
+ throw new ArgumentException ("fromBase is not valid.");\r
+\r
+ int chars = 0;\r
+ int digitValue;\r
+ long result = 0;\r
+\r
+ foreach (char c in value) {\r
+ if (Char.IsNumber (c))\r
+ digitValue = c - '0';\r
+ else if (Char.IsLetter (c))\r
+ digitValue = Char.ToLower(c) - 'a' + 10;\r
+ else\r
+ throw new FormatException ("This is an invalid string: " + value);\r
+\r
+ if (digitValue >= fromBase)\r
+ throw new FormatException ("the digits are invalid.");\r
+\r
+ result = (fromBase) * result + digitValue;\r
+ chars ++;\r
+ }\r
+\r
+ if (chars == 0)\r
+ throw new FormatException ("Could not find any digits.");\r
+\r
+ if (result > Int64.MaxValue || result < Int64.MinValue)\r
+ throw new OverflowException ("There is an overflow.");\r
+ \r
+ return result;\r
+ }\r
+\r
+ private static string ConvertToBase (int value, int toBase)\r
+ {\r
+ StringBuilder sb = new StringBuilder ();\r
+ BuildConvertedString (sb, value, toBase);\r
+ return sb.ToString ();\r
+ }\r
+\r
+ private static string ConvertToBase (long value, int toBase)\r
+ {\r
+ StringBuilder sb = new StringBuilder ();\r
+ BuildConvertedString64 (sb, value, toBase);\r
+ return sb.ToString ();\r
+ }\r
+ \r
+\r
+ internal static void BuildConvertedString (StringBuilder sb, int value, int toBase)\r
+ {\r
+ int divided = value / toBase;\r
+ int reminder = value % toBase; \r
+\r
+ if (divided > 0)\r
+ BuildConvertedString (sb, divided, toBase);\r
+ \r
+ if (reminder >= 10)\r
+ sb.Append ((char) (reminder + 'a' - 10));\r
+ else\r
+ sb.Append ((char) (reminder + '0'));\r
+ }\r
+\r
+ internal static void BuildConvertedString64 (StringBuilder sb, long value, int toBase)\r
+ {\r
+ long divided = value / toBase;\r
+ long reminder = value % toBase; \r
+\r
+ if (divided > 0)\r
+ BuildConvertedString64 (sb, divided, toBase);\r
+ \r
+ if (reminder >= 10)\r
+ sb.Append ((char) (reminder + 'a' - 10));\r
+ else\r
+ sb.Append ((char) (reminder + '0'));\r
+ }\r
+ \r
+ // Lookup table for the conversion ToType method. Order\r
+ // is important! Used by ToType for comparing the target\r
+ // type, and uses hardcoded array indexes.\r
+ private static Type[] conversionTable = {\r
+ // Valid ICovnertible Types\r
+ null, // 0 empty\r
+ typeof (object), // 1 TypeCode.Object\r
+ typeof (DBNull), // 2 TypeCode.DBNull\r
+ typeof (Boolean), // 3 TypeCode.Boolean\r
+ typeof (Char), // 4 TypeCode.Char\r
+ typeof (SByte), // 5 TypeCode.SByte\r
+ typeof (Byte), // 6 TypeCode.Byte\r
+ typeof (Int16), // 7 TypeCode.Int16\r
+ typeof (UInt16), // 8 TypeCode.UInt16\r
+ typeof (Int32), // 9 TypeCode.Int32\r
+ typeof (UInt32), // 10 TypeCode.UInt32\r
+ typeof (Int64), // 11 TypeCode.Int64\r
+ typeof (UInt64), // 12 TypeCode.UInt64\r
+ typeof (Single), // 13 TypeCode.Single\r
+ typeof (Double), // 14 TypeCode.Double\r
+ typeof (Decimal), // 15 TypeCode.Decimal\r
+ typeof (DateTime), // 16 TypeCode.DateTime\r
+ null, // 17 null.\r
+ typeof (String), // 18 TypeCode.String\r
+ };\r
+\r
+ // Function to convert an object to another type and return\r
+ // it as an object. In place for the core data types to use\r
+ // when implementing IConvertible. Uses hardcoded indexes in \r
+ // the conversionTypes array, so if modify carefully.\r
+ internal static object ToType (object value, Type conversionType, \r
+ IFormatProvider provider) \r
+ {\r
+ if (value == null && conversionType == null)\r
+ return null;\r
+ \r
+ if (value == null)\r
+ throw new NullReferenceException ("Value is null.");\r
+ \r
+ if (value is IConvertible) {\r
+ IConvertible convertValue = (IConvertible) value;\r
+\r
+ if (conversionType == conversionTable[0]) // 0 Empty\r
+ throw new ArgumentNullException ();\r
+ \r
+ else if (conversionType == conversionTable[1]) // 1 TypeCode.Object\r
+ return (object) value;\r
+ \r
+ else if (conversionType == conversionTable[2]) // 2 TypeCode.DBNull\r
+ throw new InvalidCastException (); // It's not IConvertible\r
+ \r
+ else if (conversionType == conversionTable[3]) // 3 TypeCode.Boolean\r
+ return (object) convertValue.ToBoolean (provider);\r
+ \r
+ else if (conversionType == conversionTable[4]) // 4 TypeCode.Char\r
+ return (object) convertValue.ToChar (provider);\r
+ \r
+ else if (conversionType == conversionTable[5]) // 5 TypeCode.SByte\r
+ return (object) convertValue.ToSByte (provider);\r
+\r
+ else if (conversionType == conversionTable[6]) // 6 TypeCode.Byte\r
+ return (object) convertValue.ToByte (provider);\r
+ \r
+ else if (conversionType == conversionTable[7]) // 7 TypeCode.Int16\r
+ return (object) convertValue.ToInt16 (provider);\r
+ \r
+ else if (conversionType == conversionTable[8]) // 8 TypeCode.UInt16\r
+ return (object) convertValue.ToUInt16 (provider);\r
+ \r
+ else if (conversionType == conversionTable[9]) // 9 TypeCode.Int32\r
+ return (object) convertValue.ToInt32 (provider);\r
+ \r
+ else if (conversionType == conversionTable[10]) // 10 TypeCode.UInt32\r
+ return (object) convertValue.ToUInt32 (provider);\r
+ \r
+ else if (conversionType == conversionTable[11]) // 11 TypeCode.Int64\r
+ return (object) convertValue.ToInt64 (provider);\r
+ \r
+ else if (conversionType == conversionTable[12]) // 12 TypeCode.UInt64\r
+ return (object) convertValue.ToUInt64 (provider);\r
+ \r
+ else if (conversionType == conversionTable[13]) // 13 TypeCode.Single\r
+ return (object) convertValue.ToSingle (provider);\r
+ \r
+ else if (conversionType == conversionTable[14]) // 14 TypeCode.Double\r
+ return (object) convertValue.ToDouble (provider);\r
+\r
+ else if (conversionType == conversionTable[15]) // 15 TypeCode.Decimal\r
+ return (object) convertValue.ToDecimal (provider);\r
+\r
+ else if (conversionType == conversionTable[16]) // 16 TypeCode.DateTime\r
+ return (object) convertValue.ToDateTime (provider);\r
+ \r
+ else if (conversionType == conversionTable[18]) // 18 TypeCode.String\r
+ return (object) convertValue.ToString (provider);\r
+ else\r
+ throw new ArgumentException (Locale.GetText ("Unknown target conversion type"));\r
+ } else\r
+ // Not in the conversion table\r
+ throw new InvalidCastException ((Locale.GetText (\r
+ "Value is not a convertible object: " + value.GetType().ToString() + " to " + conversionType.FullName)));\r
+ }\r
+ }\r
+}\r
projects / mono.git / blobdiff