feat: rework

Author: KillStr3aK

managed/CounterStrikeSharp.API/Modules/Memory/DisposableMemory.cs

@@ -14,10 +14,17 @@
  *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
  */
 
+using System;
+
+using CounterStrikeSharp.API.Core;
+using CounterStrikeSharp.API.Modules.Utils;
+
 namespace CounterStrikeSharp.API.Modules.Memory
 {
     public abstract class DisposableMemory : NativeObject, IDisposableMemory
     {
+        internal static Type DisposableType = typeof(DisposableMemory);
+
         internal static int _instances;
 
         internal static int Instances
@@ -82,14 +89,111 @@ public virtual void ReleaseUnmanaged()
             MemAlloc.Free(Handle);
         }
 
+        /// <summary>
+        /// Recursively checks if the given type is (or contains) a <see cref="DisposableMemory"/>
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        internal static bool IsDisposableType(Type type)
+        {
+            /* This part will be only needed if we have a correct implementation for `NetworkedVector<>` or any class that has any `DisposableMemory` as generic.
+             * Until that, this would be overkill
+            if (type == DisposableType || DisposableType.IsAssignableFrom(type))
+                return true;
+
+            if (type.IsGenericType)
+            {
+                foreach (Type arg in type.GetGenericArguments())
+                {
+                    if (DisposableType.IsAssignableFrom(arg))
+                    {
+                        return true;
+                    }
+
+                    if (IsDisposableType(arg))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return type.BaseType != null && type.BaseType.Namespace!.StartsWith("CounterStrikeSharp") && IsDisposableType(type.BaseType);
+            */
+
+            return type == DisposableType || DisposableType.IsAssignableFrom(type);
+        }
+
+        internal static void MarkAsPure(DisposableMemory disposable)
+        {
+            disposable.PurePointer = true;
+
+            // we should not count these as they are not handled by us.
+            Instances--;
+        }
+
+        /*
+        internal static void MarkCollectionAsPure<T>(IEnumerable<T> collection) where T: DisposableMemory
+        {
+            foreach (DisposableMemory disposable in collection)
+            {
+                MarkAsPure(disposable);
+            }
+        }
+        */
+
+        /* Span<T> where T has pointer or reference: Only value types without pointers or references are supported.
+        internal static void MarkSpanAsPure<T>(Span<T> collection)
+        {
+            foreach (T instance in collection)
+            {
+                if (instance is DisposableMemory disposable)
+                {
+                    MarkAsPure(disposable);
+                }
+            }
+        }
+        */
+
         internal static void MarkAsPure(object? instance)
         {
-            if (instance != null && instance is DisposableMemory disposable)
+            if (instance == null)
+                return;
+
+            switch (instance)
             {
-                disposable.PurePointer = true;
+                case DisposableMemory disposable:
+                    MarkAsPure(disposable);
+                    break;
 
-                // we should not count these as they are not handled by us.
-                Instances--;
+                /* since 'Networked vectors currently only support CHandle<T>' lets stab ourselves in the back in the future
+                case NetworkedVector<Vector> vectors:
+                    MarkCollectionAsPure<Vector>(vectors);
+                    break;
+
+                case NetworkedVector<Vector2D> vector2ds:
+                    MarkCollectionAsPure<Vector2D>(vector2ds);
+                    break;
+
+                case NetworkedVector<Vector4D> vector4ds:
+                    MarkCollectionAsPure<Vector4D>(vector4ds);
+                    break;
+
+                // 'Angle' is only referenced inside the 'Vector' class
+                case NetworkedVector<QAngle> angles:
+                    MarkCollectionAsPure<QAngle>(angles);
+                    break;
+
+                case NetworkedVector<Quaternion> quaternions:
+                    MarkCollectionAsPure<Quaternion>(quaternions);
+                    break;
+
+                case NetworkedVector<matrix3x4_t> matrixes:
+                    MarkCollectionAsPure<matrix3x4_t>(matrixes);
+                    break;
+
+                default: throw new NotSupportedException($"'MarkAsPure': type '{instance.GetType().Name}' is not supported.");
+                */
+                default: return;
             }
         }
     }

managed/CounterStrikeSharp.API/Modules/Memory/Schema.cs

@@ -100,14 +100,14 @@ public static T GetDeclaredClass<T>(IntPtr pointer, string className, string mem
     {
         if (pointer == IntPtr.Zero) throw new ArgumentNullException(nameof(pointer), "Schema target points to null.");
 
-        if (typeof(DisposableMemory).IsAssignableFrom(typeof(T)) || (typeof(T).IsGenericType && typeof(DisposableMemory).IsAssignableFrom(typeof(T).GetGenericTypeDefinition())))
+        object? instance = Activator.CreateInstance(typeof(T), pointer + GetSchemaOffset(className, memberName));
+
+        if (DisposableMemory.IsDisposableType(typeof(T)))
         {
-            object? instance = Activator.CreateInstance(typeof(T), pointer + GetSchemaOffset(className, memberName));
             DisposableMemory.MarkAsPure(instance);
-            return (T)instance;
         }
 
-        return (T)Activator.CreateInstance(typeof(T), pointer + GetSchemaOffset(className, memberName));
+        return (T)instance;
     }
 
     public static unsafe ref T GetRef<T>(IntPtr pointer, string className, string memberName)
@@ -147,13 +147,7 @@ public static unsafe Span<T> GetFixedArray<T>(IntPtr pointer, string className,
 
         Span<T> span = new((void*)(pointer + GetSchemaOffset(className, memberName)), count);
 
-        if (typeof(DisposableMemory).IsAssignableFrom(typeof(T)) || (typeof(T).IsGenericType && typeof(DisposableMemory).IsAssignableFrom(typeof(T).GetGenericTypeDefinition())))
-        {
-            foreach (T instance in span)
-            {
-                DisposableMemory.MarkAsPure(instance);
-            }
-        }
+        // TODO: once we get a correct implementation for this method check for `DisposableMemory` instances and mark them as pure
 
         return span;
     }