Added boxing write & reads for generics

TwoTenPvP · TwoTenPvP · commit cb8f10e6c2aa · 2018-07-10T15:24:30.000+02:00
diff --git a/MLAPI/Data/NetworkedCollections/NetworkedDictionary.cs b/MLAPI/Data/NetworkedCollections/NetworkedDictionary.cs
@@ -84,20 +84,23 @@ public void ReadDelta(BitReader reader)
                 switch (eventType)
                 {
                     case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Add:
-                        {
-                            //TODO: readKey
-                            //TODO: readVal
-                        }
+                    {
+                        TKey key = reader.ReadValueTypeOrString<TKey>();
+                        TValue value = reader.ReadValueTypeOrString<TValue>();
+                        dictionary.Add(key, value);
+                    }
                         break;
                     case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Remove:
                         {
-                            //TODO: readKey
+                            TKey key = reader.ReadValueTypeOrString<TKey>();
+                            dictionary.Remove(key);
                         }
                         break;
                     case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.RemovePair:
                         {
-                            //TODO: readKey
-                            //TODO: readVal
+                            TKey key = reader.ReadValueTypeOrString<TKey>();
+                            TValue value = reader.ReadValueTypeOrString<TValue>();
+                            dictionary.Remove(new KeyValuePair<TKey, TValue>(key, value));
                         }
                         break;
                     case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Clear:
@@ -108,8 +111,10 @@ public void ReadDelta(BitReader reader)
                         break;
                     case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Value:
                         {
-                            //TODO: readKey
-                            //TODO: readVal
+                            TKey key = reader.ReadValueTypeOrString<TKey>();
+                            TValue value = reader.ReadValueTypeOrString<TValue>();
+                            if (dictionary.ContainsKey(key))
+                                dictionary[key] = value;
                         }
                         break;
                     default:
@@ -121,12 +126,13 @@ public void ReadDelta(BitReader reader)
         /// <inheritdoc />
         public void ReadField(BitReader reader)
         {
+            dictionary.Clear();
             ushort entryCount = reader.ReadUShort();
-
             for (int i = 0; i < entryCount; i++)
             {
-                //TODO: readKey
-                //TODO: readVal
+                TKey key = reader.ReadValueTypeOrString<TKey>();
+                TValue value = reader.ReadValueTypeOrString<TValue>();
+                dictionary.Add(key, value);
             }
         }
 
@@ -153,19 +159,19 @@ public void WriteDelta(BitWriter writer)
                 {
                     case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Add:
                         {
-                            //TODO: writeKey
-                            //TODO: writeVal
+                            writer.WriteValueTypeOrString(dirtyEvents[i].key);
+                            writer.WriteValueTypeOrString(dirtyEvents[i].value);
                         }
                         break;
                     case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Remove:
                         {
-                            //TODO: writeKey
+                            writer.WriteValueTypeOrString(dirtyEvents[i].key);
                         }
                         break;
                     case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.RemovePair:
                         {
-                            //TODO: writeKey
-                            //TODO: writeVal
+                            writer.WriteValueTypeOrString(dirtyEvents[i].key);
+                            writer.WriteValueTypeOrString(dirtyEvents[i].value);
                         }
                         break;
                     case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Clear:
@@ -175,8 +181,8 @@ public void WriteDelta(BitWriter writer)
                         break;
                     case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Value:
                         {
-                            //TODO: writeKey
-                            //TODO: writeVal
+                            writer.WriteValueTypeOrString(dirtyEvents[i].key);
+                            writer.WriteValueTypeOrString(dirtyEvents[i].value);
                         }
                         break;
                     default:
@@ -189,10 +195,10 @@ public void WriteDelta(BitWriter writer)
         public void WriteField(BitWriter writer)
         {
             writer.WriteUShort((ushort)dictionary.Count);
-            for (int i = 0; i < dictionary.Count; i++)
+            foreach (KeyValuePair<TKey, TValue> pair in dictionary)
             {
-                //TODO: writeKey
-                //TODO: writeVal
+                writer.WriteValueTypeOrString(pair.Key);
+                writer.WriteValueTypeOrString(pair.Value);
             }
         }
 
diff --git a/MLAPI/Data/NetworkedCollections/NetworkedList.cs b/MLAPI/Data/NetworkedCollections/NetworkedList.cs
@@ -137,18 +137,18 @@ public void WriteDelta(BitWriter writer)
                     //Fuck me these signatures are proper aids
                     case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Add:
                         {
-                            //TODO: Write dirtyEvents[i].value
+                            writer.WriteValueTypeOrString(dirtyEvents[i].value);
                         }
                         break;
                     case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Insert:
                         {
                             writer.WriteInt(dirtyEvents[i].index);
-                            //TODO: Write dirtyEvents[i].value
+                            writer.WriteValueTypeOrString(dirtyEvents[i].value);
                         }
                         break;
                     case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Remove:
                         {
-                            //TODO: Write dirtyEvents[i].value
+                            writer.WriteValueTypeOrString(dirtyEvents[i].value);
                         }
                         break;
                     case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.RemoveAt:
@@ -159,7 +159,7 @@ public void WriteDelta(BitWriter writer)
                     case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Value:
                         {
                             writer.WriteInt(dirtyEvents[i].index);
-                            //TODO: Write dirtyEvents[i].value
+                            writer.WriteValueTypeOrString(dirtyEvents[i].value);
                         }
 
                         break;
@@ -178,17 +178,18 @@ public void WriteField(BitWriter writer)
             writer.WriteUShort((ushort)list.Count);
             for (int i = 0; i < list.Count; i++)
             {
-                //TODO: Write the fieldValue
+                writer.WriteValueTypeOrString(list[i]);
             }
         }
 
         /// <inheritdoc />
         public void ReadField(BitReader reader)
         {
+            list.Clear();
             ushort count = reader.ReadUShort();
             for (int i = 0; i < count; i++)
             {
-                //TODO: Read element
+                list.Add(reader.ReadValueTypeOrString<T>());
             }
         }
 
@@ -203,18 +204,18 @@ public void ReadDelta(BitReader reader)
                 {
                     case NetworkedListEvent<T>.NetworkedListEventType.Add:
                         {
-                            //TODO: list.Add(readValue);
+                            list.Add(reader.ReadValueTypeOrString<T>());
                         }
                         break;
                     case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Insert:
                         {
                             int index = reader.ReadInt();
-                            //TODO: list.Insert(index, readValue);
+                            list.Insert(index, reader.ReadValueTypeOrString<T>());
                         }
                         break;
                     case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Remove:
                         {
-                            //TODO: list.Remove(readValue);
+                            list.Remove(reader.ReadValueTypeOrString<T>());
                         }
                         break;
                     case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.RemoveAt:
@@ -226,7 +227,7 @@ public void ReadDelta(BitReader reader)
                     case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Value:
                         {
                             int index = reader.ReadInt();
-                            //TODO: list[index] = readValue
+                            if (index < list.Count) list[index] = reader.ReadValueTypeOrString<T>();
                         }
                         break;
                     case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Clear:
diff --git a/MLAPI/Data/NetworkedVar.cs b/MLAPI/Data/NetworkedVar.cs
@@ -152,17 +152,16 @@ public void SetNetworkedBehaviour(NetworkedBehaviour behaviour)
         /// <inheritdoc />
         public void ReadField(BitReader reader)
         {
-            // TODO TwoTen - Boxing sucks
             T previousValue = InternalValue;
-            InternalValue = (T)FieldTypeHelper.ReadFieldType(reader, typeof(T), (object)InternalValue);
+            InternalValue = reader.ReadValueTypeOrString<T>();
             if (OnValueChanged != null)
                 OnValueChanged(previousValue, InternalValue);
         }
         
         /// <inheritdoc />
         public void WriteField(BitWriter writer)
         {
-            //TODO: Write field
+            writer.WriteValueTypeOrString(InternalValue);
         }
 
         /// <inheritdoc />
diff --git a/MLAPI/NetworkingManagerComponents/Binary/BitReader.cs b/MLAPI/NetworkingManagerComponents/Binary/BitReader.cs
@@ -64,6 +64,49 @@ public static BitReader Get(byte[] readFrom)
             }
         }
 
