Fix settings persistence dirty state

Editor/DataVisualizer/Data/DataVisualizerSettings.cs

@@ -96,6 +96,18 @@ public void MarkDirty()
 #endif
         }
 
+        public bool SetSelectActiveObject(bool value)
+        {
+            if (selectActiveObject == value)
+            {
+                return false;
+            }
+
+            selectActiveObject = value;
+            MarkDirty();
+            return true;
+        }
+
         public void HydrateFrom(DataVisualizerUserState userState)
         {
             if (userState == null)
@@ -199,6 +211,38 @@ internal bool HasCollapseState(string namespaceKey)
             return entry != null;
         }
 
+        public bool SetNamespaceCollapsed(string namespaceKey, bool isCollapsed)
+        {
+            if (string.IsNullOrWhiteSpace(namespaceKey))
+            {
+                return false;
+            }
+
+            namespaceCollapseStates ??= new List<NamespaceCollapseState>();
+            bool changed = NamespaceCollapseState.SetCollapsed(
+                namespaceCollapseStates,
+                namespaceKey,
+                isCollapsed
+            );
+            if (changed)
+            {
+                MarkDirty();
+            }
+
+            return changed;
+        }
+
+        public bool RemoveNamespaceCollapseState(string namespaceKey)
+        {
+            bool changed = NamespaceCollapseState.Remove(namespaceCollapseStates, namespaceKey);
+            if (changed)
+            {
+                MarkDirty();
+            }
+
+            return changed;
+        }
+
         internal NamespaceCollapseState GetOrCreateCollapseState(string namespaceKey)
         {
             NamespaceCollapseState entry = namespaceCollapseStates.Find(o =>

Editor/DataVisualizer/Data/DataVisualizerUserState.cs

@@ -122,6 +122,26 @@ public bool HasCollapseState(string namespaceKey)
             return entry != null;
         }
 
+        public bool SetNamespaceCollapsed(string namespaceKey, bool isCollapsed)
+        {
+            if (string.IsNullOrWhiteSpace(namespaceKey))
+            {
+                return false;
+            }
+
+            namespaceCollapseStates ??= new List<NamespaceCollapseState>();
+            return NamespaceCollapseState.SetCollapsed(
+                namespaceCollapseStates,
+                namespaceKey,
+                isCollapsed
+            );
+        }
+
+        public bool RemoveNamespaceCollapseState(string namespaceKey)
+        {
+            return NamespaceCollapseState.Remove(namespaceCollapseStates, namespaceKey);
+        }
+
         public NamespaceCollapseState GetOrCreateCollapseState(string namespaceKey)
         {
             NamespaceCollapseState entry = namespaceCollapseStates.Find(o =>

Editor/DataVisualizer/Data/NamespaceCollapseState.cs

@@ -1,13 +1,61 @@
 namespace WallstopStudios.DataVisualizer.Editor.Data
 {
     using System;
+    using System.Collections.Generic;
 
     [Serializable]
     public sealed class NamespaceCollapseState
     {
         public string namespaceKey = string.Empty;
         public bool isCollapsed;
 
+        public static bool SetCollapsed(
+            List<NamespaceCollapseState> states,
+            string namespaceKey,
+            bool isCollapsed
+        )
+        {
+            if (states == null || string.IsNullOrWhiteSpace(namespaceKey))
+            {
+                return false;
+            }
+
+            NamespaceCollapseState entry = states.Find(state =>
+                string.Equals(state?.namespaceKey, namespaceKey, StringComparison.Ordinal)
+            );
+            if (entry == null)
+            {
+                states.Add(
+                    new NamespaceCollapseState
+                    {
+                        namespaceKey = namespaceKey,
+                        isCollapsed = isCollapsed,
+                    }
+                );
+                return true;
+            }
+
+            if (entry.isCollapsed == isCollapsed)
+            {
+                return false;
+            }
+
+            entry.isCollapsed = isCollapsed;
+            return true;
+        }
+
+        public static bool Remove(List<NamespaceCollapseState> states, string namespaceKey)
+        {
+            if (states == null || string.IsNullOrWhiteSpace(namespaceKey))
+            {
+                return false;
+            }
+
+            return states.RemoveAll(state =>
+                    string.Equals(state?.namespaceKey, namespaceKey, StringComparison.Ordinal)
+                ) > 0;
+        }
+
         public NamespaceCollapseState Clone()
         {
             return new NamespaceCollapseState

Editor/DataVisualizer/Data/NamespaceTypeOrder.cs

@@ -10,6 +10,72 @@ public sealed class NamespaceTypeOrder
         public string namespaceKey = string.Empty;
         public List<string> typeNames = new();
 
+        public static int CompareTypesByFullNameOrder(
+            Type lhs,
+            Type rhs,
+            IReadOnlyList<string> typeFullNameOrder
+        )
+        {
+            return CompareTypeFullNames(
+                lhs?.FullName ?? string.Empty,
+                rhs?.FullName ?? string.Empty,
+                typeFullNameOrder
+            );
+        }
+
+        public static int CompareTypesByFullName(Type lhs, Type rhs)
+        {
+            return string.Compare(
+                lhs?.FullName ?? string.Empty,
+                rhs?.FullName ?? string.Empty,
+                StringComparison.Ordinal
+            );
+        }
+
+        public static int CompareTypesByNameThenFullName(Type lhs, Type rhs)
+        {
+            int nameComparison = string.Compare(
+                lhs?.Name ?? string.Empty,
+                rhs?.Name ?? string.Empty,
+                StringComparison.Ordinal
+            );
+            return nameComparison != 0 ? nameComparison : CompareTypesByFullName(lhs, rhs);
+        }
+
+        public static int CompareTypeFullNames(
+            string lhsFullName,
+            string rhsFullName,
+            IReadOnlyList<string> typeFullNameOrder
+        )
+        {
+            int indexA = IndexOf(typeFullNameOrder, lhsFullName);
+            int indexB = IndexOf(typeFullNameOrder, rhsFullName);
+
+            switch (indexA)
+            {
+                case >= 0 when indexB >= 0:
+                    return indexA.CompareTo(indexB);
+                case >= 0:
+                    return -1;
+            }
+
+            return 0 <= indexB
+                ? 1
+                : string.Compare(lhsFullName, rhsFullName, StringComparison.Ordinal);
+        }
+
+        public static Type FindTypeByFullName(IEnumerable<Type> types, string typeFullName)
+        {
+            if (types == null || string.IsNullOrWhiteSpace(typeFullName))
+            {
+                return null;
+            }
+
+            return types.FirstOrDefault(type =>
+                string.Equals(type?.FullName, typeFullName, StringComparison.Ordinal)
+            );
+        }
+
         public NamespaceTypeOrder Clone()
         {
             return new NamespaceTypeOrder
@@ -18,5 +84,23 @@ public NamespaceTypeOrder Clone()
                 typeNames = typeNames?.ToList() ?? new List<string>(),
             };
         }
+
+        private static int IndexOf(IReadOnlyList<string> values, string value)
+        {
+            if (values == null || string.IsNullOrWhiteSpace(value))
+            {
+                return -1;
+            }
+
+            for (int i = 0; i < values.Count; ++i)
+            {
+                if (string.Equals(values[i], value, StringComparison.Ordinal))
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
     }
 }