CHANGELOG.md

@@ -48,7 +48,6 @@ Additions
 Improvements
 - Improved RawContentManager's reader loading and added better exception handling
 - Improved CopyExtensions construction speed
-- Improved DynamicEnum caching
 
 ## 5.0.0
 ### MLEM

MLEM.Data/DynamicEnum.cs

@@ -12,9 +12,6 @@ namespace MLEM.Data {
     /// A dynamic enum uses <see cref="BigInteger"/> as its underlying type, allowing for an arbitrary number of enum values to be created, even when a <see cref="FlagsAttribute"/>-like structure is used that would only allow for up to 64 values in a regular enum.
     /// All enum operations including <see cref="And{T}"/>, <see cref="Or{T}"/>, <see cref="Xor{T}"/> and <see cref="Neg{T}"/> are supported and can be implemented in derived classes using operator overloads.
     /// To create a custom dynamic enum, simply create a class that extends <see cref="DynamicEnum"/>. New values can then be added using <see cref="Add{T}"/>, <see cref="AddValue{T}"/> or <see cref="AddFlag{T}"/>.
-    ///
-    /// This class, and its entire concept, are extremely terrible. If you intend on using this, there's probably at least one better solution available.
-    /// Though if, for some weird reason, you need a way to have more than 64 distinct flags, this is a pretty good solution.
     /// </summary>
     /// <remarks>
     /// To include enum-like operator overloads in a dynamic enum named MyEnum, the following code can be used:
@@ -30,7 +27,10 @@ namespace MLEM.Data {
     [JsonConverter(typeof(DynamicEnumConverter))]
     public abstract class DynamicEnum {
 
-        private static readonly Dictionary<Type, Storage> Storages = new Dictionary<Type, Storage>();
+        private static readonly Dictionary<Type, Dictionary<BigInteger, DynamicEnum>> Values = new Dictionary<Type, Dictionary<BigInteger, DynamicEnum>>();
+        private static readonly Dictionary<Type, Dictionary<BigInteger, DynamicEnum>> FlagCache = new Dictionary<Type, Dictionary<BigInteger, DynamicEnum>>();
+        private static readonly Dictionary<Type, Dictionary<string, DynamicEnum>> ParseCache = new Dictionary<Type, Dictionary<string, DynamicEnum>>();
+
         private readonly BigInteger value;
 
         private Dictionary<DynamicEnum, bool> allFlagsCache;
@@ -59,6 +59,7 @@ namespace MLEM.Data {
             if (this.allFlagsCache == null)
                 this.allFlagsCache = new Dictionary<DynamicEnum, bool>();
             if (!this.allFlagsCache.TryGetValue(flags, out var ret)) {
+                // & is very memory-intensive, so we cache the return value
                 ret = (GetValue(this) & GetValue(flags)) == GetValue(flags);
                 this.allFlagsCache.Add(flags, ret);
             }
@@ -75,6 +76,7 @@ namespace MLEM.Data {
             if (this.anyFlagsCache == null)
                 this.anyFlagsCache = new Dictionary<DynamicEnum, bool>();
             if (!this.anyFlagsCache.TryGetValue(flags, out var ret)) {
+                // & is very memory-intensive, so we cache the return value
                 ret = (GetValue(this) & GetValue(flags)) != 0;
                 this.anyFlagsCache.Add(flags, ret);
             }
@@ -105,20 +107,24 @@ namespace MLEM.Data {
         /// <returns>The newly created enum value</returns>
         /// <exception cref="ArgumentException">Thrown if the name or value passed are already present</exception>
         public static T Add<T>(string name, BigInteger value) where T : DynamicEnum {
-            var storage = GetStorage(typeof(T));
+            if (!Values.TryGetValue(typeof(T), out var dict)) {
+                dict = new Dictionary<BigInteger, DynamicEnum>();
+                Values.Add(typeof(T), dict);
+            }
 
             // cached parsed values and names might be incomplete with new values
-            storage.ClearCaches();
+            FlagCache.Remove(typeof(T));
+            ParseCache.Remove(typeof(T));
 
-            if (storage.Values.ContainsKey(value))
+            if (dict.ContainsKey(value))
                 throw new ArgumentException($"Duplicate value {value}", nameof(value));
-            foreach (var v in storage.Values.Values) {
+            foreach (var v in dict.Values) {
                 if (v.name == name)
                     throw new ArgumentException($"Duplicate name {name}", nameof(name));
             }
 
             var ret = Construct(typeof(T), name, value);
-            storage.Values.Add(value, ret);
+            dict.Add(value, ret);
             return (T) ret;
         }
 
@@ -132,8 +138,10 @@ namespace MLEM.Data {
         /// <returns>The newly created enum value</returns>
         public static T AddValue<T>(string name) where T : DynamicEnum {
             BigInteger value = 0;
-            while (GetStorage(typeof(T)).Values.ContainsKey(value))
+            if (Values.TryGetValue(typeof(T), out var defined)) {
+                while (defined.ContainsKey(value))
                     value++;
+            }
             return Add<T>(name, value);
         }
 
@@ -147,8 +155,10 @@ namespace MLEM.Data {
         /// <returns>The newly created enum value</returns>
         public static T AddFlag<T>(string name) where T : DynamicEnum {
             BigInteger value = 0;
-            while (GetStorage(typeof(T)).Values.ContainsKey(value))
+            if (Values.TryGetValue(typeof(T), out var defined)) {
+                while (defined.ContainsKey(value))
                     value <<= 1;
+            }
             return Add<T>(name, value);
         }
 
@@ -169,7 +179,7 @@ namespace MLEM.Data {
         /// <param name="type">The type whose values to get</param>
         /// <returns>The defined values for the given type</returns>
         public static IEnumerable<DynamicEnum> GetValues(Type type) {
-            return GetStorage(type).Values.Values;
+            return Values.TryGetValue(type, out var ret) ? ret.Values : Enumerable.Empty<DynamicEnum>();
         }
 
         /// <summary>
@@ -180,12 +190,7 @@ namespace MLEM.Data {
         /// <typeparam name="T">The type of the values</typeparam>
         /// <returns>The bitwise OR (|) combination</returns>
         public static T Or<T>(T left, T right) where T : DynamicEnum {
-            var cache = GetStorage(typeof(T)).OrCache;
+            return GetEnumValue<T>(GetValue(left) | GetValue(right));
-            if (!cache.TryGetValue((left, right), out var ret)) {
-                ret = GetEnumValue<T>(GetValue(left) | GetValue(right));
-                cache.Add((left, right), ret);
-            }
-            return (T) ret;
         }
 
         /// <summary>
@@ -196,12 +201,7 @@ namespace MLEM.Data {
         /// <typeparam name="T">The type of the values</typeparam>
         /// <returns>The bitwise AND (&amp;) combination</returns>
         public static T And<T>(T left, T right) where T : DynamicEnum {
-            var cache = GetStorage(typeof(T)).AndCache;
+            return GetEnumValue<T>(GetValue(left) & GetValue(right));
-            if (!cache.TryGetValue((left, right), out var ret)) {
-                ret = GetEnumValue<T>(GetValue(left) & GetValue(right));
-                cache.Add((left, right), ret);
-            }
-            return (T) ret;
         }
 
         /// <summary>
@@ -212,12 +212,7 @@ namespace MLEM.Data {
         /// <typeparam name="T">The type of the values</typeparam>
         /// <returns>The bitwise XOR (^) combination</returns>
         public static T Xor<T>(T left, T right) where T : DynamicEnum {
-            var cache = GetStorage(typeof(T)).XorCache;
+            return GetEnumValue<T>(GetValue(left) ^ GetValue(right));
-            if (!cache.TryGetValue((left, right), out var ret)) {
-                ret = GetEnumValue<T>(GetValue(left) ^ GetValue(right));
-                cache.Add((left, right), ret);
-            }
-            return (T) ret;
         }
 
         /// <summary>
@@ -227,12 +222,7 @@ namespace MLEM.Data {
         /// <typeparam name="T">The type of the values</typeparam>
         /// <returns>The bitwise NEG (~) value</returns>
         public static T Neg<T>(T value) where T : DynamicEnum {
-            var cache = GetStorage(typeof(T)).NegCache;
+            return GetEnumValue<T>(~GetValue(value));
-            if (!cache.TryGetValue(value, out var ret)) {
-                ret = GetEnumValue<T>(~GetValue(value));
-                cache.Add(value, ret);
-            }
-            return (T) ret;
         }
 
         /// <summary>
@@ -261,16 +251,18 @@ namespace MLEM.Data {
         /// <param name="value">The value whose dynamic enum value to get</param>
         /// <returns>The defined or combined dynamic enum value</returns>
         public static DynamicEnum GetEnumValue(Type type, BigInteger value) {
-            var storage = GetStorage(type);
-
             // get the defined value if it exists
-            if (storage.Values.TryGetValue(value, out var defined))
+            if (Values.TryGetValue(type, out var values) && values.TryGetValue(value, out var defined))
                 return defined;
 
             // otherwise, cache the combined value
-            if (!storage.FlagCache.TryGetValue(value, out var combined)) {
+            if (!FlagCache.TryGetValue(type, out var cache)) {
+                cache = new Dictionary<BigInteger, DynamicEnum>();
+                FlagCache.Add(type, cache);
+            }
+            if (!cache.TryGetValue(value, out var combined)) {
                 combined = Construct(type, null, value);
-                storage.FlagCache.Add(value, combined);
+                cache.Add(value, combined);
             }
             return combined;
         }
@@ -295,7 +287,10 @@ namespace MLEM.Data {
         /// <param name="strg">The string to parse into a dynamic enum value</param>
         /// <returns>The parsed enum value, or null if parsing fails</returns>
         public static DynamicEnum Parse(Type type, string strg) {
-            var cache = GetStorage(type).ParseCache;
+            if (!ParseCache.TryGetValue(type, out var cache)) {
+                cache = new Dictionary<string, DynamicEnum>();
+                ParseCache.Add(type, cache);
+            }
             if (!cache.TryGetValue(strg, out var cached)) {
                 BigInteger? accum = null;
                 foreach (var val in strg.Split('|')) {
@@ -313,39 +308,10 @@ namespace MLEM.Data {
             return cached;
         }
 
-        private static Storage GetStorage(Type type) {
-            if (!Storages.TryGetValue(type, out var storage)) {
-                storage = new Storage();
-                Storages.Add(type, storage);
-            }
-            return storage;
-        }
-
         private static DynamicEnum Construct(Type type, string name, BigInteger value) {
             var constructor = type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new[] {typeof(string), typeof(BigInteger)}, null);
             return (DynamicEnum) constructor.Invoke(new object[] {name, value});
         }
 
-        private class Storage {
-
-            public readonly Dictionary<BigInteger, DynamicEnum> Values = new Dictionary<BigInteger, DynamicEnum>();
-            public readonly Dictionary<BigInteger, DynamicEnum> FlagCache = new Dictionary<BigInteger, DynamicEnum>();
-            public readonly Dictionary<string, DynamicEnum> ParseCache = new Dictionary<string, DynamicEnum>();
-            public readonly Dictionary<(DynamicEnum, DynamicEnum), DynamicEnum> OrCache = new Dictionary<(DynamicEnum, DynamicEnum), DynamicEnum>();
-            public readonly Dictionary<(DynamicEnum, DynamicEnum), DynamicEnum> AndCache = new Dictionary<(DynamicEnum, DynamicEnum), DynamicEnum>();
-            public readonly Dictionary<(DynamicEnum, DynamicEnum), DynamicEnum> XorCache = new Dictionary<(DynamicEnum, DynamicEnum), DynamicEnum>();
-            public readonly Dictionary<DynamicEnum, DynamicEnum> NegCache = new Dictionary<DynamicEnum, DynamicEnum>();
-
-            public void ClearCaches() {
-                this.FlagCache.Clear();
-                this.ParseCache.Clear();
-                this.OrCache.Clear();
-                this.AndCache.Clear();
-                this.XorCache.Clear();
-                this.NegCache.Clear();
-            }
-
-        }
-
     }
 }