+        public ValueType ReadValueType<T>()
+        {
+            if (typeof(T) == typeof(float))
+                return ReadFloat();
+            else if (typeof(T) == typeof(double))
+                return ReadDouble();
+            else if (typeof(T) == typeof(byte))
+                return ReadByte();
+            else if (typeof(T) == typeof(sbyte))
+                return ReadSByte();
+            else if (typeof(T) == typeof(short))
+                return ReadShort();
+            else if (typeof(T) == typeof(ushort))
+                return ReadUShort();
+            else if (typeof(T) == typeof(int))
+                return ReadInt();
+            else if (typeof(T) == typeof(uint))
+                return ReadUInt();
+            else if (typeof(T) == typeof(long))
+                return ReadLong();
+            else if (typeof(T) == typeof(ulong))
+                return ReadULong();
+            
+            return default(ValueType);
+        }
+
+        public T ReadValueTypeOrString<T>()
+        {
+            if (typeof(T) == typeof(string))
+            {
+                return (T)(object)ReadString(); //BOX
+            }
+            else if (typeof(T).IsValueType)
+            {
+                ValueType type = ReadValueType<T>();
+                return (T)(object)type; //BOX
+            }
+            else
+            {
+                return default(T);
+            }
+        }
+        
         public bool ReadBool()
         {
             bool result = (readFrom[bitCount / 8] & (byte)(1 << (int)(bitCount % 8))) != 0;
diff --git a/MLAPI/NetworkingManagerComponents/Binary/BitWriter.cs b/MLAPI/NetworkingManagerComponents/Binary/BitWriter.cs
@@ -102,7 +102,8 @@ private void Push<T>(T b)
                 if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("The type \"" + b.GetType() + "\" is not supported by the Binary Serializer. It will be ignored");
         }
 
