FrugalList.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Shared / MS / Utility / FrugalList.cs / 1305600 / FrugalList.cs

                            //---------------------------------------------------------------------------- 
//
// Copyright (C) Microsoft Corporation.  All rights reserved.
//
//--------------------------------------------------------------------------- 

using System; 
using System.Diagnostics; 
using System.Collections;
using System.Collections.Generic; 
using System.Windows;
using System.Diagnostics.CodeAnalysis;
#if SYSTEM_XAML
using System.Xaml; 
#else
using MS.Internal.WindowsBase; 
#endif 

//using MS.Internal.PresentationCore; 
//using SR=MS.Internal.WindowsBase.SR;
//using SRID=MS.Internal.WindowsBase.SRID;

    // These classes implement a frugal storage model for lists of type . 
    // Performance measurements show that Avalon has many lists that contain
    // a limited number of entries, and frequently zero or a single entry. 
    // Therefore these classes are structured to prefer a storage model that 
    // starts at zero, and employs a conservative growth strategy to minimize
    // the steady state memory footprint. Also note that the list uses one 
    // fewer objects than ArrayList and List and does no allocations at all
    // until an item is inserted into the list.
    //
    // The code is also structured to perform well from a CPU standpoint. Perf 
    // analysis shows that the reduced number of processor cache misses makes
    // FrugalList faster than ArrayList or List, especially for lists of 6 
    // or fewer items. Timing differ with the size of . 
    //
    // FrugalList is appropriate for small lists or lists that grow slowly. 
    // Due to the slow growth, if you use it for a list with more than 6 initial
    // entires is best to set the capacity of the list at construction time or
    // soon after. If you must grow the list by a large amount, set the capacity
    // or use Insert() method to force list growth to the final size. Choose 
    // your collections wisely and pay particular attention to the growth
    // patterns and search methods. 
 
    // FrugalList has all of the methods of the Ilist interface, but implements
    // them as virtual methods of the class and not as Interface methods. This 
    // is to avoid the virtual stub dispatch CPU costs associated with Interfaces.

    // We suppress two FxCop warnings in this module because not all usages
    // of FrugalList will instantiate all the storage classes and not all class instances 
    // will use every method.
    // CA1811:AvoidUncalledPrivateCode 
    // CA1812:AvoidUninstantiatedInternalClasses 
    //
 
