private static object CoerceProperty(object value, Type parameterType)
{
if (value == null)
{
return(null);
}
var valueType = value.GetType();
if (valueType.IsAssignmentCompatible(parameterType))
{
if ((valueType.GetBoxedType() != parameterType.GetBoxedType()) &&
parameterType.IsNumeric() &&
valueType.IsNumeric())
{
value = CoercerFactory.CoerceBoxed(value, parameterType.GetBoxedType());
}
return(value);
}
return(value);
}
public void TestGetCoercer()
{
Assert.AreEqual(1d, CoercerFactory.GetCoercer(null, typeof(double?)).Invoke(1d));
Assert.AreEqual(1d, CoercerFactory.GetCoercer(typeof(double?), typeof(double?)).Invoke(1d));
Assert.AreEqual(5d, CoercerFactory.GetCoercer(typeof(int?), typeof(double?)).Invoke(5));
Assert.AreEqual(6d, CoercerFactory.GetCoercer(typeof(byte?), typeof(double?)).Invoke((byte)6));
Assert.AreEqual(3f, CoercerFactory.GetCoercer(typeof(long?), typeof(float?)).Invoke((long)3));
Assert.AreEqual((short)2, CoercerFactory.GetCoercer(typeof(long?), typeof(short?)).Invoke((long)2));
Assert.AreEqual(4, CoercerFactory.GetCoercer(typeof(long?), typeof(int?)).Invoke((long)4));
Assert.AreEqual((byte)5, CoercerFactory.GetCoercer(typeof(long?), typeof(sbyte?)).Invoke((long)5));
Assert.AreEqual(8l, CoercerFactory.GetCoercer(typeof(long?), typeof(long?)).Invoke((long)8));
Assert.AreEqual(9.0m, CoercerFactory.GetCoercer(typeof(int), typeof(decimal)).Invoke(9));
Assert.AreEqual(9.0m, CoercerFactory.GetCoercer(typeof(double), typeof(decimal)).Invoke(9.0));
Assert.AreEqual(9.0m, CoercerFactory.GetCoercer(typeof(int), typeof(decimal?)).Invoke(9));
Assert.AreEqual(9.0m, CoercerFactory.GetCoercer(typeof(double), typeof(decimal?)).Invoke(9.0));
try {
CoercerFactory.CoerceBoxed(10, typeof(char));
Assert.Fail();
}
catch (ArgumentException) {
// Expected
}
}
public static Object CoerceProperty(String propertyName, Type containingType, Object value, Type type, EngineImportService engineImportService, bool forceNumeric, bool includeClassNameInEx)
{
if (value is ExprNode && type != typeof(ExprNode))
{
if (value is ExprIdentNode)
{
var identNode = (ExprIdentNode)value;
Property prop;
try {
prop = PropertyParser.ParseAndWalk(identNode.FullUnresolvedName);
}
catch (Exception ex) {
throw new ExprValidationException("Failed to parse property '" + identNode.FullUnresolvedName + "'");
}
if (!(prop is MappedProperty))
{
throw new ExprValidationException("Unrecognized property '" + identNode.FullUnresolvedName + "'");
}
var mappedProperty = (MappedProperty)prop;
if (mappedProperty.PropertyNameAtomic.ToLower() == ENVIRONMENT_PROPERTIES_NAME)
{
return(Environment.GetEnvironmentVariable(mappedProperty.Key));
}
}
else
{
var exprNode = (ExprNode)value;
var evaluator = exprNode.ExprEvaluator;
if (evaluator == null)
{
throw new ExprValidationException("Failed to evaluate expression '" + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(exprNode) + "'");
}
value = evaluator.Evaluate(new EvaluateParams(null, true, null));
}
}
if (value == null)
{
return(null);
}
if (value.GetType() == type)
{
return(value);
}
if (value.GetType().IsAssignmentCompatible(type))
{
if (forceNumeric && value.GetBoxedType() != type.GetBoxedType() && type.IsNumeric() && value.GetType().IsNumeric())
{
value = CoercerFactory.CoerceBoxed(value, type.GetBoxedType());
}
return(value);
}
if (TypeHelper.IsSubclassOrImplementsInterface(value.GetType(), type))
{
return(value);
}
if (type.IsArray)
{
if (!(value.GetType().IsGenericCollection()))
{
string detail = "expects an array but receives a value of type " + value.GetType().FullName;
throw new ExprValidationException(GetExceptionText(propertyName, containingType, includeClassNameInEx, detail));
}
var items = value.UnwrapIntoArray <object>();
var coercedArray = Array.CreateInstance(type.GetElementType(), items.Length);
for (var i = 0; i < items.Length; i++)
{
var coercedValue = CoerceProperty(propertyName + " (array element)", type, items[i], type.GetElementType(), engineImportService, false, includeClassNameInEx);
coercedArray.SetValue(coercedValue, i);
}
return(coercedArray);
}
if (!(value is Map))
{
string detail = "expects an " + TypeHelper.GetTypeNameFullyQualPretty(type) + " but receives a value of type " + value.GetType().FullName;
throw new ExprValidationException(GetExceptionText(propertyName, containingType, includeClassNameInEx, detail));
}
var props = (IDictionary <String, Object>)value;
return(InstantiatePopulateObject(props, type, engineImportService));
}
public static Object CoerceProperty(
string propertyName,
Type containingType,
Object value,
Type type,
ExprNodeOrigin exprNodeOrigin,
ExprValidationContext exprValidationContext,
bool forceNumeric,
bool includeClassNameInEx)
{
if (value is ExprNode && type != typeof(ExprNode))
{
if (value is ExprIdentNode)
{
var identNode = (ExprIdentNode)value;
Property prop;
try {
prop = PropertyParser.ParseAndWalkLaxToSimple(identNode.FullUnresolvedName);
}
catch (Exception) {
throw new ExprValidationException(
"Failed to parse property '" + identNode.FullUnresolvedName + "'");
}
if (!(prop is MappedProperty))
{
throw new ExprValidationException(
"Unrecognized property '" + identNode.FullUnresolvedName + "'");
}
var mappedProperty = (MappedProperty)prop;
if (string.Equals(
mappedProperty.PropertyNameAtomic, SYSTEM_PROPETIES_NAME,
StringComparison.InvariantCultureIgnoreCase))
{
return(Environment.GetEnvironmentVariable(mappedProperty.Key));
}
}
else
{
var exprNode = (ExprNode)value;
var validated = ExprNodeUtility.GetValidatedSubtree(
exprNodeOrigin, exprNode, exprValidationContext);
exprValidationContext.VariableService.SetLocalVersion();
var evaluator = validated.ExprEvaluator;
if (evaluator == null)
{
throw new ExprValidationException(
"Failed to evaluate expression '" +
ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(exprNode) + "'");
}
value = evaluator.Evaluate(EvaluateParams.EmptyTrue);
}
}
if (value == null)
{
return(null);
}
var valueType = value.GetType();
if (valueType == type)
{
return(value);
}
if (valueType.IsAssignmentCompatible(type))
{
if (forceNumeric &&
(valueType.GetBoxedType() != type.GetBoxedType()) &&
type.IsNumeric() &&
valueType.IsNumeric())
{
value = CoercerFactory.CoerceBoxed(value, type.GetBoxedType());
}
return(value);
}
#if false
// numerical coercion between non-boxed types and incompatible boxed types
if ((valueType.IsNumeric()) &&
(valueType.IsNullable() == false) &&
(type.IsNumeric()) &&
(type.IsNullable()))
{
var typeNonGeneric = Nullable.GetUnderlyingType(type);
if (valueType.IsAssignmentCompatible(typeNonGeneric))
{
value = CoercerFactory.CoerceBoxed(value, type);
}
return(value);
}
#endif
if (TypeHelper.IsSubclassOrImplementsInterface(valueType, type))
{
return(value);
}
if (type.IsArray)
{
if (!(valueType.IsGenericCollection()))
{
var detail = "expects an array but receives a value of type " + valueType.GetCleanName();
throw new ExprValidationException(
GetExceptionText(propertyName, containingType, includeClassNameInEx, detail));
}
var items = value.UnwrapIntoArray <object>();
var coercedArray = Array.CreateInstance(type.GetElementType(), items.Length);
for (var i = 0; i < items.Length; i++)
{
var coercedValue = CoerceProperty(
propertyName + " (array element)", type, items[i], type.GetElementType(), exprNodeOrigin,
exprValidationContext, false, includeClassNameInEx);
coercedArray.SetValue(coercedValue, i);
}
return(coercedArray);
}
if (type.IsNullable() && !valueType.IsNullable())
{
var typeNonGeneric = Nullable.GetUnderlyingType(type);
if (valueType.IsAssignmentCompatible(typeNonGeneric))
{
return(CoercerFactory.CoerceBoxed(value, type));
}
}
if (!(value is IDictionary <String, Object>))
{
var detail = "expects an " + type.GetCleanName() + " but receives a value of type " +
valueType.GetCleanName();
throw new ExprValidationException(
GetExceptionText(propertyName, containingType, includeClassNameInEx, detail));
}
var props = (IDictionary <string, Object>)value;
return(InstantiatePopulateObject(props, type, exprNodeOrigin, exprValidationContext));
}