Beispiel #1
0
        private void IncreaseCapacity()
        {
            int min = this.m_count * 2;

            if (min < 0)
            {
                min = this.m_count;
            }
            int prime = HashHelpers.GetPrime(min);

            if (prime <= this.m_count)
            {
                throw new ArgumentException(SR.GetString("Arg_HSCapacityOverflow"));
            }
            Slot[] destinationArray = new Slot[prime];
            if (this.m_slots != null)
            {
                Array.Copy(this.m_slots, 0, destinationArray, 0, this.m_lastIndex);
            }
            int[] numArray = new int[prime];
            for (int i = 0; i < this.m_lastIndex; i++)
            {
                int index = destinationArray[i].hashCode % prime;
                destinationArray[i].next = numArray[index] - 1;
                numArray[index]          = i + 1;
            }
            this.m_slots   = destinationArray;
            this.m_buckets = numArray;
        }
Beispiel #2
0
        private void Initialize(int capacity)
        {
            int prime = HashHelpers.GetPrime(capacity);

            this.m_buckets = new int[prime];
            this.m_slots   = new Slot[prime];
        }
Beispiel #3
0
 public void TrimExcess()
 {
     if (this.m_count == 0)
     {
         this.m_buckets = null;
         this.m_slots   = null;
         this.m_version++;
     }
     else
     {
         int    prime     = HashHelpers.GetPrime(this.m_count);
         Slot[] slotArray = new Slot[prime];
         int[]  numArray  = new int[prime];
         int    index     = 0;
         for (int i = 0; i < this.m_lastIndex; i++)
         {
             if (this.m_slots[i].hashCode >= 0)
             {
                 slotArray[index] = this.m_slots[i];
                 int num4 = slotArray[index].hashCode % prime;
                 slotArray[index].next = numArray[num4] - 1;
                 numArray[num4]        = index + 1;
                 index++;
             }
         }
         this.m_lastIndex = index;
         this.m_slots     = slotArray;
         this.m_buckets   = numArray;
         this.m_freeList  = -1;
     }
 }
Beispiel #4
0
 private void Initialize(int capacity) { 
     int size = HashHelpers.GetPrime(capacity); 
     buckets = new int[size];
     for (int i = 0; i < buckets.Length; i++) buckets[i] = -1; 
     entries = new Entry[size];
     freeList = -1;
 }
Beispiel #5
0
        private void Initialize(int capacity)
        {
            int size = HashHelpers.GetPrime(capacity);

            _buckets = new int[size];
            _slots   = new Slot[size];
        }
Beispiel #6
0
 public void TrimExcess()
 {
     if (_count == 0)
     {
         _buckets = null;
         _slots   = null;
         _version++;
     }
     else
     {
         int    newSize    = HashHelpers.GetPrime(_count);
         Slot[] newSlots   = new Slot[newSize];
         int[]  newBuckets = new int[newSize];
         int    newIndex   = 0;
         for (int i = 0; i < _lastIndex; i++)
         {
             if (_slots[i].hashCode >= 0)
             {
                 newSlots[newIndex] = _slots[i];
                 int bucket = newSlots[newIndex].hashCode % newSize;
                 newSlots[newIndex].next = newBuckets[bucket] - 1;
                 newBuckets[bucket]      = newIndex + 1;
                 newIndex++;
             }
         }
         _lastIndex = newIndex;
         _slots     = newSlots;
         _buckets   = newBuckets;
         _freeList  = -1;
     }
 }
Beispiel #7
0
        /// <summary>
        /// Initializes buckets and slots arrays. Uses suggested capacity by finding next prime
        /// greater than or equal to capacity.
        /// </summary>
        /// <param name="capacity"></param>
        private void Initialize(int capacity)
        {
            Debug.Assert(m_buckets == null, "Initialize was called but m_buckets was non-null");

            int size = HashHelpers.GetPrime(capacity);

            m_buckets = new int[size];
            m_slots   = new Slot[size];
        }
Beispiel #8
0
        private void Initialize(int capacity)
        {
            int prime = HashHelpers.GetPrime(capacity);

            this.buckets = new int[prime];
            for (int i = 0; i < this.buckets.Length; i++)
            {
                this.buckets[i] = -1;
            }
            this.entries  = new Entry <TKey, TValue> [prime];
            this.freeList = -1;
        }
Beispiel #9
0
        private int Initialize(int capacity)
        {
            var size    = HashHelpers.GetPrime(capacity);
            var buckets = new SegmentedList <int>(defaultSegmentSize, size);
            var entries = new SegmentedList <Entry>(defaultSegmentSize, size);

            // Assign member variables after both arrays allocated to guard against corruption from OOM if second fails
            _freeList          = -1;
            _fastModMultiplier = HashHelpers.GetFastModMultiplier((uint)buckets.Capacity);
            _buckets           = buckets;
            _entries           = entries;

            return(size);
        }
