com.alicizax.unity.framework/Runtime/ObjectPool/ObjectPoolService.cs

using System;
using System.Collections.Generic;
using UnityEngine;

namespace AlicizaX.ObjectPool
{

    [UnityEngine.Scripting.Preserve]
    internal sealed partial class ObjectPoolService : ServiceBase, IObjectPoolService, IObjectPoolServiceDebugView, IServiceTickable
    {
        private const float DefaultAutoReleaseInterval = float.MaxValue;
        private const int DefaultCapacity = int.MaxValue;
        private const float DefaultExpireTime = float.MaxValue;

        private readonly Dictionary<TypeNamePair, ObjectPoolBase> m_ObjectPools;
        private readonly List<ObjectPoolBase> m_ObjectPoolList;
        private readonly Dictionary<ObjectPoolBase, int> m_ObjectPoolIndexMap;
        private readonly List<ObjectPoolBase> m_CachedSortedObjectPools;
        private readonly Comparison<ObjectPoolBase> m_ObjectPoolComparer;

        public ObjectPoolService()
        {
            m_ObjectPools = new Dictionary<TypeNamePair, ObjectPoolBase>();
            m_ObjectPoolList = new List<ObjectPoolBase>();
            m_ObjectPoolIndexMap = new Dictionary<ObjectPoolBase, int>(AlicizaX.ReferenceComparer<ObjectPoolBase>.Instance);
            m_CachedSortedObjectPools = new List<ObjectPoolBase>();
            m_ObjectPoolComparer = ObjectPoolComparer;
        }

        public int Priority => 1;
        public int Count => m_ObjectPools.Count;

        void IServiceTickable.Tick(float deltaTime)
        {
            for (int i = 0; i < m_ObjectPoolList.Count; i++)
                m_ObjectPoolList[i].Update(deltaTime, Time.unscaledDeltaTime);
        }

        protected override void OnInitialize() { }

        protected override void OnDestroyService()
        {
            for (int i = m_ObjectPoolList.Count - 1; i >= 0; i--)
                m_ObjectPoolList[i].Shutdown();
            m_ObjectPools.Clear();
            m_ObjectPoolList.Clear();
            m_ObjectPoolIndexMap.Clear();
            m_CachedSortedObjectPools.Clear();
        }

        // ========== Has ==========

        public bool HasObjectPool<T>() where T : ObjectBase
            => m_ObjectPools.ContainsKey(new TypeNamePair(typeof(T)));

        public bool HasObjectPool<T>(string name) where T : ObjectBase
            => m_ObjectPools.ContainsKey(new TypeNamePair(typeof(T), name));

        public bool HasObjectPool(Type objectType)
        {
            ValidateObjectType(objectType);
            return m_ObjectPools.ContainsKey(new TypeNamePair(objectType));
        }

        public bool HasObjectPool(Type objectType, string name)
        {
            ValidateObjectType(objectType);
            return m_ObjectPools.ContainsKey(new TypeNamePair(objectType, name));
        }

        // ========== Get ==========

        public IObjectPool<T> GetObjectPool<T>() where T : ObjectBase
            => (IObjectPool<T>)InternalGet(new TypeNamePair(typeof(T)));

        public IObjectPool<T> GetObjectPool<T>(string name) where T : ObjectBase
            => (IObjectPool<T>)InternalGet(new TypeNamePair(typeof(T), name));

        public ObjectPoolBase GetObjectPool(Type objectType)
        {
            ValidateObjectType(objectType);
            return InternalGet(new TypeNamePair(objectType));
        }

        public ObjectPoolBase GetObjectPool(Type objectType, string name)
        {
            ValidateObjectType(objectType);
            return InternalGet(new TypeNamePair(objectType, name));
        }

        // ========== GetAll ==========

        int IObjectPoolServiceDebugView.GetAllObjectPools(bool sort, ObjectPoolBase[] results)
        {
            if (results == null) throw new GameFrameworkException("Results is invalid.");

            List<ObjectPoolBase> source = m_ObjectPoolList;
            if (sort)
            {
                CacheSortedObjectPools();
                source = m_CachedSortedObjectPools;
            }

            int count = source.Count;
            int copyCount = results.Length < count ? results.Length : count;
            for (int i = 0; i < copyCount; i++)
                results[i] = source[i];

            return count;
        }

        // ========== Create (single entry point) ==========

        public IObjectPool<T> CreatePool<T>(ObjectPoolCreateOptions options = default) where T : ObjectBase
        {
            var key = new TypeNamePair(typeof(T), options.Name);
            if (m_ObjectPools.ContainsKey(key))
                throw new GameFrameworkException($"Already exist object pool '{key}'.");

            var pool = new ObjectPool<T>(
                options.Name ?? string.Empty,
                options.AllowMultiSpawn,
                options.AutoReleaseInterval ?? DefaultAutoReleaseInterval,
                options.Capacity ?? DefaultCapacity,
                options.ExpireTime ?? DefaultExpireTime,
                options.Priority);

            m_ObjectPools.Add(key, pool);
            m_ObjectPoolIndexMap.Add(pool, m_ObjectPoolList.Count);
            m_ObjectPoolList.Add(pool);
            return pool;
        }

