private void AddDerivedSourceTypePopulations(
            IPopulationLoopData loopData,
            QualifiedMember dictionaryEntryMember,
            IObjectMappingData mappingData,
            IEnumerable <Type> derivedSourceTypes,
            ICollection <ParameterExpression> typedVariables,
            ICollection <Expression> mappingExpressions)
        {
            var sourceElement  = loopData.GetSourceElementValue();
            var mapNextElement = Expression.Continue(loopData.ContinueLoopTarget);

            var orderedDerivedSourceTypes = derivedSourceTypes
                                            .OrderBy(t => t, TypeComparer.MostToLeastDerived);

            foreach (var derivedSourceType in orderedDerivedSourceTypes)
            {
                var derivedSourceCheck      = new DerivedSourceTypeCheck(derivedSourceType);
                var typedVariableAssignment = derivedSourceCheck.GetTypedVariableAssignment(sourceElement);

                typedVariables.Add(derivedSourceCheck.TypedVariable);
                mappingExpressions.Add(typedVariableAssignment);

                var derivedTypeMapping    = GetDerivedTypeMapping(derivedSourceCheck, mappingData);
                var derivedTypePopulation = GetPopulation(derivedTypeMapping, dictionaryEntryMember, mappingData);
                var incrementCounter      = _wrappedBuilder.GetCounterIncrement();
                var derivedMappingBlock   = Expression.Block(derivedTypePopulation, incrementCounter, mapNextElement);
                var ifDerivedTypeReturn   = Expression.IfThen(derivedSourceCheck.TypeCheck, derivedMappingBlock);

                mappingExpressions.Add(ifDerivedTypeReturn);
            }
        }
Ejemplo n.º 2
0
        private static IDataSource GetMapFromConditionOrDefaultDataSource(
            IObjectMappingData declaredTypeMappingData,
            Expression condition,
            DerivedSourceTypeCheck derivedSourceCheck,
            IEnumerable <TypePairGroup> typePairGroups,
            Type targetType)
        {
            var declaredTypeMapperData = declaredTypeMappingData.MapperData;
            var typePairDataSources    = new List <IDataSource>();

            Expression         derivedTypeMapping;
            IObjectMappingData derivedTypeMappingData;

            foreach (var typePairGroup in typePairGroups)
            {
                var typePairsCondition =
                    declaredTypeMapperData.GetTypePairsCondition(typePairGroup.TypePairs) ??
                    declaredTypeMapperData.GetTargetValidCheckOrNull(typePairGroup.DerivedTargetType);

                derivedTypeMapping = GetReturnMappingResultExpression(
                    declaredTypeMappingData,
                    derivedSourceCheck.TypedVariable,
                    typePairGroup.DerivedTargetType,
                    out derivedTypeMappingData);

                var typePairDataSource = new DerivedComplexTypeDataSource(
                    derivedTypeMappingData.MapperData.SourceMember,
                    typePairsCondition,
                    derivedTypeMapping);

                typePairDataSources.Add(typePairDataSource);
            }

            var derivedTargetTypeDataSources = DataSourceSet.For(
                typePairDataSources,
                declaredTypeMapperData,
                ValueExpressionBuilders.ValueSequence);

            derivedTypeMapping = GetReturnMappingResultExpression(
                declaredTypeMappingData,
                derivedSourceCheck.TypedVariable,
                targetType,
                out derivedTypeMappingData);

            var derivedTypeMappings = Block(
                derivedTargetTypeDataSources.BuildValue(),
                derivedTypeMapping);

            return(new DerivedComplexTypeDataSource(
                       derivedTypeMappingData.MapperData.SourceMember,
                       derivedSourceCheck,
                       condition,
                       derivedTypeMappings,
                       declaredTypeMapperData));
        }
