Esempio n. 1
0
        /// <summary>
        ///     Maps a property to another class map.
        /// </summary>
        /// <typeparam name="TClassMap">The type of the class map.</typeparam>
        /// <param name="expression">The expression.</param>
        /// <param name="constructorArgs">Constructor arguments used to create the reference map.</param>
        /// <returns>The reference mapping for the property.</returns>
        public virtual CsvPropertyReferenceMap References <TClassMap>(Expression <Func <T, object> > expression,
                                                                      params object[] constructorArgs) where TClassMap : CsvClassMap
        {
            var property = ReflectionHelper.GetProperty(expression);

            var existingMap = ReferenceMaps.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 map = ReflectionHelper.CreateInstance <TClassMap>(constructorArgs);

            map.CreateMap();
            map.ReIndex(GetMaxIndex() + 1);
            var reference = new CsvPropertyReferenceMap(property, map);

            ReferenceMaps.Add(reference);

            return(reference);
        }
Esempio n. 2
0
        /// <summary>
        /// Maps a property to another class map.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="expression">The expression.</param>
        /// <returns>The reference mapping for the property</returns>
        protected virtual CsvPropertyReferenceMap References(Type type, Expression <Func <T, object> > expression)
        {
            var property  = ReflectionHelper.GetProperty(expression);
            var reference = new CsvPropertyReferenceMap(type, property);

            ReferenceMaps.Add(reference);
            return(reference);
        }
Esempio n. 3
0
        /// <summary>
        /// Maps a property to another class map.
        /// </summary>
        /// <typeparam name="TClassMap">The type of the class map.</typeparam>
        /// <param name="expression">The expression.</param>
        /// <returns>The reference mapping for the property.</returns>
        protected virtual CsvPropertyReferenceMap <TClassMap> References <TClassMap>(Expression <Func <T, object> > expression) where TClassMap : CsvClassMap
        {
            var property  = ReflectionHelper.GetProperty(expression);
            var reference = new CsvPropertyReferenceMap <TClassMap>(property);

            ReferenceMaps.Add(reference);
            return(reference);
        }
Esempio n. 4
0
        /// <summary>
        /// Maps a property to another class map.
        /// </summary>
        /// <param name="map">Instance map</param>
        /// <param name="expression">The expression.</param>
        /// <returns>The reference mapping for the property</returns>
        protected virtual CsvPropertyReferenceMap References(CsvClassMap map, Expression <Func <T, object> > expression)
        {
            var property = ReflectionHelper.GetProperty(expression);

            map.CreateMap();
            map.ReIndex(GetMaxIndex() + 1);
            var reference = new CsvPropertyReferenceMap(property, map);

            ReferenceMaps.Add(reference);
            return(reference);
        }
Esempio n. 5
0
        /// <summary>
        /// Maps a property to another class map.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="expression">The expression.</param>
        /// <returns>The reference mapping for the property</returns>
        protected virtual CsvPropertyReferenceMap References(Type type, Expression <Func <T, object> > expression)
        {
            var property = ReflectionHelper.GetProperty(expression);
            var map      = (CsvClassMap)ReflectionHelper.CreateInstance(type);

            map.IndexStart = GetMaxIndex() + 1;
            map.CreateMap();
            var reference = new CsvPropertyReferenceMap(property, map);

            ReferenceMaps.Add(reference);
            return(reference);
        }
Esempio n. 6
0
        /// <summary>
        /// Maps a property to another class map.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="expression">The expression.</param>
        /// <param name="constructorArgs">Constructor arguments used to create the reference map.</param>
        /// <returns>The reference mapping for the property</returns>
        protected virtual CsvPropertyReferenceMap References(Type type, Expression <Func <T, object> > expression, params object[] constructorArgs)
        {
            var property = ReflectionHelper.GetProperty(expression);
            var map      = (CsvClassMap)ReflectionHelper.CreateInstance(type, constructorArgs);

            map.CreateMap();
            map.ReIndex(GetMaxIndex() + 1);
            var reference = new CsvPropertyReferenceMap(property, map);

            ReferenceMaps.Add(reference);
            return(reference);
        }
Esempio n. 7
0
        /// <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);
        }
Esempio n. 8
0
        /// <summary>
        /// Maps a property/field to another class map.
        /// </summary>
        /// <param name="classMapType">The type of the class map.</param>
        /// <param name="member">The property/field.</param>
        /// <param name="constructorArgs">Constructor arguments used to create the reference map.</param>
        /// <returns>The reference mapping for the property/field.</returns>
        public virtual CsvPropertyReferenceMap References(Type classMapType, MemberInfo member, params object[] constructorArgs)
        {
            if (!typeof(CsvClassMap).IsAssignableFrom(classMapType))
            {
                throw new InvalidOperationException($"Argument {nameof( classMapType )} is not a CsvClassMap.");
            }

            var existingMap = ReferenceMaps.Find(member);

            if (existingMap != null)
            {
                return(existingMap);
            }

            var map = (CsvClassMap)ReflectionHelper.CreateInstance(classMapType, constructorArgs);

            map.ReIndex(GetMaxIndex() + 1);
            var reference = new CsvPropertyReferenceMap(member, map);

            ReferenceMaps.Add(reference);

            return(reference);
        }
Esempio n. 9
0
        /// <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);
        }
Esempio n. 10
0
        /// <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>
        /// <param name="indexStart">The index starting point.</param>
        internal static void AutoMapInternal(CsvClassMap map, bool ignoreReferences, bool prefixReferenceHeaders, 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 properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);

            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 (refMap.PropertyMaps.Count > 0 || refMap.ReferenceMaps.Count > 0)
                    {
                        var referenceMap = new CsvPropertyReferenceMap(property, refMap);
                        if (prefixReferenceHeaders)
                        {
                            referenceMap.Prefix();
                        }

                        map.ReferenceMaps.Add(referenceMap);
                    }
                }
                else
                {
                    var propertyMap = new CsvPropertyMap(property);
                    propertyMap.Data.Index = map.GetMaxIndex() + 1;
                    if (!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);
        }
Esempio n. 11
0
        /// <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);
        }
Esempio n. 12
0
        /// <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 );
        }
Esempio n. 13
0
        /// <summary>
        /// Maps a property/field to another class map.
        /// </summary>
        /// <param name="classMapType">The type of the class map.</param>
        /// <param name="member">The property/field.</param>
        /// <param name="constructorArgs">Constructor arguments used to create the reference map.</param>
        /// <returns>The reference mapping for the property/field.</returns>
        public virtual CsvPropertyReferenceMap References( Type classMapType, MemberInfo member, params object[] constructorArgs )
        {
            if( !typeof( CsvClassMap ).IsAssignableFrom( classMapType ) )
            {
                throw new InvalidOperationException( $"Argument {nameof( classMapType )} is not a CsvClassMap." );
            }

            var existingMap = ReferenceMaps.Find( member );

            if( existingMap != null )
            {
                return existingMap;
            }

            var map = (CsvClassMap)ReflectionHelper.CreateInstance( classMapType, constructorArgs );
            map.ReIndex( GetMaxIndex() + 1 );
            var reference = new CsvPropertyReferenceMap( member, map );
            ReferenceMaps.Add( reference );

            return reference;
        }