/// <summary>
/// Auto maps the given map using constructor parameters.
/// </summary>
/// <param name="map">The map.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="mapParents">The list of parents for the map.</param>
/// <param name="indexStart">The index starting point.</param>
protected virtual void AutoMapConstructorParameters(ClassMap map, Configuration configuration, LinkedList <Type> mapParents, int indexStart = 0)
{
var type = map.GetGenericType();
var constructor = configuration.GetConstructor(map.ClassType);
var parameters = constructor.GetParameters();
foreach (var parameter in parameters)
{
var typeConverterType = configuration.TypeConverterCache.GetConverter(parameter.ParameterType).GetType();
var parameterMap = new ParameterMap(parameter);
//var memberTypeInfo = parameter.ParameterType.GetTypeInfo();
var memberType = parameter.ParameterType;
var isDefaultConverter = typeConverterType == typeof(DefaultTypeConverter);
//if( isDefaultConverter && ( memberTypeInfo.HasParameterlessConstructor() || memberTypeInfo.IsUserDefinedStruct() ) )
if (isDefaultConverter && (memberType.HasParameterlessConstructor() || memberType.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 (configuration.IgnoreReferences)
{
//throw new InvalidOperationException( $"Configuration '{nameof( configuration.IgnoreReferences )}' can't be true " +
throw new InvalidOperationException(string.Format("Configuration '{0}' can't be true ", nameof(configuration.IgnoreReferences)) +
"when using types without a default constructor. Constructor parameters " +
"are used and all members including references must be used.");
}
if (CheckForCircularReference(parameter.ParameterType, mapParents))
{
//throw new InvalidOperationException( $"A circular reference was detected in constructor paramter '{parameter.Name}'." +
throw new InvalidOperationException(string.Format("A circular reference was detected in constructor paramter '{0}'.", parameter.Name) +
"Since all parameters must be supplied for a constructor, this parameter can't be skipped.");
}
mapParents.AddLast(type);
var refMapType = typeof(DefaultClassMap <>).MakeGenericType(parameter.ParameterType);
var refMap = (ClassMap)ReflectionHelper.CreateInstance(refMapType);
AutoMapMembers(refMap, configuration, mapParents, Math.Max(map.GetMaxIndex() + 1, indexStart));
mapParents.Drop(mapParents.Find(type));
var referenceMap = new ParameterReferenceMap(parameter, refMap);
if (configuration.ReferenceHeaderPrefix != null)
{
//referenceMap.Data.Prefix = configuration.ReferenceHeaderPrefix( memberTypeInfo.MemberType(), memberTypeInfo.Name );
referenceMap.Data.Prefix = configuration.ReferenceHeaderPrefix(memberType, memberType.Name);
}
parameterMap.ReferenceMap = referenceMap;
}
else if (configuration.ShouldUseConstructorParameters(parameter.ParameterType))
{
mapParents.AddLast(type);
var constructorMapType = typeof(DefaultClassMap <>).MakeGenericType(parameter.ParameterType);
var constructorMap = (ClassMap)ReflectionHelper.CreateInstance(constructorMapType);
// Need to use Max here for nested types.
AutoMapConstructorParameters(constructorMap, configuration, mapParents, Math.Max(map.GetMaxIndex() + 1, indexStart));
mapParents.Drop(mapParents.Find(type));
parameterMap.ConstructorTypeMap = constructorMap;
}
else
{
parameterMap.Data.TypeConverterOptions = TypeConverterOptions.Merge(new TypeConverterOptions(), configuration.TypeConverterOptionsCache.GetOptions(parameter.ParameterType), parameterMap.Data.TypeConverterOptions);
parameterMap.Data.Index = map.GetMaxIndex() + 1;
}
map.ParameterMaps.Add(parameterMap);
}
map.ReIndex(indexStart);
}