< Summary

Class:DCL.PoolManager
Assembly:PoolManager
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Controllers/PoolManager/PoolManager.cs
Covered lines:98
Uncovered lines:18
Coverable lines:116
Total lines:275
Line coverage:84.4% (98 of 116)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
PoolManager()0%110100%
PoolManager()0%110100%
HasPoolable(...)0%110100%
GetPoolable(...)0%330100%
EnsureContainer()0%220100%
OnRenderingStateChanged(...)0%110100%
AddPool(...)0%7.147085.71%
GetPool(...)0%3.333066.67%
RemovePool(...)0%3.213071.43%
ContainsPool(...)0%2.52050%
Release(...)0%3.073080%
Get(...)0%5.024060%
CleanupAsync()0%990100%
Cleanup(...)0%2.062075%
Dispose()0%110100%
ReleaseAllFromPool(...)0%220100%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Controllers/PoolManager/PoolManager.cs

#LineLine coverage
 1using System;
 2using System.Collections;
 3using System.Collections.Generic;
 4using UnityEngine;
 5using System.Linq;
 6using DCL.Interface;
 7using Object = UnityEngine.Object;
 8
 9namespace DCL
 10{
 11    public class PoolManager : Singleton<PoolManager>
 12    {
 13#if UNITY_EDITOR
 114        public static bool USE_POOL_CONTAINERS = true;
 15#else
 16        public static bool USE_POOL_CONTAINERS = false;
 17#endif
 18
 19        public const int DEFAULT_PREWARM_COUNT = 100;
 120        public static bool enablePrewarm = true;
 121        public bool initializing { get; private set; }
 22
 123        public Dictionary<object, Pool> pools = new Dictionary<object, Pool>();
 124        public Dictionary<GameObject, PoolableObject> poolables = new Dictionary<GameObject, PoolableObject>();
 125        public HashSet<PoolableObject> poolableValues = new HashSet<PoolableObject>();
 26
 27        public event System.Action OnGet;
 28
 29        public bool HasPoolable(PoolableObject poolable)
 30        {
 31            //NOTE(Brian): The only poolableValues use is this. Using ContainsValue in a Dictionary is slow as hell.
 79432            return poolableValues.Contains(poolable);
 33        }
 34
 35        public PoolableObject GetPoolable(GameObject gameObject)
 36        {
 6737            if (gameObject == null)
 138                return null;
 39
 6640            if (poolables.ContainsKey(gameObject))
 41            {
 2442                return poolables[gameObject];
 43            }
 44
 4245            return null;
 46        }
 47
 48        GameObject container
 49        {
 50            get
 51            {
 121752                EnsureContainer();
 121753                return containerValue;
 54            }
 055            set { containerValue = value; }
 56        }
 57
 58        GameObject containerValue = null;
 59
 60        void EnsureContainer()
 61        {
 121862            if (containerValue == null)
 11863                containerValue = new GameObject("_PoolManager");
 121864        }
 65
 66        public System.Action<CrashPayload> CrashPayloadEvent;
 67
 168        public PoolManager()
 69        {
 170            EnsureContainer();
 71
 172            initializing = !CommonScriptableObjects.rendererState.Get();
 173            CommonScriptableObjects.rendererState.OnChange += OnRenderingStateChanged;
 174        }
 75
 276        void OnRenderingStateChanged(bool renderingEnabled, bool prevState) { initializing = !renderingEnabled; }
 77
 78        public Pool AddPool(object id, GameObject original, IPooledObjectInstantiator instantiator = null, int maxPrewar
 79        {
 121880            Pool existingPool = GetPool(id);
 81
 121882            if (existingPool != null && !existingPool.IsValid())
 1083                RemovePool(id);
 84
 121885            if (ContainsPool(id))
 86            {
 187                if (Pool.FindPoolInGameObject(original, out Pool poolAlreadyExists))
 88                {
 089                    Debug.LogWarning("WARNING: Object is already being contained in an existing pool!. Returning it.");
 090                    poolAlreadyExists.persistent = isPersistent;
 091                    return poolAlreadyExists;
 92                }
 93
 194                Pool result = GetPool(id);
 95
 196                result.AddToPool(original);
 197                result.persistent = isPersistent;
 98
 199                return result;
 100            }
 101
 1217102            if (!enablePrewarm)
 1216103                maxPrewarmCount = 0;
 104
 1217105            Pool pool = new Pool(id.ToString(), maxPrewarmCount);
 106
 1217107            pool.id = id;
 1217108            pool.original = original;
 1217109            pool.persistent = isPersistent;
 110
 1217111            if (USE_POOL_CONTAINERS)
 112            {
 1217113                pool.container.transform.parent = container.transform;
 1217114                pool.original.name = "Original";
 1217115                pool.original.transform.SetParent(pool.container.transform, true);
 1217116            }
 117            else
 118            {
 0119                pool.original.transform.SetParent(null, true);
 120            }
 121
 1217122            pool.original.SetActive(false);
 123
 1217124            pool.instantiator = instantiator;
 125
 1217126            pools.Add(id, pool);
 127
 1217128            return pool;
 129        }
 130
 131        public Pool GetPool(object id)
 132        {
 2784133            if (id == null)
 134            {
 0135                Debug.LogError("GetPool >>> id cannot be null!");
 0136                return null;
 137            }
 138
 2784139            if (pools.ContainsKey(id))
 766140                return pools[id];
 141
 2018142            return null;
 143        }
 144
 145        public void RemovePool(object id)
 146        {
 1217147            if (id == null)
 148            {
 0149                Debug.LogError("RemovePool >>> id cannot be null!");
 0150                return;
 151            }
 152
 1217153            if (pools.ContainsKey(id))
 154            {
 1217155                pools[id].Cleanup();
 1217156                pools.Remove(id);
 157            }
 1217158        }
 159
 160        public bool ContainsPool(object id)
 161        {
 1943162            if (id == null)
 163            {
 0164                Debug.LogError("ContainsPool >>> id cannot be null!");
 0165                return false;
 166            }
 167
 1943168            return pools.ContainsKey(id);
 169        }
 170
 171        public bool Release(GameObject gameObject)
 172        {
 139173            if (gameObject == null)
 174            {
 175#if UNITY_EDITOR
 0176                Debug.LogWarning("Release >>> gameObject cannot be null!");
 177#endif
 0178                return false;
 179            }
 180
 181
 139182            if (poolables.TryGetValue(gameObject, out PoolableObject poolableObject))
 183            {
 119184                poolableObject.Release();
 119185            }
 186            else
 187            {
 188#if UNITY_EDITOR
 20189                Debug.LogWarning("Release >>> poolable not found in object, destroying it instead!");
 190#endif
 20191                Object.Destroy(gameObject);
 20192                return false;
 193            }
 194
 119195            return true;
 196        }
 197
 198        public PoolableObject Get(object id)
 199        {
 754200            if (id == null)
 201            {
 0202                Debug.LogError("Get >>> id cannot be null!");
 0203                return null;
 204            }
 205
 206            Pool pool;
 207
 754208            if (pools.ContainsKey(id))
 209            {
 754210                pool = pools[id];
 754211            }
 212            else
 213            {
 0214                Debug.LogError($"Pool doesn't exist for id {id}!");
 0215                return null;
 216            }
 217
 754218            OnGet?.Invoke();
 754219            return pool.Get();
 220        }
 221
 222        public IEnumerator CleanupAsync(bool unusedOnly = true, bool nonPersistentOnly = true, bool immediate = false)
 223        {
 766224            List<object> idsToRemove = new List<object>(pools.Count);
 225
 766226            using (var iterator = pools.GetEnumerator())
 227            {
 1965228                while (iterator.MoveNext())
 229                {
 1199230                    Pool pool = iterator.Current.Value;
 1199231                    bool unusedPool = pool.usedObjectsCount == 0; // && pool.unusedObjectsCount > 0;
 1199232                    bool isNonPersistent = !pool.persistent;
 233
 2398234                    if (!unusedOnly) unusedPool = true;
 2398235                    if (!nonPersistentOnly) isNonPersistent = true;
 236
 1199237                    bool shouldRemove = unusedPool && isNonPersistent;
 238
 1199239                    if ( shouldRemove )
 1199240                        idsToRemove.Add(iterator.Current.Key);
 241                }
 766242            }
 243
 3930244            for (int i = 0; i < idsToRemove.Count; i++)
 245            {
 1199246                RemovePool(idsToRemove[i]);
 247
 1199248                if ( !immediate )
 4249                    yield return null;
 250            }
 766251        }
 252
 253        public void Cleanup( bool unusedOnly = false, bool nonPersistentOnly = false )
 254        {
 764255            if (pools == null)
 0256                return;
 257
 764258            CleanupAsync( unusedOnly: unusedOnly, nonPersistentOnly: nonPersistentOnly, immediate: true ).MoveNext();
 764259        }
 260
 261        public void Dispose()
 262        {
 764263            Cleanup();
 764264            CommonScriptableObjects.rendererState.OnChange -= OnRenderingStateChanged;
 764265        }
 266
 267        public void ReleaseAllFromPool(object id)
 268        {
 1269            if (pools.ContainsKey(id))
 270            {
 1271                pools[id].ReleaseAll();
 272            }
 1273        }
 274    }
 275}
Generated by: ReportGenerator 4.8.9.0
10/18/2021 - 20:28:19
GitHub | www.palmmedia.de

Methods/Properties

PoolManager()
initializing()
initializing(System.Boolean)
PoolManager()
HasPoolable(DCL.PoolableObject)
GetPoolable(UnityEngine.GameObject)
container()
container(UnityEngine.GameObject)
EnsureContainer()
OnRenderingStateChanged(System.Boolean, System.Boolean)
AddPool(System.Object, UnityEngine.GameObject, DCL.IPooledObjectInstantiator, System.Int32, System.Boolean)
GetPool(System.Object)
RemovePool(System.Object)
ContainsPool(System.Object)
Release(UnityEngine.GameObject)
Get(System.Object)
CleanupAsync()
Cleanup(System.Boolean, System.Boolean)
Dispose()
ReleaseAllFromPool(System.Object)