small improvements plus fix tests

Author: Angel-foxxo

AttributeList.cs

@@ -249,14 +249,27 @@ public virtual object this[string name]
                 {
                     PropertyInfo prop = GetType().GetProperty(prop_attr.Name, BindingFlags.Public | BindingFlags.Instance);
 
-                    if (null != prop && prop.CanWrite)
+                    if (prop != null && prop.CanWrite)
                     {
+                        // were actually fine with this being null, it will just set the value to null
+                        // but need to check so the type check doesn't fail if it is null
+                        if(value != null)
+                        {
+                            var valueType = value.GetType();
+                            if (prop.PropertyType != valueType)
+                            {
+                                throw new InvalidDataException($"class property '{prop.Name}' with type '{prop.PropertyType}' does not match the type '{valueType}' of the value being set, this is likely a mismatch between the real class and the class from the datamodel");
+                            }
+                        }
+
                         prop.SetValue(this, value);
                     }
                     else
                     {
                         throw new InvalidDataException("Property of deserialisation class must be writeable, make sure it's public and has a public setter");
                     }
+
+                    return;
                 }
 
                 Attribute old_attr;

Codecs/Binary.cs

@@ -346,14 +346,9 @@ object ReadValue(Datamodel dm, Type type, bool raw_string)
             throw new ArgumentException(type == null ? "No type provided to GetValue()" : "Cannot read value of type " + type.Name);
         }
 
