Lightless-Sync/LightlessClient
8
1
Fork 2
Code Issues 2 Pull Requests 1 Actions Packages Projects Releases 52 Wiki Activity
Files
9dd8e19fb79b22f1575ea08c67d7edc5ded4b22b
LightlessClient/LightlessSync/ThirdParty/Nanomesh/Collections/FastHashSet.cs
azyges 54d6a0a1a4 reworked mesh decimation yes
2026-01-19 09:50:54 +09:00

3873 lines
147 KiB
C#
Raw Blame History

//#define Exclude_Check_For_Set_Modifications_In_Enumerator
//#define Exclude_Check_For_Is_Disposed_In_Enumerator
//#define Exclude_No_Hash_Array_Implementation
//#define Exclude_Cache_Optimize_Resize
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace Nanomesh
{
// didn't implement ISerializable and IDeserializationCallback
// these are implemented in the .NET HashSet
// the 7th HashSet constructor has params for serialization -implement that if serialization is implemented
// also add using System.Runtime.Serialization;
public class FastHashSet<T> : ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, ISet<T>
{
private const int MaxSlotsArraySize = int.MaxValue - 2;
// this is the size of the non-hash array used to make small counts of items faster
private const int InitialArraySize = 8;
// this is the # of initial nodes for the slots array after going into hashing after using the noHashArray
// this is 16 + 1; the + 1 is for the first node (node at index 0) which doesn't get used because 0 is the NullIndex
private const int InitialSlotsArraySize = 17;
// this indicates end of chain if the nextIndex of a node has this value and also indicates no chain if a buckets array element has this value
private const int NullIndex = 0;
// if a node's nextIndex = this value, then it is a blank node - this isn't a valid nextIndex when unmarked and also when marked (because we don't allow int.MaxValue items)
private const int BlankNextIndexIndicator = int.MaxValue;
// use this instead of the negate negative logic when getting hashindex - this saves an if (hashindex < 0) which can be the source of bad branch prediction
private const int HighBitNotSet = unchecked(0b0111_1111_1111_1111_1111_1111_1111_1111);
// The Mark... constants below are for marking, unmarking, and checking if an item is marked.
// This is usefull for some set operations.
// doing an | (bitwise or) with this and the nextIndex marks the node, setting the bit back will give the original nextIndex value
private const int MarkNextIndexBitMask = unchecked((int)0b1000_0000_0000_0000_0000_0000_0000_0000);
// doing an & (bitwise and) with this and the nextIndex sets it back to the original value (unmarks it)
private const int MarkNextIndexBitMaskInverted = ~MarkNextIndexBitMask;
// FastHashSet doesn't allow using an item/node index as high as int.MaxValue.
// There are 2 reasons for this: The first is that int.MaxValue is used as a special indicator
private const int LargestPrimeLessThanMaxInt = 2147483629;
// these are primes above the .75 loadfactor of the power of 2 except from 30,000 through 80,000, where we conserve space to help with cache space
private static readonly int[] bucketsSizeArray = { 11, 23, 47, 89, 173, 347, 691, 1367, 2741, 5471, 10_937, 19_841/*16_411/*21_851*/, 40_241/*32_771/*43_711*/, 84_463/*65_537/*87_383*/, /*131_101*/174_767,
/*262_147*/349_529, 699_053, 1_398_107, 2_796_221, 5_592_407, 11_184_829, 22_369_661, 44_739_259, 89_478_503, 17_8956_983, 35_7913_951, 715_827_947, 143_1655_777, LargestPrimeLessThanMaxInt};
// the buckets array can be pre-allocated to a large size, but it's not good to use that entire size for hashing because of cache locality
// instead do at most 3 size steps (for 3 levels of cache) before using its actual allocated size
// when an initial capacity is selected in the constructor or later, allocate the required space for the buckets array, but only use a subset of this space until the load factor is met
// limit the # of used elements to optimize for cpu caches
private static readonly int[] bucketsSizeArrayForCacheOptimization = { 3_371, 62_851, 701_819 };
private const double LoadFactorConst = .75;
private int currentIndexIntoBucketsSizeArray;
private int bucketsModSize;
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
private int incrementForEverySetModification;
#endif
// resize the buckets array when the count reaches this value
private int resizeBucketsCountThreshold;
private int count;
private int nextBlankIndex;
// this is needed because if items are removed, they get added into the blank list starting at nextBlankIndex, but we may want to TrimExcess capacity, so this is a quick way to see what the ExcessCapacity is
private int firstBlankAtEndIndex;
private readonly IEqualityComparer<T> comparer;
// make the buckets size a primary number to make the mod function less predictable
private int[] buckets;
private TNode[] slots;
#if !Exclude_No_Hash_Array_Implementation
// used for small sets - when the count of items is small, it is usually faster to just use an array of the items and not do hashing at all (this can also use slightly less memory)
// There may be some cases where the sets can be very small, but there can be very many of these sets. This can be good for these cases.
private T[] noHashArray;
#endif
internal enum FoundType
{
FoundFirstTime,
FoundNotFirstTime,
NotFound
}
internal struct TNode
{
// the cached hash code of the item - this is so we don't have to call GetHashCode multiple times, also doubles as a nextIndex for blanks, since blank nodes don't need a hash code
public int hashOrNextIndexForBlanks;
public int nextIndex;
public T item;
public TNode(T elem, int nextIndex, int hash)
{
item = elem;
this.nextIndex = nextIndex;
hashOrNextIndexForBlanks = hash;
}
}
// 1 - same constructor params as HashSet
/// <summary>Initializes a new instance of the FastHashSet&lt;<typeparamref name="T"/>&gt;.</summary>
/// <typeparam name="T">The element type of the FastHashSet.</typeparam>
public FastHashSet()
{
comparer = EqualityComparer<T>.Default;
SetInitialCapacity(InitialArraySize);
}
// 2 - same constructor params as HashSet
/// <summary>Initializes a new instance of the FastHashSet&lt;<typeparamref name="T"/>&gt;.</summary>
/// <typeparam name="T">The element type of the FastHashSet.</typeparam>
/// <param name="collection">The collection to initially add to the FastHashSet.</param>
public FastHashSet(IEnumerable<T> collection)
{
comparer = EqualityComparer<T>.Default;
AddInitialEnumerable(collection);
}
// 3 - same constructor params as HashSet
/// <summary>Initializes a new instance of the FastHashSet&lt;<typeparamref name="T"/>&gt;.</summary>
/// <typeparam name="T">The element type of the FastHashSet.</typeparam>
/// <param name="comparer">The IEqualityComparer to use for determining equality of elements in the FastHashSet.</param>
public FastHashSet(IEqualityComparer<T> comparer)
{
this.comparer = comparer ?? EqualityComparer<T>.Default;
SetInitialCapacity(InitialArraySize);
}
// 4 - same constructor params as HashSet
/// <summary>Initializes a new instance of the FastHashSet&lt;<typeparamref name="T"/>&gt;.</summary>
/// <typeparam name="T">The element type of the FastHashSet.</typeparam>
/// <param name="capacity">The initial capacity of the FastHashSet.</param>
public FastHashSet(int capacity)
{
comparer = EqualityComparer<T>.Default;
SetInitialCapacity(capacity);
}
// 5 - same constructor params as HashSet
/// <summary>Initializes a new instance of the FastHashSet&lt;<typeparamref name="T"/>&gt;.</summary>
/// <typeparam name="T">The element type of the FastHashSet</typeparam>
/// <param name="collection">The collection to initially add to the FastHashSet.</param>
/// <param name="comparer">The IEqualityComparer to use for determining equality of elements in the FastHashSet.</param>
public FastHashSet(IEnumerable<T> collection, IEqualityComparer<T> comparer)
{
this.comparer = comparer ?? EqualityComparer<T>.Default;
AddInitialEnumerable(collection);
}
// 6 - same constructor params as HashSet
/// <summary>Initializes a new instance of the FastHashSet&lt;<typeparamref name="T"/>&gt;.</summary>
/// <typeparam name="T">The element type of the set</typeparam>
/// <param name="capacity">The initial capacity of the FastHashSet.</param>
/// <param name="comparer">The IEqualityComparer to use for determining equality of elements in the FastHashSet.</param>
public FastHashSet(int capacity, IEqualityComparer<T> comparer)
{
this.comparer = comparer ?? EqualityComparer<T>.Default;
SetInitialCapacity(capacity);
}
/// <summary>Initializes a new instance of the FastHashSet&lt;<typeparamref name="T"/>&gt;.</summary>
/// <typeparam name="T">The element type of the FastHashSet</typeparam>
/// <param name="collection">The collection to initially add to the FastHashSet.</param>
/// <param name="areAllCollectionItemsDefinitelyUnique">True if the collection items are all unique. The collection items can be added more quickly if they are known to be unique.</param>
/// <param name="capacity">The initial capacity of the FastHashSet.</param>
/// <param name="comparer">The IEqualityComparer to use for determining equality of elements in the FastHashSet.</param>
#if false // removed for now because it's probably not that useful and needs some changes to be correct
public FastHashSet(IEnumerable<T> collection, bool areAllCollectionItemsDefinitelyUnique, int capacity, IEqualityComparer<T> comparer = null)
{
this.comparer = comparer ?? EqualityComparer<T>.Default;
SetInitialCapacity(capacity);
if (areAllCollectionItemsDefinitelyUnique)
{
// this and the call below must deal correctly with an initial capacity already set
AddInitialUniqueValuesEnumerable(collection);
}
else
{
AddInitialEnumerable(collection);
}
}
#endif
private void AddInitialUniqueValuesEnumerable(IEnumerable<T> collection)
{
int itemsCount = 0;
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
nextBlankIndex = 1;
foreach (T item in collection)
{
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
int index = buckets[hashIndex];
buckets[hashIndex] = nextBlankIndex;
ref TNode t = ref slots[nextBlankIndex];
t.hashOrNextIndexForBlanks = hash;
t.nextIndex = index;
t.item = item;
nextBlankIndex++;
itemsCount++;
}
#if !Exclude_No_Hash_Array_Implementation
}
else
{
foreach (T item in collection)
{
noHashArray[itemsCount++] = item;
}
}
#endif
count = itemsCount;
firstBlankAtEndIndex = nextBlankIndex;
}
private void AddInitialEnumerableWithEnoughCapacity(IEnumerable<T> collection)
{
// this assumes we are hashing
foreach (T item in collection)
{
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
for (int index = buckets[hashIndex]; index != NullIndex;)
{
ref TNode t = ref slots[index];
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
goto Found; // item was found
}
index = t.nextIndex;
}
ref TNode tBlank = ref slots[nextBlankIndex];
tBlank.hashOrNextIndexForBlanks = hash;
tBlank.nextIndex = buckets[hashIndex];
tBlank.item = item;
buckets[hashIndex] = nextBlankIndex;
nextBlankIndex++;
#if !Exclude_Cache_Optimize_Resize
count++;
if (count >= resizeBucketsCountThreshold)
{
ResizeBucketsArrayForward(GetNewBucketsArraySize());
}
#endif
Found:;
}
firstBlankAtEndIndex = nextBlankIndex;
#if Exclude_Cache_Optimize_Resize
count = nextBlankIndex - 1;
#endif
}
private void AddInitialEnumerable(IEnumerable<T> collection)
{
FastHashSet<T> fhset = collection as FastHashSet<T>;
if (fhset != null && Equals(fhset.Comparer, Comparer))
{
// a set with the same item comparer must have all items unique
// so Count will be the exact Count of the items added
// also don't have to check for equals of items
// and a FastHashSet has the additional advantage of not having to call GetHashCode() if it is hashing
// and it has access to the internal slots array so we don't have to use the foreach/enumerator
int count = fhset.Count;
SetInitialCapacity(count);
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
if (fhset.IsHashing)
{
#endif
// this FastHashSet is hashing and collection is a FastHashSet (with equal comparer) and it is also hashing
nextBlankIndex = 1;
int maxNodeIndex = fhset.slots.Length - 1;
if (fhset.firstBlankAtEndIndex <= maxNodeIndex)
{
maxNodeIndex = fhset.firstBlankAtEndIndex - 1;
}
for (int i = 1; i <= maxNodeIndex; i++)
{
ref TNode t2 = ref fhset.slots[i];
if (t2.nextIndex != BlankNextIndexIndicator)
{
int hash = t2.hashOrNextIndexForBlanks;
int hashIndex = hash % bucketsModSize;
ref TNode t = ref slots[nextBlankIndex];
t.hashOrNextIndexForBlanks = hash;
t.nextIndex = buckets[hashIndex];
t.item = t2.item;
buckets[hashIndex] = nextBlankIndex;
nextBlankIndex++;
}
}
this.count = count;
firstBlankAtEndIndex = nextBlankIndex;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
// this FastHashSet is hashing and collection is a FastHashSet (with equal comparer) and it is NOT hashing
nextBlankIndex = 1;
for (int i = 0; i < fhset.count; i++)
{
ref T item = ref noHashArray[i];
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
ref TNode t = ref slots[nextBlankIndex];
t.hashOrNextIndexForBlanks = hash;
t.nextIndex = buckets[hashIndex];
t.item = item;
buckets[hashIndex] = nextBlankIndex;
nextBlankIndex++;
}
}
}
else
{
// this FastHashSet is not hashing
AddInitialUniqueValuesEnumerable(collection);
}
#endif
}
else
{
// collection is not a FastHashSet with equal comparer
HashSet<T> hset = collection as HashSet<T>;
if (hset != null && Equals(hset.Comparer, Comparer))
{
// a set with the same item comparer must have all items unique
// so Count will be the exact Count of the items added
// also don't have to check for equals of items
int usedCount = hset.Count;
SetInitialCapacity(usedCount);
AddInitialUniqueValuesEnumerable(collection);
}
else
{
ICollection<T> coll = collection as ICollection<T>;
if (coll != null)
{
SetInitialCapacity(coll.Count);
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
// call SetInitialCapacity and then set the capacity back to get rid of the excess?
AddInitialEnumerableWithEnoughCapacity(collection);
TrimExcess();
#if !Exclude_No_Hash_Array_Implementation
}
else
{
foreach (T item in collection)
{
Add(item);
}
}
#endif
}
else
{
SetInitialCapacity(InitialArraySize);
foreach (T item in collection)
{
Add(in item);
}
}
}
}
}
private void SetInitialCapacity(int capacity)
{
#if !Exclude_No_Hash_Array_Implementation
if (capacity > InitialArraySize)
{
#endif
// skip using the array and go right into hashing
InitHashing(capacity);
#if !Exclude_No_Hash_Array_Implementation
}
else
{
CreateNoHashArray(); // don't set the capacity/size of the noHashArray
}
#endif
}
#if !Exclude_No_Hash_Array_Implementation
// this function can be called to switch from using the noHashArray and start using the hashing arrays (slots and buckets)
// this function can also be called before noHashArray is even allocated in order to skip using the array and go right into hashing
private void SwitchToHashing(int capacityIncrease = -1)
{
InitHashing(capacityIncrease);
if (noHashArray != null)
{
// i is the index into noHashArray
for (int i = 0; i < count; i++)
{
ref T item = ref noHashArray[i];
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
ref TNode t = ref slots[nextBlankIndex];
t.hashOrNextIndexForBlanks = hash;
t.nextIndex = buckets[hashIndex];
t.item = item;
buckets[hashIndex] = nextBlankIndex;
nextBlankIndex++;
}
noHashArray = null; // this array can now be garbage collected because it is no longer referenced
}
firstBlankAtEndIndex = nextBlankIndex;
}
#endif
private void InitHashing(int capacity = -1)
{
int newSlotsArraySize;
int newBucketsArraySize;
int newBucketsArrayModSize;
bool setThresh = false;
if (capacity == -1)
{
newSlotsArraySize = InitialSlotsArraySize;
newBucketsArraySize = bucketsSizeArray[0];
if (newBucketsArraySize < newSlotsArraySize)
{
for (currentIndexIntoBucketsSizeArray = 1; currentIndexIntoBucketsSizeArray < bucketsSizeArray.Length; currentIndexIntoBucketsSizeArray++)
{
newBucketsArraySize = bucketsSizeArray[currentIndexIntoBucketsSizeArray];
if (newBucketsArraySize >= newSlotsArraySize)
{
break;
}
}
}
newBucketsArrayModSize = newBucketsArraySize;
}
else
{
newSlotsArraySize = capacity + 1; // add 1 to accomodate blank first node (node at 0 index)
newBucketsArraySize = FastHashSetUtil.GetEqualOrClosestHigherPrime((int)(newSlotsArraySize / LoadFactorConst));
#if !Exclude_Cache_Optimize_Resize
if (newBucketsArraySize > bucketsSizeArrayForCacheOptimization[0])
{
newBucketsArrayModSize = bucketsSizeArrayForCacheOptimization[0];
setThresh = true;
}
else
#endif
{
newBucketsArrayModSize = newBucketsArraySize;
}
}
if (newSlotsArraySize == 0)
{
// this is an error, the int.MaxValue has been used for capacity and we require more - throw an Exception for this
// could try this with HashSet and see what exception it throws?
throw new InvalidOperationException("Exceeded maximum number of items allowed for this container.");
}
slots = new TNode[newSlotsArraySize]; // the slots array has an extra item as it's first item (0 index) that is for available items - the memory is wasted, but it simplifies things
buckets = new int[newBucketsArraySize]; // these will be initially set to 0, so make 0 the blank(available) value and reduce all indices by one to get to the actual index into the slots array
bucketsModSize = newBucketsArrayModSize;
if (setThresh)
{
resizeBucketsCountThreshold = (int)(newBucketsArrayModSize * LoadFactorConst);
}
else
{
CalcUsedItemsLoadFactorThreshold();
}
nextBlankIndex = 1; // start at 1 because 0 is the blank item
firstBlankAtEndIndex = nextBlankIndex;
}
#if !Exclude_No_Hash_Array_Implementation
private void CreateNoHashArray()
{
noHashArray = new T[InitialArraySize];
}
#endif
private void CalcUsedItemsLoadFactorThreshold()
{
if (buckets != null)
{
if (buckets.Length == bucketsModSize)
{
resizeBucketsCountThreshold = slots.Length; // with this value, the buckets array should always resize after the slots array (in the same public function call)
}
else
{
// when buckets.Length > bucketsModSize, this means we want to more slowly increase the bucketsModSize to keep things in the L1-3 caches
resizeBucketsCountThreshold = (int)(bucketsModSize * LoadFactorConst);
}
}
}
/// <summary>True if the FastHashSet if read-only. This is always false. This is only present to implement ICollection<T>, it has no real value otherwise.</summary>
bool ICollection<T>.IsReadOnly => false;
/// <summary>Copies all elements of the FastHashSet&lt;<typeparamref name="T"/>&gt; into an array starting at arrayIndex. This implements ICollection<T>.CopyTo(T[], Int32).</summary>
/// <param name="array">The destination array.</param>
/// <param name="arrayIndex">The starting array index to copy elements to.</param>
public void CopyTo(T[] array, int arrayIndex)
{
CopyTo(array, arrayIndex, count);
}
/// <summary>Copies all elements of the FastHashSet&lt;<typeparamref name="T"/>&gt; into an array starting at the first array index.</summary>
/// <param name="array">The destination array.</param>
public void CopyTo(T[] array)
{
CopyTo(array, 0, count);
}
// not really sure how this can be useful because you never know exactly what elements you will get copied (unless you copy them all)
// it could easily vary for different implementations or if items were added in different order or if items were added removed and then added, instead of just added
/// <summary>Copies count number of elements of the FastHashSet&lt;<typeparamref name="T"/>&gt; into an array starting at arrayIndex.</summary>
/// <param name="array">The destination array.</param>
/// <param name="arrayIndex">The starting array index to copy elements to.</param>
/// <param name="count">The number of elements to copy.</param>
public void CopyTo(T[] array, int arrayIndex, int count)
{
if (array == null)
{
throw new ArgumentNullException(nameof(array), "Value cannot be null.");
}
if (arrayIndex < 0)
{
throw new ArgumentOutOfRangeException(nameof(arrayIndex), "Non negative number is required.");
}
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count), "Non negative number is required.");
}
if (arrayIndex + count > array.Length)
{
throw new ArgumentException("Destination array is not long enough to copy all the items in the collection. Check array index and length.");
}
if (count == 0)
{
return;
}
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int pastNodeIndex = slots.Length;
if (firstBlankAtEndIndex < pastNodeIndex)
{
pastNodeIndex = firstBlankAtEndIndex;
}
int cnt = 0;
for (int i = 1; i < pastNodeIndex; i++)
{
if (slots[i].nextIndex != BlankNextIndexIndicator)
{
array[arrayIndex++] = slots[i].item;
if (++cnt == count)
{
break;
}
}
}
#if !Exclude_No_Hash_Array_Implementation
}
else
{
int cnt = this.count;
if (cnt > count)
{
cnt = count;
}
// for small arrays, I think the for loop below will actually be faster than Array.Copy because of the overhead of that function - could test this
//Array.Copy(noHashArray, 0, array, arrayIndex, cnt);
for (int i = 0; i < cnt; i++)
{
array[arrayIndex++] = noHashArray[i];
}
}
#endif
}
/// <summary>
/// Gets the IEqualityComparer used to determine equality for items of this FastHashSet.
/// </summary>
public IEqualityComparer<T> Comparer =>
// if not set, return the default - this is what HashSet does
// even if it is set to null explicitly, it will still return the default
// this behavior is implmented in the constructor
comparer;
/// <summary>
/// >Gets the number of items in this FastHashSet.
/// </summary>
public int Count => count;
// this is the percent of used items to all items (used + blank/available)
// at which point any additional added items will
// first resize the buckets array to the next prime to avoid too many collisions and chains becoming too large
/// <summary>
/// Gets the fraction of 'used items count' divided by 'used items plus available/blank items count'.
/// The buckets array is resized when adding items and this fraction is reached, so this is the minimum LoadFactor for the buckets array.
/// </summary>
public double LoadFactor => LoadFactorConst;
// this is the capacity that can be trimmed with TrimExcessCapacity
// items that were removed from the hash arrays can't be trimmed by calling TrimExcessCapacity, only the blank items at the end
// items that were removed from the noHashArray can be trimmed by calling TrimExcessCapacity because the items after are moved to fill the blank space
/// <summary>
/// Gets the capacity that can be trimmed with TrimExcessCapacity.
/// </summary>
public int ExcessCapacity
{
get
{
int excessCapacity;
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
excessCapacity = slots.Length - firstBlankAtEndIndex;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
excessCapacity = noHashArray.Length - count;
}
#endif
return excessCapacity;
}
}
/// <summary>
/// Gets the capacity of the FastHashSet, which is the number of elements that can be contained without resizing.
/// </summary>
public int Capacity
{
get
{
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
return slots.Length - 1; // subtract 1 for blank node at 0 index
#if !Exclude_No_Hash_Array_Implementation
}
else
{
return noHashArray.Length;
}
#endif
}
}
/// <summary>
/// Gets the size of the next capacity increase of the FastHashSet.
/// </summary>
public int NextCapacityIncreaseSize => GetNewSlotsArraySizeIncrease(out int oldSlotsArraySize);
/// <summary>
/// Gets the count of items when the next capacity increase (resize) of the FastHashSet will happen.
/// </summary>
public int NextCapacityIncreaseAtCount => resizeBucketsCountThreshold;
public bool IsHashing => noHashArray == null;
// the actual capacity at the end of this function may be more than specified
// (in the case when it was more before this function was called - nothing is trimmed by this function, or in the case that slighly more capacity was allocated by this function)
/// <summary>
/// Allocate enough space (or make sure existing space is enough) for capacity number of items to be stored in the FastHashSet without any further allocations.
/// </summary>
/// <param name="capacity">The capacity to ensure.</param>
/// <returns>The actual capacity at the end of this function.</returns>
public int EnsureCapacity(int capacity)
{
// this function is only in .net core for HashSet as of 4/15/2019
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
int currentCapacity;
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
currentCapacity = slots.Length - count;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
currentCapacity = noHashArray.Length - count;
}
#endif
if (currentCapacity < capacity)
{
IncreaseCapacity(capacity - currentCapacity);
}
// this should be the number where the next lowest number would force a resize of buckets array with the current loadfactor and the entire slots array is full
int calcedNewBucketsArraySize = (int)(slots.Length / LoadFactorConst) + 1;
if (calcedNewBucketsArraySize < 0 && calcedNewBucketsArraySize > LargestPrimeLessThanMaxInt)
{
calcedNewBucketsArraySize = LargestPrimeLessThanMaxInt;
}
else
{
calcedNewBucketsArraySize = FastHashSetUtil.GetEqualOrClosestHigherPrime(calcedNewBucketsArraySize);
}
if (buckets.Length < calcedNewBucketsArraySize)
{
// -1 means stop trying to increase the size based on the array of primes
// instead calc based on 2 * existing length and then get the next higher prime
currentIndexIntoBucketsSizeArray = -1;
ResizeBucketsArrayForward(calcedNewBucketsArraySize);
}
return slots.Length - count;
}
// return true if bucketsModSize was set, false otherwise
private bool CheckForModSizeIncrease()
{
if (bucketsModSize < buckets.Length)
{
// instead of array, just have 3 constants
int partLength = (int)(buckets.Length * .75);
int size0 = bucketsSizeArrayForCacheOptimization[0];
int size1 = bucketsSizeArrayForCacheOptimization[1];
if (bucketsModSize == size0)
{
if (size1 <= partLength)
{
bucketsModSize = size1;
return true;
}
else
{
bucketsModSize = buckets.Length;
return true;
}
}
else
{
int size2 = bucketsSizeArrayForCacheOptimization[2];
if (bucketsModSize == size1)
{
if (size2 <= partLength)
{
bucketsModSize = size2;
return true;
}
else
{
bucketsModSize = buckets.Length;
return true;
}
}
else if (bucketsModSize == size2)
{
bucketsModSize = buckets.Length;
return true;
}
}
}
return false;
}
private int GetNewSlotsArraySizeIncrease(out int oldArraySize)
{
if (slots != null)
{
oldArraySize = slots.Length;
}
else
{
oldArraySize = InitialSlotsArraySize; // this isn't the old array size, but it is the initial size we should start at
}
int increaseInSize;
if (oldArraySize == 1)
{
increaseInSize = InitialSlotsArraySize - 1;
}
else
{
increaseInSize = oldArraySize - 1;
}
int maxIncreaseInSize = MaxSlotsArraySize - oldArraySize;
if (increaseInSize > maxIncreaseInSize)
{
increaseInSize = maxIncreaseInSize;
}
return increaseInSize;
}
// if the value returned gets used and that value is different than the current buckets.Length, then the calling code should increment currentIndexIntoSizeArray because this would now be the current
private int GetNewBucketsArraySize()
{
int newArraySize;
if (currentIndexIntoBucketsSizeArray >= 0)
{
if (currentIndexIntoBucketsSizeArray + 1 < bucketsSizeArray.Length)
{
newArraySize = bucketsSizeArray[currentIndexIntoBucketsSizeArray + 1];
}
else
{
newArraySize = buckets.Length;
}
}
else
{
// -1 means stop trying to increase the size based on the array of primes
// instead calc based on 2 * existing length and then get the next higher prime
newArraySize = buckets.Length;
if (newArraySize < int.MaxValue / 2)
{
newArraySize = FastHashSetUtil.GetEqualOrClosestHigherPrime(newArraySize + newArraySize);
}
else
{
newArraySize = LargestPrimeLessThanMaxInt;
}
}
return newArraySize;
}
// if hashing, increase the size of the slots array
// if not yet hashing, switch to hashing
private void IncreaseCapacity(int capacityIncrease = -1)
{
// this function might be a fair bit over overhead for resizing at small sizes (like 33 and 65)
// could try to reduce the overhead - there could just be a nextSlotsArraySize (don't need increase?), or nextSlotsArraySizeIncrease?
// then we don't have to call GetNewSlotsArraySizeIncrease at all?
// could test the overhead by just replacing all of the code with
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int newSlotsArraySizeIncrease;
int oldSlotsArraySize;
if (capacityIncrease == -1)
{
newSlotsArraySizeIncrease = GetNewSlotsArraySizeIncrease(out oldSlotsArraySize);
}
else
{
newSlotsArraySizeIncrease = capacityIncrease;
oldSlotsArraySize = slots.Length;
}
if (newSlotsArraySizeIncrease <= 0)
{
throw new InvalidOperationException("Exceeded maximum number of items allowed for this container.");
}
int newSlotsArraySize = oldSlotsArraySize + newSlotsArraySizeIncrease;
TNode[] newSlotsArray = new TNode[newSlotsArraySize];
Array.Copy(slots, 0, newSlotsArray, 0, slots.Length); // check the IL, I think Array.Resize and Array.Copy without the start param calls this, so avoid the overhead by calling directly
slots = newSlotsArray;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
SwitchToHashing(capacityIncrease);
}
#endif
}
private TNode[] IncreaseCapacityNoCopy(int capacityIncrease = -1)
{
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int newSlotsrraySizeIncrease;
int oldSlotsArraySize;
if (capacityIncrease == -1)
{
newSlotsrraySizeIncrease = GetNewSlotsArraySizeIncrease(out oldSlotsArraySize);
}
else
{
newSlotsrraySizeIncrease = capacityIncrease;
oldSlotsArraySize = slots.Length;
}
if (newSlotsrraySizeIncrease <= 0)
{
throw new InvalidOperationException("Exceeded maximum number of items allowed for this container.");
}
int newSlotsArraySize = oldSlotsArraySize + newSlotsrraySizeIncrease;
TNode[] newSlotsArray = new TNode[newSlotsArraySize];
return newSlotsArray;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
SwitchToHashing(capacityIncrease);
return null;
}
#endif
}
private void ResizeBucketsArrayForward(int newBucketsArraySize)
{
if (newBucketsArraySize == buckets.Length)
{
// this will still work if no increase in size - it just might be slower than if you could increase the buckets array size
}
else
{
if (!CheckForModSizeIncrease()) //??? clean this up, it isn't really good to do it this way - no need to call GetNewBucketsArraySize before calling this function
{
buckets = new int[newBucketsArraySize];
bucketsModSize = newBucketsArraySize;
if (currentIndexIntoBucketsSizeArray >= 0)
{
currentIndexIntoBucketsSizeArray++; // when the newBucketsArraySize gets used in the above code, point to the next avaialble size - ??? not sure this is the best place to increment this
}
}
else
{
Array.Clear(buckets, 0, bucketsModSize);
}
CalcUsedItemsLoadFactorThreshold();
int bucketsArrayLength = buckets.Length;
int pastNodeIndex = slots.Length;
if (firstBlankAtEndIndex < pastNodeIndex)
{
pastNodeIndex = firstBlankAtEndIndex;
}
//??? for a loop where the end is array.Length, the compiler can skip any array bounds checking - can it do it for this code - it should be able to because pastIndex is no more than buckets.Length
if (firstBlankAtEndIndex == count + 1)
{
// this means there aren't any blank nodes
for (int i = 1; i < pastNodeIndex; i++)
{
ref TNode t = ref slots[i];
int hashIndex = t.hashOrNextIndexForBlanks % bucketsArrayLength;
t.nextIndex = buckets[hashIndex];
buckets[hashIndex] = i;
}
}
else
{
// this means there are some blank nodes
for (int i = 1; i < pastNodeIndex; i++)
{
ref TNode t = ref slots[i];
if (t.nextIndex != BlankNextIndexIndicator) // skip blank nodes
{
int hashIndex = t.hashOrNextIndexForBlanks % bucketsArrayLength;
t.nextIndex = buckets[hashIndex];
buckets[hashIndex] = i;
}
}
}
}
}
private void ResizeBucketsArrayForwardKeepMarks(int newBucketsArraySize)
{
if (newBucketsArraySize == buckets.Length)
{
// this will still work if no increase in size - it just might be slower than if you could increase the buckets array size
}
else
{
//??? what if there is a high percent of blank/unused items in the slots array before the firstBlankAtEndIndex (mabye because of lots of removes)?
// It would probably be faster to loop through the buckets array and then do chaining to find the used nodes - one problem with this is that you would have to find blank nodes - but they would be chained
// this probably isn't a very likely scenario
if (!CheckForModSizeIncrease()) //??? clean this up, it isn't really good to do it this way - no need to call GetNewBucketsArraySize before calling this function
{
buckets = new int[newBucketsArraySize];
bucketsModSize = newBucketsArraySize;
if (currentIndexIntoBucketsSizeArray >= 0)
{
currentIndexIntoBucketsSizeArray++; // when the newBucketsArraySize gets used in the above code, point to the next avaialble size - ??? not sure this is the best place to increment this
}
}
CalcUsedItemsLoadFactorThreshold();
int bucketsArrayLength = buckets.Length;
int pastNodeIndex = slots.Length;
if (firstBlankAtEndIndex < pastNodeIndex)
{
pastNodeIndex = firstBlankAtEndIndex;
}
//??? for a loop where the end is array.Length, the compiler can skip any array bounds checking - can it do it for this code - it should be able to because pastIndex is no more than buckets.Length
if (firstBlankAtEndIndex == count + 1)
{
// this means there aren't any blank nodes
for (int i = 1; i < pastNodeIndex; i++)
{
ref TNode t = ref slots[i];
int hashIndex = t.hashOrNextIndexForBlanks % bucketsArrayLength;
t.nextIndex = buckets[hashIndex] | (t.nextIndex & MarkNextIndexBitMask);
buckets[hashIndex] = i;
}
}
else
{
// this means there are some blank nodes
for (int i = 1; i < pastNodeIndex; i++)
{
ref TNode t = ref slots[i];
if (t.nextIndex != BlankNextIndexIndicator) // skip blank nodes
{
int hashIndex = t.hashOrNextIndexForBlanks % bucketsArrayLength;
t.nextIndex = buckets[hashIndex] | (t.nextIndex & MarkNextIndexBitMask);
buckets[hashIndex] = i;
}
}
}
}
}
/// <summary>
/// Removes all items from the FastHashSet, but does not do any trimming of the resulting unused memory.
/// To trim the unused memory, call TrimExcess.
/// </summary>
public void Clear()
{
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
#endif
{
firstBlankAtEndIndex = 1;
nextBlankIndex = 1;
Array.Clear(buckets, 0, buckets.Length);
}
count = 0;
}
// documentation states:
// You can use the TrimExcess method to minimize a HashSet<T> object's memory overhead once it is known that no new elements will be added
// To completely clear a HashSet<T> object and release all memory referenced by it, call this method after calling the Clear method.
/// <summary>
/// Trims excess capacity to minimize the FastHashSet's memory overhead.
/// </summary>
public void TrimExcess()
{
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
if (slots.Length > firstBlankAtEndIndex && firstBlankAtEndIndex > 0)
{
Array.Resize(ref slots, firstBlankAtEndIndex);
// when firstBlankAtEndIndex == slots.Length, that means there are no blank at end items
}
#if !Exclude_No_Hash_Array_Implementation
}
else
{
if (noHashArray != null && noHashArray.Length > count && count > 0)
{
Array.Resize(ref noHashArray, count);
}
}
#endif
}
// this is only present to implement ICollection<T> - it has no real value otherwise because the Add method with bool return value already does this
/// <summary>
/// Implements the ICollection&lt;T&gt; Add method. If possible, use the FastHashSet Add method instead to avoid any slight overhead and return a bool that indicates if the item was added.
/// </summary>
/// <param name="item">The item to add.</param>
void ICollection<T>.Add(T item)
{
Add(in item);
}
// we need 2 versions of Add, one with 'in' and one without 'in' because the one without 'in' is needed to implement the ISet Add method
// always keep the code for these 2 Add methods exactly the same
/// <summary>
/// Add an item to the FastHashSet using a read-only reference (in) parameter. Use this version of the Add method when item is a large value type to avoid copying large objects.
/// </summary>
/// <param name="item">The item to add.</param>
/// <returns>True if the item was added, or false if the FastHashSet already contains the item.</returns>
public bool Add(in T item)
{
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
for (int index = buckets[hashIndex]; index != NullIndex;)
{
ref TNode t = ref slots[index];
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
return false; // item was found, so return false to indicate it was not added
}
index = t.nextIndex;
}
if (nextBlankIndex >= slots.Length)
{
// there aren't any more blank nodes to add items, so we need to increase capacity
IncreaseCapacity();
}
int firstIndex = buckets[hashIndex];
buckets[hashIndex] = nextBlankIndex;
ref TNode tBlank = ref slots[nextBlankIndex];
if (nextBlankIndex >= firstBlankAtEndIndex)
{
// the blank nodes starting at firstBlankAtEndIndex aren't chained
nextBlankIndex = ++firstBlankAtEndIndex;
}
else
{
// the blank nodes before firstBlankAtEndIndex are chained (the hashOrNextIndexForBlanks points to the next blank node)
nextBlankIndex = tBlank.hashOrNextIndexForBlanks;
}
tBlank.hashOrNextIndexForBlanks = hash;
tBlank.nextIndex = firstIndex;
tBlank.item = item;
count++;
if (count >= resizeBucketsCountThreshold)
{
ResizeBucketsArrayForward(GetNewBucketsArraySize());
}
return true;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
int i;
for (i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
return false;
}
}
if (i == noHashArray.Length)
{
SwitchToHashing();
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
ref TNode tBlank = ref slots[nextBlankIndex];
tBlank.hashOrNextIndexForBlanks = hash;
tBlank.nextIndex = buckets[hashIndex];
tBlank.item = item;
buckets[hashIndex] = nextBlankIndex;
nextBlankIndex = ++firstBlankAtEndIndex;
count++;
return true;
}
else
{
// add to noHashArray
noHashArray[i] = item;
count++;
return true;
}
}
#endif
}
/// <summary>
/// Add an item to the FastHashSet.
/// </summary>
/// <param name="item">The item to add.</param>
/// <returns>True if the item was added, or false if the FastHashSet already contains the item.</returns>
public bool Add(T item)
{
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
for (int index = buckets[hashIndex]; index != NullIndex;)
{
ref TNode t = ref slots[index];
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
return false; // item was found, so return false to indicate it was not added
}
index = t.nextIndex;
}
if (nextBlankIndex >= slots.Length)
{
// there aren't any more blank nodes to add items, so we need to increase capacity
IncreaseCapacity();
}
int firstIndex = buckets[hashIndex];
buckets[hashIndex] = nextBlankIndex;
ref TNode tBlank = ref slots[nextBlankIndex];
if (nextBlankIndex >= firstBlankAtEndIndex)
{
// the blank nodes starting at firstBlankAtEndIndex aren't chained
nextBlankIndex = ++firstBlankAtEndIndex;
}
else
{
// the blank nodes before firstBlankAtEndIndex are chained (the hashOrNextIndexForBlanks points to the next blank node)
nextBlankIndex = tBlank.hashOrNextIndexForBlanks;
}
tBlank.hashOrNextIndexForBlanks = hash;
tBlank.nextIndex = firstIndex;
tBlank.item = item;
count++;
if (count >= resizeBucketsCountThreshold)
{
ResizeBucketsArrayForward(GetNewBucketsArraySize());
}
return true;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
int i;
for (i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
return false;
}
}
if (i == noHashArray.Length)
{
SwitchToHashing();
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
ref TNode tBlank = ref slots[nextBlankIndex];
tBlank.hashOrNextIndexForBlanks = hash;
tBlank.nextIndex = buckets[hashIndex];
tBlank.item = item;
buckets[hashIndex] = nextBlankIndex;
nextBlankIndex = ++firstBlankAtEndIndex;
count++;
return true;
}
else
{
// add to noHashArray
noHashArray[i] = item;
count++;
return true;
}
}
#endif
}
// return the index in the slots array of the item that was added or found
private int AddToHashSetIfNotFound(in T item, int hash, out bool isFound)
{
// this assmes we are hashing
int hashIndex = hash % bucketsModSize;
for (int index = buckets[hashIndex]; index != NullIndex;)
{
ref TNode t = ref slots[index];
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
isFound = true;
return index; // item was found, so return the index of the found item
}
index = t.nextIndex;
}
if (nextBlankIndex >= slots.Length)
{
// there aren't any more blank nodes to add items, so we need to increase capacity
IncreaseCapacity();
ResizeBucketsArrayForward(GetNewBucketsArraySize());
// fix things messed up by buckets array resize
hashIndex = hash % bucketsModSize;
}
int firstIndex = buckets[hashIndex];
buckets[hashIndex] = nextBlankIndex;
int addedNodeIndex = nextBlankIndex;
ref TNode tBlank = ref slots[nextBlankIndex];
if (nextBlankIndex >= firstBlankAtEndIndex)
{
// the blank nodes starting at firstBlankAtEndIndex aren't chained
nextBlankIndex = ++firstBlankAtEndIndex;
}
else
{
// the blank nodes before firstBlankAtEndIndex are chained (the hashOrNextIndexForBlanks points to the next blank node)
nextBlankIndex = tBlank.hashOrNextIndexForBlanks;
}
tBlank.hashOrNextIndexForBlanks = hash;
tBlank.nextIndex = firstIndex;
tBlank.item = item;
count++;
isFound = false;
return addedNodeIndex; // item was not found, so return the index of the added item
}
// return the node index that was added, or NullIndex if item was found
private int AddToHashSetIfNotFoundAndMark(in T item, int hash)
{
// this assumes we are hashing
int hashIndex = hash % bucketsModSize;
for (int index = buckets[hashIndex]; index != NullIndex;)
{
ref TNode t = ref slots[index];
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
return NullIndex; // item was found, so return NullIndex to indicate it was not added
}
index = t.nextIndex & MarkNextIndexBitMaskInverted;
}
if (nextBlankIndex >= slots.Length)
{
// there aren't any more blank nodes to add items, so we need to increase capacity
IncreaseCapacity();
ResizeBucketsArrayForwardKeepMarks(GetNewBucketsArraySize());
// fix things messed up by buckets array resize
hashIndex = hash % bucketsModSize;
}
int firstIndex = buckets[hashIndex];
buckets[hashIndex] = nextBlankIndex;
int addedNodeIndex = nextBlankIndex;
ref TNode tBlank = ref slots[nextBlankIndex];
if (nextBlankIndex >= firstBlankAtEndIndex)
{
// the blank nodes starting at firstBlankAtEndIndex aren't chained
nextBlankIndex = ++firstBlankAtEndIndex;
}
else
{
// the blank nodes before firstBlankAtEndIndex are chained (the hashOrNextIndexForBlanks points to the next blank node)
nextBlankIndex = tBlank.hashOrNextIndexForBlanks;
}
tBlank.hashOrNextIndexForBlanks = hash;
tBlank.nextIndex = firstIndex | MarkNextIndexBitMask;
tBlank.item = item;
count++;
return addedNodeIndex; // item was not found, so return the index of the added item
}
// we need 2 versions of Contains, one with 'in' and one without 'in' because the one without 'in' is needed to implement the ICollection Contains method
// always keep the code for these 2 Contains methods exactly the same
/// <summary>
/// Return true if the item is contained in the FastHashSet, otherwise return false. Use this version of the Contains method when item is a large value type to avoid copying large objects.
/// </summary>
/// <param name="item">The item to search for in the FastHashSet.</param>
/// <returns>True if found, false if not found.</returns>
public bool Contains(in T item)
{
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
for (int index = buckets[hashIndex]; index != NullIndex;)
{
ref TNode t = ref slots[index];
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
return true; // item was found, so return true
}
index = t.nextIndex;
}
return false;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
for (int i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
return true; // item was found, so return true
}
}
return false;
}
#endif
}
// this implements Contains for ICollection<T>
/// <summary>
/// Return true if the item is contained in the FastHashSet, otherwise return false.
/// </summary>
/// <param name="item">The item to search for in the FastHashSet.</param>
/// <returns>True if found, false if not found.</returns>
public bool Contains(T item)
{
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
for (int index = buckets[hashIndex]; index != NullIndex;)
{
ref TNode t = ref slots[index];
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
return true; // item was found, so return true
}
index = t.nextIndex;
}
return false;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
for (int i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
return true; // item was found, so return true
}
}
return false;
}
#endif
}
/// <summary>
/// Removes the item from the FastHashSet if found and returns true if the item was found and removed.
/// </summary>
/// <param name="item">The item value to remove.</param>
/// <returns>True if the item was removed, or false if the item was not contained in the FastHashSet.</returns>
public bool Remove(T item)
{
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
int priorIndex = NullIndex;
for (int index = buckets[hashIndex]; index != NullIndex;)
{
ref TNode t = ref slots[index];
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
// item was found, so remove it
if (priorIndex == NullIndex)
{
buckets[hashIndex] = t.nextIndex;
}
else
{
slots[priorIndex].nextIndex = t.nextIndex;
}
// add node to blank chain or to the blanks at the end (if possible)
if (index == firstBlankAtEndIndex - 1)
{
if (nextBlankIndex == firstBlankAtEndIndex)
{
nextBlankIndex--;
}
firstBlankAtEndIndex--;
}
else
{
t.hashOrNextIndexForBlanks = nextBlankIndex;
nextBlankIndex = index;
}
t.nextIndex = BlankNextIndexIndicator;
count--;
return true;
}
priorIndex = index;
index = t.nextIndex;
}
return false; // item not found
#if !Exclude_No_Hash_Array_Implementation
}
else
{
for (int i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
// remove the item by moving all remaining items to fill over this one - this is probably faster than Array.CopyTo
for (int j = i + 1; j < count; j++, i++)
{
noHashArray[i] = noHashArray[j];
}
count--;
return true;
}
}
return false;
}
#endif
}
// this is a new public method not in HashSet
/// <summary>
/// <para>Removes the item from the FastHashSet if found and also if the predicate param evaluates to true on the found item.</para>
/// <para>This is useful if there is something about the found item other than its equality value that can be used to determine if it should be removed.</para>
/// </summary>
/// <param name="item">The item value to remove.</param>
/// <param name="removeIfPredIsTrue">The predicate to evaluate on the found item.</param>
/// <returns>True if the item was removed, or false if the item was not removed.</returns>
public bool RemoveIf(in T item, Predicate<T> removeIfPredIsTrue)
{
if (removeIfPredIsTrue == null)
{
throw new ArgumentNullException(nameof(removeIfPredIsTrue), "Value cannot be null.");
}
// the following code is almost the same as the Remove(item) function except that it additionally invokes the removeIfPredIsTrue param to see if the item should be removed
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
int priorIndex = NullIndex;
for (int index = buckets[hashIndex]; index != NullIndex;)
{
ref TNode t = ref slots[index];
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
if (removeIfPredIsTrue.Invoke(t.item))
{
// item was found and predicate was true, so remove it
if (priorIndex == NullIndex)
{
buckets[hashIndex] = t.nextIndex;
}
else
{
slots[priorIndex].nextIndex = t.nextIndex;
}
// add node to blank chain or to the blanks at the end (if possible)
if (index == firstBlankAtEndIndex - 1)
{
if (nextBlankIndex == firstBlankAtEndIndex)
{
nextBlankIndex--;
}
firstBlankAtEndIndex--;
}
else
{
t.hashOrNextIndexForBlanks = nextBlankIndex;
nextBlankIndex = index;
}
t.nextIndex = BlankNextIndexIndicator;
count--;
return true;
}
else
{
return false;
}
}
priorIndex = index;
index = t.nextIndex;
}
return false; // item not found
#if !Exclude_No_Hash_Array_Implementation
}
else
{
for (int i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
if (removeIfPredIsTrue.Invoke(noHashArray[i]))
{
// remove the item by moving all remaining items to fill over this one - this is probably faster than Array.CopyTo
for (int j = i + 1; j < count; j++, i++)
{
noHashArray[i] = noHashArray[j];
}
count--;
return true;
}
else
{
return false;
}
}
}
return false;
}
#endif
}
// this is a new public method not in HashSet
/// <summary>
/// <para>Returns a ref to the element in the FastHashSet if found, or adds the item if not present in the FastHashSet and returns a ref to the added element.</para>
/// <para>The returned element reference should only be changed in ways that does not effect its GetHashCode value.</para>
/// <para>The returned element reference should only be used before any modifications to the FastHashSet (like Add or Remove) which may invalidate it.</para>
/// </summary>
/// <param name="item">The item to be added or found.</param>
/// <param name="isFound">Set to true if the item is found, or false if the added was not found and added.</param>
/// <returns>Returns a ref to the found item or to the added item.</returns>
public ref T FindOrAdd(in T item, out bool isFound)
{
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
isFound = false;
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int addedOrFoundItemIndex = AddToHashSetIfNotFound(in item, (comparer.GetHashCode(item) & HighBitNotSet), out isFound);
return ref slots[addedOrFoundItemIndex].item;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
int i;
for (i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
isFound = true;
return ref noHashArray[i];
}
}
if (i == noHashArray.Length)
{
SwitchToHashing();
return ref FindOrAdd(in item, out isFound);
}
else
{
// add to noHashArray and keep isAdded true
noHashArray[i] = item;
count++;
return ref noHashArray[i];
}
}
#endif
}
// this is a new public method not in HashSet
/// <summary>
/// <para>Tries to find the element with the same value as item in the FastHashSet and, if found, it returns a ref to this found element.</para>
/// <para>This is similar to TryGetValue except it returns a ref to the actual element rather than creating copy of the element with an out parameter.</para>
/// <para>This allows the actual element to be changed if it is a mutable value type.</para>
/// <para>The returned element reference should only be changed in ways that does not effect its GetHashCode value.</para>
/// <para>The returned element reference should only be used before any modifications to the FastHashSet (like Add or Remove) which may invalidate it.</para>
/// </summary>
/// <param name="item">The item to be found.</param>
/// <param name="isFound">Set to true if the item is found, or false if not found.</param>
/// <returns>Returns a ref to the element if it is found and sets the isFound out parameter to true. If not found, it returns a ref to the first element available and sets the isFound out parameter to false.</returns>
public ref T Find(in T item, out bool isFound)
{
isFound = false;
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
FindInSlotsArray(item, out int foundNodeIndex, out int priorNodeIndex, out int bucketsIndex);
if (foundNodeIndex != NullIndex)
{
isFound = true;
}
return ref slots[foundNodeIndex].item;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
int i;
for (i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
isFound = true;
return ref noHashArray[i];
}
}
// if item was not found, still need to return a ref to something, so return a ref to the first item in the array
return ref noHashArray[0];
}
#endif
}
// this is a new public method not in HashSet
/// <summary>
/// <para>Tries to find the element with the same value as item in the FastHashSet and, if found,it returns a ref to this found element, except if it is also removed (which is determined by the removeIfPredIsTrue parameter).</para>
/// <para>The returned element reference should only be changed in ways that does not effect its GetHashCode value.</para>
/// <para>The returned element reference should only be used before any modifications to the FastHashSet (like Add or Remove) which may invalidate it.</para>
/// </summary>
/// <param name="item"></param>
/// <param name="removeIfPredIsTrue">The predicate to evaluate on the found item.</param>
/// <param name="isFound">Set to true if the item is found, or false if not found.</param>
/// <param name="isRemoved">Set to true if the item is found and then removed, or false if not removed.</param>
/// <returns>Returns a ref to the element if it is found (and not removed) and sets the isFound out parameter to true and the isRemoved out parameter to false. If removed, it returns a reference to the first available element.</returns>
public ref T FindAndRemoveIf(in T item, Predicate<T> removeIfPredIsTrue, out bool isFound, out bool isRemoved)
{
if (removeIfPredIsTrue == null)
{
throw new ArgumentNullException(nameof(removeIfPredIsTrue), "Value cannot be null.");
}
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
isFound = false;
isRemoved = false;
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
FindInSlotsArray(item, out int foundNodeIndex, out int priorNodeIndex, out int bucketsIndex);
if (foundNodeIndex != NullIndex)
{
isFound = true;
ref TNode t = ref slots[foundNodeIndex];
if (removeIfPredIsTrue.Invoke(t.item))
{
if (priorNodeIndex == NullIndex)
{
buckets[bucketsIndex] = t.nextIndex;
}
else
{
slots[priorNodeIndex].nextIndex = t.nextIndex;
}
// add node to blank chain or to the blanks at the end (if possible)
if (foundNodeIndex == firstBlankAtEndIndex - 1)
{
if (nextBlankIndex == firstBlankAtEndIndex)
{
nextBlankIndex--;
}
firstBlankAtEndIndex--;
}
else
{
t.hashOrNextIndexForBlanks = nextBlankIndex;
nextBlankIndex = foundNodeIndex;
}
t.nextIndex = BlankNextIndexIndicator;
count--;
isRemoved = true;
foundNodeIndex = NullIndex;
}
}
return ref slots[foundNodeIndex].item;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
int i;
for (i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
isFound = true;
if (removeIfPredIsTrue.Invoke(noHashArray[i]))
{
// remove the item by moving all remaining items to fill over this one - this is probably faster than Array.CopyTo
for (int j = i + 1; j < count; j++, i++)
{
noHashArray[i] = noHashArray[j];
}
count--;
isRemoved = true;
return ref noHashArray[0];
}
else
{
return ref noHashArray[i];
}
}
}
// if item was not found, still need to return a ref to something, so return a ref to the first item in the array
return ref noHashArray[0];
}
#endif
}
// return index into slots array or 0 if not found
//??? to make things faster, could have a FindInSlotsArray that just returns foundNodeIndex and another version called FindWithPriorInSlotsArray that has the 3 out params
// first test to make sure this works as is
private void FindInSlotsArray(in T item, out int foundNodeIndex, out int priorNodeIndex, out int bucketsIndex)
{
foundNodeIndex = NullIndex;
priorNodeIndex = NullIndex;
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
bucketsIndex = hashIndex;
int priorIndex = NullIndex;
for (int index = buckets[hashIndex]; index != NullIndex;)
{
ref TNode t = ref slots[index];
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
foundNodeIndex = index;
priorNodeIndex = priorIndex;
return; // item was found
}
priorIndex = index;
index = t.nextIndex;
}
return; // item not found
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private bool FindInSlotsArray(in T item, int hash)
{
int hashIndex = hash % bucketsModSize;
for (int index = buckets[hashIndex]; index != NullIndex;)
{
ref TNode t = ref slots[index];
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
return true; // item was found, so return true
}
index = t.nextIndex;
}
return false;
}
#if !Exclude_No_Hash_Array_Implementation
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private bool FindInNoHashArray(in T item)
{
for (int i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
return true; // item was found, so return true
}
}
return false;
}
#endif
private void UnmarkAllNextIndexValues(int maxNodeIndex)
{
// must be hashing to be here
for (int i = 1; i <= maxNodeIndex; i++)
{
slots[i].nextIndex &= MarkNextIndexBitMaskInverted;
}
}
// removeMarked = true, means remove the marked items and keep the unmarked items
// removeMarked = false, means remove the unmarked items and keep the marked items
private void UnmarkAllNextIndexValuesAndRemoveAnyMarkedOrUnmarked(bool removeMarked)
{
// must be hashing to be here
// must traverse all of the chains instead of just looping through the slots array because going through the chains is the only way to set
// nodes within a chain to blank and still be able to remove the blank node from the chain
int index;
int nextIndex;
int priorIndex;
int lastNonBlankIndex = firstBlankAtEndIndex - 1;
for (int i = 0; i < buckets.Length; i++)
{
priorIndex = NullIndex; // 0 means use buckets array
index = buckets[i];
while (index != NullIndex)
{
ref TNode t = ref slots[index];
nextIndex = t.nextIndex;
bool isMarked = (nextIndex & MarkNextIndexBitMask) != 0;
if (isMarked)
{
// this node is marked, so unmark it
nextIndex &= MarkNextIndexBitMaskInverted;
t.nextIndex = nextIndex;
}
if (removeMarked == isMarked)
{
// set this node to blank
count--;
// first try to set it to blank by adding it to the blank at end group
if (index == lastNonBlankIndex)
{
//??? does it make sense to attempt this because any already blank items before this will not get added
lastNonBlankIndex--;
if (nextBlankIndex == firstBlankAtEndIndex)
{
nextBlankIndex--;
}
firstBlankAtEndIndex--;
}
else
{
// add to the blank group
t.nextIndex = BlankNextIndexIndicator;
t.hashOrNextIndexForBlanks = nextBlankIndex;
nextBlankIndex = index;
}
if (priorIndex == NullIndex)
{
buckets[i] = nextIndex;
}
else
{
slots[priorIndex].nextIndex = nextIndex;
}
// keep priorIndex the same because we removed the node in the chain, so the priorIndex is still the same value
}
else
{
priorIndex = index; // node was not removed from the chain, so the priorIndex now points to the node that was not removed
}
index = nextIndex;
}
}
}
private FoundType FindInSlotsArrayAndMark(in T item, out int foundNodeIndex)
{
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
int index = buckets[hashIndex];
if (index == NullIndex)
{
foundNodeIndex = NullIndex;
return FoundType.NotFound;
}
else
{
// item with same hashIndex already exists, so need to look in the chained list for an equal item (using Equals)
int nextIndex;
while (true)
{
ref TNode t = ref slots[index];
nextIndex = t.nextIndex;
// check if hash codes are equal before calling Equals (which may take longer) items that are Equals must have the same hash code
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
foundNodeIndex = index;
if ((nextIndex & MarkNextIndexBitMask) == 0)
{
// not marked, so mark it
t.nextIndex |= MarkNextIndexBitMask;
return FoundType.FoundFirstTime;
}
return FoundType.FoundNotFirstTime;
}
nextIndex &= MarkNextIndexBitMaskInverted;
if (nextIndex == NullIndex)
{
foundNodeIndex = NullIndex;
return FoundType.NotFound; // not found
}
else
{
index = nextIndex;
}
}
}
}
// this is a new public method not in HashSet
/// <summary>
/// <para>Get the information about the size of chains in the FastHashSet.</para>
/// <para>The size of chains should be small to reduce traversing and comparing items.</para>
/// <para>This can indicate the effectiveness of the hash code creation method.</para>
/// </summary>
/// <param name="avgNodeVisitsPerChain">Outputs the average node visits per chain. This is a single number that summarizes the average length of chains in terms of the average number of compares until an equal value is found (when the item is present).</param>
/// <returns>A List of LevelAndCount items that gives the length of each chain in the FastHashSet.</returns>
public List<ChainLevelAndCount> GetChainLevelsCounts(out double avgNodeVisitsPerChain)
{
Dictionary<int, int> itemsInChainToCountDict = new Dictionary<int, int>();
// this function only makes sense when hashing
int chainCount = 0;
if (buckets != null)
{
for (int i = 0; i < buckets.Length; i++)
{
int index = buckets[i];
if (index != NullIndex)
{
chainCount++;
int itemsInChain = 1;
while (slots[index].nextIndex != NullIndex)
{
index = slots[index].nextIndex;
itemsInChain++;
}
itemsInChainToCountDict.TryGetValue(itemsInChain, out int cnt);
cnt++;
itemsInChainToCountDict[itemsInChain] = cnt;
}
}
}
double totalAvgNodeVisitsIfVisitingAllChains = 0;
List<ChainLevelAndCount> lst = new List<ChainLevelAndCount>(itemsInChainToCountDict.Count);
foreach (KeyValuePair<int, int> keyVal in itemsInChainToCountDict)
{
lst.Add(new ChainLevelAndCount(keyVal.Key, keyVal.Value));
if (keyVal.Key == 1)
{
totalAvgNodeVisitsIfVisitingAllChains += keyVal.Value;
}
else
{
totalAvgNodeVisitsIfVisitingAllChains += keyVal.Value * (keyVal.Key + 1.0) / 2.0;
}
}
if (chainCount == 0)
{
avgNodeVisitsPerChain = 0;
}
else
{
avgNodeVisitsPerChain = totalAvgNodeVisitsIfVisitingAllChains / chainCount;
}
lst.Sort();
return lst;
}
// this is a new public method not in HashSet
/// <summary>
/// <para>Reorders items in the same hash chain (items that have the same hash code or mod to the same index), so that they are adjacent in memory.</para>
/// <para>This gives better locality of reference for larger count of items, which can result in fewer cache misses.</para>
/// </summary>
public void ReorderChainedNodesToBeAdjacent()
{
if (slots != null)
{
TNode[] newSlotsArray = new TNode[slots.Length];
// copy elements using the buckets array chains so there is better locality in the chains
int index;
int newIndex = 1;
for (int i = 0; i < buckets.Length; i++)
{
index = buckets[i];
if (index != NullIndex)
{
buckets[i] = newIndex;
while (true)
{
ref TNode t = ref slots[index];
ref TNode tNew = ref newSlotsArray[newIndex];
index = t.nextIndex;
newIndex++;
// copy
tNew.hashOrNextIndexForBlanks = t.hashOrNextIndexForBlanks;
tNew.item = t.item;
if (index == NullIndex)
{
tNew.nextIndex = NullIndex;
break;
}
tNew.nextIndex = newIndex;
}
}
}
newIndex++;
nextBlankIndex = newIndex;
firstBlankAtEndIndex = newIndex;
slots = newSlotsArray;
}
}
/// <summary>
/// Looks for equalValue and if found, returns a copy of the found value in actualValue and returns true.
/// </summary>
/// <param name="equalValue">The item to look for.</param>
/// <param name="actualValue">The copy of the found value, if found, or the default value of the same type if not found.</param>
/// <returns>True if equalValue is found, or false if not found.</returns>
public bool TryGetValue(T equalValue, out T actualValue)
{
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
FindInSlotsArray(equalValue, out int foundNodeIndex, out int priorNodeIndex, out int bucketsIndex);
if (foundNodeIndex > 0)
{
actualValue = slots[foundNodeIndex].item;
return true;
}
actualValue = default;
return false;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
int i;
for (i = 0; i < count; i++)
{
if (comparer.Equals(equalValue, noHashArray[i]))
{
actualValue = noHashArray[i];
return true;
}
}
actualValue = default;
return false;
}
#endif
}
/// <summary>
/// Adds all items in <paramref name="other"/> into this FastHashSet. This is similar to AddRange for other types of collections, but it is called UnionWith for ISets.
/// </summary>
/// <param name="other">The enumerable items to add (cannot be null).</param>
public void UnionWith(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other), "Value cannot be null.");
}
// Note: HashSet doesn't seem to increment this unless it really changes something - like doing an Add(3) when 3 is already in the hashset doesn't increment, same as doing a UnionWith with an empty set as the param.
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
if (other == this)
{
return;
}
//??? maybe there is a faster way to add a bunch at one time - I copied the Add code below to make this faster
//foreach (T item in range)
//{
// Add(item);
//}
// do this with more code because it might get called in some high performance situations
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
foreach (T item in other)
{
AddToHashSetIfNotFound(in item, (comparer.GetHashCode(item) & HighBitNotSet), out bool isFound);
}
#if !Exclude_No_Hash_Array_Implementation
}
else
{
int i;
foreach (T item in other)
{
//??? if it's easier for the jit compiler or il compiler to remove the array bounds checking then
// have i < noHashArray.Length and do the check for count within the loop with a break statement
for (i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
goto found; // break out of inner for loop
}
}
// if here then item was not found
if (i == noHashArray.Length)
{
SwitchToHashing();
AddToHashSetIfNotFound(in item, (comparer.GetHashCode(item) & HighBitNotSet), out bool isFound);
}
else
{
// add to noHashArray
noHashArray[i] = item;
count++;
}
found:;
}
}
#endif
}
/// <summary>
/// Removes all items in <paramref name="other"/> from the FastHashSet.
/// </summary>
/// <param name="other">The enumerable items (cannot be null).</param>
public void ExceptWith(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other), "Value cannot be null.");
}
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
if (other == this)
{
Clear();
}
else
{
foreach (T item in other)
{
Remove(item);
}
}
}
/// <summary>
/// Removes items from the FastHashSet so that the only remaining items are those contained in <paramref name="other"/> that also match an item in the FastHashSet.
/// </summary>
/// <param name="other">The enumerable items (cannot be null).</param>
public void IntersectWith(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other), "Value cannot be null.");
}
if (other == this)
{
return;
}
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
// if hashing, find each item in the slots array and mark anything found, but remove from being found again
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int foundItemCount = 0; // the count of found items in the hash - without double counting
foreach (T item in other)
{
FoundType foundType = FindInSlotsArrayAndMark(in item, out int foundIndex);
if (foundType == FoundType.FoundFirstTime)
{
foundItemCount++;
if (foundItemCount == count)
{
break;
}
}
}
if (foundItemCount == 0)
{
Clear();
}
else
{
UnmarkAllNextIndexValuesAndRemoveAnyMarkedOrUnmarked(false);
}
#if !Exclude_No_Hash_Array_Implementation
}
else
{
// Note: we could actually do this faster by moving any found items to the front and keeping track of the found items
// with a single int index
// the problem with this method is it reorders items and even though that shouldn't matter in a set
// it might cause issues with code that incorrectly assumes order stays the same for operations like this
// possibly a faster implementation would be to use the method above, but keep track of original order with an int array of the size of count (ex. item at 0 was originally 5, and also item at 5 was originally 0)
// set the corresponding bit in this int if an item was found
// using a uint means the no hashing array cannot be more than 32 items
uint foundItemBits = 0;
int i;
int foundItemCount = 0; // the count of found items in the hash - without double counting
foreach (T item in other)
{
for (i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
uint mask = (1u << i);
if ((foundItemBits & mask) == 0)
{
foundItemBits |= mask;
foundItemCount++;
}
goto found; // break out of inner for loop
}
}
found:
if (foundItemCount == count)
{
// all items in the set were found, so there is nothing to remove - the set isn't changed
return;
}
}
if (foundItemCount == 0)
{
count = 0; // this is the equivalent of calling Clear
}
else
{
// remove any items that are unmarked (unfound)
// go backwards because this can be faster
for (i = count - 1; i >= 0; i--)
{
uint mask = (1u << i);
if ((foundItemBits & mask) == 0)
{
if (i < count - 1)
{
// a faster method if there are multiple unfound items in a row is to find the first used item (make i go backwards until the item is used and then increment i by 1)
// if there aren't multiple unused in a row, then this is a bit of a waste
int j = i + 1; // j now points to the next item after the unfound one that we want to keep
i--;
while (i >= 0)
{
uint mask2 = (1u << i);
if ((foundItemBits & mask2) != 0)
{
break;
}
i--;
}
i++;
int k = i;
for (; j < count; j++, k++)
{
noHashArray[k] = noHashArray[j];
}
}
count--;
}
}
}
}
#endif
}
// An empty set is a proper subset of any other collection. Therefore, this method returns true if the collection represented by the current HashSet<T> object
// is empty unless the other parameter is also an empty set.
// This method always returns false if Count is greater than or equal to the number of elements in other.
// If the collection represented by other is a HashSet<T> collection with the same equality comparer as the current HashSet<T> object,
// then this method is an O(n) operation. Otherwise, this method is an O(n + m) operation, where n is Count and m is the number of elements in other.
/// <summary>
/// Returns true if this FastHashSet is a proper subset of <paramref name="other"/>.
/// </summary>
/// <param name="other">The enumerable items (cannot be null).</param>
/// <returns>True if a proper subset of <paramref name="other"/>.</returns>
public bool IsProperSubsetOf(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other), "Value cannot be null.");
}
if (other == this)
{
return false;
}
ICollection<T> collection = other as ICollection<T>;
if (collection != null)
{
if (count == 0 && collection.Count > 0)
{
return true; // by definition, an empty set is a proper subset of any non-empty collection
}
if (count >= collection.Count)
{
return false;
}
}
else
{
if (count == 0)
{
foreach (T item in other)
{
return true;
}
return false;
}
}
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int foundItemCount = 0; // the count of found items in the hash - without double counting
int maxFoundIndex = 0;
bool notFoundAtLeastOne = false;
foreach (T item in other)
{
FoundType foundType = FindInSlotsArrayAndMark(in item, out int foundIndex);
if (foundType == FoundType.FoundFirstTime)
{
foundItemCount++;
if (maxFoundIndex < foundIndex)
{
maxFoundIndex = foundIndex;
}
}
else if (foundType == FoundType.NotFound)
{
notFoundAtLeastOne = true;
}
if (notFoundAtLeastOne && foundItemCount == count)
{
// true means all of the items in the set were found in other and at least one item in other was not found in the set
break; // will return true below after unmarking
}
}
UnmarkAllNextIndexValues(maxFoundIndex);
return notFoundAtLeastOne && foundItemCount == count; // true if all of the items in the set were found in other and at least one item in other was not found in the set
#if !Exclude_No_Hash_Array_Implementation
}
else
{
uint foundItemBits = 0;
int foundItemCount = 0; // the count of found items in the hash - without double counting
bool notFoundAtLeastOne = false;
foreach (T item in other)
{
for (int i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
uint mask = (1u << i);
if ((foundItemBits & mask) == 0)
{
foundItemBits |= mask;
foundItemCount++;
}
goto found; // break out of inner for loop
}
}
// if here then item was not found
notFoundAtLeastOne = true;
found:
if (notFoundAtLeastOne && foundItemCount == count)
{
// true means all of the items in the set were found in other and at least one item in other was not found in the set
return true;
}
}
return false;
}
#endif
}
/// <summary>
/// Returns true if this FastHashSet is a subset of <paramref name="other"/>.
/// </summary>
/// <param name="other">The enumerable items (cannot be null).</param>
/// <returns>True if a subset of <paramref name="other"/>.</returns>
public bool IsSubsetOf(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other), "Value cannot be null.");
}
if (other == this)
{
return true;
}
if (count == 0)
{
return true; // by definition, an empty set is a subset of any collection
}
ICollection<T> collection = other as ICollection<T>;
if (collection != null)
{
if (count > collection.Count)
{
return false;
}
}
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int foundItemCount = 0; // the count of found items in the hash - without double counting
int maxFoundIndex = 0;
foreach (T item in other)
{
FoundType foundType = FindInSlotsArrayAndMark(in item, out int foundIndex);
if (foundType == FoundType.FoundFirstTime)
{
foundItemCount++;
if (maxFoundIndex < foundIndex)
{
maxFoundIndex = foundIndex;
}
if (foundItemCount == count)
{
break;
}
}
}
UnmarkAllNextIndexValues(maxFoundIndex);
return foundItemCount == count; // true if all of the items in the set were found in other
#if !Exclude_No_Hash_Array_Implementation
}
else
{
uint foundItemBits = 0;
int foundItemCount = 0; // the count of found items in the hash - without double counting
foreach (T item in other)
{
for (int i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
uint mask = (1u << i);
if ((foundItemBits & mask) == 0)
{
foundItemBits |= mask;
foundItemCount++;
}
goto found; // break out of inner for loop
}
}
found:
if (foundItemCount == count)
{
break;
}
}
return foundItemCount == count; // true if all of the items in the set were found in other
}
#endif
}
/// <summary>
/// Returns true if this FastHashSet is a proper superset of <paramref name="other"/>.
/// </summary>
/// <param name="other">The enumerable items (cannot be null).</param>
/// <returns>True if a proper superset of <paramref name="other"/>.</returns>
public bool IsProperSupersetOf(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other), "Value cannot be null.");
}
if (other == this)
{
return false;
}
if (count == 0)
{
return false; // an empty set can never be a proper superset of anything (not even an empty collection)
}
ICollection<T> collection = other as ICollection<T>;
if (collection != null)
{
if (collection.Count == 0)
{
return true; // by definition, an empty other means the set is a proper superset of it if the set has at least one value
}
}
else
{
foreach (T item in other)
{
goto someItemsInOther;
}
return true;
}
someItemsInOther:
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int foundItemCount = 0; // the count of found items in the hash - without double counting
int maxFoundIndex = 0;
foreach (T item in other)
{
FoundType foundType = FindInSlotsArrayAndMark(in item, out int foundIndex);
if (foundType == FoundType.FoundFirstTime)
{
foundItemCount++;
if (maxFoundIndex < foundIndex)
{
maxFoundIndex = foundIndex;
}
if (foundItemCount == count)
{
break;
}
}
else if (foundType == FoundType.NotFound)
{
// any unfound item means this can't be a proper superset of
UnmarkAllNextIndexValues(maxFoundIndex);
return false;
}
}
UnmarkAllNextIndexValues(maxFoundIndex);
return foundItemCount < count; // true if all of the items in other were found in set and at least one item in set was not found in other
#if !Exclude_No_Hash_Array_Implementation
}
else
{
uint foundItemBits = 0;
int foundItemCount = 0; // the count of found items in the hash - without double counting
foreach (T item in other)
{
for (int i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
uint mask = (1u << i);
if ((foundItemBits & mask) == 0)
{
foundItemBits |= mask;
foundItemCount++;
}
goto found; // break out of inner for loop
}
}
// if here then item was not found
return false;
found:
if (foundItemCount == count)
{
break;
}
}
return foundItemCount < count; // true if all of the items in other were found in set and at least one item in set was not found in other
}
#endif
}
/// <summary>
/// Returns true if this FastHashSet is a superset of <paramref name="other"/>.
/// </summary>
/// <param name="other">The enumerable items (cannot be null).</param>
/// <returns>True if a superset of <paramref name="other"/>.</returns>
public bool IsSupersetOf(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other), "Value cannot be null.");
}
if (other == this)
{
return true;
}
ICollection<T> collection = other as ICollection<T>;
if (collection != null)
{
if (collection.Count == 0)
{
return true; // by definition, an empty other means the set is a superset of it
}
}
else
{
foreach (T item in other)
{
goto someItemsInOther;
}
return true;
}
someItemsInOther:
if (count == 0)
{
return false; // an empty set can never be a proper superset of anything (except an empty collection - but an empty collection returns true above)
}
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
foreach (T item in other)
{
if (!FindInSlotsArray(in item, (comparer.GetHashCode(item) & HighBitNotSet)))
{
return false;
}
}
return true; // true if all of the items in other were found in the set, false if at least one item in other was not found in the set
#if !Exclude_No_Hash_Array_Implementation
}
else
{
int i;
foreach (T item in other)
{
for (i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
goto found; // break out of inner for loop
}
}
// if here then item was not found
return false;
found:;
}
return true; // true if all of the items in other were found in the set, false if at least one item in other was not found in the set
}
#endif
}
/// <summary>
/// Returns true if this FastHashSet contains any items in <paramref name="other"/>.
/// </summary>
/// <param name="other">The enumerable items (cannot be null).</param>
/// <returns>True if contains any items in <paramref name="other"/>.</returns>
public bool Overlaps(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other), "Value cannot be null.");
}
if (other == this)
{
return count > 0; // return false if there are no items when both sets are the same, otherwise return true when both sets are the same
}
foreach (T item in other)
{
if (Contains(in item))
{
return true;
}
}
return false;
}
/// <summary>
/// Returns true if this FastHashSet contains exactly the same elements as <paramref name="other"/>.
/// </summary>
/// <param name="other">The enumerable items (cannot be null).</param>
/// <returns>True if contains the same elements as <paramref name="other"/>.</returns>
public bool SetEquals(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other), "Value cannot be null.");
}
if (other == this)
{
return true;
}
// if other is ICollection, then it has count
ICollection c = other as ICollection;
if (c != null)
{
if (c.Count < count)
{
return false;
}
HashSet<T> hset = other as HashSet<T>;
if (hset != null && Equals(hset.Comparer, Comparer))
{
if (hset.Count != count)
{
return false;
}
foreach (T item in other)
{
if (!Contains(in item))
{
return false;
}
}
return true;
}
FastHashSet<T> fhset = other as FastHashSet<T>;
if (fhset != null && Equals(fhset.Comparer, Comparer))
{
if (fhset.Count != count)
{
return false;
}
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int pastNodeIndex = slots.Length;
if (firstBlankAtEndIndex < pastNodeIndex)
{
pastNodeIndex = firstBlankAtEndIndex;
}
#if !Exclude_No_Hash_Array_Implementation
if (fhset.IsHashing)
{
#endif
for (int i = 1; i < pastNodeIndex; i++)
{
// could not do the blank check if we know there aren't any blanks - below code and in the loop in the else
// could do the check to see if there are any blanks first and then have 2 versions of this code, one with the check for blank and the other without it
if (slots[i].nextIndex != BlankNextIndexIndicator) // skip any blank nodes
{
if (!fhset.FindInSlotsArray(in slots[i].item, slots[i].hashOrNextIndexForBlanks))
{
return false;
}
}
}
#if !Exclude_No_Hash_Array_Implementation
}
else
{
for (int i = 1; i < pastNodeIndex; i++)
{
if (slots[i].nextIndex != BlankNextIndexIndicator) // skip any blank nodes
{
if (!fhset.FindInNoHashArray(in slots[i].item))
{
return false;
}
}
}
}
}
else
{
foreach (T item in other)
{
if (!FindInNoHashArray(in item))
{
return false;
}
}
}
return true;
#endif
}
}
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
int foundItemCount = 0; // the count of found items in the hash - without double counting
int maxFoundIndex = 0;
foreach (T item in other)
{
FoundType foundType = FindInSlotsArrayAndMark(in item, out int foundIndex);
if (foundType == FoundType.FoundFirstTime)
{
foundItemCount++;
if (maxFoundIndex < foundIndex)
{
maxFoundIndex = foundIndex;
}
}
else if (foundType == FoundType.NotFound)
{
UnmarkAllNextIndexValues(maxFoundIndex);
return false;
}
}
UnmarkAllNextIndexValues(maxFoundIndex);
return foundItemCount == count;
#if !Exclude_No_Hash_Array_Implementation
}
else
{
uint foundItemBits = 0;
int foundItemCount = 0; // the count of found items in the hash - without double counting
foreach (T item in other)
{
for (int i = 0; i < count; i++)
{
if (comparer.Equals(item, noHashArray[i]))
{
uint mask = (1u << i);
if ((foundItemBits & mask) == 0)
{
foundItemBits |= mask;
foundItemCount++;
}
goto found; // break out of inner for loop
}
}
// if here then item was not found
return false;
found:;
}
return foundItemCount == count;
}
#endif
}
// From the online document: Modifies the current HashSet<T> object to contain only elements that are present either in that object or in the specified collection, but not both.
/// <summary>
/// Modifies the FastHashSet so that it contains only items in the FashHashSet or <paramref name="other"/>, but not both.
/// So items in <paramref name="other"/> that are also in the FastHashSet are removed, and items in <paramref name="other"/> that are not in the FastHashSet are added.
/// </summary>
/// <param name="other">The enumerable items (cannot be null).</param>
public void SymmetricExceptWith(IEnumerable<T> other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other), "Value cannot be null.");
}
if (other == this)
{
Clear();
}
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
#if !Exclude_No_Hash_Array_Implementation
if (!IsHashing)
{
// to make things easier for now, just switch to hashing if calling this function and deal with only one set of code
SwitchToHashing();
}
#endif
// for the first loop through other, add any unfound items and mark
int addedNodeIndex;
int maxAddedNodeIndex = NullIndex;
foreach (T item in other)
{
addedNodeIndex = AddToHashSetIfNotFoundAndMark(in item, (comparer.GetHashCode(item) & HighBitNotSet));
if (addedNodeIndex > maxAddedNodeIndex)
{
maxAddedNodeIndex = addedNodeIndex;
}
}
foreach (T item in other)
{
RemoveIfNotMarked(in item);
}
UnmarkAllNextIndexValues(maxAddedNodeIndex);
}
private void RemoveIfNotMarked(in T item)
{
// calling this function assumes we are hashing
int hash = (comparer.GetHashCode(item) & HighBitNotSet);
int hashIndex = hash % bucketsModSize;
int priorIndex = NullIndex;
for (int index = buckets[hashIndex]; index != NullIndex;)
{
ref TNode t = ref slots[index];
if (t.hashOrNextIndexForBlanks == hash && comparer.Equals(t.item, item))
{
// item was found, so remove it if not marked
if ((t.nextIndex & MarkNextIndexBitMask) == 0)
{
if (priorIndex == NullIndex)
{
buckets[hashIndex] = t.nextIndex;
}
else
{
// if slots[priorIndex].nextIndex was marked, then keep it marked
// already know that t.nextIndex is not marked
slots[priorIndex].nextIndex = t.nextIndex | (slots[priorIndex].nextIndex & MarkNextIndexBitMask);
}
// add node to blank chain or to the blanks at the end (if possible)
if (index == firstBlankAtEndIndex - 1)
{
if (nextBlankIndex == firstBlankAtEndIndex)
{
nextBlankIndex--;
}
firstBlankAtEndIndex--;
}
else
{
t.hashOrNextIndexForBlanks = nextBlankIndex;
nextBlankIndex = index;
}
t.nextIndex = BlankNextIndexIndicator;
count--;
return;
}
}
priorIndex = index;
index = t.nextIndex & MarkNextIndexBitMaskInverted;
}
return; // item not found
}
/// <summary>
/// Removes any items in the FastHashSet where the <paramref name="match"/> predicate is true for that item.
/// </summary>
/// <param name="match">The match predicate (cannot be null).</param>
/// <returns>The number of items removed.</returns>
public int RemoveWhere(Predicate<T> match)
{
if (match == null)
{
throw new ArgumentNullException(nameof(match), "Value cannot be null.");
}
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification++;
#endif
int removeCount = 0;
#if !Exclude_No_Hash_Array_Implementation
if (IsHashing)
{
#endif
// must traverse all of the chains instead of just looping through the slots array because going through the chains is the only way to set
// nodes within a chain to blank and still be able to remove the blank node from the chain
int priorIndex;
int nextIndex;
for (int i = 0; i < buckets.Length; i++)
{
priorIndex = NullIndex; // 0 means use buckets array
for (int index = buckets[i]; index != NullIndex;)
{
ref TNode t = ref slots[index];
nextIndex = t.nextIndex;
if (match.Invoke(t.item))
{
// item was matched, so remove it
if (priorIndex == NullIndex)
{
buckets[i] = nextIndex;
}
else
{
slots[priorIndex].nextIndex = nextIndex;
}
// add node to blank chain or to the blanks at the end (if possible)
if (index == firstBlankAtEndIndex - 1)
{
if (nextBlankIndex == firstBlankAtEndIndex)
{
nextBlankIndex--;
}
firstBlankAtEndIndex--;
}
else
{
t.hashOrNextIndexForBlanks = nextBlankIndex;
nextBlankIndex = index;
}
t.nextIndex = BlankNextIndexIndicator;
count--;
removeCount++;
}
priorIndex = index;
index = nextIndex;
}
}
#if !Exclude_No_Hash_Array_Implementation
}
else
{
int i;
for (i = count - 1; i >= 0; i--)
{
if (match.Invoke(noHashArray[i]))
{
removeCount++;
if (i < count - 1)
{
int j = i + 1;
int k = i;
for (; j < count; j++, k++)
{
noHashArray[k] = noHashArray[j];
}
}
count--;
}
}
}
#endif
return removeCount;
}
private class FastHashSetEqualityComparer : IEqualityComparer<FastHashSet<T>>
{
public bool Equals(FastHashSet<T> x, FastHashSet<T> y)
{
if (x == null && y == null)
{
return true;
}
if (y == null)
{
return false;
}
if (x != null)
{
return x.SetEquals(y);
}
else
{
return false;
}
}
public int GetHashCode(FastHashSet<T> set)
{
if (set == null)
{
// oddly the documentation for the IEqualityComparer.GetHashCode function says it will throw an ArgumentNullException if the param is null
return 0; // 0 seems to be what .NET framework uses when passing in null, so return the same thing to be consistent
}
else
{
unchecked
{
int hashCode = 0;
#if !Exclude_No_Hash_Array_Implementation
if (set.IsHashing)
{
#endif
int pastNodeIndex = set.slots.Length;
if (set.firstBlankAtEndIndex < pastNodeIndex)
{
pastNodeIndex = set.firstBlankAtEndIndex;
}
for (int i = 1; i < pastNodeIndex; i++)
{
if (set.slots[i].nextIndex != 0) // nextIndex == 0 indicates a blank/available node
{
// maybe do ^= instead of add? - will this produce the same thing regardless of order? - if ^= maybe we don't need unchecked
// sum up the individual item hash codes - this way it won't matter what order the items are in, the same resulting hash code will be produced
hashCode += set.slots[i].hashOrNextIndexForBlanks;
}
}
#if !Exclude_No_Hash_Array_Implementation
}
else
{
for (int i = 0; i < set.count; i++)
{
// sum up the individual item hash codes - this way it won't matter what order the items are in, the same resulting hash code will be produced
hashCode += set.noHashArray[i].GetHashCode();
}
}
#endif
return hashCode;
}
}
}
}
/// <summary>
/// Creates and returns the IEqualityComparer for a FastHashSet which can be used to compare two FastHashSets based on their items being equal.
/// </summary>
/// <returns>An IEqualityComparer for a FastHashSet.</returns>
public static IEqualityComparer<FastHashSet<T>> CreateSetComparer()
{
return new FastHashSetEqualityComparer();
}
/// <summary>
/// Allows enumerating through items in the FastHashSet. Order is not guaranteed.
/// </summary>
/// <returns>The IEnumerator<T> for the FastHashSet.</returns>
public IEnumerator<T> GetEnumerator()
{
return new FastHashSetEnumerator<T>(this);
}
/// <summary>
/// Allows enumerating through items in the FastHashSet. Order is not guaranteed.
/// </summary>
/// <returns>The IEnumerator for the FastHashSet.</returns>
IEnumerator IEnumerable.GetEnumerator()
{
return new FastHashSetEnumerator<T>(this);
}
private class FastHashSetEnumerator<T2> : IEnumerator<T2>
{
private readonly FastHashSet<T2> set;
private int currentIndex = -1;
#if !Exclude_Check_For_Is_Disposed_In_Enumerator
private bool isDisposed;
#endif
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
private readonly int incrementForEverySetModification;
#endif
/// <summary>
/// Constructor for the FastHashSetEnumerator that takes a FastHashSet as a parameter.
/// </summary>
/// <param name="set">The FastHashSet to enumerate through.</param>
public FastHashSetEnumerator(FastHashSet<T2> set)
{
this.set = set;
#if !Exclude_No_Hash_Array_Implementation
if (set.IsHashing)
{
#endif
currentIndex = NullIndex; // 0 is the index before the first possible node (0 is the blank node)
#if !Exclude_No_Hash_Array_Implementation
}
else
{
currentIndex = -1;
}
#endif
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
incrementForEverySetModification = set.incrementForEverySetModification;
#endif
}
/// <summary>
/// Moves to the next item for the FastHashSet enumerator.
/// </summary>
/// <returns>True if there was a next item, otherwise false.</returns>
public bool MoveNext()
{
#if !Exclude_Check_For_Is_Disposed_In_Enumerator
if (isDisposed)
{
// the only reason this code returns false when Disposed is called is to be compatable with HashSet<T>
// if this level of compatibility isn't needed, then #define Exclude_Check_For_Is_Disposed_In_Enumerator to remove this check and makes the code slightly faster
return false;
}
#endif
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
if (incrementForEverySetModification != set.incrementForEverySetModification)
{
throw new InvalidOperationException("Collection was modified; enumeration operation may not execute.");
}
#endif
#if !Exclude_No_Hash_Array_Implementation
if (set.IsHashing)
{
#endif
// it's easiest to just loop through the node array and skip any nodes that are blank
// rather than looping through the buckets array and following the nextIndex to the end of each bucket
while (true)
{
currentIndex++;
if (currentIndex < set.firstBlankAtEndIndex)
{
if (set.slots[currentIndex].nextIndex != BlankNextIndexIndicator)
{
return true;
}
}
else
{
currentIndex = set.firstBlankAtEndIndex;
return false;
}
}
#if !Exclude_No_Hash_Array_Implementation
}
else
{
currentIndex++;
if (currentIndex < set.count)
{
return true;
}
else
{
currentIndex--;
return false;
}
}
#endif
}
/// <summary>
/// Resets the FastHashSet enumerator.
/// </summary>
public void Reset()
{
#if !Exclude_Check_For_Set_Modifications_In_Enumerator
if (incrementForEverySetModification != set.incrementForEverySetModification)
{
throw new InvalidOperationException("Collection was modified; enumeration operation may not execute.");
}
#endif
#if !Exclude_No_Hash_Array_Implementation
if (set.IsHashing)
{
#endif
currentIndex = NullIndex; // 0 is the index before the first possible node (0 is the blank node)
#if !Exclude_No_Hash_Array_Implementation
}
else
{
currentIndex = -1;
}
#endif
}
/// <summary>
/// Implements the IDisposable.Dispose method for the FastHashSet enumerator.
/// </summary>
void IDisposable.Dispose()
{
#if !Exclude_Check_For_Is_Disposed_In_Enumerator
isDisposed = true;
#endif
}
/// <summary>
/// Gets the current item for the FastHashSet enumerator.
/// </summary>
public T2 Current
{
get
{
#if !Exclude_No_Hash_Array_Implementation
if (set.IsHashing)
{
#endif
// it's easiest to just loop through the node array and skip any nodes with nextIndex = 0
// rather than looping through the buckets array and following the nextIndex to the end of each bucket
if (currentIndex > NullIndex && currentIndex < set.firstBlankAtEndIndex)
{
return set.slots[currentIndex].item;
}
#if !Exclude_No_Hash_Array_Implementation
}
else
{
if (currentIndex >= 0 && currentIndex < set.count)
{
return set.noHashArray[currentIndex];
}
}
#endif
return default;
}
}
/// <summary>
/// Gets a reference to the current item for the FastHashSet enumerator.
/// </summary>
public ref T2 CurrentRef
{
get
{
#if !Exclude_No_Hash_Array_Implementation
if (set.IsHashing)
{
#endif
// it's easiest to just loop through the node array and skip any nodes with nextIndex = 0
// rather than looping through the buckets array and following the nextIndex to the end of each bucket
if (currentIndex > NullIndex && currentIndex < set.firstBlankAtEndIndex)
{
return ref set.slots[currentIndex].item;
}
else
{
// we can just return a ref to the 0 node's item instead of throwing an exception? - this should have a default item value
return ref set.slots[0].item;
}
#if !Exclude_No_Hash_Array_Implementation
}
else
{
if (currentIndex >= 0 && currentIndex < set.count)
{
return ref set.noHashArray[currentIndex];
}
else
{
// we can just return a ref to the 0 node's item instead of throwing an exception?
return ref set.noHashArray[0];
}
}
#endif
}
}
/// <summary>
/// True if the current item is valid for the FastHashSet enumerator, otherwise false.
/// </summary>
public bool IsCurrentValid
{
get
{
#if !Exclude_No_Hash_Array_Implementation
if (set.IsHashing)
{
#endif
// it's easiest to just loop through the node array and skip any nodes with nextIndex = 0
// rather than looping through the buckets array and following the nextIndex to the end of each bucket
if (currentIndex > NullIndex && currentIndex < set.firstBlankAtEndIndex)
{
return true;
}
#if !Exclude_No_Hash_Array_Implementation
}
else
{
if (currentIndex >= 0 && currentIndex < set.count)
{
return true;
}
}
#endif
return false;
}
}
/// <summary>
/// Gets the Current item for the FastHashSet enumerator.
/// </summary>
object IEnumerator.Current => Current;
}
public static class FastHashSetUtil
{
/// <summary>
/// Return the prime number that is equal to n (if n is a prime number) or the closest prime number greather than n.
/// </summary>
/// <param name="n">The lowest number to start looking for a prime.</param>
/// <returns>The passed in n parameter value (if it is prime), or the next highest prime greater than n.</returns>
public static int GetEqualOrClosestHigherPrime(int n)
{
if (n >= LargestPrimeLessThanMaxInt)
{
// the next prime above this number is int.MaxValue, which we don't want to return that value because some indices increment one or two ints past this number and we don't want them to overflow
return LargestPrimeLessThanMaxInt;
}
if ((n & 1) == 0)
{
n++; // make n odd
}
bool found;
do
{
found = true;
int sqrt = (int)Math.Sqrt(n);
for (int i = 3; i <= sqrt; i += 2)
{
int div = n / i;
if (div * i == n) // dividing and multiplying might be faster than a single % (n % i) == 0
{
found = false;
n += 2;
break;
}
}
} while (!found);
return n;
}
}
}
public struct ChainLevelAndCount : IComparable<ChainLevelAndCount>
{
public ChainLevelAndCount(int level, int count)
{
Level = level;
Count = count;
}
public int Level;
public int Count;
public int CompareTo(ChainLevelAndCount other)
{
return Level.CompareTo(other.Level);
}
}
#if DEBUG
public static class DebugOutput
{
public static void OutputEnumerableItems<T2>(IEnumerable<T2> e, string enumerableName)
{
System.Diagnostics.Debug.WriteLine("---start items: " + enumerableName + "---");
int count = 0;
foreach (T2 item in e)
{
System.Diagnostics.Debug.WriteLine(item.ToString());
count++;
}
System.Diagnostics.Debug.WriteLine("---end items: " + enumerableName + "; count = " + count.ToString("N0") + "---");
}
public static void OutputSortedEnumerableItems<T2>(IEnumerable<T2> e, string enumerableName)
{
List<T2> lst = new List<T2>(e);
lst.Sort();
System.Diagnostics.Debug.WriteLine("---start items (sorted): " + enumerableName + "---");
int count = 0;
foreach (T2 item in lst)
{
System.Diagnostics.Debug.WriteLine(item.ToString());
count++;
}
System.Diagnostics.Debug.WriteLine("---end items: " + enumerableName + "; count = " + count.ToString("N0") + "---");
}
}
#endif
}
Reference in New Issue View Git Blame Copy Permalink