-
+        public void WriteValueTypeOrString<T>(T t)  => Push(t);
+        public void WriteValueType(ValueType v)     => Push(v);
         public void WriteBool(bool b)               => Push(b);
         public void WriteFloat(float f)             => Push(f);
         public void WriteDouble(double d)           => Push(d);

Original file line number	Diff line number	Diff line change
`@@ -84,20 +84,23 @@ public void ReadDelta(BitReader reader)`
`84`	`84`	`switch (eventType)`
`85`	`85`	`{`
`86`	`86`	`case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Add:`
`87`		`- {`
`88`		`- //TODO: readKey`
`89`		`- //TODO: readVal`
`90`		`- }`
	`87`	`+ {`
	`88`	`+ TKey key = reader.ReadValueTypeOrString<TKey>();`
	`89`	`+ TValue value = reader.ReadValueTypeOrString<TValue>();`
	`90`	`+ dictionary.Add(key, value);`
	`91`	`+ }`
`91`	`92`	`break;`
`92`	`93`	`case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Remove:`
`93`	`94`	`{`
`94`		`- //TODO: readKey`
	`95`	`+ TKey key = reader.ReadValueTypeOrString<TKey>();`
	`96`	`+ dictionary.Remove(key);`
`95`	`97`	`}`
`96`	`98`	`break;`
`97`	`99`	`case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.RemovePair:`
`98`	`100`	`{`
`99`		`- //TODO: readKey`
`100`		`- //TODO: readVal`
	`101`	`+ TKey key = reader.ReadValueTypeOrString<TKey>();`
	`102`	`+ TValue value = reader.ReadValueTypeOrString<TValue>();`
	`103`	`+ dictionary.Remove(new KeyValuePair<TKey, TValue>(key, value));`
`101`	`104`	`}`
`102`	`105`	`break;`
`103`	`106`	`case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Clear:`
`@@ -108,8 +111,10 @@ public void ReadDelta(BitReader reader)`
`108`	`111`	`break;`
`109`	`112`	`case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Value:`
`110`	`113`	`{`
`111`		`- //TODO: readKey`
`112`		`- //TODO: readVal`
	`114`	`+ TKey key = reader.ReadValueTypeOrString<TKey>();`
	`115`	`+ TValue value = reader.ReadValueTypeOrString<TValue>();`
	`116`	`+ if (dictionary.ContainsKey(key))`
	`117`	`+ dictionary[key] = value;`
`113`	`118`	`}`
`114`	`119`	`break;`
`115`	`120`	`default:`
`@@ -121,12 +126,13 @@ public void ReadDelta(BitReader reader)`
`121`	`126`	`/// <inheritdoc />`
`122`	`127`	`public void ReadField(BitReader reader)`
`123`	`128`	`{`
	`129`	`+ dictionary.Clear();`
`124`	`130`	`ushort entryCount = reader.ReadUShort();`
`125`		`-`
`126`	`131`	`for (int i = 0; i < entryCount; i++)`
`127`	`132`	`{`
`128`		`- //TODO: readKey`
`129`		`- //TODO: readVal`
	`133`	`+ TKey key = reader.ReadValueTypeOrString<TKey>();`
	`134`	`+ TValue value = reader.ReadValueTypeOrString<TValue>();`
	`135`	`+ dictionary.Add(key, value);`