        public ObjectPoolBase CreatePool(Type objectType, ObjectPoolCreateOptions options = default)
        {
            ValidateObjectType(objectType);
            var key = new TypeNamePair(objectType, options.Name);
            if (m_ObjectPools.ContainsKey(key))
                throw new GameFrameworkException($"Already exist object pool '{key}'.");

            var poolType = typeof(ObjectPool<>).MakeGenericType(objectType);
            var pool = (ObjectPoolBase)Activator.CreateInstance(poolType,
                options.Name ?? string.Empty,
                options.AllowMultiSpawn,
                options.AutoReleaseInterval ?? DefaultAutoReleaseInterval,
                options.Capacity ?? DefaultCapacity,
                options.ExpireTime ?? DefaultExpireTime,
                options.Priority);

            m_ObjectPools.Add(key, pool);
            m_ObjectPoolIndexMap.Add(pool, m_ObjectPoolList.Count);
            m_ObjectPoolList.Add(pool);
            return pool;
        }

        // ========== Destroy ==========

        public bool DestroyObjectPool<T>() where T : ObjectBase
            => InternalDestroy(new TypeNamePair(typeof(T)));

        public bool DestroyObjectPool<T>(string name) where T : ObjectBase
            => InternalDestroy(new TypeNamePair(typeof(T), name));

        public bool DestroyObjectPool(Type objectType)
        {
            ValidateObjectType(objectType);
            return InternalDestroy(new TypeNamePair(objectType));
        }

        public bool DestroyObjectPool(Type objectType, string name)
        {
            ValidateObjectType(objectType);
            return InternalDestroy(new TypeNamePair(objectType, name));
        }

        public bool DestroyObjectPool<T>(IObjectPool<T> objectPool) where T : ObjectBase
        {
            if (objectPool == null) throw new GameFrameworkException("Object pool is invalid.");
            return InternalDestroy(new TypeNamePair(typeof(T), objectPool.Name));
        }

        public bool DestroyObjectPool(ObjectPoolBase objectPool)
        {
            if (objectPool == null) throw new GameFrameworkException("Object pool is invalid.");
            return InternalDestroy(new TypeNamePair(objectPool.ObjectType, objectPool.Name));
        }

        // ========== Release ==========

        public void Release()
        {
            CacheSortedObjectPools();
            for (int i = 0; i < m_CachedSortedObjectPools.Count; i++)
                m_CachedSortedObjectPools[i].Release();
        }

        public void ReleaseAllUnused()
        {
            CacheSortedObjectPools();
            for (int i = 0; i < m_CachedSortedObjectPools.Count; i++)
                m_CachedSortedObjectPools[i].ReleaseAllUnused();
        }

        // ========== Low memory ==========

        public void OnLowMemory()
        {
            for (int i = 0; i < m_ObjectPoolList.Count; i++)
                m_ObjectPoolList[i].OnLowMemory();
        }

        // ========== Internal ==========

        private ObjectPoolBase InternalGet(TypeNamePair key)
        {
            m_ObjectPools.TryGetValue(key, out var pool);
            return pool;
        }

        private bool InternalDestroy(TypeNamePair key)
        {
            if (m_ObjectPools.TryGetValue(key, out var pool))
            {
                pool.Shutdown();
                RemovePoolFromList(pool);
                m_ObjectPoolIndexMap.Remove(pool);
                return m_ObjectPools.Remove(key);
            }
            return false;
        }

        private void CacheSortedObjectPools()
        {
            m_CachedSortedObjectPools.Clear();
            m_CachedSortedObjectPools.AddRange(m_ObjectPoolList);
            m_CachedSortedObjectPools.Sort(m_ObjectPoolComparer);
        }

        private void RemovePoolFromList(ObjectPoolBase pool)
        {
            if (!m_ObjectPoolIndexMap.TryGetValue(pool, out int index))
                return;

            int lastIndex = m_ObjectPoolList.Count - 1;
            ObjectPoolBase lastPool = m_ObjectPoolList[lastIndex];
            m_ObjectPoolList[index] = lastPool;
            m_ObjectPoolList.RemoveAt(lastIndex);

            if (!ReferenceEquals(lastPool, pool))
                m_ObjectPoolIndexMap[lastPool] = index;
        }

        private static void ValidateObjectType(Type objectType)
        {
            if (objectType == null)
                throw new GameFrameworkException("Object type is invalid.");
            if (!typeof(ObjectBase).IsAssignableFrom(objectType))
                throw new GameFrameworkException($"Object type '{objectType.FullName}' is invalid.");
        }

        private static int ObjectPoolComparer(ObjectPoolBase a, ObjectPoolBase b)
            => a.Priority.CompareTo(b.Priority);
    }
}