root/Domain.Components/Extensions/IListExtensions.cs

// Copyright (c) 2007 Omer Rauchwerger (a.k.a rauchy) (omer@rauchy.net)
// All rights reserved.
//
// This file is part of Regionerate.
// 
// This program is free software; you can redistribute it and/or modify it 
// under the terms of the GNU General Public License as published by 
// the Free Software Foundation; either version 3 of the License, 
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

using System.Collections.Generic;
using System.Reflection;

namespace Rauchy.Regionerate.Domain.Components.Extensions
{
    public static class IListExtensions
    {
                #region�Methods�(2)�

                //�Public�Methods�(2)�

        /// <summary>
        /// Slices an <see cref="IList"/> into a map by unique values of a single property.
        /// </summary>
        /// <example>
        /// Suppose you have a type called Foo with a string property called Bar and you have 3 instances of Foo inside 
        /// a list. 2 of these instances have the value "hello" as Bar and 1 instance has the value "goodbye".
        /// Running Slice on the list will return an <see cref="IDictionary"/> which contains two items - 
        /// the first item will be keyd 'hello' and its value will be a list containing the 2 instances 
        /// that contains "hello" and the second item will be keyd 'goodbye' and its value will be 
        /// a list that contains the single instance which contains "goodbye".
        /// </example>
        /// <remarks>
        /// The original list does not need to be sorted.
        /// </remarks>
        /// <typeparam name="T">The type inside the list.</typeparam>
        /// <param name="list">The <see cref="IList"/> to operate on.</param>
        /// <param name="propertyInfo">The <see cref="PropertyInfo"/> to slice by.</param>
        /// <returns>A map of lists, each containing distinct values in the provided property info.</returns>
        public static IDictionary<object, IList<T>> Slice<T>( this IList<T> list, PropertyInfo propertyInfo )
        {
            IDictionary<object, IList<T>> slices = new Dictionary<object, IList<T>>();
            foreach ( T t in list )
            {
                // Get the value of propertyInfo.
                object value = propertyInfo.GetValue( t, null );

                // Add it to slices.
                if ( slices.Keys.Contains( value ) )
                {
                    // slices already has a slice for this value.
                    slices[ value ].Add( t );
                }
                else
                {
                    // there is no slice for this value inside slices, create a new slice.
                    IList<T> newSlice = new List<T>();
                    newSlice.Add( t );
                    slices.Add( value, newSlice );
                }
            }

            return slices;
        }

        /// <summary>
        /// Slices an <see cref="IList"/> into a map by unique values of a single property.
        /// </summary>
        /// <example>
        /// Suppose you have a type called Foo with a string property called Bar and you have 3 instances of Foo inside 
        /// a list. 2 of these instances have the value "hello" as Bar and 1 instance has the value "goodbye".
        /// Running Slice on the list will return an <see cref="IDictionary"/> which contains two items - 
        /// the first item will be keyd 'hello' and its value will be a list containing the 2 instances 
        /// that contains "hello" and the second item will be keyd 'goodbye' and its value will be 
        /// a list that contains the single instance which contains "goodbye".
        /// </example>
        /// <remarks>
        /// The original list does not need to be sorted.
        /// </remarks>
        /// <typeparam name="T">The type inside the list.</typeparam>
        /// <param name="list">The <see cref="IList"/> to operate on.</param>
        /// <param name="propertyName">The name of the property to slice by.</param>
        /// <returns>A map of lists, each containing distinct values in the provided property info.</returns>
        public static IDictionary<object, IList<T>> Slice<T>( this IList<T> list, string propertyName )
        {
            PropertyInfo propertyInfo = typeof ( T ).GetProperty( propertyName );
            return Slice( list, propertyInfo );
        }

                #endregion�Methods�
    }
}