`130`	`136`	`}`
`131`	`137`	`}`
`132`	`138`
`@@ -153,19 +159,19 @@ public void WriteDelta(BitWriter writer)`
`153`	`159`	`{`
`154`	`160`	`case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Add:`
`155`	`161`	`{`
`156`		`- //TODO: writeKey`
`157`		`- //TODO: writeVal`
	`162`	`+ writer.WriteValueTypeOrString(dirtyEvents[i].key);`
	`163`	`+ writer.WriteValueTypeOrString(dirtyEvents[i].value);`
`158`	`164`	`}`
`159`	`165`	`break;`
`160`	`166`	`case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Remove:`
`161`	`167`	`{`
`162`		`- //TODO: writeKey`
	`168`	`+ writer.WriteValueTypeOrString(dirtyEvents[i].key);`
`163`	`169`	`}`
`164`	`170`	`break;`
`165`	`171`	`case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.RemovePair:`
`166`	`172`	`{`
`167`		`- //TODO: writeKey`
`168`		`- //TODO: writeVal`
	`173`	`+ writer.WriteValueTypeOrString(dirtyEvents[i].key);`
	`174`	`+ writer.WriteValueTypeOrString(dirtyEvents[i].value);`
`169`	`175`	`}`
`170`	`176`	`break;`
`171`	`177`	`case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Clear:`
`@@ -175,8 +181,8 @@ public void WriteDelta(BitWriter writer)`
`175`	`181`	`break;`
`176`	`182`	`case NetworkedDictionaryEvent<TKey, TValue>.NetworkedListEventType.Value:`
`177`	`183`	`{`
`178`		`- //TODO: writeKey`
`179`		`- //TODO: writeVal`
	`184`	`+ writer.WriteValueTypeOrString(dirtyEvents[i].key);`
	`185`	`+ writer.WriteValueTypeOrString(dirtyEvents[i].value);`
`180`	`186`	`}`
`181`	`187`	`break;`
`182`	`188`	`default:`
`@@ -189,10 +195,10 @@ public void WriteDelta(BitWriter writer)`
`189`	`195`	`public void WriteField(BitWriter writer)`
`190`	`196`	`{`
`191`	`197`	`writer.WriteUShort((ushort)dictionary.Count);`
`192`		`- for (int i = 0; i < dictionary.Count; i++)`
	`198`	`+ foreach (KeyValuePair<TKey, TValue> pair in dictionary)`
`193`	`199`	`{`
`194`		`- //TODO: writeKey`
`195`		`- //TODO: writeVal`
	`200`	`+ writer.WriteValueTypeOrString(pair.Key);`
	`201`	`+ writer.WriteValueTypeOrString(pair.Value);`
`196`	`202`	`}`
`197`	`203`	`}`
`198`	`204`
Original file line number	Diff line number	Diff line change
`@@ -137,18 +137,18 @@ public void WriteDelta(BitWriter writer)`
`137`	`137`	`//Fuck me these signatures are proper aids`
`138`	`138`	`case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Add:`
`139`	`139`	`{`
`140`		`- //TODO: Write dirtyEvents[i].value`
	`140`	`+ writer.WriteValueTypeOrString(dirtyEvents[i].value);`
`141`	`141`	`}`
`142`	`142`	`break;`
`143`	`143`	`case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Insert:`
`144`	`144`	`{`
`145`	`145`	`writer.WriteInt(dirtyEvents[i].index);`
`146`		`- //TODO: Write dirtyEvents[i].value`
	`146`	`+ writer.WriteValueTypeOrString(dirtyEvents[i].value);`
`147`	`147`	`}`
`148`	`148`	`break;`
`149`	`149`	`case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Remove:`
`150`	`150`	`{`
`151`		`- //TODO: Write dirtyEvents[i].value`
	`151`	`+ writer.WriteValueTypeOrString(dirtyEvents[i].value);`
`152`	`152`	`}`
`153`	`153`	`break;`
`154`	`154`	`case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.RemoveAt:`
`@@ -159,7 +159,7 @@ public void WriteDelta(BitWriter writer)`
`159`	`159`	`case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Value:`
`160`	`160`	`{`
`161`	`161`	`writer.WriteInt(dirtyEvents[i].index);`
`162`		`- //TODO: Write dirtyEvents[i].value`
	`162`	`+ writer.WriteValueTypeOrString(dirtyEvents[i].value);`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`break;`
`@@ -178,17 +178,18 @@ public void WriteField(BitWriter writer)`
`178`	`178`	`writer.WriteUShort((ushort)list.Count);`
`179`	`179`	`for (int i = 0; i < list.Count; i++)`
`180`	`180`	`{`
`181`		`- //TODO: Write the fieldValue`
	`181`	`+ writer.WriteValueTypeOrString(list[i]);`
`182`	`182`	`}`
`183`	`183`	`}`
`184`	`184`
`185`	`185`	`/// <inheritdoc />`
`186`	`186`	`public void ReadField(BitReader reader)`
`187`	`187`	`{`
	`188`	`+ list.Clear();`
`188`	`189`	`ushort count = reader.ReadUShort();`
`189`	`190`	`for (int i = 0; i < count; i++)`
`190`	`191`	`{`
`191`		`- //TODO: Read element`
	`192`	`+ list.Add(reader.ReadValueTypeOrString<T>());`
`192`	`193`	`}`
`193`	`194`	`}`
`194`	`195`
`@@ -203,18 +204,18 @@ public void ReadDelta(BitReader reader)`
`203`	`204`	`{`
`204`	`205`	`case NetworkedListEvent<T>.NetworkedListEventType.Add:`
`205`	`206`	`{`
`206`		`- //TODO: list.Add(readValue);`
	`207`	`+ list.Add(reader.ReadValueTypeOrString<T>());`
`207`	`208`	`}`
`208`	`209`	`break;`
`209`	`210`	`case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Insert:`
`210`	`211`	`{`
`211`	`212`	`int index = reader.ReadInt();`
`212`		`- //TODO: list.Insert(index, readValue);`
	`213`	`+ list.Insert(index, reader.ReadValueTypeOrString<T>());`
`213`	`214`	`}`
`214`	`215`	`break;`
`215`	`216`	`case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Remove:`
`216`	`217`	`{`
`217`		`- //TODO: list.Remove(readValue);`
	`218`	`+ list.Remove(reader.ReadValueTypeOrString<T>());`
`218`	`219`	`}`
`219`	`220`	`break;`
`220`	`221`	`case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.RemoveAt:`
`@@ -226,7 +227,7 @@ public void ReadDelta(BitReader reader)`
`226`	`227`	`case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Value:`
`227`	`228`	`{`
`228`	`229`	`int index = reader.ReadInt();`
`229`		`- //TODO: list[index] = readValue`
	`230`	`+ if (index < list.Count) list[index] = reader.ReadValueTypeOrString<T>();`
`230`	`231`	`}`
`231`	`232`	`break;`
`232`	`233`	`case NetworkedList<T>.NetworkedListEvent<T>.NetworkedListEventType.Clear:`
Original file line number	Diff line number	Diff line change
`@@ -152,17 +152,16 @@ public void SetNetworkedBehaviour(NetworkedBehaviour behaviour)`
`152`	`152`	`/// <inheritdoc />`
`153`	`153`	`public void ReadField(BitReader reader)`
`154`	`154`	`{`
`155`		`- // TODO TwoTen - Boxing sucks`
`156`	`155`	`T previousValue = InternalValue;`
`157`		`- InternalValue = (T)FieldTypeHelper.ReadFieldType(reader, typeof(T), (object)InternalValue);`
	`156`	`+ InternalValue = reader.ReadValueTypeOrString<T>();`
`158`	`157`	`if (OnValueChanged != null)`
`159`	`158`	`OnValueChanged(previousValue, InternalValue);`
`160`	`159`	`}`
`161`	`160`
`162`	`161`	`/// <inheritdoc />`
`163`	`162`	`public void WriteField(BitWriter writer)`
`164`	`163`	`{`
`165`		`- //TODO: Write field`
	`164`	`+ writer.WriteValueTypeOrString(InternalValue);`
`166`	`165`	`}`
`167`	`166`
`168`	`167`	`/// <inheritdoc />`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,8 @@ private void Push<T>(T b)`
`102`	`102`	`if (LogHelper.CurrentLogLevel <= LogLevel.Normal) LogHelper.LogWarning("The type \"" + b.GetType() + "\" is not supported by the Binary Serializer. It will be ignored");`
`103`	`103`	`}`
`104`	`104`
`105`		`-`
	`105`	`+ public void WriteValueTypeOrString<T>(T t) => Push(t);`
	`106`	`+ public void WriteValueType(ValueType v) => Push(v);`
`106`	`107`	`public void WriteBool(bool b) => Push(b);`
`107`	`108`	`public void WriteFloat(float f) => Push(f);`
`108`	`109`	`public void WriteDouble(double d) => Push(d);`