Update file(s) "Packages/unity-utils/." from "unity-korea-community/unity-utils"

KorStrix · KorStrix · commit 471484e2e8c0 · 2021-05-31T15:27:35.000Z
diff --git a/Runtime/Extension/CollectionExtension.cs b/Runtime/Extension/CollectionExtension.cs
@@ -39,7 +39,9 @@ public static HashSet<T> ToHashSet<T>(this IEnumerable<T> target)
         public static IEnumerable<T> Foreach<T>(this IEnumerable<T> target, System.Action<T> OnEach)
         {
             foreach (var item in target)
+            {
                 OnEach(item);
+            }
 
             return target;
         }
diff --git a/Runtime/SimplePool.cs b/Runtime/SimplePool.cs
@@ -14,13 +14,25 @@ public class SimplePool<T>
         protected T _originItem { get; private set; }
         protected Func<T, T> _OnCreateInstance;
 
+        public SimplePool(T originItem)
+        {
+            _OnCreateInstance = (origin) => Activator.CreateInstance<T>();
+            Init(originItem, 0);
+        }
+
         public SimplePool(T originItem, int initializeSize = 0)
         {
             _OnCreateInstance = (origin) => Activator.CreateInstance<T>();
             Init(originItem, initializeSize);
         }
 
-        public SimplePool(Func<T> onCreateInstance, int initializeSize = 0)
+        public SimplePool(Func<T> onCreateInstance)
+        {
+            _OnCreateInstance = (origin) => onCreateInstance();
+            Init(onCreateInstance(), 0);
+        }
+
+        public SimplePool(Func<T> onCreateInstance, int initializeSize)
         {
             _OnCreateInstance = (origin) => onCreateInstance();
             Init(onCreateInstance(), initializeSize);
diff --git a/Runtime/SingletonComponentBase.cs b/Runtime/SingletonComponentBase.cs
@@ -22,8 +22,8 @@ public static T instance
             }
         }
 
-        private static T s_instance;
-        protected static bool s_isQuitApp { get; private set; } = false;
+        private static T s_instance { get; set; }
+        private static bool s_isQuitApp { get; set; }
 
         void Awake()
         {
diff --git a/Runtime/StateMachineGeneric.cs b/Runtime/StateMachineGeneric.cs
@@ -27,7 +27,7 @@ public enum CommandType
         }
 
         [System.Serializable]
-        public struct Command
+        public struct Command : System.IEquatable<Command>
         {
             public CommandType commandType { get; private set; }
             public STATE_ID stateID { get; private set; }
@@ -43,6 +43,16 @@ public Command(CommandType commandType, STATE_ID stateID)
                 this.commandType = commandType;
                 this.stateID = stateID;
             }
+
+            public bool Equals(Command other)
+            {
+                if (commandType.Equals(other.commandType) == false)
+                {
+                    return false;
+                }
+
+                return stateID.Equals(other.stateID);
+            }
         }
 
         public event System.Action<STATE_ID, TSTATE> OnChangeState;
diff --git a/Runtime/Unsubscriber.cs b/Runtime/Unsubscriber.cs
@@ -10,7 +10,14 @@ public class Unsubscriber<T> : IDisposable
         private IObserver<T> _observer;
         private Action<Unsubscriber<T>> _onDisplose;
 
