< Summary

Class:GDX.Collections.Generic.SimpleList[T]
Assembly:GDX
File(s):./Packages/com.dotbunny.gdx/GDX/Collections/Generic/SimpleList.cs
Covered lines:308
Uncovered lines:7
Coverable lines:315
Total lines:580
Line coverage:97.7% (308 of 315)
Covered branches:0
Total branches:0
Covered methods:27
Total methods:28
Method coverage:96.4% (27 of 28)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
SimpleList(...)0%110100%
SimpleList()0%110100%
SimpleList(...)0%110100%
AddUnchecked(...)0%110100%
AddWithExpandCheck(...)0%440100%
AddWithExpandCheck(...)0%220100%
AddExpandNoClear(...)0%440100%
AddExpandClearOld(...)0%440100%
AddExpandClearNew(...)0%440100%
AddExpandClearBoth(...)0%440100%
Clear()0%110100%
Compact()0%6200%
InsertUnchecked(...)0%110100%
InsertWithExpandCheck(...)0%440100%
InsertWithExpandCheck(...)0%440100%
InsertExpandNoClear(...)0%440100%
InsertExpandClearOld(...)0%440100%
InsertExpandClearNew(...)0%440100%
InsertExpandClearBoth(...)0%440100%
RemoveAt(...)0%220100%
RemoveAtSwapBack(...)0%110100%
RemoveFromBack()0%110100%
Reserve(...)0%220100%
ReserveNoClear(...)0%220100%
ReserveClearOld(...)0%220100%
ReserveClearNew(...)0%220100%
ReserveClearBoth(...)0%220100%
Reverse()0%220100%

File(s)

