Implementation of a Max Depth for member scanning

src/NPoco/ColumnInfo.cs

@@ -26,6 +26,10 @@ public class ColumnInfo
         public string ReferenceMemberName { get; set; }
         public MemberInfo MemberInfo { get; internal set; }
         public bool ExactColumnNameMatch { get; set; }
+        /// <summary>
+        /// If this is set, this column's members will not be mapped beyond [HardDepthLimit] iterations (useful for complex, long-looping or aggregate data structures)
+        /// </summary>
+        public int? HardDepthLimit {get;set;}
 
         public static ColumnInfo FromMemberInfo(MemberInfo mi)
         {
@@ -38,6 +42,7 @@ public static ColumnInfo FromMemberInfo(MemberInfo mi)
             var serializedColumnAttributes = attrs.OfType<SerializedColumnAttribute>().ToArray();
             var reference = attrs.OfType<ReferenceAttribute>().ToArray();
             var aliasColumn = attrs.OfType<AliasAttribute>().FirstOrDefault();
+            var depthLimit = attrs.OfType<DepthLimitAttribute>().FirstOrDefault();
 
             // Check if declaring poco has [ExplicitColumns] attribute
             var explicitColumns = mi.DeclaringType.GetTypeInfo().GetCustomAttributes(typeof(ExplicitColumnsAttribute), true).Any();
@@ -50,6 +55,9 @@ public static ColumnInfo FromMemberInfo(MemberInfo mi)
                 ci.IgnoreColumn = true;
             }
 
+            if (depthLimit != null )
+                ci.HardDepthLimit = depthLimit.DepthLimit;
+
             if (complexMapping.Any())
             {
                 ci.ComplexMapping = true;

src/NPoco/DepthLimitAttribute.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace NPoco
+{
+    /// <summary>
+    /// Use to decorate columns, usually of lists, that have a chance of looping on themselves while being mapped
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
+    public class DepthLimitAttribute : Attribute
+    {
+        /// <summary>
+        /// Default constructor sets the depth limit to 1, which is - do not map beyond one iteration.
+        /// </summary>
+        public DepthLimitAttribute() 
+        {
+            DepthLimit = 1;
+        }
+        public DepthLimitAttribute(int maxDepth) 
+        {
+            if (maxDepth < 1) throw new ArgumentOutOfRangeException("maxDepth", "Hard depth limit should be at least equal to 1");
+            DepthLimit = maxDepth; 
+        }
+        public int DepthLimit { get; set; }
+    }
+}

src/NPoco/FluentMappings/ColumnConfigurationBuilder.cs

@@ -61,6 +61,7 @@ public interface IManyColumnBuilder<TModel>
         IManyColumnBuilder<TModel> WithDbType(Type type);
         IManyColumnBuilder<TModel> WithDbType<T>();
         IManyColumnBuilder<TModel> Reference(Expression<Func<TModel, object>> member);
+        IManyColumnBuilder<TModel> LimitMappingDepth(int limit = 1);        
     }
 
     public class ManyColumnBuilder<TModel> : IManyColumnBuilder<TModel>
@@ -96,6 +97,20 @@ public IManyColumnBuilder<TModel> Reference(Expression<Func<TModel, object>> mem
             _columnDefinition.ReferenceMember = MemberHelper<TModel>.GetMembers(member).Last();
             return this;
         }
+        /// <summary>
+        /// Sets the hard mapping depth limit for this column's definition
+        /// </summary>
+        /// <param name="limit">integer hard depth limit. Defaults to and can't be less than 1</param>
+        /// <returns>The ManyColumnBuilder</returns>
+        public IManyColumnBuilder<TModel> LimitMappingDepth(int limit = 1)
+        {
+            if ( limit < 1 )
+                throw new ArgumentOutOfRangeException("limit", "The mapping depth limit must always be at least equal to 1");
+
+                _columnDefinition.HardDepthLimit = limit;
+
+                return this;
+        }
     }
 
     public interface IColumnBuilder<TModel>
@@ -118,6 +133,7 @@ public interface IColumnBuilder<TModel>
         IColumnBuilder<TModel> ValueObject();
         IColumnBuilder<TModel> ValueObject(Expression<Func<TModel, object>> member);
         IColumnBuilder<TModel> ForceToUtc(bool enabled);
+        IColumnBuilder<TModel> LimitMappingDepth(int limit = 1);
     }
 
     public class ColumnBuilder<TModel> : IColumnBuilder<TModel>
