< Summary

Class:GDX.SimpleListExtensions
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/SimpleListExtensions.cs
Covered lines:126
Uncovered lines:22
Coverable lines:148
Total lines:391
Line coverage:85.1% (126 of 148)
Covered branches:0
Total branches:0
Covered methods:12
Total methods:14
Method coverage:85.7% (12 of 14)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
AddUncheckedUniqueItem[T](...)0%220100%
AddUncheckedUniqueReference[T](...)0%220100%
AddWithExpandCheckUniqueItem[T](...)0%220100%
AddWithExpandCheckUniqueValue[T](...)0%12300%
AddWithExpandCheckUniqueReference[T](...)0%220100%
ContainsItem[T](...)0%330100%
ContainsValue[T](...)0%12300%
ContainsReference[T](...)0%330100%
RemoveFirstItem[T](...)0%330100%
RemoveFirstReference[T](...)0%330100%
RemoveItems[T](...)0%330100%
RemoveReferences[T](...)0%330100%
RemoveLastItem[T](...)0%330100%
RemoveLastReference[T](...)0%330100%

File(s)

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

#LineLine coverage
 1// Copyright (c) 2020-2022 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using System.Runtime.CompilerServices;
 7using GDX.Collections.Generic;
 8
 9namespace GDX
 10{
 11    /// <summary>
 12    ///     <see cref="GDX.Collections.Generic.SimpleList{T}" /> Based Extension Methods
 13    /// </summary>
 14    /// <remarks>
 15    ///     Methods found in this extensions class are less performant then the included methods in
 16    ///     <see cref="GDX.Collections.Generic.SimpleList{T}" />. They are seperated out to clearly delineate this
 17    ///     performance regression.
 18    /// </remarks>
 19    public static class SimpleListExtensions
 20    {
 21        /// <summary>
 22        ///     Add an item to the <see cref="SimpleList{T}" /> without checking the internal size,
 23        ///     making sure that the item is not already contained in the <see cref="SimpleList{T}" />.
 24        /// </summary>
 25        /// <param name="targetSimpleList">The target <see cref="SimpleList{T}" /> to add to.</param>
 26        /// <param name="targetItem">The target class object to add.</param>
 27        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 28        /// <returns>true/false if the operation was able to add the item successfully.</returns>
 29        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 30        public static bool AddUncheckedUniqueItem<T>(ref this SimpleList<T> targetSimpleList, T targetItem)
 31            where T : class
 932        {
 933            if (targetSimpleList.ContainsItem(targetItem))
 134            {
 135                return false;
 36            }
 37
 838            targetSimpleList.AddUnchecked(targetItem);
 739            return true;
 840        }
 41
 42        /// <summary>
 43        ///     Add an object reference to the <see cref="SimpleList{T}" /> without checking the internal size,
 44        ///     making sure that the reference is not already contained in the <see cref="SimpleList{T}" />.
 45        ///     Does not prevent addition of different objects for which Equals returns true.
 46        /// </summary>
 47        /// <param name="targetSimpleList">The target <see cref="SimpleList{T}" /> to add to.</param>
 48        /// <param name="targetReference">The target class object to add.</param>
 49        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 50        /// <returns>true/false if the operation was able to add the reference successfully.</returns>
 51        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 52        public static bool AddUncheckedUniqueReference<T>(ref this SimpleList<T> targetSimpleList, T targetReference)
 53            where T : class
 954        {
 955            if (targetSimpleList.ContainsReference(targetReference))
 156            {
 157                return false;
 58            }
 59
 860            targetSimpleList.AddUnchecked(targetReference);
 761            return true;
 862        }
 63
 64        /// <summary>
 65        ///     Add an item to the <see cref="SimpleList{T}" /> with checking the internal size (expanding as necessary)
 66        ///     making sure that the item is not already contained in the <see cref="SimpleList{T}" />.
 67        /// </summary>
 68        /// <param name="targetSimpleList">The target <see cref="SimpleList{T}" /> to add to.</param>
 69        /// <param name="targetItem">The target class object to add.</param>
 70        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 71        /// <returns>true/false if the operation was able to add the item successfully.</returns>
 72        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 73        public static bool AddWithExpandCheckUniqueItem<T>(ref this SimpleList<T> targetSimpleList, T targetItem)
 74            where T : class
 875        {
 876            if (targetSimpleList.ContainsItem(targetItem))
 177            {
 178                return false;
 79            }
 80
 781            targetSimpleList.AddWithExpandCheck(targetItem);
 782            return true;
 883        }
 84
 85        /// <summary>
 86        ///     Add an item to the <see cref="SimpleList{T}" /> with checking the internal size (expanding as necessary)
 87        ///     making sure that the item is not already contained in the <see cref="SimpleList{T}" />.
 88        /// </summary>
 89        /// <param name="targetSimpleList">The target <see cref="SimpleList{T}" /> to add to.</param>
 90        /// <param name="targetItem">The target class object to add.</param>
 91        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 92        /// <returns>true/false if the operation was able to add the item successfully.</returns>
 93        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 94        public static bool AddWithExpandCheckUniqueValue<T>(ref this SimpleList<T> targetSimpleList, T targetItem)
 95            where T : IEquatable<T>
 096        {
 097            int count = targetSimpleList.Count;
 098            for (int i = 0; i < count; i++)
 099            {
 0100                if (targetSimpleList.Array[i].Equals(targetItem))
 0101                {
 0102                    return false;
 103                }
 0104            }
 105
 0106            targetSimpleList.AddWithExpandCheck(targetItem);
 0107            return true;
 0108        }
 109
 110        /// <summary>
 111        ///     Add an object reference to the <see cref="SimpleList{T}" /> with checking the internal size (expanding a
 112        ///     making sure that the reference is not already contained in the <see cref="SimpleList{T}" />.
 113        ///     Does not prevent addition of different objects for which Equals returns true.
 114        /// </summary>
 115        /// <param name="targetSimpleList">The target <see cref="SimpleList{T}" /> to add to.</param>
 116        /// <param name="targetReference">The target class object to add.</param>
 117        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 118        /// <returns>true/false if the operation was able to add the reference successfully.</returns>
 119        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 120        public static bool AddWithExpandCheckUniqueReference<T>(ref this SimpleList<T> targetSimpleList, T targetReferen
 121            where T : class
 8122        {
 8123            if (targetSimpleList.ContainsReference(targetReference))
 1124            {
 1125                return false;
 126            }
 127
 7128            targetSimpleList.AddWithExpandCheck(targetReference);
 7129            return true;
 8130        }
 131
 132        /// <summary>
 133        ///     <para>Does <paramref name="targetSimpleList" /> contain <paramref name="targetItem" />?</para>
 134        /// </summary>
 135        /// <remarks>Avoids using <see cref="System.Collections.Generic.EqualityComparer{T}" />.</remarks>
 136        /// <param name="targetSimpleList">The <see cref="SimpleList{T}" /> to look in.</param>
 137        /// <param name="targetItem">The target class object to look for.</param>
 138        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 139        /// <returns>true/false</returns>
 140        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 141        public static bool ContainsItem<T>(ref this SimpleList<T> targetSimpleList, T targetItem) where T : class
 22142        {
 22143            int length = targetSimpleList.Count;
 22144            T[] array = targetSimpleList.Array;
 145
 96146            for (int i = 0; i < length; i++)
 32147            {
 32148                if (array[i] == targetItem)
 6149                {
 6150                    return true;
 151                }
 26152            }
 153
 16154            return false;
 22155        }
 156
 157        /// <summary>
 158        ///     <para>Does <paramref name="targetSimpleList" /> contain <paramref name="targetItem" />?</para>
 159        /// </summary>
 160        /// <remarks>Avoids using <see cref="System.Collections.Generic.EqualityComparer{T}" />.</remarks>
 161        /// <param name="targetSimpleList">The <see cref="SimpleList{T}" /> to look in.</param>
 162        /// <param name="targetItem">The target class object to look for.</param>
 163        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 164        /// <returns>true/false</returns>
 165        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 166        public static bool ContainsValue<T>(ref this SimpleList<T> targetSimpleList, T targetItem) where T : IEquatable<
 0167        {
 0168            int length = targetSimpleList.Count;
 0169            T[] array = targetSimpleList.Array;
 170
 0171            for (int i = 0; i < length; i++)
 0172            {
 0173                if (array[i].Equals(targetItem))
 0174                {
 0175                    return true;
 176                }
 0177            }
 178
 0179            return false;
 0180        }
 181
 182        /// <summary>
 183        ///     <para>Does <paramref name="targetSimpleList" /> contain <paramref name="targetItem" />?</para>
 184        /// </summary>
 185        /// <remarks>Ignores equality check and end up comparing object pointers.</remarks>
 186        /// <param name="targetSimpleList">The <see cref="SimpleList{T}" /> to look in.</param>
 187        /// <param name="targetItem">The target class object to look for.</param>
 188        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 189        /// <returns>true/false</returns>
 190        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 191        public static bool ContainsReference<T>(ref this SimpleList<T> targetSimpleList, T targetItem) where T : class
 22192        {
 22193            int length = targetSimpleList.Count;
 22194            T[] array = targetSimpleList.Array;
 195
 96196            for (int i = 0; i < length; i++)
 32197            {
 198#pragma warning disable
 199                // ReSharper disable All
 32200                if ((System.Object)array[i] == (System.Object)targetItem)
 6201                {
 6202                    return true;
 203                }
 204                // ReSharper restore All
 205#pragma warning restore
 26206            }
 207
 16208            return false;
 22209        }
 210
 211        /// <summary>
 212        ///     <para>Removes the first <paramref name="targetItem" /> from the provided <paramref name="targetSimpleLis
 213        /// </summary>
 214        /// <remarks>Avoids using <see cref="System.Collections.Generic.EqualityComparer{T}" />.</remarks>
 215        /// <param name="targetSimpleList">The target <see cref="SimpleList{T}" />.</param>
 216        /// <param name="targetItem">The target object to remove from the <paramref name="targetSimpleList" />.</param>
 217        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 218        /// <returns>true/false if an item was removed.</returns>
 219        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 220        public static bool RemoveFirstItem<T>(ref this SimpleList<T> targetSimpleList, T targetItem) where T : class
 2221        {
 2222            int length = targetSimpleList.Count;
 2223            T[] array = targetSimpleList.Array;
 224
 18225            for (int i = 0; i < length; i++)
 8226            {
 227                // Skip to next if its not what we are looking for
 8228                if (array[i] != targetItem)
 7229                {
 7230                    continue;
 231                }
 232
 1233                targetSimpleList.RemoveAt(i);
 1234                return true;
 235            }
 236
 1237            return false;
 2238        }
 239
 240        /// <summary>
 241        ///     <para>Removes the first <paramref name="targetReference" /> from the provided <paramref name="targetSimp
 242        ///     Only removes direct object references, i.e. equivalent strings at different memory addresses would not b
 243        /// </summary>
 244        /// <remarks>Avoids using <see cref="System.Collections.Generic.EqualityComparer{T}" />.</remarks>
 245        /// <param name="targetSimpleList">The target <see cref="SimpleList{T}" />.</param>
 246        /// <param name="targetReference">The target object to remove from the <paramref name="targetSimpleList" />.</pa
 247        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 248        /// <returns>true/false if an object reference was removed.</returns>
 249        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 250        public static bool RemoveFirstReference<T>(ref this SimpleList<T> targetSimpleList, T targetReference) where T :
 2251        {
 2252            int length = targetSimpleList.Count;
 2253            T[] array = targetSimpleList.Array;
 254
 18255            for (int i = 0; i < length; i++)
 8256            {
 257#pragma warning disable
 258                // ReSharper disable All
 8259                if ((System.Object)array[i] == (System.Object)targetReference)
 1260                {
 1261                    targetSimpleList.RemoveAt(i);
 1262                    return true;
 263                }
 264                // ReSharper restore All
 265#pragma warning restore
 7266            }
 267
 1268            return false;
 2269        }
 270
 271        /// <summary>
 272        ///     <para>Removes all <paramref name="targetItem" /> from the provided <paramref name="targetSimpleList" />.
 273        /// </summary>
 274        /// <remarks>Avoids using <see cref="System.Collections.Generic.EqualityComparer{T}" />.</remarks>
 275
 276        /// <param name="targetSimpleList">The target <see cref="SimpleList{T}" />.</param>
 277        /// <param name="targetItem">The item to remove from the <paramref name="targetSimpleList" />.</param>
 278        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 279        /// <returns>true/false if items were removed.</returns>
 280        public static bool RemoveItems<T>(ref this SimpleList<T> targetSimpleList, T targetItem) where T : class
 1281        {
 1282            int length = targetSimpleList.Count;
 1283            T[] array = targetSimpleList.Array;
 1284            bool removedItems = false;
 285
 14286            for (int i = length - 1; i >= 0; i--)
 6287            {
 288                // Skip to next if its not what we are looking for
 6289                if (array[i] != targetItem)
 4290                {
 4291                    continue;
 292                }
 293
 2294                targetSimpleList.RemoveAt(i);
 2295                removedItems = true;
 2296            }
 297
 1298            return removedItems;
 1299        }
 300
 301        /// <summary>
 302        ///     <para>Removes all instances of references to <paramref name="targetReference" /> from the provided <para
 303        ///     Only removes direct object references, i.e. equivalent strings at different memory addresses would not b
 304        /// </summary>
 305        /// <remarks>Avoids using <see cref="System.Collections.Generic.EqualityComparer{T}" />.</remarks>
 306
 307        /// <param name="targetSimpleList">The target <see cref="SimpleList{T}" />.</param>
 308        /// <param name="targetReference">The object reference to remove from the <paramref name="targetSimpleList" />.<
 309        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 310        /// <returns>true/false if any references were removed.</returns>
 311        public static bool RemoveReferences<T>(ref this SimpleList<T> targetSimpleList, T targetReference) where T : cla
 1312        {
 1313            int length = targetSimpleList.Count;
 1314            T[] array = targetSimpleList.Array;
 1315            bool removedItems = false;
 316
 14317            for (int i = length - 1; i >= 0; i--)
 6318            {
 319#pragma warning disable
 320                // ReSharper disable All
 6321                if ((System.Object)array[i] == (System.Object)targetReference)
 2322                {
 2323                    targetSimpleList.RemoveAt(i);
 2324                    removedItems = true;
 2325                }
 326                // ReSharper restore All
 327#pragma warning restore
 6328            }
 329
 1330            return removedItems;
 1331        }
 332
 333        /// <summary>
 334        ///     <para>Removes the last <paramref name="targetItem" /> from the provided <paramref name="targetSimpleList
 335        /// </summary>
 336        /// <remarks>Avoids using <see cref="System.Collections.Generic.EqualityComparer{T}" />.</remarks>
 337        /// <param name="targetSimpleList">The target <see cref="SimpleList{T}" />.</param>
 338        /// <param name="targetItem">The target object to remove from the <paramref name="targetSimpleList" />.</param>
 339        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 340        /// <returns>true/false if an item was removed.</returns>
 341        public static bool RemoveLastItem<T>(ref this SimpleList<T> targetSimpleList, T targetItem) where T : class
 2342        {
 2343            int length = targetSimpleList.Count;
 2344            T[] array = targetSimpleList.Array;
 345
 18346            for (int i = length - 1; i >= 0; i--)
 8347            {
 348                // Skip to next if its not what we are looking for
 8349                if (array[i] != targetItem)
 7350                {
 7351                    continue;
 352                }
 353
 1354                targetSimpleList.RemoveAt(i);
 1355                return true;
 356            }
 357
 1358            return false;
 2359        }
 360
 361        /// <summary>
 362        ///     <para>Removes the last reference to <paramref name="targetReference" /> from the provided <paramref name
 363        ///     Only removes direct object references, i.e. equivalent strings at different memory addresses would not b
 364        /// </summary>
 365        /// <remarks>Avoids using <see cref="System.Collections.Generic.EqualityComparer{T}" />.</remarks>
 366        /// <param name="targetSimpleList">The target <see cref="SimpleList{T}" />.</param>
 367        /// <param name="targetReference">The target object reference to remove from the <paramref name="targetSimpleLis
 368        /// <typeparam name="T">The type of the <see cref="SimpleList{T}" />.</typeparam>
 369        /// <returns>true/false if an object reference was removed.</returns>
 370        public static bool RemoveLastReference<T>(ref this SimpleList<T> targetSimpleList, T targetReference) where T : 
 2371        {
 2372            int length = targetSimpleList.Count;
 2373            T[] array = targetSimpleList.Array;
 374
 18375            for (int i = length - 1; i >= 0; i--)
 8376            {
 377#pragma warning disable
 378                // ReSharper disable All
 8379                if ((System.Object)array[i] == (System.Object)targetReference)
 1380                {
 1381                    targetSimpleList.RemoveAt(i);
 1382                    return true;
 383                }
 384                // ReSharper restore All
 385#pragma warning restore
 7386            }
 387
 1388            return false;
 2389        }
 390    }
 391}