./Packages/com.dotbunny.gdx/GDX/Collections/Generic/SimpleList.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 GDX.Collections.Pooling;
 6
 7namespace GDX.Collections.Generic
 8{
 9    /// <summary>
 10    ///     An optimized <see cref="System.Collections.Generic.List{T}" />-like data structure.
 11    /// </summary>
 12    /// <typeparam name="T">The type of the <see cref="object" />s contained within.</typeparam>
 13    [VisualScriptingCompatible(1)]
 14    public struct SimpleList<T>
 15    {
 16        /// <summary>
 17        ///     Internal array of backed data for the <see cref="SimpleList{T}" />.
 18        /// </summary>
 19        public T[] Array;
 20
 21        /// <summary>
 22        ///     The current number of occupied elements in the <see cref="CircularBuffer{T}" />.
 23        /// </summary>
 24        /// <remarks>CAUTION! Changing this will alter the understanding of the data.</remarks>
 25        public int Count;
 26
 27        /// <summary>
 28        ///     Create a <see cref="SimpleList{T}" /> with an initial <paramref name="capacity" />.
 29        /// </summary>
 30        /// <param name="capacity">An initial sizing for the <see cref="Array" />.</param>
 31        public SimpleList(int capacity)
 12632        {
 12633            Array = new T[capacity];
 12634            Count = 0;
 12635        }
 36
 37        /// <summary>
 38        ///     Create a <see cref="SimpleList{T}" /> providing an existing <paramref name="arrayToUse" />.
 39        /// </summary>
 40        /// <param name="arrayToUse">An existing array to use in the <see cref="SimpleList{T}" />.</param>
 41        public SimpleList(T[] arrayToUse)
 342        {
 343            Array = arrayToUse;
 344            Count = 0;
 345        }
 46
 47        /// <summary>
 48        ///     Create a <see cref="SimpleList{T}" /> providing an existing <paramref name="arrayToUse" /> and setting t
 49        ///     <see cref="Count" />.
 50        /// </summary>
 51        /// <param name="arrayToUse">An existing array to use in the <see cref="SimpleList{T}" />.</param>
 52        /// <param name="count">An existing element count.</param>
 53        public SimpleList(T[] arrayToUse, int count)
 2754        {
 2755            Array = arrayToUse;
 2756            Count = count;
 2757        }
 58
 59        /// <summary>
 60        ///     Add an item to the <see cref="SimpleList{T}" /> without checking the <see cref="Array" /> size.
 61        /// </summary>
 62        /// <param name="item">A typed <see cref="object" /> to add.</param>
 63        public void AddUnchecked(T item)
 33764        {
 33765            Array[Count] = item;
 33466            ++Count;
 33467        }
 68
 69        /// <summary>
 70        ///     Add an item to the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resized.
 71        /// </summary>
 72        /// <param name="item">A typed <see cref="object" /> to add.</param>
 73        public void AddWithExpandCheck(T item)
 3874        {
 3875            int arrayLength = Array.Length;
 76
 3877            if (Count >= arrayLength)
 578            {
 579                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 580                System.Array.Resize(ref Array, arrayLength * 2);
 581            }
 82
 3883            Array[Count] = item;
 3884            ++Count;
 3885        }
 86
 87        /// <summary>
 88        ///     Add an item to the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resized.
 89        /// </summary>
 90        /// <param name="item">A typed <see cref="object" /> to add.</param>
 91        /// <param name="howMuchToExpand">How much to expand the array by.</param>
 92        public void AddWithExpandCheck(T item, int howMuchToExpand)
 193        {
 194            if (Count >= Array.Length)
 195            {
 196                System.Array.Resize(ref Array, Array.Length + howMuchToExpand);
 197            }
 98
 199            Array[Count] = item;
 1100            ++Count;
 1101        }
 102
 103        /// <summary>
 104        ///     Add an item to the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resized.
 105        /// </summary>
 106        /// <param name="item">A typed <see cref="object" /> to add.</param>
 107        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 108        public void AddExpandNoClear(T item, ArrayPool<T> pool)
 5109        {
 5110            T[] array = Array;
 5111            int count = Count;
 5112            int arrayLength = array.Length;
 113
 5114            if (Count >= arrayLength)
 1115            {
 1116                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1117                T[] newArray = pool.Get(arrayLength * 2);
 1118                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1119                pool.Return(array);
 1120                array = newArray;
 1121                Array = newArray;
 1122            }
 123
 5124            array[count] = item;
 5125            ++count;
 5126            Count = count;
 5127        }
 128
 129        /// <summary>
 130        ///     Add an item to the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resized. C
 131        ///     old array on resize after copying its contents.
 132        /// </summary>
 133        /// <param name="item">A typed <see cref="object" /> to add.</param>
 134        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 135        public void AddExpandClearOld(T item, ArrayPool<T> pool)
 3136        {
 3137            T[] array = Array;
 3138            int count = Count;
 3139            int arrayLength = array.Length;
 140
 3141            if (Count >= arrayLength)
 1142            {
 1143                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1144                T[] newArray = pool.Get(arrayLength * 2);
 1145                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1146                System.Array.Clear(array, 0, arrayLength);
 1147                pool.Return(array);
 1148                array = newArray;
 1149                Array = newArray;
 1150            }
 151
 3152            array[count] = item;
 3153            ++count;
 3154            Count = count;
 3155        }
 156
 157        /// <summary>
 158        ///     Add an item to the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resized. C
 159        ///     unused indices of the new array on resize.
 160        /// </summary>
 161        /// <param name="item">A typed <see cref="object" /> to add.</param>
 162        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 163        public void AddExpandClearNew(T item, ArrayPool<T> pool)
 5164        {
 5165            T[] array = Array;
 5166            int count = Count;
 5167            int arrayLength = array.Length;
 168
 5169            if (Count >= arrayLength)
 1170            {
 1171                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1172                T[] newArray = pool.Get(arrayLength * 2);
 1173                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1174                System.Array.Clear(newArray, arrayLength, arrayLength);
 1175                pool.Return(array);
 1176                array = newArray;
 1177                Array = newArray;
 1178            }
 179
 5180            array[count] = item;
 5181            ++count;
 5182            Count = count;
 5183        }
 184
 185        /// <summary>
 186        ///     Add an item to the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resized.  
 187        ///     and new arrays on resize.
 188        /// </summary>
 189        /// <param name="item">A typed <see cref="object" /> to add.</param>
 190        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 191        public void AddExpandClearBoth(T item, ArrayPool<T> pool)
 5192        {
 5193            T[] array = Array;
 5194            int count = Count;
 5195            int arrayLength = array.Length;
 196
 5197            if (Count >= arrayLength)
 1198            {
 1199                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1200                T[] newArray = pool.Get(arrayLength * 2);
 1201                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1202                System.Array.Clear(array, 0, arrayLength);
 1203                System.Array.Clear(newArray, arrayLength, arrayLength);
 1204                pool.Return(array);
 1205                array = newArray;
 1206                Array = newArray;
 1207            }
 208
 5209            array[count] = item;
 5210            ++count;
 5211            Count = count;
 5212        }
 213
 214        /// <summary>
 215        ///     Clear out the <see cref="Array" /> in <see cref="SimpleList{T}" /> and sets the <see cref="Count" /> to 
 216        /// </summary>
 217        public void Clear()
 57218        {
 57219            System.Array.Clear(Array, 0, Count);
 57220            Count = 0;
 57221        }
 222
 223        /// <summary>
 224        ///     Shrink/compact the backing <see cref="Array" /> so there is no unused space.
 225        /// </summary>
 226        public void Compact()
 0227        {
 0228            int arrayLength = Array.Length;
 0229            if (Count < arrayLength)
 0230            {
 0231                System.Array.Resize(ref Array, Count);
 0232            }
 0233        }
 234
 235        /// <summary>
 236        ///     Insert an item into the <see cref="SimpleList{T}" /> without checking the <see cref="Array" /> size.
 237        /// </summary>
 238        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 239        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 240        public void InsertUnchecked(int index, T item)
 3241        {
 3242            System.Array.Copy(Array, index, Array, index + 1, Count - index);
 3243            Array[index] = item;
 3244            ++Count;
 3245        }
 246
 247        /// <summary>
 248        ///     Insert an item into the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resiz
 249        /// </summary>
 250        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 251        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 252        public void InsertWithExpandCheck(int index, T item)
 3253        {
 3254            int arrayLength = Array.Length;
 3255            if (Count >= arrayLength)
 3256            {
 3257                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 3258                System.Array.Resize(ref Array, arrayLength * 2);
 3259            }
 260
 3261            System.Array.Copy(Array, index, Array, index + 1, Count - index);
 3262            Array[index] = item;
 3263            ++Count;
 3264        }
 265
 266        /// <summary>
 267        ///     Insert an item into the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resiz
 268        /// </summary>
 269        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 270        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 271        /// <param name="howMuchToExpand">The number of elements to add at the end of the array when expanding.</param>
 272        public void InsertWithExpandCheck(int index, T item, int howMuchToExpand)
 3273        {
 3274            int arrayLength = Array.Length;
 3275            if (Count >= arrayLength)
 3276            {
 3277                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 3278                System.Array.Resize(ref Array, arrayLength + howMuchToExpand);
 3279            }
 280
 3281            System.Array.Copy(Array, index, Array, index + 1, Count - index);
 3282            Array[index] = item;
 3283            ++Count;
 3284        }
 285
 286        /// <summary>
 287        ///     Insert an item into the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resiz
 288        /// </summary>
 289        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 290        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 291        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 292        public void InsertExpandNoClear(int index, T item, ArrayPool<T> pool)
 1293        {
 1294            T[] array = Array;
 1295            int count = Count;
 1296            int arrayLength = array.Length;
 297
 1298            if (Count >= arrayLength)
 1299            {
 1300                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1301                T[] newArray = pool.Get(arrayLength * 2);
 1302                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1303                pool.Return(array);
 1304                array = newArray;
 1305                Array = newArray;
 1306            }
 307
 1308            System.Array.Copy(array, index, array, index + 1, Count - index);
 1309            array[index] = item;
 1310            ++count;
 1311            Count = count;
 1312        }
 313
 314        /// <summary>
 315        ///     Insert an item into the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resiz
 316        ///     the old array on resize after copying its contents.
 317        /// </summary>
 318        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 319        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 320        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 321        public void InsertExpandClearOld(int index, T item, ArrayPool<T> pool)
 1322        {
 1323            T[] array = Array;
 1324            int count = Count;
 1325            int arrayLength = array.Length;
 326
 1327            if (Count >= arrayLength)
 1328            {
 1329                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1330                T[] newArray = pool.Get(arrayLength * 2);
 1331                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1332                System.Array.Clear(array, 0, arrayLength);
 1333                pool.Return(array);
 1334                array = newArray;
 1335                Array = newArray;
 1336            }
 337
 1338            System.Array.Copy(array, index, array, index + 1, Count - index);
 1339            array[index] = item;
 1340            ++count;
 1341            Count = count;
 1342        }
 343
 344        /// <summary>
 345        ///     Insert an item into the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resiz
 346        ///     unused indices of the new array on resize.
 347        /// </summary>
 348        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 349        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 350        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 351        public void InsertExpandClearNew(int index, T item, ArrayPool<T> pool)
 1352        {
 1353            T[] array = Array;
 1354            int count = Count;
 1355            int arrayLength = array.Length;
 356
 1357            if (Count >= arrayLength)
 1358            {
 1359                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1360                T[] newArray = pool.Get(arrayLength * 2);
 1361                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1362                System.Array.Clear(newArray, arrayLength, arrayLength);
 1363                pool.Return(array);
 1364                array = newArray;
 1365                Array = newArray;
 1366            }
 367
 1368            System.Array.Copy(array, index, array, index + 1, Count - index);
 1369            array[index] = item;
 1370            ++count;
 1371            Count = count;
 1372        }
 373
 374        /// <summary>
 375        ///     Insert an item into the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resiz
 376        ///     old and new arrays on resize.
 377        /// </summary>
 378        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 379        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 380        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 381        public void InsertExpandClearBoth(int index, T item, ArrayPool<T> pool)
 1382        {
 1383            T[] array = Array;
 1384            int count = Count;
 1385            int arrayLength = array.Length;
 386
 1387            if (Count >= arrayLength)
 1388            {
 1389                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1390                T[] newArray = pool.Get(arrayLength * 2);
 1391                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1392                System.Array.Clear(array, 0, arrayLength);
 1393                System.Array.Clear(newArray, arrayLength, arrayLength);
 1394                pool.Return(array);
 1395                array = newArray;
 1396                Array = newArray;
 1397            }
 398
 1399            System.Array.Copy(array, index, array, index + 1, Count - index);
 1400            array[index] = item;
 1401            ++count;
 1402            Count = count;
 1403        }
 404
 405        /// <summary>
 406        ///     Remove an item from the <see cref="SimpleList{T}" /> at a specific <paramref name="index" />.
 407        /// </summary>
 408        /// <param name="index">The target index.</param>
 409        public void RemoveAt(int index)
 23410        {
 23411            int newLength = Count - 1;
 412
 23413            Array[index] = default;
 414
 23415            if (index < Array.Length)
 23416            {
 23417                System.Array.Copy(Array, index + 1, Array, index, newLength - index);
 23418            }
 419
 23420            Count = newLength;
 23421        }
 422
 423        /// <summary>
 424        ///     Remove an item from the <see cref="SimpleList{T}" /> at a specific <paramref name="index" />, swapping i
 425        ///     item from the highest used index.
 426        /// </summary>
 427        /// <param name="index">The target index.</param>
 428        public void RemoveAtSwapBack(int index)
 15429        {
 15430            int newLength = Count - 1;
 15431            T[] array = Array;
 15432            array[index] = array[newLength];
 15433            array[newLength] = default;
 434
 15435            Count = newLength;
 15436        }
 437
 438        /// <summary>
 439        ///     Remove the last element in the <see cref="SimpleList{T}" />.
 440        /// </summary>
 441        public void RemoveFromBack()
 1442        {
 1443            int newLength = Count - 1;
 1444            Array[newLength] = default;
 1445            Count = newLength;
 1446        }
 447
 448        /// <summary>
 449        ///     Resizes the <see cref="Array" />, ensuring there are the provided number of empty spots in it.
 450        /// </summary>
 451        /// <param name="numberToReserve">Number of desired empty spots.</param>
 452        public void Reserve(int numberToReserve)
 1453        {
 1454            int combinedLength = Count + numberToReserve;
 455
 1456            if (combinedLength > Array.Length)
 1457            {
 1458                System.Array.Resize(ref Array, combinedLength);
 1459            }
 1460        }
 461
 462        /// <summary>
 463        ///     Resizes the <see cref="Array" />, ensuring there are the provided number of empty spots in it.
 464        /// </summary>
 465        /// <param name="numberToReserve">Number of desired empty spots.</param>
 466        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 467        public void ReserveNoClear(int numberToReserve, ArrayPool<T> pool)
 1468        {
 1469            T[] array = Array;
 1470            int count = Count;
 1471            int arrayLength = array.Length;
 472
 1473            int combinedLength = count + numberToReserve;
 474
 1475            if (combinedLength > arrayLength)
 1476            {
 1477                T[] newArray = pool.Get(combinedLength);
 1478                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1479                pool.Return(array);
 1480                Array = newArray;
 1481            }
 1482        }
 483
 484        /// <summary>
 485        ///     Resizes the <see cref="Array" />, ensuring there are the provided number of empty spots in it. Clears th
 486        ///     on resize after copying its contents.
 487        /// </summary>
 488        /// <param name="numberToReserve">Number of desired empty spots.</param>
 489        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 490        public void ReserveClearOld(int numberToReserve, ArrayPool<T> pool)
 1491        {
 1492            T[] array = Array;
 1493            int count = Count;
 1494            int arrayLength = array.Length;
 495
 1496            int combinedLength = count + numberToReserve;
 497
 1498            if (combinedLength > arrayLength)
 1499            {
 1500                T[] newArray = pool.Get(combinedLength);
 1501                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1502                System.Array.Clear(array, 0, arrayLength);
 1503                pool.Return(array);
 1504                Array = newArray;
 1505            }
 1506        }
 507
 508        /// <summary>
 509        ///     Resizes the <see cref="Array" />, ensuring there are the provided number of empty spots in it.  Clears u
 510        ///     indices of the new array on resize.
 511        /// </summary>
 512        /// <param name="numberToReserve">Number of desired empty spots.</param>
 513        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 514        public void ReserveClearNew(int numberToReserve, ArrayPool<T> pool)
 1515        {
 1516            T[] array = Array;
 1517            int count = Count;
 1518            int arrayLength = array.Length;
 519
 1520            int combinedLength = count + numberToReserve;
 521
 1522            if (combinedLength > arrayLength)
 1523            {
 1524                T[] newArray = pool.Get(combinedLength);
 1525                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1526                System.Array.Clear(newArray, arrayLength, arrayLength);
 1527                pool.Return(array);
 1528                Array = newArray;
 1529            }
 1530        }
 531
 532        /// <summary>
 533        ///     Resizes the <see cref="Array" />, ensuring there are the provided number of empty spots in it. Clears ol
 534        ///     arrays on resize.
 535        /// </summary>
 536        /// <param name="numberToReserve">Number of desired empty spots.</param>
 537        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 538        public void ReserveClearBoth(int numberToReserve, ArrayPool<T> pool)
 1539        {
 1540            T[] array = Array;
 1541            int count = Count;
 1542            int arrayLength = array.Length;
 543
 1544            int combinedLength = count + numberToReserve;
 545
 1546            if (combinedLength > arrayLength)
 1547            {
 1548                T[] newArray = pool.Get(combinedLength);
 1549                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1550                System.Array.Clear(array, 0, arrayLength);
 1551                System.Array.Clear(newArray, arrayLength, arrayLength);
 1552                pool.Return(array);
 1553                Array = newArray;
 1554            }
 1555        }
 556
 557        /// <summary>
 558        ///     Reverse the order of <see cref="Array" />.
 559        /// </summary>
 560        public void Reverse()
 3561        {
 562            // ReSharper disable once TooWideLocalVariableScope
 563            T temporaryStorage;
 564
 3565            int lastIndex = Count - 1;
 3566            int middleIndex = Count / 2;
 567
 18568            for (int currentElementIndex = 0; currentElementIndex < middleIndex; currentElementIndex++)
 6569            {
 570                // Store the swap value
 6571                temporaryStorage = Array[currentElementIndex];
 6572                int swapElementIndex = lastIndex - currentElementIndex;
 573
 574                // Swap values
 6575                Array[currentElementIndex] = Array[swapElementIndex];
 6576                Array[swapElementIndex] = temporaryStorage;
 6577            }
 3578        }
 579    }
 580}
