< Summary

Class:GDX.Collections.SparseSet
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Collections/SparseSet.cs
Covered lines:1001
Uncovered lines:59
Coverable lines:1060
Total lines:1825
Line coverage:94.4% (1001 of 1060)
Covered branches:0
Total branches:0
Covered methods:49
Total methods:51
Method coverage:96% (49 of 51)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
SparseSet(...)0%220100%
SparseSet(...)0%220100%
AddWithExpandCheck(...)0%330100%
AddWithExpandCheck(...)0%12300%
AddUnchecked(...)0%110100%
AddUnchecked(...)0%110100%
GetDenseIndexUnchecked(...)0%110100%
GetDenseIndexWithBoundsCheck(...)0%6.016092.86%
GetDenseIndexWithVersionCheck(...)0%220100%
GetDenseIndexWithBoundsAndVersionCheck(...)0%7.017093.33%
RemoveWithBoundsCheck(...)0%770100%
RemoveWithVersionCheck(...)0%220100%
RemoveWithBoundsAndVersionChecks(...)0%880100%
RemoveUnchecked(...)0%110100%
RemoveUnchecked(...)0%110100%
RemoveUnchecked(...)0%110100%
RemoveUncheckedFromDenseIndex(...)0%110100%
RemoveUncheckedFromDenseIndex(...)0%110100%
RemoveUncheckedFromDenseIndex(...)0%110100%
RemoveUncheckedFromDenseIndex(...)0%110100%
Clear()0%220100%
Clear(...)0%220100%
ClearWithVersionArrayReset(...)0%220100%
Expand(...)0%220100%
Expand(...)0%220100%
Reserve(...)0%330100%
Reserve(...)0%12300%
AddWithExpandCheck[T0](...)0%330100%
AddWithExpandCheck[T0, T1](...)0%330100%
AddWithExpandCheck[T0, T1, T2](...)0%330100%
AddWithExpandCheck[T0, T1, T2, T3](...)0%330100%
AddWithExpandCheck[T0, T1, T2, T3, T4](...)0%330100%
AddWithExpandCheck[T0, T1, T2, T3, T4, T5](...)0%330100%
AddWithExpandCheck[T0, T1, T2, T3, T4, T5, T6](...)0%330100%
AddWithExpandCheck[T0, T1, T2, T3, T4, T5, T6, T7](...)0%330100%
AddUnchecked[T0](...)0%110100%
AddUnchecked[T0, T1](...)0%110100%
AddUnchecked[T0, T1, T2](...)0%110100%
AddUnchecked[T0, T1, T2, T3](...)0%110100%
AddUnchecked[T0, T1, T2, T3, T4](...)0%110100%
AddUnchecked[T0, T1, T2, T3, T4, T5](...)0%110100%
AddUnchecked[T0, T1, T2, T3, T4, T5, T6](...)0%110100%
AddUnchecked[T0, T1, T2, T3, T4, T5, T6, T7](...)0%110100%
RemoveUnchecked[T0](...)0%110100%
RemoveUnchecked[T0, T1](...)0%110100%
RemoveUnchecked[T0, T1, T2](...)0%110100%
RemoveUnchecked[T0, T1, T2, T3](...)0%110100%
RemoveUnchecked[T0, T1, T2, T3, T4](...)0%110100%
RemoveUnchecked[T0, T1, T2, T3, T4, T5](...)0%110100%
RemoveUnchecked[T0, T1, T2, T3, T4, T5, T6](...)0%110100%
RemoveUnchecked[T0, T1, T2, T3, T4, T5, T6, T7](...)0%110100%

File(s)

D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Collections/SparseSet.cs

