public DefaultMemberMapper(MappingContainer container, MemberMapOptions options, MappingMember targetMember, MappingMember sourceMember,
ValueConverter converter)
: base(container, options, targetMember, converter)
{
Throw.IfArgumentNull(sourceMember, nameof(sourceMember));
_sourceMember = sourceMember;
}
/// <summary>
/// Applies the convention to type member mappings.
/// </summary>
/// <param name="context">The context to apply convensions.</param>
public void Apply(ConventionContext context)
{
MemberMapOptions options = context.Options == MemberMapOptions.Default ? Options : context.Options;
bool includeNonPublic = (options & MemberMapOptions.NonPublic) == MemberMapOptions.NonPublic;
MappingMember[] targetMembers =
context.TargetMembers.Where(member => member.CanWrite(includeNonPublic)).ToArray();
MappingMember[] sourceMembers =
context.SourceMembers.Where(member => member.CanRead(includeNonPublic)).ToArray();
StringComparison comparison = (options & MemberMapOptions.IgnoreCase) == MemberMapOptions.IgnoreCase
? StringComparison.CurrentCultureIgnoreCase
: StringComparison.CurrentCulture;
bool hierarchy = (options & MemberMapOptions.Hierarchy) == MemberMapOptions.Hierarchy;
foreach (MappingMember targetMember in targetMembers)
{
foreach (MappingMember sourceMember in sourceMembers)
{
if (string.Equals(sourceMember.MemberName, targetMember.MemberName, comparison) &&
(hierarchy || targetMember.MemberType.IsAssignableFrom(sourceMember.MemberType) ||
context.Converters.Get(sourceMember.MemberType, targetMember.MemberType) != null))
{
context.Mappings.Set(sourceMember, targetMember);
break;
}
}
}
}
protected MemberMapper(MappingContainer container, MemberMapOptions options, MappingMember targetMember, ValueConverter converter)
{
_container = container;
_options = options;
TargetMember = targetMember;
_converter = converter;
}
protected MemberMapper(ObjectMapper container, MemberMapOptions options, MappingMember targetMember,
Converter converter)
{
_container = container;
_options = options;
_targetMember = targetMember;
_converter = converter;
}
internal bool HasOption(MemberMapOptions options, MemberMapOptions option)
{
#if Net35
return((options & option) == option);
#else
return(options.HasFlag(option));
#endif
}
internal ConventionContext(MappingContainer container, Type sourceType, Type targetType, MemberMapOptions options)
{
_container = container;
SourceType = sourceType;
TargetType = targetType;
Options = options;
SourceMembers = new MappingMemberCollection(GetMembers(sourceType, true, false));
TargetMembers = new MappingMemberCollection(GetMembers(targetType, false, true));
}
public LambdaMemberMapper(MappingContainer container, MemberMapOptions options, MappingMember targetMember, Func <TSource, TMember> expression)
: base(container, options, targetMember, null)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
_expression = expression;
}
public ITypeMapper <TSource, TTarget> WithOptions(MemberMapOptions options)
{
if (_initialized)
{
throw new NotSupportedException("The type mapper has been initialized. Please configure options before the other configurations.");
}
_options = options;
return(this);
}
public ITypeMapper <TSource, TTarget> WithOptions(MemberMapOptions options)
{
if (_initialized)
{
throw new NotSupportedException(Strings.TypeMapper_Initialized);
}
_options = options;
return(this);
}
public DefaultMemberMapper(MappingContainer container, MemberMapOptions options, MappingMember targetMember, MappingMember sourceMember,
ValueConverter converter)
: base(container, options, targetMember, converter)
{
if (sourceMember == null)
{
throw new ArgumentNullException(nameof(sourceMember));
}
_sourceMember = sourceMember;
}
public DefaultMemberMapper(ObjectMapper container, MemberMapOptions options, MappingMember targetMember,
MappingMember sourceMember,
Converter converter)
: base(container, options, targetMember, converter)
{
if (sourceMember == null)
{
throw new ArgumentNullException("sourceMember");
}
_sourceMember = sourceMember;
}
public MemberMapperCollection(ObjectMapper container, MemberMapOptions options)
{
_container = container;
_options = options;
}
public LambdaMemberMapper(MappingContainer container, MemberMapOptions options, MappingMember targetMember, Func <TSource, TMember> expression)
: base(container, options, targetMember, null)
{
Throw.IfArgumentNull(expression, nameof(expression));
_expression = expression;
}
internal bool HasOption(MemberMapOptions options, MemberMapOptions option)
{
return(options.HasFlag(option));
}
private bool HasOption(MemberMapOptions option)
{
return(_options.HasFlag(option));
}
private bool HasOption(MemberMapOptions option)
{
return((_options & option) == option);
}
