Esempio n. 1
0
        public void Populate(IObjectWithPathAndChildren source)
        {
            if (name.isNullOrEmpty())
            {
                name = source.name;
            }

            var allChilren = source.getAllChildren();

            foreach (var item in allChilren)
            {
                Int32 ChildrenCount = 0;
                foreach (var citem in item)
                {
                    ChildrenCount++;
                }

                ChildrenCountRange.Learn(ChildrenCount);

                if (ChildrenCount == 0)
                {
                    LeafNodes++;
                    LeafLevelRange.Learn(item.level);
                }
                LevelRange.Learn(item.level);
            }

            TotalCount = allChilren.Count;
        }
Esempio n. 2
0
        //public static List<IObjectWithPathAndChildren> getOnlyWithFullBranch(this IEnumerable<IObjectWithPathAndChildren> children, Regex pathRegex, Regex nameRegex = null)
        //{
        //    List<IObjectWithPathAndChildren> output = new List<IObjectWithPathAndChildren>();

        //    foreach (IObjectWithPathAndChildren child in children)
        //    {
        //        if (pathRegex.IsMatch(child.path))
        //        {
        //            if (nameRegex != null)
        //            {
        //                if (nameRegex.IsMatch(child.name)) output.Add(child);
        //            }
        //            else
        //            {
        //                output.Add(child);
        //            }
        //        }
        //        else { }
        //    }
        //    return output;
        //}

        /// <summary>
        /// Gets all leafs, optionally applies Regex criteria used to child name [[[doesn't work]]]
        /// </summary>
        /// <param name="parent">The parent.</param>
        /// <param name="nameFilter">The name filter.</param>
        /// <returns></returns>
        public static List <IObjectWithPathAndChildren> getAllLeafs(this IObjectWithPathAndChildren parent, Regex nameFilter = null, Boolean inverse = false)
        {
            List <IObjectWithPathAndChildren> output = new List <IObjectWithPathAndChildren>();

            List <IObjectWithPathAndChildren> stack = new List <IObjectWithPathAndChildren>();

            stack.Add(parent);

            while (stack.Any())
            {
                var n_stack = new List <IObjectWithPathAndChildren>();

                foreach (IObjectWithPathAndChildren child in stack)
                {
                    if (child.Any())
                    {
                        foreach (IObjectWithPathAndChildren c in child)
                        {
                            n_stack.Add(c);
                        }
                    }
                    else
                    {
                        if (nameFilter != null)
                        {
                            if (nameFilter.IsMatch(child.name))
                            {
                                if (!inverse)
                                {
                                    output.Add(child);
                                }
                            }
                            else
                            {
                                if (inverse)
                                {
                                    output.Add(child);
                                }
                            }
                        }
                        else
                        {
                            output.Add(child);
                        }
                    }
                }
                stack = n_stack;
            }
            return(output);
        }
Esempio n. 3
0
        /// <summary>
        /// Gets all children. If pathFilder defined, it uses it to select only children with appropriate path
        /// </summary>
        /// <param name="parent">The parent.</param>
        /// <param name="pathFilter">The path filter.</param>
        /// <param name="inverse">if set to <c>true</c> it inverses the filter</param>
        /// <param name="orderByPath">if set to <c>true</c> [order by path].</param>
        /// <param name="recursiveIndex">Index of the recursive calls (if orderByPath is true)</param>
        /// <param name="recursiveLimit">The recursive calls limit.</param>
        /// <returns></returns>
        public static List <IObjectWithPathAndChildren> getAllChildren(this IObjectWithPathAndChildren parent, Regex pathFilter = null, Boolean inverse = false, Boolean orderByPath = false,
                                                                       Int32 recursiveIndex = 1, Int32 recursiveLimit = 500, Boolean includingParent = false)
        {
            List <IObjectWithPathAndChildren> output = new List <IObjectWithPathAndChildren>();

            List <IObjectWithPathAndChildren> stack = new List <IObjectWithPathAndChildren>();

            stack.Add(parent);
            if (recursiveIndex > recursiveLimit)
            {
#if DEBUG
                Console.WriteLine("RECURSIVE LIMIT REACHED [" + recursiveIndex + "] in getAllChildren - [" + parent.name + "] (" + parent.GetType().Name + ")");
#endif
                return(output);
            }
            while (stack.Any())
            {
                var n_stack = new List <IObjectWithPathAndChildren>();

                foreach (IObjectWithPathAndChildren child in stack)
                {
                    if (orderByPath)
                    {
                        if (pathFilter != null)
                        {
                            if (pathFilter.IsMatch(child.path))
                            {
                                if (!inverse)
                                {
                                    output.Add(child);
                                }
                            }
                            else
                            {
                                if (inverse)
                                {
                                    output.Add(child);
                                }
                            }
                        }
                        else
                        {
                            output.Add(child);
                        }

                        if (child.Any())
                        {
                            foreach (IObjectWithPathAndChildren c in child)
                            {
                                output.AddRange(getAllChildren(c, pathFilter, inverse, orderByPath, recursiveIndex + 1, recursiveLimit, true));
                            }
                        }
                    }
                    else
                    {
                        if (pathFilter != null)
                        {
                            if (!child.path.isNullOrEmpty())
                            {
                                if (pathFilter.IsMatch(child.path))
                                {
                                    if (!inverse)
                                    {
                                        output.Add(child);
                                    }
                                }
                                else
                                {
                                    if (inverse)
                                    {
                                        output.Add(child);
                                    }
                                }
                            }
                        }
                        else
                        {
                            output.Add(child);
                        }
                        if (child != null)
                        {
                            if (child.Any())
                            {
                                foreach (IObjectWithPathAndChildren c in child)
                                {
                                    n_stack.Add(c);
                                }
                            }
                        }
                    }
                }

                stack = n_stack;
            }

            if (!includingParent)
            {
                output.Remove(parent);
            }
            return(output);
        }