-        public void Reset(HashSet<IObserver<T>> observers, IObserver<T> observer, Action<Unsubscriber<T>> onDisplose = null)
+        public void Reset(HashSet<IObserver<T>> observers, IObserver<T> observer)
+        {
+            this._observers = observers;
+            this._observer = observer;
+            this._onDisplose = null;
+        }
+
+        public void Reset(HashSet<IObserver<T>> observers, IObserver<T> observer, Action<Unsubscriber<T>> onDisplose)
         {
             this._observers = observers;
             this._observer = observer;
diff --git a/Tests/Runtime/CollectionExtensionTests.cs b/Tests/Runtime/CollectionExtensionTests.cs
@@ -8,10 +8,10 @@ public class CollectionExtensionTests
     [Test]
     public void ToStringCollectionExample()
     {
-        string list = new List<int>() { 1, 2, 3, 4, 5 }.ToStringCollection();
+        string list = new List<int> { 1, 2, 3, 4, 5 }.ToStringCollection();
         Debug.Log(list);
 
-        string dictionary = new Dictionary<string, int>()
+        string dictionary = new Dictionary<string, int>
         {
             {"one", 1}, {"two", 2}, {"three", 3},
         }.ToStringCollection();
@@ -21,14 +21,14 @@ public void ToStringCollectionExample()
     [Test]
     public void ForeachExample()
     {
-        int[] originArray = new int[] { 1, 2, 3, 4, 5 };
+        int[] originArray = new[] { 1, 2, 3, 4, 5 };
         originArray.Foreach(number => Debug.Log(number));
     }
 
     [Test]
     public void DequeueExample()
     {
-        List<int> list = new List<int>() { 1, 2, 3 };
+        List<int> list = new List<int> { 1, 2, 3 };
         Assert.AreEqual(list.Dequeue(), 1);
         Assert.AreEqual(list.Count, 2);
 
@@ -42,7 +42,7 @@ public void DequeueExample()
     [Test]
     public void PopExample()
     {
-        List<int> list = new List<int>() { 1, 2, 3 };
+        List<int> list = new List<int> { 1, 2, 3 };
         Assert.AreEqual(list.Pop(), 3);
         Assert.AreEqual(list.Count, 2);
 
diff --git a/Tests/Runtime/DataSenderTests.cs b/Tests/Runtime/DataSenderTests.cs
@@ -5,7 +5,7 @@
 
 public class DataSenderTests
 {
-    public struct TestData
+    public class TestData
     {
         public string stringData;
         public int numberData;
@@ -26,8 +26,15 @@ public class TestReceiver : MonoBehaviour, IObserver<TestData>
     {
         public TestData data { get; private set; }
 
-        public void OnCompleted() { }
-        public void OnError(Exception error) { }
+        public void OnCompleted()
+        {
+            // Do nothing because test
+        }
+
+        public void OnError(Exception error)
+        {
+            // Do nothing because test
+        }
 
         public void OnNext(TestData value)
         {
diff --git a/Tests/Runtime/RandomExtensionTests.cs b/Tests/Runtime/RandomExtensionTests.cs
@@ -9,7 +9,7 @@ public class RandomExtensionTests
     [Test]
     public void RandomWorks()
     {
-        int[] numbers = new int[] { 1, 2, 3, 4, 5 };
+        int[] numbers = new[] { 1, 2, 3, 4, 5 };
         Debug.Log(numbers.Random());
         Debug.Log(numbers.Random());
     }
@@ -30,14 +30,14 @@ public Item(string name, int percent)
     public void RandomPercent()
     {
         // Arrange
-        Item[] items = new Item[] {
+        Item[] items = new[] {
             new Item("normal sword", 80),
             new Item("epic sword", 19),
             new Item("regendary sword", 1),
         };
 
         int gotchaCount = 1000;
-        Dictionary<string, int> hasItemCount = new Dictionary<string, int>()
+        Dictionary<string, int> hasItemCount = new Dictionary<string, int>
         {
             {"normal", 0}, {"epic", 0}, {"regendary", 0}
         };
@@ -61,20 +61,19 @@ public void RandomPercent()
         for (int i = 0; i < items.Length; i++)
         {
             Item item = items[i];
-            float errorRate = 0.2f;
+            float errorRate = 0.5f; // 랜덤에 걸리지 않기 위해 범위를 많이 넓힘
             int expectCount = (int)(gotchaCount * (item.percent / 100f));
             int errorRange = (int)(expectCount * errorRate);
             KeyValuePair<string, int> itemCount = hasItemCount.First(hasItem => item.name.StartsWith(hasItem.Key));
 
-            // 대부분 통과하나, 랜덤 확률에 의해 가끔 실패함..
-            // Assert.GreaterOrEqual(itemCount.Value, expectCount - errorRange);
+            Assert.GreaterOrEqual(itemCount.Value, expectCount - errorRange);
         }
     }
 
     [Test]
     public void RandomFilter()
     {
-        int[] numbers = new int[] { 1, 2, 3, 4, 5 };
+        int[] numbers = new[] { 1, 2, 3, 4, 5 };
         HashSet<int> set = new HashSet<int>();
 
         for (int i = 0; i < numbers.Length; i++)
diff --git a/Tests/Runtime/SimplePoolTests.cs b/Tests/Runtime/SimplePoolTests.cs
@@ -8,7 +8,7 @@ public class SimplePoolTests
 {
     public class SimplePoolTarget
     {
-        public static int instanceCount { get; private set; } = 0;
+        public static int instanceCount { get; private set; }
 
         public static void Reset_InstanceCount()
         {
@@ -17,13 +17,13 @@ public static void Reset_InstanceCount()
 
         static public class Factory
         {
-            static public SimplePoolTarget CreateInstance()
+            static public SimplePoolTarget CreateInstance_FromFactory()
             {
                 return new SimplePoolTarget() { isCreateFromFactory = true };
             }
         }
 
-        public bool isCreateFromFactory { get; private set; } = false;
+        public bool isCreateFromFactory { get; private set; }
 
         public SimplePoolTarget()
         {
@@ -69,13 +69,13 @@ public void 사용예시()
 
     public class PoolEx : SimplePool<SimplePoolTarget>
     {
-        public PoolEx(int initializeSize = 0) : base(new SimplePoolTarget(), initializeSize)
+        public PoolEx(int initializeSize) : base(new SimplePoolTarget(), initializeSize)
         {
         }
 
         protected override SimplePoolTarget OnRequireNewInstance(SimplePoolTarget originItem)
         {
-            return SimplePoolTarget.Factory.CreateInstance();
+            return SimplePoolTarget.Factory.CreateInstance_FromFactory();
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,9 @@ public static HashSet<T> ToHashSet<T>(this IEnumerable<T> target)`
`39`	`39`	`public static IEnumerable<T> Foreach<T>(this IEnumerable<T> target, System.Action<T> OnEach)`
`40`	`40`	`{`
`41`	`41`	`foreach (var item in target)`
	`42`	`+ {`
`42`	`43`	`OnEach(item);`
	`44`	`+ }`
`43`	`45`
`44`	`46`	`return target;`
`45`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,8 +22,8 @@ public static T instance`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`		`- private static T s_instance;`
`26`		`- protected static bool s_isQuitApp { get; private set; } = false;`
	`25`	`+ private static T s_instance { get; set; }`
	`26`	`+ private static bool s_isQuitApp { get; set; }`
`27`	`27`
`28`	`28`	`void Awake()`
`29`	`29`	`{`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public enum CommandType`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`[System.Serializable]`
`30`		`- public struct Command`
	`30`	`+ public struct Command : System.IEquatable<Command>`
`31`	`31`	`{`
`32`	`32`	`public CommandType commandType { get; private set; }`
`33`	`33`	`public STATE_ID stateID { get; private set; }`
`@@ -43,6 +43,16 @@ public Command(CommandType commandType, STATE_ID stateID)`
`43`	`43`	`this.commandType = commandType;`
`44`	`44`	`this.stateID = stateID;`
`45`	`45`	`}`
	`46`	`+`
	`47`	`+ public bool Equals(Command other)`
	`48`	`+ {`
	`49`	`+ if (commandType.Equals(other.commandType) == false)`
	`50`	`+ {`
	`51`	`+ return false;`
	`52`	`+ }`
	`53`	`+`
	`54`	`+ return stateID.Equals(other.stateID);`
	`55`	`+ }`
`46`	`56`	`}`
`47`	`57`
`48`	`58`	`public event System.Action<STATE_ID, TSTATE> OnChangeState;`
Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,10 @@ public class CollectionExtensionTests`
`8`	`8`	`[Test]`
`9`	`9`	`public void ToStringCollectionExample()`
`10`	`10`	`{`
`11`		`- string list = new List<int>() { 1, 2, 3, 4, 5 }.ToStringCollection();`
	`11`	`+ string list = new List<int> { 1, 2, 3, 4, 5 }.ToStringCollection();`
`12`	`12`	`Debug.Log(list);`
`13`	`13`
`14`		`- string dictionary = new Dictionary<string, int>()`
	`14`	`+ string dictionary = new Dictionary<string, int>`
`15`	`15`	`{`
`16`	`16`	`{"one", 1}, {"two", 2}, {"three", 3},`
`17`	`17`	`}.ToStringCollection();`
`@@ -21,14 +21,14 @@ public void ToStringCollectionExample()`
`21`	`21`	`[Test]`
`22`	`22`	`public void ForeachExample()`
`23`	`23`	`{`
`24`		`- int[] originArray = new int[] { 1, 2, 3, 4, 5 };`
	`24`	`+ int[] originArray = new[] { 1, 2, 3, 4, 5 };`
`25`	`25`	`originArray.Foreach(number => Debug.Log(number));`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`[Test]`
`29`	`29`	`public void DequeueExample()`
`30`	`30`	`{`
`31`		`- List<int> list = new List<int>() { 1, 2, 3 };`
	`31`	`+ List<int> list = new List<int> { 1, 2, 3 };`
`32`	`32`	`Assert.AreEqual(list.Dequeue(), 1);`
`33`	`33`	`Assert.AreEqual(list.Count, 2);`
`34`	`34`
`@@ -42,7 +42,7 @@ public void DequeueExample()`
`42`	`42`	`[Test]`
`43`	`43`	`public void PopExample()`
`44`	`44`	`{`
`45`		`- List<int> list = new List<int>() { 1, 2, 3 };`
	`45`	`+ List<int> list = new List<int> { 1, 2, 3 };`
`46`	`46`	`Assert.AreEqual(list.Pop(), 3);`
`47`	`47`	`Assert.AreEqual(list.Count, 2);`
`48`	`48`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`public class DataSenderTests`
`7`	`7`	`{`
`8`		`- public struct TestData`
	`8`	`+ public class TestData`
`9`	`9`	`{`
`10`	`10`	`public string stringData;`
`11`	`11`	`public int numberData;`
`@@ -26,8 +26,15 @@ public class TestReceiver : MonoBehaviour, IObserver<TestData>`
`26`	`26`	`{`
`27`	`27`	`public TestData data { get; private set; }`
`28`	`28`
`29`		`- public void OnCompleted() { }`
`30`		`- public void OnError(Exception error) { }`
	`29`	`+ public void OnCompleted()`
	`30`	`+ {`
	`31`	`+ // Do nothing because test`
	`32`	`+ }`
	`33`	`+`
	`34`	`+ public void OnError(Exception error)`
	`35`	`+ {`
	`36`	`+ // Do nothing because test`
	`37`	`+ }`
`31`	`38`
`32`	`39`	`public void OnNext(TestData value)`
`33`	`40`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public class RandomExtensionTests`
`9`	`9`	`[Test]`
`10`	`10`	`public void RandomWorks()`
`11`	`11`	`{`
`12`		`- int[] numbers = new int[] { 1, 2, 3, 4, 5 };`
	`12`	`+ int[] numbers = new[] { 1, 2, 3, 4, 5 };`
`13`	`13`	`Debug.Log(numbers.Random());`
`14`	`14`	`Debug.Log(numbers.Random());`
`15`	`15`	`}`
`@@ -30,14 +30,14 @@ public Item(string name, int percent)`
`30`	`30`	`public void RandomPercent()`
`31`	`31`	`{`
`32`	`32`	`// Arrange`
`33`		`- Item[] items = new Item[] {`
	`33`	`+ Item[] items = new[] {`
`34`	`34`	`new Item("normal sword", 80),`
`35`	`35`	`new Item("epic sword", 19),`
`36`	`36`	`new Item("regendary sword", 1),`
`37`	`37`	`};`
`38`	`38`
`39`	`39`	`int gotchaCount = 1000;`
`40`		`- Dictionary<string, int> hasItemCount = new Dictionary<string, int>()`
	`40`	`+ Dictionary<string, int> hasItemCount = new Dictionary<string, int>`
`41`	`41`	`{`
`42`	`42`	`{"normal", 0}, {"epic", 0}, {"regendary", 0}`
`43`	`43`	`};`
`@@ -61,20 +61,19 @@ public void RandomPercent()`
`61`	`61`	`for (int i = 0; i < items.Length; i++)`
`62`	`62`	`{`
`63`	`63`	`Item item = items[i];`
`64`		`- float errorRate = 0.2f;`
	`64`	`+ float errorRate = 0.5f; // 랜덤에 걸리지 않기 위해 범위를 많이 넓힘`
`65`	`65`	`int expectCount = (int)(gotchaCount * (item.percent / 100f));`
`66`	`66`	`int errorRange = (int)(expectCount * errorRate);`
`67`	`67`	`KeyValuePair<string, int> itemCount = hasItemCount.First(hasItem => item.name.StartsWith(hasItem.Key));`
`68`	`68`
`69`		`- // 대부분 통과하나, 랜덤 확률에 의해 가끔 실패함..`
`70`		`- // Assert.GreaterOrEqual(itemCount.Value, expectCount - errorRange);`
	`69`	`+ Assert.GreaterOrEqual(itemCount.Value, expectCount - errorRange);`
`71`	`70`	`}`
`72`	`71`	`}`
`73`	`72`
`74`	`73`	`[Test]`
`75`	`74`	`public void RandomFilter()`
`76`	`75`	`{`
`77`		`- int[] numbers = new int[] { 1, 2, 3, 4, 5 };`
	`76`	`+ int[] numbers = new[] { 1, 2, 3, 4, 5 };`
`78`	`77`	`HashSet<int> set = new HashSet<int>();`
`79`	`78`
`80`	`79`	`for (int i = 0; i < numbers.Length; i++)`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ public class SimplePoolTests`
`8`	`8`	`{`
`9`	`9`	`public class SimplePoolTarget`
`10`	`10`	`{`
`11`		`- public static int instanceCount { get; private set; } = 0;`
	`11`	`+ public static int instanceCount { get; private set; }`
`12`	`12`
`13`	`13`	`public static void Reset_InstanceCount()`
`14`	`14`	`{`
`@@ -17,13 +17,13 @@ public static void Reset_InstanceCount()`
`17`	`17`
`18`	`18`	`static public class Factory`
`19`	`19`	`{`
`20`		`- static public SimplePoolTarget CreateInstance()`
	`20`	`+ static public SimplePoolTarget CreateInstance_FromFactory()`
`21`	`21`	`{`
`22`	`22`	`return new SimplePoolTarget() { isCreateFromFactory = true };`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`
`26`		`- public bool isCreateFromFactory { get; private set; } = false;`
	`26`	`+ public bool isCreateFromFactory { get; private set; }`
`27`	`27`
`28`	`28`	`public SimplePoolTarget()`
`29`	`29`	`{`
`@@ -69,13 +69,13 @@ public void 사용예시()`
`69`	`69`
`70`	`70`	`public class PoolEx : SimplePool<SimplePoolTarget>`
`71`	`71`	`{`
`72`		`- public PoolEx(int initializeSize = 0) : base(new SimplePoolTarget(), initializeSize)`
	`72`	`+ public PoolEx(int initializeSize) : base(new SimplePoolTarget(), initializeSize)`
`73`	`73`	`{`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`protected override SimplePoolTarget OnRequireNewInstance(SimplePoolTarget originItem)`
`77`	`77`	`{`
`78`		`- return SimplePoolTarget.Factory.CreateInstance();`
	`78`	`+ return SimplePoolTarget.Factory.CreateInstance_FromFactory();`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`