< Summary

Class:GDX.Collections.Generic.SimpleList[T]
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Collections/Generic/SimpleList.cs
Covered lines:308
Uncovered lines:0
Coverable lines:308
Total lines:558
Line coverage:100% (308 of 308)
Covered branches:0
Total branches:0
Covered methods:27
Total methods:27
Method coverage:100% (27 of 27)

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

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

#LineLine coverage
 1// Copyright (c) 2020-2022 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using 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)
 11432        {
 11433            Array = new T[capacity];
 11434            Count = 0;
 11435        }
 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)
 154        {
 155            Array = arrayToUse;
 156            Count = count;
 157        }
 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)
 31164        {
 31165            Array[Count] = item;
 30866            ++Count;
 30867        }
 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)
 3174        {
 3175            int arrayLength = Array.Length;
 76
 3177            if (Count >= arrayLength)
 478            {
 479                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 480                System.Array.Resize(ref Array, arrayLength * 2);
 481            }
 82
 3183            Array[Count] = item;
 3184            ++Count;
 3185        }
 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        /// </summary>
 132        /// <param name="item">A typed <see cref="object" /> to add.</param>
 133        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 134        public void AddExpandClearOld(T item, ArrayPool<T> pool)
 3135        {
 3136            T[] array = Array;
 3137            int count = Count;
 3138            int arrayLength = array.Length;
 139
 3140            if (Count >= arrayLength)
 1141            {
 1142                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1143                T[] newArray = pool.Get(arrayLength * 2);
 1144                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1145                System.Array.Clear(array, 0, arrayLength);
 1146                pool.Return(array);
 1147                array = newArray;
 1148                Array = newArray;
 1149            }
 150
 3151            array[count] = item;
 3152            ++count;
 3153            Count = count;
 3154        }
 155
 156        /// <summary>
 157        ///     Add an item to the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resized. C
 158        /// </summary>
 159        /// <param name="item">A typed <see cref="object" /> to add.</param>
 160        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 161        public void AddExpandClearNew(T item, ArrayPool<T> pool)
 5162        {
 5163            T[] array = Array;
 5164            int count = Count;
 5165            int arrayLength = array.Length;
 166
 5167            if (Count >= arrayLength)
 1168            {
 1169                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1170                T[] newArray = pool.Get(arrayLength * 2);
 1171                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1172                System.Array.Clear(newArray, arrayLength, arrayLength);
 1173                pool.Return(array);
 1174                array = newArray;
 1175                Array = newArray;
 1176            }
 177
 5178            array[count] = item;
 5179            ++count;
 5180            Count = count;
 5181        }
 182
 183        /// <summary>
 184        ///     Add an item to the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resized.  
 185        /// </summary>
 186        /// <param name="item">A typed <see cref="object" /> to add.</param>
 187        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 188        public void AddExpandClearBoth(T item, ArrayPool<T> pool)
 5189        {
 5190            T[] array = Array;
 5191            int count = Count;
 5192            int arrayLength = array.Length;
 193
 5194            if (Count >= arrayLength)
 1195            {
 1196                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1197                T[] newArray = pool.Get(arrayLength * 2);
 1198                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1199                System.Array.Clear(array, 0, arrayLength);
 1200                System.Array.Clear(newArray, arrayLength, arrayLength);
 1201                pool.Return(array);
 1202                array = newArray;
 1203                Array = newArray;
 1204            }
 205
 5206            array[count] = item;
 5207            ++count;
 5208            Count = count;
 5209        }
 210
 211        /// <summary>
 212        ///     Clear out the <see cref="Array" /> in <see cref="SimpleList{T}" /> and sets the <see cref="Count" /> to 
 213        /// </summary>
 214        public void Clear()
 53215        {
 53216            System.Array.Clear(Array, 0, Count);
 53217            Count = 0;
 53218        }
 219
 220        /// <summary>
 221        ///     Insert an item into the <see cref="SimpleList{T}" /> without checking the <see cref="Array" /> size.
 222        /// </summary>
 223        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 224        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 225        public void InsertUnchecked(int index, T item)
 3226        {
 3227            System.Array.Copy(Array, index, Array, index + 1, Count - index);
 3228            Array[index] = item;
 3229            ++Count;
 3230        }
 231
 232        /// <summary>
 233        ///     Insert an item into the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resiz
 234        /// </summary>
 235        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 236        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 237        public void InsertWithExpandCheck(int index, T item)
 3238        {
 3239            int arrayLength = Array.Length;
 3240            if (Count >= arrayLength)
 3241            {
 3242                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 3243                System.Array.Resize(ref Array, arrayLength * 2);
 3244            }
 245
 3246            System.Array.Copy(Array, index, Array, index + 1, Count - index);
 3247            Array[index] = item;
 3248            ++Count;
 3249        }
 250
 251        /// <summary>
 252        ///     Insert an item into the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resiz
 253        /// </summary>
 254        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 255        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 256        /// <param name="howMuchToExpand">The number of elements to add at the end of the array when expanding.</param>
 257        public void InsertWithExpandCheck(int index, T item, int howMuchToExpand)
 3258        {
 3259            int arrayLength = Array.Length;
 3260            if (Count >= arrayLength)
 3261            {
 3262                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 3263                System.Array.Resize(ref Array, arrayLength + howMuchToExpand);
 3264            }
 265
 3266            System.Array.Copy(Array, index, Array, index + 1, Count - index);
 3267            Array[index] = item;
 3268            ++Count;
 3269        }
 270
 271        /// <summary>
 272        ///     Insert an item into the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resiz
 273        /// </summary>
 274        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 275        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 276        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 277        public void InsertExpandNoClear(int index, T item, ArrayPool<T> pool)
 1278        {
 1279            T[] array = Array;
 1280            int count = Count;
 1281            int arrayLength = array.Length;
 282
 1283            if (Count >= arrayLength)
 1284            {
 1285                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1286                T[] newArray = pool.Get(arrayLength * 2);
 1287                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1288                pool.Return(array);
 1289                array = newArray;
 1290                Array = newArray;
 1291            }
 292
 1293            System.Array.Copy(array, index, array, index + 1, Count - index);
 1294            array[index] = item;
 1295            ++count;
 1296            Count = count;
 1297        }
 298
 299        /// <summary>
 300        ///     Insert an item into the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resiz
 301        /// </summary>
 302        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 303        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 304        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 305        public void InsertExpandClearOld(int index, T item, ArrayPool<T> pool)
 1306        {
 1307            T[] array = Array;
 1308            int count = Count;
 1309            int arrayLength = array.Length;
 310
 1311            if (Count >= arrayLength)
 1312            {
 1313                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1314                T[] newArray = pool.Get(arrayLength * 2);
 1315                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1316                System.Array.Clear(array, 0, arrayLength);
 1317                pool.Return(array);
 1318                array = newArray;
 1319                Array = newArray;
 1320            }
 321
 1322            System.Array.Copy(array, index, array, index + 1, Count - index);
 1323            array[index] = item;
 1324            ++count;
 1325            Count = count;
 1326        }
 327
 328        /// <summary>
 329        ///     Insert an item into the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resiz
 330        /// </summary>
 331        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 332        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 333        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 334        public void InsertExpandClearNew(int index, T item, ArrayPool<T> pool)
 1335        {
 1336            T[] array = Array;
 1337            int count = Count;
 1338            int arrayLength = array.Length;
 339
 1340            if (Count >= arrayLength)
 1341            {
 1342                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1343                T[] newArray = pool.Get(arrayLength * 2);
 1344                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1345                System.Array.Clear(newArray, arrayLength, arrayLength);
 1346                pool.Return(array);
 1347                array = newArray;
 1348                Array = newArray;
 1349            }
 350
 1351            System.Array.Copy(array, index, array, index + 1, Count - index);
 1352            array[index] = item;
 1353            ++count;
 1354            Count = count;
 1355        }
 356
 357        /// <summary>
 358        ///     Insert an item into the <see cref="SimpleList{T}" />, checking if <see cref="Array" /> needs to be resiz
 359        /// </summary>
 360        /// <param name="item">A typed <see cref="object" /> to insert.</param>
 361        /// <param name="index">The index in <see cref="Array" /> to add the <paramref name="item" /> at.</param>
 362        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 363        public void InsertExpandClearBoth(int index, T item, ArrayPool<T> pool)
 1364        {
 1365            T[] array = Array;
 1366            int count = Count;
 1367            int arrayLength = array.Length;
 368
 1369            if (Count >= arrayLength)
 1370            {
 1371                arrayLength = arrayLength == 0 ? 1 : arrayLength;
 1372                T[] newArray = pool.Get(arrayLength * 2);
 1373                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1374                System.Array.Clear(array, 0, arrayLength);
 1375                System.Array.Clear(newArray, arrayLength, arrayLength);
 1376                pool.Return(array);
 1377                array = newArray;
 1378                Array = newArray;
 1379            }
 380
 1381            System.Array.Copy(array, index, array, index + 1, Count - index);
 1382            array[index] = item;
 1383            ++count;
 1384            Count = count;
 1385        }
 386
 387        /// <summary>
 388        ///     Remove an item from the <see cref="SimpleList{T}" /> at a specific <paramref name="index" />.
 389        /// </summary>
 390        /// <param name="index">The target index.</param>
 391        public void RemoveAt(int index)
 23392        {
 23393            int newLength = Count - 1;
 394
 23395            Array[index] = default;
 396
 23397            if (index < Array.Length)
 23398            {
 23399                System.Array.Copy(Array, index + 1, Array, index, newLength - index);
 23400            }
 401
 23402            Count = newLength;
 23403        }
 404
 405        /// <summary>
 406        ///     Remove an item from the <see cref="SimpleList{T}" /> at a specific <paramref name="index" />, swapping i
 407        /// </summary>
 408        /// <param name="index">The target index.</param>
 409        public void RemoveAtSwapBack(int index)
 15410        {
 15411            int newLength = Count - 1;
 15412            T[] array = Array;
 15413            array[index] = array[newLength];
 15414            array[newLength] = default;
 415
 15416            Count = newLength;
 15417        }
 418
 419        /// <summary>
 420        ///     Remove the last element in the <see cref="SimpleList{T}" />.
 421        /// </summary>
 422        public void RemoveFromBack()
 1423        {
 1424            int newLength = Count - 1;
 1425            Array[newLength] = default;
 1426            Count = newLength;
 1427        }
 428
 429        /// <summary>
 430        ///     Resizes the <see cref="Array" />, ensuring there are the provided number of empty spots in it.
 431        /// </summary>
 432        /// <param name="numberToReserve">Number of desired empty spots.</param>
 433        public void Reserve(int numberToReserve)
 1434        {
 1435            int combinedLength = Count + numberToReserve;
 436
 1437            if (combinedLength > Array.Length)
 1438            {
 1439                System.Array.Resize(ref Array, combinedLength);
 1440            }
 1441        }
 442
 443        /// <summary>
 444        ///     Resizes the <see cref="Array" />, ensuring there are the provided number of empty spots in it.
 445        /// </summary>
 446        /// <param name="numberToReserve">Number of desired empty spots.</param>
 447        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 448        public void ReserveNoClear(int numberToReserve, ArrayPool<T> pool)
 1449        {
 1450            T[] array = Array;
 1451            int count = Count;
 1452            int arrayLength = array.Length;
 453
 1454            int combinedLength = count + numberToReserve;
 455
 1456            if (combinedLength > arrayLength)
 1457            {
 1458                T[] newArray = pool.Get(combinedLength);
 1459                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1460                pool.Return(array);
 1461                Array = newArray;
 1462            }
 1463        }
 464
 465        /// <summary>
 466        ///     Resizes the <see cref="Array" />, ensuring there are the provided number of empty spots in it. Clears th
 467        /// </summary>
 468        /// <param name="numberToReserve">Number of desired empty spots.</param>
 469        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 470        public void ReserveClearOld(int numberToReserve, ArrayPool<T> pool)
 1471        {
 1472            T[] array = Array;
 1473            int count = Count;
 1474            int arrayLength = array.Length;
 475
 1476            int combinedLength = count + numberToReserve;
 477
 1478            if (combinedLength > arrayLength)
 1479            {
 1480                T[] newArray = pool.Get(combinedLength);
 1481                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1482                System.Array.Clear(array, 0, arrayLength);
 1483                pool.Return(array);
 1484                Array = newArray;
 1485            }
 1486        }
 487
 488        /// <summary>
 489        ///     Resizes the <see cref="Array" />, ensuring there are the provided number of empty spots in it.  Clears u
 490        /// </summary>
 491        /// <param name="numberToReserve">Number of desired empty spots.</param>
 492        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 493        public void ReserveClearNew(int numberToReserve, ArrayPool<T> pool)
 1494        {
 1495            T[] array = Array;
 1496            int count = Count;
 1497            int arrayLength = array.Length;
 498
 1499            int combinedLength = count + numberToReserve;
 500
 1501            if (combinedLength > arrayLength)
 1502            {
 1503                T[] newArray = pool.Get(combinedLength);
 1504                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1505                System.Array.Clear(newArray, arrayLength, arrayLength);
 1506                pool.Return(array);
 1507                Array = newArray;
 1508            }
 1509        }
 510
 511        /// <summary>
 512        ///     Resizes the <see cref="Array" />, ensuring there are the provided number of empty spots in it. Clears ol
 513        /// </summary>
 514        /// <param name="numberToReserve">Number of desired empty spots.</param>
 515        /// <param name="pool">Pool to allocate the array from if resizing.</param>
 516        public void ReserveClearBoth(int numberToReserve, ArrayPool<T> pool)
 1517        {
 1518            T[] array = Array;
 1519            int count = Count;
 1520            int arrayLength = array.Length;
 521
 1522            int combinedLength = count + numberToReserve;
 523
 1524            if (combinedLength > arrayLength)
 1525            {
 1526                T[] newArray = pool.Get(combinedLength);
 1527                System.Array.Copy(array, 0, newArray, 0, arrayLength);
 1528                System.Array.Clear(array, 0, arrayLength);
 1529                System.Array.Clear(newArray, arrayLength, arrayLength);
 1530                pool.Return(array);
 1531                Array = newArray;
 1532            }
 1533        }
 534
 535        /// <summary>
 536        ///     Reverse the order of <see cref="Array"/>.
 537        /// </summary>
 538        public void Reverse()
 3539        {
 540            // ReSharper disable once TooWideLocalVariableScope
 541            T temporaryStorage;
 542
 3543            int lastIndex = Count - 1;
 3544            int middleIndex = Count / 2;
 545
 18546            for (int currentElementIndex = 0; currentElementIndex < middleIndex; currentElementIndex++)
 6547            {
 548                // Store the swap value
 6549                temporaryStorage = Array[currentElementIndex];
 6550                int swapElementIndex = lastIndex - currentElementIndex;
 551
 552                // Swap values
 6553                Array[currentElementIndex] = Array[swapElementIndex];
 6554                Array[swapElementIndex] = temporaryStorage;
 6555            }
 3556        }
 557    }
 558}