public virtual CsvPropertyMap PropertyMap <T>(Expression <Func <T, object> > expression)
{
var property = ReflectionHelper.GetProperty(expression);
var csvPropertyMap = PropertyMaps.SingleOrDefault(m =>
{
if (m.Data.Property == property)
{
return(true);
}
if (m.Data.Property.Name != property.Name)
{
return(false);
}
if (m.Data.Property.DeclaringType.IsAssignableFrom(property.DeclaringType))
{
return(true);
}
return(property.DeclaringType.IsAssignableFrom(m.Data.Property.DeclaringType));
});
if (csvPropertyMap != null)
{
return(csvPropertyMap);
}
var maxIndex = new CsvPropertyMap(property);
maxIndex.Data.Index = GetMaxIndex() + 1;
PropertyMaps.Add(maxIndex);
return(maxIndex);
}
/// <summary>
/// Maps a property to a CSV field.
/// </summary>
/// <param name="expression">The property to map.</param>
protected CsvPropertyMap Map(Expression <Func <T, object> > expression)
{
var property = ReflectionHelper.GetProperty(expression);
var propertyMap = new CsvPropertyMap(property);
Properties.Add(propertyMap);
return(propertyMap);
}
/// <summary>
/// Generates a <see cref="CsvClassMap"/> for the type.
/// </summary>
/// <param name="type">The ytpe to generate for the map.</param>
/// <returns>The generate map.</returns>
public virtual CsvClassMap AutoMap( Type type )
{
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( maps[type] != null )
{
// If the map already exists, use it.
return maps[type];
}
#if WINRT_4_5
var properties = type.GetProperties();
#else
var properties = type.GetProperties( propertyBindingFlags );
#endif
var mapType = typeof( CsvClassMap<> ).MakeGenericType( type );
var map = (CsvClassMap)ReflectionHelper.CreateInstance( mapType );
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 the type is not a one covered by our type converters
// and it has a parameterless constructor, create a
// reference map for it.
var refMap = AutoMap( property.PropertyType );
if( refMap.PropertyMaps.Count > 0 || refMap.ReferenceMaps.Count > 0 )
{
map.ReferenceMaps.Add( new CsvPropertyReferenceMap( property, refMap ) );
}
}
else
{
var propertyMap = new CsvPropertyMap( property );
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( new CsvPropertyMap( property ) );
}
}
}
return map;
}
/// <summary>
/// Maps a non-member to a CSV field. This allows for writing
/// data that isn't mapped to a class property/field.
/// </summary>
/// <returns>The property mapping.</returns>
public virtual CsvPropertyMap Map()
{
var propertyMap = new CsvPropertyMap(null);
propertyMap.Data.Index = GetMaxIndex() + 1;
PropertyMaps.Add(propertyMap);
return(propertyMap);
}
/// <summary>
/// Maps a property to a CSV field.
/// </summary>
/// <param name="expression">The property to map.</param>
/// <returns>The property mapping.</returns>
protected virtual CsvPropertyMap Map(Expression <Func <T, object> > expression)
{
var property = ReflectionHelper.GetProperty(expression);
if (PropertyMaps.Any(m => m.Data.Property == property))
{
throw new CsvConfigurationException(string.Format("Property '{0}' has already been mapped.", property.Name));
}
var propertyMap = new CsvPropertyMap(property);
PropertyMaps.Add(propertyMap);
return(propertyMap);
}
/// <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>
/// Maps a property to a CSV field.
/// </summary>
/// <param name="property">The property to map.</param>
/// <returns>The property mapping.</returns>
public virtual CsvPropertyMap Map(PropertyInfo property)
{
var existingMap = PropertyMaps.Find(property);
if (existingMap != null)
{
return(existingMap);
}
var propertyMap = new CsvPropertyMap(property);
propertyMap.Data.Index = GetMaxIndex() + 1;
PropertyMaps.Add(propertyMap);
return(propertyMap);
}
/// <summary>
/// Maps a property/field to a CSV field.
/// </summary>
/// <param name="member">The property/field to map.</param>
/// <param name="useExistingMap">If true, an existing map will be used if available.
/// If false, a new map is created for the same property/field.</param>
/// <returns>The property/field mapping.</returns>
public virtual CsvPropertyMap Map(MemberInfo member, bool useExistingMap = true)
{
if (useExistingMap)
{
var existingMap = PropertyMaps.Find(member);
if (existingMap != null)
{
return(existingMap);
}
}
var propertyMap = new CsvPropertyMap(member);
propertyMap.Data.Index = GetMaxIndex() + 1;
PropertyMaps.Add(propertyMap);
return(propertyMap);
}
/// <summary>
/// Maps a property/field to a CSV field.
/// </summary>
/// <param name="classType">The type of the class this map is for. This may not be the same type
/// as the member.DeclaringType or the current ClassType due to nested property mappings.</param>
/// <param name="member">The property/field to map.</param>
/// <param name="useExistingMap">If true, an existing map will be used if available.
/// If false, a new map is created for the same property/field.</param>
/// <returns>The property/field mapping.</returns>
public CsvPropertyMap Map(Type classType, MemberInfo member, bool useExistingMap = true)
{
if (useExistingMap)
{
var existingMap = PropertyMaps.Find(member);
if (existingMap != null)
{
return(existingMap);
}
}
var propertyMap = CsvPropertyMap.CreateGeneric(classType, member);
propertyMap.Data.Index = GetMaxIndex() + 1;
PropertyMaps.Add(propertyMap);
return(propertyMap);
}
/// <summary>
/// Maps a property to a CSV field.
/// </summary>
/// <param name="expression">The property to map.</param>
/// <returns>The property mapping.</returns>
protected virtual CsvPropertyMap Map(Expression <Func <T, object> > expression)
{
var property = ReflectionHelper.GetProperty(expression);
var existingMap = PropertyMaps.SingleOrDefault(m => m.Data.Property == property);
if (existingMap != null)
{
return(existingMap);
}
var propertyMap = new CsvPropertyMap(property);
propertyMap.Data.Index = GetMaxIndex() + 1;
PropertyMaps.Add(propertyMap);
return(propertyMap);
}
/// <summary>
/// Generates a <see cref="CsvClassMap"/> for the type.
/// </summary>
/// <param name="type">The ytpe to generate for the map.</param>
/// <returns>The generate map.</returns>
public virtual CsvClassMap AutoMap(Type type)
{
#if WINRT_4_5
var properties = type.GetProperties();
#else
var properties = type.GetProperties(propertyBindingFlags);
#endif
var mapType = typeof(CsvAutoClassMap <>).MakeGenericType(type);
var map = (CsvClassMap)ReflectionHelper.CreateInstance(mapType);
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 the type is not a one covered by our type converters
// and it has a parameterless constructor, create a
// reference map for it.
var refMap = AutoMap(property.PropertyType);
if (refMap.PropertyMaps.Count > 0 || refMap.ReferenceMaps.Count > 0)
{
map.ReferenceMaps.Add(new CsvPropertyReferenceMap(property, refMap));
}
}
else
{
var propertyMap = new CsvPropertyMap(property);
if (propertyMap.TypeConverterValue.CanConvertFrom(typeof(string)) ||
propertyMap.TypeConverterValue.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(new CsvPropertyMap(property));
}
}
}
return(map);
}
public virtual CsvPropertyMap PropertyMap <T>(Expression <Func <T, object> > expression)
{
var property = ReflectionHelper.GetProperty(expression);
var existingMap = PropertyMaps.SingleOrDefault(m =>
m.Data.Property == property ||
m.Data.Property.Name == property.Name &&
(m.Data.Property.DeclaringType.IsAssignableFrom(property.DeclaringType) || property.DeclaringType.IsAssignableFrom(m.Data.Property.DeclaringType)));
if (existingMap != null)
{
return(existingMap);
}
var propertyMap = new CsvPropertyMap(property);
propertyMap.Data.Index = GetMaxIndex() + 1;
PropertyMaps.Add(propertyMap);
return(propertyMap);
}
/// <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>
/// Creates a new instance using the given <see cref="CsvPropertyMap"/>.
/// </summary>
/// <param name="propertyMap">The property/field map the options are being applied to.</param>
public MapTypeConverterOption(CsvPropertyMap propertyMap)
{
this.propertyMap = propertyMap;
}
/// <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();
}
public PropertyMapBuilder(CsvClassMap <TClass> classMap, CsvPropertyMap <TClass, TProperty> propertyMap)
{
this.classMap = classMap;
this.propertyMap = propertyMap;
}
/// <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);
}