Beispiel #10
0
        /// <summary>
        /// Sets the capacity of this list to the size of the list (rounded up to nearest prime),
        /// unless count is 0, in which case we release references.
        ///
        /// This method can be used to minimize a list's memory overhead once it is known that no
        /// new elements will be added to the list. To completely clear a list and release all
        /// memory referenced by the list, execute the following statements:
        ///
        /// list.Clear();
        /// list.TrimExcess();
        /// </summary>
        public void TrimExcess()
        {
            Debug.Assert(m_count >= 0, "m_count is negative");

            if (m_count == 0)
            {
                // if count is zero, clear references
                m_buckets = null;
                m_slots   = null;
                m_version++;
            }
            else
            {
                Debug.Assert(m_buckets != null, "m_buckets was null but m_count > 0");

                // similar to IncreaseCapacity but moves down elements in case add/remove/etc
                // caused fragmentation
                int    newSize    = HashHelpers.GetPrime(m_count);
                Slot[] newSlots   = new Slot[newSize];
                int[]  newBuckets = new int[newSize];

                // move down slots and rehash at the same time. newIndex keeps track of current
                // position in newSlots array
                int newIndex = 0;
                for (int i = 0; i < m_lastIndex; i++)
                {
                    if (m_slots[i].hashCode >= 0)
                    {
                        newSlots[newIndex] = m_slots[i];

                        // rehash
                        int bucket = newSlots[newIndex].hashCode % newSize;
                        newSlots[newIndex].next = newBuckets[bucket] - 1;
                        newBuckets[bucket]      = newIndex + 1;

                        newIndex++;
                    }
                }

                Debug.Assert(newSlots.Length <= m_slots.Length, "capacity increased after TrimExcess");

                m_lastIndex = newIndex;
                m_slots     = newSlots;
                m_buckets   = newBuckets;
                m_freeList  = -1;
            }
        }
Beispiel #11
0
        private void Resize()
        {
            int prime = HashHelpers.GetPrime(this.count * 2);

            int[] numArray = new int[prime];
            for (int i = 0; i < numArray.Length; i++)
            {
                numArray[i] = -1;
            }
            Entry <TKey, TValue>[] destinationArray = new Entry <TKey, TValue> [prime];
            Array.Copy(this.entries, 0, destinationArray, 0, this.count);
            for (int j = 0; j < this.count; j++)
            {
                int index = destinationArray[j].hashCode % prime;
                destinationArray[j].next = numArray[index];
                numArray[index]          = j;
            }
            this.buckets = numArray;
            this.entries = destinationArray;
        }
        private void Resize()
        {
            int newSize = HashHelpers.GetPrime(count * 2);

            int[] newBuckets = new int[newSize];
            for (int i = 0; i < newBuckets.Length; i++)
            {
                newBuckets[i] = -1;
            }
            Entry[] newEntries = new Entry[newSize];
            Array.Copy(entries, 0, newEntries, 0, count);
            for (int i = 0; i < count; i++)
            {
                int bucket = newEntries[i].hashCode % newSize;
                newEntries[i].next = newBuckets[bucket];
                newBuckets[bucket] = i;
            }
            buckets = newBuckets;
            entries = newEntries;
        }
Beispiel #13
0
        /// <summary>
        /// Expand to new capacity. New capacity is next prime greater than or equal to suggested
        /// size. This is called when the underlying array is filled. This performs no
        /// defragmentation, allowing faster execution; note that this is reasonable since
        /// AddIfNotPresent attempts to insert new elements in re-opened spots.
        /// </summary>
        /// <param name="sizeSuggestion"></param>
        private void IncreaseCapacity()
        {
            Debug.Assert(m_buckets != null, "IncreaseCapacity called on a set with no elements");

            // Handle overflow conditions. Try to expand capacity by GrowthFactor. If that causes
            // overflow, use size suggestion of m_count and see if HashHelpers returns a value
            // greater than that. If not, capacity can't be increased so throw capacity overflow
            // exception.
            int sizeSuggestion = unchecked (m_count * GrowthFactor);

            if (sizeSuggestion < 0)
            {
                sizeSuggestion = m_count;
            }
            int newSize = HashHelpers.GetPrime(sizeSuggestion);

            if (newSize <= m_count)
            {
                throw new ArgumentException(SR.GetString(SR.Arg_HSCapacityOverflow));
            }

            // Able to increase capacity; copy elements to larger array and rehash
            Slot[] newSlots = new Slot[newSize];
            if (m_slots != null)
            {
                Array.Copy(m_slots, 0, newSlots, 0, m_lastIndex);
            }

            int[] newBuckets = new int[newSize];
            for (int i = 0; i < m_lastIndex; i++)
            {
                int bucket = newSlots[i].hashCode % newSize;
                newSlots[i].next   = newBuckets[bucket] - 1;
                newBuckets[bucket] = i + 1;
            }
            m_slots   = newSlots;
            m_buckets = newBuckets;
        }