@@ -253,5 +269,19 @@ public IColumnBuilder<TModel> ForceToUtc(bool enabled)
             _columnDefinition.ForceUtc = enabled;
             return this;
         }
+        /// <summary>
+        /// Sets the hard mapping depth limit for this column's definition
+        /// </summary>
+        /// <param name="limit">integer hard depth limit. Defaults to and can't be less than 1</param>
+        /// <returns>The ColumnBuilder</returns>
+        public IColumnBuilder<TModel> LimitMappingDepth(int limit = 1)
+        {
+            if ( limit < 1 )
+                throw new ArgumentOutOfRangeException("limit", "The mapping depth limit must always be at least equal to 1");
+
+                _columnDefinition.HardDepthLimit = limit;
+
+            return this;
+        }        
     }
 }

src/NPoco/FluentMappings/ColumnDefinition.cs

@@ -26,5 +26,9 @@ public class ColumnDefinition
         public bool? ValueObjectColumn { get; set; }
         public string ValueObjectColumnName { get; set; }
         public bool? ExactColumnNameMatch { get; set; }
+        /// <summary>
+        /// If this is set, this column's members will not be mapped beyond [HardDepthLimit] iterations (useful for complex, long-looping or aggregate data structures)
+        /// </summary>
+        public int? HardDepthLimit {get;set;}
     }
 }

src/NPoco/FluentMappings/ConventionScannerSettings.cs

@@ -31,6 +31,10 @@ public ConventionScannerSettings()
         public Func<MemberInfo, string> DbColumnsNamed { get; set; }
         public Func<MemberInfo, string> AliasNamed { get; set; }
         public Func<MemberInfo, Type> DbColumnTypesAs { get; set; }
+        /// <summary>
+        /// Set the hard depth limit for the columns. Null leaves the limit unset.
+        /// </summary>
+        public Func<MemberInfo, int?> HardDepthLimitAs {get;set;}
         public List<Func<MemberInfo, bool>> IgnorePropertiesWhere { get; set; }
         public Func<MemberInfo, bool> VersionPropertiesWhere { get; set; }
         public Func<MemberInfo, VersionColumnType> VersionPropertyTypeAs { get; set; }

src/NPoco/FluentMappings/FluentMappingConfiguration.cs

@@ -113,10 +113,14 @@ private static IEnumerable<ColumnDefinition> GetColumnDefinitions(ConventionScan
 
                     foreach (var columnDefinition in columnDefinitions)
                     {
+
+                        if ( columnDefinition.HardDepthLimit >= members.Count)
+                            continue;
+
                         yield return columnDefinition;
                     }
 
-                    var referenceDbColumnsNamed = scannerSettings.ReferenceDbColumnsNamed(member);
+                    var referenceDbColumnsNamed = scannerSettings.ReferenceDbColumnsNamed(member);                                        
 
                     yield return new ColumnDefinition()
                     {
@@ -128,6 +132,7 @@ private static IEnumerable<ColumnDefinition> GetColumnDefinitions(ConventionScan
                         ReferenceMember = null,
                         ResultColumn = scannerSettings.ResultPropertiesWhere(member),
                         DbColumnName = referenceProperty ? referenceDbColumnsNamed : null,
+                        HardDepthLimit = scannerSettings.HardDepthLimitAs(member)
                     };
                 }
                 else
@@ -151,6 +156,7 @@ private static IEnumerable<ColumnDefinition> GetColumnDefinitions(ConventionScan
                     columnDefinition.Serialized = scannerSettings.SerializedWhere(member);
                     columnDefinition.IsComplexMapping = scannerSettings.ComplexPropertiesWhere(member);
                     columnDefinition.ValueObjectColumn = scannerSettings.ValueObjectColumnWhere(member);
+                    columnDefinition.HardDepthLimit = scannerSettings.HardDepthLimitAs(member);
                     yield return columnDefinition;
                 }
             }
@@ -182,7 +188,8 @@ private static ConventionScannerSettings ProcessSettings(Action<IConventionScann
                 DbColumnWhere = x => ReflectionUtils.GetCustomAttributes(x, typeof(ColumnAttribute)).Any(),
                 ValueObjectColumnWhere = x => x.GetMemberInfoType().GetInterfaces().Any(y => y == typeof(IValueObject)),
                 Lazy = false,
-                MapNestedTypesWhen = x => false
+                MapNestedTypesWhen = x => false,
+                HardDepthLimitAs = x => null //no depth limit by default
             };
             scanner.Invoke(new ConventionScanner(defaultScannerSettings));
             return defaultScannerSettings;
