Constrain config manager to use enum and refine type argument names.

osu.Framework/Configuration/ConfigManager.cs

···
 
 namespace osu.Framework.Configuration
 {
-    public abstract class ConfigManager<T> : ITrackableConfigManager, IDisposable
-        where T : struct
+    public abstract class ConfigManager<TLookup> : ITrackableConfigManager, IDisposable
+        where TLookup : struct, Enum
     {
         /// <summary>
         /// Whether user specified configuration elements should be set even though a default was never specified.
         /// </summary>
         protected virtual bool AddMissingEntries => true;
 
-        private readonly IDictionary<T, object> defaultOverrides;
+        private readonly IDictionary<TLookup, object> defaultOverrides;
 
-        protected readonly Dictionary<T, IBindable> ConfigStore = new Dictionary<T, IBindable>();
+        protected readonly Dictionary<TLookup, IBindable> ConfigStore = new Dictionary<TLookup, IBindable>();
 
         /// <summary>
-        /// Initialise a new <see cref="ConfigManager{T}"/>
+        /// Initialise a new <see cref="ConfigManager{TLookup}"/>
         /// </summary>
-        /// <param name="defaultOverrides">Dictionary of overrides which should take precedence over defaults specified by the <see cref="ConfigManager{T}"/> implementation.</param>
-        protected ConfigManager(IDictionary<T, object> defaultOverrides = null)
+        /// <param name="defaultOverrides">Dictionary of overrides which should take precedence over defaults specified by the <see cref="ConfigManager{TLookup}"/> implementation.</param>
+        protected ConfigManager(IDictionary<TLookup, object> defaultOverrides = null)
         {
             this.defaultOverrides = defaultOverrides;
         }
···
         {
         }
 
-        public BindableDouble Set(T lookup, double value, double? min = null, double? max = null, double? precision = null)
+        public BindableDouble Set(TLookup lookup, double value, double? min = null, double? max = null, double? precision = null)
         {
             value = getDefault(lookup, value);
 
···
             return bindable;
         }
 
-        public BindableFloat Set(T lookup, float value, float? min = null, float? max = null, float? precision = null)
+        public BindableFloat Set(TLookup lookup, float value, float? min = null, float? max = null, float? precision = null)
         {
             value = getDefault(lookup, value);
 
···
             return bindable;
         }
 
-        public BindableInt Set(T lookup, int value, int? min = null, int? max = null)
+        public BindableInt Set(TLookup lookup, int value, int? min = null, int? max = null)
         {
             value = getDefault(lookup, value);
 
···
             return bindable;
         }
 
-        public BindableBool Set(T lookup, bool value)
+        public BindableBool Set(TLookup lookup, bool value)
         {
             value = getDefault(lookup, value);
 
···
             return bindable;
         }
 
-        public BindableSize Set(T lookup, Size value, Size? min = null, Size? max = null)
+        public BindableSize Set(TLookup lookup, Size value, Size? min = null, Size? max = null)
         {
             value = getDefault(lookup, value);
 
···
             return bindable;
         }
 
-        public Bindable<U> Set<U>(T lookup, U value)
+        public Bindable<TValue> Set<TValue>(TLookup lookup, TValue value)
         {
             value = getDefault(lookup, value);
 
-            Bindable<U> bindable = GetOriginalBindable<U>(lookup);
+            Bindable<TValue> bindable = GetOriginalBindable<TValue>(lookup);
 
             if (bindable == null)
                 bindable = set(lookup, value);
···
             return bindable;
         }
 
-        protected virtual void AddBindable<TBindable>(T lookup, Bindable<TBindable> bindable)
+        protected virtual void AddBindable<TBindable>(TLookup lookup, Bindable<TBindable> bindable)
         {
             ConfigStore[lookup] = bindable;
             bindable.ValueChanged += _ => backgroundSave();
         }
 
-        private TType getDefault<TType>(T lookup, TType fallback)
+        private TValue getDefault<TValue>(TLookup lookup, TValue fallback)
         {
             if (defaultOverrides != null && defaultOverrides.TryGetValue(lookup, out object found))
-                return (TType)found;
+                return (TValue)found;
 
             return fallback;
         }
 
-        private Bindable<U> set<U>(T lookup, U value)
+        private Bindable<TValue> set<TValue>(TLookup lookup, TValue value)
         {
-            Bindable<U> bindable = new Bindable<U>(value);
+            Bindable<TValue> bindable = new Bindable<TValue>(value);
             AddBindable(lookup, bindable);
             return bindable;
         }
 
-        public U Get<U>(T lookup) => GetOriginalBindable<U>(lookup).Value;
+        public TValue Get<TValue>(TLookup lookup) => GetOriginalBindable<TValue>(lookup).Value;
 
-        protected Bindable<U> GetOriginalBindable<U>(T lookup)
+        protected Bindable<TValue> GetOriginalBindable<TValue>(TLookup lookup)
         {
             if (ConfigStore.TryGetValue(lookup, out IBindable obj))
             {
-                if (!(obj is Bindable<U>))
-                    throw new InvalidCastException($"Cannot convert bindable of type {obj.GetType()} retrieved from {nameof(ConfigManager<T>)} to {typeof(Bindable<U>)}.");
+                if (!(obj is Bindable<TValue>))
+                    throw new InvalidCastException($"Cannot convert bindable of type {obj.GetType()} retrieved from {nameof(ConfigManager<TLookup>)} to {typeof(Bindable<TValue>)}.");
 
-                return (Bindable<U>)obj;
+                return (Bindable<TValue>)obj;
             }
 
             return null;
···
         /// a local reference.
         /// </summary>
         /// <returns>A weakly bound copy of the specified bindable.</returns>
-        public Bindable<U> GetBindable<U>(T lookup) => GetOriginalBindable<U>(lookup)?.GetBoundCopy();
+        public Bindable<TValue> GetBindable<TValue>(TLookup lookup) => GetOriginalBindable<TValue>(lookup)?.GetBoundCopy();
 
         /// <summary>
         /// Binds a local bindable with a configuration-backed bindable.
         /// </summary>
-        public void BindWith<U>(T lookup, Bindable<U> bindable) => bindable.BindTo(GetOriginalBindable<U>(lookup));
+        public void BindWith<TValue>(TLookup lookup, Bindable<TValue> bindable) => bindable.BindTo(GetOriginalBindable<TValue>(lookup));
 
         #region IDisposable Support
 
···
 
         public void LoadInto(TrackedSettings settings) => settings.LoadFrom(this);
 
-        public class TrackedSetting<U> : Tracking.TrackedSetting<U>
+        public class TrackedSetting<TValue> : Tracking.TrackedSetting<TValue>
         {
             /// <summary>
-            /// Constructs a new <see cref="TrackedSetting{U}"/>.
+            /// Constructs a new <see cref="TrackedSetting{TValue}"/>.
             /// </summary>
             /// <param name="setting">The config setting to be tracked.</param>
             /// <param name="generateDescription">A function that generates the description for the setting, invoked every time the value changes.</param>
-            public TrackedSetting(T setting, Func<U, SettingDescription> generateDescription)
+            public TrackedSetting(TLookup setting, Func<TValue, SettingDescription> generateDescription)
                 : base(setting, generateDescription)
             {
             }

osu.Framework/Configuration/IniConfigManager.cs

···
 
 namespace osu.Framework.Configuration
 {
-    public class IniConfigManager<T> : ConfigManager<T>
-        where T : struct
+    public class IniConfigManager<TLookup> : ConfigManager<TLookup>
+        where TLookup : struct, Enum
     {
         /// <summary>
         /// The backing file used to store the config. Null means no persistent storage.
···
 
         private readonly Storage storage;
 
-        public IniConfigManager(Storage storage, IDictionary<T, object> defaultOverrides = null)
+        public IniConfigManager(Storage storage, IDictionary<TLookup, object> defaultOverrides = null)
             : base(defaultOverrides)
         {
             this.storage = storage;
···
                         string key = line.Substring(0, equalsIndex).Trim();
                         string val = line.Remove(0, equalsIndex + 1).Trim();
 
-                        if (!Enum.TryParse(key, out T lookup))
+                        if (!Enum.TryParse(key, out TLookup lookup))
                             continue;
 
                         if (ConfigStore.TryGetValue(lookup, out IBindable b))

osu.Framework/Configuration/Tracking/ITrackedSetting.cs

···
         /// <summary>
         /// Loads a <see cref="Bindable{T}"/> into this tracked setting, binding to <see cref="SettingChanged"/>.
         /// </summary>
-        /// <param name="configManager">The <see cref="ConfigManager{T}"/> to load from.</param>
-        void LoadFrom<T>(ConfigManager<T> configManager)
-            where T : struct;
+        /// <param name="configManager">The <see cref="ConfigManager{TLookup}"/> to load from.</param>
+        void LoadFrom<TLookup>(ConfigManager<TLookup> configManager)
+            where TLookup : struct, Enum;
 
         /// <summary>
         /// Unloads the <see cref="Bindable{T}"/> from this tracked setting, unbinding from <see cref="SettingChanged"/>.

osu.Framework/Configuration/Tracking/TrackedSetting.cs

···
     /// <summary>
     /// A singular tracked setting.
     /// </summary>
-    /// <typeparam name="U">The type of the tracked value.</typeparam>
-    public abstract class TrackedSetting<U> : ITrackedSetting
+    /// <typeparam name="TValue">The type of the tracked value.</typeparam>
+    public abstract class TrackedSetting<TValue> : ITrackedSetting
     {
         public event Action<SettingDescription> SettingChanged;
 
         private readonly object setting;
-        private readonly Func<U, SettingDescription> generateDescription;
+        private readonly Func<TValue, SettingDescription> generateDescription;
 
-        private Bindable<U> bindable;
+        private Bindable<TValue> bindable;
 
         /// <summary>
-        /// Constructs a new <see cref="TrackedSetting{U}"/>.
+        /// Constructs a new <see cref="TrackedSetting{TValue}"/>.
         /// </summary>
         /// <param name="setting">The config setting to be tracked.</param>
         /// <param name="generateDescription">A function that generates the description for the setting, invoked every time the value changes.</param>
-        protected TrackedSetting(object setting, Func<U, SettingDescription> generateDescription)
+        protected TrackedSetting(object setting, Func<TValue, SettingDescription> generateDescription)
         {
             this.setting = setting;
             this.generateDescription = generateDescription;
         }
 
-        public void LoadFrom<T>(ConfigManager<T> configManager)
-            where T : struct
+        public void LoadFrom<TLookup>(ConfigManager<TLookup> configManager)
+            where TLookup : struct, Enum
         {
-            bindable = configManager.GetBindable<U>((T)setting);
+            bindable = configManager.GetBindable<TValue>((TLookup)setting);
             bindable.ValueChanged += displaySetting;
         }
 
···
             bindable.ValueChanged -= displaySetting;
         }
 
-        private void displaySetting(ValueChangedEvent<U> args) => SettingChanged?.Invoke(generateDescription(args.NewValue));
+        private void displaySetting(ValueChangedEvent<TValue> args) => SettingChanged?.Invoke(generateDescription(args.NewValue));
     }
 }

osu.Framework/Configuration/Tracking/TrackedSettings.cs

···
     {
         public event Action<SettingDescription> SettingChanged;
 
-        public void LoadFrom<T>(ConfigManager<T> configManager)
-            where T : struct
+        public void LoadFrom<TLookup>(ConfigManager<TLookup> configManager)
+            where TLookup : struct, Enum
         {
             foreach (var value in this)
             {