< Summary

Class:DCL.PoolManager
Assembly:PoolManager
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Controllers/PoolManager/PoolManager.cs
Covered lines:91
Uncovered lines:22
Coverable lines:113
Total lines:275
Line coverage:80.5% (91 of 113)
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%3.073080%
EnsureContainer()0%220100%
OnRenderingStateChanged(...)0%110100%
AddPool(...)0%7.167085.19%
GetPool(...)0%3.333066.67%
RemovePool(...)0%3.213071.43%
ContainsPool(...)0%2.52050%
Release(...)0%3.13077.78%
Get(...)0%5.44055.56%
CleanupAsync()0%990100%
Cleanup(...)0%2.062075%
Dispose()0%110100%
ReleaseAllFromPool(...)0%6200%

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;
 157021        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.
 173532            return poolableValues.Contains(poolable);
 33        }
 34
 35        public PoolableObject GetPoolable(GameObject gameObject)
 36        {
 9937            if (gameObject == null)
 038                return null;
 39
 9940            if (poolables.ContainsKey(gameObject))
 41            {
 2442                return poolables[gameObject];
 43            }
 44
 7545            return null;
 46        }
 47
 48        GameObject container
 49        {
 50            get
 51            {
 520452                EnsureContainer();
 520453                return containerValue;
 54            }
 055            set { containerValue = value; }
 56        }
 57
 58        GameObject containerValue = null;
 59
 60        void EnsureContainer()
 61        {
 520562            if (containerValue == null)
 45063                containerValue = new GameObject("_PoolManager");
 520564        }
 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        {
 520780            Pool existingPool = GetPool(id);
 81
 520782            if (existingPool != null && !existingPool.IsValid())
 1283                RemovePool(id);
 84
 520785            if (ContainsPool(id))
 86            {
 387                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
 394                Pool result = GetPool(id);
 95
 396                result.AddToPool(original);
 397                result.persistent = isPersistent;
 98
 399                return result;
 100            }
 101
 5204102            if (!enablePrewarm)
 5204103                maxPrewarmCount = 0;
 104
 5204105            Pool pool = new Pool(id.ToString(), maxPrewarmCount);
 106
 5204107            pool.id = id;
 5204108            pool.original = original;
 5204109            pool.persistent = isPersistent;
 110
 5204111            if (USE_POOL_CONTAINERS)
 112            {
 5204113                pool.container.transform.parent = container.transform;
 5204114                pool.original.name = "Original";
 5204115                pool.original.transform.SetParent(pool.container.transform, true);
 116            }
 117            else
 118            {
 0119                pool.original.transform.SetParent(null, true);
 120            }
 121
 5204122            pool.original.SetActive(false);
 123
 5204124            pool.instantiator = instantiator;
 125
 5204126            pools.Add(id, pool);
 127
 5204128            return pool;
 129        }
 130
 131        public Pool GetPool(object id)
 132        {
 12147133            if (id == null)
 134            {
 0135                Debug.LogError("GetPool >>> id cannot be null!");
 0136                return null;
 137            }
 138
 12147139            if (pools.ContainsKey(id))
 2611140                return pools[id];
 141
 9536142            return null;
 143        }
 144
 145        public void RemovePool(object id)
 146        {
 5186147            if (id == null)
 148            {
 0149                Debug.LogError("RemovePool >>> id cannot be null!");
 0150                return;
 151            }
 152
 5186153            if (pools.ContainsKey(id))
 154            {
 5186155                pools[id].Cleanup();
 5186156                pools.Remove(id);
 157            }
 5186158        }
 159
 160        public bool ContainsPool(object id)
 161        {
 6202162            if (id == null)
 163            {
 0164                Debug.LogError("ContainsPool >>> id cannot be null!");
 0165                return false;
 166            }
 167
 6202168            return pools.ContainsKey(id);
 169        }
 170
 171        public bool Release(GameObject gameObject)
 172        {
 94173            if (gameObject == null)
 174            {
 175#if UNITY_EDITOR
 0176                Debug.LogWarning("Release >>> gameObject cannot be null!");
 177#endif
 0178                return false;
 179            }
 180
 181
 94182            if (poolables.TryGetValue(gameObject, out PoolableObject poolableObject))
 183            {
 74184                poolableObject.Release();
 185            }
 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
 74195            return true;
 196        }
 197
 198        public PoolableObject Get(object id)
 199        {
 505200            if (id == null)
 201            {
 0202                Debug.LogError("Get >>> id cannot be null!");
 0203                return null;
 204            }
 205
 206            Pool pool;
 207
 505208            if (pools.ContainsKey(id))
 209            {
 505210                pool = pools[id];
 211            }
 212            else
 213            {
 0214                Debug.LogError($"Pool doesn't exist for id {id}!");
 0215                return null;
 216            }
 217
 505218            OnGet?.Invoke();
 505219            return pool.Get();
 220        }
 221
 222        public IEnumerator CleanupAsync(bool unusedOnly = true, bool nonPersistentOnly = true, bool immediate = false)
 223        {
 836224            List<object> idsToRemove = new List<object>(pools.Count);
 225
 836226            using (var iterator = pools.GetEnumerator())
 227            {
 6195228                while (iterator.MoveNext())
 229                {
 5359230                    Pool pool = iterator.Current.Value;
 5359231                    bool unusedPool = pool.usedObjectsCount == 0; // && pool.unusedObjectsCount > 0;
 5359232                    bool isNonPersistent = !pool.persistent;
 233
 10418234                    if (!unusedOnly) unusedPool = true;
 10418235                    if (!nonPersistentOnly) isNonPersistent = true;
 236
 5359237                    bool shouldRemove = unusedPool && isNonPersistent;
 238
 5359239                    if ( shouldRemove )
 5064240                        idsToRemove.Add(iterator.Current.Key);
 241                }
 836242            }
 243
 11800244            for (int i = 0; i < idsToRemove.Count; i++)
 245            {
 5064246                RemovePool(idsToRemove[i]);
 247
 5064248                if ( !immediate )
 8249                    yield return null;
 250            }
 836251        }
 252
 253        public void Cleanup( bool unusedOnly = false, bool nonPersistentOnly = false )
 254        {
 812255            if (pools == null)
 0256                return;
 257
 812258            CleanupAsync( unusedOnly: unusedOnly, nonPersistentOnly: nonPersistentOnly, immediate: true ).MoveNext();
 812259        }
 260
 261        public void Dispose()
 262        {
 529263            Cleanup();
 529264            CommonScriptableObjects.rendererState.OnChange -= OnRenderingStateChanged;
 529265        }
 266
 267        public void ReleaseAllFromPool(object id)
 268        {
 0269            if (pools.ContainsKey(id))
 270            {
 0271                pools[id].ReleaseAll();
 272            }
 0273        }
 274    }
 275}
Generated by: ReportGenerator 4.8.9.0
02/03/2023 - 18:35:21
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)