ArraySet.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 / ndp / fx / src / DataWeb / Client / System / Data / Services / Client / ArraySet.cs / 1305376 / ArraySet.cs

                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//  
// a set, collection of unordered, distinct objects, implemented as an array
//  
//--------------------------------------------------------------------- 

namespace System.Data.Services.Client 
{
    using System;
    using System.Collections.Generic;
    using System.Diagnostics; 

    /// a set, collection of unordered, distinct objects, implemented as an array 
    /// element type 
    [DebuggerDisplay("Count = {count}")]
    internal struct ArraySet : IEnumerable where T : class 
    {
        /// item array of T
        private T[] items;
 
        /// count of elements in the items array
        private int count; 
 
        /// number of Add and RemoveAt operations
        private int version; 

        /// 
        /// array set with an intial capacity
        ///  
        /// initial capacity
        public ArraySet(int capacity) 
        { 
            this.items = new T[capacity];
            this.count = 0; 
            this.version = 0;
        }

        /// count of elements in the set 
        public int Count
        { 
            get { return this.count; } 
        }
 
        /// get an item from an index in the set
        /// index to access
        public T this[int index]
        { 
            get
            { 
                Debug.Assert(index < this.count); 
                return this.items[index];
            } 
        }

        /// add new element to the set
        /// element to add 
        /// equality comparison function to avoid duplicates
        /// true if actually added, false if a duplicate was discovered 
        public bool Add(T item, Func equalityComparer) 
        {
            if ((null != equalityComparer) && this.Contains(item, equalityComparer)) 
            {
                return false;
            }
 
            int index = this.count++;
            if ((null == this.items) || (index == this.items.Length)) 
            {   // grow array in size, with minimum size being 32 
                Array.Resize(ref this.items, Math.Min(Math.Max(index, 16), Int32.MaxValue / 2) * 2);
            } 

            this.items[index] = item;
            unchecked
            { 
                this.version++;
            } 
 
            return true;
        } 

        /// is the element contained within the set
        /// item to find
        /// comparer 
        /// true if the element is contained
        public bool Contains(T item, Func equalityComparer) 
        { 
            return (0 <= this.IndexOf(item, equalityComparer));
        } 

        /// 
        /// enumerator
        ///  
        /// enumerator
        public IEnumerator GetEnumerator() 
        { 
            for (int i = 0; i < this.count; ++i)
            { 
                yield return this.items[i];
            }
        }
 
        /// 
        /// enumerator 
        ///  
        /// enumerator
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
        {
            return this.GetEnumerator();
        }
 
        /// Find the current index of element within the set
        /// item to find 
        /// comparision function 
        /// index of the item else (-1)
        public int IndexOf(T item, Func comparer) 
        {
            return this.IndexOf(item, IdentitySelect, comparer);
        }
 
        /// Find the current index of element within the set
        /// selected type 
        /// item to find 
        /// selector for item to compare
        /// item to compare 
        /// index of the item else (-1)
        public int IndexOf(K item, Func select, Func comparer)
        {
            T[] array = this.items; 
            if (null != array)
            { 
                int length = this.count; 
                for (int i = 0; i < length; ++i)
                { 
                    if (comparer(item, select(array[i])))
                    {
                        return i;
                    } 
                }
            } 
 
            return -1;
        } 

        /// Remove the matched item from within the set
        /// item to find within the set
        /// comparer to find item to remove 
        /// the item that was actually contained else its default
        public T Remove(T item, Func equalityComparer) 
        { 
            int index = this.IndexOf(item, equalityComparer);
            if (0 <= index) 
            {
                item = this.items[index];
                this.RemoveAt(index);
                return item; 
            }
 
            return default(T); 
        }
 
        /// Remove an item at a specific index from within the set
        /// index of item to remove within the set
        public void RemoveAt(int index)
        { 
            Debug.Assert(unchecked((uint)index < (uint)this.count), "index out of range");
            T[] array = this.items; 
            int lastIndex = --this.count; 
            array[index] = array[lastIndex];
            array[lastIndex] = default(T); 

            if ((0 == lastIndex) && (256 <= array.Length))
            {
                this.items = null; 
            }
            else if ((256 < array.Length) && (lastIndex < array.Length / 4)) 
            {   // shrink to half size when count is a quarter 
                Array.Resize(ref this.items, array.Length / 2);
            } 

            unchecked
            {
                this.version++; 
            }
        } 
 
        /// Sort array based on selected value out of item being stored
        /// selected type 
        /// selector
        /// comparer
        public void Sort(Func selector, Func comparer)
        { 
            if (null != this.items)
            { 
                SelectorComparer scomp; 
                scomp.Selector = selector;
                scomp.Comparer = comparer; 
                Array.Sort(this.items, 0, this.count, scomp);
            }
        }
 
        /// Sets the capacity to the actual number of elements in the ArraySet.
        public void TrimToSize() 
        { 
            Array.Resize(ref this.items, this.count);
        } 

        /// identity selector, returns self
        /// input
        /// output 
        private static T IdentitySelect(T arg)
        { 
            return arg; 
        }
 
        /// Compare selected value out of t
        /// comparison type
        private struct SelectorComparer : IComparer
        { 
            /// Select something out of T
            internal Func Selector; 
 
            /// Comparer of selected value
            internal Func Comparer; 

            /// Compare
            /// x
            /// y 
            /// int
            int IComparer.Compare(T x, T y) 
            { 
                return this.Comparer(this.Selector(x), this.Selector(y));
            } 
        }
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

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