public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
string s = value as string;
if (s == null)
{
return(base.ConvertFrom(context, culture, value));
}
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
string[] subs = s.Split(culture.TextInfo.ListSeparator.ToCharArray());
SingleConverter converter = new SingleConverter();
float[] numSubs = new float[subs.Length];
for (int i = 0; i < numSubs.Length; i++)
{
numSubs[i] = (float)converter.ConvertFromString(context, culture, subs[i]);
}
if (subs.Length != 2)
{
throw new ArgumentException("Failed to parse Text(" + s + ") expected text in the format \"Width,Height.\"");
}
return(new SizeF(numSubs[0], numSubs[1]));
}
public void PropertiesTest()
{
var converter = new SingleConverter();
Assert.AreEqual(true, converter.AcceptsNativeType);
Assert.AreEqual(typeof(float), converter.ConvertedType);
}
/// <summary>Converts the given object to the type of this converter, using the specified context and culture information.</summary>
/// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext" /> that provides a format context. </param>
/// <param name="culture">The <see cref="T:System.Globalization.CultureInfo" /> to use as the current culture. </param>
/// <param name="value">The <see cref="T:System.Object" /> to convert. </param>
/// <returns>An <see cref="T:System.Object" /> that represents the converted value.</returns>
// Token: 0x060007E2 RID: 2018 RVA: 0x00012420 File Offset: 0x00010620
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
string text = value as string;
if (text == null)
{
return(base.ConvertFrom(context, culture, value));
}
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
string[] array = text.Split(culture.TextInfo.ListSeparator.ToCharArray());
SingleConverter singleConverter = new SingleConverter();
float[] array2 = new float[array.Length];
for (int i = 0; i < array2.Length; i++)
{
array2[i] = (float)singleConverter.ConvertFromString(context, culture, array[i]);
}
if (array.Length != 2)
{
throw new ArgumentException("Failed to parse Text(" + text + ") expected text in the format \"Width,Height.\"");
}
return(new SizeF(array2[0], array2[1]));
}
/// <summary>
/// Convert a field to a string
/// </summary>
/// <param name="o">object we want to convert</param>
/// <returns>string representation of the string</returns>
internal string ValueToString(object o)
{
if (mDecimalConv == null)
{
mDecimalConv = new DecimalConverter(DecimalSeparator);
mDoubleConv = new DoubleConverter(DecimalSeparator);
mSingleConv = new SingleConverter(DecimalSeparator);
mDateConv = new DateTimeConverter(DateFormat);
}
if (o == null)
{
return(string.Empty);
}
else if (o is DateTime)
{
return(mDateConv.FieldToString(o));
}
else if (o is decimal)
{
return(mDecimalConv.FieldToString(o));
}
else if (o is double)
{
return(mDoubleConv.FieldToString(o));
}
else if (o is float)
{
return(mSingleConv.FieldToString(o));
}
else
{
return(o.ToString());
}
}
static Converter()
{
BoolConverter.Initialize();
CharConverter.Initialize();
ByteConverter.Initialize();
SByteConverter.Initialize();
Int16Converter.Initialize();
UInt16Converter.Initialize();
Int32Converter.Initialize();
UInt32Converter.Initialize();
Int64Converter.Initialize();
UInt64Converter.Initialize();
SingleConverter.Initialize();
DoubleConverter.Initialize();
DecimalConverter.Initialize();
BigIntegerConverter.Initialize();
BytesConverter.Initialize();
CharsConverter.Initialize();
StringConverter.Initialize();
StringBuilderConverter.Initialize();
DateTimeConverter.Initialize();
TimeSpanConverter.Initialize();
GuidConverter.Initialize();
MemoryStreamConverter.Initialize();
StreamConverter.Initialize();
}
private Font(SerializationInfo info, StreamingContext context)
{
string familyName = null;
float emSize = -1f;
FontStyle style = FontStyle.Regular;
GraphicsUnit unit = GraphicsUnit.Point;
SingleConverter singleConverter = new SingleConverter();
SerializationInfoEnumerator enumerator = info.GetEnumerator();
while (enumerator.MoveNext())
{
if (string.Equals(enumerator.Name, "Name", StringComparison.OrdinalIgnoreCase))
{
familyName = (string)enumerator.Value;
}
else if (string.Equals(enumerator.Name, "Size", StringComparison.OrdinalIgnoreCase))
{
emSize = ((!(enumerator.Value is string)) ? ((float)enumerator.Value) : ((float)singleConverter.ConvertFrom(enumerator.Value)));
}
else if (string.Compare(enumerator.Name, "Style", ignoreCase: true, CultureInfo.InvariantCulture) == 0)
{
style = (FontStyle)enumerator.Value;
}
else if (string.Compare(enumerator.Name, "Unit", ignoreCase: true, CultureInfo.InvariantCulture) == 0)
{
unit = (GraphicsUnit)enumerator.Value;
}
}
Initialize(familyName, emSize, style, unit, 1, IsVerticalName(familyName));
}
internal Unit(string value, CultureInfo culture, UnitType defaultType)
{
if (string.IsNullOrEmpty(value))
{
this.@value = 0;
this.type = (UnitType)0;
return;
}
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
string lower = value.Trim().ToLower(CultureInfo.InvariantCulture);
int length = lower.Length;
int num = -1;
for (int i = 0; i < length; i++)
{
char chr = lower[i];
if ((chr < '0' || chr > '9') && chr != '-' && chr != '.' && chr != ',')
{
break;
}
num = i;
}
if (num == -1)
{
object[] objArray = new object[] { value };
throw new FormatException(SR.GetString("UnitParseNoDigits", objArray));
}
if (num >= length - 1)
{
this.type = defaultType;
}
else
{
this.type = Unit.GetTypeFromString(lower.Substring(num + 1).Trim());
}
string str = lower.Substring(0, num + 1);
try
{
TypeConverter singleConverter = new SingleConverter();
this.@value = (double)((float)singleConverter.ConvertFromString(null, culture, str));
if (this.type == UnitType.Pixel)
{
this.@value = (double)((int)this.@value);
}
}
catch
{
object[] objArray1 = new object[] { value, str, this.type.ToString("G") };
throw new FormatException(SR.GetString("UnitParseNumericPart", objArray1));
}
if (this.@value < -32768 || this.@value > 32767)
{
throw new ArgumentOutOfRangeException("value");
}
}
public void RoundTripMinValueTest()
{
var converter = new SingleConverter();
var s = converter.ConvertToString(float.MinValue, null, new MemberMapData(null));
var f = converter.ConvertFromString(s, null, new MemberMapData(null));
Assert.Equal(float.MinValue, f);
}
/// <summary>
/// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
/// used as generic method and casting is not required.
/// <example>
/// basenumberconverter.ConvertTo<int>(context, culture, value);
/// </example>
/// </summary>
public static T ConvertTo <T>(this SingleConverter basenumberconverter, ITypeDescriptorContext context, System.Globalization.CultureInfo culture, Object value)
{
if (basenumberconverter == null)
{
throw new ArgumentNullException("basenumberconverter");
}
return((T)basenumberconverter.ConvertTo(context, culture, value, typeof(T)));
}
/// <summary>
/// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
/// used as generic method and casting is not required.
/// <example>
/// typeconverter.ConvertTo<int>(value);
/// </example>
/// </summary>
public static T ConvertTo <T>(this SingleConverter typeconverter, Object value)
{
if (typeconverter == null)
{
throw new ArgumentNullException("typeconverter");
}
return((T)typeconverter.ConvertTo(value, typeof(T)));
}
internal Unit(string value, CultureInfo culture, UnitType defaultType)
{
if (string.IsNullOrEmpty(value))
{
this.value = 0.0;
this.type = (UnitType)0;
}
else
{
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
string str = value.Trim().ToLower(CultureInfo.InvariantCulture);
int length = str.Length;
int num2 = -1;
for (int i = 0; i < length; i++)
{
char ch = str[i];
if (((ch < '0') || (ch > '9')) && (((ch != '-') && (ch != '.')) && (ch != ',')))
{
break;
}
num2 = i;
}
if (num2 == -1)
{
throw new FormatException(System.Web.SR.GetString("UnitParseNoDigits", new object[] { value }));
}
if (num2 < (length - 1))
{
this.type = GetTypeFromString(str.Substring(num2 + 1).Trim());
}
else
{
this.type = defaultType;
}
string text = str.Substring(0, num2 + 1);
try
{
TypeConverter converter = new SingleConverter();
this.value = (float)converter.ConvertFromString(null, culture, text);
if (this.type == UnitType.Pixel)
{
this.value = (int)this.value;
}
}
catch
{
throw new FormatException(System.Web.SR.GetString("UnitParseNumericPart", new object[] { value, text, this.type.ToString("G") }));
}
if ((this.value < -32768.0) || (this.value > 32767.0))
{
throw new ArgumentOutOfRangeException("value");
}
}
}
private void Init(string value, CultureInfo culture, RVUnitType defaultType)
{
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
string text = value.Trim().ToLower(culture);
int length = text.Length;
int num = -1;
for (int i = 0; i < length; i++)
{
char c = text[i];
if ((c < '0' || c > '9') && c != '-' && c != '.' && c != ',')
{
break;
}
num = i;
}
if (num == -1)
{
throw new FormatException();
}
if (num < length - 1)
{
m_type = GetTypeFromString(text.Substring(num + 1).Trim());
}
else
{
if (defaultType == (RVUnitType)0)
{
throw new FormatException();
}
m_type = defaultType;
}
string text2 = text.Substring(0, num + 1);
try
{
TypeConverter typeConverter = new SingleConverter();
m_value = (float)typeConverter.ConvertFromString(null, culture, text2);
}
catch (Exception ex)
{
Exception ex2 = FindStoppingException(ex);
if (ex2 == ex)
{
throw;
}
if (ex2 != null)
{
throw ex2;
}
throw new FormatException();
}
}
public void TargetType()
{
// Arrange
IConverter converter = new SingleConverter();
var expectedType = typeof(Single);
// Act
var actualType = converter.TargetType;
// Assert
Assert.Equal(expectedType, actualType);
}
private void Init(string value, CultureInfo culture, UnitType defaultType)
{
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
string valueString = value.Trim().ToLower();
int valueLength = valueString.Length;
int num2 = -1;
for (int i = 0; i < valueLength; i++)
{
char currentChar = valueString[i];
if (((currentChar < '0') || (currentChar > '9')) && (((currentChar != '-') && (currentChar != '.')) && (currentChar != ',')))
{
break;
}
num2 = i;
}
if (num2 == -1)
{
throw new FormatException(string.Format("{0} cannot be parsed as a unit because it does not contain numeric values. Examples of valid unit strings are \"1pt\" and \".5in\".", value));
}
if (num2 < (valueLength - 1))
{
_type = Unit.GetTypeFromString(valueString.Substring(num2 + 1).Trim());
}
else
{
if (defaultType == ((UnitType)0))
{
throw new FormatException(string.Format("{0} does not contain a unit specification. Examples of valid unit strings are \"1pt\" and \".5in\".", value));
}
_type = defaultType;
}
string valueSubstring = valueString.Substring(0, num2 + 1);
try
{
TypeConverter converter = new SingleConverter();
_value = (float)converter.ConvertFromString(null, CultureInfo.InvariantCulture, valueSubstring);
}
catch
{
throw new FormatException(string.Format("The numeric portion of {0} cannot be parsed as a unit of type {1}.", value, _type.ToString("G")));
}
}
private JsonFxAOT()
{
TypeConverter c;
c = new ArrayConverter();
m_fakeFlag = c.Equals(c);
//c = new BaseNumberConverter();
//m_fakeFlag = c.Equals(c);
c = new BooleanConverter();
m_fakeFlag = c.Equals(c);
c = new ByteConverter();
m_fakeFlag = c.Equals(c);
c = new CollectionConverter();
m_fakeFlag = c.Equals(c);
c = new ComponentConverter(typeof(int));
m_fakeFlag = c.Equals(c);
c = new CultureInfoConverter();
m_fakeFlag = c.Equals(c);
c = new DateTimeConverter();
m_fakeFlag = c.Equals(c);
c = new DecimalConverter();
m_fakeFlag = c.Equals(c);
c = new DoubleConverter();
m_fakeFlag = c.Equals(c);
c = new EnumConverter(typeof(int));
m_fakeFlag = c.Equals(c);
c = new ExpandableObjectConverter();
m_fakeFlag = c.Equals(c);
c = new Int16Converter();
m_fakeFlag = c.Equals(c);
c = new Int32Converter();
m_fakeFlag = c.Equals(c);
c = new Int64Converter();
m_fakeFlag = c.Equals(c);
c = new NullableConverter(typeof(object));
m_fakeFlag = c.Equals(c);
c = new SByteConverter();
m_fakeFlag = c.Equals(c);
c = new SingleConverter();
m_fakeFlag = c.Equals(c);
c = new StringConverter();
m_fakeFlag = c.Equals(c);
c = new TimeSpanConverter();
m_fakeFlag = c.Equals(c);
c = new UInt16Converter();
m_fakeFlag = c.Equals(c);
c = new UInt32Converter();
m_fakeFlag = c.Equals(c);
c = new UInt64Converter();
m_fakeFlag = c.Equals(c);
}
/// <summary>
/// Tries to parse a 32-bit single precision float from a string. This method should handle hexadecimal values
/// as well as normal values.
/// </summary>
/// <param name="value">The string value to parse.</param>
/// <param name="result">The parsed float value, if the string was valid. If invalid, this
/// will be the default float value value.</param>
/// <returns>True if the conversion was successful; otherwise returns false.</returns>
public static bool TryParseEx(string value, out float result)
{
bool canConvert = true;
try
{
var converter = new SingleConverter();
result = (float)converter.ConvertFromString(value);
}
catch (Exception)
{
result = default(float);
canConvert = false;
}
return(canConvert);
}
private Font(SerializationInfo info, StreamingContext context)
{
Debug.Assert(info != null, "Didn't expect a null parameter");
string name = null;
float size = -1f;
FontStyle style = FontStyle.Regular;
GraphicsUnit unit = GraphicsUnit.Point;
SingleConverter sc = new SingleConverter();
SerializationInfoEnumerator sie = info.GetEnumerator();
for (; sie.MoveNext();)
{
if (String.Equals(sie.Name, "Name", StringComparison.OrdinalIgnoreCase))
{
name = (string)sie.Value;
}
else if (String.Equals(sie.Name, "Size", StringComparison.OrdinalIgnoreCase))
{
if (sie.Value is System.String)
{
size = (float)sc.ConvertFrom(sie.Value);
}
else
{
size = (float)sie.Value;
}
}
else if (String.Compare(sie.Name, "Style", true, CultureInfo.InvariantCulture) == 0)
{
style = (FontStyle)sie.Value;
}
else if (String.Compare(sie.Name, "Unit", true, CultureInfo.InvariantCulture) == 0)
{
unit = (GraphicsUnit)sie.Value;
}
else
{
Debug.Fail("Unknown serialization item for font: " + sie.Name);
}
}
Initialize(name, size, style, unit, SafeNativeMethods.DEFAULT_CHARSET, IsVerticalName(name));
}
public void Conversion()
{
// Arrange
IConverter converter = new SingleConverter();
var value = "42,1";
var expectedValue = (Single)42.1;
// Act
using (new LangageSwitcher("fr-fr"))
{
var actualValue = converter.Convert(value, converter.TargetType);
// Assert
Assert.NotNull(actualValue);
Assert.IsType <Single>(actualValue);
Assert.Equal(expectedValue, (Single)actualValue);
}
}
public void ConvertFromExcelTest()
{
var converter = new SingleConverter();
var typeConverterOptions = new TypeConverterOptions {
CultureInfo = CultureInfo.CurrentCulture
};
Assert.AreEqual((float)12.3, converter.ConvertFromExcel(typeConverterOptions, 12.3));
Assert.AreEqual((float)12.3, converter.ConvertFromExcel(typeConverterOptions, "12.3"));
Assert.AreEqual((float)12.3, converter.ConvertFromExcel(typeConverterOptions, " 12.3 "));
Assert.AreEqual((float)0, converter.ConvertFromExcel(typeConverterOptions, null));
try {
converter.ConvertFromExcel(typeConverterOptions, "");
Assert.Fail();
} catch (ExcelTypeConverterException) {
}
}
private Font(SerializationInfo info, StreamingContext context)
{
string familyName = null;
float emSize = -1f;
FontStyle style = FontStyle.Regular;
GraphicsUnit unit = GraphicsUnit.Point;
SingleConverter singleConverter = new SingleConverter();
SerializationInfoEnumerator enumerator = info.GetEnumerator();
while (enumerator.MoveNext())
{
if (string.Equals(enumerator.Name, "Name", StringComparison.OrdinalIgnoreCase))
{
familyName = (string)enumerator.Value;
}
else if (string.Equals(enumerator.Name, "Size", StringComparison.OrdinalIgnoreCase))
{
emSize = ((!(enumerator.Value is string))
? ((float)enumerator.Value)
: ((float)singleConverter.ConvertFrom(enumerator.Value)));
}
else if (string.Compare(enumerator.Name, "Style", ignoreCase: true, CultureInfo.InvariantCulture) == 0)
{
style = (FontStyle)enumerator.Value;
}
else if (string.Compare(enumerator.Name, "Unit", ignoreCase: true, CultureInfo.InvariantCulture) == 0)
{
unit = (GraphicsUnit)enumerator.Value;
}
}
//Initialize(familyName, emSize, style, unit, 1, IsVerticalName(familyName));
if (unit == GraphicsUnit.Point)
{
emSize *= 1.333f;
}
nativeFont = new SKPaint()
{
Typeface = SKTypeface.Default, TextSize = emSize, Style = SKPaintStyle.Fill,
TextAlign = SKTextAlign.Left, IsVerticalText = IsVerticalName(familyName),
TextEncoding = SKTextEncoding.Utf8
};
}
private Font(SerializationInfo info, StreamingContext context)
{
this.gdiCharSet = 1;
this.systemFontName = "";
string familyName = null;
float emSize = -1f;
FontStyle regular = FontStyle.Regular;
GraphicsUnit point = GraphicsUnit.Point;
SingleConverter converter = new SingleConverter();
SerializationInfoEnumerator enumerator = info.GetEnumerator();
while (enumerator.MoveNext())
{
if (string.Equals(enumerator.Name, "Name", StringComparison.OrdinalIgnoreCase))
{
familyName = (string)enumerator.Value;
}
else
{
if (string.Equals(enumerator.Name, "Size", StringComparison.OrdinalIgnoreCase))
{
if (enumerator.Value is string)
{
emSize = (float)converter.ConvertFrom(enumerator.Value);
}
else
{
emSize = (float)enumerator.Value;
}
continue;
}
if (string.Compare(enumerator.Name, "Style", true, CultureInfo.InvariantCulture) == 0)
{
regular = (FontStyle)enumerator.Value;
}
else if (string.Compare(enumerator.Name, "Unit", true, CultureInfo.InvariantCulture) == 0)
{
point = (GraphicsUnit)enumerator.Value;
}
}
}
this.Initialize(familyName, emSize, regular, point, 1, IsVerticalName(familyName));
}
/// <summary>
/// Converts the specified value to a <see cref="SizeF"/>
/// </summary>
/// <param name="context">Conversion context</param>
/// <param name="culture">Culture to perform the conversion</param>
/// <param name="value">Value to convert</param>
/// <returns>A new instance of a <see cref="SizeF"/> converted from the specified <paramref name="value"/></returns>
public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
{
var text = value as string;
if (text != null)
{
var parts = text.Split(culture.TextInfo.ListSeparator.ToCharArray());
if (parts.Length != 2)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "Cannot parse value '{0}' as size. Should be in the form of 'width,height'", text));
}
var converter = new SingleConverter();
return(new SizeF(
(float)converter.ConvertFromString(context, culture, parts [0]),
(float)converter.ConvertFromString(context, culture, parts [1])
));
}
return(base.ConvertFrom(context, culture, value));
}
public void BadValueConversion()
{
// Arrange
IConverter converter = new SingleConverter();
var value = "Hello";
var expectedExceptionMessage = Constants.ExceptionMessages.FormatConverterUnableConvert(value, typeof(float));
var expectedInnerExceptionMessage = "Input string was not in a correct format.";
// Act
using (new LangageSwitcher("en-us"))
{
var actualException = Assert.Throws <CommandLineParserException>(() => converter.Convert(value, converter.TargetType));
// Assert
Assert.Equal(expectedExceptionMessage, actualException.Message);
Assert.NotNull(actualException.InnerException);
var actualInnerExecption = Assert.IsAssignableFrom <FormatException>(actualException.InnerException);
Assert.Equal(expectedInnerExceptionMessage, actualInnerExecption.Message);
}
}
internal void Write(float value)
{
Write(SingleConverter.SingleToInt32Bits(value));
}
public void SetUp()
{
converter = new SingleConverter();
}
internal object ConvertToType(Type type, object obj)
{
if (obj == null)
{
return(null);
}
if (obj is IDictionary <string, object> )
{
if (type == null)
{
obj = EvaluateDictionary((IDictionary <string, object>)obj);
}
else
{
JavaScriptConverter converter = GetConverter(type);
if (converter != null)
{
return(converter.Deserialize(
EvaluateDictionary((IDictionary <string, object>)obj),
type, this));
}
}
return(ConvertToObject((IDictionary <string, object>)obj, type));
}
if (obj is IEnumerable <object> )
{
return(ConvertToList((IEnumerable <object>)obj, type));
}
if (type == null)
{
return(obj);
}
Type sourceType = obj.GetType();
if (type.IsAssignableFrom(sourceType))
{
return(obj);
}
if (type.IsEnum)
{
return(Enum.ToObject(type, obj));
}
TypeConverter c = null;
try {
c = TypeDescriptor.GetConverter(type);
} catch (Exception) {
if (type.FullName == "System.Int32")
{
c = new Int32Converter();
// int
}
else if (type.FullName == "System.Int64")
{
c = new Int64Converter();
// long
}
else if (type.FullName == "System.Single")
{
c = new SingleConverter();
// float
}
else if (type.FullName == "System.Double")
{
c = new DoubleConverter();
// float
}
else if (type.FullName == "System.Boolean")
{
c = new BooleanConverter();
// bool
}
else if (type.FullName == "System.Byte")
{
c = new ByteConverter();
}
}
if (c.CanConvertFrom(sourceType))
{
if (obj is string)
{
return(c.ConvertFromInvariantString((string)obj));
}
return(c.ConvertFrom(obj));
}
/*
* Take care of the special case whereas in JSON an empty string ("") really means
* an empty value
* (see: https://bugzilla.novell.com/show_bug.cgi?id=328836)
*/
if ((type.IsGenericType) && (type.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
string s = obj as String;
if (String.IsNullOrEmpty(s))
{
return(null);
}
}
return(Convert.ChangeType(obj, type));
}
internal Unit(string value, CultureInfo culture, UnitType defaultType)
{
if (string.IsNullOrEmpty(value))
{
_value = 0.0f;
_type = (UnitType)0;
}
else
{
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
string str = value.Trim().ToLower(CultureInfo.InvariantCulture);
int length = str.Length;
int num2 = -1;
for (int i = 0; i < length; i++)
{
char ch = str[i];
if (((ch < '0') || (ch > '9')) && (((ch != '-') && (ch != '.')) && (ch != ',')))
{
break;
}
num2 = i;
}
if (num2 == -1)
{
throw new FormatException(string.Format("'{0}' cannot be parsed as a unit as there are no numeric values in it. Examples of valid unit strings are '30px' and '50%'.", value));
}
if (num2 < (length - 1))
{
_type = GetTypeFromString(str.Substring(num2 + 1).Trim());
}
else
{
_type = defaultType;
}
string text = str.Substring(0, num2 + 1);
try
{
TypeConverter converter = new SingleConverter();
_value = (float)converter.ConvertFromString(null, culture, text);
if (_type == UnitType.Pixel)
{
_value = (int)_value;
}
}
catch
{
throw new FormatException(string.Format("The numeric part ('{1}') of '{0}' cannot be parsed as a numeric part of a {2} unit.", value, text, _type.ToString("G")));
}
if ((_value < -32768.0) || (_value > 32767.0))
{
throw new ArgumentOutOfRangeException("value");
}
}
}
internal static TypeConverter GetCoreConverterFromCustomType(Type type)
{
TypeConverter result = null;
if (type.IsEnum)
{
result = new EnumConverter(type);
}
else if (typeof(int).IsAssignableFrom(type))
{
result = new Int32Converter();
}
else if (typeof(short).IsAssignableFrom(type))
{
result = new Int16Converter();
}
else if (typeof(long).IsAssignableFrom(type))
{
result = new Int64Converter();
}
else if (typeof(uint).IsAssignableFrom(type))
{
result = new UInt32Converter();
}
else if (typeof(ushort).IsAssignableFrom(type))
{
result = new UInt16Converter();
}
else if (typeof(ulong).IsAssignableFrom(type))
{
result = new UInt64Converter();
}
else if (typeof(bool).IsAssignableFrom(type))
{
result = new BooleanConverter();
}
else if (typeof(double).IsAssignableFrom(type))
{
result = new DoubleConverter();
}
else if (typeof(float).IsAssignableFrom(type))
{
result = new SingleConverter();
}
else if (typeof(byte).IsAssignableFrom(type))
{
result = new ByteConverter();
}
else if (typeof(sbyte).IsAssignableFrom(type))
{
result = new SByteConverter();
}
else if (typeof(char).IsAssignableFrom(type))
{
result = new CharConverter();
}
else if (typeof(decimal).IsAssignableFrom(type))
{
result = new DecimalConverter();
}
else if (typeof(TimeSpan).IsAssignableFrom(type))
{
result = new TimeSpanConverter();
}
else if (typeof(Guid).IsAssignableFrom(type))
{
result = new GuidConverter();
}
else if (typeof(string).IsAssignableFrom(type))
{
result = new StringConverter();
}
else if (typeof(CultureInfo).IsAssignableFrom(type))
{
result = new CultureInfoConverter();
}
else if (typeof(Type).IsAssignableFrom(type))
{
result = new TypeTypeConverter();
}
else if (typeof(DateTime).IsAssignableFrom(type))
{
result = new DateTimeConverter2();
}
return(result);
}
internal Unit(string value, CultureInfo culture, UnitType defaultType)
{
if ((value == null) || (value.Length == 0))
{
this.value = 0;
this.type = (UnitType)0;
}
else
{
if (culture == null)
{
culture = CultureInfo.CurrentCulture;
}
// This is invariant because it acts like an enum with a number together.
// The enum part is invariant, but the number uses current culture.
string trimLcase = value.Trim().ToLower(CultureInfo.InvariantCulture);
int len = trimLcase.Length;
int lastDigit = -1;
for (int i = 0; i < len; i++)
{
char ch = trimLcase[i];
if (((ch < '0') || (ch > '9')) && (ch != '-') && (ch != '.') && (ch != ','))
{
break;
}
lastDigit = i;
}
if (lastDigit == -1)
{
throw new FormatException(SR.GetString(SR.UnitParseNoDigits, value));
}
if (lastDigit < len - 1)
{
type = (UnitType)GetTypeFromString(trimLcase.Substring(lastDigit + 1).Trim());
}
else
{
type = defaultType;
}
string numericPart = trimLcase.Substring(0, lastDigit + 1);
// Cannot use Double.FromString, because we don't use it in the ToString implementation
try {
if (type == UnitType.Pixel)
{
TypeConverter converter = new Int32Converter();
this.value = (int)converter.ConvertFromString(null, culture, numericPart);
}
else
{
TypeConverter converter = new SingleConverter();
this.value = (Single)converter.ConvertFromString(null, culture, numericPart);
}
}
catch {
throw new FormatException(SR.GetString(SR.UnitParseNumericPart, value, numericPart, type.ToString("G")));
}
if ((this.value < MinValue) || (this.value > MaxValue))
{
throw new ArgumentOutOfRangeException("value");
}
}
}
private static TypeConverter GetCoreConverterFromCoreType(Type type)
{
TypeConverter result = null;
if (type == typeof(int))
{
result = new Int32Converter();
}
else if (type == typeof(short))
{
result = new Int16Converter();
}
else if (type == typeof(long))
{
result = new Int64Converter();
}
else if (type == typeof(uint))
{
result = new UInt32Converter();
}
else if (type == typeof(ushort))
{
result = new UInt16Converter();
}
else if (type == typeof(ulong))
{
result = new UInt64Converter();
}
else if (type == typeof(bool))
{
result = new BooleanConverter();
}
else if (type == typeof(double))
{
result = new DoubleConverter();
}
else if (type == typeof(float))
{
result = new SingleConverter();
}
else if (type == typeof(byte))
{
result = new ByteConverter();
}
else if (type == typeof(sbyte))
{
result = new SByteConverter();
}
else if (type == typeof(char))
{
result = new CharConverter();
}
else if (type == typeof(decimal))
{
result = new DecimalConverter();
}
else if (type == typeof(TimeSpan))
{
result = new TimeSpanConverter();
}
else if (type == typeof(Guid))
{
result = new GuidConverter();
}
else if (type == typeof(string))
{
result = new StringConverter();
}
else if (type == typeof(CultureInfo))
{
result = new CultureInfoConverter();
}
else if (type == typeof(Type))
{
result = new TypeTypeConverter();
}
else if (type == typeof(DateTime))
{
result = new DateTimeConverter2();
}
else if (ReflectionHelper.IsNullableType(type))
{
result = new NullableConverter(type);
}
return(result);
}
