< Summary

Class:GDX.Collections.SparseSet
Assembly:GDX
File(s):./Packages/com.dotbunny.gdx/GDX/Collections/SparseSet.cs
Covered lines:1001
Uncovered lines:59
Coverable lines:1060
Total lines:1838
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)

./Packages/com.dotbunny.gdx/GDX/Collections/SparseSet.cs

#LineLine coverage
 1// Copyright (c) 2020-2024 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,
 135            out ulong version)
 0136        {
 0137            int indexToClaim = FreeIndex;
 0138            int currentCapacity = SparseArray.Length;
 0139            bool needsExpansion = false;
 140
 0141            if (indexToClaim >= currentCapacity)
 0142            {
 143                // We're out of space, the last free index points to nothing. Allocate more indices.
 0144                needsExpansion = true;
 145
 0146                int newCapacity = currentCapacity + expandBy;
 147
 0148                int[] newSparseArray = new int[newCapacity];
 0149                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 0150                SparseArray = newSparseArray;
 151
 0152                int[] newDenseArray = new int[newCapacity];
 0153                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 0154                DenseArray = newDenseArray;
 155
 0156                ulong[] newVersionArray = new ulong[newCapacity];
 0157                Array.Copy(versionArray, 0, newVersionArray, 0, currentCapacity);
 0158                versionArray = newVersionArray;
 159
 0160                for (int i = currentCapacity; i < newCapacity; i++)
 0161                {
 0162                    SparseArray[i] = i + 1; // Build the free list chain.
 0163                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 0164                    newVersionArray[i] = 1;
 0165                }
 0166            }
 167
 0168            int nextFreeIndex = SparseArray[indexToClaim];
 0169            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 0170            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 0171            denseIndex = Count;
 172
 0173            version = versionArray[indexToClaim];
 174
 0175            ++Count;
 0176            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 177
 0178            sparseIndex = indexToClaim;
 0179            return needsExpansion;
 0180        }
 181
 182        /// <summary>
 183        ///     Adds a sparse/dense index pair to the set without checking if the set needs to expand.
 184        /// </summary>
 185        /// <param name="sparseIndex">The sparse index allocated.</param>
 186        /// <param name="denseIndex">The dense index allocated.</param>
 187        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 188        public void AddUnchecked(out int sparseIndex, out int denseIndex)
 20189        {
 20190            int indexToClaim = FreeIndex;
 20191            int nextFreeIndex = SparseArray[indexToClaim];
 19192            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 19193            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 194
 19195            sparseIndex = indexToClaim;
 19196            denseIndex = Count;
 19197            ++Count;
 19198            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 19199        }
 200
 201        /// <summary>
 202        ///     Adds a sparse/dense index pair to the set without checking if the set needs to expand.
 203        /// </summary>
 204        /// <param name="sparseIndex">The sparse index allocated.</param>
 205        /// <param name="denseIndex">The dense index allocated.</param>
 206        /// <param name="versionArray">The array containing the version number to check against.</param>
 207        /// <param name="version">Enables detection of use-after-free errors when using the sparse index as a reference.
 208        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 209        public void AddUnchecked(out int sparseIndex, out int denseIndex, ulong[] versionArray, out ulong version)
 24210        {
 24211            int indexToClaim = FreeIndex;
 24212            int nextFreeIndex = SparseArray[indexToClaim];
 23213            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 23214            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 215
 23216            version = versionArray[indexToClaim];
 23217            sparseIndex = indexToClaim;
 23218            denseIndex = Count;
 219
 23220            ++Count;
 23221            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 23222        }
 223
 224        /// <summary>
 225        ///     Gets the value of the sparse array at the given index without any data validation.
 226        /// </summary>
 227        /// <param name="sparseIndex">The index to check in the sparse array.</param>
 228        /// <returns>The dense index at the given sparse index.</returns>
 229        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 230        public int GetDenseIndexUnchecked(int sparseIndex)
 1231        {
 1232            return SparseArray[sparseIndex];
 1233        }
 234
 235        /// <summary>
 236        ///     Gets the value of the sparse array at the given index,
 237        ///     or -1 if the dense and sparse indices don't point to each other or if the dense index is outside the den
 238        /// </summary>
 239        /// <param name="sparseIndex">The index in the sparse array to check against.</param>
 240        /// <returns>The dense index pointed to by the current sparse index, or -1 if invalid.</returns>
 241        public int GetDenseIndexWithBoundsCheck(int sparseIndex)
 4242        {
 4243            if (sparseIndex >= 0 && sparseIndex < SparseArray.Length)
 2244            {
 2245                int denseIndex = SparseArray[sparseIndex];
 246
 2247                if (denseIndex < Count && denseIndex >= 0)
 1248                {
 1249                    int sparseIndexAtDenseIndex = DenseArray[denseIndex];
 250
 1251                    if (sparseIndex == sparseIndexAtDenseIndex)
 1252                    {
 1253                        return denseIndex;
 254                    }
 0255                }
 1256            }
 257
 3258            return -1;
 4259        }
 260
 261        /// <summary>
 262        ///     Gets the value of the sparse array at the given index,
 263        ///     or -1 if the version number does not match.
 264        /// </summary>
 265        /// <param name="sparseIndex">The index in the sparse array to check against.</param>
 266        /// <param name="version">The version number associated with the sparse index.</param>
 267        /// <param name="versionArray">The array containing the version number to check against.</param>
 268        /// <returns>The dense index pointed to by the current sparse index, or -1 if invalid.</returns>
 269        public int GetDenseIndexWithVersionCheck(int sparseIndex, ulong version, ulong[] versionArray)
 4270        {
 4271            int denseIndex = SparseArray[sparseIndex];
 4272            ulong versionAtSparseIndex = versionArray[sparseIndex];
 273
 4274            if (version == versionAtSparseIndex)
 2275            {
 2276                return denseIndex;
 277            }
 278
 2279            return -1;
 4280        }
 281
 282        /// <summary>
 283        ///     Gets the value of the sparse array at the given index,
 284        ///     or -1 if the given sparse index is invalid..
 285        /// </summary>
 286        /// <param name="sparseIndex">The index in the sparse array to check against.</param>
 287        /// <param name="version">The version number associated with the sparse index.</param>
 288        /// <param name="versionArray">The array containing the version number to check against.</param>
 289        /// <returns>The dense index pointed to by the current sparse index, or -1 if invalid.</returns>
 290        public int GetDenseIndexWithBoundsAndVersionCheck(int sparseIndex, ulong version, ulong[] versionArray)
 7291        {
 7292            if (sparseIndex >= 0 && sparseIndex < SparseArray.Length)
 5293            {
 5294                int denseIndex = SparseArray[sparseIndex];
 5295                ulong versionAtSparseIndex = versionArray[sparseIndex];
 296
 5297                if (versionAtSparseIndex == version && denseIndex < Count && denseIndex >= 0)
 2298                {
 2299                    int sparseIndexAtDenseIndex = DenseArray[denseIndex];
 300
 2301                    if (sparseIndex == sparseIndexAtDenseIndex)
 2302                    {
 2303                        return denseIndex;
 304                    }
 0305                }
 3306            }
 307
 5308            return -1;
 7309        }
 310
 311        /// <summary>
 312        ///     Frees the allocated entry corresponding to the sparse index.
 313        ///     WARNING: Will not protect against accidentally removing twice if the index in question was recycled betw
 314        ///     calls.
 315        ///     <param name="sparseIndexToRemove">The sparse index corresponding to the entry to remove.</param>
 316        ///     <param name="dataIndexToSwapTo">
 317        ///         Replace the data array value at this index with the data array value at
 318        ///         indexToSwapFrom.
 319        ///     </param>
 320        ///     <param name="dataIndexToSwapFrom">
 321        ///         Set the data array value at this index to default after swapping with the data array
 322        ///         value at dataIndexToSwapTo.
 323        ///     </param>
 324        /// </summary>
 325        /// <returns>True if the entry was valid and thus removed.</returns>
 326        public bool RemoveWithBoundsCheck(ref int sparseIndexToRemove, out int dataIndexToSwapFrom,
 327            out int dataIndexToSwapTo)
 4328        {
 4329            dataIndexToSwapFrom = -1;
 4330            dataIndexToSwapTo = -1;
 4331            bool didRemove = false;
 4332            if (sparseIndexToRemove >= 0 && sparseIndexToRemove < SparseArray.Length)
 2333            {
 2334                int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 335
 2336                if (denseIndexToRemove >= 0 && denseIndexToRemove < Count)
 1337                {
 1338                    int sparseIndexAtDenseIndex = DenseArray[denseIndexToRemove];
 1339                    int newLength = Count - 1;
 1340                    int sparseIndexBeingSwapped = DenseArray[newLength];
 341
 1342                    if (denseIndexToRemove < Count && sparseIndexAtDenseIndex == sparseIndexToRemove)
 1343                    {
 1344                        didRemove = true;
 345                        // Swap the entry being removed with the last entry.
 1346                        SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1347                        DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 348
 1349                        dataIndexToSwapFrom = newLength;
 1350                        dataIndexToSwapTo = denseIndexToRemove;
 351
 352                        // Clear the dense index, for debugging purposes
 1353                        DenseArray[newLength] = -1;
 354
 355                        // Add the sparse index to the free list.
 1356                        SparseArray[sparseIndexToRemove] = FreeIndex;
 1357                        FreeIndex = sparseIndexToRemove;
 358
 1359                        Count = newLength;
 1360                    }
 1361                }
 2362            }
 363
 4364            sparseIndexToRemove = -1;
 365
 4366            return didRemove;
 4367        }
 368
 369        /// <summary>
 370        ///     Removes the allocated entry corresponding to the sparse index.
 371        ///     Indicates which dense indices were swapped as a result of removing the entry.
 372        /// </summary>
 373        /// <param name="sparseIndexToRemove">The sparse index to remove.</param>
 374        /// <param name="version">
 375        ///     The version number of the int used to access the sparse index. Used to guard against accessing
 376        ///     indices that have been removed and reused.
 377        /// </param>
 378        /// <param name="versionArray">The array where version numbers to check against are stored.</param>
 379        /// <param name="dataIndexToSwapTo">
 380        ///     Replace the data array value at this index with the data array value at
 381        ///     indexToSwapFrom.
 382        /// </param>
 383        /// <param name="dataIndexToSwapFrom">
 384        ///     Set the data array value at this index to default after swapping with the data array
 385        ///     value at dataIndexToSwapTo.
 386        /// </param>
 387        /// <returns>Whether or not the remove attempt succeeded.</returns>
 388        public bool RemoveWithVersionCheck(int sparseIndexToRemove, ulong version, ulong[] versionArray,
 389            out int dataIndexToSwapFrom, out int dataIndexToSwapTo)
 2390        {
 2391            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 2392            ulong versionAtSparseIndex = versionArray[sparseIndexToRemove];
 393
 2394            dataIndexToSwapFrom = -1;
 2395            dataIndexToSwapTo = -1;
 396
 2397            bool succeeded = versionAtSparseIndex == version;
 398
 2399            if (succeeded)
 1400            {
 1401                int newLength = Count - 1;
 1402                int sparseIndexBeingSwapped = DenseArray[newLength];
 403
 404                // Swap the entry being removed with the last entry.
 1405                SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1406                DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 407
 408                // Clear the dense  index, for debugging purposes
 1409                DenseArray[newLength] = -1;
 410
 411                // Add the sparse index to the free list.
 1412                SparseArray[sparseIndexToRemove] = FreeIndex;
 1413                versionArray[sparseIndexToRemove] = versionArray[sparseIndexToRemove] + 1;
 1414                FreeIndex = sparseIndexToRemove;
 415
 1416                Count = newLength;
 417
 1418                dataIndexToSwapTo = denseIndexToRemove;
 1419                dataIndexToSwapFrom = newLength;
 1420            }
 421
 2422            return succeeded;
 2423        }
 424
 425        /// <summary>
 426        ///     Removes the allocated entry corresponding to the sparse index.
 427        /// </summary>
 428        /// <param name="sparseIndexToRemove">The sparse index corresponding to the entry to remove.</param>
 429        /// <param name="version">
 430        ///     The version number of the int used to access the sparse index. Used to guard against erroneously accessi
 431        ///     freed indices currently in use with an outdated reference.
 432        /// </param>
 433        /// <param name="dataIndexToSwapTo">
 434        ///     Replace the data array value at this index with the data array value at
 435        ///     indexToSwapFrom.
 436        /// </param>
 437        /// <param name="dataIndexToSwapFrom">
 438        ///     Set the data array value at this index to default after swapping with the data array
 439        ///     value at dataIndexToSwapTo.
 440        /// </param>
 441        /// <param name="versionArray">The array where version numbers to check against are stored.</param>
 442        /// <returns>True if the entry was valid and thus removed.</returns>
 443        public bool RemoveWithBoundsAndVersionChecks(ref int sparseIndexToRemove, ulong version,
 444            ulong[] versionArray, out int dataIndexToSwapFrom, out int dataIndexToSwapTo)
 6445        {
 6446            dataIndexToSwapFrom = -1;
 6447            dataIndexToSwapTo = -1;
 6448            bool didRemove = false;
 6449            if (sparseIndexToRemove >= 0 && sparseIndexToRemove < SparseArray.Length)
 3450            {
 3451                ulong sparseIndexVersion = versionArray[sparseIndexToRemove];
 3452                int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 453
 3454                if (sparseIndexVersion == version && denseIndexToRemove >= 0 && denseIndexToRemove < Count)
 2455                {
 2456                    int sparseIndexAtDenseIndex = DenseArray[denseIndexToRemove];
 2457                    int newLength = Count - 1;
 2458                    int sparseIndexBeingSwapped = DenseArray[newLength];
 459
 2460                    if (denseIndexToRemove < Count && sparseIndexAtDenseIndex == sparseIndexToRemove)
 2461                    {
 2462                        didRemove = true;
 2463                        versionArray[sparseIndexToRemove] = sparseIndexVersion + 1;
 464                        // Swap the entry being removed with the last entry.
 2465                        SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 2466                        DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 467
 2468                        dataIndexToSwapFrom = newLength;
 2469                        dataIndexToSwapTo = denseIndexToRemove;
 470
 471                        // Clear the dense index, for debugging purposes
 2472                        DenseArray[newLength] = -1;
 473
 474                        // Add the sparse index to the free list.
 2475                        SparseArray[sparseIndexToRemove] = FreeIndex;
 2476                        FreeIndex = sparseIndexToRemove;
 477
 2478                        Count = newLength;
 2479                    }
 2480                }
 3481            }
 482
 6483            sparseIndexToRemove = -1;
 484
 6485            return didRemove;
 6486        }
 487
 488        /// <summary>
 489        ///     Removes the associated sparse/dense index pair from active use.
 490        /// </summary>
 491        /// <param name="sparseIndexToRemove">The sparse index to remove.</param>
 492        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 493        public void RemoveUnchecked(int sparseIndexToRemove)
 1494        {
 1495            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 1496            int newLength = Count - 1;
 1497            int sparseIndexBeingSwapped = DenseArray[newLength];
 498
 499            // Swap the entry being removed with the last entry.
 1500            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1501            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 502
 503            // Clear the dense  index, for debugging purposes
 1504            DenseArray[newLength] = -1;
 505
 506            // Add the sparse index to the free list.
 1507            SparseArray[sparseIndexToRemove] = FreeIndex;
 1508            FreeIndex = sparseIndexToRemove;
 509
 1510            Count = newLength;
 1511        }
 512
 513        /// <summary>
 514        ///     Removes the associated sparse/dense index pair from active use.
 515        ///     Out parameters used to manage parallel data arrays.
 516        /// </summary>
 517        /// <param name="sparseIndexToRemove">The sparse index to remove.</param>
 518        /// <param name="indexToSwapTo">Replace the data array value at this index with the data array value at indexToS
 519        /// <param name="indexToSwapFrom">
 520        ///     Set the data array value at this index to default after swapping with the data array
 521        ///     value at indexToSwapTo.
 522        /// </param>
 523        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 524        public void RemoveUnchecked(int sparseIndexToRemove, out int indexToSwapFrom, out int indexToSwapTo)
 1525        {
 1526            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 1527            int newLength = Count - 1;
 1528            int sparseIndexBeingSwapped = DenseArray[newLength];
 529
 530            // Swap the entry being removed with the last entry.
 1531            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1532            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 533
 534            // Clear the dense  index, for debugging purposes
 1535            DenseArray[newLength] = -1;
 536
 537            // Add the sparse index to the free list.
 1538            SparseArray[sparseIndexToRemove] = FreeIndex;
 1539            FreeIndex = sparseIndexToRemove;
 540
 1541            Count = newLength;
 542
 1543            indexToSwapTo = denseIndexToRemove;
 1544            indexToSwapFrom = newLength;
 1545        }
 546
 547        /// <summary>
 548        ///     Removes the associated sparse/dense index pair from active use and increments the version.
 549        ///     Out parameters used to manage parallel data arrays.
 550        /// </summary>
 551        /// <param name="sparseIndexToRemove">The sparse index to remove.</param>
 552        /// <param name="versionArray">The array where version numbers to check against are stored.</param>
 553        /// <param name="indexToSwapTo">Replace the data array value at this index with the data array value at indexToS
 554        /// <param name="indexToSwapFrom">
 555        ///     Set the data array value at this index to default after swapping with the data array
 556        ///     value at indexToSwapTo.
 557        /// </param>
 558        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 559        public void RemoveUnchecked(int sparseIndexToRemove, ulong[] versionArray, out int indexToSwapFrom,
 560            out int indexToSwapTo)
 2561        {
 2562            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 2563            int newLength = Count - 1;
 2564            int sparseIndexBeingSwapped = DenseArray[newLength];
 565
 566            // Swap the entry being removed with the last entry.
 2567            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 2568            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 569
 570            // Clear the dense  index, for debugging purposes
 2571            DenseArray[newLength] = -1;
 572
 573            // Add the sparse index to the free list.
 2574            SparseArray[sparseIndexToRemove] = FreeIndex;
 2575            versionArray[sparseIndexToRemove] = versionArray[sparseIndexToRemove] + 1;
 2576            FreeIndex = sparseIndexToRemove;
 577
 2578            Count = newLength;
 579
 2580            indexToSwapTo = denseIndexToRemove;
 2581            indexToSwapFrom = newLength;
 2582        }
 583
 584        /// <summary>
 585        ///     Removes the associated sparse/dense index pair from active use.
 586        /// </summary>
 587        /// <param name="denseIndexToRemove">The dense index associated with the sparse index to remove.</param>
 588        public void RemoveUncheckedFromDenseIndex(int denseIndexToRemove)
 1589        {
 1590            int sparseIndexToRemove = DenseArray[denseIndexToRemove];
 1591            int newLength = Count - 1;
 1592            int sparseIndexBeingSwapped = DenseArray[newLength];
 593
 594            // Swap the entry being removed with the last entry.
 1595            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1596            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 597
 598            // Clear the dense  index, for debugging purposes
 1599            DenseArray[newLength] = -1;
 600
 601            // Add the sparse index to the free list.
 1602            SparseArray[sparseIndexToRemove] = FreeIndex;
 1603            FreeIndex = sparseIndexToRemove;
 604
 1605            Count = newLength;
 1606        }
 607
 608        /// <summary>
 609        ///     Removes the associated sparse/dense index pair from active use.
 610        /// </summary>
 611        /// <param name="denseIndexToRemove">The dense index associated with the sparse index to remove.</param>
 612        /// <param name="versionArray">The array where version numbers to check against are stored.</param>
 613        public void RemoveUncheckedFromDenseIndex(int denseIndexToRemove, ulong[] versionArray)
 1614        {
 1615            int sparseIndexToRemove = DenseArray[denseIndexToRemove];
 1616            int newLength = Count - 1;
 1617            int sparseIndexBeingSwapped = DenseArray[newLength];
 618
 619            // Swap the entry being removed with the last entry.
 1620            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1621            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 622
 623            // Clear the dense  index, for debugging purposes
 1624            DenseArray[newLength] = -1;
 625
 626            // Add the sparse index to the free list.
 1627            SparseArray[sparseIndexToRemove] = FreeIndex;
 1628            versionArray[sparseIndexToRemove] += 1;
 1629            FreeIndex = sparseIndexToRemove;
 630
 1631            Count = newLength;
 1632        }
 633
 634        /// <summary>
 635        ///     Removes the associated sparse/dense index pair from active use.
 636        ///     Out parameter used to manage parallel data arrays.
 637        /// </summary>
 638        /// <param name="denseIndexToRemove">The sparse index to remove.</param>
 639        /// <param name="indexToSwapFrom">
 640        ///     Set the data array value at this index to default after swapping with the data array
 641        ///     value at denseIndexToRemove.
 642        /// </param>
 643        public void RemoveUncheckedFromDenseIndex(int denseIndexToRemove, out int indexToSwapFrom)
 1644        {
 1645            int sparseIndexToRemove = DenseArray[denseIndexToRemove];
 1646            int newLength = Count - 1;
 1647            int sparseIndexBeingSwapped = DenseArray[newLength];
 648
 649            // Swap the entry being removed with the last entry.
 1650            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1651            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 652
 653            // Clear the dense  index, for debugging purposes
 1654            DenseArray[newLength] = -1;
 655
 656            // Add the sparse index to the free list.
 1657            SparseArray[sparseIndexToRemove] = FreeIndex;
 1658            FreeIndex = sparseIndexToRemove;
 659
 1660            Count = newLength;
 661
 1662            indexToSwapFrom = newLength;
 1663        }
 664
 665        /// <summary>
 666        ///     Removes the associated sparse/dense index pair from active use.
 667        ///     Out parameter used to manage parallel data arrays.
 668        /// </summary>
 669        /// <param name="denseIndexToRemove">The sparse index to remove.</param>
 670        /// <param name="versionArray">The array where version numbers to check against are stored.</param>
 671        /// <param name="indexToSwapFrom">
 672        ///     Set the data array value at this index to default after swapping with the data array
 673        ///     value at denseIndexToRemove.
 674        /// </param>
 675        public void RemoveUncheckedFromDenseIndex(int denseIndexToRemove, ulong[] versionArray, out int indexToSwapFrom)
 1676        {
 1677            int sparseIndexToRemove = DenseArray[denseIndexToRemove];
 1678            int newLength = Count - 1;
 1679            int sparseIndexBeingSwapped = DenseArray[newLength];
 680
 681            // Swap the entry being removed with the last entry.
 1682            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 1683            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 684
 685            // Clear the dense  index, for debugging purposes
 1686            DenseArray[newLength] = -1;
 687
 688            // Add the sparse index to the free list.
 1689            SparseArray[sparseIndexToRemove] = FreeIndex;
 1690            versionArray[sparseIndexToRemove] = versionArray[sparseIndexToRemove] + 1;
 1691            FreeIndex = sparseIndexToRemove;
 692
 1693            Count = newLength;
 694
 1695            indexToSwapFrom = newLength;
 1696        }
 697
 698        /// <summary>
 699        ///     Clear the dense and sparse arrays.
 700        /// </summary>
 701        public void Clear()
 1702        {
 1703            int capacity = SparseArray.Length;
 8704            for (int i = 0; i < capacity; i++)
 3705            {
 3706                DenseArray[i] = -1;
 3707                SparseArray[i] = i + 1;
 3708            }
 709
 1710            FreeIndex = 0;
 1711            Count = 0;
 1712        }
 713
 714        /// <summary>
 715        ///     Clear the dense and sparse arrays.
 716        /// </summary>
 717        /// ///
 718        /// <param name="versionArray">Array containing version numbers to check against.</param>
 719        public void Clear(ulong[] versionArray)
 1720        {
 1721            int capacity = SparseArray.Length;
 8722            for (int i = 0; i < capacity; i++)
 3723            {
 3724                DenseArray[i] = -1;
 3725                SparseArray[i] = i + 1;
 3726                versionArray[i] = versionArray[i] + 1;
 3727            }
 728
 1729            FreeIndex = 0;
 1730            Count = 0;
 1731        }
 732
 733        /// <summary>
 734        ///     Clear the dense and sparse arrays and reset the version array.
 735        ///     Note: Only clear the version array if you are sure there are no outstanding dependencies on version numb
 736        /// </summary>
 737        /// ///
 738        /// <param name="versionArray">Array containing version numbers to check against.</param>
 739        public void ClearWithVersionArrayReset(ulong[] versionArray)
 1740        {
 1741            int capacity = SparseArray.Length;
 8742            for (int i = 0; i < capacity; i++)
 3743            {
 3744                DenseArray[i] = -1;
 3745                SparseArray[i] = i + 1;
 3746                versionArray[i] = 1;
 3747            }
 748
 1749            FreeIndex = 0;
 1750            Count = 0;
 1751        }
 752
 753        /// <summary>
 754        ///     Reallocate the dense and sparse arrays with additional capacity.
 755        /// </summary>
 756        /// <param name="extraCapacity">How many indices to expand the dense and sparse arrays by.</param>
 757        public void Expand(int extraCapacity)
 1758        {
 1759            int currentCapacity = SparseArray.Length;
 1760            int newCapacity = currentCapacity + extraCapacity;
 761
 1762            int[] newSparseArray = new int[newCapacity];
 1763            Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 1764            SparseArray = newSparseArray;
 765
 1766            int[] newDenseArray = new int[newCapacity];
 1767            Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 1768            DenseArray = newDenseArray;
 769
 8770            for (int i = currentCapacity; i < newCapacity; i++)
 3771            {
 3772                DenseArray[i] = -1; // Set new dense indices as unclaimed.
 3773                SparseArray[i] = i + 1; // Build the free list chain.
 3774            }
 1775        }
 776
 777        /// <summary>
 778        ///     Reallocate the dense and sparse arrays with additional capacity.
 779        /// </summary>
 780        /// <param name="extraCapacity">How many indices to expand the dense and sparse arrays by.</param>
 781        /// <param name="versionArray">Array containing version numbers to check against.</param>
 782        public void Expand(int extraCapacity, ref ulong[] versionArray)
 2783        {
 2784            int currentCapacity = SparseArray.Length;
 2785            int newCapacity = currentCapacity + extraCapacity;
 786
 2787            int[] newSparseArray = new int[newCapacity];
 2788            Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 2789            SparseArray = newSparseArray;
 790
 2791            int[] newDenseArray = new int[newCapacity];
 2792            Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 2793            DenseArray = newDenseArray;
 794
 2795            ulong[] newVersionArray = new ulong[newCapacity];
 2796            Array.Copy(versionArray, 0, newVersionArray, 0, currentCapacity);
 2797            versionArray = newVersionArray;
 798
 16799            for (int i = currentCapacity; i < newCapacity; i++)
 6800            {
 6801                DenseArray[i] = -1; // Set new dense indices as unclaimed.
 6802                SparseArray[i] = i + 1; // Build the free list chain.
 6803                versionArray[i] = 1;
 6804            }
 2805        }
 806
 807        public void Reserve(int numberToReserve)
 1808        {
 1809            int currentCapacity = SparseArray.Length;
 1810            int currentCount = Count;
 1811            int newCount = currentCount + numberToReserve;
 812
 1813            if (newCount > currentCapacity)
 1814            {
 1815                int[] newSparseArray = new int[newCount];
 1816                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 1817                SparseArray = newSparseArray;
 818
 1819                int[] newDenseArray = new int[newCount];
 1820                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 1821                DenseArray = newDenseArray;
 822
 4823                for (int i = currentCapacity; i < newCount; i++)
 1824                {
 1825                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 1826                    SparseArray[i] = i + 1; // Build the free list chain.
 1827                }
 1828            }
 1829        }
 830
 831        public void Reserve(int numberToReserve, ref ulong[] versionArray)
 0832        {
 0833            int currentCapacity = SparseArray.Length;
 0834            int currentCount = Count;
 0835            int newCount = currentCount + numberToReserve;
 836
 0837            if (newCount > currentCapacity)
 0838            {
 0839                int[] newSparseArray = new int[newCount];
 0840                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 0841                SparseArray = newSparseArray;
 842
 0843                int[] newDenseArray = new int[newCount];
 0844                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 0845                DenseArray = newDenseArray;
 846
 0847                ulong[] newVersionArray = new ulong[newCount];
 0848                Array.Copy(versionArray, 0, newVersionArray, 0, currentCapacity);
 0849                versionArray = newVersionArray;
 850
 0851                for (int i = currentCapacity; i < newCount; i++)
 0852                {
 0853                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 0854                    SparseArray[i] = i + 1; // Build the free list chain.
 0855                    versionArray[i] = 1;
 0856                }
 0857            }
 0858        }
 859
 860        #region Parallel array method duplicates
 861
 862        /// <summary>
 863        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 864        /// </summary>
 865        /// <returns>True if the index pool expanded.</returns>
 866        public bool AddWithExpandCheck<T0>(T0 obj0, ref T0[] array0, out int lookupIndex, int howMuchToExpand = 16)
 2867        {
 2868            int indexToClaim = FreeIndex;
 2869            int currentCapacity = SparseArray.Length;
 2870            bool needsExpansion = false;
 871
 2872            if (indexToClaim >= currentCapacity)
 1873            {
 1874                needsExpansion = true;
 875                // We're out of space, the last free index points to nothing. Allocate more indices.
 1876                int newCapacity = currentCapacity + howMuchToExpand;
 877
 1878                int[] newSparseArray = new int[newCapacity];
 1879                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 1880                SparseArray = newSparseArray;
 881
 1882                int[] newDenseArray = new int[newCapacity];
 1883                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 1884                DenseArray = newDenseArray;
 885
 1886                T0[] newArray0 = new T0[newCapacity];
 1887                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 1888                array0 = newArray0;
 889
 12890                for (int i = currentCapacity; i < newCapacity; i++)
 5891                {
 5892                    SparseArray[i] = i + 1; // Build the free list chain.
 5893                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 5894                }
 1895            }
 896
 2897            int nextFreeIndex = SparseArray[indexToClaim];
 898
 2899            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 2900            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 901
 2902            array0[Count] = obj0;
 903
 2904            ++Count;
 2905            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 906
 2907            lookupIndex = indexToClaim;
 2908            return needsExpansion;
 2909        }
 910
 911        /// <summary>
 912        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 913        /// </summary>
 914        /// <returns>True if the index pool expanded.</returns>
 915        public bool AddWithExpandCheck<T0, T1>(T0 obj0, ref T0[] array0, T1 obj1, ref T1[] array1, out int lookupIndex,
 916            int howMuchToExpand = 16)
 2917        {
 2918            int indexToClaim = FreeIndex;
 2919            int currentCapacity = SparseArray.Length;
 2920            bool needsExpansion = false;
 921
 2922            if (indexToClaim >= currentCapacity)
 1923            {
 1924                needsExpansion = true;
 925                // We're out of space, the last free index points to nothing. Allocate more indices.
 1926                int newCapacity = currentCapacity + howMuchToExpand;
 927
 1928                int[] newSparseArray = new int[newCapacity];
 1929                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 1930                SparseArray = newSparseArray;
 931
 1932                int[] newDenseArray = new int[newCapacity];
 1933                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 1934                DenseArray = newDenseArray;
 935
 1936                T0[] newArray0 = new T0[newCapacity];
 1937                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 1938                array0 = newArray0;
 939
 1940                T1[] newArray1 = new T1[newCapacity];
 1941                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 1942                array1 = newArray1;
 943
 12944                for (int i = currentCapacity; i < newCapacity; i++)
 5945                {
 5946                    SparseArray[i] = i + 1; // Build the free list chain.
 5947                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 5948                }
 1949            }
 950
 2951            int nextFreeIndex = SparseArray[indexToClaim];
 952
 2953            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 2954            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 955
 2956            array0[Count] = obj0;
 2957            array1[Count] = obj1;
 958
 2959            ++Count;
 2960            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 961
 2962            lookupIndex = indexToClaim;
 2963            return needsExpansion;
 2964        }
 965
 966        /// <summary>
 967        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 968        /// </summary>
 969        /// <returns>True if the index pool expanded.</returns>
 970        public bool AddWithExpandCheck<T0, T1, T2>(T0 obj0, ref T0[] array0, T1 obj1, ref T1[] array1, T2 obj2,
 971            ref T2[] array2,
 972            out int lookupIndex, int howMuchToExpand = 16)
 2973        {
 2974            int indexToClaim = FreeIndex;
 2975            int currentCapacity = SparseArray.Length;
 2976            bool needsExpansion = false;
 977
 2978            if (indexToClaim >= currentCapacity)
 1979            {
 1980                needsExpansion = true;
 981                // We're out of space, the last free index points to nothing. Allocate more indices.
 1982                int newCapacity = currentCapacity + howMuchToExpand;
 983
 1984                int[] newSparseArray = new int[newCapacity];
 1985                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 1986                SparseArray = newSparseArray;
 987
 1988                int[] newDenseArray = new int[newCapacity];
 1989                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 1990                DenseArray = newDenseArray;
 991
 1992                T0[] newArray0 = new T0[newCapacity];
 1993                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 1994                array0 = newArray0;
 995
 1996                T1[] newArray1 = new T1[newCapacity];
 1997                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 1998                array1 = newArray1;
 999
 11000                T2[] newArray2 = new T2[newCapacity];
 11001                Array.Copy(array2, 0, newArray2, 0, currentCapacity);
 11002                array2 = newArray2;
 1003
 121004                for (int i = currentCapacity; i < newCapacity; i++)
 51005                {
 51006                    SparseArray[i] = i + 1; // Build the free list chain.
 51007                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 51008                }
 11009            }
 1010
 21011            int nextFreeIndex = SparseArray[indexToClaim];
 1012
 21013            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 21014            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1015
 21016            array0[Count] = obj0;
 21017            array1[Count] = obj1;
 21018            array2[Count] = obj2;
 1019
 21020            ++Count;
 21021            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1022
 21023            lookupIndex = indexToClaim;
 21024            return needsExpansion;
 21025        }
 1026
 1027        /// <summary>
 1028        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 1029        /// </summary>
 1030        /// <returns>True if the index pool expanded.</returns>
 1031        public bool AddWithExpandCheck<T0, T1, T2, T3>(T0 obj0, ref T0[] array0, T1 obj1, ref T1[] array1, T2 obj2,
 1032            ref T2[] array2, T3 obj3, ref T3[] array3, out int lookupIndex, int howMuchToExpand = 16)
 21033        {
 21034            int indexToClaim = FreeIndex;
 21035            int currentCapacity = SparseArray.Length;
 21036            bool needsExpansion = false;
 1037
 21038            if (indexToClaim >= currentCapacity)
 11039            {
 11040                needsExpansion = true;
 1041                // We're out of space, the last free index points to nothing. Allocate more indices.
 11042                int newCapacity = currentCapacity + howMuchToExpand;
 1043
 11044                int[] newSparseArray = new int[newCapacity];
 11045                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 11046                SparseArray = newSparseArray;
 1047
 11048                int[] newDenseArray = new int[newCapacity];
 11049                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 11050                DenseArray = newDenseArray;
 1051
 11052                T0[] newArray0 = new T0[newCapacity];
 11053                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 11054                array0 = newArray0;
 1055
 11056                T1[] newArray1 = new T1[newCapacity];
 11057                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 11058                array1 = newArray1;
 1059
 11060                T2[] newArray2 = new T2[newCapacity];
 11061                Array.Copy(array2, 0, newArray2, 0, currentCapacity);
 11062                array2 = newArray2;
 1063
 11064                T3[] newArray3 = new T3[newCapacity];
 11065                Array.Copy(array3, 0, newArray3, 0, currentCapacity);
 11066                array3 = newArray3;
 1067
 121068                for (int i = currentCapacity; i < newCapacity; i++)
 51069                {
 51070                    SparseArray[i] = i + 1; // Build the free list chain.
 51071                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 51072                }
 11073            }
 1074
 21075            int nextFreeIndex = SparseArray[indexToClaim];
 1076
 21077            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 21078            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1079
 21080            array0[Count] = obj0;
 21081            array1[Count] = obj1;
 21082            array2[Count] = obj2;
 21083            array3[Count] = obj3;
 1084
 21085            ++Count;
 21086            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1087
 21088            lookupIndex = indexToClaim;
 21089            return needsExpansion;
 21090        }
 1091
 1092        /// <summary>
 1093        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 1094        /// </summary>
 1095        /// <returns>True if the index pool expanded.</returns>
 1096        public bool AddWithExpandCheck<T0, T1, T2, T3, T4>(T0 obj0, ref T0[] array0, T1 obj1, ref T1[] array1, T2 obj2,
 1097            ref T2[] array2, T3 obj3, ref T3[] array3, T4 obj4, ref T4[] array4, out int lookupIndex,
 1098            int howMuchToExpand = 16)
 21099        {
 21100            int indexToClaim = FreeIndex;
 21101            int currentCapacity = SparseArray.Length;
 21102            bool needsExpansion = false;
 1103
 21104            if (indexToClaim >= currentCapacity)
 11105            {
 11106                needsExpansion = true;
 1107                // We're out of space, the last free index points to nothing. Allocate more indices.
 11108                int newCapacity = currentCapacity + howMuchToExpand;
 1109
 11110                int[] newSparseArray = new int[newCapacity];
 11111                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 11112                SparseArray = newSparseArray;
 1113
 11114                int[] newDenseArray = new int[newCapacity];
 11115                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 11116                DenseArray = newDenseArray;
 1117
 11118                T0[] newArray0 = new T0[newCapacity];
 11119                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 11120                array0 = newArray0;
 1121
 11122                T1[] newArray1 = new T1[newCapacity];
 11123                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 11124                array1 = newArray1;
 1125
 11126                T2[] newArray2 = new T2[newCapacity];
 11127                Array.Copy(array2, 0, newArray2, 0, currentCapacity);
 11128                array2 = newArray2;
 1129
 11130                T3[] newArray3 = new T3[newCapacity];
 11131                Array.Copy(array3, 0, newArray3, 0, currentCapacity);
 11132                array3 = newArray3;
 1133
 11134                T4[] newArray4 = new T4[newCapacity];
 11135                Array.Copy(array4, 0, newArray4, 0, currentCapacity);
 11136                array4 = newArray4;
 1137
 121138                for (int i = currentCapacity; i < newCapacity; i++)
 51139                {
 51140                    SparseArray[i] = i + 1; // Build the free list chain.
 51141                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 51142                }
 11143            }
 1144
 21145            int nextFreeIndex = SparseArray[indexToClaim];
 1146
 21147            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 21148            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1149
 21150            array0[Count] = obj0;
 21151            array1[Count] = obj1;
 21152            array2[Count] = obj2;
 21153            array3[Count] = obj3;
 21154            array4[Count] = obj4;
 1155
 21156            ++Count;
 21157            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1158
 21159            lookupIndex = indexToClaim;
 21160            return needsExpansion;
 21161        }
 1162
 1163        /// <summary>
 1164        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 1165        /// </summary>
 1166        /// <returns>True if the index pool expanded.</returns>
 1167        public bool AddWithExpandCheck<T0, T1, T2, T3, T4, T5>(T0 obj0, ref T0[] array0, T1 obj1, ref T1[] array1,
 1168            T2 obj2,
 1169            ref T2[] array2, T3 obj3, ref T3[] array3, T4 obj4, ref T4[] array4, T5 obj5, ref T5[] array5,
 1170            out int lookupIndex, int howMuchToExpand = 16)
 21171        {
 21172            int indexToClaim = FreeIndex;
 21173            int currentCapacity = SparseArray.Length;
 21174            bool needsExpansion = false;
 1175
 21176            if (indexToClaim >= currentCapacity)
 11177            {
 11178                needsExpansion = true;
 1179                // We're out of space, the last free index points to nothing. Allocate more indices.
 11180                int newCapacity = currentCapacity + howMuchToExpand;
 1181
 11182                int[] newSparseArray = new int[newCapacity];
 11183                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 11184                SparseArray = newSparseArray;
 1185
 11186                int[] newDenseArray = new int[newCapacity];
 11187                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 11188                DenseArray = newDenseArray;
 1189
 11190                T0[] newArray0 = new T0[newCapacity];
 11191                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 11192                array0 = newArray0;
 1193
 11194                T1[] newArray1 = new T1[newCapacity];
 11195                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 11196                array1 = newArray1;
 1197
 11198                T2[] newArray2 = new T2[newCapacity];
 11199                Array.Copy(array2, 0, newArray2, 0, currentCapacity);
 11200                array2 = newArray2;
 1201
 11202                T3[] newArray3 = new T3[newCapacity];
 11203                Array.Copy(array3, 0, newArray3, 0, currentCapacity);
 11204                array3 = newArray3;
 1205
 11206                T4[] newArray4 = new T4[newCapacity];
 11207                Array.Copy(array4, 0, newArray4, 0, currentCapacity);
 11208                array4 = newArray4;
 1209
 11210                T5[] newArray5 = new T5[newCapacity];
 11211                Array.Copy(array5, 0, newArray5, 0, currentCapacity);
 11212                array5 = newArray5;
 1213
 121214                for (int i = currentCapacity; i < newCapacity; i++)
 51215                {
 51216                    SparseArray[i] = i + 1; // Build the free list chain.
 51217                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 51218                }
 11219            }
 1220
 21221            int nextFreeIndex = SparseArray[indexToClaim];
 1222
 21223            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 21224            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1225
 21226            array0[Count] = obj0;
 21227            array1[Count] = obj1;
 21228            array2[Count] = obj2;
 21229            array3[Count] = obj3;
 21230            array4[Count] = obj4;
 21231            array5[Count] = obj5;
 1232
 21233            ++Count;
 21234            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1235
 21236            lookupIndex = indexToClaim;
 21237            return needsExpansion;
 21238        }
 1239
 1240        /// <summary>
 1241        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 1242        /// </summary>
 1243        /// <returns>True if the index pool expanded.</returns>
 1244        public bool AddWithExpandCheck<T0, T1, T2, T3, T4, T5, T6>(T0 obj0, ref T0[] array0, T1 obj1, ref T1[] array1,
 1245            T2 obj2,
 1246            ref T2[] array2, T3 obj3, ref T3[] array3, T4 obj4, ref T4[] array4, T5 obj5, ref T5[] array5, T6 obj6,
 1247            ref T6[] array6, out int lookupIndex, int howMuchToExpand = 16)
 21248        {
 21249            int indexToClaim = FreeIndex;
 21250            int currentCapacity = SparseArray.Length;
 21251            bool needsExpansion = false;
 1252
 21253            if (indexToClaim >= currentCapacity)
 11254            {
 11255                needsExpansion = true;
 1256                // We're out of space, the last free index points to nothing. Allocate more indices.
 11257                int newCapacity = currentCapacity + howMuchToExpand;
 1258
 11259                int[] newSparseArray = new int[newCapacity];
 11260                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 11261                SparseArray = newSparseArray;
 1262
 11263                int[] newDenseArray = new int[newCapacity];
 11264                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 11265                DenseArray = newDenseArray;
 1266
 11267                T0[] newArray0 = new T0[newCapacity];
 11268                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 11269                array0 = newArray0;
 1270
 11271                T1[] newArray1 = new T1[newCapacity];
 11272                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 11273                array1 = newArray1;
 1274
 11275                T2[] newArray2 = new T2[newCapacity];
 11276                Array.Copy(array2, 0, newArray2, 0, currentCapacity);
 11277                array2 = newArray2;
 1278
 11279                T3[] newArray3 = new T3[newCapacity];
 11280                Array.Copy(array3, 0, newArray3, 0, currentCapacity);
 11281                array3 = newArray3;
 1282
 11283                T4[] newArray4 = new T4[newCapacity];
 11284                Array.Copy(array4, 0, newArray4, 0, currentCapacity);
 11285                array4 = newArray4;
 1286
 11287                T5[] newArray5 = new T5[newCapacity];
 11288                Array.Copy(array5, 0, newArray5, 0, currentCapacity);
 11289                array5 = newArray5;
 1290
 11291                T6[] newArray6 = new T6[newCapacity];
 11292                Array.Copy(array6, 0, newArray6, 0, currentCapacity);
 11293                array6 = newArray6;
 1294
 121295                for (int i = currentCapacity; i < newCapacity; i++)
 51296                {
 51297                    SparseArray[i] = i + 1; // Build the free list chain.
 51298                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 51299                }
 11300            }
 1301
 21302            int nextFreeIndex = SparseArray[indexToClaim];
 1303
 21304            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 21305            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1306
 21307            array0[Count] = obj0;
 21308            array1[Count] = obj1;
 21309            array2[Count] = obj2;
 21310            array3[Count] = obj3;
 21311            array4[Count] = obj4;
 21312            array5[Count] = obj5;
 21313            array6[Count] = obj6;
 1314
 21315            ++Count;
 21316            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1317
 21318            lookupIndex = indexToClaim;
 21319            return needsExpansion;
 21320        }
 1321
 1322        /// <summary>
 1323        ///     Adds a sparse/dense index pair to the set and expands the arrays if necessary.
 1324        /// </summary>
 1325        /// <returns>True if the index pool expanded.</returns>
 1326        public bool AddWithExpandCheck<T0, T1, T2, T3, T4, T5, T6, T7>(T0 obj0, ref T0[] array0, T1 obj1,
 1327            ref T1[] array1, T2 obj2,
 1328            ref T2[] array2, T3 obj3, ref T3[] array3, T4 obj4, ref T4[] array4, T5 obj5, ref T5[] array5, T6 obj6,
 1329            ref T6[] array6, T7 obj7, ref T7[] array7, out int lookupIndex, int howMuchToExpand = 16)
 21330        {
 21331            int indexToClaim = FreeIndex;
 21332            int currentCapacity = SparseArray.Length;
 21333            bool needsExpansion = false;
 1334
 21335            if (indexToClaim >= currentCapacity)
 11336            {
 11337                needsExpansion = true;
 1338                // We're out of space, the last free index points to nothing. Allocate more indices.
 11339                int newCapacity = currentCapacity + howMuchToExpand;
 1340
 11341                int[] newSparseArray = new int[newCapacity];
 11342                Array.Copy(SparseArray, 0, newSparseArray, 0, currentCapacity);
 11343                SparseArray = newSparseArray;
 1344
 11345                int[] newDenseArray = new int[newCapacity];
 11346                Array.Copy(DenseArray, 0, newDenseArray, 0, currentCapacity);
 11347                DenseArray = newDenseArray;
 1348
 11349                T0[] newArray0 = new T0[newCapacity];
 11350                Array.Copy(array0, 0, newArray0, 0, currentCapacity);
 11351                array0 = newArray0;
 1352
 11353                T1[] newArray1 = new T1[newCapacity];
 11354                Array.Copy(array1, 0, newArray1, 0, currentCapacity);
 11355                array1 = newArray1;
 1356
 11357                T2[] newArray2 = new T2[newCapacity];
 11358                Array.Copy(array2, 0, newArray2, 0, currentCapacity);
 11359                array2 = newArray2;
 1360
 11361                T3[] newArray3 = new T3[newCapacity];
 11362                Array.Copy(array3, 0, newArray3, 0, currentCapacity);
 11363                array3 = newArray3;
 1364
 11365                T4[] newArray4 = new T4[newCapacity];
 11366                Array.Copy(array4, 0, newArray4, 0, currentCapacity);
 11367                array4 = newArray4;
 1368
 11369                T5[] newArray5 = new T5[newCapacity];
 11370                Array.Copy(array5, 0, newArray5, 0, currentCapacity);
 11371                array5 = newArray5;
 1372
 11373                T6[] newArray6 = new T6[newCapacity];
 11374                Array.Copy(array6, 0, newArray6, 0, currentCapacity);
 11375                array6 = newArray6;
 1376
 11377                T7[] newArray7 = new T7[newCapacity];
 11378                Array.Copy(array7, 0, newArray7, 0, currentCapacity);
 11379                array7 = newArray7;
 1380
 121381                for (int i = currentCapacity; i < newCapacity; i++)
 51382                {
 51383                    SparseArray[i] = i + 1; // Build the free list chain.
 51384                    DenseArray[i] = -1; // Set new dense indices as unclaimed.
 51385                }
 11386            }
 1387
 21388            int nextFreeIndex = SparseArray[indexToClaim];
 1389
 21390            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 21391            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1392
 21393            array0[Count] = obj0;
 21394            array1[Count] = obj1;
 21395            array2[Count] = obj2;
 21396            array3[Count] = obj3;
 21397            array4[Count] = obj4;
 21398            array5[Count] = obj5;
 21399            array6[Count] = obj6;
 21400            array7[Count] = obj7;
 1401
 21402            ++Count;
 21403            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1404
 21405            lookupIndex = indexToClaim;
 21406            return needsExpansion;
 21407        }
 1408
 1409        /// <summary>
 1410        ///     Adds to the set without checking if the set needs to expand.
 1411        /// </summary>
 1412        /// <returns>The sparse index allocated</returns>
 1413        public int AddUnchecked<T0>(T0 obj0, T0[] array0)
 41414        {
 41415            int indexToClaim = FreeIndex;
 41416            int nextFreeIndex = SparseArray[indexToClaim];
 41417            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41418            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1419
 41420            array0[Count] = obj0;
 1421
 41422            ++Count;
 41423            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1424
 41425            return indexToClaim;
 41426        }
 1427
 1428        /// <summary>
 1429        ///     Adds to the set without checking if the set needs to expand.
 1430        /// </summary>
 1431        /// <returns>The sparse index allocated</returns>
 1432        public int AddUnchecked<T0, T1>(T0 obj0, T0[] array0, T1 obj1, T1[] array1)
 41433        {
 41434            int indexToClaim = FreeIndex;
 41435            int nextFreeIndex = SparseArray[indexToClaim];
 41436            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41437            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1438
 41439            array0[Count] = obj0;
 41440            array1[Count] = obj1;
 1441
 41442            ++Count;
 41443            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1444
 41445            return indexToClaim;
 41446        }
 1447
 1448        /// <summary>
 1449        ///     Adds to the set without checking if the set needs to expand.
 1450        /// </summary>
 1451        /// <returns>The sparse index allocated</returns>
 1452        public int AddUnchecked<T0, T1, T2>(T0 obj0, T0[] array0, T1 obj1, T1[] array1, T2 obj2, T2[] array2)
 41453        {
 41454            int indexToClaim = FreeIndex;
 41455            int nextFreeIndex = SparseArray[indexToClaim];
 41456            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41457            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1458
 41459            array0[Count] = obj0;
 41460            array1[Count] = obj1;
 41461            array2[Count] = obj2;
 1462
 41463            ++Count;
 41464            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1465
 41466            return indexToClaim;
 41467        }
 1468
 1469        /// <summary>
 1470        ///     Adds to the set without checking if the set needs to expand.
 1471        /// </summary>
 1472        /// <returns>The sparse index allocated</returns>
 1473        public int AddUnchecked<T0, T1, T2, T3>(T0 obj0, T0[] array0, T1 obj1, T1[] array1, T2 obj2, T2[] array2,
 1474            T3 obj3,
 1475            T3[] array3)
 41476        {
 41477            int indexToClaim = FreeIndex;
 41478            int nextFreeIndex = SparseArray[indexToClaim];
 41479            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41480            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1481
 41482            array0[Count] = obj0;
 41483            array1[Count] = obj1;
 41484            array2[Count] = obj2;
 41485            array3[Count] = obj3;
 1486
 41487            ++Count;
 41488            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1489
 41490            return indexToClaim;
 41491        }
 1492
 1493        /// <summary>
 1494        ///     Adds to the set without checking if the set needs to expand.
 1495        /// </summary>
 1496        /// <returns>The sparse index allocated</returns>
 1497        public int AddUnchecked<T0, T1, T2, T3, T4>(T0 obj0, T0[] array0, T1 obj1, T1[] array1, T2 obj2, T2[] array2,
 1498            T3 obj3, T3[] array3, T4 obj4, T4[] array4)
 41499        {
 41500            int indexToClaim = FreeIndex;
 41501            int nextFreeIndex = SparseArray[indexToClaim];
 41502            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41503            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1504
 41505            array0[Count] = obj0;
 41506            array1[Count] = obj1;
 41507            array2[Count] = obj2;
 41508            array3[Count] = obj3;
 41509            array4[Count] = obj4;
 1510
 41511            ++Count;
 41512            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1513
 41514            return indexToClaim;
 41515        }
 1516
 1517        /// <summary>
 1518        ///     Adds to the set without checking if the set needs to expand.
 1519        /// </summary>
 1520        /// <returns>The sparse index allocated</returns>
 1521        public int AddUnchecked<T0, T1, T2, T3, T4, T5>(T0 obj0, T0[] array0, T1 obj1, T1[] array1, T2 obj2,
 1522            T2[] array2,
 1523            T3 obj3, T3[] array3, T4 obj4, T4[] array4, T5 obj5, T5[] array5)
 41524        {
 41525            int indexToClaim = FreeIndex;
 41526            int nextFreeIndex = SparseArray[indexToClaim];
 41527            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41528            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1529
 41530            array0[Count] = obj0;
 41531            array1[Count] = obj1;
 41532            array2[Count] = obj2;
 41533            array3[Count] = obj3;
 41534            array4[Count] = obj4;
 41535            array5[Count] = obj5;
 1536
 41537            ++Count;
 41538            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1539
 41540            return indexToClaim;
 41541        }
 1542
 1543        /// <summary>
 1544        ///     Adds to the set without checking if the set needs to expand.
 1545        /// </summary>
 1546        /// <returns>The sparse index allocated</returns>
 1547        public int AddUnchecked<T0, T1, T2, T3, T4, T5, T6>(T0 obj0, T0[] array0, T1 obj1, T1[] array1, T2 obj2,
 1548            T2[] array2,
 1549            T3 obj3, T3[] array3, T4 obj4, T4[] array4, T5 obj5, T5[] array5, T6 obj6, T6[] array6)
 41550        {
 41551            int indexToClaim = FreeIndex;
 41552            int nextFreeIndex = SparseArray[indexToClaim];
 41553            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41554            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1555
 41556            array0[Count] = obj0;
 41557            array1[Count] = obj1;
 41558            array2[Count] = obj2;
 41559            array3[Count] = obj3;
 41560            array4[Count] = obj4;
 41561            array5[Count] = obj5;
 41562            array6[Count] = obj6;
 1563
 41564            ++Count;
 41565            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1566
 41567            return indexToClaim;
 41568        }
 1569
 1570        /// <summary>
 1571        ///     Adds to the set without checking if the set needs to expand.
 1572        /// </summary>
 1573        /// <returns>The sparse index allocated</returns>
 1574        public int AddUnchecked<T0, T1, T2, T3, T4, T5, T6, T7>(T0 obj0, T0[] array0, T1 obj1, T1[] array1, T2 obj2,
 1575            T2[] array2, T3 obj3, T3[] array3, T4 obj4, T4[] array4, T5 obj5, T5[] array5, T6 obj6, T6[] array6,
 1576            T7 obj7, T7[] array7)
 41577        {
 41578            int indexToClaim = FreeIndex;
 41579            int nextFreeIndex = SparseArray[indexToClaim];
 41580            DenseArray[Count] = indexToClaim; // Point the next dense id at our newly claimed sparse index.
 41581            SparseArray[indexToClaim] = Count; // Point our newly claimed sparse index at the dense index.
 1582
 41583            array0[Count] = obj0;
 41584            array1[Count] = obj1;
 41585            array2[Count] = obj2;
 41586            array3[Count] = obj3;
 41587            array4[Count] = obj4;
 41588            array5[Count] = obj5;
 41589            array6[Count] = obj6;
 41590            array7[Count] = obj7;
 1591
 41592            ++Count;
 41593            FreeIndex = nextFreeIndex; // Set the free list head for next time.
 1594
 41595            return indexToClaim;
 41596        }
 1597
 1598        public void RemoveUnchecked<T0>(int sparseIndexToRemove, T0[] array0)
 21599        {
 21600            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 21601            int newLength = Count - 1;
 21602            int sparseIndexBeingSwapped = DenseArray[newLength];
 1603
 1604            // Swap the entry being removed with the last entry.
 21605            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 21606            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 21607            array0[denseIndexToRemove] = array0[newLength];
 1608
 1609            // Clear the dense  index, for debugging purposes
 21610            DenseArray[newLength] = -1;
 21611            array0[newLength] = default;
 1612
 1613            // Add the sparse index to the free list.
 21614            SparseArray[sparseIndexToRemove] = FreeIndex;
 21615            FreeIndex = sparseIndexToRemove;
 1616
 21617            Count = newLength;
 21618        }
 1619
 1620        public void RemoveUnchecked<T0, T1>(int sparseIndexToRemove, T0[] array0, T1[] array1)
 11621        {
 11622            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11623            int newLength = Count - 1;
 11624            int sparseIndexBeingSwapped = DenseArray[newLength];
 1625
 1626            // Swap the entry being removed with the last entry.
 11627            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11628            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11629            array0[denseIndexToRemove] = array0[newLength];
 11630            array1[denseIndexToRemove] = array1[newLength];
 1631
 1632            // Clear the dense  index, for debugging purposes
 11633            DenseArray[newLength] = -1;
 11634            array0[newLength] = default;
 11635            array1[newLength] = default;
 1636
 1637            // Add the sparse index to the free list.
 11638            SparseArray[sparseIndexToRemove] = FreeIndex;
 11639            FreeIndex = sparseIndexToRemove;
 1640
 11641            Count = newLength;
 11642        }
 1643
 1644        public void RemoveUnchecked<T0, T1, T2>(int sparseIndexToRemove, T0[] array0, T1[] array1, T2[] array2)
 11645        {
 11646            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11647            int newLength = Count - 1;
 11648            int sparseIndexBeingSwapped = DenseArray[newLength];
 1649
 1650            // Swap the entry being removed with the last entry.
 11651            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11652            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11653            array0[denseIndexToRemove] = array0[newLength];
 11654            array1[denseIndexToRemove] = array1[newLength];
 11655            array2[denseIndexToRemove] = array2[newLength];
 1656
 1657            // Clear the dense  index, for debugging purposes
 11658            DenseArray[newLength] = -1;
 11659            array0[newLength] = default;
 11660            array1[newLength] = default;
 11661            array2[newLength] = default;
 1662
 1663            // Add the sparse index to the free list.
 11664            SparseArray[sparseIndexToRemove] = FreeIndex;
 11665            FreeIndex = sparseIndexToRemove;
 1666
 11667            Count = newLength;
 11668        }
 1669
 1670        public void RemoveUnchecked<T0, T1, T2, T3>(int sparseIndexToRemove, T0[] array0, T1[] array1, T2[] array2,
 1671            T3[] array3)
 11672        {
 11673            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11674            int newLength = Count - 1;
 11675            int sparseIndexBeingSwapped = DenseArray[newLength];
 1676
 1677            // Swap the entry being removed with the last entry.
 11678            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11679            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11680            array0[denseIndexToRemove] = array0[newLength];
 11681            array1[denseIndexToRemove] = array1[newLength];
 11682            array2[denseIndexToRemove] = array2[newLength];
 11683            array3[denseIndexToRemove] = array3[newLength];
 1684
 1685            // Clear the dense  index, for debugging purposes
 11686            DenseArray[newLength] = -1;
 11687            array0[newLength] = default;
 11688            array1[newLength] = default;
 11689            array2[newLength] = default;
 11690            array3[newLength] = default;
 1691
 1692            // Add the sparse index to the free list.
 11693            SparseArray[sparseIndexToRemove] = FreeIndex;
 11694            FreeIndex = sparseIndexToRemove;
 1695
 11696            Count = newLength;
 11697        }
 1698
 1699        public void RemoveUnchecked<T0, T1, T2, T3, T4>(int sparseIndexToRemove, T0[] array0, T1[] array1, T2[] array2,
 1700            T3[] array3, T4[] array4)
 11701        {
 11702            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11703            int newLength = Count - 1;
 11704            int sparseIndexBeingSwapped = DenseArray[newLength];
 1705
 1706            // Swap the entry being removed with the last entry.
 11707            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11708            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11709            array0[denseIndexToRemove] = array0[newLength];
 11710            array1[denseIndexToRemove] = array1[newLength];
 11711            array2[denseIndexToRemove] = array2[newLength];
 11712            array3[denseIndexToRemove] = array3[newLength];
 11713            array4[denseIndexToRemove] = array4[newLength];
 1714
 1715            // Clear the dense  index, for debugging purposes
 11716            DenseArray[newLength] = -1;
 11717            array0[newLength] = default;
 11718            array1[newLength] = default;
 11719            array2[newLength] = default;
 11720            array3[newLength] = default;
 11721            array4[newLength] = default;
 1722
 1723            // Add the sparse index to the free list.
 11724            SparseArray[sparseIndexToRemove] = FreeIndex;
 11725            FreeIndex = sparseIndexToRemove;
 1726
 11727            Count = newLength;
 11728        }
 1729
 1730        public void RemoveUnchecked<T0, T1, T2, T3, T4, T5>(int sparseIndexToRemove, T0[] array0, T1[] array1,
 1731            T2[] array2,
 1732            T3[] array3, T4[] array4, T5[] array5)
 11733        {
 11734            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11735            int newLength = Count - 1;
 11736            int sparseIndexBeingSwapped = DenseArray[newLength];
 1737
 1738            // Swap the entry being removed with the last entry.
 11739            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11740            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11741            array0[denseIndexToRemove] = array0[newLength];
 11742            array1[denseIndexToRemove] = array1[newLength];
 11743            array2[denseIndexToRemove] = array2[newLength];
 11744            array3[denseIndexToRemove] = array3[newLength];
 11745            array4[denseIndexToRemove] = array4[newLength];
 11746            array5[denseIndexToRemove] = array5[newLength];
 1747
 1748            // Clear the dense  index, for debugging purposes
 11749            DenseArray[newLength] = -1;
 11750            array0[newLength] = default;
 11751            array1[newLength] = default;
 11752            array2[newLength] = default;
 11753            array3[newLength] = default;
 11754            array4[newLength] = default;
 11755            array5[newLength] = default;
 1756
 1757            // Add the sparse index to the free list.
 11758            SparseArray[sparseIndexToRemove] = FreeIndex;
 11759            FreeIndex = sparseIndexToRemove;
 1760
 11761            Count = newLength;
 11762        }
 1763
 1764        public void RemoveUnchecked<T0, T1, T2, T3, T4, T5, T6>(int sparseIndexToRemove, T0[] array0, T1[] array1,
 1765            T2[] array2, T3[] array3, T4[] array4, T5[] array5, T6[] array6)
 11766        {
 11767            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11768            int newLength = Count - 1;
 11769            int sparseIndexBeingSwapped = DenseArray[newLength];
 1770
 1771            // Swap the entry being removed with the last entry.
 11772            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11773            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11774            array0[denseIndexToRemove] = array0[newLength];
 11775            array1[denseIndexToRemove] = array1[newLength];
 11776            array2[denseIndexToRemove] = array2[newLength];
 11777            array3[denseIndexToRemove] = array3[newLength];
 11778            array4[denseIndexToRemove] = array4[newLength];
 11779            array5[denseIndexToRemove] = array5[newLength];
 11780            array6[denseIndexToRemove] = array6[newLength];
 1781
 1782            // Clear the dense  index, for debugging purposes
 11783            DenseArray[newLength] = -1;
 11784            array0[newLength] = default;
 11785            array1[newLength] = default;
 11786            array2[newLength] = default;
 11787            array3[newLength] = default;
 11788            array4[newLength] = default;
 11789            array5[newLength] = default;
 11790            array6[newLength] = default;
 1791
 1792            // Add the sparse index to the free list.
 11793            SparseArray[sparseIndexToRemove] = FreeIndex;
 11794            FreeIndex = sparseIndexToRemove;
 1795
 11796            Count = newLength;
 11797        }
 1798
 1799        public void RemoveUnchecked<T0, T1, T2, T3, T4, T5, T6, T7>(int sparseIndexToRemove, T0[] array0, T1[] array1,
 1800            T2[] array2, T3[] array3, T4[] array4, T5[] array5, T6[] array6, T7[] array7)
 11801        {
 11802            int denseIndexToRemove = SparseArray[sparseIndexToRemove];
 11803            int newLength = Count - 1;
 11804            int sparseIndexBeingSwapped = DenseArray[newLength];
 1805
 1806            // Swap the entry being removed with the last entry.
 11807            SparseArray[sparseIndexBeingSwapped] = denseIndexToRemove;
 11808            DenseArray[denseIndexToRemove] = sparseIndexBeingSwapped;
 11809            array0[denseIndexToRemove] = array0[newLength];
 11810            array1[denseIndexToRemove] = array1[newLength];
 11811            array2[denseIndexToRemove] = array2[newLength];
 11812            array3[denseIndexToRemove] = array3[newLength];
 11813            array4[denseIndexToRemove] = array4[newLength];
 11814            array5[denseIndexToRemove] = array5[newLength];
 11815            array6[denseIndexToRemove] = array6[newLength];
 11816            array7[denseIndexToRemove] = array7[newLength];
 1817
 1818            // Clear the dense  index, for debugging purposes
 11819            DenseArray[newLength] = -1;
 11820            array0[newLength] = default;
 11821            array1[newLength] = default;
 11822            array2[newLength] = default;
 11823            array3[newLength] = default;
 11824            array4[newLength] = default;
 11825            array5[newLength] = default;
 11826            array6[newLength] = default;
 11827            array7[newLength] = default;
 1828
 1829            // Add the sparse index to the free list.
 11830            SparseArray[sparseIndexToRemove] = FreeIndex;
 11831            FreeIndex = sparseIndexToRemove;
 1832
 11833            Count = newLength;
 11834        }
 1835
 1836        #endregion
 1837    }
 1838}

Coverage by test methods






















































































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, , , , , , , , )