Merge pull request #55 from InitialPrefabs/develop

Develop (0.3.0 - NumericUtils)

Author: psuong

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Change Log
 
+## 0.3.0
+### Added
+* NumericsUtils to convert integers to character arrays.
+
+### Changed
+* Updates the minimum dependency to Entities 0.11.0
+
+### Removed
+* Removes checks of a null EntityManager in the test fixture.
+
 ## 0.2.0
 ### Added
 * Added `ChildrenActiveMetadata` component to store the state of the visibility of the entity

Common.Tests.meta

@@ -0,0 +1,62 @@
+using NUnit.Framework;
+
+namespace CarteDiem.Common.Tests {
+
+    public unsafe class NumericUtilTests {
+
+        [Test]
+        public void CharEqualsPositiveDigit() {
+            int value = 1234567890;
+
+            char* actual = stackalloc char[10];
+
+            value.ToCharArray(actual, 10, out int count);
+
+            string expected = value.ToString();
+
+            for (int i = 0; i < count; i++) {
+                Assert.AreEqual(expected[i], actual[i], "Mismatched digits");
+            }
+        }
+
+        [Test]
+        public void CharEqualsPositiveDigitWithExcess() {
+            int value = 12345;
+
+            char* actual = stackalloc char[15];
+            value.ToCharArray(actual, 15, out int count);
+            string exepected = value.ToString();
+
+            for (int i = 0; i < count; i++) {
+
+                Assert.AreEqual(exepected[i], actual[i], "Mismatched digits");
+            }
+        }
+
+        [Test]
+        public void CharEqualsNegativeDigits() {
+            int value = -12345;
+
+            char* actual = stackalloc char[6];
+            value.ToCharArray(actual, 6, out int count);
+            string expected = value.ToString();
+
+            for (int i = 0; i < count; i++) {
+                Assert.AreEqual(expected[i], actual[i], "Mismatch digits");
+            }
+        }
+
+        [Test]
+        public void CharEqualsNegativeDigitsWIthExcess() {
+            int value = -1234569;
+
+            char* actual = stackalloc char[15];
+            value.ToCharArray(actual, 15, out int count);
+            string expected = value.ToString();
+
+            for (int i = 0; i < count; i++) {
+                Assert.AreEqual(expected[i], actual[i], "Mismatch digits");
+            }
+        }
+    }
+}

Common.Tests/NumericUtilsTests.cs

@@ -0,0 +1,24 @@
+{
+    "name": "UGUIDots.Common.Tests",
+    "references": [
+        "GUID:5f36bc0aeb435984fb19ecbd27b87a1f",
+        "GUID:e0cd26848372d4e5c891c569017e11f1",
+        "GUID:0acc523941302664db1f4e527237feb3",
+        "GUID:27619889b8ba8c24980f49ee34dbb44a"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Common.Tests/NumericUtilsTests.cs.meta

@@ -0,0 +1,47 @@
+using Unity.Collections;
+using Unity.Mathematics;
+
+namespace CarteDiem.Common {
+
+    public unsafe static class NumericUtils {
+
+        /// <summary>
+        /// Fills a character array pointer with the unicode equivalent of each digit.
+        /// </summary>
+        /// <param name="ptr">The character buffer to store into</param>
+        /// <param name="length">The size of the buffer</param>
+        /// <param name="count">The total number of counted digits</param>
+        public static void ToCharArray(this int value, char* ptr, in int length, out int count) {
+            var offset = value < 0 ? 0 : -1;
+
+            value = math.abs(value);
+            var stack = new NativeList<char>(Allocator.Temp);
+            do {
+                var mod = value % 10;
+                value /= 10;
+
+                // Convert to the unicode numerical equivalent, the last digit should go into the last value
+                stack.Add((char)(mod + 48));
+            } while (value != 0);
+
+            for (int i = 0; i < stack.Length; i++) {
+                var flipped = stack.Length + offset - i;
+
+                if (flipped < length) {
+                    ptr[flipped] = stack[i];
+                }
+            }
+
+            count = stack.Length;
+
+            if (offset >= 0) {
+                ptr[0] = '-';
+                count++;
+            }
+
+            stack.Dispose();
+        }
+
+        // TODO: Figure out how to count the number of digits in a floating point #.
+    }
+}

Common.Tests/UGUIDots.Common.Tests.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "UGUIDots.Common",
+    "references": [
+        "GUID:e0cd26848372d4e5c891c569017e11f1",
+        "GUID:d8b63aba1907145bea998dd612889d6b"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}