#if SYSTEM_XAML
namespace System.Xaml.MS.Impl
#else
namespace MS.Utility 
#endif
{ 
    // These classes implement a frugal storage model for lists of . 
    // Performance measurements show that many lists contain a single item.
    // Therefore this list is structured to prefer a list that contains a single 
    // item, and does conservative growth to minimize the memory footprint.

    // This enum controls the growth to successively more complex storage models
    internal enum FrugalListStoreState 
    {
        Success, 
        SingleItemList, 
        ThreeItemList,
        SixItemList, 
        Array
    }

    abstract class FrugalListBase 
    {
        ///  
        /// Number of entries in this store 
        /// 
        // Number of entries in this store 
        public int Count
        {
            get
            { 
                return _count;
            } 
        } 

        ///  
        /// Capacity of this store
        /// 
        public abstract int Capacity
        { 
            get;
        } 
 
        // Increase size if needed, insert item into the store
        public abstract FrugalListStoreState Add(T value); 

        /// 
        /// Removes all values from the store
        ///  
        public abstract void Clear();
 
        ///  
        /// Returns true if the store contains the entry.
        ///  
        public abstract bool Contains(T value);

        /// 
        /// Returns the index into the store that contains the item. 
        /// -1 is returned if the item is not in the store.
        ///  
        public abstract int IndexOf(T value); 

        ///  
        /// Insert item into the store at index, grows if needed
        /// 
        public abstract void Insert(int index, T value);
 
        // Place item into the store at index
        public abstract void SetAt(int index, T value); 
 
        /// 
        /// Removes the item from the store. If the item was not 
        /// in the store false is returned.
        /// 
        public abstract bool Remove(T value);
 
        /// 
        /// Removes the item from the store 
        ///  
        public abstract void RemoveAt(int index);
 
        /// 
        /// Return the item at index in the store
        /// 
        public abstract T EntryAt(int index); 

        ///  
        /// Promotes the values in the current store to the next larger 
        /// and more complex storage model.
        ///  
        public abstract void Promote(FrugalListBase newList);

        /// 
        /// Returns the entries as an array 
        /// 
        public abstract T[] ToArray(); 
 
        /// 
        /// Copies the entries to the given array starting at the 
        /// specified index
        /// 
        public abstract void CopyTo(T[] array, int index);
 
        /// 
        /// Creates a shallow copy of the  list 
        ///  
        public abstract object Clone();
 
        // The number of items in the list.
        protected int _count;
    }
 
    /// 
    /// A simple class to handle a single item 
    ///  
    internal sealed class SingleItemList : FrugalListBase
    { 
        // Capacity of this store
        public override int Capacity
        {
            get 
            {
                return SIZE; 
            } 
        }
 
        public override FrugalListStoreState Add(T value)
        {
            // If we don't have any entries or the existing entry is being overwritten,
            // then we can use this store. Otherwise we have to promote. 
            if (0 == _count)
            { 
                _loneEntry = value; 
                ++_count;
                return FrugalListStoreState.Success; 
            }
            else
            {
                // Entry already used, move to an ThreeItemList 
                return FrugalListStoreState.ThreeItemList;
            } 
        } 

        public override void Clear() 
        {
            // Wipe out the info
            _loneEntry = default(T);
            _count = 0; 
        }
 
        public override bool Contains(T value) 
        {
            return _loneEntry.Equals(value); 
        }

        public override int IndexOf(T value)
        { 
            if (_loneEntry.Equals(value))
            { 
                return 0; 
            }
            return -1; 
        }

        public override void Insert(int index, T value)
        { 
            // Should only get here if count and index are 0
            if ((_count < SIZE) && (index < SIZE)) 
            { 
                _loneEntry = value;
                ++_count; 
                return;
            }
            throw new ArgumentOutOfRangeException("index");
        } 

        public override void SetAt(int index, T value) 
        { 
            // Overwrite item at index
            _loneEntry = value; 
        }

        public override bool Remove(T value)
        { 
            // Wipe out the info in the only entry if it matches the item.
            if (_loneEntry.Equals(value)) 
            { 
                _loneEntry = default(T);
                --_count; 
                return true;
            }

            return false; 
        }
 
        public override void RemoveAt(int index) 
        {
            // Wipe out the info at index 
            if (0 == index)
            {
                _loneEntry = default(T);
                --_count; 
            }
            else 
            { 
                throw new ArgumentOutOfRangeException("index");
            } 
        }

        public override T EntryAt(int index)
        { 
            return _loneEntry;
        } 
 
        public override void Promote(FrugalListBase oldList)
        { 
            if (SIZE == oldList.Count)
            {
                SetCount(SIZE);
                SetAt(0, oldList.EntryAt(0)); 
            }
            else 
            { 
                // this list is smaller than oldList
                throw new ArgumentException(SR.Get(SRID.FrugalList_TargetMapCannotHoldAllData, oldList.ToString(), this.ToString()), "oldList"); 
            }
        }

        // Class specific implementation to avoid virtual method calls and additional logic 
        public void Promote(SingleItemList oldList)
        { 
            SetCount(oldList.Count); 
            SetAt(0, oldList.EntryAt(0));
        } 

        public override T[] ToArray()
        {
            T[] array = new T[1]; 
            array[0] = _loneEntry;
            return array; 
        } 

        public override void CopyTo(T[] array, int index) 
        {
            array[index] = _loneEntry;
        }
 
        public override object Clone()
        { 
            SingleItemList newList = new SingleItemList(); 
            newList.Promote(this);
            return newList; 
        }

        private void SetCount(int value)
        { 
            if ((value >= 0) && (value <= SIZE))
            { 
                _count = value; 
            }
            else 
            {
                throw new ArgumentOutOfRangeException("value");
            }
        } 

        private const int SIZE = 1; 
 
        private T _loneEntry;
    } 


    /// 
    /// A simple class to handle a list with 3 items.  Perf analysis showed 
    /// that this yielded better memory locality and perf than an object and an array.
    ///  
    internal sealed class ThreeItemList : FrugalListBase 
    {
        // Capacity of this store 
        public override int Capacity
        {
            get
            { 
                return SIZE;
            } 
        } 

        public override FrugalListStoreState Add(T value) 
        {
            switch (_count)
            {
                case 0: 
                    _entry0 = value;
                    break; 
 
                case 1:
                    _entry1 = value; 
                    break;

                case 2:
                    _entry2 = value; 
                    break;
 
                default: 
                    // We have to promote
                    return FrugalListStoreState.SixItemList; 
            }
            ++_count;
            return FrugalListStoreState.Success;
        } 

        public override void Clear() 
        { 
            // Wipe out the info.
            _entry0 = default(T); 
            _entry1 = default(T);
            _entry2 = default(T);
            _count = 0;
        } 

        public override bool Contains(T value) 
        { 
            return (-1 != IndexOf(value));
        } 

        public override int IndexOf(T value)
        {
            if (_entry0.Equals(value)) 
            {
                return 0; 
            } 
            if (_count > 1)
            { 
                if (_entry1.Equals(value))
                {
                    return 1;
                } 
                if ((3 == _count) && (_entry2.Equals(value)))
                { 
                    return 2; 
                }
            } 
            return -1;
        }

        public override void Insert(int index, T value) 
        {
            // Should only get here if count < SIZE 
            if (_count < SIZE) 
            {
                switch (index) 
                {
                    case 0:
                        _entry2 = _entry1;
                        _entry1 = _entry0; 
                        _entry0 = value;
                        break; 
 
                    case 1:
                        _entry2 = _entry1; 
                        _entry1 = value;
                        break;

                    case 2: 
                        _entry2 = value;
                        break; 
 
                    default:
                        throw new ArgumentOutOfRangeException("index"); 
                }
                ++_count;
                return;
            } 
            throw new ArgumentOutOfRangeException("index");
        } 
 
        public override void SetAt(int index, T value)
        { 
            // Overwrite item at index
            switch (index)
            {
                case 0: 
                    _entry0 = value;
                    break; 
 
                case 1:
                    _entry1 = value; 
                    break;

                case 2:
                    _entry2 = value; 
                    break;
 
                default: 
                    throw new ArgumentOutOfRangeException("index");
            } 
        }

        public override bool Remove(T value)
        { 
            // If the item matches an existing entry, wipe out the last
            // entry and move all the other entries up.  Because we only 
            // have three entries we can just unravel all the cases. 
            if (_entry0.Equals(value))
            { 
                RemoveAt(0);
                return true;
            }
            else if ( _count > 1) 
            {
                if (_entry1.Equals(value)) 
                { 
                    RemoveAt(1);
                    return true; 
                }
                else if ((3 == _count) && (_entry2.Equals(value)))
                {
                    RemoveAt(2); 
                    return true;
                } 
            } 
            return false;
        } 

        public override void RemoveAt(int index)
        {
            // Remove entry at index, wipe out the last entry and move 
            // all the other entries up.  Because we only have three
            // entries we can just unravel all the cases. 
            switch (index) 
            {
                case 0: 
                    _entry0 = _entry1;
                    _entry1 = _entry2;
                    break;
 
                case 1:
                    _entry1 = _entry2; 
                    break; 

                case 2: 
                    break;

                default:
                    throw new ArgumentOutOfRangeException("index"); 
            }
            _entry2 = default(T); 
            --_count; 
        }
 
        public override T EntryAt(int index)
        {
            switch (index)
            { 
                case 0:
                    return _entry0; 
 
                case 1:
                    return _entry1; 

                case 2:
                    return _entry2;
 
                default:
                    throw new ArgumentOutOfRangeException("index"); 
            } 
        }
 
        public override void Promote(FrugalListBase oldList)
        {
            int oldCount = oldList.Count;
            if (SIZE >= oldCount) 
            {
                SetCount(oldList.Count); 
 
                switch (oldCount)
                { 
                    case 3:
                        SetAt(0, oldList.EntryAt(0));
                        SetAt(1, oldList.EntryAt(1));
                        SetAt(2, oldList.EntryAt(2)); 
                        break;
 
                    case 2: 
                        SetAt(0, oldList.EntryAt(0));
                        SetAt(1, oldList.EntryAt(1)); 
                        break;

                    case 1:
                        SetAt(0, oldList.EntryAt(0)); 
                        break;
 
                    case 0: 
                        break;
 
                    default:
                        throw new ArgumentOutOfRangeException("oldList");
                }
            } 
            else
            { 
                // this list is smaller than oldList 
                throw new ArgumentException(SR.Get(SRID.FrugalList_TargetMapCannotHoldAllData, oldList.ToString(), this.ToString()), "oldList");
            } 
        }

        // Class specific implementation to avoid virtual method calls and additional logic
        public void Promote(SingleItemList oldList) 
        {
            SetCount(oldList.Count); 
            SetAt(0, oldList.EntryAt(0)); 
        }
 
        // Class specific implementation to avoid virtual method calls and additional logic
        public void Promote(ThreeItemList oldList)
        {
            int oldCount = oldList.Count; 
            SetCount(oldList.Count);
 
            switch (oldCount) 
            {
                case 3: 
                    SetAt(0, oldList.EntryAt(0));
                    SetAt(1, oldList.EntryAt(1));
                    SetAt(2, oldList.EntryAt(2));
                    break; 

                case 2: 
                    SetAt(0, oldList.EntryAt(0)); 
                    SetAt(1, oldList.EntryAt(1));
                    break; 

                case 1:
                    SetAt(0, oldList.EntryAt(0));
                    break; 

                case 0: 
                    break; 

                default: 
                    throw new ArgumentOutOfRangeException("oldList");
            }
        }
 
        public override T[] ToArray()
        { 
            T[] array = new T[_count]; 

            array[0] = _entry0; 
            if (_count >= 2)
            {
                array[1] = _entry1;
                if (_count == 3) 
                {
                    array[2] = _entry2; 
                } 
            }
            return array; 
        }

        public override void CopyTo(T[] array, int index)
        { 
            array[index] = _entry0;
            if (_count >= 2) 
            { 
                array[index+1] = _entry1;
                if (_count == 3) 
                {
                    array[index+2] = _entry2;
                }
            } 
        }
 
        public override object Clone() 
        {
            ThreeItemList newList = new ThreeItemList(); 
            newList.Promote(this);
            return newList;
        }
 
        private void SetCount(int value)
        { 
            if ((value >= 0) && (value <= SIZE)) 
            {
                _count = value; 
            }
            else
            {
                throw new ArgumentOutOfRangeException("value"); 
            }
        } 
 
        private const int SIZE = 3;
 
        private T _entry0;
        private T _entry1;
        private T _entry2;
    } 

    ///  
    /// A simple class to handle a list with 6 items. 
    /// 
    internal sealed class SixItemList : FrugalListBase 
    {
        // Capacity of this store
        public override int Capacity
        { 
            get
            { 
                return SIZE; 
            }
        } 

        public override FrugalListStoreState Add(T value)
        {
            switch (_count) 
            {
                case 0: 
                    _entry0 = value; 
                    break;
 
                case 1:
                    _entry1 = value;
                    break;
 
                case 2:
                    _entry2 = value; 
                    break; 

                case 3: 
                    _entry3 = value;
                    break;

                case 4: 
                    _entry4 = value;
                    break; 
 
                case 5:
                    _entry5 = value; 
                    break;

                default:
                    // We have to promote 
                    return FrugalListStoreState.Array;
            } 
            ++_count; 
            return FrugalListStoreState.Success;
        } 

        public override void Clear()
        {
            // Wipe out the info. 
            _entry0 = default(T);
            _entry1 = default(T); 
            _entry2 = default(T); 
            _entry3 = default(T);
            _entry4 = default(T); 
            _entry5 = default(T);
            _count = 0;
        }
 
        public override bool Contains(T value)
        { 
            return (-1 != IndexOf(value)); 
        }
 
        public override int IndexOf(T value)
        {
            if (_entry0.Equals(value))
            { 
                return 0;
            } 
            if (_count > 1) 
            {
                if (_entry1.Equals(value)) 
                {
                    return 1;
                }
                if (_count > 2) 
                {
                    if (_entry2.Equals(value)) 
                    { 
                        return 2;
                    } 
                    if (_count > 3)
                    {
                        if (_entry3.Equals(value))
                        { 
                            return 3;
                        } 
                        if (_count > 4) 
                        {
                            if (_entry4.Equals(value)) 
                            {
                                return 4;
                            }
                            if ((6 == _count) && (_entry5.Equals(value))) 
                            {
                                return 5; 
                            } 
                        }
                    } 
                }
            }
            return -1;
        } 

        public override void Insert(int index, T value) 
        { 
            // Should only get here if count is less than SIZE
            if (_count < SIZE) 
            {
                switch (index)
                {
                    case 0: 
                        _entry5 = _entry4;
                        _entry4 = _entry3; 
                        _entry3 = _entry2; 
                        _entry2 = _entry1;
                        _entry1 = _entry0; 
                        _entry0 = value;
                        break;

                    case 1: 
                        _entry5 = _entry4;
                        _entry4 = _entry3; 
                        _entry3 = _entry2; 
                        _entry2 = _entry1;
                        _entry1 = value; 
                        break;

                    case 2:
                        _entry5 = _entry4; 
                        _entry4 = _entry3;
                        _entry3 = _entry2; 
                        _entry2 = value; 
                        break;
 
                    case 3:
                        _entry5 = _entry4;
                        _entry4 = _entry3;
                        _entry3 = value; 
                        break;
 
                    case 4: 
                        _entry5 = _entry4;
                        _entry4 = value; 
                        break;

                    case 5:
                        _entry5 = value; 
                        break;
 
                    default: 
                        throw new ArgumentOutOfRangeException("index");
                } 
                ++_count;
                return;
            }
            throw new ArgumentOutOfRangeException("index"); 
        }
 
        public override void SetAt(int index, T value) 
        {
            // Overwrite item at index 
            switch (index)
            {
                case 0:
                    _entry0 = value; 
                    break;
 
                case 1: 
                    _entry1 = value;
                    break; 

                case 2:
                    _entry2 = value;
                    break; 

                case 3: 
                    _entry3 = value; 
                    break;
 
                case 4:
                    _entry4 = value;
                    break;
 
                case 5:
                    _entry5 = value; 
                    break; 

                default: 
                    throw new ArgumentOutOfRangeException("index");
            }
        }
 
        public override bool Remove(T value)
        { 
            // If the item matches an existing entry, wipe out the last 
            // entry and move all the other entries up.  Because we only
            // have six entries we can just unravel all the cases. 
            if (_entry0.Equals(value))
            {
                RemoveAt(0);
                return true; 
            }
            else if (_count > 1) 
            { 
                if (_entry1.Equals(value))
                { 
                    RemoveAt(1);
                    return true;
                }
                else if (_count > 2) 
                {
                    if (_entry2.Equals(value)) 
                    { 
                        RemoveAt(2);
                        return true; 
                    }
                    else if (_count > 3)
                    {
                        if (_entry3.Equals(value)) 
                        {
                            RemoveAt(3); 
                            return true; 
                        }
                        else if (_count > 4) 
                        {
                            if (_entry4.Equals(value))
                            {
                                RemoveAt(4); 
                                return true;
                            } 
                            else if ((6 == _count) && (_entry5.Equals(value))) 
                            {
                                RemoveAt(5); 
                                return true;
                            }
                        }
                    } 
                }
            } 
 
            return false;
        } 

        public override void RemoveAt(int index)
        {
            // Remove entry at index, wipe out the last entry and move 
            // all the other entries up. Because we only have six
            // entries we can just unravel all the cases. 
            switch (index) 
            {
                case 0: 
                    _entry0 = _entry1;
                    _entry1 = _entry2;
                    _entry2 = _entry3;
                    _entry3 = _entry4; 
                    _entry4 = _entry5;
                    break; 
 
                case 1:
                    _entry1 = _entry2; 
                    _entry2 = _entry3;
                    _entry3 = _entry4;
                    _entry4 = _entry5;
                    break; 

                case 2: 
                    _entry2 = _entry3; 
                    _entry3 = _entry4;
                    _entry4 = _entry5; 
                    break;

                case 3:
                    _entry3 = _entry4; 
                    _entry4 = _entry5;
                    break; 
 
                case 4:
                    _entry4 = _entry5; 
                    break;

                case 5:
                    break; 

                default: 
                    throw new ArgumentOutOfRangeException("index"); 
            }
            _entry5 = default(T); 
            --_count;
        }

        public override T EntryAt(int index) 
        {
            switch (index) 
            { 
                case 0:
                    return _entry0; 

                case 1:
                    return _entry1;
 
                case 2:
                    return _entry2; 
 
                case 3:
                    return _entry3; 

                case 4:
                    return _entry4;
 
                case 5:
                    return _entry5; 
 
                default:
                    throw new ArgumentOutOfRangeException("index"); 
            }
        }

        public override void Promote(FrugalListBase oldList) 
        {
            int oldCount = oldList.Count; 
            if (SIZE >= oldCount) 
            {
                SetCount(oldList.Count); 

                switch (oldCount)
                {
                    case 6: 
                        SetAt(0, oldList.EntryAt(0));
                        SetAt(1, oldList.EntryAt(1)); 
                        SetAt(2, oldList.EntryAt(2)); 
                        SetAt(3, oldList.EntryAt(3));
                        SetAt(4, oldList.EntryAt(4)); 
                        SetAt(5, oldList.EntryAt(5));
                        break;

                    case 5: 
                        SetAt(0, oldList.EntryAt(0));
                        SetAt(1, oldList.EntryAt(1)); 
                        SetAt(2, oldList.EntryAt(2)); 
                        SetAt(3, oldList.EntryAt(3));
                        SetAt(4, oldList.EntryAt(4)); 
                        break;

                    case 4:
                        SetAt(0, oldList.EntryAt(0)); 
                        SetAt(1, oldList.EntryAt(1));
                        SetAt(2, oldList.EntryAt(2)); 
                        SetAt(3, oldList.EntryAt(3)); 
                        break;
 
                    case 3:
                        SetAt(0, oldList.EntryAt(0));
                        SetAt(1, oldList.EntryAt(1));
                        SetAt(2, oldList.EntryAt(2)); 
                        break;
 
                    case 2: 
                        SetAt(0, oldList.EntryAt(0));
                        SetAt(1, oldList.EntryAt(1)); 
                        break;

                    case 1:
                        SetAt(0, oldList.EntryAt(0)); 
                        break;
 
                    case 0: 
                        break;
 
                    default:
                        throw new ArgumentOutOfRangeException("oldList");
                }
            } 
            else
            { 
                // this list is smaller than oldList 
                throw new ArgumentException(SR.Get(SRID.FrugalList_TargetMapCannotHoldAllData, oldList.ToString(), this.ToString()), "oldList");
            } 
        }

        // Class specific implementation to avoid virtual method calls and additional logic
        public void Promote(ThreeItemList oldList) 
        {
            int oldCount = oldList.Count; 
            if (SIZE <= oldCount) 
            {
                SetCount(oldList.Count); 

                switch (oldCount)
                {
                    case 3: 
                        SetAt(0, oldList.EntryAt(0));
                        SetAt(1, oldList.EntryAt(1)); 
                        SetAt(2, oldList.EntryAt(2)); 
                        break;
 
                    case 2:
                        SetAt(0, oldList.EntryAt(0));
                        SetAt(1, oldList.EntryAt(1));
                        break; 

                    case 1: 
                        SetAt(0, oldList.EntryAt(0)); 
                        break;
 
                    case 0:
                        break;

                    default: 
                        throw new ArgumentOutOfRangeException("oldList");
                } 
            } 
            else
            { 
                // this list is smaller than oldList
                throw new ArgumentException(SR.Get(SRID.FrugalList_TargetMapCannotHoldAllData, oldList.ToString(), this.ToString()), "oldList");
            }
        } 

        // Class specific implementation to avoid virtual method calls and additional logic 
        public void Promote(SixItemList oldList) 
        {
            int oldCount = oldList.Count; 
            SetCount(oldList.Count);

            switch (oldCount)
            { 
                case 6:
                    SetAt(0, oldList.EntryAt(0)); 
                    SetAt(1, oldList.EntryAt(1)); 
                    SetAt(2, oldList.EntryAt(2));
                    SetAt(3, oldList.EntryAt(3)); 
                    SetAt(4, oldList.EntryAt(4));
                    SetAt(5, oldList.EntryAt(5));
                    break;
 
                case 5:
                    SetAt(0, oldList.EntryAt(0)); 
                    SetAt(1, oldList.EntryAt(1)); 
                    SetAt(2, oldList.EntryAt(2));
                    SetAt(3, oldList.EntryAt(3)); 
                    SetAt(4, oldList.EntryAt(4));
                    break;

                case 4: 
                    SetAt(0, oldList.EntryAt(0));
                    SetAt(1, oldList.EntryAt(1)); 
                    SetAt(2, oldList.EntryAt(2)); 
                    SetAt(3, oldList.EntryAt(3));
                    break; 

                case 3:
                    SetAt(0, oldList.EntryAt(0));
                    SetAt(1, oldList.EntryAt(1)); 
                    SetAt(2, oldList.EntryAt(2));
                    break; 
 
                case 2:
                    SetAt(0, oldList.EntryAt(0)); 
                    SetAt(1, oldList.EntryAt(1));
                    break;

                case 1: 
                    SetAt(0, oldList.EntryAt(0));
                    break; 
 
                case 0:
                    break; 

                default:
                    throw new ArgumentOutOfRangeException("oldList");
            } 
        }
 
        public override T[] ToArray() 
        {
            T[] array = new T[_count]; 

            if (_count >= 1)
            {
                array[0] = _entry0; 
                if (_count >= 2)
                { 
                    array[1] = _entry1; 
                    if (_count >= 3)
                    { 
                        array[2] = _entry2;
                        if (_count >= 4)
                        {
                            array[3] = _entry3; 
                            if (_count >= 5)
                            { 
                                array[4] = _entry4; 
                                if (_count == 6)
                                { 
                                    array[5] = _entry5;
                                }
                            }
                        } 
                    }
                } 
            } 
            return array;
        } 

        public override void CopyTo(T[] array, int index)
        {
            if (_count >= 1) 
            {
                array[index] = _entry0; 
                if (_count >= 2) 
                {
                    array[index+1] = _entry1; 
                    if (_count >= 3)
                    {
                        array[index+2] = _entry2;
                        if (_count >= 4) 
                        {
                            array[index+3] = _entry3; 
                            if (_count >= 5) 
                            {
                                array[index+4] = _entry4; 
                                if (_count == 6)
                                {
                                    array[index+5] = _entry5;
                                } 
                            }
                        } 
                    } 
                }
            } 
        }

        public override object Clone()
        { 
            SixItemList newList = new SixItemList();
            newList.Promote(this); 
            return newList; 
        }
 
        private void SetCount(int value)
        {
            if ((value >= 0) && (value <= SIZE))
            { 
                _count = value;
            } 
            else 
            {
                throw new ArgumentOutOfRangeException("value"); 
            }
        }

        private const int SIZE = 6; 

        private T _entry0; 
        private T _entry1; 
        private T _entry2;
        private T _entry3; 
        private T _entry4;
        private T _entry5;
    }
 
    /// 
    /// A simple class to handle an array of 7 or more items.  It is unsorted and uses 
    /// a linear search. 
    /// 
    internal sealed class ArrayItemList : FrugalListBase 
    {
        public ArrayItemList()
        {
        } 

        public ArrayItemList(int size) 
        { 
            // Make size a multiple of GROWTH
            size += (GROWTH - 1); 
            size -= (size % GROWTH);
            _entries = new T[size];
        }
 
        public ArrayItemList(ICollection collection)
        { 
            if (collection != null) 
            {
                _count = collection.Count; 
                _entries = new T[_count];
                collection.CopyTo(_entries, 0);
            }
        } 

        public ArrayItemList(ICollection collection) 
        { 
            if (collection != null)
            { 
                _count = collection.Count;
                _entries = new T[_count];
                collection.CopyTo(_entries, 0);
            } 
        }
 
        // Capacity of this store 
        public override int Capacity
        { 
            get
            {
                if (_entries != null)
                { 
                    return _entries.Length;
                } 
                return 0; 
            }
        } 

        public override FrugalListStoreState Add(T value)
        {
            // If we don't have any entries or the existing entry is being overwritten, 
            // then we can use this store. Otherwise we have to promote.
            if ((null != _entries) && (_count < _entries.Length)) 
            { 
                _entries[_count] = value;
                ++_count; 
            }
            else
            {
                if (null != _entries) 
                {
                    int size = _entries.Length; 
 
                    // Grow the list slowly while it is small but
                    // faster once it reaches the LARGEGROWTH size 
                    if (size < LARGEGROWTH)
                    {
                        size += GROWTH;
                    } 
                    else
                    { 
                        size += size >> 2; 
                    }
 
                    T[] destEntries = new T[size];

                    // Copy old array
                    Array.Copy(_entries, 0, destEntries, 0, _entries.Length); 
                    _entries = destEntries;
                } 
                else 
                {
                    _entries = new T[MINSIZE]; 
                }

                // Insert into new array
                _entries[_count] = value; 
                ++_count;
            } 
            return FrugalListStoreState.Success; 
        }
 
        public override void Clear()
        {
            // Wipe out the info.
            for (int i = 0; i < _count; ++i) 
            {
                _entries[i] = default(T); 
            } 
            _count = 0;
        } 

        public override bool Contains(T value)
        {
            return (-1 != IndexOf(value)); 
        }
 
        public override int IndexOf(T value) 
        {
            for (int index = 0; index < _count; ++index) 
            {
                if (_entries[index].Equals(value))
                {
                    return index; 
                }
            } 
            return -1; 
        }
 
        public override void Insert(int index, T value)
        {
            if ((null != _entries) && (_count < _entries.Length))
            { 
                // Move down the required number of items
                Array.Copy(_entries, index, _entries, index + 1, _count - index); 
 
                // Put in the new item at the specified index
                _entries[index] = value; 
                ++_count;
                return;
            }
            throw new ArgumentOutOfRangeException("index"); 
        }
 
        public override void SetAt(int index, T value) 
        {
            // Overwrite item at index 
            _entries[index] = value;
        }

        public override bool Remove(T value) 
        {
            for (int index = 0; index < _count; ++index) 
            { 
                if (_entries[index].Equals(value))
                { 
                    RemoveAt(index);
                    return true;
                }
            } 

            return false; 
        } 

        public override void RemoveAt(int index) 
        {
            // Shift entries down
            int numToCopy = (_count - index) - 1;
            if (numToCopy > 0) 
            {
                Array.Copy(_entries, index + 1, _entries, index, numToCopy); 
            } 

            // Wipe out the last entry 
            _entries[_count - 1] = default(T);
            --_count;
            return;
        } 

        public override T EntryAt(int index) 
        { 
            return _entries[index];
        } 

        public override void Promote(FrugalListBase oldList)
        {
            for (int index = 0; index < oldList.Count; ++index) 
            {
                if (FrugalListStoreState.Success == Add(oldList.EntryAt(index))) 
                { 
                    continue;
                } 
                // this list is smaller than oldList
                throw new ArgumentException(SR.Get(SRID.FrugalList_TargetMapCannotHoldAllData, oldList.ToString(), this.ToString()), "oldList");
            }
        } 

        // Class specific implementation to avoid virtual method calls and additional logic 
        public void Promote(SixItemList oldList) 
        {
            int oldCount = oldList.Count; 
            SetCount(oldList.Count);

            switch (oldCount)
            { 
                case 6:
                    SetAt(0, oldList.EntryAt(0)); 
                    SetAt(1, oldList.EntryAt(1)); 
                    SetAt(2, oldList.EntryAt(2));
                    SetAt(3, oldList.EntryAt(3)); 
                    SetAt(4, oldList.EntryAt(4));
                    SetAt(5, oldList.EntryAt(5));
                    break;
 
                case 5:
                    SetAt(0, oldList.EntryAt(0)); 
                    SetAt(1, oldList.EntryAt(1)); 
                    SetAt(2, oldList.EntryAt(2));
                    SetAt(3, oldList.EntryAt(3)); 
                    SetAt(4, oldList.EntryAt(4));
                    break;

                case 4: 
                    SetAt(0, oldList.EntryAt(0));
                    SetAt(1, oldList.EntryAt(1)); 
                    SetAt(2, oldList.EntryAt(2)); 
                    SetAt(3, oldList.EntryAt(3));
                    break; 

                case 3:
                    SetAt(0, oldList.EntryAt(0));
                    SetAt(1, oldList.EntryAt(1)); 
                    SetAt(2, oldList.EntryAt(2));
                    break; 
 
                case 2:
                    SetAt(0, oldList.EntryAt(0)); 
                    SetAt(1, oldList.EntryAt(1));
                    break;

                case 1: 
                    SetAt(0, oldList.EntryAt(0));
                    break; 
 
                case 0:
                    break; 

                default:
                    throw new ArgumentOutOfRangeException("oldList");
            } 
        }
 
        // Class specific implementation to avoid virtual method calls and additional logic 
        public void Promote(ArrayItemList oldList)
        { 
            int oldCount = oldList.Count;
            if (_entries.Length >= oldCount)
            {
                SetCount(oldList.Count); 

                for (int index = 0; index < oldCount; ++index) 
                { 
                    SetAt(index, oldList.EntryAt(index));
                } 
            }
            else
            {
                // this list is smaller than oldList 
                throw new ArgumentException(SR.Get(SRID.FrugalList_TargetMapCannotHoldAllData, oldList.ToString(), this.ToString()), "oldList");
            } 
        } 

        public override T[] ToArray() 
        {
            T[] array = new T[_count];

            for (int i = 0; i < _count; ++i) 
            {
                array[i] = _entries[i]; 
            } 
            return array;
        } 

        public override void CopyTo(T[] array, int index)
        {
            for (int i = 0; i < _count; ++i) 
            {
                array[index+i] = _entries[i]; 
            } 
        }
 
        public override object Clone()
        {
            ArrayItemList newList = new ArrayItemList(this.Capacity);
            newList.Promote(this); 
            return newList;
        } 
 
        private void SetCount(int value)
        { 
            if ((value >= 0) && (value <= _entries.Length))
            {
                _count = value;
            } 
            else
            { 
                throw new ArgumentOutOfRangeException("value"); 
            }
        } 

        // MINSIZE and GROWTH chosen to minimize memory footprint
        private const int MINSIZE = 9;
        private const int GROWTH = 3; 
        private const int LARGEGROWTH = 18;
 
        private T[] _entries; 
    }
 
    // Use FrugalObjectList when more than one reference to the list is needed.
    // The "object" in FrugalObjectLIst refers to the list itself, not what the list contains.

#if !SYSTEM_XAML 
    [FriendAccessAllowed] // Built into Core, also used by Framework.
#endif 
    internal class FrugalObjectList 
    {
        public FrugalObjectList() 
        {
        }

        public FrugalObjectList(int size) 
        {
            Capacity = size; 
        } 

        public int Capacity 
        {
            get
            {
                if (null != _listStore) 
                {
                    return _listStore.Capacity; 
                } 
                return 0;
            } 
            set
            {
                int capacity = 0;
                if (null != _listStore) 
                {
                    capacity = _listStore.Capacity; 
                } 
                if (capacity < value)
                { 
                    // Need to move to a more complex storage
                    FrugalListBase newStore;

                    if (value == 1) 
                    {
                        newStore = new SingleItemList(); 
                    } 
                    else if (value <= 3)
                    { 
                        newStore = new ThreeItemList();
                    }
                    else if (value <= 6)
                    { 
                        newStore = new SixItemList();
                    } 
                    else 
                    {
                        newStore = new ArrayItemList(value); 
                    }

                    if (null != _listStore)
                    { 
                        // Move entries in the old store to the new one
                        newStore.Promote(_listStore); 
                    } 

                    _listStore = newStore; 
                }
            }
        }
 
        public int Count
        { 
            get 
            {
                if (null != _listStore) 
                {
                    return _listStore.Count;
                }
                return 0; 
            }
        } 
 

        public T this[int index] 
        {
            get
            {
                // If no entry, default(T) is returned 
                if ((null != _listStore) && ((index < _listStore.Count) && (index >= 0)))
                { 
                    return _listStore.EntryAt(index); 
                }
                throw new ArgumentOutOfRangeException("index"); 
            }

            set
            { 
                // Ensure write success
                if ((null != _listStore) && ((index < _listStore.Count) && (index >= 0))) 
                { 
                    _listStore.SetAt(index, value);
                    return; 
                }
                throw new ArgumentOutOfRangeException("index");
            }
        } 

        public int Add(T value) 
        { 
            if (null != _listStore)
            { 
                // This is done because forward branches
                // default prediction is not to be taken
                // making this a CPU win because Add is
                // a common operation. 
            }
            else 
            { 
                _listStore = new SingleItemList();
            } 

            FrugalListStoreState myState = _listStore.Add(value);
            if (FrugalListStoreState.Success == myState)
            { 
            }
            else 
            { 
                // Need to move to a more complex storage
                // Allocate the store, promote, and add using the derived classes 
                // to avoid virtual method calls

                if (FrugalListStoreState.ThreeItemList == myState)
                { 
                    ThreeItemList newStore = new ThreeItemList();
 
                    // Extract the values from the old store and insert them into the new store 
                    newStore.Promote(_listStore);
 
                    // Insert the new item
                    newStore.Add(value);
                    _listStore = newStore;
                } 
                else if (FrugalListStoreState.SixItemList == myState)
                { 
                    SixItemList newStore = new SixItemList(); 

                    // Extract the values from the old store and insert them into the new store 
                    newStore.Promote(_listStore);
                    _listStore = newStore;

                    // Insert the new item 
                    newStore.Add(value);
                    _listStore = newStore; 
                } 
                else if (FrugalListStoreState.Array == myState)
                { 
                    ArrayItemList newStore = new ArrayItemList(_listStore.Count + 1);

                    // Extract the values from the old store and insert them into the new store
                    newStore.Promote(_listStore); 
                    _listStore = newStore;
 
                    // Insert the new item 
                    newStore.Add(value);
                    _listStore = newStore; 
                }
                else
                {
                    throw new InvalidOperationException(SR.Get(SRID.FrugalList_CannotPromoteBeyondArray)); 
                }
            } 
            return _listStore.Count - 1; 
        }
 
        public void Clear()
        {
            if (null != _listStore)
            { 
                _listStore.Clear();
            } 
        } 

        public bool Contains(T value) 
        {
            if ((null != _listStore) && (_listStore.Count > 0))
            {
                return _listStore.Contains(value); 
            }
            return false; 
        } 

        public int IndexOf(T value) 
        {
            if ((null != _listStore) && (_listStore.Count > 0))
            {
                return _listStore.IndexOf(value); 
            }
            return -1; 
        } 

        public void Insert(int index, T value) 
        {
            if ((index == 0) || ((null != _listStore) && ((index <= _listStore.Count) && (index >= 0))))
            {
                // Make sure we have a place to put the item 
                int minCapacity = 1;
 
                if ((null != _listStore) && (_listStore.Count == _listStore.Capacity)) 
                {
                    // Store is full 
                    minCapacity = Capacity + 1;
                }

                // Make the Capacity at *least* this big 
                Capacity = minCapacity;
 
                _listStore.Insert(index, value); 
                return;
            } 
            throw new ArgumentOutOfRangeException("index");
        }

        public bool Remove(T value) 
        {
            if ((null != _listStore) && (_listStore.Count > 0)) 
            { 
                return _listStore.Remove(value);
            } 
            return false;
        }

        public void RemoveAt(int index) 
        {
            if ((null != _listStore) && ((index < _listStore.Count) && (index >= 0))) 
            { 
                _listStore.RemoveAt(index);
                return; 
            }
            throw new ArgumentOutOfRangeException("index");
        }
 
        public void EnsureIndex(int index)
        { 
            if (index >= 0) 
            {
                int delta = (index + 1) - Count; 
                if (delta > 0)
                {
                    // Grow the store
                    Capacity = index + 1; 

                    T filler = default(T); 
 
                    // Insert filler structs or objects
                    for (int i = 0; i < delta; ++i) 
                    {
                        _listStore.Add(filler);
                    }
                } 
                return;
            } 
            throw new ArgumentOutOfRangeException("index"); 
        }
 
        public T[] ToArray()
        {
            if ((null != _listStore) && (_listStore.Count > 0))
            { 
                return _listStore.ToArray();
            } 
            return null; 
        }
 
        public void CopyTo(T[] array, int index)
        {
            if ((null != _listStore) && (_listStore.Count > 0))
            { 
                _listStore.CopyTo(array, index);
            } 
        } 

        public FrugalObjectList Clone() 
        {
            FrugalObjectList myClone = new FrugalObjectList();

            if (null != _listStore) 
            {
                myClone._listStore = (FrugalListBase)_listStore.Clone(); 
            } 

            return myClone; 
        }

        internal FrugalListBase _listStore;
    } 

    // Use FrugalStructList when only one reference to the list is needed. 
    // The "struct" in FrugalStructList refers to the list itself, not what the list contains. 
#if !SYSTEM_XAML
    [FriendAccessAllowed] // Built into Core, also used by Framework. 
#endif
    internal struct FrugalStructList
    {
        public FrugalStructList(int size) 
        {
            _listStore = null; 
            Capacity = size; 
        }
 
        public FrugalStructList(ICollection collection)
        {
            if (collection.Count > 6)
            { 
                _listStore = new ArrayItemList(collection);
            } 
            else 
            {
                _listStore = null; 
                Capacity = collection.Count;
                foreach (T item in collection)
                {
                    Add(item); 
                }
            } 
        } 

        public FrugalStructList(ICollection collection) 
        {
            if (collection.Count > 6)
            {
                _listStore = new ArrayItemList(collection); 
            }
            else 
            { 
                _listStore = null;
                Capacity = collection.Count; 
                foreach (T item in collection)
                {
                    Add(item);
                } 
            }
        } 
 
        public int Capacity
        { 
            get
            {
                if (null != _listStore)
                { 
                    return _listStore.Capacity;
                } 
                return 0; 
            }
            set 
            {
                int capacity = 0;
                if (null != _listStore)
                { 
                    capacity = _listStore.Capacity;
                } 
                if (capacity < value) 
                {
                    // Need to move to a more complex storage 
                    FrugalListBase newStore;

                    if (value == 1)
                    { 
                        newStore = new SingleItemList();
                    } 
                    else if (value <= 3) 
                    {
                        newStore = new ThreeItemList(); 
                    }
                    else if (value <= 6)
                    {
                        newStore = new SixItemList(); 
                    }
                    else 
                    { 
                        newStore = new ArrayItemList(value);
                    } 

                    if (null != _listStore)
                    {
                        // Move entries in the old store to the new one 
                        newStore.Promote(_listStore);
                    } 
 
                    _listStore = newStore;
                } 
            }
        }

        public int Count 
        {
            get 
            { 
                if (null != _listStore)
                { 
                    return _listStore.Count;
                }
                return 0;
            } 
        }
 
 
        public T this[int index]
        { 
            get
            {
                // If no entry, default(T) is returned
                if ((null != _listStore) && ((index < _listStore.Count) && (index >= 0))) 
                {
                    return _listStore.EntryAt(index); 
                } 
                throw new ArgumentOutOfRangeException("index");
            } 

            set
            {
                // Ensure write success 
                if ((null != _listStore) && ((index < _listStore.Count) && (index >= 0)))
                { 
                    _listStore.SetAt(index, value); 
                    return;
                } 
                throw new ArgumentOutOfRangeException("index");
            }
        }
 
        public int Add(T value)
        { 
            if (null != _listStore) 
            {
                // This is done because forward branches 
                // default prediction is not to be taken
                // making this a CPU win because Add is
                // a common operation.
            } 
            else
            { 
                _listStore = new SingleItemList(); 
            }
 
            FrugalListStoreState myState = _listStore.Add(value);
            if (FrugalListStoreState.Success == myState)
            {
            } 
            else
            { 
                // Need to move to a more complex storage 
                // Allocate the store, promote, and add using the derived classes
                // to avoid virtual method calls 

                if (FrugalListStoreState.ThreeItemList == myState)
                {
                    ThreeItemList newStore = new ThreeItemList(); 

                    // Extract the values from the old store and insert them into the new store 
                    newStore.Promote(_listStore); 

                    // Insert the new item 
                    newStore.Add(value);
                    _listStore = newStore;
                }
                else if (FrugalListStoreState.SixItemList == myState) 
                {
                    SixItemList newStore = new SixItemList(); 
 
                    // Extract the values from the old store and insert them into the new store
                    newStore.Promote(_listStore); 
                    _listStore = newStore;

                    // Insert the new item
                    newStore.Add(value); 
                    _listStore = newStore;
                } 
                else if (FrugalListStoreState.Array == myState) 
                {
                    ArrayItemList newStore = new ArrayItemList(_listStore.Count + 1); 

                    // Extract the values from the old store and insert them into the new store
                    newStore.Promote(_listStore);
                    _listStore = newStore; 

                    // Insert the new item 
                    newStore.Add(value); 
                    _listStore = newStore;
                } 
                else
                {
                    throw new InvalidOperationException(SR.Get(SRID.FrugalList_CannotPromoteBeyondArray));
                } 
            }
            return _listStore.Count - 1; 
        } 

        public void Clear() 
        {
            if (null != _listStore)
            {
                _listStore.Clear(); 
            }
        } 
 
        public bool Contains(T value)
        { 
            if ((null != _listStore) && (_listStore.Count > 0))
            {
                return _listStore.Contains(value);
            } 
            return false;
        } 
 
        public int IndexOf(T value)
        { 
            if ((null != _listStore) && (_listStore.Count > 0))
            {
                return _listStore.IndexOf(value);
            } 
            return -1;
        } 
 
        public void Insert(int index, T value)
        { 
            if ((index == 0) || ((null != _listStore) && ((index <= _listStore.Count) && (index >= 0))))
            {
                // Make sure we have a place to put the item
                int minCapacity = 1; 

                if ((null != _listStore) && (_listStore.Count == _listStore.Capacity)) 
                { 
                    // Store is full
                    minCapacity = Capacity + 1; 
                }

                // Make the Capacity at *least* this big
                Capacity = minCapacity; 

                _listStore.Insert(index, value); 
                return; 
            }
            throw new ArgumentOutOfRangeException("index"); 
        }

        public bool Remove(T value)
        { 
            if ((null != _listStore) && (_listStore.Count > 0))
            { 
                return _listStore.Remove(value); 
            }
            return false; 
        }

        public void RemoveAt(int index)
        { 
            if ((null != _listStore) && ((index < _listStore.Count) && (index >= 0)))
            { 
                _listStore.RemoveAt(index); 
                return;
            } 
            throw new ArgumentOutOfRangeException("index");
        }

        public void EnsureIndex(int index) 
        {
            if (index >= 0) 
            { 
                int delta = (index + 1) - Count;
                if (delta > 0) 
                {
                    // Grow the store
                    Capacity = index + 1;
 
                    T filler = default(T);
 
                    // Insert filler structs or objects 
                    for (int i = 0; i < delta; ++i)
                    { 
                        _listStore.Add(filler);
                    }
                }
                return; 
            }
            throw new ArgumentOutOfRangeException("index"); 
        } 

        public T[] ToArray() 
        {
            if ((null != _listStore) && (_listStore.Count > 0))
            {
                return _listStore.ToArray(); 
            }
            return null; 
        } 

        public void CopyTo(T[] array, int index) 
        {
            if ((null != _listStore) && (_listStore.Count > 0))
            {
                _listStore.CopyTo(array, index); 
            }
        } 
 
        public FrugalStructList Clone()
        { 
            FrugalStructList myClone = new FrugalStructList();

            if (null != _listStore)
            { 
                myClone._listStore = (FrugalListBase)_listStore.Clone();
            } 
 
            return myClone;
        } 

        internal FrugalListBase _listStore;
    }
} 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK