public bool MapDestinationPropertyToSource(IProfileConfiguration options, TypeDetails sourceType, Type destType, Type destMemberType, string nameToSearch, LinkedList<IMemberGetter> resolvers, IMemberConfiguration parent )
{
string[] matches = DestinationMemberNamingConvention.SplittingExpression
.Matches(nameToSearch)
.Cast<Match>()
.Select(m => SourceMemberNamingConvention.ReplaceValue(m))
.ToArray();
MemberInfo matchingMemberInfo = null;
for (int i = 1; i <= matches.Length; i++)
{
NameSnippet snippet = CreateNameSnippet(matches, i);
matchingMemberInfo = parent.NameMapper.GetMatchingMemberInfo(sourceType, destType, destMemberType, snippet.First);
if (matchingMemberInfo != null)
{
resolvers.AddLast(matchingMemberInfo.ToMemberGetter());
var details = new TypeDetails(matchingMemberInfo.GetMemberType(), options);
var foundMatch = parent.MapDestinationPropertyToSource(options, details, destType, destMemberType, snippet.Second, resolvers);
if (!foundMatch)
resolvers.RemoveLast();
else
break;
}
}
return matchingMemberInfo != null;
}
public MemberValue(TypeDetails td, string memberName, object value, Exception exception)
{
Details = td;
MemberName = memberName;
this.Value = value;
this.Exception = exception;
}
public object Map(ResolutionContext context)
{
var source = context.SourceValue;
var sourceType = source.GetType();
var sourceTypeDetails = new TypeDetails(sourceType, _ => true, _ => true);
var membersDictionary = sourceTypeDetails.PublicReadAccessors.ToDictionary(p => p.Name, p => p.GetMemberValue(source));
var newContext = context.CreateTypeContext(null, membersDictionary, context.DestinationValue, membersDictionary.GetType(), context.DestinationType);
return context.Engine.Map(newContext);
}
public MemberInfo GetMatchingMemberInfo(IGetTypeInfoMembers getTypeInfoMembers, TypeDetails typeInfo, Type destType, Type destMemberType, string nameToSearch)
{
SourceMember[] sourceMembers;
if(!allSourceMembers.TryGetValue(typeInfo, out sourceMembers))
{
sourceMembers = getTypeInfoMembers.GetMemberInfos(typeInfo).Select(sourceMember => new SourceMember(sourceMember)).Where(s=>s.Attribute != null).ToArray();
allSourceMembers[typeInfo] = sourceMembers.Length == 0 ? Empty : sourceMembers;
}
return sourceMembers.FirstOrDefault(d => d.Attribute.IsMatch(typeInfo, d.Member, destType, destMemberType, nameToSearch)).Member;
}
public MemberInfo GetMatchingMemberInfo(IGetTypeInfoMembers getTypeInfoMembers, TypeDetails typeInfo, Type destType, Type destMemberType, string nameToSearch)
{
return
getTypeInfoMembers.GetMemberInfos(typeInfo)
.FirstOrDefault(
mi =>
typeof (ParameterInfo).IsAssignableFrom(destType) || !MethodCaseSensitive
? string.Compare(mi.Name, nameToSearch, StringComparison.OrdinalIgnoreCase) == 0
: string.CompareOrdinal(mi.Name, nameToSearch) == 0);
}
public bool MapDestinationPropertyToSource(ProfileMap options, TypeDetails sourceType, Type destType, Type destMemberType, string nameToSearch, LinkedList<MemberInfo> resolvers, IMemberConfiguration parent = null)
{
if (string.IsNullOrEmpty(nameToSearch))
return true;
var matchingMemberInfo = NameMapper.GetMatchingMemberInfo(sourceType, destType, destMemberType, nameToSearch);
if (matchingMemberInfo != null)
resolvers.AddLast(matchingMemberInfo);
return matchingMemberInfo != null;
}
public MemberInfo GetMatchingMemberInfo(TypeDetails typeInfo, Type destType, Type destMemberType, string nameToSearch)
{
MemberInfo memberInfo = null;
foreach (var namedMapper in NamedMappers)
{
memberInfo = namedMapper.GetMatchingMemberInfo(GetMembers, typeInfo, destType, destMemberType, nameToSearch);
if (memberInfo != null)
break;
}
return memberInfo;
}
public object Map(ResolutionContext context)
{
var dictionary = (StringDictionary)context.SourceValue;
object destination = context.Engine.CreateObject(context);
var destTypeDetails = new TypeDetails(context.DestinationType, _ => true, _ => true);
var members = from name in dictionary.Keys join member in destTypeDetails.PublicWriteAccessors on name equals member.Name select member;
foreach(var member in members)
{
object value = ReflectionHelper.Map(context, member, dictionary[member.Name]);
member.SetMemberValue(destination, value);
}
return destination;
}
public JsonMember(PropertyInfo property, int defaultOrder)
{
this.property = property;
var dataMember = property.GetCustomAttribute<DataMemberAttribute>();
Name = dataMember?.Name ?? property.Name;
Order = dataMember?.Order ?? defaultOrder;
EmitDefaultValue = dataMember?.EmitDefaultValue ?? true;
this.type = TypeDetails.Get(property.PropertyType);
}
public MemberInfo GetMatchingMemberInfo(IGetTypeInfoMembers getTypeInfoMembers, TypeDetails typeInfo, Type destType, Type destMemberType, string nameToSearch)
{
var possibleSourceNames = PossibleNames(nameToSearch, DestinationPrefixes, DestinationPostfixes);
var possibleDestNames = getTypeInfoMembers.GetMemberInfos(typeInfo).Select(mi => new { mi, possibles = PossibleNames(mi.Name, Prefixes, Postfixes) });
var all =
from sourceName in possibleSourceNames
from destName in possibleDestNames
select new { sourceName, destName };
var match =
all.FirstOrDefault(
pair => pair.destName.possibles.Any(p => string.Compare(p, pair.sourceName, StringComparison.OrdinalIgnoreCase) == 0));
return match?.destName.mi;
}
public bool MapDestinationPropertyToSource(IProfileConfiguration options, TypeDetails sourceType, Type destType,
string nameToSearch, LinkedList <MemberInfo> resolvers, IMemberConfiguration parent = null)
{
if (string.IsNullOrEmpty(nameToSearch))
{
return(true);
}
var matchingMemberInfo = NameMapper.GetMatchingMemberInfo(sourceType, destType, nameToSearch);
if (matchingMemberInfo != null)
{
resolvers.AddLast(matchingMemberInfo);
}
return(matchingMemberInfo != null);
}
public MemberInfo GetMatchingMemberInfo(IGetTypeInfoMembers getTypeInfoMembers, TypeDetails typeInfo, Type destType, Type destMemberType, string nameToSearch)
{
var possibleSourceNames = DestinationPostfixes.Any() || DestinationPrefixes.Any()
? PossibleNames(nameToSearch, DestinationPrefixes, DestinationPostfixes)
: new[] {nameToSearch};
var all =
from sourceName in possibleSourceNames
from destName in typeInfo.DestinationMemberNames
select new { sourceName, destName };
var match =
all.FirstOrDefault(
pair => pair.destName.Possibles.Any(p => string.Compare(p, pair.sourceName, StringComparison.OrdinalIgnoreCase) == 0));
return match?.destName.Member;
}
public static MemberDetails[] GetAllMembers(TypeDetails details)
{
var properties = details.Type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
var fields = details.Type.GetFields(BindingFlags.Instance | BindingFlags.Public);
var members = properties
.Where(pi => pi.GetGetMethod() != null && pi.GetIndexParameters().Length == 0)
.Select(pi => new MemberDetails(pi));
members = members.Concat(
fields.Select(fi => new MemberDetails(fi))
);
return members.ToArray();
}
public bool MapDestinationPropertyToSource(IProfileConfiguration options, TypeDetails sourceType, Type destType,
string nameToSearch, LinkedList <MemberInfo> resolvers)
{
var foundMap = false;
foreach (var memberMapper in MemberMappers)
{
foundMap = memberMapper.MapDestinationPropertyToSource(options, sourceType, destType, nameToSearch,
resolvers, this);
if (foundMap)
{
break;
}
}
return(foundMap);
}
public CreateInstance GetCreateInstanceSingleton(TypeDetails typeDetails)
{
#if SILVERLIGHT
var method = new DynamicMethod("CreateInstance" + typeDetails.ImplementType.Name, typeof(void), new[] { typeof(TypeDetails), typeof(object).MakeByRefType() });
#else
var method = new DynamicMethod("CreateSinlgetonInstance" + typeDetails.ImplementType.Name, MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, typeof(void), new[] { typeof(TypeDetails), typeof(object).MakeByRefType() }, typeof(TypeDetails), true);
#endif
var ilGenerator = method.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_1);
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Ldfld, typeof(TypeDetails).GetField("SingletonObject"));
ilGenerator.Emit(OpCodes.Stind_Ref);
ilGenerator.Emit(OpCodes.Ret);
return((CreateInstance)method.CreateDelegate(typeof(CreateInstance)));
}
private static TDestination Map <TDestination>(StringDictionary source, ResolutionContext context)
{
TDestination destination = context.Mapper.CreateObject <TDestination>(context);
var destTypeDetails = new TypeDetails(context.DestinationType, _ => true, _ => true);
var members = from name in source.Keys
join member in destTypeDetails.PublicWriteAccessors on name equals member.Name
select member;
var memberContext = new ResolutionContext(context);
foreach (var member in members)
{
object value = memberContext.Map(member, source[member.Name]);
member.SetMemberValue(destination, value);
}
return(destination);
}
private static TDestination Map <TDestination>(StringDictionary source, TDestination destination, ResolutionContext context)
{
destination = destination == null?context.Mapper.CreateObject <TDestination>() : destination;
var destTypeDetails = new TypeDetails(typeof(TDestination), _ => true, _ => true);
var members = from name in source.Keys
join member in destTypeDetails.PublicWriteAccessors on name equals member.Name
select member;
foreach (var member in members)
{
var value = context.MapMember(member, source[member.Name], destination);
member.SetMemberValue(destination, value);
}
return(destination);
}
public static IDbValueConverter Get(Type type)
{
var details = TypeDetails.Get(type);
if (details.IsEnum)
{
return(new EnumConverter());
}
if (!TryGet(details.NonNullType, out IDbValueConverter converter))
{
throw new ConversionException($"No converter found for '{type.Name}'.");
}
return(converter);
}
public static IcnsType FindType(int width, int height, int bpp, TypeDetails details)
{
for (int i = 0; i < ALL_TYPES.Length; i++)
{
IcnsType type = ALL_TYPES[i];
if (type.width == width &&
type.height == height &&
type.bitsPerPixel == bpp &&
type.details == details)
{
return(type);
}
}
return(null);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var dictionary = (StringDictionary)context.SourceValue;
var destination = mapper.CreateObject(context);
var destTypeDetails = new TypeDetails(context.DestinationType, _ => true, _ => true);
var members = from name in dictionary.Keys
join member in destTypeDetails.PublicWriteAccessors on name equals member.Name
select member;
foreach (var member in members)
{
var value = ReflectionHelper.Map(member, dictionary[member.Name]);
ReflectionHelper.SetMemberValue(member, destination, value);
}
return(destination);
}
protected List <SyntaxToken> FormatTypeDetails(TypeDetails details)
{
List <SyntaxToken> tokens = new List <SyntaxToken>();
// If the type is an array the type ref details are no longer valid
if (details.IsArray || details.IsMultidemensionalArray)
{
if (details.IsArray)
{
tokens.AddRange(this.FormatTypeDetails(details.ArrayOf));
tokens.Add(Constants.ArrayEmpty);
}
if (details.IsMultidemensionalArray)
{
tokens.AddRange(this.FormatTypeDetails(details.ArrayOf));
tokens.Add(Constants.ArrayStart);
tokens.Add(new SyntaxToken(new String(',', (int)details.ArrayShape.Rank - 1), SyntaxTokens.Text));
tokens.Add(Constants.ArrayEnd);
}
}
else
{
tokens.Add(this.FormatTypeName(details.Type));
if (details.IsGenericInstance)
{
tokens.Add(Constants.GenericStart);
tokens.Add(Constants.Space);
for (int i = 0; i < details.GenericParameters.Count; i++)
{
if (i != 0)
{
tokens.Add(new SyntaxToken(", ", SyntaxTokens.Text));
}
tokens.AddRange(this.FormatTypeDetails(details.GenericParameters[i]));
}
tokens.Add(Constants.GenericEnd);
}
}
// Pointers are not supported in visual basic .net. This would mean that
// this element would not be available to a vb.net application. For now
// we will just not show it.
//if (details.IsPointer) {
// tokens.Add(new SyntaxToken("*", SyntaxTokens.Text));
//}
return(tokens);
}
public CreateInstance GetCreateInstanceWithInterception(TypeDetails typeDetailsLocal, CreateInstance delegateToBeIncepted)
{
var argTypes = typeDetailsLocal.DependenciesTypeDetails.Select(typeDetails => typeDetails.ImplementType);
var createInterceptedInstance = GetCreateInterceptedInstance(typeDetailsLocal);
return((TypeDetails typeDetails, out object output) =>
{
var invocation = new Instantiation(typeDetails, delegateToBeIncepted, createInterceptedInstance)
{
argTypes = argTypes,
DependenciesTypeDetails = typeDetails.DependenciesTypeDetails,
};
typeDetailsLocal.Interceptor.Intercept(invocation);
output = invocation.instance;
});
}
public MemberInfo GetMatchingMemberInfo(IGetTypeInfoMembers getTypeInfoMembers, TypeDetails typeInfo, Type destType, Type destMemberType, string nameToSearch)
{
var member = typeInfo.GetMember(nameToSearch);
if (member != null)
{
return(member);
}
foreach (var possibleSourceName in TypeDetails.PossibleNames(nameToSearch, _destinationPrefixes, _destinationPostfixes))
{
if ((member = typeInfo.GetMember(possibleSourceName)) != null)
{
return(member);
}
}
return(null);
}
public MemberInfo GetMatchingMemberInfo(TypeDetails sourceTypeDetails, Type destType, Type destMemberType, string nameToSearch)
{
var possibleSourceNames = PossibleNames(nameToSearch);
var possibleDestNames = sourceTypeDetails.ReadAccessors.Select(mi => new { mi, possibles = PossibleNames(mi.Name) }).ToArray();
foreach (var sourceName in possibleSourceNames)
{
foreach (var destName in possibleDestNames)
{
if (Array.Exists(destName.possibles, name => string.Compare(name, sourceName, StringComparison.OrdinalIgnoreCase) == 0))
{
return(destName.mi);
}
}
}
return(null);
}
public bool MapDestinationPropertyToSource(ProfileMap options, TypeDetails sourceType, Type destType, Type destMemberType, string nameToSearch, LinkedList <MemberInfo> resolvers, IMemberConfiguration parent)
{
if (map.TryGetValue(new TypePair(sourceType.Type, destType), out var properties))
{
foreach (var property in properties)
{
resolvers.AddLast(property);
var memberType = options.CreateTypeDetails(property.PropertyType);
if (parent.MapDestinationPropertyToSource(options, memberType, destType, destMemberType, nameToSearch, resolvers))
{
return(true);
}
resolvers.RemoveLast();
}
}
return(false);
}
private static string AddResponseType(TypeDetails typeDetails)
{
if (typeDetails.Name == "boolean" || typeDetails.Name == "string" || typeDetails.ToString() == "number")
{
string convert = "x";
if (typeDetails.Name == "boolean")
{
convert = "JSON.parse(x) === true";
}
else if (typeDetails.Name == "number")
{
convert = "Number(x)";
}
string map = String.Format(".pipe(map( x => {0}))", convert);
return(", { responseType: 'text' })" + map);
}
return(")");
}
private DelegateFactory.CreateInstance GetCreateInstance(TypeDetails typeDetails, IDictionary <Type, IList <TypeDetails> > dependencyMap)
{
if (typeDetails.IsSingleton && !typeDetails.IsLazySingleton)
{
if (typeDetails.CreateInstanceDelegate == null)
{
GetCreateInstanceDelegate(typeDetails, dependencyMap).Invoke(typeDetails, out typeDetails.SingletonObject);
}
return(_delegateFactory.GetCreateInstanceSingleton(typeDetails));
}
if (typeDetails.LamdaFunction != null)
{
return(_delegateFactory.GetCreateInstanceFromLambdaFunction(typeDetails));
}
return(GetCreateInstanceDelegate(typeDetails, dependencyMap));
}
public static IcnsType FindType(int type, TypeDetails ignoreDetails)
{
for (int i = 0; i < ALL_TYPES.Length; i++)
{
if (ALL_TYPES[i].type != type)
{
continue;
}
if (ignoreDetails != 0 && ALL_TYPES[i].Details == ignoreDetails)
{
continue;
}
return(ALL_TYPES[i]);
}
return(null);
}
public new TypeDetails GetType()
{
TypeDetails details = null;
if (_get != null)
{
ReturnTypeSignatureToken returnType = (ReturnTypeSignatureToken)_get.Signiture.Tokens.Find(
t => t.TokenType == SignatureTokens.ReturnType
);
details = returnType.GetTypeDetails(_get);
}
else
{
ParamSignatureToken delegateType = _set.Signiture.GetParameterTokens()[0];
details = delegateType.GetTypeDetails(_set);
}
return(details);
}
protected List <SyntaxToken> FormatTypeDetails(TypeDetails details)
{
List <SyntaxToken> tokens = new List <SyntaxToken>();
// If the type is an array the type ref details are no longer valid
if (details.IsArray || details.IsMultidemensionalArray)
{
if (details.IsArray)
{
tokens.AddRange(FormatTypeDetails(details.ArrayOf));
tokens.Add(Constants.ArrayEmpty);
}
if (details.IsMultidemensionalArray)
{
tokens.AddRange(FormatTypeDetails(details.ArrayOf));
tokens.Add(Constants.ArrayStart);
tokens.Add(new SyntaxToken(new String(',', (int)details.ArrayShape.Rank - 1), SyntaxTokens.Text));
tokens.Add(Constants.ArrayEnd);
}
}
else
{
tokens.Add(FormatTypeName(details.Type));
if (details.IsGenericInstance)
{
tokens.Add(Constants.GenericStart);
for (int i = 0; i < details.GenericParameters.Count; i++)
{
if (i != 0)
{
tokens.Add(new SyntaxToken(", ", SyntaxTokens.Text));
}
tokens.AddRange(FormatTypeDetails(details.GenericParameters[i]));
}
tokens.Add(Constants.GenericEnd);
}
}
if (details.IsPointer)
{
tokens.Add(Constants.KeywordPointer);
}
return(tokens);
}
private void DependencyCreateInstanceResolver(TypeDetails typeDetails, IDictionary <Type, IList <TypeDetails> > dependencyMap)
{
var constructorParameters = typeDetails.ImplementType.GetConstructors().First().GetParameters();
int index = 0;
constructorParameters.Each(x =>
{
var parameterTypeDetails = GetParameterTypeDetails(dependencyMap, x);
if (parameterTypeDetails.CreateInstanceDelegate == null)
{
parameterTypeDetails.CreateInstanceDelegate = GetCreateInstance(parameterTypeDetails, dependencyMap);
}
typeDetails.DependenciesTypeDetails[index] = parameterTypeDetails;
index++;
});
}
public bool MapDestinationPropertyToSource(ProfileMap options, TypeDetails sourceType, Type destType, Type destMemberType, string nameToSearch, LinkedList <MemberInfo> resolvers, IMemberConfiguration parent)
{
if (TypeExtensions.IsAssignableFrom(typeof(IDataRecord), sourceType.Type))
{
var returnType = destMemberType;
// TODO: The return type really should be the type of the field in the reader.
// TODO: Remove the previous comment. We're going to add value conversion functionality, so using the destination
// type here can be done safely.
var method = new DynamicMethod($"Get{nameToSearch.Replace(".", string.Empty) }", returnType, new[] { typeof(IDataRecord) }, true);
var il = method.GetILGenerator();
EmitPropertyMapping(il, destType, destMemberType, nameToSearch);
il.Emit(Ret);
resolvers.AddLast(method);
return(true);
}
return(false);
}
private void Populate(Match match, TypeDetails typeDetails)
{
DetailList = new List <String>();
switch (typeDetails)
{
case TypeDetails.MatchType:
Title = "Pick competition";
DetailList = match.MatchTypes.Select(x => x.MatchTypeName).ToList();
break;
case TypeDetails.Team:
Title = "Pick team";
DetailList = match.Teams.OrderBy(x => x.TeamName).Select(x => x.TeamName).ToList();
break;
case TypeDetails.Categorie:
Title = "Pick team categorie";
DetailList = match.Categories.Select(x => x.CategorieName).ToList();
break;
case TypeDetails.Squad:
Title = "Pick team squad";
DetailList = match.Squads.Select(x => x.SquadName).ToList();
break;
case TypeDetails.Location:
Title = "Pick match location";
DetailList = match.Teams.OrderBy(x => x.TeamLocation).Select(x => x.TeamLocation).Distinct().ToList();
break;
case TypeDetails.MatchStatus:
Title = "Pick match status";
DetailList = match.Statuses?.Where(x => x.StatusID == 0 || x.StatusID == 13 || x.StatusID == 14).Select(x => x.StatusName).ToList();
break;
case TypeDetails.LiveMatchPeriod:
Title = "Pick live match status";
DetailList = match.Statuses?.Where(x => x.StatusID > 0 && x.StatusID < 13).Select(x => x.StatusName).ToList();
break;
}
}
public bool MapDestinationPropertyToSource(IProfileConfiguration options, TypeDetails sourceType, Type destType,
string nameToSearch, LinkedList <MemberInfo> resolvers, IMemberConfiguration parent)
{
var matches = DestinationMemberNamingConvention.SplittingExpression
.Matches(nameToSearch)
.Cast <Match>()
.Select(m => SourceMemberNamingConvention.ReplaceValue(m))
.ToArray();
MemberInfo matchingMemberInfo = null;
for (var i = 1; i <= matches.Length; i++)
{
var snippet = CreateNameSnippet(matches, i);
matchingMemberInfo = parent.NameMapper.GetMatchingMemberInfo(sourceType, destType, snippet.First);
if (matchingMemberInfo != null)
{
resolvers.AddLast(matchingMemberInfo);
var foundMatch = parent.MapDestinationPropertyToSource(options,
TypeMapFactory.GetTypeInfo(matchingMemberInfo.GetMemberType(), options), destType,
snippet.Second, resolvers);
if (!foundMatch)
{
resolvers.RemoveLast();
}
else
{
break;
}
}
}
return(matchingMemberInfo != null);
}
public MemberInfo GetMatchingMemberInfo(
TypeDetails sourceTypeDetails,
Type destType,
Type destMemberType,
string nameToSearch
)
{
MemberInfo memberInfo = null;
foreach (var namedMapper in NamedMappers)
{
memberInfo = namedMapper.GetMatchingMemberInfo(
sourceTypeDetails,
destType,
destMemberType,
nameToSearch
);
if (memberInfo != null)
{
break;
}
}
return(memberInfo);
}
public MemberInfo GetMatchingMemberInfo(
TypeDetails sourceTypeDetails,
Type destType,
Type destMemberType,
string nameToSearch
)
{
MemberInfo member;
foreach (
var possibleSourceName in TypeDetails.PossibleNames(
nameToSearch,
DestinationPrefixes,
DestinationPostfixes
)
)
{
if ((member = sourceTypeDetails.GetMember(possibleSourceName)) != null)
{
return(member);
}
}
return(null);
}
public abstract bool IsMatch(TypeDetails typeInfo, MemberInfo memberInfo, Type destType, Type destMemberType, string nameToSearch);
public MemberInfo GetMatchingMemberInfo(IGetTypeInfoMembers getTypeInfoMembers, TypeDetails typeInfo, Type destType, Type destMemberType, string nameToSearch)
{
return
getTypeInfoMembers.GetMemberInfos(typeInfo)
.FirstOrDefault(mi => string.Compare(mi.Name, nameToSearch, StringComparison.OrdinalIgnoreCase) == 0);
}
public MemberInfo GetMatchingMemberInfo(IGetTypeInfoMembers getTypeInfoMembers, TypeDetails typeInfo, Type destType, Type destMemberType, string nameToSearch)
{
return
(getTypeInfoMembers.GetMemberInfos(typeInfo)
.FirstOrDefault(
mi =>
typeof(ParameterInfo).IsAssignableFrom(destType) || !MethodCaseSensitive
? string.Compare(mi.Name, nameToSearch, StringComparison.OrdinalIgnoreCase) == 0
: string.CompareOrdinal(mi.Name, nameToSearch) == 0));
}
public MemberInfo GetMatchingMemberInfo(IGetTypeInfoMembers getTypeInfoMembers, TypeDetails typeInfo, Type destType, Type destMemberType, string nameToSearch)
{
var possibleSourceNames = DestinationPostfixes.Any() || DestinationPrefixes.Any()
? PossibleNames(nameToSearch, DestinationPrefixes, DestinationPostfixes)
: new[] { nameToSearch };
var all =
from sourceName in possibleSourceNames
from destName in typeInfo.DestinationMemberNames
select new { sourceName, destName };
var match =
all.FirstOrDefault(
pair => pair.destName.Possibles.Any(p => string.Compare(p, pair.sourceName, StringComparison.OrdinalIgnoreCase) == 0));
return(match?.destName.Member);
}
public override bool IsMatch(TypeDetails typeInfo, MemberInfo memberInfo, Type destType, Type destMemberType, string nameToSearch)
{
return string.Compare(MatchingName, nameToSearch, StringComparison.OrdinalIgnoreCase) == 0;
}
private MemberDetails(FieldInfo fi)
{
FieldInfo = fi;
Name = fi.Name;
TypeDetails = TypeDetails.Get(fi.FieldType);
}
public bool MapDestinationPropertyToSource(
ProfileMap options,
TypeDetails sourceType,
Type destType,
Type destMemberType,
string nameToSearch,
List <MemberInfo> resolvers,
IMemberConfiguration parent,
bool isReverseMap
)
{
var destinationMemberNamingConvention = isReverseMap
? SourceMemberNamingConvention
: DestinationMemberNamingConvention;
var sourceMemberNamingConvention = isReverseMap
? DestinationMemberNamingConvention
: SourceMemberNamingConvention;
var matches =
destinationMemberNamingConvention.SplittingExpression
?.Matches(nameToSearch)
.Cast <Match>()
.Select(m => sourceMemberNamingConvention.ReplaceValue(m))
.ToArray() ?? Array.Empty <string>();
MemberInfo matchingMemberInfo = null;
for (var i = 1; i <= matches.Length; i++)
{
var first = string.Join(
sourceMemberNamingConvention.SeparatorCharacter,
matches.Take(i).Select(SplitMembers)
);
var second = string.Join(
sourceMemberNamingConvention.SeparatorCharacter,
matches.Skip(i).Select(SplitMembers)
);
matchingMemberInfo = parent.NameMapper.GetMatchingMemberInfo(
sourceType,
destType,
destMemberType,
first
);
if (matchingMemberInfo != null)
{
resolvers.Add(matchingMemberInfo);
var details = options.CreateTypeDetails(matchingMemberInfo.GetMemberType());
var foundMatch = parent.MapDestinationPropertyToSource(
options,
details,
destType,
destMemberType,
second,
resolvers,
isReverseMap
);
if (!foundMatch)
{
resolvers.RemoveAt(resolvers.Count - 1);
}
else
{
break;
}
}
}
return(matchingMemberInfo != null);
string SplitMembers(string value) =>
sourceMemberNamingConvention.SplittingExpression.Replace(
value,
sourceMemberNamingConvention.ReplaceValue
);
}
public IEnumerable<MemberInfo> GetMemberInfos(TypeDetails typeInfo)
{
return !_predicates.Any()
? typeInfo.AllMembers
: typeInfo.AllMembers.Where(m => _predicates.All(p => p(m))).ToList();
}
private MemberDetails(PropertyInfo pi)
{
PropertyInfo = pi;
Name = pi.Name;
TypeDetails = TypeDetails.Get(pi.PropertyType);
}
public MemberDescriptor(string name, Type type, bool isKey = false)
{
Name = name;
PropertyName = name;
if (isKey)
{
flags |= DatumFlags.Key;
}
this.typeDetails = TypeDetails.Get(type);
}
public MemberInfo GetMatchingMemberInfo(IGetTypeInfoMembers getTypeInfoMembers, TypeDetails typeInfo, Type destType, Type destMemberType, string nameToSearch)
{
Cache.GetOrAdd(typeInfo, ti => getTypeInfoMembers.GetMemberInfos(ti).ToDictionary(mi => mi, mi => mi.GetCustomAttributes(typeof(SourceToDestinationMapperAttribute), true).OfType<SourceToDestinationMapperAttribute>()));
return Cache[typeInfo].FirstOrDefault(kp => kp.Value.Any(_ => _.IsMatch(typeInfo, kp.Key, destType, destMemberType, nameToSearch))).Key;
}
private MemberDescriptor(string name, Type _type, MemberInfo _member, int order)
{
#region Preconditions
if (_type == null) throw new ArgumentNullException(nameof(_type));
if (_member == null) throw new ArgumentNullException(nameof(_member));
#endregion
typeDetails = TypeDetails.Get(_type);
Order = order;
if (typeDetails.IsNullable || !typeDetails.IsValueType)
{
flags |= DatumFlags.Optional;
}
Name = name;
PropertyName = _member.Name;
foreach (var a in _member.GetCustomAttributes())
{
if (a is ColumnAttribute)
{
var columnAttribute = (ColumnAttribute)a;
if (columnAttribute.Name != null)
{
Name = columnAttribute.Name;
}
if (columnAttribute.Order != 0)
{
Order = columnAttribute.Order;
}
}
else if (a is MutableAttribute)
{
flags |= DatumFlags.Mutable;
}
else if (a is AsciiAttribute)
{
flags |= DatumFlags.Ascii;
}
else if (a is IdentityAttribute)
{
var identity = (IdentityAttribute)a;
flags |= (DatumFlags.Identity | DatumFlags.Key);
flags &= ~DatumFlags.Mutable; // An identity may not be changed
flags &= ~DatumFlags.Optional;
Identity = identity;
}
else if (a is KeyAttribute || a is cm::KeyAttribute)
{
flags |= DatumFlags.Key;
flags &= ~DatumFlags.Mutable; // An identity may not be changed
}
else if (a is TimestampAttribute)
{
flags |= DatumFlags.Timestamp | DatumFlags.Computed;
flags &= ~DatumFlags.Mutable; // An identity may not be changed
}
else if (a is cm::RequiredAttribute)
{
flags &= ~DatumFlags.Optional;
}
else if (a is FixedSizeAttribute)
{
flags &= ~DatumFlags.FixedSize;
}
else if (a is cm::MaxLengthAttribute)
{
var m = (cm::MaxLengthAttribute)a;
Size = m.Length;
}
else if (a is cm::StringLengthAttribute)
{
var m = (cm::StringLengthAttribute)a;
Size = m.MaximumLength;
}
else if (a is VersionAttribute)
{
flags |= DatumFlags.Version;
flags &= ~DatumFlags.Optional;
}
else if (a is PrecisionAttribute)
{
var p = a as PrecisionAttribute;
Precision = p.Precision;
Scale = p.Scale;
}
else if (a is UniqueAttribute)
{
flags |= DatumFlags.Unique | DatumFlags.Indexed;
}
else if (a is IndexedAttribute)
{
flags |= DatumFlags.Indexed;
}
}
if (Size == null)
{
Size = GetSize(_type);
}
}
public abstract bool IsMatch(TypeDetails typeInfo, MemberInfo memberInfo, Type destType, Type destMemberType, string nameToSearch);
public MemberInfo GetMatchingMemberInfo(TypeDetails sourceTypeDetails, Type destType, Type destMemberType, string nameToSearch)
{
if (!_allSourceMembers.TryGetValue(sourceTypeDetails, out SourceMember[] sourceMembers))
public IEnumerable <MemberInfo> GetMemberInfos(TypeDetails typeInfo)
{
return(!_predicates.Any()
? typeInfo.AllMembers
: typeInfo.AllMembers.Where(m => _predicates.All(p => p(m))).ToList());
}
private static IEnumerable<MemberInfo> AllMembers(TypeDetails typeInfo)
{
return typeInfo.PublicReadAccessors.Concat(typeInfo.PublicNoArgMethods).Concat(typeInfo.PublicNoArgExtensionMethods).ToList();
}
