com.amanotes.gdk 0.2.71 → 0.2.72

package/Runtime/Core/GDKPool.cs

@@ -1,385 +1,104 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Reflection;
 using System.Text;
-using Unity.Collections.LowLevel.Unsafe;
-using UnityEngine;
-using UnityEngine.Assertions;
-using UnityEngine.Profiling;
+
+using static Amanotes.Core.GDKDebug;
 namespace Amanotes.Core.Internal
 {
-    internal static class GDKPoolExtension
+    public interface IPoolItem
     {
-        internal static T Pop<T>(this List<T> list)
-        {
-            if (list == null || list.Count == 0) return default;
-
-            T result = list[list.Count - 1];
-            list.RemoveAt(list.Count - 1);
-            return result;
-        }
-    }
-
-    public static partial class GDKPool // TypeHandler 
-    {
-        private const int STRING_BUILDER_DEFAULT_LEN = 64;
-        private static readonly Dictionary<Type, object> typeHandlerMap = new Dictionary<Type, object>
-        {
-            { typeof(StringBuilder), new TypeHandler<StringBuilder>(() => new StringBuilder(), h => h.Clear()) },
-            { typeof(HashSet<string>), new TypeHandler<HashSet<string>>(() => new HashSet<string>(), h => h.Clear()) },
-            { typeof(Dictionary<string, object>), new TypeHandler<Dictionary<string, object>>(() => new Dictionary<string, object>(), d => d.Clear()) }
-        };
-
-        public static TypeHandler<T> GetTypeHandler<T>() where T : class
-        {
-            return typeHandlerMap.TryGetValue(typeof(T), out object result)
-                ? UnsafeUtility.As<object, TypeHandler<T>>(ref result)
-                : null;
-        }
-
-        public static TypeHandler<T> AddTypeHandler<T>(Func<T> newT, Action<T> resetT = null) where T : class
-        {
-            if (typeof(IPoolItem).IsAssignableFrom(typeof(T)))
-            {
-                if (resetT != null) Debug.LogWarning("Unsupported custom resetT() when T: IPoolItem!");
-                resetT = item => { (item as IPoolItem)?.Reset(); };
-            }
-
-            var result = new TypeHandler<T>(newT, resetT);
-            typeHandlerMap.Add(typeof(T), result);
-            return result;
-        }
-        public static TypeHandler<T> AddTypeHandler<T>(Action<T> resetT = null) where T : class, new()
-        {
-            return AddTypeHandler(() => new T(), resetT);
-        }
-        public class TypeHandler<T> where T : class
-        {
-            public readonly Func<T> newT;
-            public readonly Action<T> resetT;
-
-            public TypeHandler(Func<T> newT, Action<T> resetT)
-            {
-                this.newT = newT;
-                this.resetT = resetT;
-            }
-        }
+        void Reset();
     }
 
-    public static partial class GDKPool // Interface 
-    {
-        public interface IPoolItem
-        {
-            void Reset();
-        }
-        public interface IPool<T> where T : class
-        {
-            int Count { get; } // Added to get the number of items currently in the pool
-            T Take();
-            void Return(T item);
-        }
-        public interface IPoolMap
-        {
-            IPool<T> GetPool<T>() where T : class;
-            IPool<T> CreatePool<T>(TypeHandler<T> handler = null) where T : class;
-            IPool<T> GetOrCreatePool<T>(TypeHandler<T> handler = null) where T : class;
-        }
-    }
-    public static partial class GDKPool // POOLs 
+    public static class GDKPool
     {
-        internal abstract class BasePool<T, T1> : IPool<T>
-            where T : class
-            where T1 : new()
+        internal class Pool<T> where T : new()
         {
-            internal readonly TypeHandler<T> handler;
-            internal readonly T1 pool;
-            protected BasePool(TypeHandler<T> handler)
+            private readonly ConcurrentQueue<T> _pool;
+            public Pool(int initialCapacity = 4)
             {
-                pool = new T1();
-                this.handler = handler;
-            }
-
-            public abstract T Take();
-            public abstract void Return(T item);
-            public abstract int Count { get; }
-        }
-        internal sealed class ListPool<T> : BasePool<T, List<T>> where T : class
-        {
-            public ListPool(TypeHandler<T> handler, int capacity) : base(handler)
-            {
-                for (var i = 0; i < capacity; i++)
+                _pool = new ConcurrentQueue<T>();
+                for (var i = 0; i < initialCapacity; i++)
                 {
-                    Return(handler.newT());
+                    _pool.Enqueue(new T());
                 }
             }
-            public override int Count => pool.Count;
-
-            public override T Take()
-            {
-                if (pool.Count == 0) return handler.newT();
-                T last = pool.Pop();
-                handler.resetT?.Invoke(last); // Take from pool: Do Reset
-                return last;
-            }
-
-            internal T TakeAt(int idx)
-            {
-                if (idx < 0 || idx >= pool.Count - 1) return Take();
-
-                // swap last item to index
-                T item = pool[idx];
-                pool[idx] = pool.Pop();
-                handler.resetT?.Invoke(item);
-                return item;
-            }
-
-            public override void Return(T item)
-            {
-                if (item == null) return;
-                pool.Add(item);
-            }
-        }
-        internal sealed class ConcurrentPool<T> : BasePool<T, ConcurrentBag<T>> where T : class
-        {
-            public ConcurrentPool(TypeHandler<T> handler, int capacity) : base(handler)
+        
+            public Pool(int initialCapacity, Func<T> newT)
             {
-                for (var i = 0; i < capacity; i++)
+                _pool = new ConcurrentQueue<T>();
+                for (var i = 0; i < initialCapacity; i++)
                 {
-                    Return(handler.newT());
+                    _pool.Enqueue(newT());
                 }
             }
-
-            public override int Count => pool.Count;
-
-            public override T Take()
-            {
-                if (!pool.TryTake(out T result)) return handler.newT();
-                handler.resetT?.Invoke(result);
-                return result;
-            }
-
-            public override void Return(T item)
-            {
-                if (item == null) return;
-                pool.Add(item);
-            }
-        }
-    }
-
-    public static partial class GDKPool // POOL MAP 
-    {
-        internal abstract class BasePoolMap<TDict> : IPoolMap where TDict : IDictionary<Type, object>, new()
-        {
-            internal readonly TDict map = new TDict();
-
-            // IPoolMap
-            public IPool<T> GetPool<T>() where T : class
-            {
-                return map.TryGetValue(typeof(T), out object result)
-                    ? UnsafeUtility.As<object, IPool<T>>(ref result)
-                    : null;
-            }
-
-            public IPool<T> CreatePool<T>(TypeHandler<T> handler = null) where T : class
+        
+            public T Get()
             {
-                return CreatePoolInternal(handler ?? GetTypeHandler<T>());
+                if (!_pool.TryDequeue(out var obj)) return new T();
+                if (obj is IPoolItem poolItem) poolItem.Reset();
+                return obj;
             }
 
-            public IPool<T> GetOrCreatePool<T>(TypeHandler<T> handler = null) where T : class
+            public void Return(T obj)
             {
-                return GetPool<T>() ?? CreatePoolInternal(handler ?? GetTypeHandler<T>());
+                _pool.Enqueue(obj);
             }
-            internal abstract IPool<T> CreatePoolInternal<T>(TypeHandler<T> handler) where T : class;
-        }
-        internal class ListPoolMap : BasePoolMap<Dictionary<Type, object>>
-        {
-            internal override IPool<T> CreatePoolInternal<T>(TypeHandler<T> handler) where T : class
-            {
-                var result = new ListPool<T>(handler, 1);
-                map.Add(typeof(T), result);
-                return result;
-            }
-        }
-        internal class ConcurrentPoolMap : BasePoolMap<ConcurrentDictionary<Type, object>>
-        {
-            internal override IPool<T> CreatePoolInternal<T>(TypeHandler<T> handler) where T : class
-            {
-                var result = new ConcurrentPool<T>(handler, 1);
-                map.TryAdd(typeof(T), result);
-                return result;
-            }
-        }
-    }
-
-    public static partial class GDKPool
-    {
-        private static readonly ListPoolMap mainPM = new ListPoolMap();
-        private static readonly ConcurrentPoolMap threadPM = new ConcurrentPoolMap();
-
-        // HashSet<T> support
-        private static readonly ListPool<HashSet<string>> hPool; // cached reference for main-thread
-        private static readonly ListPool<StringBuilder> sbPool;
-
-        // StringBuilder support
-        private static readonly ListPool<StringBuilder> fixedSBPool;
-
-        // Dictionary support
-        private static readonly ListPool<Dictionary<string, object>> dictPool;
 
-        // SPECIAL APIs
-        static GDKPool()
-        {
-            // Main-thread: Use fixed-length StringBuilder
-            sbPool = (ListPool<StringBuilder>) mainPM.CreatePool<StringBuilder>();
-            hPool = (ListPool<HashSet<string>>) mainPM.CreatePool<HashSet<string>>();
-            dictPool = (ListPool<Dictionary<string, object>>)mainPM.CreatePool<Dictionary<string, object>>();
-            fixedSBPool = new ListPool<StringBuilder>(new TypeHandler<StringBuilder>(null, sb => sb.Clear()), 0);
+            public int Count => _pool.Count;
         }
+        private static readonly Pool<StringBuilder> sbPool1KB = new Pool<StringBuilder>(8, () => new StringBuilder(1024));
+        private static readonly Pool<StringBuilder> sbPool8KB = new Pool<StringBuilder>(8, () => new StringBuilder(8*1024));
+        private static readonly Pool<HashSet<string>> hashsetPool = new Pool<HashSet<string>>(4);
         
-        private static IPoolMap poolMap => GDKUtils.isOnMainThread ? mainPM : (IPoolMap)threadPM;
-        internal static void ClearAndReset()
+        public static StringBuilder GetStringBuilder(int capacityInKb = 1)
         {
-            // main thread
-            mainPM.map.Clear();
-            mainPM.map.Add(typeof(StringBuilder), sbPool);
-            mainPM.map.Add(typeof(HashSet<string>), hPool);
-            mainPM.map.Add(typeof(Dictionary<string, object>), dictPool);
-            
-            // other threads
-            threadPM.map.Clear();
+            StringBuilder result = capacityInKb <= 1 ? sbPool1KB.Get() : sbPool8KB.Get();
+            result.Clear();
+            return result;
         }
-
-        public static T Take<T>(bool autoCreatePool = true) where T : class, new()
+        
+        public static HashSet<string> GetHashSet()
         {
-            IPool<T> pool = poolMap.GetPool<T>() ?? CreatePool<T>();
-            return pool.Take();
+            HashSet<string> result = hashsetPool.Get();
+            result.Clear();
+            return result;
         }
         
-        public static T Take<T>(Action<T> resetT) where T : class, new()
+        public static string ReturnString(StringBuilder sb)
         {
-            IPool<T> pool = poolMap.GetPool<T>() ?? CreatePool(() => new T(), resetT);
-            return pool.Take();
+            if (sb == null) return null;
+            var result = sb.ToString();
+            Return(sb);
+            return result;
         }
         
-        public static void Return<T>(T item) where T : class
+        public static void Return(StringBuilder sb)
         {
-            if (typeof(T) == typeof(StringBuilder))
+            if (sb == null) return;
+            int capacity = sb.Capacity;
+            
+            if (capacity == 1024)
             {
-                StringBuilder sb = UnsafeUtility.As<T, StringBuilder>(ref item);
-                if (sb.Capacity == sb.MaxCapacity)
-                {
-                    fixedSBPool.Return(sb);
-                    return;
-                }
+                sbPool1KB.Return(sb);
+                return;
             }
             
-            poolMap.GetPool<T>()?.Return(item);
-        }
-
-        public static IPool<T> GetPool<T>(bool autoCreatePool = false) where T : class, new()
-        {
-            IPool<T> result = poolMap.GetPool<T>();
-            if (result != null) return result;
-            return autoCreatePool ? CreatePool<T>() : null;
-        }
-        private static IPool<T> TryCreatePoolUsingTypeHandler<T>() where T : class
-        {
-            TypeHandler<T> handler = GetTypeHandler<T>();
-            return handler != null ? poolMap.CreatePool(handler) : null;
+            sbPool8KB.Return(sb);
         }
-        public static IPool<T> CreatePool<T>(Func<T> newT, Action<T> resetT) where T : class
-        {
-            IPool<T> result = TryCreatePoolUsingTypeHandler<T>();
-            if (result != null) return result;
-            return poolMap.CreatePool(AddTypeHandler(newT, resetT));
-        }
-
-        public static IPool<T> CreatePool<T>(Action<T> resetT = null) where T : class, new()
-        {
-            IPool<T> result = TryCreatePoolUsingTypeHandler<T>();
-            if (result != null) return result;
-            return poolMap.CreatePool(AddTypeHandler(() => new T(), resetT));
-        }
-        public static HashSet<T> TakeHashSet<T>()
-        {
-            var result = Take<HashSet<T>>();
-            return result ?? CreatePool<HashSet<T>>(h => h.Clear()).Take();
-        }
-        public static HashSet<string> TakeHashSet()
+        
+        public static void Return(HashSet<string> hashset)
         {
-            return GDKUtils.isOnMainThread ? hPool.Take() : TakeHashSet<string>();
+            if (hashset == null) return;
+            hashsetPool.Return(hashset);
         }
-
+        
         public static void ReturnAndNullize(ref HashSet<string> hashset)
         {
             if (hashset == null) return;
-            hashset.Clear();
-            Return(hashset);
+            hashsetPool.Return(hashset);
             hashset = null;
         }
-
-        public static StringBuilder TakeStringBuilder(int fixedLength = 0)
-        {
-            if (!GDKUtils.isOnMainThread)
-            {
-                if (fixedLength != 0) Logging.LogWarningOnce("Fixed length StringBuilder only work for Main Thread!");
-                return Take<StringBuilder>();
-            }
-            
-            if (fixedLength == 0) return Take<StringBuilder>();
-            
-            if (fixedSBPool.Count == 0) return new StringBuilder(fixedLength, fixedLength);
-            List<StringBuilder> pool = fixedSBPool.pool;
-            for (var i = 0; i < pool.Count; i++)
-            {
-                if (pool[i].Capacity != fixedLength) continue;
-                return fixedSBPool.TakeAt(i);
-            }
-            
-            return new StringBuilder(fixedLength, fixedLength);
-        }
-
-        private static FieldInfo sbStringValueField;
-        private static readonly Dictionary<StringBuilder, string> internalSB = new Dictionary<StringBuilder, string>();
-        public static string ReturnAndStringify(StringBuilder sb)
-        {
-            if (sb == null) return null;
-            
-            // if (GDKUtils.isOnMainThread && sb.Capacity == sb.MaxCapacity)
-            // {
-            //     string str;
-            //     Profiler.BeginSample("GDKPool.ReturnAndStringify()");
-            //     {
-            //         if (!internalSB.TryGetValue(sb, out str))
-            //         {
-            //             sbStringValueField ??= typeof(StringBuilder)
-            //                 .GetField("m_StringValue", BindingFlags.NonPublic | BindingFlags.Instance);
-            //             
-            //             str = (string)sbStringValueField?.GetValue(sb);
-            //             internalSB.Add(sb, str);
-            //         }
-            //         
-            //         fixedSBPool.Return(sb);
-            //     }
-            //     Profiler.EndSample();
-            //     return str;
-            // }
-            
-            string result = null;
-            Profiler.BeginSample("GDKPool.ReturnAndStringify()");
-            {
-                result = sb.ToString();
-                sb.Clear();
-                Return(sb);
-            }
-            Profiler.EndSample();
-
-            return result;
-        }
-        public static Dictionary<string, object> TakeDictionary()
-        {
-            return GDKUtils.isOnMainThread ? dictPool.Take() : Take<Dictionary<string, object>>();
-        }
     }
 }

