Exemple #1
0
            private Expression GetCondition(Expression enumerableAccess, EnumerableTypeHelper helper)
            {
                var enumerableCheck = HasMetaMemberPart.GetEnumerableCountCheck(enumerableAccess, helper);

                if (MapperData.RuleSet.Settings.GuardAccessTo(enumerableAccess))
                {
                    enumerableCheck = Expression.AndAlso(
                        enumerableAccess.GetIsNotDefaultComparison(),
                        enumerableCheck);
                }

                return(enumerableCheck);
            }
Exemple #2
0
            public static bool TryCreateFor(IMemberMapperData mapperData, ref MetaMemberPartBase metaMemberPart)
            {
                if (!mapperData.TargetMember.IsSimple)
                {
                    return(false);
                }

                if (!mapperData.CanConvert(typeof(bool), mapperData.TargetMember.Type))
                {
                    return(false);
                }

                metaMemberPart = new HasMetaMemberPart(mapperData);
                return(true);
            }
Exemple #3
0
        private static bool TryGetMetaMember(
            IList <string> memberNameParts,
            DataSourceFindContext context,
            out MetaMemberPartBase metaMember)
        {
            var currentMappingData  = default(IObjectMappingData);
            var currentSourceMember = default(IQualifiedMember);
            var currentTargetMember = default(QualifiedMember);
            var currentMemberPart   = metaMember = default(MetaMemberPartBase);

            Func <IQualifiedMember, QualifiedMember, IObjectMappingData, DataSourceFindContext, IObjectMappingData> currentMappingDataFactory =
                (sm, tm, md, c) => c.ChildMappingData.Parent;

            for (var i = memberNameParts.Count - 1; i >= 0; --i)
            {
                var memberNamePart = memberNameParts[i];

                switch (memberNamePart)
                {
                case HasMetaMemberPart.Name:
                    if (HasMetaMemberPart.TryCreateFor(context.MapperData, ref currentMemberPart))
                    {
                        break;
                    }

                    return(false);

                case FirstMetaMemberPart.Name:
                    currentMemberPart = new FirstMetaMemberPart(context.MapperData);
                    break;

                case LastMetaMemberPart.Name:
                    currentMemberPart = new LastMetaMemberPart(context.MapperData);
                    break;

                case CountMetaMemberPart.Name:
                    if (CountMetaMemberPart.TryCreateFor(context.MapperData, ref currentMemberPart))
                    {
                        break;
                    }

                    return(false);

                case NumberOfMetaMemberPart.Name:
                    if (NumberOfMetaMemberPart.TryCreateFor(context.MapperData, ref currentMemberPart))
                    {
                        break;
                    }

                    return(false);

                default:
                    currentMappingData = currentMappingDataFactory.Invoke(
                        currentSourceMember,
                        currentTargetMember,
                        currentMappingData,
                        context);

                    var currentMapperData = currentMappingData.MapperData;

                    var matchingTargetMember = GlobalContext.Instance
                                               .MemberCache
                                               .GetTargetMembers(currentMapperData.TargetType)
                                               .FirstOrDefault(m => m.Name == memberNamePart);

                    if (matchingTargetMember == null)
                    {
                        matchingTargetMember = GlobalContext.Instance
                                               .MemberCache
                                               .GetSourceMembers(currentMapperData.SourceType)
                                               .FirstOrDefault(m => m.Name == memberNamePart);

                        if (matchingTargetMember == null)
                        {
                            return(false);
                        }
                    }

                    currentTargetMember = currentMapperData.TargetMember.Append(matchingTargetMember);

                    var childMemberMapperData = new ChildMemberMapperData(currentTargetMember, currentMapperData);

                    var memberMappingData = currentMappingData.GetChildMappingData(childMemberMapperData);

                    currentSourceMember = SourceMemberMatcher.GetMatchFor(
                        memberMappingData,
                        out _,
                        searchParentContexts: false);

                    if (currentSourceMember == null)
                    {
                        return(false);
                    }

                    currentMemberPart = new SourceMemberMetaMemberPart(
                        currentSourceMember,
                        currentMapperData,
                        isRootMemberPart: currentMemberPart == null);

                    currentMappingDataFactory = (sm, tm, md, c) =>
                    {
                        var mappingData = ObjectMappingDataFactory.ForChild(sm, tm, 0, md);

                        return(sm.IsEnumerable
                                ? ObjectMappingDataFactory.ForElement(mappingData)
                                : ObjectMappingDataFactory.ForChild(sm, tm, 0, md));
                    };

                    break;
                }

                if (metaMember == null)
                {
                    metaMember = currentMemberPart;
                    continue;
                }

                if (!metaMember.TrySetNextPart(currentMemberPart))
                {
                    return(false);
                }
            }

            return(true);
        }