Synnefo » Pithos MS Client

using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Linq.Expressions;

using System.Text;

using System.Text.RegularExpressions;

using Pithos.Client.WPF.SelectiveSynch;

using Pithos.Core;

using Pithos.Interfaces;

namespace Pithos.Client.WPF.Utils

{

    public static class EnumerableExtensions

    {

        public static IEnumerable<T> Slice<T>(this IEnumerable<T> collection, int start, int end)

        {

            int index = 0;

            int count = 0;

            if (collection == null)

                throw new ArgumentNullException("collection");

            // Optimise item count for ICollection interfaces.

            if (collection is ICollection<T>)

                count = ((ICollection<T>)collection).Count;

            else if (collection is ICollection)

                count = ((ICollection)collection).Count;

            else

            {

                count = collection.Count();

            }

            // Get start/end indexes, negative numbers start at the end of the collection.

            if (start < 0)

                start += count;

            if (end < 0)

                end += count;

            foreach (var item in collection)

            {

                if (index >= end)

                    yield break;

                if (index >= start)

                    yield return item;

                ++index;

            }

        }

        public static IEnumerable<Node<T>> ToTree<TSource,T>(this IEnumerable<TSource> enumerable,Func<TSource,string> pathFunc,Func<TSource,T> valueFunc,string delimiter="/")

        {

            var orderedItems=enumerable.OrderBy(pathFunc);

            var lookups = new Dictionary<string,Node<T>>();

            var nodes = new List<Node<T>>();

            foreach (var item in orderedItems)

            {

                var path = pathFunc(item);

                var value = valueFunc(item);

                var newNode = new Node<T> { Path = path,Data=value };

                lookups[path] = newNode;

                var lastIndex = path.LastIndexOf(delimiter, StringComparison.Ordinal);

                var upTo = lastIndex < 0 ? path.Length - 1 : lastIndex;

                var parentPath = path.Substring(0, upTo);              

                Node<T> parent;

                if (lookups.TryGetValue(parentPath, out parent))

                {

                    parent.Children.Add(newNode);   

                    parent.Children.Sort((x,y)=>String.CompareOrdinal(x.Path, y.Path));

                }

                else

                    nodes.Add(newNode);

            }

            return nodes;

        }

        static readonly Regex PascalCaseRegex = new Regex("[a-z][A-Z]", RegexOptions.Compiled);        

        public static string Name(this  Enum value)

        {

            var name = Enum.GetName(value.GetType(), value);            

            return PascalCaseRegex.Replace(name, m => m.Value[0] + " " + char.ToLower(m.Value[1]));            

        }

    }

}