/// <summary>
/// Auto maps the given map and checks for circular references as it goes.
/// </summary>
/// <param name="map">The map to auto map.</param>
/// <param name="ignoreReferences">
/// A value indicating if references should be ignored when auto mapping.
/// True to ignore references, otherwise false.
/// </param>
/// <param name="prefixReferenceHeaders">
/// A value indicating if headers of reference properties should
/// get prefixed by the parent property name.
/// True to prefix, otherwise false.
/// </param>
/// <param name="mapParents">The list of parents for the map.</param>
internal static void AutoMapInternal(CsvClassMap map, bool ignoreReferences, bool prefixReferenceHeaders,
LinkedList <Type> mapParents, int indexStart = 0)
{
var genericArguments = map.GetType().GetTypeInfo().BaseType.GetGenericArguments()[0];
if (typeof(IEnumerable).IsAssignableFrom(genericArguments))
{
throw new CsvConfigurationException(
"Types that inherit IEnumerable cannot be auto mapped. Did you accidentally call GetRecord or WriteRecord which acts on a single record instead of calling GetRecords or WriteRecords which acts on a list of records?");
}
var properties = genericArguments.GetProperties(BindingFlags.Instance | BindingFlags.Public);
for (int i = 0; i < properties.Length; i++)
{
var propertyInfo = properties[i];
var type = TypeConverterFactory.GetConverter(propertyInfo.PropertyType).GetType();
if (type != typeof(EnumerableConverter))
{
bool flag = type == typeof(DefaultTypeConverter);
if (!(flag & (propertyInfo.PropertyType.GetConstructor(new Type[0]) != null)))
{
var csvPropertyMap = new CsvPropertyMap(propertyInfo);
csvPropertyMap.Data.Index = map.GetMaxIndex() + 1;
if (csvPropertyMap.Data.TypeConverter.CanConvertFrom(typeof(string)) ||
csvPropertyMap.Data.TypeConverter.CanConvertTo(typeof(string)) && !flag)
{
map.PropertyMaps.Add(csvPropertyMap);
}
}
else if (!ignoreReferences && !CheckForCircularReference(propertyInfo.PropertyType, mapParents))
{
mapParents.AddLast(genericArguments);
var csvClassMap =
(CsvClassMap)
ReflectionHelper.CreateInstance(
typeof(DefaultCsvClassMap <>).MakeGenericType(propertyInfo.PropertyType));
AutoMapInternal(csvClassMap, false, prefixReferenceHeaders, mapParents, map.GetMaxIndex() + 1);
if (csvClassMap.PropertyMaps.Count > 0 || csvClassMap.ReferenceMaps.Count > 0)
{
var csvPropertyReferenceMap = new CsvPropertyReferenceMap(propertyInfo, csvClassMap);
if (prefixReferenceHeaders)
{
csvPropertyReferenceMap.Prefix(null);
}
map.ReferenceMaps.Add(csvPropertyReferenceMap);
}
}
}
}
map.ReIndex(indexStart);
}
/// <summary>
/// Auto maps the given map and checks for circular references as it goes.
/// </summary>
/// <param name="map">The map to auto map.</param>
/// <param name="ignoreReferences">A value indicating if references should be ignored when auto mapping.
/// True to ignore references, otherwise false.</param>
/// <param name="prefixReferenceHeaders">A value indicating if headers of reference properties should
/// get prefixed by the parent property name.
/// True to prefix, otherwise false.</param>
/// <param name="mapParents">The list of parents for the map.</param>
internal static void AutoMapInternal(CsvClassMap map, bool ignoreReferences, bool prefixReferenceHeaders, LinkedList <Type> mapParents, int indexStart = 0)
{
var type = map.GetType().BaseType.GetGenericArguments()[0];
if (typeof(IEnumerable).IsAssignableFrom(type))
{
throw new CsvConfigurationException("Types that inhererit IEnumerable cannot be auto mapped. " +
"Did you accidentally call GetRecord or WriteRecord which " +
"acts on a single record instead of calling GetRecords or " +
"WriteRecords which acts on a list of records?");
}
var properties = type.GetProperties();
foreach (var property in properties)
{
var typeConverterType = TypeConverterFactory.GetConverter(property.PropertyType).GetType();
if (typeConverterType == typeof(EnumerableConverter))
{
// The IEnumerable converter just throws an exception so skip it.
continue;
}
var isDefaultConverter = typeConverterType == typeof(DefaultTypeConverter);
var hasDefaultConstructor = property.PropertyType.GetConstructor(new Type[0]) != null;
if (isDefaultConverter && hasDefaultConstructor)
{
if (ignoreReferences)
{
continue;
}
// If the type is not one covered by our type converters
// and it has a parameterless constructor, create a
// reference map for it.
if (CheckForCircularReference(property.PropertyType, mapParents))
{
continue;
}
mapParents.AddLast(type);
var refMapType = typeof(DefaultCsvClassMap <>).MakeGenericType(property.PropertyType);
var refMap = (CsvClassMap)ReflectionHelper.CreateInstance(refMapType);
AutoMapInternal(refMap, false, prefixReferenceHeaders, mapParents, map.GetMaxIndex() + 1);
if (prefixReferenceHeaders)
{
foreach (var propertyMap in refMap.PropertyMaps)
{
for (var i = 0; i < propertyMap.Data.Names.Count; i++)
{
propertyMap.Data.Names[i] = string.Format("{0}.{1}", property.Name, propertyMap.Data.Names[i]);
}
}
}
if (refMap.PropertyMaps.Count > 0 || refMap.ReferenceMaps.Count > 0)
{
map.ReferenceMaps.Add(new CsvPropertyReferenceMap(property, refMap));
}
}
else
{
var propertyMap = new CsvPropertyMap(property);
propertyMap.Data.Index = map.GetMaxIndex() + 1;
if (propertyMap.Data.TypeConverter.CanConvertFrom(typeof(string)) ||
propertyMap.Data.TypeConverter.CanConvertTo(typeof(string)) && !isDefaultConverter)
{
// Only add the property map if it can be converted later on.
// If the property will use the default converter, don't add it because
// we don't want the .ToString() value to be used when auto mapping.
map.PropertyMaps.Add(propertyMap);
}
}
}
map.ReIndex(indexStart);
}
/// <summary>
/// Auto maps the given map and checks for circular references as it goes.
/// </summary>
/// <param name="map">The map to auto map.</param>
/// <param name="options">Options for auto mapping.</param>
/// <param name="mapParents">The list of parents for the map.</param>
/// <param name="indexStart">The index starting point.</param>
internal static void AutoMapInternal(CsvClassMap map, AutoMapOptions options, LinkedList <Type> mapParents, int indexStart = 0)
{
var type = map.GetType().GetTypeInfo().BaseType.GetGenericArguments()[0];
if (typeof(IEnumerable).IsAssignableFrom(type))
{
throw new CsvConfigurationException("Types that inherit IEnumerable cannot be auto mapped. " +
"Did you accidentally call GetRecord or WriteRecord which " +
"acts on a single record instead of calling GetRecords or " +
"WriteRecords which acts on a list of records?");
}
var flags = BindingFlags.Instance | BindingFlags.Public;
if (options.IncludePrivateProperties)
{
flags = flags | BindingFlags.NonPublic;
}
var members = new List <MemberInfo>();
if ((options.MemberTypes & MemberTypes.Properties) == MemberTypes.Properties)
{
var properties = type.GetProperties(flags);
members.AddRange(properties);
}
if ((options.MemberTypes & MemberTypes.Fields) == MemberTypes.Fields)
{
var fields = new List <MemberInfo>();
foreach (var field in type.GetFields(flags))
{
if (!field.GetCustomAttributes(typeof(CompilerGeneratedAttribute), false).Any())
{
fields.Add(field);
}
}
members.AddRange(fields);
}
foreach (var member in members)
{
var typeConverterType = TypeConverterFactory.GetConverter(member.MemberType()).GetType();
if (typeConverterType == typeof(EnumerableConverter))
{
// The IEnumerable converter just throws an exception so skip it.
continue;
}
var isDefaultConverter = typeConverterType == typeof(DefaultTypeConverter);
var hasDefaultConstructor = member.MemberType().GetConstructor(new Type[0]) != null;
if (isDefaultConverter && hasDefaultConstructor)
{
if (options.IgnoreReferences)
{
continue;
}
// If the type is not one covered by our type converters
// and it has a parameterless constructor, create a
// reference map for it.
if (CheckForCircularReference(member.MemberType(), mapParents))
{
continue;
}
mapParents.AddLast(type);
var refMapType = typeof(DefaultCsvClassMap <>).MakeGenericType(member.MemberType());
var refMap = (CsvClassMap)ReflectionHelper.CreateInstance(refMapType);
var refOptions = options.Copy();
refOptions.IgnoreReferences = false;
AutoMapInternal(refMap, options, mapParents, map.GetMaxIndex() + 1);
if (refMap.PropertyMaps.Count > 0 || refMap.ReferenceMaps.Count > 0)
{
var referenceMap = new CsvPropertyReferenceMap(member, refMap);
if (options.PrefixReferenceHeaders)
{
referenceMap.Prefix();
}
map.ReferenceMaps.Add(referenceMap);
}
}
else
{
var propertyMap = new CsvPropertyMap(member);
// Use global values as the starting point.
propertyMap.Data.TypeConverterOptions = TypeConverterOptions.Merge(options.TypeConverterOptionsFactory.GetOptions(member.MemberType()));
propertyMap.Data.Index = map.GetMaxIndex() + 1;
if (!isDefaultConverter)
{
// Only add the property/field map if it can be converted later on.
// If the property/field will use the default converter, don't add it because
// we don't want the .ToString() value to be used when auto mapping.
map.PropertyMaps.Add(propertyMap);
}
}
}
map.ReIndex(indexStart);
}
/// <summary>
/// Auto maps the given map and checks for circular references as it goes.
/// </summary>
/// <param name="map">The map to auto map.</param>
/// <param name="ignoreReferences">A value indicating if references should be ignored when auto mapping.
/// True to ignore references, otherwise false.</param>
/// <param name="mapParents">The list of parents for the map.</param>
internal static void AutoMapInternal(CsvClassMap map, bool ignoreReferences, LinkedList <Type> mapParents)
{
#if WINRT_4_5
var type = map.GetType().GetTypeInfo().BaseType.GetGenericArguments()[0];
#else
var type = map.GetType().BaseType.GetGenericArguments()[0];
#endif
if (typeof(IEnumerable).IsAssignableFrom(type))
{
throw new CsvConfigurationException("Types that inhererit IEnumerable cannot be auto mapped. " +
"Did you accidentally call GetRecord or WriteRecord which " +
"acts on a single record instead of calling GetRecords or " +
"WriteRecords which acts on a list of records?");
}
#if WINRT_4_5
var properties = type.GetProperties();
#else
var properties = type.GetProperties();
#endif
foreach (var property in properties)
{
var isDefaultConverter = TypeConverterFactory.GetConverter(property.PropertyType).GetType() == typeof(DefaultTypeConverter);
#if WINRT_4_5
var hasDefaultConstructor = property.PropertyType.GetTypeInfo().DeclaredConstructors.Any(c => !c.GetParameters().Any());
#else
var hasDefaultConstructor = property.PropertyType.GetConstructor(Type.EmptyTypes) != null;
#endif
if (isDefaultConverter && hasDefaultConstructor)
{
if (ignoreReferences)
{
continue;
}
// If the type is not one covered by our type converters
// and it has a parameterless constructor, create a
// reference map for it.
if (CheckForCircularReference(property.PropertyType, mapParents))
{
continue;
}
mapParents.AddLast(type);
var refMapType = typeof(DefaultCsvClassMap <>).MakeGenericType(property.PropertyType);
var refMap = (CsvClassMap)ReflectionHelper.CreateInstance(refMapType);
AutoMapInternal(refMap, false, mapParents);
if (refMap.PropertyMaps.Count > 0 || refMap.ReferenceMaps.Count > 0)
{
map.ReferenceMaps.Add(new CsvPropertyReferenceMap(property, refMap));
}
}
else
{
var propertyMap = new CsvPropertyMap(property);
propertyMap.Data.Index = map.GetMaxIndex() + 1;
if (propertyMap.Data.TypeConverter.CanConvertFrom(typeof(string)) ||
propertyMap.Data.TypeConverter.CanConvertTo(typeof(string)) && !isDefaultConverter)
{
// Only add the property map if it can be converted later on.
// If the property will use the default converter, don't add it because
// we don't want the .ToString() value to be used when auto mapping.
map.PropertyMaps.Add(propertyMap);
}
}
}
map.ReIndex();
}
/// <summary>
/// Auto maps the given map using constructor parameters.
/// </summary>
/// <param name="map">The map to auto map.</param>
/// <param name="options">Options for auto mapping.</param>
/// <param name="mapParents">The list of parents for the map.</param>
/// <param name="indexStart">The index starting point.</param>
protected virtual void AutoMapConstructorParameters(CsvClassMap map, AutoMapOptions options, LinkedList <Type> mapParents, int indexStart = 0)
{
var type = map.GetGenericType();
var constructor = options.GetConstructor(map.ClassType);
var parameters = constructor.GetParameters();
foreach (var parameter in parameters)
{
var typeConverterType = TypeConverterFactory.Current.GetConverter(parameter.ParameterType).GetType();
var parameterMap = new CsvParameterMap(parameter);
var memberTypeInfo = parameter.ParameterType.GetTypeInfo();
var isDefaultConverter = typeConverterType == typeof(DefaultTypeConverter);
if (isDefaultConverter && (memberTypeInfo.HasParameterlessConstructor() || memberTypeInfo.IsUserDefinedStruct()))
{
// If the type is not one covered by our type converters
// and it has a parameterless constructor, create a
// reference map for it.
if (options.IgnoreReferences)
{
throw new InvalidOperationException($"Configuration '{nameof( options.IgnoreReferences )}' can't be true " +
"when using types without a default constructor. Constructor parameters " +
"are used and all properties including references must be used.");
}
if (CheckForCircularReference(parameter.ParameterType, mapParents))
{
throw new InvalidOperationException($"A circular reference was detected in constructor paramter '{parameter.Name}'." +
"Since all parameters must be supplied for a constructor, this parameter can't be skipped.");
}
mapParents.AddLast(type);
var refMapType = typeof(DefaultCsvClassMap <>).MakeGenericType(parameter.ParameterType);
var refMap = (CsvClassMap)ReflectionHelper.CreateInstance(refMapType);
var refOptions = options.Copy();
refOptions.IgnoreReferences = false;
AutoMapProperties(refMap, options, mapParents, Math.Max(map.GetMaxIndex() + 1, indexStart));
mapParents.Drop(mapParents.Find(type));
var referenceMap = new CsvParameterReferenceMap(parameter, refMap);
if (options.PrefixReferenceHeaders)
{
referenceMap.Prefix();
}
parameterMap.ReferenceMap = referenceMap;
}
else if (options.ShouldUseConstructorParameters(parameter.ParameterType))
{
mapParents.AddLast(type);
var constructorMapType = typeof(DefaultCsvClassMap <>).MakeGenericType(parameter.ParameterType);
var constructorMap = (CsvClassMap)ReflectionHelper.CreateInstance(constructorMapType);
var constructorOptions = options.Copy();
constructorOptions.IgnoreReferences = false;
// Need to use Max here for nested types.
AutoMapConstructorParameters(constructorMap, constructorOptions, mapParents, Math.Max(map.GetMaxIndex() + 1, indexStart));
mapParents.Drop(mapParents.Find(type));
parameterMap.ConstructorTypeMap = constructorMap;
}
else
{
parameterMap.Data.TypeConverterOptions = TypeConverterOptions.Merge(new TypeConverterOptions(), options.TypeConverterOptionsFactory.GetOptions(parameter.ParameterType), parameterMap.Data.TypeConverterOptions);
parameterMap.Data.Index = map.GetMaxIndex() + 1;
}
map.ParameterMaps.Add(parameterMap);
}
map.ReIndex(indexStart);
}
/// <summary>
/// Auto maps the given map and checks for circular references as it goes.
/// </summary>
/// <param name="map">The map to auto map.</param>
/// <param name="options">Options for auto mapping.</param>
/// <param name="mapParents">The list of parents for the map.</param>
/// <param name="indexStart">The index starting point.</param>
protected virtual void AutoMapProperties(CsvClassMap map, AutoMapOptions options, LinkedList <Type> mapParents, int indexStart = 0)
{
var type = map.GetGenericType();
var flags = BindingFlags.Instance | BindingFlags.Public;
if (options.IncludePrivateProperties)
{
flags = flags | BindingFlags.NonPublic;
}
var members = new List <MemberInfo>();
if (options.MemberTypes.HasFlag(MemberTypes.Properties))
{
// We need to go up the declaration tree and find the actual type the property
// exists on and use that PropertyInfo instead. This is so we can get the private
// set method for the property.
var properties = new List <PropertyInfo>();
foreach (var property in type.GetProperties(flags))
{
properties.Add(ReflectionHelper.GetDeclaringProperty(type, property, flags));
}
members.AddRange(properties);
}
if (options.MemberTypes.HasFlag(MemberTypes.Fields))
{
var fields = new List <MemberInfo>();
foreach (var field in type.GetFields(flags))
{
if (!field.GetCustomAttributes(typeof(CompilerGeneratedAttribute), false).Any())
{
fields.Add(field);
}
}
members.AddRange(fields);
}
foreach (var member in members)
{
var typeConverterType = TypeConverterFactory.Current.GetConverter(member.MemberType()).GetType();
if (options.HasHeaderRecord && enumerableConverters.Contains(typeConverterType))
{
// Enumerable converters can't write the header properly, so skip it.
continue;
}
var memberTypeInfo = member.MemberType().GetTypeInfo();
var isDefaultConverter = typeConverterType == typeof(DefaultTypeConverter);
if (isDefaultConverter && (memberTypeInfo.HasParameterlessConstructor() || memberTypeInfo.IsUserDefinedStruct()))
{
// If the type is not one covered by our type converters
// and it has a parameterless constructor, create a
// reference map for it.
if (options.IgnoreReferences)
{
continue;
}
if (CheckForCircularReference(member.MemberType(), mapParents))
{
continue;
}
mapParents.AddLast(type);
var refMapType = typeof(DefaultCsvClassMap <>).MakeGenericType(member.MemberType());
var refMap = (CsvClassMap)ReflectionHelper.CreateInstance(refMapType);
var refOptions = options.Copy();
refOptions.IgnoreReferences = false;
// Need to use Max here for nested types.
AutoMapProperties(refMap, options, mapParents, Math.Max(map.GetMaxIndex() + 1, indexStart));
mapParents.Drop(mapParents.Find(type));
if (refMap.PropertyMaps.Count > 0 || refMap.ReferenceMaps.Count > 0)
{
var referenceMap = new CsvPropertyReferenceMap(member, refMap);
if (options.PrefixReferenceHeaders)
{
referenceMap.Prefix();
}
map.ReferenceMaps.Add(referenceMap);
}
}
else
{
var propertyMap = CsvPropertyMap.CreateGeneric(map.ClassType, member);
// Use global values as the starting point.
propertyMap.Data.TypeConverterOptions = TypeConverterOptions.Merge(new TypeConverterOptions(), options.TypeConverterOptionsFactory.GetOptions(member.MemberType()), propertyMap.Data.TypeConverterOptions);
propertyMap.Data.Index = map.GetMaxIndex() + 1;
if (!isDefaultConverter)
{
// Only add the property/field map if it can be converted later on.
// If the property/field will use the default converter, don't add it because
// we don't want the .ToString() value to be used when auto mapping.
map.PropertyMaps.Add(propertyMap);
}
}
}
map.ReIndex(indexStart);
}
/// <summary>
/// Auto maps the given map and checks for circular references as it goes.
/// </summary>
/// <param name="map">The map to auto map.</param>
/// <param name="options">Options for auto mapping.</param>
/// <param name="mapParents">The list of parents for the map.</param>
/// <param name="indexStart">The index starting point.</param>
internal static void AutoMapInternal( CsvClassMap map, AutoMapOptions options, LinkedList<Type> mapParents, int indexStart = 0 )
{
var type = map.GetType().GetTypeInfo().BaseType.GetGenericArguments()[0];
if( typeof( IEnumerable ).IsAssignableFrom( type ) )
{
throw new CsvConfigurationException( "Types that inherit IEnumerable cannot be auto mapped. " +
"Did you accidentally call GetRecord or WriteRecord which " +
"acts on a single record instead of calling GetRecords or " +
"WriteRecords which acts on a list of records?" );
}
var flags = BindingFlags.Instance | BindingFlags.Public;
if( options.IncludePrivateProperties )
{
flags = flags | BindingFlags.NonPublic;
}
var members = new List<MemberInfo>();
if( ( options.MemberTypes & MemberTypes.Properties ) == MemberTypes.Properties )
{
var properties = type.GetProperties( flags );
members.AddRange( properties );
}
if( ( options.MemberTypes & MemberTypes.Fields ) == MemberTypes.Fields )
{
var fields = new List<MemberInfo>();
foreach( var field in type.GetFields( flags ) )
{
if( !field.GetCustomAttributes( typeof( CompilerGeneratedAttribute ), false ).Any() )
{
fields.Add( field );
}
}
members.AddRange( fields );
}
foreach( var member in members )
{
var typeConverterType = TypeConverterFactory.GetConverter( member.MemberType() ).GetType();
if( typeConverterType == typeof( EnumerableConverter ) )
{
// The IEnumerable converter just throws an exception so skip it.
continue;
}
var isDefaultConverter = typeConverterType == typeof( DefaultTypeConverter );
var hasDefaultConstructor = member.MemberType().GetConstructor( new Type[0] ) != null;
if( isDefaultConverter && hasDefaultConstructor )
{
if( options.IgnoreReferences )
{
continue;
}
// If the type is not one covered by our type converters
// and it has a parameterless constructor, create a
// reference map for it.
if( CheckForCircularReference( member.MemberType(), mapParents ) )
{
continue;
}
mapParents.AddLast( type );
var refMapType = typeof( DefaultCsvClassMap<> ).MakeGenericType( member.MemberType() );
var refMap = (CsvClassMap)ReflectionHelper.CreateInstance( refMapType );
var refOptions = options.Copy();
refOptions.IgnoreReferences = false;
AutoMapInternal( refMap, options, mapParents, map.GetMaxIndex() + 1 );
if( refMap.PropertyMaps.Count > 0 || refMap.ReferenceMaps.Count > 0 )
{
var referenceMap = new CsvPropertyReferenceMap( member, refMap );
if( options.PrefixReferenceHeaders )
{
referenceMap.Prefix();
}
map.ReferenceMaps.Add( referenceMap );
}
}
else
{
var propertyMap = new CsvPropertyMap( member );
// Use global values as the starting point.
propertyMap.Data.TypeConverterOptions = TypeConverterOptions.Merge( options.TypeConverterOptionsFactory.GetOptions( member.MemberType() ) );
propertyMap.Data.Index = map.GetMaxIndex() + 1;
if( !isDefaultConverter )
{
// Only add the property/field map if it can be converted later on.
// If the property/field will use the default converter, don't add it because
// we don't want the .ToString() value to be used when auto mapping.
map.PropertyMaps.Add( propertyMap );
}
}
}
map.ReIndex( indexStart );
}