protected override bool CanHandle(Type plainNetType, out OpenTypeKind mapsTo)
{
if (plainNetType == typeof(TestCollectionElement))
{
mapsTo = OpenTypeKind.CompositeType;
return(true);
}
return(base.CanHandle(plainNetType, out mapsTo));
}
protected virtual bool CanHandle(Type plainNetType, out OpenTypeKind mapsTo)
{
mapsTo = OpenTypeKind.SimpleType;
if (plainNetType == typeof(int) || plainNetType == typeof(string))
{
mapsTo = OpenTypeKind.SimpleType;
return(true);
}
return(Mapper.CanHandle(plainNetType, out mapsTo, CanHandle));
}
protected virtual bool CanHandle(Type plainNetType, out OpenTypeKind mapsTo)
{
mapsTo = OpenTypeKind.SimpleType;
if (plainNetType == typeof(int) || plainNetType == typeof(string))
{
mapsTo = OpenTypeKind.SimpleType;
return true;
}
return Mapper.CanHandle(plainNetType, out mapsTo, CanHandle);
}
private bool CanHandleImpl(Type plainNetType, out OpenTypeKind mapsTo)
{
mapsTo = OpenTypeKind.SimpleType;
foreach (ITypeMapper mapper in _mappers.Values)
{
if (mapper.CanHandle(plainNetType, out mapsTo, CanHandleImpl))
{
return(true);
}
}
return(false);
}
private static bool CanHandleElementType(Type elementType, out OpenTypeKind mapsTo, CanHandleDelegate canHandleNestedTypeCallback)
{
mapsTo = OpenTypeKind.ArrayType;
OpenTypeKind elementMapsTo;
if (canHandleNestedTypeCallback(elementType, out elementMapsTo))
{
mapsTo = ResolveMappedTypeKind(elementType);
return((mapsTo == OpenTypeKind.ArrayType && elementMapsTo == OpenTypeKind.SimpleType) ||
(mapsTo == OpenTypeKind.TabularType && elementMapsTo == OpenTypeKind.CompositeType));
}
return(false);
}
public bool CanHandle(Type plainNetType, out OpenTypeKind mapsTo, CanHandleDelegate canHandleNestedTypeCallback)
{
mapsTo = OpenTypeKind.CompositeType;
foreach (PropertyInfo propertyInfo in plainNetType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (propertyInfo.CanRead && propertyInfo.GetIndexParameters().Length == 0)
{
OpenTypeKind featureMapsTo;
if (!canHandleNestedTypeCallback(propertyInfo.PropertyType, out featureMapsTo))
{
return false;
}
}
}
return true;
}
public bool CanHandle(Type plainNetType, out OpenTypeKind mapsTo, CanHandleDelegate canHandleNestedTypeCallback)
{
mapsTo = OpenTypeKind.CompositeType;
foreach (PropertyInfo propertyInfo in plainNetType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (propertyInfo.CanRead && propertyInfo.GetIndexParameters().Length == 0)
{
OpenTypeKind featureMapsTo;
if (!canHandleNestedTypeCallback(propertyInfo.PropertyType, out featureMapsTo))
{
return(false);
}
}
}
return(true);
}
public OpenType MapType(Type plainNetType, MapTypeDelegate mapNestedTypeCallback)
{
Type elementType = GetElementType(plainNetType);
OpenTypeKind kind = ResolveMappedTypeKind(elementType);
if (kind == OpenTypeKind.ArrayType)
{
return(new ArrayType(1, mapNestedTypeCallback(elementType)));
}
else
{
CompositeType mappedElementType = (CompositeType)mapNestedTypeCallback(elementType);
CompositeType rowType = MakeRowType(mappedElementType);
return(new TabularType(
string.Format(CultureInfo.InvariantCulture, "{0} table", AttributeUtils.GetOpenTypeName(elementType)),
string.Format(CultureInfo.InvariantCulture, "Table of {0}", AttributeUtils.GetOpenTypeName(elementType)),
rowType, new string[] { CollectionIndexColumnName }));
}
}
public bool CanHandle(Type plainNetType, out OpenTypeKind mapsTo, CanHandleDelegate canHandleNestedTypeCallback)
{
mapsTo = OpenTypeKind.ArrayType;
if (plainNetType.IsGenericType)
{
Type genericDef = plainNetType.GetGenericTypeDefinition();
if (Array.Exists(_supportedCollectionTypes, delegate(Type t)
{
return(t == genericDef);
}))
{
Type elementType = plainNetType.GetGenericArguments()[0];
return(CanHandleElementType(elementType, out mapsTo, canHandleNestedTypeCallback));
}
}
else if (plainNetType.IsArray && plainNetType.GetArrayRank() == 1)
{
return(CanHandleElementType(plainNetType.GetElementType(), out mapsTo, canHandleNestedTypeCallback));
}
return(false);
}
public bool CanHandle(Type plainNetType, out OpenTypeKind mapsTo, CanHandleDelegate canHandleNestedTypeCallback)
{
mapsTo = OpenTypeKind.ArrayType;
if (plainNetType.IsGenericType)
{
Type genericDef = plainNetType.GetGenericTypeDefinition();
if (Array.Exists(_supportedCollectionTypes, delegate(Type t)
{
return t == genericDef;
}))
{
Type elementType = plainNetType.GetGenericArguments()[0];
return CanHandleElementType(elementType, out mapsTo, canHandleNestedTypeCallback);
}
}
else if (plainNetType.IsArray && plainNetType.GetArrayRank() == 1)
{
return CanHandleElementType(plainNetType.GetElementType(), out mapsTo, canHandleNestedTypeCallback);
}
return false;
}
public bool CanHandle(Type plainNetType, out OpenTypeKind mapsTo, CanHandleDelegate canHandleNestedTypeCallback)
{
mapsTo = OpenTypeKind.SimpleType;
return(plainNetType.IsEnum);
}
public bool CanHandle(Type plainNetType, out OpenTypeKind mapsTo, CanHandleDelegate canHandleNestedTypeCallback)
{
mapsTo = OpenTypeKind.SimpleType;
return SimpleType.IsSimpleType(plainNetType);
}
private bool CanHandleImpl(Type plainNetType, out OpenTypeKind mapsTo)
{
mapsTo = OpenTypeKind.SimpleType;
foreach (ITypeMapper mapper in _mappers.Values)
{
if (mapper.CanHandle(plainNetType, out mapsTo, CanHandleImpl))
{
return true;
}
}
return false;
}
private static bool CanHandleElementType(Type elementType, out OpenTypeKind mapsTo, CanHandleDelegate canHandleNestedTypeCallback)
{
mapsTo = OpenTypeKind.ArrayType;
OpenTypeKind elementMapsTo;
if (canHandleNestedTypeCallback(elementType, out elementMapsTo))
{
mapsTo = ResolveMappedTypeKind(elementType);
return (mapsTo == OpenTypeKind.ArrayType && elementMapsTo == OpenTypeKind.SimpleType) ||
(mapsTo == OpenTypeKind.TabularType && elementMapsTo == OpenTypeKind.CompositeType);
}
return false;
}
protected override bool CanHandle(Type plainNetType, out OpenTypeKind mapsTo)
{
if (plainNetType == typeof(TestCollectionElement))
{
mapsTo = OpenTypeKind.CompositeType;
return true;
}
return base.CanHandle(plainNetType, out mapsTo);
}