@@ -227,6 +234,7 @@ private static void MergeAttributeOverrides(Dictionary<Type, TypeDefinition> con
                     columnDefinition.Value.ForceUtc = columnInfo.ForceToUtc;
                     columnDefinition.Value.Serialized = columnInfo.SerializedColumn;
                     columnDefinition.Value.ValueObjectColumn = columnInfo.ValueObjectColumn;
+                    columnDefinition.Value.HardDepthLimit = columnInfo.HardDepthLimit;
                 }
             }
         }
@@ -278,6 +286,7 @@ private static void MergeOverrides(Dictionary<Type, TypeDefinition> config, Mapp
                     convColDefinition.ValueObjectColumn = overrideColumnDefinition.Value.ValueObjectColumn ?? convColDefinition.ValueObjectColumn;
                     convColDefinition.ValueObjectColumnName = overrideColumnDefinition.Value.ValueObjectColumnName ?? convColDefinition.ValueObjectColumnName;
                     convColDefinition.ExactColumnNameMatch = overrideColumnDefinition.Value.ExactColumnNameMatch ?? convColDefinition.ExactColumnNameMatch;
+                    convColDefinition.HardDepthLimit = overrideColumnDefinition.Value.HardDepthLimit ?? convColDefinition.HardDepthLimit;
                 }
             }
         }

src/NPoco/FluentMappings/FluentMappingsPocoDataBuilder.cs

@@ -116,6 +116,8 @@ protected override ColumnInfo GetColumnInfo(MemberInfo mi, Type type)
             if (isColumnDefined && (typeConfig.ColumnConfiguration[key].IgnoreColumn.HasValue && typeConfig.ColumnConfiguration[key].IgnoreColumn.Value))
                 columnInfo.IgnoreColumn = true;
 
+            if (isColumnDefined) columnInfo.HardDepthLimit = typeConfig.ColumnConfiguration[key].HardDepthLimit;
+
             // Work out the DB column name
             if (isColumnDefined)
             {

src/NPoco/PocoDataBuilder.cs

@@ -123,10 +123,34 @@ private static IEnumerable<PocoColumn> GetPocoColumns(IEnumerable<PocoMember> me
             }
         }
 
-        public IEnumerable<PocoMemberPlan> GetPocoMembers(ColumnInfo[] columnInfos, List<MemberInfo> memberInfos, string prefix = null)
+        private int _LongestUnbrokenTypeSequence(IEnumerable<Type> input)
         {
+            var iterator = input.GetEnumerator();
+            Dictionary<Type, int> lastPositions = new Dictionary<Type, int>();
+            int maxLen = 0;
+            int windowStart = 0;
+            int windowEnd = 0;
+
+            while (iterator.MoveNext())
+            {
+                if (lastPositions.ContainsKey(iterator.Current))
+                {
+                    windowStart = Math.Max(windowStart, lastPositions[iterator.Current] + 1);
+                }
+
+                lastPositions[iterator.Current] = windowEnd;
+                maxLen = Math.Max(maxLen, windowEnd - windowStart + 1);
+                windowEnd++;
+            }
+
+            return maxLen;
+        }
+
+        public IEnumerable<PocoMemberPlan> GetPocoMembers(ColumnInfo[] columnInfos, List<MemberInfo> memberInfos, string prefix = null)
+        {            
             var capturedMembers = memberInfos.ToArray();
             var capturedPrefix = prefix;
+
             foreach (var columnInfo in columnInfos)
             {
                 if (columnInfo.IgnoreColumn)
@@ -145,6 +169,14 @@ public IEnumerable<PocoMemberPlan> GetPocoMembers(ColumnInfo[] columnInfos, List
                 TableInfoPlan childTableInfoPlan = null;
                 var members = new List<MemberInfo>(capturedMembers) { columnInfo.MemberInfo };
 
+                // Never map anything beyond the hard set limit, if one has been set
+                if ( columnInfo.HardDepthLimit.HasValue)
+                {
+                    if (_LongestUnbrokenTypeSequence(members.Select(m => m.GetMemberInfoType())) > columnInfo.HardDepthLimit.Value)
+                        continue;
+                }
+
+
                 if (columnInfo.ComplexMapping || columnInfo.ReferenceType != ReferenceType.None)
                 {
                     if (capturedMembers.GroupBy(x => x.GetMemberInfoType()).Any(x => x.Count() >= 2))