Change EmbeddedPresetHolder data layout to make searches faster

Author: gilzoide

Runtime/Internal/EmbeddedPresetHolder.cs

@@ -11,6 +11,8 @@ namespace Gilzoide.ConditionalObjects
 {
     public class EmbeddedPresetHolder : ScriptableObject
     {
+        #region Instance
+
         public static readonly string InstanceAssetPath = $"Assets/ConditionalObjects/Editor/{nameof(EmbeddedPresetHolder)}.asset";
 
         public static EmbeddedPresetHolder Instance => _instance ? _instance : (_instance = GetOrCreateInstance());
@@ -33,69 +35,98 @@ static EmbeddedPresetHolder GetOrCreateInstance()
             return instance;
         }
 
+        #endregion
+
         [Serializable]
-        public class EmbeddedPreset
+        internal class EmbeddedPresets : IComparable<EmbeddedPresets>
         {
             public GUID AssetGuid;
-            public Preset Preset;
+            public List<Preset> PresetList;
+
+            public int CompareTo(EmbeddedPresets other)
+            {
+                return AssetGuid.CompareTo(other.AssetGuid);
+            }
         }
 
-        [SerializeField] private List<EmbeddedPreset> _embeddedPresets = new List<EmbeddedPreset>();
+        [SerializeField] private List<EmbeddedPresets> _embeddedPresets = new List<EmbeddedPresets>();
 
         public Preset CreatePreset(GameObject ownerObject, Object target)
         {
             string assetPath = ownerObject.GetAssetPath();
-            return CreatePreset(AssetDatabase.AssetPathToGUID(assetPath), target);
+            return CreatePreset(assetPath, target);
+        }
+
+        public void HandleAssetDelete(string assetPath)
+        {
+            RemoveEmbeddedPresets(assetPath);
         }
 
-        public Preset CreatePreset(string assetGuid, Object target)
+        public void DeleteOrphanPresets(string assetPath, HashSet<Preset> referencedPresets)
         {
-            if (string.IsNullOrEmpty(AssetDatabase.GUIDToAssetPath(assetGuid)))
+            GetEmbeddedPresets(assetPath)?.PresetList.RemoveAll(p =>
             {
-                throw new ArgumentOutOfRangeException(nameof(assetGuid), "GUID is not know in AssetDatabase");
-            }
+                bool shouldRemove = !referencedPresets.Contains(p);
+                if (shouldRemove)
+                {
+                    DestroyImmediate(p, true);
+                }
+                return shouldRemove;
+            });
+        }
 
+        private Preset CreatePreset(string assetPath, Object target)
+        {
+            var guid = new GUID(AssetDatabase.AssetPathToGUID(assetPath));
             var preset = new Preset(target)
             {
-                name = $"{assetGuid}-{GlobalObjectId.GetGlobalObjectIdSlow(target).targetObjectId}",
+                name = $"{guid}-{GlobalObjectId.GetGlobalObjectIdSlow(target).targetObjectId}",
+                hideFlags = HideFlags.HideInHierarchy,
             };
             preset.ExcludeAllProperties();
-            _embeddedPresets.Add(new EmbeddedPreset
-            {
-                AssetGuid = new GUID(assetGuid),
-                Preset = preset,
-            });
             AssetDatabase.AddObjectToAsset(preset, this);
-            AssetDatabase.SaveAssetIfDirty(this);
+            GetOrCreateEmbeddedPresets(assetPath).PresetList.Add(preset);
             return preset;
         }
 
-        public void HandleAssetDelete(string assetPath)
+        private EmbeddedPresets GetEmbeddedPresets(string assetPath)
         {
             var guid = new GUID(AssetDatabase.AssetPathToGUID(assetPath));
-            _embeddedPresets.RemoveAll(p =>
+            int index = _embeddedPresets.BinarySearch(new EmbeddedPresets { AssetGuid = guid });
+            if (index >= 0)
             {
-                bool shouldRemove = p.AssetGuid == guid;
-                if (shouldRemove)
-                {
-                    DestroyImmediate(p.Preset, true);
-                }
-                return shouldRemove;
-            });
+                return _embeddedPresets[index];
+            }
+            else
+            {
+                return null;
+            }
         }
 
-        public void DeleteOrphanPresets(string assetPath, HashSet<Preset> referencedPresets)
+        private EmbeddedPresets GetOrCreateEmbeddedPresets(string assetPath)
         {
             var guid = new GUID(AssetDatabase.AssetPathToGUID(assetPath));
-            _embeddedPresets.RemoveAll(p =>
+            int index = _embeddedPresets.BinarySearch(new EmbeddedPresets { AssetGuid = guid });
+            if (index >= 0)
             {
-                bool shouldRemove = p.AssetGuid == guid && !referencedPresets.Contains(p.Preset);
-                if (shouldRemove)
-                {
-                    DestroyImmediate(p.Preset, true);
-                }
-                return shouldRemove;
-            });
+                return _embeddedPresets[index];
+            }
+            else
+            {
+                var embeddedPreset = new EmbeddedPresets { AssetGuid = guid, PresetList = new List<Preset>() };
+                _embeddedPresets.Insert(~index, embeddedPreset);
+                return embeddedPreset;
+            }
+        }
+
+        private void RemoveEmbeddedPresets(string assetPath)
+        {
+            var guid = new GUID(AssetDatabase.AssetPathToGUID(assetPath));
+            int index = _embeddedPresets.BinarySearch(new EmbeddedPresets { AssetGuid = guid });
+            if (index >= 0)
+            {
+                _embeddedPresets.RemoveAt(index);
+            }
         }
     }
 }