Replaced IBitWritable with BitWritable with support for automatic serialization

Author: TwoTenPvP

MLAPI/MLAPI.csproj

@@ -116,8 +116,9 @@
     <Compile Include="NetworkingManagerComponents\Binary\BitReaderDeprecated.cs" />
     <Compile Include="NetworkingManagerComponents\Binary\BinaryHelpers.cs" />
     <Compile Include="NetworkingManagerComponents\Binary\ByteBool.cs" />
-    <Compile Include="NetworkingManagerComponents\Binary\IBitWritable.cs" />
+    <Compile Include="NetworkingManagerComponents\Binary\BitWritable.cs" />
     <Compile Include="NetworkingManagerComponents\Binary\ResourcePool.cs" />
+    <Compile Include="NetworkingManagerComponents\Binary\SerializationHelper.cs" />
     <Compile Include="NetworkingManagerComponents\Binary\UIntFloat.cs" />
     <Compile Include="NetworkingManagerComponents\Core\LogHelper.cs" />
     <Compile Include="NetworkingManagerComponents\Cryptography\CryptographyHelper.cs" />

MLAPI/NetworkingManagerComponents/Binary/BitReader.cs

@@ -174,10 +174,10 @@ public object ReadObjectPacked(Type type)
                     return null;
                 }
             }
-            if (typeof(IBitWritable).IsAssignableFrom(type))
+            if (typeof(BitWritable).IsAssignableFrom(type))
             {
                 object instance = Activator.CreateInstance(type);
-                ((IBitWritable)instance).Read(this.source);
+                ((BitWritable)instance).Read(this.source);
                 return instance;
             }
 

MLAPI/NetworkingManagerComponents/Binary/BitWritable.cs

@@ -0,0 +1,55 @@
+using System;
+using System.IO;
+using System.Reflection;
+
+namespace MLAPI.Serialization 
+{
+    [Obsolete("The IBitWritable interface has been replaced with the abstract BitWritable class", true)]
+    public interface IBitWritable
+    {
+        [Obsolete("The IBitWritable interface has been replaced with the abstract BitWritable class", true)]
+        void Read(Stream stream);
+        [Obsolete("The IBitWritable interface has been replaced with the abstract BitWritable class", true)]
+        void Write(Stream stream);
+    }
+    
+    /// <summary>
+    /// BitWritable is the base class for writable types
+    /// </summary>
+    public abstract class BitWritable
+    {        
+        /// <summary>
+        /// Writes the contents of the type instance to the stream
+        /// </summary>
+        /// <param name="stream">The stream to write to</param>
+        public virtual void Write(Stream stream)
+        {
+            FieldInfo[] fields = SerializationHelper.GetFieldsForType(GetType());
+
+            using (PooledBitWriter writer = PooledBitWriter.Get(stream))
+            {
+                for (int i = 0; i < fields.Length; i++)
+                {
+                    writer.WriteObjectPacked(fields[i].GetValue(this));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reads the contents from the stream and applies it to the type instance
+        /// </summary>
+        /// <param name="stream">The stream to read from</param>
+        public virtual void Read(Stream stream)
+        {
+            FieldInfo[] fields = SerializationHelper.GetFieldsForType(GetType());
+
+            using (PooledBitReader reader = PooledBitReader.Get(stream))
+            {
+                for (int i = 0; i < fields.Length; i++)
+                {
+                    fields[i].SetValue(this, reader.ReadObjectPacked(fields[i].FieldType));
+                }
+            }
+        }
+    }
+}

MLAPI/NetworkingManagerComponents/Binary/BitWriter.cs

@@ -190,13 +190,13 @@ public void WriteObjectPacked(object value)
                 WriteUInt16Packed(((NetworkedBehaviour)value).GetBehaviourId());
                 return;
             } 
-            else if (value is IBitWritable)
+            else if (value is BitWritable)
             {
                 if (value == null)
                 {
                     throw new ArgumentException("BitWriter cannot write IBitWritable types with a null value");
                 }
-                ((IBitWritable)value).Write(this.sink);
+                ((BitWritable)value).Write(this.sink);
                 return;
             } 
 

MLAPI/NetworkingManagerComponents/Binary/IBitWritable.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEngine;
+
+namespace MLAPI.Serialization
+{
+    /// <summary>
+    /// Helper class providing helper serialization methods
+    /// </summary>
+    public static class SerializationHelper
+    {
+        private static readonly Dictionary<Type, FieldInfo[]> fieldCache = new Dictionary<Type, FieldInfo[]>();
+
+        internal static FieldInfo[] GetFieldsForType(Type type)
+        {
+            if (fieldCache.ContainsKey(type))
+                return fieldCache[type];
+            else
+            {
+                FieldInfo[] fields = type
+                    .GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
+                    .Where(x => (x.IsPublic || x.GetCustomAttributes(typeof(SerializeField), true).Length > 0) && IsTypeSupported(x.FieldType))
+                    .OrderBy(x => x.Name).ToArray();
+                
+                fieldCache.Add(type, fields);
+
+                return fields;
+            }
+        }
+
+        private static readonly HashSet<Type> SupportedTypes = new HashSet<Type>()
+        {
+            typeof(byte),
+            typeof(byte),
+            typeof(sbyte),
+            typeof(ushort),
+            typeof(short),
+            typeof(int),
+            typeof(uint),
+            typeof(long),
+            typeof(ulong),
+            typeof(float),
+            typeof(double),
+            typeof(string),
+            typeof(bool),
+            typeof(Vector2),
+            typeof(Vector3),
+            typeof(Vector4),
+            typeof(Color),
+            typeof(Color32),
+            typeof(Ray),
+            typeof(Quaternion),
+            typeof(char),
+            typeof(GameObject),
+            typeof(NetworkedObject),
+            typeof(NetworkedBehaviour)
+        };
+
+        /// <summary>
+        /// Returns if a type is supported for serialization
+        /// </summary>
+        /// <param name="type">The type to check</param>
+        /// <returns>Whether or not the type is supported</returns>
+        public static bool IsTypeSupported(Type type)
+        {
+            return type.IsEnum || SupportedTypes.Contains(type) || (typeof(BitWritable).IsAssignableFrom(type));
+        }
+    }
+}