-        public Datamodel Decode(string encoding, int encoding_version, string format, int format_version, Stream stream, DeferredMode defer_mode, Assembly callingAssembly, bool attemptReflection)
+        public Datamodel Decode(string encoding, int encoding_version, string format, int format_version, Stream stream, DeferredMode defer_mode, ReflectionParams reflectionParams)
         {
-            Dictionary<string, Type> callingTypes = new();
-
-            foreach (var classType in callingAssembly.DefinedTypes)
-            {
-                callingTypes.Add(classType.Name, classType);
-            }
+            var types = CodecUtilities.GetReflectionTypes(reflectionParams);
 
             stream.Seek(0, SeekOrigin.Begin);
             while (true)
@@ -393,9 +388,9 @@ public Datamodel Decode(string encoding, int encoding_version, string format, in
                 var id = new Guid(BitConverter.IsLittleEndian ? id_bits : id_bits.Reverse().ToArray());
 
                 Element? elem = null;
-                var matchedType = callingTypes.TryGetValue(type, out var classType);
+                var matchedType = types.TryGetValue(type, out var classType);
 
-                if(matchedType)
+                if(matchedType && reflectionParams.AttemptReflection)
                 {
                     var isElementDerived = IsElementDerived(classType);
                     if (isElementDerived && classType.Name == type)
@@ -437,7 +432,7 @@ public Datamodel Decode(string encoding, int encoding_version, string format, in
                 foreach (var i in Enumerable.Range(0, num_attrs))
                 {
                     var name = StringDict.ReadString();
-                    if (defer_mode == DeferredMode.Automatic && attemptReflection == false)
+                    if (defer_mode == DeferredMode.Automatic && reflectionParams.AttemptReflection == false)
                     {
                         CodecUtilities.AddDeferredAttribute(elem, name, Reader.BaseStream.Position);
                         SkipAttribute();

Codecs/KeyValues2.cs

@@ -598,7 +598,7 @@ object Decode_ParseValue(Type type, string value)
             else throw new ArgumentException($"Internal error: ParseValue passed unsupported type: {type}.");
         }
 
-        public Datamodel Decode(string encoding, int encoding_version, string format, int format_version, Stream stream, DeferredMode defer_mode, Assembly callingAssembly, bool attemptReflection)
+        public Datamodel Decode(string encoding, int encoding_version, string format, int format_version, Stream stream, DeferredMode defer_mode, ReflectionParams reflectionParams)
         {
             DM = new Datamodel(format, format_version);
 

Datamodel.cs

@@ -232,32 +232,32 @@ public void Save(string path, string encoding, int encoding_version)
         /// </summary>
         /// <param name="stream">The input Stream.</param>
         /// <param name="defer_mode">How to handle deferred loading.</param>
-        public static Datamodel Load(Stream stream, DeferredMode defer_mode = DeferredMode.Automatic, bool attemptReflection = false)
+        public static Datamodel Load(Stream stream, DeferredMode defer_mode = DeferredMode.Automatic, ReflectionParams? reflectionParams = null)
         {
-            return Load_Internal(stream, Assembly.GetCallingAssembly(), defer_mode, attemptReflection);
+            return Load_Internal(stream, Assembly.GetCallingAssembly(), defer_mode, reflectionParams);
         }
         /// <summary>
         /// Loads a Datamodel from a byte array.
         /// </summary>
         /// <param name="stream">The input Stream.</param>
         /// <param name="defer_mode">How to handle deferred loading.</param>
-        public static Datamodel Load(byte[] data, DeferredMode defer_mode = DeferredMode.Automatic, bool attemptReflection = false)
+        public static Datamodel Load(byte[] data, DeferredMode defer_mode = DeferredMode.Automatic, ReflectionParams? reflectionParams = null)
         {
-            return Load_Internal(new MemoryStream(data, true), Assembly.GetCallingAssembly(), defer_mode, attemptReflection);
+            return Load_Internal(new MemoryStream(data, true), Assembly.GetCallingAssembly(), defer_mode, reflectionParams);
         }
 
         /// <summary>
         /// Loads a Datamodel from a file path.
         /// </summary>
         /// <param name="path">The source file path.</param>
         /// <param name="defer_mode">How to handle deferred loading.</param>
-        public static Datamodel Load(string path, DeferredMode defer_mode = DeferredMode.Automatic, bool attemptReflection = false)
+        public static Datamodel Load(string path, DeferredMode defer_mode = DeferredMode.Automatic, ReflectionParams? reflectionParams = null)
         {
             var stream = File.OpenRead(path);
             Datamodel dm = null;
             try
             {
-                dm = Load_Internal(stream, Assembly.GetCallingAssembly(), defer_mode, attemptReflection);
+                dm = Load_Internal(stream, Assembly.GetCallingAssembly(), defer_mode, reflectionParams);
                 return dm;
             }
             finally
@@ -266,8 +266,11 @@ public static Datamodel Load(string path, DeferredMode defer_mode = DeferredMode
             }
         }
 
-        private static Datamodel Load_Internal(Stream stream, Assembly callingAssembly, DeferredMode defer_mode = DeferredMode.Automatic, bool attemptReflection = false)
+        private static Datamodel Load_Internal(Stream stream, Assembly callingAssembly, DeferredMode defer_mode = DeferredMode.Automatic, ReflectionParams? reflectionParams = null)
         {
+            reflectionParams ??= new();
+            reflectionParams.AssembliesToSearch.Add(callingAssembly);
+
             stream.Seek(0, SeekOrigin.Begin);
             var header = string.Empty;
             int b;
@@ -293,7 +296,7 @@ private static Datamodel Load_Internal(Stream stream, Assembly callingAssembly,
 
             ICodec codec = GetCodec(encoding, encoding_version);
 
-            var dm = codec.Decode(encoding, encoding_version, format, format_version, stream, defer_mode, callingAssembly, attemptReflection);
+            var dm = codec.Decode(encoding, encoding_version, format, format_version, stream, defer_mode, reflectionParams);
             if (defer_mode == DeferredMode.Automatic && codec is IDeferredAttributeCodec deferredCodec)
             {
                 dm.Stream = stream;

ICodec.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Numerics;
 using System.Reflection;
+using System.Collections.Generic;
 
 namespace Datamodel.Codecs
 {
@@ -30,9 +31,31 @@ public interface ICodec
         /// <param name="stream">The input stream. Its position will always be 0. Do not dispose.</param>
         /// <param name="defer_mode">The deferred loading mode specified by the caller. Only relevant to implementers of <see cref="IDeferredAttributeCodec"/></param>
         /// <returns></returns>
-        Datamodel Decode(string encoding, int encoding_version, string format, int format_version, Stream stream, DeferredMode defer_mode, Assembly callingAssembly, bool attemptReflection);
+        Datamodel Decode(string encoding, int encoding_version, string format, int format_version, Stream stream, DeferredMode defer_mode, ReflectionParams reflectionParams);
     }
 
+    /// <summary>
+    /// Parameters for reflection based deserialisation
+    /// By default it will look for types in the calling assembly (the one which made this class)
+    /// </summary>
+    public class ReflectionParams
+    {
+        public bool AttemptReflection;
+        public List<Type> AdditionalTypes;
+        public List<Assembly> AssembliesToSearch;
+
+        /// <param name="attemptReflection">If to use reflection or not.</param>
+        /// <param name="additionalTypes">Additional types to consider when matching.</param>
+        /// <param name="assembliesToSearch">Additional assemblies to look for types in.</param>
+        public ReflectionParams(bool attemptReflection = true, List<Type>? additionalTypes = null, List<Assembly>? assembliesToSearch = null)
+        {
+            AttemptReflection = attemptReflection;
+            AdditionalTypes = additionalTypes ??= new();
+            AssembliesToSearch = assembliesToSearch ??= new();
+        }
+    }
+
+
     /// <summary>
     /// Defines methods for the deferred loading of <see cref="Attribute"/> values.
     /// </summary>
@@ -171,6 +194,29 @@ public static void AddDeferredAttribute(Element elem, string key, long offset)
             if (offset <= 0) throw new ArgumentOutOfRangeException(nameof(offset), "Address must be greater than 0.");
             elem.Add(key, offset);
         }
+
+        public static Dictionary<string, Type> GetReflectionTypes(ReflectionParams reflectionParams)
+        {
+            Dictionary<string, Type> types = new();
+
+            if (reflectionParams.AttemptReflection)
+            {
+                foreach (var assembly in reflectionParams.AssembliesToSearch)
+                {
+                    foreach (var classType in assembly.DefinedTypes)
+                    {
+                        types.TryAdd(classType.Name, classType);
+                    }
+                }
+
+                foreach (var type in reflectionParams.AdditionalTypes)
+                {
+                    types.TryAdd(type.Name, type);
+                }
+            }
+
+            return types;
+        }
     }
 
     [AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = true)]

Tests/Resources/error.vmap

@@ -8,10 +8,8 @@
 using Datamodel;
 using System.Numerics;
 using DM = Datamodel.Datamodel;
-using System.Text;
 using System.Globalization;
-using ValveResourceFormat.IO.ContentFormats.ValveMap;
-using System.ComponentModel.DataAnnotations;
+using VMAP;
 
 namespace Datamodel_Tests
 {
@@ -298,40 +296,27 @@ public static void TypedArrayAddingRemoving()
 
 
         [Test]
-        public void Create_Datamodel_Vmap()
-        {
-            //using var datamodel = new DM("vmap", 29);
-            //datamodel.PrefixAttributes.Add("map_asset_references", new List<string>());
-            //datamodel.Root = new Element(datamodel, "root", classNameOverride: "CMapRootElement")
-            //{
-            //    ["isprefab"] = false,
-            //    ["showgrid"] = true,
-            //    ["snaprotationangle"] = 15,
-            //    ["gridspacing"] = 64,
-            //    ["show3dgrid"] = true,
-            //    ["itemFile"] = true,
-            //    ["world"] = new Element(datamodel, "world", classNameOverride: "CMapWorld"),
-            //};
-            //
-            //using var stream = new MemoryStream();
-            //datamodel.Save(stream, "keyvalues2", 4);
-            //Assert.That(stream.Length, Is.GreaterThan(0));
-
-            using var actual = DM.Load(Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "cs2_map.vmap.txt"));
-
-            CMapRootElement root = (CMapRootElement)actual.Root;
+        public void LoadVmap_Reflection_Binary()
+        {
+            var unserialisedVmap = DM.Load(Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources", "cs2_map.vmap"));
+
+            Assert.AreEqual(unserialisedVmap.Root.GetType(), typeof(CMapRootElement));
+
+            CMapRootElement root = (CMapRootElement)unserialisedVmap.Root;
+
+            Assert.AreEqual(root.world.GetType(), typeof(CMapWorld));
+
             var world = root.world;
-            var prop = (CMapEntity)world.children[1];
-            var propProperties = prop.EntityProperties;
 
+            var props = world.children.Where(i => i.ClassName == "CMapEntity").OfType<CMapEntity>().ToList();
+
+            var propProperties = props[0].EntityProperties;
             var classname = propProperties.Get<string>("classname");
 
-            var meshes = world.children.Where(i => i.ClassName == "CMapMesh");
+            var meshes = world.children.Where(i => i.ClassName == "CMapMesh").OfType<CMapMesh>().ToList();
+            var mesh = meshes[0];
 
-            //Assert.That(actual.PrefixAttributes.ContainsKey("map_asset_references"), Is.True);
-            //Assert.That(actual.PrefixAttributes["map_asset_references"], Is.Empty);
-            Assert.That(actual.Root, Is.Not.Null);
-            Assert.That(actual.Root["world"], Is.Not.Null);
+            Assert.That(unserialisedVmap.PrefixAttributes["map_asset_references"], Is.Not.Empty);
         }
 
         public class NullOwnerElement
@@ -417,16 +402,6 @@ public void PropertyAccessByKey()
                 Assert.That(myprop, Is.EqualTo(1337));
             }
 
-            [Test]
-            public void PropertySetByKey_Throws()
-            {
-                var elem = new CustomElement();
-
-                var ex = Assert.Throws(typeof(InvalidOperationException), () => elem["MyProperty"] = 5);
-
-                Assert.That(ex.Message, Does.Contain("Cannot set the value of a property-derived attribute by key"));
-            }
-
             [Test]
             public void CanBeAssignedToDatamodelRoot()
             {
@@ -600,7 +575,7 @@ public void TF2_KeyValues2_1()
         [Test, TestCaseSource(nameof(GetDmxFiles))]
         public void Unserialize(string path)
         {
-            var dm = DM.Load(path);
+            var dm = DM.Load(path, Datamodel.Codecs.DeferredMode.Automatic);
             PrintContents(dm);
             dm.Dispose();
         }

Tests/Tests.cs

@@ -14,9 +14,6 @@
   <ItemGroup>
     <Compile Remove="Resources\vmap.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <None Include="vmap.cs" />
-  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Datamodel.NET.csproj" />
   </ItemGroup>

Tests/Tests.csproj

@@ -2,7 +2,7 @@
 using System.Numerics;
 using DMElement = Datamodel.Element;
 
-namespace consoleTestApp.VMAP;
+namespace VMAP;
 
 /// <summary>
 ///  Valve Map (VMAP) format version 29.
@@ -205,7 +205,7 @@ internal class CMapInstance : BaseEntity
     /// <summary>
     /// A target <see cref="CMapGroup"/> to instance. With custom tint and transform.
     /// </summary>
-    public DMElement? target { get; set; }
+    public CMapGroup? target { get; set; }
     public Datamodel.Color tintColor { get; set; } = new Datamodel.Color(255, 255, 255, 255);
 }