public object ToType(Type conversionType, IFormatProvider provider)
{
if (conversionType == typeof(Value))
{
return(this);
}
if (RawValue == null)
{
return(null);
}
if (conversionType == typeof(int))
{
return(ToInt32(provider));
}
if (conversionType == typeof(double))
{
return(ToDouble(provider));
}
if (RawValue == null)
{
throw new NullReferenceException();
}
if (RawValue.GetType() == conversionType)
{
return(RawValue);
}
return(new TypeConverter().ConvertTo(RawValue, conversionType));
}
public bool CanBeNull()
{
if (SystemType == null && RawValue == null)
{
return(true);
}
return(SqlDataType.CanBeNull(SystemType ?? RawValue.GetType()));
}
private void setPropertyType()
{
if (Property != null)
{
PropertyType = Property.PropertyType;
}
else if (RawValue != null)
{
PropertyType = RawValue.GetType();
}
}
public string StringValue()
{
if (RawValue == null || RawValue as string == string.Empty)
{
return(string.Empty);
}
return(RawValue.ToString());
// I don't know what this is about. Why do we care if it's nullable or what it's type is?
var type = RawValue.GetType();
return(type.IsNullable() ? type.GetInnerTypeFromNullable().ToString() : type.ToString());
}
public T GenericReturn <T>()
{
if (RawValue is T)
{
return((T)RawValue);
}
if (RawValue is string)
{
return(((string)RawValue).Convert <T>());
}
//Is it a list
if (typeof(T).HasElementType || typeof(IList).IsAssignableFrom(typeof(T)))
{
var subType = typeof(T).GetElementType() ?? typeof(T).GenericTypeArguments.FirstOrDefault();
Array data;
//Convert from RawData to Array
if (RawValue is IList)
{
var vals = (IList)RawValue;
data = Array.CreateInstance(subType, vals.Count);
for (var i = 0; i < vals.Count; i++)
{
var val = (Value)vals[i];
data.SetValue(val.ToType(subType, null), i);
}
}
else
{
throw new NotSupportedException();
}
//Convert from Array to T
if (typeof(T).IsArray)
{
dynamic typedData = Array.CreateInstance(subType, data.Length);
data.CopyTo(typedData, 0);
return(typedData);
}
else if (typeof(IList).IsAssignableFrom(typeof(T)))
{
var listInstance = (IList)typeof(List <>)
.MakeGenericType(subType)
.GetConstructor(Type.EmptyTypes)
?.Invoke(null);
if (listInstance == null)
{
throw new NotSupportedException();
}
var converter = TypeDescriptor.GetConverter(subType);
foreach (var i in data)
{
listInstance.Add(converter.ConvertTo(i, subType));
}
return((T)listInstance);
}
else
{
throw new NotSupportedException();
}
}
try
{
return((T)ToType(typeof(T), null));
}
catch (NotSupportedException)
{
var valo = RawValue?.GetType().Name ?? RawValue?.GetType().Name ?? "null";
throw new InvalidCastException(
$"Cannot convert {valo} to {typeof(T).Name}");
}
catch (NullReferenceException)
{
throw new InvalidCastException(
$"Cannot convert Null to {typeof(T).Name}");
}
}
public override string ToString()
{
string raw = null;
if (Engine != null)
{
var e = this.Contains("convert_string").FirstOrDefault();
if (e != null)
{
var scopes = new ValueContainer(Engine);
scopes.Push(Engine.Globals);
scopes.NewStackBoundary();
dynamic ss = new Value();
ss.@this = this;
scopes.Push(ss);
dynamic scopeValue
= new Value(scopes, Engine.GlobalContainer.FindValue("Scopes"));
var expression = ((FunctionAbstract)e.RawValue).Lambda;
var c = new FunctionCallExpression(expression, new List <Value>()
{
(Value)scopeValue
});
dynamic res = Engine.RunExpressionCustomScope(c, scopes);
return((string)res);
}
}
if (IsNumber)
{
raw = RawValue.ToString();
}
if (RawValue is string)
{
raw = $"\"{RawValue}\"";
}
if (RawValue is Expression)
{
raw = ((Expression)RawValue).ToString();
}
if (IsBool)
{
raw = $"{RawValue}";
}
if (RawValue is FunctionAbstract)
{
raw = ((FunctionAbstract)RawValue).ToString();
return(raw);
}
if (RawValue is Delegate)
{
raw = ((Delegate)RawValue).ToString();
}
if (IsArray)
{
var v = (List <Value>)RawValue;
raw = "[" + string.Join(",", v.Select(x => x.ToString())) + "]";
}
var left = raw;
var right = (Values?.Any() ?? false) ? $"({string.Join(",", Values.Keys)})" : null;
if (left != null && right != null)
{
return($"{left}: {right}");
}
if (left != null)
{
return(left);
}
if (right != null)
{
return(right);
}
if (RawValue.ToString() != RawValue.GetType().ToString())
{
return(RawValue.ToString());
}
return("null");
}
