v1.3.0.1 (Epic Store release)

2024-03-28 18:34:33 +02:00
parent 81ca8637be
commit 3791670c42
269 changed files with 13160 additions and 2966 deletions
@@ -0,0 +1,112 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Reflection;
+
+namespace Barotrauma
+{
+    public static class ReflectionUtils
+    {
+        private static readonly Dictionary<Assembly, ImmutableArray<Type>> cachedNonAbstractTypes
+            = new Dictionary<Assembly, ImmutableArray<Type>>();
+
+        private static readonly Dictionary<Assembly, Dictionary<Type, ImmutableArray<Type>>> cachedDerivedNonAbstract
+            = new Dictionary<Assembly, Dictionary<Type, ImmutableArray<Type>>>();
+
+        public static T GetValueFromStaticProperty<T>(this PropertyInfo property)
+        {
+            if (property.GetMethod is not { IsStatic: true })
+            {
+                throw new ArgumentException($"Property {property} is not static");
+            }
+
+            var value = property.GetValue(obj: null);
+            if (value is not T castValue)
+            {
+                throw new ArgumentException($"Property {property} is null or not of type {typeof(T)}");
+            }
+
+            return castValue;
+        }
+
+        public static IEnumerable<Type> GetDerivedNonAbstract<T>()
+        {
+            Type t = typeof(T);
+            Assembly assembly = typeof(T).Assembly;
+            if (!cachedNonAbstractTypes.ContainsKey(assembly))
+            {
+                cachedNonAbstractTypes[assembly] = assembly.GetTypes()
+                    .Where(t => !t.IsAbstract).ToImmutableArray();
+
+                cachedDerivedNonAbstract[assembly] = new Dictionary<Type, ImmutableArray<Type>>();
+            }
+            if (cachedDerivedNonAbstract[assembly].TryGetValue(t, out var cachedArray))
+            {
+                return cachedArray;
+            }
+            var newArray = cachedNonAbstractTypes[assembly].Where(t2 => t2.IsSubclassOf(t)).ToImmutableArray();
+            cachedDerivedNonAbstract[assembly].Add(t, newArray);
+            return newArray;
+        }
+
+        public static Type? GetType(string nameWithNamespace)
+        {
+            if (Type.GetType(nameWithNamespace) is Type t) { return t; }
+
+            var entryAssembly = Assembly.GetEntryAssembly();
+            if (entryAssembly?.GetType(nameWithNamespace) is Type t2) { return t2; }
+
+            return null;
+        }
+
+        public static Option<TBase> ParseDerived<TBase, TInput>(TInput input)
+            where TBase : notnull
+            where TInput : notnull
+        {
+            static Option<TBase> none() => Option<TBase>.None();
+            
+            var derivedTypes = GetDerivedNonAbstract<TBase>();
+
+            Option<TBase> parseOfType(Type t)
+            {
+                //every TBase type is expected to have a method with the following signature:
+                //  public static Option<T> Parse(TInput str)
+                var parseFunc = t.GetMethod("Parse", BindingFlags.Public | BindingFlags.Static);
+                if (parseFunc is null) { return none(); }
+                
+                var parameters = parseFunc.GetParameters();
+                if (parameters.Length != 1) { return none(); }
+                
+                var returnType = parseFunc.ReturnType;
+                if (!returnType.IsConstructedGenericType) { return none(); }
+                if (returnType.GetGenericTypeDefinition() != typeof(Option<>)) { return none(); }
+                if (returnType.GenericTypeArguments[0] != t) { return none(); }
+
+                //some hacky business to convert from Option<T2> to Option<TBase> when we only know T2 at runtime
+                static Option<TBase> convert<T2>(Option<T2> option) where T2 : TBase
+                    => option.Select(v => (TBase)v);
+                Func<Option<TBase>, Option<TBase>> f = convert;
+                var genericArgs = f.Method.GetGenericArguments();
+                genericArgs[^1] = t;
+                var constructedConverter =
+                    f.Method.GetGenericMethodDefinition().MakeGenericMethod(genericArgs);
+
+                return constructedConverter.Invoke(null, new[] { parseFunc.Invoke(null, new object[] { input }) })
+                    as Option<TBase>? ?? none();
+            }
+
+            return derivedTypes.Select(parseOfType).FirstOrDefault(t => t.IsSome());
+        }
+
+        public static string NameWithGenerics(this Type t)
+        {
+            if (!t.IsGenericType) { return t.Name; }
+
+            string result = t.Name[..t.Name.IndexOf('`')];
+            result += $"<{string.Join(", ", t.GetGenericArguments().Select(NameWithGenerics))}>";
+            return result;
+        }
+    }
+}