Generated by: ReportGenerator 5.0.4.0
2024-01-01 - 7:00:16 PM
GitHub | www.palmmedia.de

Coverage by test methods































































































Methods/Properties

SimpleList(System.Int32)
SimpleList()
SimpleList(, System.Int32)
AddUnchecked(T)
AddWithExpandCheck(T)
AddWithExpandCheck(T, System.Int32)
AddExpandNoClear(T, GDX.Collections.Pooling.ArrayPool[T])
AddExpandClearOld(T, GDX.Collections.Pooling.ArrayPool[T])
AddExpandClearNew(T, GDX.Collections.Pooling.ArrayPool[T])
AddExpandClearBoth(T, GDX.Collections.Pooling.ArrayPool[T])
Clear()
Compact()
InsertUnchecked(System.Int32, T)
InsertWithExpandCheck(System.Int32, T)
InsertWithExpandCheck(System.Int32, T, System.Int32)
InsertExpandNoClear(System.Int32, T, GDX.Collections.Pooling.ArrayPool[T])
InsertExpandClearOld(System.Int32, T, GDX.Collections.Pooling.ArrayPool[T])
InsertExpandClearNew(System.Int32, T, GDX.Collections.Pooling.ArrayPool[T])
InsertExpandClearBoth(System.Int32, T, GDX.Collections.Pooling.ArrayPool[T])
RemoveAt(System.Int32)
RemoveAtSwapBack(System.Int32)
RemoveFromBack()
Reserve(System.Int32)
ReserveNoClear(System.Int32, GDX.Collections.Pooling.ArrayPool[T])
ReserveClearOld(System.Int32, GDX.Collections.Pooling.ArrayPool[T])
ReserveClearNew(System.Int32, GDX.Collections.Pooling.ArrayPool[T])
ReserveClearBoth(System.Int32, GDX.Collections.Pooling.ArrayPool[T])
Reverse()