Exemple #1
0
            public override bool IsInvalid(MetaMemberPartBase nextPart)
            {
                if (!nextPart.SourceMember.IsEnumerable)
                {
                    return(true);
                }

                var elementType = nextPart.SourceMember.ElementType;

                return(elementType.IsSimple() &&
                       !MapperData.CanConvert(elementType, MapperData.TargetMember.Type));
            }
Exemple #2
0
            protected static bool TryCreate <TPart>(
                IMemberMapperData mapperData,
                ref MetaMemberPartBase metaMemberPart,
                Func <IMemberMapperData, TPart> partFactory)
                where TPart : CountMetaMemberPartBase
            {
                if (!mapperData.TargetMember.IsSimple || !mapperData.TargetMember.Type.IsNumeric())
                {
                    return(false);
                }

                metaMemberPart = partFactory.Invoke(mapperData);
                return(true);
            }
Exemple #3
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 #4
0
            public bool TrySetNextPart(MetaMemberPartBase nextPart)
            {
                if (NextPart != null)
                {
                    return(NextPart.TrySetNextPart(nextPart));
                }

                if (IsInvalid(nextPart))
                {
                    return(false);
                }

                SetNextPart(nextPart);
                return(true);
            }
Exemple #5
0
 public override bool IsInvalid(MetaMemberPartBase nextPart) => nextPart.IsInvalid(this);
Exemple #6
0
 public static bool TryCreateFor(IMemberMapperData mapperData, ref MetaMemberPartBase metaMemberPart)
 => TryCreate(mapperData, ref metaMemberPart, md => new NumberOfMetaMemberPart(md));
Exemple #7
0
 public override bool IsInvalid(MetaMemberPartBase nextPart)
 => !nextPart.SourceMember.IsEnumerable;
Exemple #8
0
            protected override void SetNextPart(MetaMemberPartBase nextPart)
            {
                _sourceMember = nextPart.SourceMember.GetElementMember();

                base.SetNextPart(nextPart);
            }
Exemple #9
0
 public override bool IsInvalid(MetaMemberPartBase nextPart) => false;
Exemple #10
0
 public abstract bool IsInvalid(MetaMemberPartBase nextPart);
Exemple #11
0
 protected virtual void SetNextPart(MetaMemberPartBase nextPart) => NextPart = nextPart;
Exemple #12
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);
        }