internal MapperOptions TryGetMapperOptions(Type t, MappingSides side)
{
if (mapperOptionsCache == null)
{
return(null);
}
var key = new OptionsCacheKey
{
Type = t,
Side = side
};
MapperOptions options;
if (!MapperOptionsCache.TryGetValue(key, out options))
{
options = MapperOptionsCache
.Where(kv => kv.Key.Type.IsAssignableFrom(key.Type) && kv.Key.Side == side)
.Select(kv => kv.Value).FirstOrDefault();
if (options != null)
{
if (mapperOptionsCache.ContainsKey(key))
{
mapperOptionsCache.AddOrUpdate(key, options, (k, v) => options);
}
}
}
return(options);
}
internal IEnumerable <VariableDefinition> GetAllVariablesForType(Type t, MappingSides side)
{
if (variableCache == null)
{
return(Enumerable.Empty <VariableDefinition>());
}
return(VariableCache.Where(v => v.Key.Type.IsAssignableFrom(t) && v.Key.Side == side).Select(v => v.Value));
}
internal void AddMapperOptions(Type t, MapperOptions options, MappingSides side)
{
var key = new OptionsCacheKey
{
Type = t,
Side = side
};
MapperOptionsCache[key] = options;
}
internal TypeModifierData TryGetTypeModifierData(Type t, MappingSides side)
{
TypeModifierData data;
var key = new TypeDataCacheKey
{
Type = t,
Side = side
};
if (!TypeModifierCache.TryGetValue(key, out data))
{
var item = TypeModifierCache.FirstOrDefault(s => s.Key.Type.IsAssignableFrom(t));
data = item.Value;
}
return(data);
}
internal void AddTypeModifierData(TypeModifierData data, MappingSides side)
{
TypeModifierData current;
var key = new TypeDataCacheKey
{
Type = data.Type,
Side = side
};
if (TypeModifierCache.TryGetValue(key, out current))
{
current.Message = data.Message ?? current.Message;
current.ThrowIfCondition = data.ThrowIfCondition ?? current.ThrowIfCondition;
}
else
{
TypeModifierCache[key] = data;
}
}
internal void AddVariableDefinition <T>(Type type, string name, Fluent.VariableDefinition <T> variable, MappingSides side)
{
var key = new VariableCacheKey
{
Name = name,
Type = type,
Side = side
};
var existing = VariableCache.Keys.FirstOrDefault(k => k.Name == name);
if (existing != null)
{
throw new InvalidOperationException(string.Format("Variable {0} already defined on type {1}", name, existing.Type));
}
VariableCache[key] = variable;
}
private void ProcessTypeModifierData(ParameterExpression param, List<Expression> expressions, MappingSides side)
{
var typeData = mapper.Data.TryGetTypeModifierData(param.Type, side);
if (typeData != null)
{
var typeExpr = ProcessTypeModifierData(typeData, param);
if (typeExpr != null)
{
expressions.Add(typeExpr);
}
}
var vars = mapper.Data.GetAllVariablesForType(param.Type, side);
foreach (var variable in vars)
{
var varExpr = Expression.Variable(variable.Type, "_" + variable.Name);
newParameters.Add(varExpr);
this.mapProcessor.Variables.Add(variable.Name, varExpr);
Expression initVar;
if (variable.Initialization != null)
{
initVar = Expression.Assign(varExpr, variable.Initialization.Body);
}
else
{
initVar = Expression.Assign(varExpr, Expression.Default(variable.Type));
}
expressions.Add(initVar);
}
}
