private ScriptUserdataField GetField(string strName)
{
if (m_FieldInfos.ContainsKey(strName))
{
return(m_FieldInfos[strName]);
}
ScriptUserdataField field = new ScriptUserdataField();
field.name = strName;
FieldInfo info = ValueType.GetField(strName);
if (info != null)
{
field.field = info;
field.fieldType = info.FieldType;
m_FieldInfos.Add(strName, field);
return(field);
}
MethodInfo method = ValueType.GetMethod("get_" + strName);
if (method != null)
{
field.getMethod = method;
field.fieldType = method.ReturnType;
field.setMethod = ValueType.GetMethod("set_" + strName);
m_FieldInfos.Add(strName, field);
return(field);
}
method = ValueType.GetMethod("set_" + strName);
if (method != null)
{
field.setMethod = method;
field.fieldType = method.GetParameters()[0].ParameterType;
field.getMethod = ValueType.GetMethod("get_" + strName);
m_FieldInfos.Add(strName, field);
return(field);
}
return(null);
}
public void SetValue()
{
if (DbParameter == null)
{
return;
}
if (IsNull)
{
DbParameter.Value = DBNull.Value;
}
if (ValueType == typeof(string) || ValueType.IsSubclassOf(typeof(string)))
{
DbParameter.Value = string.IsNullOrEmpty(Value) ? (object)DBNull.Value : Value;
return;
}
if (string.IsNullOrEmpty(Value))
{
DbParameter.Value = DBNull.Value;
return;
}
MethodInfo mi = null;
if (!string.IsNullOrEmpty(StringFormat))
{
mi = ValueType.GetMethod("ParseExact", new Type[] { typeof(string), typeof(string) });
if (mi != null)
{
DbParameter.Value = mi.Invoke(null, new object[] { Value, StringFormat });
return;
}
}
mi = ValueType.GetMethod("Parse", new Type[] { typeof(string) });
if (mi == null)
{
throw new NotSupportedException();
}
DbParameter.Value = mi.Invoke(null, new object[] { Value });
}
public override void Initialize(ParserInitializeArgs args)
{
base.Initialize(args);
if (args.Push(this))
{
if (ValueType != null)
{
var style = NumberStyles.None;
if (AllowSign)
{
style |= NumberStyles.AllowLeadingSign;
}
if (AllowDecimal)
{
style |= NumberStyles.AllowDecimalPoint;
}
if (AllowExponent)
{
style |= NumberStyles.AllowExponent;
}
var numberFormat = Culture.NumberFormat;
if (typeof(decimal) == ValueType)
{
getValue = text => decimal.Parse(text, style, numberFormat);
}
else if (typeof(Int16) == ValueType)
{
getValue = text => Int16.Parse(text, style, numberFormat);
}
else if (typeof(Int32) == ValueType)
{
getValue = text => Int32.Parse(text, style, numberFormat);
}
else if (typeof(Int64) == ValueType)
{
getValue = text => Int64.Parse(text, style, numberFormat);
}
else if (typeof(UInt16) == ValueType)
{
getValue = text => UInt16.Parse(text, style, numberFormat);
}
else if (typeof(UInt32) == ValueType)
{
getValue = text => UInt32.Parse(text, style, numberFormat);
}
else if (typeof(UInt64) == ValueType)
{
getValue = text => UInt64.Parse(text, style, numberFormat);
}
else if (typeof(double) == ValueType)
{
getValue = text => double.Parse(text, style, numberFormat);
}
else if (typeof(float) == ValueType)
{
getValue = text => float.Parse(text, style, numberFormat);
}
else
{
#if PCL
var parameters = new [] { typeof(string), typeof(NumberStyles) };
var parseMethod = ValueType.GetTypeInfo().DeclaredMethods.FirstOrDefault(r => r.Name == "Parse" && r.GetParameters().Select(p => p.ParameterType).SequenceEqual(parameters));
#else
var parseMethod = ValueType.GetMethod("Parse", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(NumberStyles) }, null);
#endif
getValue = text => parseMethod.Invoke(null, new object[] { text, style });
}
}
args.Pop();
}
}
/// <inheritdoc />
public object ParseValue(string text, string stringMarker = null, IFormatProvider provider = null)
{
if (provider == null)
{
provider = CultureInfo.InvariantCulture;
}
if (ValueType == null)
{
throw new InvalidOperationException("This function requires a valid ValueType!");
}
if (text == null)
{
return(null);
}
if (stringMarker != null)
{
if (text == "null")
{
return(null);
}
}
switch (DataType)
{
case DataType.TimeSpan:
{
if (string.IsNullOrEmpty(text) || (text == "null"))
{
return(IsNullable ? null : (object)default(TimeSpan));
}
switch (DateTimeType)
{
default: throw new NotSupportedException($"DateTimeType {DateTimeType} is not supported.");
case DateTimeType.BigIntHumanReadable:
return(new TimeSpan(DateTime.ParseExact(text, Storage.BigIntDateTimeFormat, provider).Ticks));
case DateTimeType.Undefined:
case DateTimeType.Native:
if (stringMarker != null)
{
text = text.Unbox(stringMarker, false);
}
#if NET20 || NET35
return(TimeSpan.Parse(text));
#else
return(TimeSpan.Parse(text, provider));
#endif
case DateTimeType.BigIntTicks:
return(new TimeSpan(long.Parse(text, provider)));
case DateTimeType.DecimalSeconds:
return(new TimeSpan((long)decimal.Round(decimal.Parse(text, provider) * TimeSpan.TicksPerSecond)));
case DateTimeType.DoubleSeconds:
{
var value = double.Parse(text, provider) * TimeSpan.TicksPerSecond;
var longValue = (long)value;
if ((value > 0) && (longValue < 0))
{
Trace.WriteLine("DoubleSeconds exceeded (long) range. Overflow detected!");
longValue = long.MaxValue;
}
else if ((value < 0) && (longValue > 0))
{
Trace.WriteLine("DoubleSeconds exceeded (long) range. Overflow detected!");
longValue = long.MinValue;
}
return(new TimeSpan(longValue));
}
}
}
case DataType.DateTime:
{
if (string.IsNullOrEmpty(text) || (text == "null"))
{
return(IsNullable ? null : (object)default(DateTime));
}
switch (DateTimeType)
{
default: throw new NotSupportedException($"DateTimeType {DateTimeType} is not supported.");
case DateTimeType.BigIntHumanReadable:
return(DateTime.ParseExact(text, Storage.BigIntDateTimeFormat, provider));
case DateTimeType.Undefined:
case DateTimeType.Native:
if (stringMarker != null)
{
text = text.Unbox(stringMarker, false);
}
return(DateTime.ParseExact(text, StringExtensions.InterOpDateTimeFormat, provider));
case DateTimeType.BigIntTicks:
return(new DateTime(long.Parse(text, provider), DateTimeKind));
case DateTimeType.DecimalSeconds:
return(new DateTime((long)decimal.Round(decimal.Parse(text, provider) * TimeSpan.TicksPerSecond), DateTimeKind));
case DateTimeType.DoubleSeconds:
return(new DateTime((long)Math.Round(double.Parse(text, provider) * TimeSpan.TicksPerSecond), DateTimeKind));
case DateTimeType.DoubleEpoch:
return(new DateTime((long)Math.Round(double.Parse(text, provider) * TimeSpan.TicksPerSecond) + Storage.EpochTicks, DateTimeKind));
}
}
case DataType.Binary:
{
if (string.IsNullOrEmpty(text) || (text == "null"))
{
return(null);
}
if (stringMarker != null)
{
text = text.Unbox(stringMarker, false);
}
return(Base64.NoPadding.Decode(text));
}
case DataType.Bool:
if (text.Length == 0)
{
return(IsNullable ? null : (object)false);
}
return((text.ToUpperInvariant() == "TRUE") || (text.ToUpperInvariant() == "YES") || (text == "1"));
case DataType.Single:
if (text.Length == 0)
{
return(IsNullable ? null : (object)0f);
}
return(float.Parse(text, provider));
case DataType.Double:
if (text.Length == 0)
{
return(IsNullable ? null : (object)0d);
}
return(double.Parse(text, provider));
case DataType.Decimal:
if (text.Length == 0)
{
return(IsNullable ? null : (object)0m);
}
return(decimal.Parse(text, provider));
case DataType.Int8:
if (text.Length == 0)
{
return(IsNullable ? null : (object)(sbyte)0);
}
return(sbyte.Parse(text, provider));
case DataType.Int16:
if (text.Length == 0)
{
return(IsNullable ? null : (object)(short)0);
}
return(short.Parse(text, provider));
case DataType.Int32:
if (text.Length == 0)
{
return(IsNullable ? null : (object)0);
}
return(int.Parse(text, provider));
case DataType.Int64:
if (text.Length == 0)
{
return(IsNullable ? null : (object)0L);
}
return(long.Parse(text, provider));
case DataType.UInt8:
if (text.Length == 0)
{
return(IsNullable ? null : (object)(byte)0);
}
return(byte.Parse(text, provider));
case DataType.UInt16:
if (text.Length == 0)
{
return(IsNullable ? null : (object)(ushort)0);
}
return(ushort.Parse(text, provider));
case DataType.UInt32:
if (text.Length == 0)
{
return(IsNullable ? null : (object)0U);
}
return(uint.Parse(text, provider));
case DataType.UInt64:
if (text.Length == 0)
{
return(IsNullable ? null : (object)0UL);
}
return(ulong.Parse(text, provider));
case DataType.Enum:
if (stringMarker != null)
{
text = text.Unbox(stringMarker, false);
}
if (text.Length == 0)
{
text = "0";
}
return(Enum.Parse(ValueType, text, true));
case DataType.Char:
if (stringMarker != null)
{
text = text.Unbox(stringMarker, false).Unescape();
}
if (text.Length != 1)
{
throw new InvalidDataException();
}
return(text[0]);
case DataType.String:
if (stringMarker != null)
{
text = text.Unbox(stringMarker, false).Unescape();
}
return(text);
case DataType.User: break;
default: throw new NotImplementedException();
}
if (stringMarker != null)
{
text = text.Unbox(stringMarker, false).Unescape();
}
if (!parserInitialized)
{
// lookup static Parse(string) method first
staticParse = ValueType.GetMethod("Parse", BindingFlags.Public | BindingFlags.Static, null, new[] { typeof(string) }, null);
// if there is none, search constructor(string)
if (staticParse == null)
{
constructor = ValueType.GetConstructor(new[] { typeof(string) });
}
parserInitialized = true;
}
// has static Parse(string) ?
if (staticParse != null)
{
// use method to parse value
return(staticParse.Invoke(null, new object[] { text }));
}
// has constructor(string) ?
if (constructor != null)
{
return(constructor.Invoke(new object[] { text }));
}
throw new MissingMethodException($"Could not find a way to parse or create {ValueType} from string!");
}