/// <summary>Returns the widener. </summary>
/// <param name="columnName">name of column</param>
/// <param name="columnType">type of column</param>
/// <param name="writeablePropertyType">property type</param>
/// <param name="writeablePropertyName">propery name</param>
/// <returns>type widender</returns>
/// <throws>ExprValidationException if type validation fails</throws>
public static TypeWidener GetCheckPropertyAssignType(String columnName,
Type columnType,
Type writeablePropertyType,
String writeablePropertyName)
{
Type columnClassBoxed = columnType.GetBoxedType();
Type targetClassBoxed = writeablePropertyType.GetBoxedType();
if (columnType == null)
{
if (writeablePropertyType.IsPrimitive)
{
String message = "Invalid assignment of column '" + columnName +
"' of null type to event property '" + writeablePropertyName +
"' typed as '" + writeablePropertyType.FullName +
"', nullable type mismatch";
throw new ExprValidationException(message);
}
}
else if (columnClassBoxed != targetClassBoxed)
{
if (columnClassBoxed == typeof(string) && targetClassBoxed == typeof(char?))
{
return(TypeWidenerStringToCharCoercer.Widen);
}
if (columnClassBoxed.IsArray && targetClassBoxed.IsArray)
{
var columnClassElement = columnClassBoxed.GetElementType();
var targetClassElement = targetClassBoxed.GetElementType();
// By definition, columnClassElement and targetClassElement should be
// incompatible. Question is, can we find a coercer between them?
var coercer = CoercerFactory.GetCoercer(columnClassElement, targetClassElement);
return(source => WidenArray(source, targetClassElement, coercer));
}
if (!columnClassBoxed.IsAssignmentCompatible(targetClassBoxed))
{
var writablePropName = writeablePropertyType.FullName;
if (writeablePropertyType.IsArray)
{
writablePropName = writeablePropertyType.GetElementType().FullName + "[]";
}
var columnTypeName = columnType.FullName;
if (columnType.IsArray)
{
columnTypeName = columnType.GetElementType().FullName + "[]";
}
String message = "Invalid assignment of column '" + columnName +
"' of type '" + columnTypeName +
"' to event property '" + writeablePropertyName +
"' typed as '" + writablePropName +
"', column and parameter types mismatch";
throw new ExprValidationException(message);
}
if (writeablePropertyType.IsNumeric())
{
var instance = new TypeWidenerBoxedNumeric(
CoercerFactory.GetCoercer(columnClassBoxed, targetClassBoxed));
return(instance.Widen);
}
}
return(null);
}
/// <summary>Returns the widener. </summary>
/// <param name="columnName">name of column</param>
/// <param name="columnType">type of column</param>
/// <param name="writeablePropertyType">property type</param>
/// <param name="writeablePropertyName">propery name</param>
/// <param name="allowObjectArrayToCollectionConversion">whether we widen object-array to collection</param>
/// <param name="customizer">customization if any</param>
/// <param name="engineURI">engine URI</param>
/// <param name="statementName">statement name</param>
/// <exception cref="ExprValidationException">if type validation fails</exception>
/// <returns>type widender</returns>
/// <throws>ExprValidationException if type validation fails</throws>
public static TypeWidener GetCheckPropertyAssignType(
String columnName,
Type columnType,
Type writeablePropertyType,
String writeablePropertyName,
bool allowObjectArrayToCollectionConversion,
TypeWidenerCustomizer customizer,
string statementName,
string engineURI)
{
Type columnClassBoxed = TypeHelper.GetBoxedType(columnType);
Type targetClassBoxed = TypeHelper.GetBoxedType(writeablePropertyType);
if (customizer != null)
{
TypeWidener custom = customizer.WidenerFor(columnName, columnType, writeablePropertyType, writeablePropertyName, statementName, engineURI);
if (custom != null)
{
return(custom);
}
}
if (columnType == null)
{
if (writeablePropertyType.IsPrimitive)
{
String message = "Invalid assignment of column '" + columnName +
"' of null type to event property '" + writeablePropertyName +
"' typed as '" + writeablePropertyType.FullName +
"', nullable type mismatch";
throw new ExprValidationException(message);
}
}
else if (columnClassBoxed != targetClassBoxed)
{
if (columnClassBoxed == typeof(string) && targetClassBoxed == typeof(char?))
{
return(TypeWidenerStringToCharCoercer.Widen);
}
if (allowObjectArrayToCollectionConversion &&
columnClassBoxed.IsArray &&
!columnClassBoxed.GetElementType().IsPrimitive &&
targetClassBoxed.IsGenericCollection())
{
return(OBJECT_ARRAY_TO_COLLECTION_COERCER);
}
if (columnClassBoxed.IsGenericDictionary() && targetClassBoxed.IsGenericDictionary())
{
var columnClassGenerics = columnClassBoxed.GetGenericArguments();
var targetClassGenerics = targetClassBoxed.GetGenericArguments();
var transformMethod = typeof(TransformDictionaryFactory)
.GetMethod("Create", new[] { typeof(object) })
.MakeGenericMethod(targetClassGenerics[0], targetClassGenerics[1], columnClassGenerics[0], columnClassGenerics[1]);
return(source =>
{
var parameters = new object[] { source };
return transformMethod.Invoke(null, BindingFlags.Static | BindingFlags.Public, null, parameters, null);
});
}
if ((columnClassBoxed == typeof(string)) &&
(targetClassBoxed == typeof(char[])))
{
return(source =>
{
var sourceAsString = (string)source;
return sourceAsString != null?sourceAsString.ToCharArray() : null;
});
}
if ((columnClassBoxed == typeof(char[])) &&
(targetClassBoxed == typeof(string)))
{
return(source =>
{
var sourceAsCharArray = (char[])source;
return sourceAsCharArray != null ? new string(sourceAsCharArray) : null;
});
}
if (columnClassBoxed.IsArray && targetClassBoxed.IsArray)
{
var columnClassElement = columnClassBoxed.GetElementType();
var targetClassElement = targetClassBoxed.GetElementType();
if (columnClassElement.IsAssignmentCompatible(targetClassElement))
{
// By definition, columnClassElement and targetClassElement should be
// incompatible. Question is, can we find a coercer between them?
var coercer = CoercerFactory.GetCoercer(columnClassElement, targetClassElement);
return(source => WidenArray(source, targetClassElement, coercer));
}
}
if (!columnClassBoxed.IsAssignmentCompatible(targetClassBoxed))
{
var writablePropName = writeablePropertyType.FullName;
if (writeablePropertyType.IsArray)
{
writablePropName = writeablePropertyType.GetElementType().FullName + "[]";
}
var columnTypeName = columnType.FullName;
if (columnType.IsArray)
{
columnTypeName = columnType.GetElementType().FullName + "[]";
}
String message = "Invalid assignment of column '" + columnName +
"' of type '" + columnTypeName +
"' to event property '" + writeablePropertyName +
"' typed as '" + writablePropName +
"', column and parameter types mismatch";
throw new ExprValidationException(message);
}
if (writeablePropertyType.IsNumeric())
{
var instance = new TypeWidenerBoxedNumeric(
CoercerFactory.GetCoercer(columnClassBoxed, targetClassBoxed));
return(instance.Widen);
}
}
return(null);
}