package/Runtime/Core/GDKRoutine.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections;
 using UnityEngine;
+using static Amanotes.Core.GDKDebug;
+
 namespace Amanotes.Core.Internal
 {
     public class GDKRoutine
@@ -59,7 +61,7 @@ namespace Amanotes.Core.Internal
                 } catch (Exception ex)
                 {
                     status |= RoutineStatus.Stopped;
-                    if (exceptionHandler == null) Logging.LogError($"Exception caught in coroutine: {ex}");
+                    if (exceptionHandler == null) LogError($"Exception caught in coroutine: {ex}");
                     exceptionHandler?.Invoke(ex);
                     yield break; // Stop executing the coroutine
                 }

package/Runtime/Core/GDKSemVer.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
 using UnityEngine.Profiling;
-using static Amanotes.Core.Internal.Logging;
+using static Amanotes.Core.GDKDebug;
 
 namespace Amanotes.Core.Internal
 {

package/Runtime/Core/GDKString.cs

@@ -0,0 +1,197 @@
+using System;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public static class GDKStringExtension
+    {
+        internal static void Log(GDKString gdkStr, LogType logType, UnityEngine.Object context, Action<string, UnityEngine.Object> logFunc)
+        {
+            StackTraceLogType type = Application.GetStackTraceLogType(logType);
+            Application.SetStackTraceLogType(logType, StackTraceLogType.None);
+            {
+                logFunc(gdkStr.ToString(), context);
+            }
+            Application.SetStackTraceLogType(logType, type);
+            gdkStr.Clear();
+        }
+
+        public static void Log(this GDKString gdkStr, UnityEngine.Object context = null)
+        {
+            Log(gdkStr, LogType.Log, context, Debug.Log);
+        }
+
+        public static void LogWarning(this GDKString gdkStr, UnityEngine.Object context = null)
+        {
+            Log(gdkStr, LogType.Warning, context, Debug.LogWarning);
+        }
+        
+        public static void LogError(this GDKString gdkStr, UnityEngine.Object context = null)
+        {
+            Log(gdkStr, LogType.Error, context, Debug.LogError);
+        }
+        
+        private static readonly char[] DigitChars = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
+        internal static unsafe int Write(string s, int stIndex, ulong value, bool writePrefix = false, char prefix = '-')
+        {
+            fixed (char* ptr = s)
+            {
+                var idx = 0;
+                if (writePrefix)
+                {
+                    ptr[stIndex] = prefix;
+                    idx++;
+                }
+                
+                if (value <= 9)
+                {
+                    ptr[stIndex + idx] = DigitChars[value];
+                    idx++;
+                    return idx;
+                }
+
+                var len = (int)Math.Ceiling(Math.Log10(value));
+                int endIdx = stIndex + len - 1 + idx;
+                do
+                {
+                    ptr[endIdx] = (char)('0' + value % 10);
+                    endIdx--;
+                    value /= 10;
+                } while (value > 0);
+
+                idx += len;
+                return idx;
+            }
+        }
+
+        internal static int WriteULong(this string s, int stIndex, ulong value)
+        {
+            return Write(s, stIndex, value);
+        }
+        
+        internal static int WriteLong(this string s, int stIndex, long value)
+        {
+            return Write(s, stIndex, (ulong)(value < 0 ? -value : value), value < 0, '-');
+        }
+        
+        internal static int WriteDouble(this string s, int stIndex, double value, int decimalPlaces = 4)
+        {
+            var integerPart = (ulong)value;
+            int counter = Write(s, stIndex, integerPart, value < 0);
+            if (decimalPlaces <= 0) return counter;
+            
+            double fractionalPart = value - integerPart;
+            for (var i = 0; i < decimalPlaces; i++)
+            {
+                fractionalPart *= 10;
+            }
+            
+            var fractionalInt = (ulong)(fractionalPart + 0.5);
+            counter += Write(s, stIndex + counter, fractionalInt, true, '.');
+            return counter;
+        }
+    }
+    
+    public unsafe class GDKString
+    {
+        private readonly int _capacity;
+        private readonly string _str;
+        private int _length;
+        
+        public GDKString(int capacity)
+        {
+            _capacity = capacity;
+            _str = new string('\0', capacity);
+            _length = 0;
+        }
+
+        public int Length => _length;
+
+        private GDKString SetLength(int value)
+        {
+            if (value < 0 || value > _capacity)
+            {
+                throw new ArgumentOutOfRangeException(nameof(value));
+            }
+            
+            _length = value;
+            fixed (char* ptr = _str)
+            {
+                ptr[value] = '\0';
+                *(int*)((IntPtr)ptr - sizeof(int)) = _length;
+            }
+
+            return this;
+        }
+
+        public GDKString Append(string value)
+        {
+            return string.IsNullOrEmpty(value) ? this : WriteAt(_length, value);
+        }
+        
+        public GDKString WriteAt(int stIdx, string value)
+        {
+            if (string.IsNullOrEmpty(value)) return this;
+            
+            int vLength = value.Length;
+            if (stIdx + vLength >= _capacity)
+            {
+                throw new InvalidOperationException("Buffer overflow.");
+            }
+            
+            // Calculate the number of bytes to copy (2 bytes per char)
+            fixed (char* srcPtr = value)
+            fixed (char* destPtr = _str)
+            {
+                // Use memcpy equivalent with pointers
+                char* destPos = destPtr + _length;
+                for (var i = 0; i < vLength; i++)
+                {
+                    *(destPos + i) = *(srcPtr + i);
+                }
+            }
+
+            if (stIdx + vLength > _length) SetLength(_length + vLength);
+            return this;
+        }
+        
+        public GDKString Append(int value)
+        {
+            int vLength = _str.WriteLong(Length, value);
+            return SetLength(_length + vLength);
+        }
+
+        public GDKString Append(uint value)
+        {
+            int vLength = _str.WriteULong(Length, value);
+            return SetLength(_length + vLength);
+        }
+
+        private const string TRUE = "True";
+        private const string FALSE = "False";
+        public GDKString Append(bool value)
+        {
+            Append(value ? TRUE : FALSE);
+            return this;
+        }
+
+        public GDKString Append(float value)
+        {
+            int vLength = _str.WriteDouble(Length, value);
+            return SetLength(_length + vLength);
+        }
+
+        public GDKString Append(double value)
+        {
+            int vLength = _str.WriteDouble(Length, value);
+            return SetLength(_length + vLength);
+        }
+        
+        public GDKString Clear()
+        {
+            return SetLength(0);
+        }
+
+        public override string ToString() => _str;
+    }
+}

package/Runtime/Core/GDKString.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1b832c4b2bab4b7d8f05c2d315eb6f85
+timeCreated: 1724065190

package/Runtime/EmbedRemoteConfigAsset.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using UnityEngine;
+using static Amanotes.Core.GDKDebug;
 
 namespace Amanotes.Core.Internal
 {
@@ -30,7 +31,7 @@ namespace Amanotes.Core.Internal
         {
             var config = configs?.FirstOrDefault(a => a.id == id);
             if (config == null)
-                Logging.LogWarningOnce($"Not found embedded config <{id}>");
+                LogWarningOnce($"Not found embedded config <{id}>");
             return config;
         }