Ejemplo n.º 3
0
 public DerivedComplexTypeDataSource(
     IQualifiedMember sourceMember,
     DerivedSourceTypeCheck derivedSourceCheck,
     Expression condition,
     Expression value,
     IMemberMapperData declaredTypeMapperData)
     : base(sourceMember, new[] { derivedSourceCheck.TypedVariable }, value, condition)
 {
     _typedVariableAssignment = derivedSourceCheck
                                .GetTypedVariableAssignment(declaredTypeMapperData);
 }
        private static Expression GetDerivedTypeMapping(
            DerivedSourceTypeCheck derivedSourceCheck,
            IObjectMappingData mappingData)
        {
            var mappingTryCatch = DerivedMappingFactory.GetDerivedTypeMapping(
                mappingData,
                derivedSourceCheck.TypedVariable,
                mappingData.MapperData.TargetType);

            return(mappingTryCatch);
        }
Ejemplo n.º 5
0
        private static IDataSource GetReturnMappingResultDataSource(
            IObjectMappingData declaredTypeMappingData,
            Expression condition,
            DerivedSourceTypeCheck derivedSourceCheck,
            Type targetType)
        {
            var derivedTypeMapping = GetReturnMappingResultExpression(
                declaredTypeMappingData,
                derivedSourceCheck.TypedVariable,
                targetType,
                out var derivedTypeMappingData);

            return(new DerivedComplexTypeDataSource(
                       derivedTypeMappingData.MapperData.SourceMember,
                       derivedSourceCheck,
                       condition,
                       derivedTypeMapping,
                       declaredTypeMappingData.MapperData));
        }
Ejemplo n.º 6
0
        private static void AddDerivedSourceTypeDataSources(
            IEnumerable <Type> derivedSourceTypes,
            IObjectMappingData declaredTypeMappingData,
            IList <IDataSource> derivedTypeDataSources)
        {
            var declaredTypeMapperData = declaredTypeMappingData.MapperData;
            var insertionOffset        = derivedTypeDataSources.Count;

            var orderedDerivedSourceTypes = derivedSourceTypes
                                            .OrderBy(t => t, MostToLeastDerived);

            foreach (var derivedSourceType in orderedDerivedSourceTypes)
            {
                var derivedSourceCheck = new DerivedSourceTypeCheck(derivedSourceType);
                var targetType         = declaredTypeMapperData.TargetType.GetRuntimeTargetType(derivedSourceType);

                var outerCondition = derivedSourceCheck.TypeCheck;
                outerCondition = AppendTargetValidCheckIfAppropriate(outerCondition, targetType, declaredTypeMapperData);

                var derivedTypePairs = GetTypePairsFor(derivedSourceType, targetType, declaredTypeMapperData);

                IDataSource sourceVariableIsDerivedTypeDataSource;

                if (derivedTypePairs.None())
                {
                    sourceVariableIsDerivedTypeDataSource = GetReturnMappingResultDataSource(
                        declaredTypeMappingData,
                        outerCondition,
                        derivedSourceCheck,
                        targetType);

                    derivedTypeDataSources.Insert(sourceVariableIsDerivedTypeDataSource, insertionOffset);
                    continue;
                }

                var hasUnconditionalDerivedTargetTypeMapping = HasUnconditionalDerivedTargetTypeMapping(
                    derivedTypePairs,
                    declaredTypeMapperData,
                    out var unconditionalDerivedTargetType,
                    out var groupedTypePairs);

                if (hasUnconditionalDerivedTargetTypeMapping)
                {
                    sourceVariableIsDerivedTypeDataSource = GetReturnMappingResultDataSource(
                        declaredTypeMappingData,
                        outerCondition,
                        derivedSourceCheck,
                        unconditionalDerivedTargetType);

                    derivedTypeDataSources.Insert(sourceVariableIsDerivedTypeDataSource, insertionOffset);
                    continue;
                }

                sourceVariableIsDerivedTypeDataSource = GetMapFromConditionOrDefaultDataSource(
                    declaredTypeMappingData,
                    outerCondition,
                    derivedSourceCheck,
                    groupedTypePairs,
                    targetType);

                derivedTypeDataSources.Insert(sourceVariableIsDerivedTypeDataSource, insertionOffset);
            }
        }