#LineLine coverage
 1// Copyright (c) 2020-2022 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using System.Runtime.CompilerServices;
 7
 8namespace GDX.Collections
 9{
 10    /// <summary>
 11    ///     An adapter collection for external data arrays that allows constant-time insertion, deletion, and lookup by
 12    ///     handle, as well as array-like iteration.
 13    /// </summary>
 14    public struct SparseSet
 15    {
 16        /// <summary>
 17        ///     Holds references to the sparse array for swapping indices.
 18        /// </summary>
 19        public int[] DenseArray;
 20
 21        /// <summary>
 22        ///     Holds references to dense array indices.
 23        /// </summary>
 24        /// <remarks>
 25        ///     Its own indices are claimed and freed via a free-list.
 26        /// </remarks>
 27        public int[] SparseArray;
 28
 29        /// <summary>
 30        ///     How many indices are being used currently?
 31        /// </summary>
 32        public int Count;
 33
 34        /// <summary>
 35        ///     The first free (currently unused) index in the sparse array.
 36        /// </summary>
 37        public int FreeIndex;
 38
 39        /// <summary>
 40        ///     Create a <see cref="SparseSet" /> with an <paramref name="initialCapacity" />.
 41        /// </summary>
 42        /// <param name="initialCapacity">The initial capacity of the sparse and dense int arrays.</param>
 43        public SparseSet(int initialCapacity)
 3844        {
 3845            DenseArray = new int[initialCapacity];
 3846            SparseArray = new int[initialCapacity];
 3847            Count = 0;
 3848            FreeIndex = 0;
 49
 22850            for (int i = 0; i < initialCapacity; i++)
 7651            {
 7652                DenseArray[i] = -1;
 7653                SparseArray[i] = i + 1;
 7654            }
 3855        }
 56
 57        /// <summary>
 58        ///     Create a <see cref="SparseSet" /> with an <paramref name="initialCapacity" />.
 59        /// </summary>
 60        /// <param name="initialCapacity">The initial capacity of the sparse and dense int arrays.</param>
 61        /// <param name="versionArray">Array containing version numbers to check sparse references against.</param>
 62        public SparseSet(int initialCapacity, out ulong[] versionArray)
 1663        {
 1664            DenseArray = new int[initialCapacity];
 1665            SparseArray = new int[initialCapacity];
 1666            versionArray = new ulong[initialCapacity];
 1667            Count = 0;
 1668            FreeIndex = 0;
 69
 11670            for (int i = 0; i < initialCapacity; i++)
 4271            {
 4272                DenseArray[i] = -1;
 4273                SparseArray[i] = i + 1;
 4274                versionArray[i] = 1;
 4275            }
 1676        }
 77
 78        /// <summary>
 79        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 80        /// </summary>
 81        /// <param name="expandBy">How many indices to expand by.</param>
 82        /// <param name="sparseIndex">The sparse index allocated.</param>
 83        /// <param name="denseIndex">The dense index allocated.</param>
 84        /// <returns>True if the index pool expanded.</returns>
 85        public bool AddWithExpandCheck(int expandBy, out int sparseIndex, out int denseIndex)
 686        {
 687            int indexToClaim = FreeIndex;
 688            int currentCapacity = SparseArray.Length;
 689            bool needsExpansion = false;
 90
 691            if (indexToClaim >= currentCapacity)
 392            {
 93                // We're out of space, the last free index points to nothing. Allocate more indices.
 394                needsExpansion = true;
 95
 396                int newCapacity = currentCapacity + expandBy;
 97
 398                int[] newSparseArray = new int[newCapacity];
 399                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 3100                SparseArray = newSparseArray;
 101
 3102                int[] newDenseArray = new int[newCapacity];
 3103                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 3104                DenseArray = newDenseArray;
 105
 36106                for (int i = currentCapacity; i < newCapacity; i++)
 15107                {
 15108                    SparseArray[i] = i + 1; // Build the free list chain.
 15109                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 15110                }
 3111            }
 112
 6113            int nextFreeIndex = SparseArray[indexToClaim];
 6114            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 6115            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 6116            denseIndex = Count;
 117
 6118            ++Count;
 6119            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 120
 6121            sparseIndex = indexToClaim;
 6122            return needsExpansion;
 6123        }
 124
 125        /// <summary>
 126        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 127        /// </summary>
 128        /// <param name="expandBy">How many indices to expand by.</param>
 129        /// <param name="sparseIndex">The sparse index allocated.</param>
 130        /// <param name="denseIndex">The dense index allocated.</param>
 131        /// <param name="versionArray">The array containing the version number to check against.</param>
 132        /// <param name="version">Enables detection of use-after-free errors when using the sparse index as a reference.
 133        /// <returns>True if the index pool expanded.</returns>
 134        public bool AddWithExpandCheck(int expandBy, out int sparseIndex, out int denseIndex, ref ulong[] versionArray, 
 0135        {
 0136            int indexToClaim = FreeIndex;
 0137            int currentCapacity = SparseArray.Length;
 0138            bool needsExpansion = false;
 139
 0140            if (indexToClaim >= currentCapacity)
 0141            {
 142                // We're out of space, the last free index points to nothing. Allocate more indices.
 0143                needsExpansion = true;
 144
 0145                int newCapacity = currentCapacity + expandBy;
 146
 0147                int[] newSparseArray = new int[newCapacity];
 0148                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 0149                SparseArray = newSparseArray;
 150
 0151                int[] newDenseArray = new int[newCapacity];
 0152                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 0153                DenseArray = newDenseArray;
 154
 0155                ulong[] newVersionArray = new ulong[newCapacity];
 0156                Array.Copy(versionArray, 0, newVersionArray, 0, currentCapacity);
 0157                versionArray = newVersionArray;
 158
 0159                for (int i = currentCapacity; i < newCapacity; i++)
 0160                {
 0161                    SparseArray[i] = i + 1; // Build the free list chain.
 0162                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 0163                    newVersionArray[i] = 1;
 0164                }
 0165            }
 166
 0167            int nextFreeIndex = SparseArray[indexToClaim];
 0168            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 0169            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 0170            denseIndex = Count;
 171
 0172            version = versionArray[indexToClaim];
 173
 0174            ++Count;
 0175            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 176
 0177            sparseIndex = indexToClaim;
 0178            return needsExpansion;
 0179        }
 180
 181        /// <summary>
 182        ///     Adds a sparse/dense index pair to the set without checking if the set needs to expand.
 183        /// </summary>
 184        /// <param name="sparseIndex">The sparse index allocated.</param>
 185        /// <param name="denseIndex">The dense index allocated.</param>
 186        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 187        public void AddUnchecked(out int sparseIndex, out int denseIndex)
 20188        {
 20189            int indexToClaim = FreeIndex;
 20190            int nextFreeIndex = SparseArray[indexToClaim];
 19191            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 19192            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 193
 19194            sparseIndex = indexToClaim;
 19195            denseIndex = Count;
 19196            ++Count;
 19197            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 19198        }
 199
 200        /// <summary>
 201        ///     Adds a sparse/dense index pair to the set without checking if the set needs to expand.
 202        /// </summary>
 203        /// <param name="sparseIndex">The sparse index allocated.</param>
 204        /// <param name="denseIndex">The dense index allocated.</param>
 205        /// <param name="versionArray">The array containing the version number to check against.</param>
 206        /// <param name="version">Enables detection of use-after-free errors when using the sparse index as a reference.
 207        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 208        public void AddUnchecked(out int sparseIndex, out int denseIndex, ulong[] versionArray, out ulong version)
 24209        {
 24210            int indexToClaim = FreeIndex;
 24211            int nextFreeIndex = SparseArray[indexToClaim];
 23212            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 23213            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 214
 23215            version = versionArray[indexToClaim];
 23216            sparseIndex = indexToClaim;
 23217            denseIndex = Count;
 218
 23219            ++Count;
 23220            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 23221        }
 222
 223        /// <summary>
 224        ///     Gets the value of the sparse array at the given index without any data validation.
 225        /// </summary>
 226        /// <param name="sparseIndex">The index to check in the sparse array.</param>
 227        /// <returns>The dense index at the given sparse index.</returns>
 228        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 229        public int GetDenseIndexUnchecked(int sparseIndex)
 1230        {
 1231            return SparseArray[sparseIndex];
 1232        }
 233
 234        /// <summary>
 235        ///     Gets the value of the sparse array at the given index,
 236        ///     or -1 if the dense and sparse indices don't point to each other or if the dense index is outside the den
 237        /// </summary>
 238        /// <param name="sparseIndex">The index in the sparse array to check against.</param>
 239        /// <returns>The dense index pointed to by the current sparse index, or -1 if invalid.</returns>
 240        public int GetDenseIndexWithBoundsCheck(int sparseIndex)
 4241        {
 4242            if (sparseIndex >= 0 && sparseIndex < SparseArray.Length)
 2243            {
 2244                int denseIndex = SparseArray[sparseIndex];
 245
 2246                if (denseIndex < Count && denseIndex >= 0)
 1247                {
 1248                    int sparseIndexAtDenseIndex = DenseArray[denseIndex];
 249
 1250                    if (sparseIndex == sparseIndexAtDenseIndex)
 1251                    {
 1252                        return denseIndex;
 253                    }
 0254                }
 1255            }
 256
 3257            return -1;
 4258        }
 259
 260        /// <summary>
 261        ///     Gets the value of the sparse array at the given index,
 262        ///     or -1 if the version number does not match.
 263        /// </summary>
 264        /// <param name="sparseIndex">The index in the sparse array to check against.</param>
 265        /// <param name="version">The version number associated with the sparse index.</param>
 266        /// <param name="versionArray">The array containing the version number to check against.</param>
 267        /// <returns>The dense index pointed to by the current sparse index, or -1 if invalid.</returns>
 268        public int GetDenseIndexWithVersionCheck(int sparseIndex, ulong version, ulong[] versionArray)
 4269        {
 4270            int denseIndex = SparseArray[sparseIndex];
 4271            ulong versionAtSparseIndex = versionArray[sparseIndex];
 272
 4273            if (version == versionAtSparseIndex)
 2274            {
 2275                return denseIndex;
 276            }
 277
 2278            return -1;
 4279        }
 280
 281        /// <summary>
 282        ///     Gets the value of the sparse array at the given index,
 283        ///     or -1 if the given sparse index is invalid..
 284        /// </summary>
 285        /// <param name="sparseIndex">The index in the sparse array to check against.</param>
 286        /// <param name="version">The version number associated with the sparse index.</param>
 287        /// <param name="versionArray">The array containing the version number to check against.</param>
 288        /// <returns>The dense index pointed to by the current sparse index, or -1 if invalid.</returns>
 289        public int GetDenseIndexWithBoundsAndVersionCheck(int sparseIndex, ulong version, ulong[] versionArray)
 7290        {
 7291            if (sparseIndex >= 0 && sparseIndex < SparseArray.Length)
 5292            {
 5293                int denseIndex = SparseArray[sparseIndex];
 5294                ulong versionAtSparseIndex = versionArray[sparseIndex];
 295
 5296                if (versionAtSparseIndex == version && denseIndex < Count && denseIndex >= 0)
 2297                {
 2298                    int sparseIndexAtDenseIndex = DenseArray[denseIndex];
 299
 2300                    if (sparseIndex == sparseIndexAtDenseIndex)
 2301                    {
 2302                        return denseIndex;
 303                    }
 0304                }
 3305            }
 306
 5307            return -1;
 7308        }
 309
 310        /// <summary>
 311        ///     Frees the allocated entry corresponding to the sparse index.
 312        ///     WARNING: Will not protect against accidentally removing twice if the index in question was recycled betw
 313        /// <param name="sparseIndexToRemove">The sparse index corresponding to the entry to remove.</param>
 314        /// <param name="dataIndexToSwapTo">Replace the data array value at this index with the data array value at inde
 315        /// <param name="dataIndexToSwapFrom">
 316        ///     Set the data array value at this index to default after swapping with the data array
 317        ///     value at dataIndexToSwapTo.
 318        /// </param>
 319        /// </summary>
 320        /// <returns>True if the entry was valid and thus removed.</returns>
 321        public bool RemoveWithBoundsCheck(ref int sparseIndexToRemove, out int dataIndexToSwapFrom, out int dataIndexToS
 4322        {
 4323            dataIndexToSwapFrom = -1;
 4324            dataIndexToSwapTo = -1;
 4325            bool didRemove = false;
 4326            if (sparseIndexToRemove >= 0 && sparseIndexToRemove < SparseArray.Length)
 2327            {
 2328                int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 329
 2330                if (denseIndexToRemove >= 0 && denseIndexToRemove < Count)
 1331                {
 1332                    int sparseIndexAtDenseIndex = DenseArray[denseIndexToRemove];
 1333                    int newLength = Count - 1;
 1334                    int sparseIndexBeingSwapped = DenseArray[newLength];
 335
 1336                    if (denseIndexToRemove < Count && sparseIndexAtDenseIndex == sparseIndexToRemove)
 1337                    {
 1338                        didRemove = true;
 339                        // Swap the entry being removed with the last entry.
 1340                        SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1341                        DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 342
 1343                        dataIndexToSwapFrom = newLength;
 1344                        dataIndexToSwapTo = denseIndexToRemove;
 345
 346                        // Clear the dense index, for debugging purposes
 1347                        DenseArray[newLength] = -1;
 348
 349                        // Add the sparse index to the free list.
 1350                        SparseArray[sparseIndexToRemove] = FreeIndex;
 1351                        FreeIndex = sparseIndexToRemove;
 352
 1353                        Count = newLength;
 1354                    }
 1355                }
 2356            }
 357
 4358            sparseIndexToRemove = -1;
 359
 4360            return didRemove;
 4361        }
 362
 363        /// <summary>
 364        ///     Removes the allocated entry corresponding to the sparse index.
 365        ///     Indicates which dense indices were swapped as a result of removing the entry.
 366        /// </summary>
 367        /// <param name="sparseIndexToRemove">The sparse index to remove.</param>
 368        /// <param name="version">
 369        ///     The version number of the int used to access the sparse index. Used to guard against accessing
 370        ///     indices that have been removed and reused.
 371        /// </param>
 372        /// <param name="versionArray">The array where version numbers to check against are stored.</param>
 373        /// <param name="dataIndexToSwapTo">Replace the data array value at this index with the data array value at inde
 374        /// <param name="dataIndexToSwapFrom">
 375        ///     Set the data array value at this index to default after swapping with the data array
 376        ///     value at dataIndexToSwapTo.
 377        /// </param>
 378        /// <returns>Whether or not the remove attempt succeeded.</returns>
 379        public bool RemoveWithVersionCheck(int sparseIndexToRemove, ulong version, ulong[] versionArray,
 380            out int dataIndexToSwapFrom, out int dataIndexToSwapTo)
 2381        {
 2382            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 2383            ulong versionAtSparseIndex = versionArray[sparseIndexToRemove];
 384
 2385            dataIndexToSwapFrom = -1;
 2386            dataIndexToSwapTo = -1;
 387
 2388            bool succeeded = versionAtSparseIndex == version;
 389
 2390            if (succeeded)
 1391            {
 1392                int newLength = Count - 1;
 1393                int sparseIndexBeingSwapped = DenseArray[newLength];
 394
 395                // Swap the entry being removed with the last entry.
 1396                SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1397                DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 398
 399                // Clear the dense  index, for debugging purposes
 1400                DenseArray[newLength] = -1;
 401
 402                // Add the sparse index to the free list.
 1403                SparseArray[sparseIndexToRemove] = FreeIndex;
 1404                versionArray[sparseIndexToRemove] = versionArray[sparseIndexToRemove] + 1;
 1405                FreeIndex = sparseIndexToRemove;
 406
 1407                Count = newLength;
 408
 1409                dataIndexToSwapTo = denseIndexToRemove;
 1410                dataIndexToSwapFrom = newLength;
 1411            }
 412
 2413            return succeeded;
 2414        }
 415
 416        /// <summary>
 417        ///     Removes the allocated entry corresponding to the sparse index.
 418        /// </summary>
 419        /// <param name="sparseIndexToRemove">The sparse index corresponding to the entry to remove.</param>
 420        /// <param name="version">
 421        ///     The version number of the int used to access the sparse index. Used to guard against erroneously accessi
 422        ///     freed indices currently in use with an outdated reference.
 423        /// </param>
 424        /// <param name="dataIndexToSwapTo">Replace the data array value at this index with the data array value at inde
 425        /// <param name="dataIndexToSwapFrom">
 426        ///     Set the data array value at this index to default after swapping with the data array
 427        ///     value at dataIndexToSwapTo.
 428        /// </param>
 429        /// <param name="versionArray">The array where version numbers to check against are stored.</param>
 430        /// <returns>True if the entry was valid and thus removed.</returns>
 431        public bool RemoveWithBoundsAndVersionChecks(ref int sparseIndexToRemove, ulong version,
 432            ulong[] versionArray, out int dataIndexToSwapFrom, out int dataIndexToSwapTo)
 6433        {
 6434            dataIndexToSwapFrom = -1;
 6435            dataIndexToSwapTo = -1;
 6436            bool didRemove = false;
 6437            if (sparseIndexToRemove >= 0 && sparseIndexToRemove < SparseArray.Length)
 3438            {
 3439                ulong sparseIndexVersion = versionArray[sparseIndexToRemove];
 3440                int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 441
 3442                if (sparseIndexVersion == version && denseIndexToRemove >= 0 && denseIndexToRemove < Count)
 2443                {
 2444                    int sparseIndexAtDenseIndex = DenseArray[denseIndexToRemove];
 2445                    int newLength = Count - 1;
 2446                    int sparseIndexBeingSwapped = DenseArray[newLength];
 447
 2448                    if (denseIndexToRemove < Count && sparseIndexAtDenseIndex == sparseIndexToRemove)
 2449                    {
 2450                        didRemove = true;
 2451                        versionArray[sparseIndexToRemove] = sparseIndexVersion + 1;
 452                        // Swap the entry being removed with the last entry.
 2453                        SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 2454                        DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 455
 2456                        dataIndexToSwapFrom = newLength;
 2457                        dataIndexToSwapTo = denseIndexToRemove;
 458
 459                        // Clear the dense index, for debugging purposes
 2460                        DenseArray[newLength] = -1;
 461
 462                        // Add the sparse index to the free list.
 2463                        SparseArray[sparseIndexToRemove] = FreeIndex;
 2464                        FreeIndex = sparseIndexToRemove;
 465
 2466                        Count = newLength;
 2467                    }
 2468                }
 3469            }
 470
 6471            sparseIndexToRemove = -1;
 472
 6473            return didRemove;
 6474        }
 475
 476        /// <summary>
 477        ///     Removes the associated sparse/dense index pair from active use.
 478        /// </summary>
 479        /// <param name="sparseIndexToRemove">The sparse index to remove.</param>
 480        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 481        public void RemoveUnchecked(int sparseIndexToRemove)
 1482        {
 1483            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 1484            int newLength = Count - 1;
 1485            int sparseIndexBeingSwapped = DenseArray[newLength];
 486
 487            // Swap the entry being removed with the last entry.
 1488            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1489            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 490
 491            // Clear the dense  index, for debugging purposes
 1492            DenseArray[newLength] = -1;
 493
 494            // Add the sparse index to the free list.
 1495            SparseArray[sparseIndexToRemove] = FreeIndex;
 1496            FreeIndex = sparseIndexToRemove;
 497
 1498            Count = newLength;
 1499        }
 500
 501        /// <summary>
 502        ///     Removes the associated sparse/dense index pair from active use.
 503        ///     Out parameters used to manage parallel data arrays.
 504        /// </summary>
 505        /// <param name="sparseIndexToRemove">The sparse index to remove.</param>
 506        /// <param name="indexToSwapTo">Replace the data array value at this index with the data array value at indexToS
 507        /// <param name="indexToSwapFrom">
 508        ///     Set the data array value at this index to default after swapping with the data array
 509        ///     value at indexToSwapTo.
 510        /// </param>
 511        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 512        public void RemoveUnchecked(int sparseIndexToRemove, out int indexToSwapFrom, out int indexToSwapTo)
 1513        {
 1514            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 1515            int newLength = Count - 1;
 1516            int sparseIndexBeingSwapped = DenseArray[newLength];
 517
 518            // Swap the entry being removed with the last entry.
 1519            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1520            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 521
 522            // Clear the dense  index, for debugging purposes
 1523            DenseArray[newLength] = -1;
 524
 525            // Add the sparse index to the free list.
 1526            SparseArray[sparseIndexToRemove] = FreeIndex;
 1527            FreeIndex = sparseIndexToRemove;
 528
 1529            Count = newLength;
 530
 1531            indexToSwapTo = denseIndexToRemove;
 1532            indexToSwapFrom = newLength;
 1533        }
 534
 535        /// <summary>
 536        ///     Removes the associated sparse/dense index pair from active use and increments the version.
 537        ///     Out parameters used to manage parallel data arrays.
 538        /// </summary>
 539        /// <param name="sparseIndexToRemove">The sparse index to remove.</param>
 540        /// <param name="versionArray">The array where version numbers to check against are stored.</param>
 541        /// <param name="indexToSwapTo">Replace the data array value at this index with the data array value at indexToS
 542        /// <param name="indexToSwapFrom">
 543        ///     Set the data array value at this index to default after swapping with the data array
 544        ///     value at indexToSwapTo.
 545        /// </param>
 546        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 547        public void RemoveUnchecked(int sparseIndexToRemove, ulong[] versionArray, out int indexToSwapFrom, out int inde
 2548        {
 2549            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 2550            int newLength = Count - 1;
 2551            int sparseIndexBeingSwapped = DenseArray[newLength];
 552
 553            // Swap the entry being removed with the last entry.
 2554            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 2555            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 556
 557            // Clear the dense  index, for debugging purposes
 2558            DenseArray[newLength] = -1;
 559
 560            // Add the sparse index to the free list.
 2561            SparseArray[sparseIndexToRemove] = FreeIndex;
 2562            versionArray[sparseIndexToRemove] = versionArray[sparseIndexToRemove] + 1;
 2563            FreeIndex = sparseIndexToRemove;
 564
 2565            Count = newLength;
 566
 2567            indexToSwapTo = denseIndexToRemove;
 2568            indexToSwapFrom = newLength;
 2569        }
 570
 571        /// <summary>
 572        ///     Removes the associated sparse/dense index pair from active use.
 573        /// </summary>
 574        /// <param name="denseIndexToRemove">The dense index associated with the sparse index to remove.</param>
 575        public void RemoveUncheckedFromDenseIndex(int denseIndexToRemove)
 1576        {
 1577            int sparseIndexToRemove = DenseArray[denseIndexToRemove];
 1578            int newLength = Count - 1;
 1579            int sparseIndexBeingSwapped = DenseArray[newLength];
 580
 581            // Swap the entry being removed with the last entry.
 1582            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1583            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 584
 585            // Clear the dense  index, for debugging purposes
 1586            DenseArray[newLength] = -1;
 587
 588            // Add the sparse index to the free list.
 1589            SparseArray[sparseIndexToRemove] = FreeIndex;
 1590            FreeIndex = sparseIndexToRemove;
 591
 1592            Count = newLength;
 1593        }
 594
 595        /// <summary>
 596        ///     Removes the associated sparse/dense index pair from active use.
 597        /// </summary>
 598        /// <param name="denseIndexToRemove">The dense index associated with the sparse index to remove.</param>
 599        /// <param name="versionArray">The array where version numbers to check against are stored.</param>
 600        public void RemoveUncheckedFromDenseIndex(int denseIndexToRemove, ulong[] versionArray)
 1601        {
 1602            int sparseIndexToRemove = DenseArray[denseIndexToRemove];
 1603            int newLength = Count - 1;
 1604            int sparseIndexBeingSwapped = DenseArray[newLength];
 605
 606            // Swap the entry being removed with the last entry.
 1607            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1608            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 609
 610            // Clear the dense  index, for debugging purposes
 1611            DenseArray[newLength] = -1;
 612
 613            // Add the sparse index to the free list.
 1614            SparseArray[sparseIndexToRemove] = FreeIndex;
 1615            versionArray[sparseIndexToRemove] += 1;
 1616            FreeIndex = sparseIndexToRemove;
 617
 1618            Count = newLength;
 1619        }
 620
 621        /// <summary>
 622        ///     Removes the associated sparse/dense index pair from active use.
 623        ///     Out parameter used to manage parallel data arrays.
 624        /// </summary>
 625        /// <param name="denseIndexToRemove">The sparse index to remove.</param>
 626        /// <param name="indexToSwapFrom">
 627        ///     Set the data array value at this index to default after swapping with the data array
 628        ///     value at denseIndexToRemove.
 629        /// </param>
 630        public void RemoveUncheckedFromDenseIndex(int denseIndexToRemove, out int indexToSwapFrom)
 1631        {
 1632            int sparseIndexToRemove = DenseArray[denseIndexToRemove];
 1633            int newLength = Count - 1;
 1634            int sparseIndexBeingSwapped = DenseArray[newLength];
 635
 636            // Swap the entry being removed with the last entry.
 1637            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1638            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 639
 640            // Clear the dense  index, for debugging purposes
 1641            DenseArray[newLength] = -1;
 642
 643            // Add the sparse index to the free list.
 1644            SparseArray[sparseIndexToRemove] = FreeIndex;
 1645            FreeIndex = sparseIndexToRemove;
 646
 1647            Count = newLength;
 648
 1649            indexToSwapFrom = newLength;
 1650        }
 651
 652        /// <summary>
 653        ///     Removes the associated sparse/dense index pair from active use.
 654        ///     Out parameter used to manage parallel data arrays.
 655        /// </summary>
 656        /// <param name="denseIndexToRemove">The sparse index to remove.</param>
 657        /// <param name="versionArray">The array where version numbers to check against are stored.</param>
 658        /// <param name="indexToSwapFrom">
 659        ///     Set the data array value at this index to default after swapping with the data array
 660        ///     value at denseIndexToRemove.
 661        /// </param>
 662        public void RemoveUncheckedFromDenseIndex(int denseIndexToRemove, ulong[] versionArray, out int indexToSwapFrom)
 1663        {
 1664            int sparseIndexToRemove = DenseArray[denseIndexToRemove];
 1665            int newLength = Count - 1;
 1666            int sparseIndexBeingSwapped = DenseArray[newLength];
 667
 668            // Swap the entry being removed with the last entry.
 1669            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1670            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 671
 672            // Clear the dense  index, for debugging purposes
 1673            DenseArray[newLength] = -1;
 674
 675            // Add the sparse index to the free list.
 1676            SparseArray[sparseIndexToRemove] = FreeIndex;
 1677            versionArray[sparseIndexToRemove] = versionArray[sparseIndexToRemove] + 1;
 1678            FreeIndex = sparseIndexToRemove;
 679
 1680            Count = newLength;
 681
 1682            indexToSwapFrom = newLength;
 1683        }
 684
 685        /// <summary>
 686        ///     Clear the dense and sparse arrays.
 687        /// </summary>
 688        public void Clear()
 1689        {
 1690            int capacity = SparseArray.Length;
 8691            for (int i = 0; i < capacity; i++)
 3692            {
 3693                DenseArray[i] = -1;
 3694                SparseArray[i] = i + 1;
 3695            }
 696
 1697            FreeIndex = 0;
 1698            Count = 0;
 1699        }
 700
 701        /// <summary>
 702        ///     Clear the dense and sparse arrays.
 703        /// </summary>
 704        /// ///
 705        /// <param name="versionArray">Array containing version numbers to check against.</param>
 706        public void Clear(ulong[] versionArray)
 1707        {
 1708            int capacity = SparseArray.Length;
 8709            for (int i = 0; i < capacity; i++)
 3710            {
 3711                DenseArray[i] = -1;
 3712                SparseArray[i] = i + 1;
 3713                versionArray[i] = versionArray[i] + 1;
 3714            }
 715
 1716            FreeIndex = 0;
 1717            Count = 0;
 1718        }
 719
 720        /// <summary>
 721        ///     Clear the dense and sparse arrays and reset the version array.
 722        ///     Note: Only clear the version array if you are sure there are no outstanding dependencies on version numb
 723        /// </summary>
 724        /// ///
 725        /// <param name="versionArray">Array containing version numbers to check against.</param>
 726        public void ClearWithVersionArrayReset(ulong[] versionArray)
 1727        {
 1728            int capacity = SparseArray.Length;
 8729            for (int i = 0; i < capacity; i++)
 3730            {
 3731                DenseArray[i] = -1;
 3732                SparseArray[i] = i + 1;
 3733                versionArray[i] = 1;
 3734            }
 735
 1736            FreeIndex = 0;
 1737            Count = 0;
 1738        }
 739
 740        /// <summary>
 741        ///     Reallocate the dense and sparse arrays with additional capacity.
 742        /// </summary>
 743        /// <param name="extraCapacity">How many indices to expand the dense and sparse arrays by.</param>
 744        public void Expand(int extraCapacity)
 1745        {
 1746            int currentCapacity = SparseArray.Length;
 1747            int newCapacity = currentCapacity + extraCapacity;
 748
 1749            int[] newSparseArray = new int[newCapacity];
 1750            Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 1751            SparseArray = newSparseArray;
 752
 1753            int[] newDenseArray = new int[newCapacity];
 1754            Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 1755            DenseArray = newDenseArray;
 756
 8757            for (int i = currentCapacity; i < newCapacity; i++)
 3758            {
 3759                DenseArray[i] = -1; // Set new dense indices as unclaimed.
 3760                SparseArray[i] = i + 1; // Build the free list chain.
 3761            }
 1762        }
 763
 764        /// <summary>
 765        ///     Reallocate the dense and sparse arrays with additional capacity.
 766        /// </summary>
 767        /// <param name="extraCapacity">How many indices to expand the dense and sparse arrays by.</param>
 768        /// <param name="versionArray">Array containing version numbers to check against.</param>
 769        public void Expand(int extraCapacity, ref ulong[] versionArray)
 2770        {
 2771            int currentCapacity = SparseArray.Length;
 2772            int newCapacity = currentCapacity + extraCapacity;
 773
 2774            int[] newSparseArray = new int[newCapacity];
 2775            Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 2776            SparseArray = newSparseArray;
 777
 2778            int[] newDenseArray = new int[newCapacity];
 2779            Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 2780            DenseArray = newDenseArray;
 781
 2782            ulong[] newVersionArray = new ulong[newCapacity];
 2783            Array.Copy(versionArray, 0, newVersionArray, 0, currentCapacity);
 2784            versionArray = newVersionArray;
 785
 16786            for (int i = currentCapacity; i < newCapacity; i++)
 6787            {
 6788                DenseArray[i] = -1; // Set new dense indices as unclaimed.
 6789                SparseArray[i] = i + 1; // Build the free list chain.
 6790                versionArray[i] = 1;
 6791            }
 2792        }
 793
 794        public void Reserve(int numberToReserve)
 1795        {
 1796            int currentCapacity = SparseArray.Length;
 1797            int currentCount = Count;
 1798            int newCount = currentCount + numberToReserve;
 799
 1800            if (newCount > currentCapacity)
 1801            {
 1802                int[] newSparseArray = new int[newCount];
 1803                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 1804                SparseArray = newSparseArray;
 805
 1806                int[] newDenseArray = new int[newCount];
 1807                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 1808                DenseArray = newDenseArray;
 809
 4810                for (int i = currentCapacity; i < newCount; i++)
 1811                {
 1812                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 1813                    SparseArray[i] = i + 1; // Build the free list chain.
 1814                }
 1815            }
 1816        }
 817
 818        public void Reserve(int numberToReserve, ref ulong[] versionArray)
 0819        {
 0820            int currentCapacity = SparseArray.Length;
 0821            int currentCount = Count;
 0822            int newCount = currentCount + numberToReserve;
 823
 0824            if (newCount > currentCapacity)
 0825            {
 0826                int[] newSparseArray = new int[newCount];
 0827                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 0828                SparseArray = newSparseArray;
 829
 0830                int[] newDenseArray = new int[newCount];
 0831                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 0832                DenseArray = newDenseArray;
 833
 0834                ulong[] newVersionArray = new ulong[newCount];
 0835                Array.Copy(versionArray, 0, newVersionArray, 0, currentCapacity);
 0836                versionArray = newVersionArray;
 837
 0838                for (int i = currentCapacity; i < newCount; i++)
 0839                {
 0840                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 0841                    SparseArray[i] = i + 1; // Build the free list chain.
 0842                    versionArray[i] = 1;
 0843                }
 0844            }
 0845        }
 846
 847        #region Parallel array method duplicates
 848
 849        /// <summary>
 850        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 851        /// </summary>
 852        /// <returns>True if the index pool expanded.</returns>
 853        public bool AddWithExpandCheck<T0>(T0 obj0, ref T0[] array0, out int lookupIndex, int howMuchToExpand = 16)
 2854        {
 2855            int indexToClaim = FreeIndex;
 2856            int currentCapacity = SparseArray.Length;
 2857            bool needsExpansion = false;
 858
 2859            if (indexToClaim >= currentCapacity)
 1860            {
 1861                needsExpansion = true;
 862                // We're out of space, the last free index points to nothing. Allocate more indices.
 1863                int newCapacity = currentCapacity + howMuchToExpand;
 864
 1865                int[] newSparseArray = new int[newCapacity];
 1866                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 1867                SparseArray = newSparseArray;
 868
 1869                int[] newDenseArray = new int[newCapacity];
 1870                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 1871                DenseArray = newDenseArray;
 872
 1873                T0[] newArray0 = new T0[newCapacity];
 1874                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 1875                array0 = newArray0;
 876
 12877                for (int i = currentCapacity; i < newCapacity; i++)
 5878                {
 5879                    SparseArray[i] = i + 1; // Build the free list chain.
 5880                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 5881                }
 1882            }
 883
 2884            int nextFreeIndex = SparseArray[indexToClaim];
 885
 2886            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 2887            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 888
 2889            array0[Count] = obj0;
 890
 2891            ++Count;
 2892            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 893
 2894            lookupIndex = indexToClaim;
 2895            return needsExpansion;
 2896        }
 897
 898        /// <summary>
 899        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 900        /// </summary>
 901        /// <returns>True if the index pool expanded.</returns>
 902        public bool AddWithExpandCheck<T0, T1>(T0 obj0, ref T0[] array0, T1 obj1, ref T1[] array1, out int lookupIndex,
 903            int howMuchToExpand = 16)
 2904        {
 2905            int indexToClaim = FreeIndex;
 2906            int currentCapacity = SparseArray.Length;
 2907            bool needsExpansion = false;
 908
 2909            if (indexToClaim >= currentCapacity)
 1910            {
 1911                needsExpansion = true;
 912                // We're out of space, the last free index points to nothing. Allocate more indices.
 1913                int newCapacity = currentCapacity + howMuchToExpand;
 914
 1915                int[] newSparseArray = new int[newCapacity];
 1916                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 1917                SparseArray = newSparseArray;
 918
 1919                int[] newDenseArray = new int[newCapacity];
 1920                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 1921                DenseArray = newDenseArray;
 922
 1923                T0[] newArray0 = new T0[newCapacity];
 1924                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 1925                array0 = newArray0;
 926
 1927                T1[] newArray1 = new T1[newCapacity];
 1928                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 1929                array1 = newArray1;
 930
 12931                for (int i = currentCapacity; i < newCapacity; i++)
 5932                {
 5933                    SparseArray[i] = i + 1; // Build the free list chain.
 5934                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 5935                }
 1936            }
 937
 2938            int nextFreeIndex = SparseArray[indexToClaim];
 939
 2940            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 2941            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 942
 2943            array0[Count] = obj0;
 2944            array1[Count] = obj1;
 945
 2946            ++Count;
 2947            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 948
 2949            lookupIndex = indexToClaim;
 2950            return needsExpansion;
 2951        }
 952
 953        /// <summary>
 954        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 955        /// </summary>
 956        /// <returns>True if the index pool expanded.</returns>
 957        public bool AddWithExpandCheck<T0, T1, T2>(T0 obj0, ref T0[] array0, T1 obj1, ref T1[] array1, T2 obj2,
 958            ref T2[] array2,
 959            out int lookupIndex, int howMuchToExpand = 16)
 2960        {
 2961            int indexToClaim = FreeIndex;
 2962            int currentCapacity = SparseArray.Length;
 2963            bool needsExpansion = false;
 964
 2965            if (indexToClaim >= currentCapacity)
 1966            {
 1967                needsExpansion = true;
 968                // We're out of space, the last free index points to nothing. Allocate more indices.
 1969                int newCapacity = currentCapacity + howMuchToExpand;
 970
 1971                int[] newSparseArray = new int[newCapacity];
 1972                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 1973                SparseArray = newSparseArray;
 974
 1975                int[] newDenseArray = new int[newCapacity];
 1976                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 1977                DenseArray = newDenseArray;
 978
 1979                T0[] newArray0 = new T0[newCapacity];
 1980                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 1981                array0 = newArray0;
 982
 1983                T1[] newArray1 = new T1[newCapacity];
 1984                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 1985                array1 = newArray1;
 986
 1987                T2[] newArray2 = new T2[newCapacity];
 1988                Array.Copy(array2, 0, newArray2, 0, currentCapacity);
 1989                array2 = newArray2;
 990
 12991                for (int i = currentCapacity; i < newCapacity; i++)
 5992                {
 5993                    SparseArray[i] = i + 1; // Build the free list chain.
 5994                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 5995                }
 1996            }
 997
 2998            int nextFreeIndex = SparseArray[indexToClaim];
 999
 21000            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 21001            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1002
 21003            array0[Count] = obj0;
 21004            array1[Count] = obj1;
 21005            array2[Count] = obj2;
 1006
 21007            ++Count;
 21008            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1009
 21010            lookupIndex = indexToClaim;
 21011            return needsExpansion;
 21012        }
 1013
 1014        /// <summary>
 1015        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 1016        /// </summary>
 1017        /// <returns>True if the index pool expanded.</returns>
 1018        public bool AddWithExpandCheck<T0, T1, T2, T3>(T0 obj0, ref T0[] array0, T1 obj1, ref T1[] array1, T2 obj2,
 1019            ref T2[] array2, T3 obj3, ref T3[] array3, out int lookupIndex, int howMuchToExpand = 16)
 21020        {
 21021            int indexToClaim = FreeIndex;
 21022            int currentCapacity = SparseArray.Length;
 21023            bool needsExpansion = false;
 1024
 21025            if (indexToClaim >= currentCapacity)
 11026            {
 11027                needsExpansion = true;
 1028                // We're out of space, the last free index points to nothing. Allocate more indices.
 11029                int newCapacity = currentCapacity + howMuchToExpand;
 1030
 11031                int[] newSparseArray = new int[newCapacity];
 11032                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 11033                SparseArray = newSparseArray;
 1034
 11035                int[] newDenseArray = new int[newCapacity];
 11036                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 11037                DenseArray = newDenseArray;
 1038
 11039                T0[] newArray0 = new T0[newCapacity];
 11040                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 11041                array0 = newArray0;
 1042
 11043                T1[] newArray1 = new T1[newCapacity];
 11044                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 11045                array1 = newArray1;
 1046
 11047                T2[] newArray2 = new T2[newCapacity];
 11048                Array.Copy(array2, 0, newArray2, 0, currentCapacity);
 11049                array2 = newArray2;
 1050
 11051                T3[] newArray3 = new T3[newCapacity];
 11052                Array.Copy(array3, 0, newArray3, 0, currentCapacity);
 11053                array3 = newArray3;
 1054
 121055                for (int i = currentCapacity; i < newCapacity; i++)
 51056                {
 51057                    SparseArray[i] = i + 1; // Build the free list chain.
 51058                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 51059                }
 11060            }
 1061
 21062            int nextFreeIndex = SparseArray[indexToClaim];
 1063
 21064            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 21065            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1066
 21067            array0[Count] = obj0;
 21068            array1[Count] = obj1;
 21069            array2[Count] = obj2;
 21070            array3[Count] = obj3;
 1071
 21072            ++Count;
 21073            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1074
 21075            lookupIndex = indexToClaim;
 21076            return needsExpansion;
 21077        }
 1078
 1079        /// <summary>
 1080        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 1081        /// </summary>
 1082        /// <returns>True if the index pool expanded.</returns>
 1083        public bool AddWithExpandCheck<T0, T1, T2, T3, T4>(T0 obj0, ref T0[] array0, T1 obj1, ref T1[] array1, T2 obj2,
 1084            ref T2[] array2, T3 obj3, ref T3[] array3, T4 obj4, ref T4[] array4, out int lookupIndex,
 1085            int howMuchToExpand = 16)
 21086        {
 21087            int indexToClaim = FreeIndex;
 21088            int currentCapacity = SparseArray.Length;
 21089            bool needsExpansion = false;
 1090
 21091            if (indexToClaim >= currentCapacity)
 11092            {
 11093                needsExpansion = true;
 1094                // We're out of space, the last free index points to nothing. Allocate more indices.
 11095                int newCapacity = currentCapacity + howMuchToExpand;
 1096
 11097                int[] newSparseArray = new int[newCapacity];
 11098                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 11099                SparseArray = newSparseArray;
 1100
 11101                int[] newDenseArray = new int[newCapacity];
 11102                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 11103                DenseArray = newDenseArray;
 1104
 11105                T0[] newArray0 = new T0[newCapacity];
 11106                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 11107                array0 = newArray0;
 1108
 11109                T1[] newArray1 = new T1[newCapacity];
 11110                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 11111                array1 = newArray1;
 1112
 11113                T2[] newArray2 = new T2[newCapacity];
 11114                Array.Copy(array2, 0, newArray2, 0, currentCapacity);
 11115                array2 = newArray2;
 1116
 11117                T3[] newArray3 = new T3[newCapacity];
 11118                Array.Copy(array3, 0, newArray3, 0, currentCapacity);
 11119                array3 = newArray3;
 1120
 11121                T4[] newArray4 = new T4[newCapacity];
 11122                Array.Copy(array4, 0, newArray4, 0, currentCapacity);
 11123                array4 = newArray4;
 1124
 121125                for (int i = currentCapacity; i < newCapacity; i++)
 51126                {
 51127                    SparseArray[i] = i + 1; // Build the free list chain.
 51128                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 51129                }
 11130            }
 1131
 21132            int nextFreeIndex = SparseArray[indexToClaim];
 1133
 21134            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 21135            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1136
 21137            array0[Count] = obj0;
 21138            array1[Count] = obj1;
 21139            array2[Count] = obj2;
 21140            array3[Count] = obj3;
 21141            array4[Count] = obj4;
 1142
 21143            ++Count;
 21144            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1145
 21146            lookupIndex = indexToClaim;
 21147            return needsExpansion;
 21148        }
 1149
 1150        /// <summary>
 1151        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 1152        /// </summary>
 1153        /// <returns>True if the index pool expanded.</returns>
 1154        public bool AddWithExpandCheck<T0, T1, T2, T3, T4, T5>(T0 obj0, ref T0[] array0, T1 obj1, ref T1[] array1,
 1155            T2 obj2,
 1156            ref T2[] array2, T3 obj3, ref T3[] array3, T4 obj4, ref T4[] array4, T5 obj5, ref T5[] array5,
 1157            out int lookupIndex, int howMuchToExpand = 16)
 21158        {
 21159            int indexToClaim = FreeIndex;
 21160            int currentCapacity = SparseArray.Length;
 21161            bool needsExpansion = false;
 1162
 21163            if (indexToClaim >= currentCapacity)
 11164            {
 11165                needsExpansion = true;
 1166                // We're out of space, the last free index points to nothing. Allocate more indices.
 11167                int newCapacity = currentCapacity + howMuchToExpand;
 1168
 11169                int[] newSparseArray = new int[newCapacity];
 11170                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 11171                SparseArray = newSparseArray;
 1172
 11173                int[] newDenseArray = new int[newCapacity];
 11174                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 11175                DenseArray = newDenseArray;
 1176
 11177                T0[] newArray0 = new T0[newCapacity];
 11178                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 11179                array0 = newArray0;
 1180
 11181                T1[] newArray1 = new T1[newCapacity];
 11182                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 11183                array1 = newArray1;
 1184
 11185                T2[] newArray2 = new T2[newCapacity];
 11186                Array.Copy(array2, 0, newArray2, 0, currentCapacity);
 11187                array2 = newArray2;
 1188
 11189                T3[] newArray3 = new T3[newCapacity];
 11190                Array.Copy(array3, 0, newArray3, 0, currentCapacity);
 11191                array3 = newArray3;
 1192
 11193                T4[] newArray4 = new T4[newCapacity];
 11194                Array.Copy(array4, 0, newArray4, 0, currentCapacity);
 11195                array4 = newArray4;
 1196
 11197                T5[] newArray5 = new T5[newCapacity];
 11198                Array.Copy(array5, 0, newArray5, 0, currentCapacity);
 11199                array5 = newArray5;
 1200
 121201                for (int i = currentCapacity; i < newCapacity; i++)
 51202                {
 51203                    SparseArray[i] = i + 1; // Build the free list chain.
 51204                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 51205                }
 11206            }
 1207
 21208            int nextFreeIndex = SparseArray[indexToClaim];
 1209
 21210            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 21211            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1212
 21213            array0[Count] = obj0;
 21214            array1[Count] = obj1;
 21215            array2[Count] = obj2;
 21216            array3[Count] = obj3;
 21217            array4[Count] = obj4;
 21218            array5[Count] = obj5;
 1219
 21220            ++Count;
 21221            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1222
 21223            lookupIndex = indexToClaim;
 21224            return needsExpansion;
 21225        }
 1226
 1227        /// <summary>
 1228        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 1229        /// </summary>
 1230        /// <returns>True if the index pool expanded.</returns>
 1231        public bool AddWithExpandCheck<T0, T1, T2, T3, T4, T5, T6>(T0 obj0, ref T0[] array0, T1 obj1, ref T1[] array1,
 1232            T2 obj2,
 1233            ref T2[] array2, T3 obj3, ref T3[] array3, T4 obj4, ref T4[] array4, T5 obj5, ref T5[] array5, T6 obj6,
 1234            ref T6[] array6, out int lookupIndex, int howMuchToExpand = 16)
 21235        {
 21236            int indexToClaim = FreeIndex;
 21237            int currentCapacity = SparseArray.Length;
 21238            bool needsExpansion = false;
 1239
 21240            if (indexToClaim >= currentCapacity)
 11241            {
 11242                needsExpansion = true;
 1243                // We're out of space, the last free index points to nothing. Allocate more indices.
 11244                int newCapacity = currentCapacity + howMuchToExpand;
 1245
 11246                int[] newSparseArray = new int[newCapacity];
 11247                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 11248                SparseArray = newSparseArray;
 1249
 11250                int[] newDenseArray = new int[newCapacity];
 11251                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 11252                DenseArray = newDenseArray;
 1253
 11254                T0[] newArray0 = new T0[newCapacity];
 11255                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 11256                array0 = newArray0;
 1257
 11258                T1[] newArray1 = new T1[newCapacity];
 11259                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 11260                array1 = newArray1;
 1261
 11262                T2[] newArray2 = new T2[newCapacity];
 11263                Array.Copy(array2, 0, newArray2, 0, currentCapacity);
 11264                array2 = newArray2;
 1265
 11266                T3[] newArray3 = new T3[newCapacity];
 11267                Array.Copy(array3, 0, newArray3, 0, currentCapacity);
 11268                array3 = newArray3;
 1269
 11270                T4[] newArray4 = new T4[newCapacity];
 11271                Array.Copy(array4, 0, newArray4, 0, currentCapacity);
 11272                array4 = newArray4;
 1273
 11274                T5[] newArray5 = new T5[newCapacity];
 11275                Array.Copy(array5, 0, newArray5, 0, currentCapacity);
 11276                array5 = newArray5;
 1277
 11278                T6[] newArray6 = new T6[newCapacity];
 11279                Array.Copy(array6, 0, newArray6, 0, currentCapacity);
 11280                array6 = newArray6;
 1281
 121282                for (int i = currentCapacity; i < newCapacity; i++)
 51283                {
 51284                    SparseArray[i] = i + 1; // Build the free list chain.
 51285                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 51286                }
 11287            }
 1288
 21289            int nextFreeIndex = SparseArray[indexToClaim];
 1290
 21291            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 21292            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1293
 21294            array0[Count] = obj0;
 21295            array1[Count] = obj1;
 21296            array2[Count] = obj2;
 21297            array3[Count] = obj3;
 21298            array4[Count] = obj4;
 21299            array5[Count] = obj5;
 21300            array6[Count] = obj6;
 1301
 21302            ++Count;
 21303            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1304
 21305            lookupIndex = indexToClaim;
 21306            return needsExpansion;
 21307        }
 1308
 1309        /// <summary>
 1310        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 1311        /// </summary>
 1312        /// <returns>True if the index pool expanded.</returns>
 1313        public bool AddWithExpandCheck<T0, T1, T2, T3, T4, T5, T6, T7>(T0 obj0, ref T0[] array0, T1 obj1,
 1314            ref T1[] array1, T2 obj2,
 1315            ref T2[] array2, T3 obj3, ref T3[] array3, T4 obj4, ref T4[] array4, T5 obj5, ref T5[] array5, T6 obj6,
 1316            ref T6[] array6, T7 obj7, ref T7[] array7, out int lookupIndex, int howMuchToExpand = 16)
 21317        {
 21318            int indexToClaim = FreeIndex;
 21319            int currentCapacity = SparseArray.Length;
 21320            bool needsExpansion = false;
 1321
 21322            if (indexToClaim >= currentCapacity)
 11323            {
 11324                needsExpansion = true;
 1325                // We're out of space, the last free index points to nothing. Allocate more indices.
 11326                int newCapacity = currentCapacity + howMuchToExpand;
 1327
 11328                int[] newSparseArray = new int[newCapacity];
 11329                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 11330                SparseArray = newSparseArray;
 1331
 11332                int[] newDenseArray = new int[newCapacity];
 11333                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 11334                DenseArray = newDenseArray;
 1335
 11336                T0[] newArray0 = new T0[newCapacity];
 11337                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 11338                array0 = newArray0;
 1339
 11340                T1[] newArray1 = new T1[newCapacity];
 11341                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 11342                array1 = newArray1;
 1343
 11344                T2[] newArray2 = new T2[newCapacity];
 11345                Array.Copy(array2, 0, newArray2, 0, currentCapacity);
 11346                array2 = newArray2;
 1347
 11348                T3[] newArray3 = new T3[newCapacity];
 11349                Array.Copy(array3, 0, newArray3, 0, currentCapacity);
 11350                array3 = newArray3;
 1351
 11352                T4[] newArray4 = new T4[newCapacity];
 11353                Array.Copy(array4, 0, newArray4, 0, currentCapacity);
 11354                array4 = newArray4;
 1355
 11356                T5[] newArray5 = new T5[newCapacity];
 11357                Array.Copy(array5, 0, newArray5, 0, currentCapacity);
 11358                array5 = newArray5;
 1359
 11360                T6[] newArray6 = new T6[newCapacity];
 11361                Array.Copy(array6, 0, newArray6, 0, currentCapacity);
 11362                array6 = newArray6;
 1363
 11364                T7[] newArray7 = new T7[newCapacity];
 11365                Array.Copy(array7, 0, newArray7, 0, currentCapacity);
 11366                array7 = newArray7;
 1367
 121368                for (int i = currentCapacity; i < newCapacity; i++)
 51369                {
 51370                    SparseArray[i] = i + 1; // Build the free list chain.
 51371                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 51372                }
 11373            }
 1374
 21375            int nextFreeIndex = SparseArray[indexToClaim];
 1376
 21377            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 21378            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1379
 21380            array0[Count] = obj0;
 21381            array1[Count] = obj1;
 21382            array2[Count] = obj2;
 21383            array3[Count] = obj3;
 21384            array4[Count] = obj4;
 21385            array5[Count] = obj5;
 21386            array6[Count] = obj6;
 21387            array7[Count] = obj7;
 1388
 21389            ++Count;
 21390            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1391
 21392            lookupIndex = indexToClaim;
 21393            return needsExpansion;
 21394        }
 1395
 1396        /// <summary>
 1397        ///     Adds to the set without checking if the set needs to expand.
 1398        /// </summary>
 1399        /// <returns>The sparse index allocated</returns>
 1400        public int AddUnchecked<T0>(T0 obj0, T0[] array0)
 41401        {
 41402            int indexToClaim = FreeIndex;
 41403            int nextFreeIndex = SparseArray[indexToClaim];
 41404            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41405            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1406
 41407            array0[Count] = obj0;
 1408
 41409            ++Count;
 41410            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1411
 41412            return indexToClaim;
 41413        }
 1414
 1415        /// <summary>
 1416        ///     Adds to the set without checking if the set needs to expand.
 1417        /// </summary>
 1418        /// <returns>The sparse index allocated</returns>
 1419        public int AddUnchecked<T0, T1>(T0 obj0, T0[] array0, T1 obj1, T1[] array1)
 41420        {
 41421            int indexToClaim = FreeIndex;
 41422            int nextFreeIndex = SparseArray[indexToClaim];
 41423            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41424            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1425
 41426            array0[Count] = obj0;
 41427            array1[Count] = obj1;
 1428
 41429            ++Count;
 41430            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1431
 41432            return indexToClaim;
 41433        }
 1434
 1435        /// <summary>
 1436        ///     Adds to the set without checking if the set needs to expand.
 1437        /// </summary>
 1438        /// <returns>The sparse index allocated</returns>
 1439        public int AddUnchecked<T0, T1, T2>(T0 obj0, T0[] array0, T1 obj1, T1[] array1, T2 obj2, T2[] array2)
 41440        {
 41441            int indexToClaim = FreeIndex;
 41442            int nextFreeIndex = SparseArray[indexToClaim];
 41443            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41444            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1445
 41446            array0[Count] = obj0;
 41447            array1[Count] = obj1;
 41448            array2[Count] = obj2;
 1449
 41450            ++Count;
 41451            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1452
 41453            return indexToClaim;
 41454        }
 1455
 1456        /// <summary>
 1457        ///     Adds to the set without checking if the set needs to expand.
 1458        /// </summary>
 1459        /// <returns>The sparse index allocated</returns>
 1460        public int AddUnchecked<T0, T1, T2, T3>(T0 obj0, T0[] array0, T1 obj1, T1[] array1, T2 obj2, T2[] array2,
 1461            T3 obj3,
 1462            T3[] array3)
 41463        {
 41464            int indexToClaim = FreeIndex;
 41465            int nextFreeIndex = SparseArray[indexToClaim];
 41466            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41467            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1468
 41469            array0[Count] = obj0;
 41470            array1[Count] = obj1;
 41471            array2[Count] = obj2;
 41472            array3[Count] = obj3;
 1473
 41474            ++Count;
 41475            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1476
 41477            return indexToClaim;
 41478        }
 1479
 1480        /// <summary>
 1481        ///     Adds to the set without checking if the set needs to expand.
 1482        /// </summary>
 1483        /// <returns>The sparse index allocated</returns>
 1484        public int AddUnchecked<T0, T1, T2, T3, T4>(T0 obj0, T0[] array0, T1 obj1, T1[] array1, T2 obj2, T2[] array2,
 1485            T3 obj3, T3[] array3, T4 obj4, T4[] array4)
 41486        {
 41487            int indexToClaim = FreeIndex;
 41488            int nextFreeIndex = SparseArray[indexToClaim];
 41489            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41490            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1491
 41492            array0[Count] = obj0;
 41493            array1[Count] = obj1;
 41494            array2[Count] = obj2;
 41495            array3[Count] = obj3;
 41496            array4[Count] = obj4;
 1497
 41498            ++Count;
 41499            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1500
 41501            return indexToClaim;
 41502        }
 1503
 1504        /// <summary>
 1505        ///     Adds to the set without checking if the set needs to expand.
 1506        /// </summary>
 1507        /// <returns>The sparse index allocated</returns>
 1508        public int AddUnchecked<T0, T1, T2, T3, T4, T5>(T0 obj0, T0[] array0, T1 obj1, T1[] array1, T2 obj2,
 1509            T2[] array2,
 1510            T3 obj3, T3[] array3, T4 obj4, T4[] array4, T5 obj5, T5[] array5)
 41511        {
 41512            int indexToClaim = FreeIndex;
 41513            int nextFreeIndex = SparseArray[indexToClaim];
 41514            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41515            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1516
 41517            array0[Count] = obj0;
 41518            array1[Count] = obj1;
 41519            array2[Count] = obj2;
 41520            array3[Count] = obj3;
 41521            array4[Count] = obj4;
 41522            array5[Count] = obj5;
 1523
 41524            ++Count;
 41525            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1526
 41527            return indexToClaim;
 41528        }
 1529
 1530        /// <summary>
 1531        ///     Adds to the set without checking if the set needs to expand.
 1532        /// </summary>
 1533        /// <returns>The sparse index allocated</returns>
 1534        public int AddUnchecked<T0, T1, T2, T3, T4, T5, T6>(T0 obj0, T0[] array0, T1 obj1, T1[] array1, T2 obj2,
 1535            T2[] array2,
 1536            T3 obj3, T3[] array3, T4 obj4, T4[] array4, T5 obj5, T5[] array5, T6 obj6, T6[] array6)
 41537        {
 41538            int indexToClaim = FreeIndex;
 41539            int nextFreeIndex = SparseArray[indexToClaim];
 41540            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41541            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1542
 41543            array0[Count] = obj0;
 41544            array1[Count] = obj1;
 41545            array2[Count] = obj2;
 41546            array3[Count] = obj3;
 41547            array4[Count] = obj4;
 41548            array5[Count] = obj5;
 41549            array6[Count] = obj6;
 1550
 41551            ++Count;
 41552            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1553
 41554            return indexToClaim;
 41555        }
 1556
 1557        /// <summary>
 1558        ///     Adds to the set without checking if the set needs to expand.
 1559        /// </summary>
 1560        /// <returns>The sparse index allocated</returns>
 1561        public int AddUnchecked<T0, T1, T2, T3, T4, T5, T6, T7>(T0 obj0, T0[] array0, T1 obj1, T1[] array1, T2 obj2,
 1562            T2[] array2, T3 obj3, T3[] array3, T4 obj4, T4[] array4, T5 obj5, T5[] array5, T6 obj6, T6[] array6,
 1563            T7 obj7, T7[] array7)
 41564        {
 41565            int indexToClaim = FreeIndex;
 41566            int nextFreeIndex = SparseArray[indexToClaim];
 41567            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41568            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1569
 41570            array0[Count] = obj0;
 41571            array1[Count] = obj1;
 41572            array2[Count] = obj2;
 41573            array3[Count] = obj3;
 41574            array4[Count] = obj4;
 41575            array5[Count] = obj5;
 41576            array6[Count] = obj6;
 41577            array7[Count] = obj7;
 1578
 41579            ++Count;
 41580            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1581
 41582            return indexToClaim;
 41583        }
 1584
 1585        public void RemoveUnchecked<T0>(int sparseIndexToRemove, T0[] array0)
 21586        {
 21587            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 21588            int newLength = Count - 1;
 21589            int sparseIndexBeingSwapped = DenseArray[newLength];
 1590
 1591            // Swap the entry being removed with the last entry.
 21592            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 21593            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 21594            array0[denseIndexToRemove] = array0[newLength];
 1595
 1596            // Clear the dense  index, for debugging purposes
 21597            DenseArray[newLength] = -1;
 21598            array0[newLength] = default;
 1599
 1600            // Add the sparse index to the free list.
 21601            SparseArray[sparseIndexToRemove] = FreeIndex;
 21602            FreeIndex = sparseIndexToRemove;
 1603
 21604            Count = newLength;
 21605        }
 1606
 1607        public void RemoveUnchecked<T0, T1>(int sparseIndexToRemove, T0[] array0, T1[] array1)
 11608        {
 11609            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11610            int newLength = Count - 1;
 11611            int sparseIndexBeingSwapped = DenseArray[newLength];
 1612
 1613            // Swap the entry being removed with the last entry.
 11614            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11615            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11616            array0[denseIndexToRemove] = array0[newLength];
 11617            array1[denseIndexToRemove] = array1[newLength];
 1618
 1619            // Clear the dense  index, for debugging purposes
 11620            DenseArray[newLength] = -1;
 11621            array0[newLength] = default;
 11622            array1[newLength] = default;
 1623
 1624            // Add the sparse index to the free list.
 11625            SparseArray[sparseIndexToRemove] = FreeIndex;
 11626            FreeIndex = sparseIndexToRemove;
 1627
 11628            Count = newLength;
 11629        }
 1630
 1631        public void RemoveUnchecked<T0, T1, T2>(int sparseIndexToRemove, T0[] array0, T1[] array1, T2[] array2)
 11632        {
 11633            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11634            int newLength = Count - 1;
 11635            int sparseIndexBeingSwapped = DenseArray[newLength];
 1636
 1637            // Swap the entry being removed with the last entry.
 11638            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11639            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11640            array0[denseIndexToRemove] = array0[newLength];
 11641            array1[denseIndexToRemove] = array1[newLength];
 11642            array2[denseIndexToRemove] = array2[newLength];
 1643
 1644            // Clear the dense  index, for debugging purposes
 11645            DenseArray[newLength] = -1;
 11646            array0[newLength] = default;
 11647            array1[newLength] = default;
 11648            array2[newLength] = default;
 1649
 1650            // Add the sparse index to the free list.
 11651            SparseArray[sparseIndexToRemove] = FreeIndex;
 11652            FreeIndex = sparseIndexToRemove;
 1653
 11654            Count = newLength;
 11655        }
 1656
 1657        public void RemoveUnchecked<T0, T1, T2, T3>(int sparseIndexToRemove, T0[] array0, T1[] array1, T2[] array2,
 1658            T3[] array3)
 11659        {
 11660            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11661            int newLength = Count - 1;
 11662            int sparseIndexBeingSwapped = DenseArray[newLength];
 1663
 1664            // Swap the entry being removed with the last entry.
 11665            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11666            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11667            array0[denseIndexToRemove] = array0[newLength];
 11668            array1[denseIndexToRemove] = array1[newLength];
 11669            array2[denseIndexToRemove] = array2[newLength];
 11670            array3[denseIndexToRemove] = array3[newLength];
 1671
 1672            // Clear the dense  index, for debugging purposes
 11673            DenseArray[newLength] = -1;
 11674            array0[newLength] = default;
 11675            array1[newLength] = default;
 11676            array2[newLength] = default;
 11677            array3[newLength] = default;
 1678
 1679            // Add the sparse index to the free list.
 11680            SparseArray[sparseIndexToRemove] = FreeIndex;
 11681            FreeIndex = sparseIndexToRemove;
 1682
 11683            Count = newLength;
 11684        }
 1685
 1686        public void RemoveUnchecked<T0, T1, T2, T3, T4>(int sparseIndexToRemove, T0[] array0, T1[] array1, T2[] array2,
 1687            T3[] array3, T4[] array4)
 11688        {
 11689            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11690            int newLength = Count - 1;
 11691            int sparseIndexBeingSwapped = DenseArray[newLength];
 1692
 1693            // Swap the entry being removed with the last entry.
 11694            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11695            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11696            array0[denseIndexToRemove] = array0[newLength];
 11697            array1[denseIndexToRemove] = array1[newLength];
 11698            array2[denseIndexToRemove] = array2[newLength];
 11699            array3[denseIndexToRemove] = array3[newLength];
 11700            array4[denseIndexToRemove] = array4[newLength];
 1701
 1702            // Clear the dense  index, for debugging purposes
 11703            DenseArray[newLength] = -1;
 11704            array0[newLength] = default;
 11705            array1[newLength] = default;
 11706            array2[newLength] = default;
 11707            array3[newLength] = default;
 11708            array4[newLength] = default;
 1709
 1710            // Add the sparse index to the free list.
 11711            SparseArray[sparseIndexToRemove] = FreeIndex;
 11712            FreeIndex = sparseIndexToRemove;
 1713
 11714            Count = newLength;
 11715        }
 1716
 1717        public void RemoveUnchecked<T0, T1, T2, T3, T4, T5>(int sparseIndexToRemove, T0[] array0, T1[] array1,
 1718            T2[] array2,
 1719            T3[] array3, T4[] array4, T5[] array5)
 11720        {
 11721            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11722            int newLength = Count - 1;
 11723            int sparseIndexBeingSwapped = DenseArray[newLength];
 1724
 1725            // Swap the entry being removed with the last entry.
 11726            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11727            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11728            array0[denseIndexToRemove] = array0[newLength];
 11729            array1[denseIndexToRemove] = array1[newLength];
 11730            array2[denseIndexToRemove] = array2[newLength];
 11731            array3[denseIndexToRemove] = array3[newLength];
 11732            array4[denseIndexToRemove] = array4[newLength];
 11733            array5[denseIndexToRemove] = array5[newLength];
 1734
 1735            // Clear the dense  index, for debugging purposes
 11736            DenseArray[newLength] = -1;
 11737            array0[newLength] = default;
 11738            array1[newLength] = default;
 11739            array2[newLength] = default;
 11740            array3[newLength] = default;
 11741            array4[newLength] = default;
 11742            array5[newLength] = default;
 1743
 1744            // Add the sparse index to the free list.
 11745            SparseArray[sparseIndexToRemove] = FreeIndex;
 11746            FreeIndex = sparseIndexToRemove;
 1747
 11748            Count = newLength;
 11749        }
 1750
 1751        public void RemoveUnchecked<T0, T1, T2, T3, T4, T5, T6>(int sparseIndexToRemove, T0[] array0, T1[] array1,
 1752            T2[] array2, T3[] array3, T4[] array4, T5[] array5, T6[] array6)
 11753        {
 11754            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11755            int newLength = Count - 1;
 11756            int sparseIndexBeingSwapped = DenseArray[newLength];
 1757
 1758            // Swap the entry being removed with the last entry.
 11759            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11760            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11761            array0[denseIndexToRemove] = array0[newLength];
 11762            array1[denseIndexToRemove] = array1[newLength];
 11763            array2[denseIndexToRemove] = array2[newLength];
 11764            array3[denseIndexToRemove] = array3[newLength];
 11765            array4[denseIndexToRemove] = array4[newLength];
 11766            array5[denseIndexToRemove] = array5[newLength];
 11767            array6[denseIndexToRemove] = array6[newLength];
 1768
 1769            // Clear the dense  index, for debugging purposes
 11770            DenseArray[newLength] = -1;
 11771            array0[newLength] = default;
 11772            array1[newLength] = default;
 11773            array2[newLength] = default;
 11774            array3[newLength] = default;
 11775            array4[newLength] = default;
 11776            array5[newLength] = default;
 11777            array6[newLength] = default;
 1778
 1779            // Add the sparse index to the free list.
 11780            SparseArray[sparseIndexToRemove] = FreeIndex;
 11781            FreeIndex = sparseIndexToRemove;
 1782
 11783            Count = newLength;
 11784        }
 1785
 1786        public void RemoveUnchecked<T0, T1, T2, T3, T4, T5, T6, T7>(int sparseIndexToRemove, T0[] array0, T1[] array1,
 1787            T2[] array2, T3[] array3, T4[] array4, T5[] array5, T6[] array6, T7[] array7)
 11788        {
 11789            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11790            int newLength = Count - 1;
 11791            int sparseIndexBeingSwapped = DenseArray[newLength];
 1792
 1793            // Swap the entry being removed with the last entry.
 11794            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11795            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11796            array0[denseIndexToRemove] = array0[newLength];
 11797            array1[denseIndexToRemove] = array1[newLength];
 11798            array2[denseIndexToRemove] = array2[newLength];
 11799            array3[denseIndexToRemove] = array3[newLength];
 11800            array4[denseIndexToRemove] = array4[newLength];
 11801            array5[denseIndexToRemove] = array5[newLength];
 11802            array6[denseIndexToRemove] = array6[newLength];
 11803            array7[denseIndexToRemove] = array7[newLength];
 1804
 1805            // Clear the dense  index, for debugging purposes
 11806            DenseArray[newLength] = -1;
 11807            array0[newLength] = default;
 11808            array1[newLength] = default;
 11809            array2[newLength] = default;
 11810            array3[newLength] = default;
 11811            array4[newLength] = default;
 11812            array5[newLength] = default;
 11813            array6[newLength] = default;
 11814            array7[newLength] = default;
 1815
 1816            // Add the sparse index to the free list.
 11817            SparseArray[sparseIndexToRemove] = FreeIndex;
 11818            FreeIndex = sparseIndexToRemove;
 1819
 11820            Count = newLength;
 11821        }
 1822
 1823        #endregion
 1824    }
 1825}

Methods/Properties

SparseSet(System.Int32)
SparseSet(System.Int32, System.UInt64[]&)
AddWithExpandCheck(System.Int32, System.Int32&, System.Int32&)
AddWithExpandCheck(System.Int32, System.Int32&, System.Int32&, System.UInt64[]&, System.UInt64&)
AddUnchecked(System.Int32&, System.Int32&)
AddUnchecked(System.Int32&, System.Int32&, System.UInt64[], System.UInt64&)
GetDenseIndexUnchecked(System.Int32)
GetDenseIndexWithBoundsCheck(System.Int32)
GetDenseIndexWithVersionCheck(System.Int32, System.UInt64, System.UInt64[])
GetDenseIndexWithBoundsAndVersionCheck(System.Int32, System.UInt64, System.UInt64[])
RemoveWithBoundsCheck(System.Int32&, System.Int32&, System.Int32&)
RemoveWithVersionCheck(System.Int32, System.UInt64, System.UInt64[], System.Int32&, System.Int32&)
RemoveWithBoundsAndVersionChecks(System.Int32&, System.UInt64, System.UInt64[], System.Int32&, System.Int32&)
RemoveUnchecked(System.Int32)
RemoveUnchecked(System.Int32, System.Int32&, System.Int32&)
RemoveUnchecked(System.Int32, System.UInt64[], System.Int32&, System.Int32&)
RemoveUncheckedFromDenseIndex(System.Int32)
RemoveUncheckedFromDenseIndex(System.Int32, System.UInt64[])
RemoveUncheckedFromDenseIndex(System.Int32, System.Int32&)
RemoveUncheckedFromDenseIndex(System.Int32, System.UInt64[], System.Int32&)
Clear()
Clear(System.UInt64[])
ClearWithVersionArrayReset(System.UInt64[])
Expand(System.Int32)
Expand(System.Int32, System.UInt64[]&)
Reserve(System.Int32)
Reserve(System.Int32, System.UInt64[]&)
AddWithExpandCheck[T0](T0, , System.Int32&, System.Int32)
AddWithExpandCheck[T0, T1](T0, , T1, , System.Int32&, System.Int32)
AddWithExpandCheck[T0, T1, T2](T0, , T1, , T2, , System.Int32&, System.Int32)
AddWithExpandCheck[T0, T1, T2, T3](T0, , T1, , T2, , T3, , System.Int32&, System.Int32)
AddWithExpandCheck[T0, T1, T2, T3, T4](T0, , T1, , T2, , T3, , T4, , System.Int32&, System.Int32)
AddWithExpandCheck[T0, T1, T2, T3, T4, T5](T0, , T1, , T2, , T3, , T4, , T5, , System.Int32&, System.Int32)
AddWithExpandCheck[T0, T1, T2, T3, T4, T5, T6](T0, , T1, , T2, , T3, , T4, , T5, , T6, , System.Int32&, System.Int32)
AddWithExpandCheck[T0, T1, T2, T3, T4, T5, T6, T7](T0, , T1, , T2, , T3, , T4, , T5, , T6, , T7, , System.Int32&, System.Int32)
AddUnchecked[T0](T0, )
AddUnchecked[T0, T1](T0, , T1, )
AddUnchecked[T0, T1, T2](T0, , T1, , T2, )
AddUnchecked[T0, T1, T2, T3](T0, , T1, , T2, , T3, )
AddUnchecked[T0, T1, T2, T3, T4](T0, , T1, , T2, , T3, , T4, )
AddUnchecked[T0, T1, T2, T3, T4, T5](T0, , T1, , T2, , T3, , T4, , T5, )
AddUnchecked[T0, T1, T2, T3, T4, T5, T6](T0, , T1, , T2, , T3, , T4, , T5, , T6, )
AddUnchecked[T0, T1, T2, T3, T4, T5, T6, T7](T0, , T1, , T2, , T3, , T4, , T5, , T6, , T7, )
RemoveUnchecked[T0](System.Int32, )
RemoveUnchecked[T0, T1](System.Int32, , )
RemoveUnchecked[T0, T1, T2](System.Int32, , , )
RemoveUnchecked[T0, T1, T2, T3](System.Int32, , , , )
RemoveUnchecked[T0, T1, T2, T3, T4](System.Int32, , , , , )
RemoveUnchecked[T0, T1, T2, T3, T4, T5](System.Int32, , , , , , )
RemoveUnchecked[T0, T1, T2, T3, T4, T5, T6](System.Int32, , , , , , , )
RemoveUnchecked[T0, T1, T2, T3, T4, T5, T6, T7](System.Int32, , , , , , , , )