Example #1
0
        private static void CheckForCycles(
            IGlobalConfiguration configurationProvider,
            TypeMap typeMap,
            HashSet <TypeMap> typeMapsPath
            )
        {
            if (typeMap.DestinationTypeOverride != null)
            {
                CheckForCycles(
                    configurationProvider,
                    configurationProvider.GetIncludedTypeMap(typeMap.GetAsPair()),
                    typeMapsPath
                    );
                return;
            }
            var inlineWasChecked = typeMap.WasInlineChecked;

            typeMap.WasInlineChecked = true;
            typeMapsPath.Add(typeMap);
            foreach (var memberMap in MemberMaps())
            {
                var memberTypeMap = ResolveMemberTypeMap(memberMap);
                if (memberTypeMap == null || memberTypeMap.HasTypeConverter)
                {
                    continue;
                }
                if (
                    !inlineWasChecked &&
                    typeMapsPath.Count % configurationProvider.MaxExecutionPlanDepth == 0
                    )
                {
                    memberMap.Inline = false;
                    Debug.WriteLine(
                        $"Resetting Inline: {memberMap.DestinationName} in {typeMap.SourceType} - {typeMap.DestinationType}"
                        );
                }
                if (memberTypeMap.PreserveReferences || memberTypeMap.MapExpression != null)
                {
                    continue;
                }
                if (typeMapsPath.Contains(memberTypeMap))
                {
                    if (memberTypeMap.SourceType.IsValueType)
                    {
                        if (memberTypeMap.MaxDepth == 0)
                        {
                            memberTypeMap.MaxDepth = 10;
                        }
                        typeMapsPath.Remove(typeMap);
                        return;
                    }
                    memberTypeMap.PreserveReferences = true;
                    Trace(typeMap, memberTypeMap);
                    foreach (
                        var derivedTypeMap in configurationProvider.GetIncludedTypeMaps(
                            memberTypeMap
                            )
                        )
                    {
                        derivedTypeMap.PreserveReferences = true;
                        Trace(typeMap, derivedTypeMap);
                    }
                }
                CheckForCycles(configurationProvider, memberTypeMap, typeMapsPath);
            }
            typeMapsPath.Remove(typeMap);
            return;

            IEnumerable <MemberMap> MemberMaps()
            {
                var memberMaps = typeMap.MemberMaps;

                if (typeMap.HasDerivedTypesToInclude)
                {
                    memberMaps = memberMaps.Concat(
                        configurationProvider
                        .GetIncludedTypeMaps(typeMap)
                        .SelectMany(tm => tm.MemberMaps)
                        );
                }
                return(memberMaps);
            }

            TypeMap ResolveMemberTypeMap(MemberMap memberMap)
            {
                if (!memberMap.CanResolveValue)
                {
                    return(null);
                }
                var types = memberMap.Types();

                if (types.ContainsGenericParameters)
                {
                    return(null);
                }
                return(configurationProvider.ResolveAssociatedTypeMap(types));
            }
Example #2
0
 public static TypeMap[] GetIncludedTypeMaps(
     this IGlobalConfiguration configuration,
     TypeMap typeMap
     ) => configuration.GetIncludedTypeMaps(typeMap.IncludedDerivedTypes);