Beispiel #1
0
        private static void AddDerivedTargetTypeDataSources(
            IObjectMappingData declaredTypeMappingData,
            IEnumerable <Type> derivedTargetTypes,
            ICollection <IDataSource> derivedTypeDataSources)
        {
            var declaredTypeMapperData = declaredTypeMappingData.MapperData;

            derivedTargetTypes = derivedTargetTypes.OrderBy(t => t, MostToLeastDerived);

            foreach (var derivedTargetType in derivedTargetTypes)
            {
                var targetTypeCondition = declaredTypeMapperData.GetTargetIsDerivedTypeCheck(derivedTargetType);

                var derivedTypeMapping = GetReturnMappingResultExpression(
                    declaredTypeMappingData,
                    declaredTypeMapperData.SourceObject,
                    derivedTargetType,
                    out var derivedTypeMappingData);

                if (derivedTypeMapping == EmptyExpression)
                {
                    continue;
                }

                var derivedTargetTypeDataSource = new DerivedComplexTypeDataSource(
                    derivedTypeMappingData.MapperData.SourceMember,
                    targetTypeCondition,
                    derivedTypeMapping);

                derivedTypeDataSources.Add(derivedTargetTypeDataSource);
            }
        }
Beispiel #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));
        }
Beispiel #3
0
        private static void AddDeclaredSourceTypeDataSources(
            IEnumerable <DerivedTypePair> derivedTypePairs,
            IObjectMappingData declaredTypeMappingData,
            ICollection <IDataSource> derivedTypeDataSources)
        {
            var declaredTypeMapperData = declaredTypeMappingData.MapperData;

            derivedTypePairs = derivedTypePairs
                               .OrderBy(tp => tp.DerivedSourceType, MostToLeastDerived);

            foreach (var derivedTypePair in derivedTypePairs)
            {
                var condition = GetTypePairCondition(derivedTypePair, declaredTypeMapperData);

                var sourceValue = GetDerivedTypeSourceValue(
                    derivedTypePair,
                    declaredTypeMappingData,
                    out var sourceValueCondition);

                var derivedTypeMapping = DerivedMappingFactory.GetDerivedTypeMapping(
                    declaredTypeMappingData,
                    sourceValue,
                    derivedTypePair.DerivedTargetType,
                    out var derivedTypeMappingData);

                if (sourceValueCondition != null)
                {
                    derivedTypeMapping = derivedTypeMapping.ToIfFalseDefaultCondition(sourceValueCondition);
                }

                var returnMappingResult = GetReturnMappingResultExpression(declaredTypeMapperData, derivedTypeMapping);

                var derivedTypeMappingDataSource = new DerivedComplexTypeDataSource(
                    derivedTypeMappingData.MapperData.SourceMember,
                    condition,
                    returnMappingResult);

                derivedTypeDataSources.Add(derivedTypeMappingDataSource);

                if (!derivedTypeMappingDataSource.IsConditional)
                {
                    return;
                }
            }
        }