com.wallstop-studios.unity-helpers 1.0.1-rc01 → 1.0.1-rc02

package/Runtime/Core/Extension/DictionaryExtensions.cs

@@ -1,6 +1,7 @@
 namespace UnityHelpers.Core.Extension
 {
     using System;
+    using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.Linq;
 
@@ -8,6 +9,11 @@
     {
         public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key, Func<V> valueProducer)
         {
+            if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
+            {
+                return concurrentDictionary.GetOrAdd(key, static (_, existing) => existing(), valueProducer);
+            }
+
             if (dictionary.TryGetValue(key, out V result))
             {
                 return result;
@@ -15,8 +21,14 @@
 
             return dictionary[key] = valueProducer();
         }
+
         public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key, Func<K, V> valueProducer)
         {
+            if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
+            {
+                return concurrentDictionary.GetOrAdd(key, valueProducer);
+            }
+
             if (dictionary.TryGetValue(key, out V result))
             {
                 return result;
@@ -25,16 +37,17 @@
             return dictionary[key] = valueProducer(key);
         }
 
-        public static V GetOrElse<K, V>(this IDictionary<K, V> dictionary, K key, Func<V> valueProducer)
+        public static V GetOrElse<K, V>(this IReadOnlyDictionary<K, V> dictionary, K key, Func<V> valueProducer)
         {
             if (dictionary.TryGetValue(key, out V value))
             {
                 return value;
             }
+
             return valueProducer.Invoke();
         }
 
-        public static V GetOrElse<K, V>(this IDictionary<K, V> dictionary, K key, Func<K, V> valueProducer)
+        public static V GetOrElse<K, V>(this IReadOnlyDictionary<K, V> dictionary, K key, Func<K, V> valueProducer)
         {
             if (dictionary.TryGetValue(key, out V value))
             {
@@ -46,6 +59,11 @@
 
         public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key) where V : new()
         {
+            if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
+            {
+                return concurrentDictionary.AddOrUpdate(key, _ => new V(), (_, existing) => existing);
+            }
+
             if (dictionary.TryGetValue(key, out V result))
             {
                 return result;
@@ -54,43 +72,58 @@
             return dictionary[key] = new V();
         }
 
-        public static V GetOrElse<K, V>(this IDictionary<K, V> dictionary, K key, V value)
+        public static V GetOrElse<K, V>(this IReadOnlyDictionary<K, V> dictionary, K key, V value)
         {
             return GetOrElse(dictionary, key, () => value);
         }
 
-        public static bool Remove<K, V>(this IDictionary<K, V> dictionary, K key, out V value)
+        public static V AddOrUpdate<K, V>(
+            this IDictionary<K, V> dictionary, K key, Func<K, V> creator, Func<K, V, V> updater)
         {
-            if (dictionary.TryGetValue(key, out value))
+            if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
             {
-                return dictionary.Remove(key);
+                return concurrentDictionary.AddOrUpdate(key, creator, updater);
             }
-            return false;
-        }
 
-        public static V AddOrUpdate<K, V>(this IDictionary<K, V> dictionary, K key, Func<K, V> creator, Func<K, V, V> updater)
-        {
             V latest = dictionary.TryGetValue(key, out V value) ? updater(key, value) : creator(key);
             dictionary[key] = latest;
             return latest;
         }
 
-        public static Dictionary<K, V> Merge<K, V>(this IDictionary<K, V> lhs, IDictionary<K, V> rhs)
+        public static V TryAdd<K, V>(this IDictionary<K, V> dictionary, K key, Func<K, V> creator)
+        {
+            if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
+            {
+                return concurrentDictionary.AddOrUpdate(key, creator, (_, existing) => existing);
+            }
+
+            if (dictionary.TryGetValue(key, out V existing))
+            {
+                return existing;
+            }
+
+            V value = creator(key);
+            dictionary[key] = value;
+            return value;
+        }
+
+        public static Dictionary<K, V> Merge<K, V>(this IReadOnlyDictionary<K, V> lhs, IReadOnlyDictionary<K, V> rhs)
         {
-            Dictionary<K, V> result = new Dictionary<K, V>(lhs.Count);
-            foreach (KeyValuePair<K, V> kvp in lhs)
+            Dictionary<K, V> result = new();
+            if (0 < lhs.Count)
             {
-                if (rhs.ContainsKey(kvp.Key))
+                foreach (KeyValuePair<K, V> kvp in lhs)
                 {
-                    continue;
+                    result[kvp.Key] = kvp.Value;
                 }
-
-                result[kvp.Key] = kvp.Value;
             }
 
-            foreach (KeyValuePair<K, V> kvp in rhs)
+            if (0 < rhs.Count)
             {
-                result[kvp.Key] = kvp.Value;
+                foreach (KeyValuePair<K, V> kvp in rhs)
+                {
+                    result[kvp.Key] = kvp.Value;
+                }
             }
 
             return result;
@@ -103,38 +136,36 @@
         /// <param name="lhs">Basis dictionary.</param>
         /// <param name="rhs">Changed dictionary.</param>
         /// <returns>All elements of rhs that either don't exist in or are different from lhs</returns>
-        public static Dictionary<K, V> Difference<K, V>(this IDictionary<K, V> lhs, IDictionary<K, V> rhs)
+        public static Dictionary<K, V> Difference<K, V>(
+            this IReadOnlyDictionary<K, V> lhs, IReadOnlyDictionary<K, V> rhs)
         {
-            Dictionary<K, V> result = new Dictionary<K, V>(rhs.Count);
+            Dictionary<K, V> result = new(rhs.Count);
             foreach (KeyValuePair<K, V> kvp in rhs)
             {
                 K key = kvp.Key;
-                V existing;
-                if (lhs.TryGetValue(key, out existing))
+                if (lhs.TryGetValue(key, out V existing) && Equals(existing, kvp.Value))
                 {
-                    if (Equals(existing, kvp.Value))
-                    {
-                        continue;
-                    }
-
-                    result[key] = kvp.Value;
+                    continue;
                 }
+
+                result[key] = kvp.Value;
             }
 
             return result;
         }
 
-        public static Dictionary<V, K> Reverse<K, V>(this IDictionary<K, V> dictionary)
+        public static Dictionary<V, K> Reverse<K, V>(this IReadOnlyDictionary<K, V> dictionary)
         {
-            Dictionary<V, K> output = new Dictionary<V, K>(dictionary.Count);
+            Dictionary<V, K> output = new(dictionary.Count);
             foreach (KeyValuePair<K, V> entry in dictionary)
             {
                 output[entry.Value] = entry.Key;
             }
+
             return output;
         }
 
-        public static Dictionary<K, V> ToDictionary<K, V>(this IDictionary<K, V> dictionary)
+        public static Dictionary<K, V> ToDictionary<K, V>(this IReadOnlyDictionary<K, V> dictionary)
         {
             return new Dictionary<K, V>(dictionary);
         }
@@ -144,7 +175,13 @@
             return prettyMuchADictionary.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
         }
 
-        public static bool ContentEquals<K, V>(this IDictionary<K, V> dictionary, IDictionary<K, V> other)
+        public static Dictionary<K, V> ToDictionary<K, V>(this IEnumerable<(K, V)> prettyMuchADictionary)
+        {
+            return prettyMuchADictionary.ToDictionary(kvp => kvp.Item1, kvp => kvp.Item2);
+        }
+
+        public static bool ContentEquals<K, V>(
+            this IReadOnlyDictionary<K, V> dictionary, IReadOnlyDictionary<K, V> other)
         {
             if (ReferenceEquals(dictionary, other))
             {
@@ -170,4 +207,4 @@
             value = kvp.Value;
         }
     }
-}
+}

package/Tests/Runtime/Extensions/DictionaryExtensionTests.cs

@@ -0,0 +1,419 @@
+namespace UnityHelpers.Tests.Extensions
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core.Extension;
+    using NUnit.Framework;
+
+    public sealed class DictionaryExtensionTests
+    {
+        [Test]
+        public void GetOrAddValueProducer()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.GetOrAdd("test", () => 100);
+            Assert.AreEqual(100, value);
+            Assert.AreEqual(value, dictionary["test"]);
+
+            int newValue = dictionary.GetOrAdd(
+                "test", () =>
+                {
+                    Assert.Fail("Value Producer should not have been called!");
+                    return 200;
+                });
+            Assert.AreEqual(100, newValue);
+
+            newValue = dictionary.GetOrAdd("test2", () => 300);
+            Assert.AreEqual(300, newValue);
+            Assert.AreEqual(100, dictionary["test"]);
+        }
+
+        [Test]
+        public void GetOrAddKeyValueProducer()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.GetOrAdd(
+                "test", key =>
+                {
+                    Assert.AreEqual("test", key);
+                    return 100;
+                });
+            Assert.AreEqual(100, value);
+            Assert.AreEqual(value, dictionary["test"]);
+
+            int newValue = dictionary.GetOrAdd(
+                "test", key =>
+                {
+                    Assert.Fail("Value Producer should not have been called!");
+                    return 200;
+                });
+            Assert.AreEqual(100, newValue);
+
+            newValue = dictionary.GetOrAdd(
+                "test2", key =>
+                {
+                    Assert.AreEqual("test2", key);
+                    return 300;
+                });
+            Assert.AreEqual(300, newValue);
+            Assert.AreEqual(100, dictionary["test"]);
+        }
+
+        [Test]
+        public void GetOrElseValue()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.GetOrElse("test", 100);
+            Assert.AreEqual(100, value);
+            Assert.IsFalse(dictionary.ContainsKey("test"));
+            dictionary["test"] = 150;
+            value = dictionary.GetOrElse("test", 100);
+            Assert.AreEqual(150, value);
+            Assert.AreEqual(150, dictionary["test"]);
+        }
+
+        [Test]
+        public void GetOrElseValueProducer()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.GetOrElse("test", () => 100);
+            Assert.AreEqual(100, value);
+            Assert.IsFalse(dictionary.ContainsKey("test"));
+            dictionary["test"] = 150;
+            value = dictionary.GetOrElse(
+                "test", () =>
+                {
+                    Assert.Fail("Producer should not be called.");
+                    return 100;
+                });
+            Assert.AreEqual(150, value);
+            Assert.AreEqual(150, dictionary["test"]);
+        }
+
+        [Test]
+        public void GetOrElseKeyValueProducer()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.GetOrElse(
+                "test", key =>
+                {
+                    Assert.AreEqual("test", key);
+                    return 100;
+                });
+            Assert.AreEqual(100, value);
+            Assert.IsFalse(dictionary.ContainsKey("test"));
+            dictionary["test"] = 150;
+            value = dictionary.GetOrElse(
+                "test", () =>
+                {
+                    Assert.Fail("Producer should not be called.");
+                    return 100;
+                });
+            Assert.AreEqual(150, value);
+            Assert.AreEqual(150, dictionary["test"]);
+        }
+
+        [Test]
+        public void GetOrAddNew()
+        {
+            Dictionary<string, List<int>> dictionary = new();
+            List<int> value = dictionary.GetOrAdd("test");
+            Assert.IsNotNull(value);
+            Assert.AreEqual(value, dictionary["test"]);
+            value.Add(1);
+
+            List<int> newValue = dictionary.GetOrAdd("test");
+            Assert.AreEqual(value, newValue);
+        }
+
+        [Test]
+        public void GetOrElse()
+        {
+            IReadOnlyDictionary<string, int> dictionary = new Dictionary<string, int>();
+            int value = dictionary.GetOrElse("test", 100);
+            Assert.AreEqual(100, value);
+            Assert.AreEqual(0, dictionary.Count);
+        }
+
+        [Test]
+        public void AddOrUpdate()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.AddOrUpdate("test", key => 100, (key, existing) => existing + 1);
+            Assert.AreEqual(100, value);
+            Assert.AreEqual(100, dictionary["test"]);
+            int expected = value;
+            for (int i = 0; i < 100; ++i)
+            {
+                value = dictionary.AddOrUpdate("test", key => 100, (key, existing) => existing + 1);
+                Assert.AreEqual(++expected, value);
+                Assert.AreEqual(value, dictionary["test"]);
+            }
+
+            value = dictionary.AddOrUpdate("test2", key => 150, (key, existing) => existing + 1);
+            Assert.AreEqual(150, value);
+            Assert.AreEqual(150, dictionary["test2"]);
+            Assert.AreEqual(expected, dictionary["test"]);
+        }
+
+        [Test]
+        public void TryAdd()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.TryAdd(
+                "test", key =>
+                {
+                    Assert.AreEqual("test", key);
+                    return 150;
+                });
+            Assert.AreEqual(150, value);
+            Assert.AreEqual(value, dictionary["test"]);
+
+            value = dictionary.TryAdd(
+                "test", key =>
+                {
+                    Assert.Fail("Creator should not have been called.");
+                    return 200;
+                });
+            Assert.AreEqual(150, value);
+            Assert.AreEqual(value, dictionary["test"]);
+
+            value = dictionary.TryAdd(
+                "test2", key =>
+                {
+                    Assert.AreEqual("test2", key);
+                    return 350;
+                });
+            Assert.AreEqual(350, value);
+            Assert.AreEqual(value, dictionary["test2"]);
+            Assert.AreEqual(150, dictionary["test"]);
+        }
+
+        [Test]
+        public void Merge()
+        {
+            IReadOnlyDictionary<string, int> left = new Dictionary<string, int>()
+            {
+                ["only-on-left"] = 1,
+                ["both"] = 1,
+            };
+
+            IReadOnlyDictionary<string, int> right = new Dictionary<string, int>()
+            {
+                ["only-on-right"] = 3,
+                ["both"] = 2,
+            };
+
+            Dictionary<string, int> merged = left.Merge(right);
+            Assert.AreEqual(3, merged.Count);
+            Assert.AreEqual(1, merged["only-on-left"]);
+            Assert.AreEqual(2, merged["both"]);
+            Assert.AreEqual(3, merged["only-on-right"]);
+
+            merged = right.Merge(left);
+            Assert.AreEqual(3, merged.Count);
+            Assert.AreEqual(1, merged["only-on-left"]);
+            Assert.AreEqual(1, merged["both"]);
+            Assert.AreEqual(3, merged["only-on-right"]);
+
+            merged = left.Merge(left);
+            Assert.AreEqual(2, merged.Count);
+            Assert.AreEqual(1, merged["only-on-left"]);
+            Assert.AreEqual(1, merged["both"]);
+
+            merged = right.Merge(right);
+            Assert.AreEqual(2, merged.Count);
+            Assert.AreEqual(3, merged["only-on-right"]);
+            Assert.AreEqual(2, merged["both"]);
+        }
+
+        [Test]
+        public void Difference()
+        {
+            IReadOnlyDictionary<string, int> left = new Dictionary<string, int>()
+            {
+                ["only-on-left"] = 1,
+                ["both"] = 1,
+            };
+
+            IReadOnlyDictionary<string, int> right = new Dictionary<string, int>()
+            {
+                ["only-on-right"] = 3,
+                ["both"] = 2,
+            };
+
+            Dictionary<string, int> difference = left.Difference(right);
+            Assert.AreEqual(2, difference.Count);
+            Assert.AreEqual(2, difference["both"]);
+            Assert.AreEqual(3, difference["only-on-right"]);
+
+            difference = right.Difference(left);
+            Assert.AreEqual(2, difference.Count);
+            Assert.AreEqual(1, difference["both"]);
+            Assert.AreEqual(1, difference["only-on-left"]);
+
+            difference = left.Difference(left);
+            Assert.AreEqual(0, difference.Count);
+
+            difference = right.Difference(right);
+            Assert.AreEqual(0, difference.Count);
+        }
+
+        [Test]
+        public void Reverse()
+        {
+            IReadOnlyDictionary<string, int> initial = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["one-duplicate"] = 1,
+                ["two"] = 2,
+                ["three"] = 3,
+            };
+
+            Dictionary<int, string> reversed = initial.Reverse();
+            Assert.AreEqual(3, reversed.Count);
+            Assert.AreEqual("one-duplicate", reversed[1]);
+            Assert.AreEqual("two", reversed[2]);
+            Assert.AreEqual("three", reversed[3]);
+        }
+
+        [Test]
+        public void ToDictionaryFromDictionary()
+        {
+            IReadOnlyDictionary<string, int> initial = new Dictionary<string, int>()
+            {
+                ["test"] = 1,
+                ["test2"] = 2,
+            };
+
+            Dictionary<string, int> copy = initial.ToDictionary();
+            Assert.AreEqual(2, copy.Count);
+            Assert.AreEqual(1, copy["test"]);
+            Assert.AreEqual(2, copy["test2"]);
+        }
+
+        [Test]
+        public void ToDictionaryFromEnumerableKeyValuePair()
+        {
+            IEnumerable<KeyValuePair<string, int>> initial = new Dictionary<string, int>()
+            {
+                ["test"] = 1,
+                ["test2"] = 2,
+            };
+
+            Dictionary<string, int> copy = initial.ToDictionary();
+            Assert.AreEqual(2, copy.Count);
+            Assert.AreEqual(1, copy["test"]);
+            Assert.AreEqual(2, copy["test2"]);
+        }
+
+        [Test]
+        public void ToDictionaryFromEnumerableValueTuple()
+        {
+            IEnumerable<(string, int)> initial = new Dictionary<string, int>()
+            {
+                ["test"] = 1,
+                ["test2"] = 2,
+            }.Select(kvp => (kvp.Key, kvp.Value));
+
+            Dictionary<string, int> copy = initial.ToDictionary();
+            Assert.AreEqual(2, copy.Count);
+            Assert.AreEqual(1, copy["test"]);
+            Assert.AreEqual(2, copy["test2"]);
+        }
+
+        [Test]
+        public void ContentEqualsSame()
+        {
+            IReadOnlyDictionary<string, int> left = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 2,
+            };
+
+            IReadOnlyDictionary<string, int> right = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 2,
+            };
+
+            Assert.IsTrue(left.ContentEquals(right));
+            Assert.IsTrue(left.ContentEquals(left));
+            Assert.IsTrue(right.ContentEquals(left));
+            Assert.IsTrue(right.ContentEquals(right));
+        }
+
+        [Test]
+        public void ContentEqualsDifferentCount()
+        {
+            IReadOnlyDictionary<string, int> left = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 2,
+            };
+
+            IReadOnlyDictionary<string, int> right = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 2,
+                ["three"] = 3,
+            };
+
+            Assert.IsFalse(left.ContentEquals(right));
+            Assert.IsTrue(left.ContentEquals(left));
+            Assert.IsFalse(right.ContentEquals(left));
+            Assert.IsTrue(right.ContentEquals(right));
+        }
+
+        [Test]
+        public void ContentEqualsDifferentValuesSameSize()
+        {
+            IReadOnlyDictionary<string, int> left = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 2,
+            };
+
+            IReadOnlyDictionary<string, int> right = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 20_000,
+            };
+
+            Assert.IsFalse(left.ContentEquals(right));
+            Assert.IsTrue(left.ContentEquals(left));
+            Assert.IsFalse(right.ContentEquals(left));
+            Assert.IsTrue(right.ContentEquals(right));
+        }
+
+        [Test]
+        public void ContentEqualsDifferentKeysSameSize()
+        {
+            IReadOnlyDictionary<string, int> left = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 2,
+            };
+
+            IReadOnlyDictionary<string, int> right = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["three"] = 2,
+            };
+
+            Assert.IsFalse(left.ContentEquals(right));
+            Assert.IsTrue(left.ContentEquals(left));
+            Assert.IsFalse(right.ContentEquals(left));
+            Assert.IsTrue(right.ContentEquals(right));
+        }
+
+        [Test]
+        public void Deconstruct()
+        {
+            new KeyValuePair<string, int>("one", 1).Deconstruct(out string key, out int value);
+            Assert.AreEqual("one", key);
+            Assert.AreEqual(1, value);
+        }
+    }
+}

package/Tests/Runtime/Extensions/DictionaryExtensionTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 31368b65c8f54bed82bc38001ab86cba
+timeCreated: 1720405525

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "1.0.1-rc01",
+  "version": "1.0.1-rc02",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {