HashCode: Removed unused methods

Author: TalAloni

StandardSocketsHttpHandler/HashCode.cs

@@ -60,10 +60,6 @@ public struct HashCode
         private const uint Prime4 = 668265263U;
         private const uint Prime5 = 374761393U;
 
-        private uint _v1, _v2, _v3, _v4;
-        private uint _queue1, _queue2, _queue3;
-        private uint _length;
-
         private static unsafe uint GenerateGlobalSeed()
         {
             uint result;
@@ -302,129 +298,5 @@ private static uint MixFinal(uint hash)
             hash ^= hash >> 16;
             return hash;
         }
-
-        public void Add<T>(T value)
-        {
-            Add(value?.GetHashCode() ?? 0);
-        }
-
-        public void Add<T>(T value, IEqualityComparer<T> comparer)
-        {
-            Add(comparer != null ? comparer.GetHashCode(value) : (value?.GetHashCode() ?? 0));
-        }
-
-        private void Add(int value)
-        {
-            // The original xxHash works as follows:
-            // 0. Initialize immediately. We can't do this in a struct (no
-            //    default ctor).
-            // 1. Accumulate blocks of length 16 (4 uints) into 4 accumulators.
-            // 2. Accumulate remaining blocks of length 4 (1 uint) into the
-            //    hash.
-            // 3. Accumulate remaining blocks of length 1 into the hash.
-
-            // There is no need for #3 as this type only accepts ints. _queue1,
-            // _queue2 and _queue3 are basically a buffer so that when
-            // ToHashCode is called we can execute #2 correctly.
-
-            // We need to initialize the xxHash32 state (_v1 to _v4) lazily (see
-            // #0) nd the last place that can be done if you look at the
-            // original code is just before the first block of 16 bytes is mixed
-            // in. The xxHash32 state is never used for streams containing fewer
-            // than 16 bytes.
-
-            // To see what's really going on here, have a look at the Combine
-            // methods.
-            
-            var val = (uint)value;
-            
-            // Storing the value of _length locally shaves of quite a few bytes
-            // in the resulting machine code.
-            uint previousLength = _length++;
-            uint position = previousLength % 4;
-
-            // Switch can't be inlined.
-
-            if (position == 0)
-                _queue1 = val;
-            else if (position == 1)
-                _queue2 = val;
-            else if (position == 2)
-                _queue3 = val;
-            else // position == 3
-            {
-                if (previousLength == 3)
-                    Initialize(out _v1, out _v2, out _v3, out _v4);
-
-                _v1 = Round(_v1, _queue1);
-                _v2 = Round(_v2, _queue2);
-                _v3 = Round(_v3, _queue3);
-                _v4 = Round(_v4, val);
-            }
-        }
-
-        public int ToHashCode()
-        {
-            // Storing the value of _length locally shaves of quite a few bytes
-            // in the resulting machine code.
-            uint length = _length;
-            
-            // position refers to the *next* queue position in this method, so
-            // position == 1 means that _queue1 is populated; _queue2 would have
-            // been populated on the next call to Add.
-            uint position = length % 4;
-
-            // If the length is less than 4, _v1 to _v4 don't contain anything
-            // yet. xxHash32 treats this differently.
-
-            uint hash = length < 4 ? MixEmptyState() : MixState(_v1, _v2, _v3, _v4);
-
-            // _length is incremented once per Add(Int32) and is therefore 4
-            // times too small (xxHash length is in bytes, not ints).
-
-            hash += length * 4;
-
-            // Mix what remains in the queue
-
-            // Switch can't be inlined right now, so use as few branches as
-            // possible by manually excluding impossible scenarios (position > 1
-            // is always false if position is not > 0).
-            if (position > 0)
-            {
-                hash = QueueRound(hash, _queue1);
-                if (position > 1)
-                {
-                    hash = QueueRound(hash, _queue2);
-                    if (position > 2)
-                        hash = QueueRound(hash, _queue3);
-                }
-            }
-
-            hash = MixFinal(hash);
-            return (int)hash;
-        }
-
-#pragma warning disable 0809
-        // Obsolete member 'memberA' overrides non-obsolete member 'memberB'. 
-        // Disallowing GetHashCode and Equals is by design
-
-        // * We decided to not override GetHashCode() to produce the hash code 
-        //   as this would be weird, both naming-wise as well as from a
-        //   behavioral standpoint (GetHashCode() should return the object's
-        //   hash code, not the one being computed).
-
-        // * Even though ToHashCode() can be called safely multiple times on
-        //   this implementation, it is not part of the contract. If the
-        //   implementation has to change in the future we don't want to worry
-        //   about people who might have incorrectly used this type.
-
-        [Obsolete("HashCode is a mutable struct and should not be compared with other HashCodes. Use ToHashCode to retrieve the computed hash code.", error: true)]
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        public override int GetHashCode() => throw new NotSupportedException(SR.HashCode_HashCodeNotSupported);
-
-        [Obsolete("HashCode is a mutable struct and should not be compared with other HashCodes.", error: true)]
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        public override bool Equals(object obj) => throw new NotSupportedException(SR.HashCode_EqualityNotSupported);
-#pragma warning restore 0809
     }
 }