public static object From_Bytes(Type type, byte[] buffer, int index = 0) { if (type == typeof(Byte)) { return(Bit_Conversion <Byte> .From_Bytes(buffer, index)); } else if (type == typeof(SByte)) { return(Bit_Conversion <SByte> .From_Bytes(buffer, index)); } else if (type == typeof(Boolean)) { return(Bit_Conversion <Boolean> .From_Bytes(buffer, index)); } else if (type == typeof(Int16)) { return(Bit_Conversion <Int16> .From_Bytes(buffer, index)); } else if (type == typeof(UInt16)) { return(Bit_Conversion <UInt16> .From_Bytes(buffer, index)); } else if (type == typeof(Int32)) { return(Bit_Conversion <Int32> .From_Bytes(buffer, index)); } else if (type == typeof(UInt32)) { return(Bit_Conversion <UInt32> .From_Bytes(buffer, index)); } else if (type == typeof(Int64)) { return(Bit_Conversion <Int64> .From_Bytes(buffer, index)); } else if (type == typeof(UInt64)) { return(Bit_Conversion <UInt64> .From_Bytes(buffer, index)); } else if (type == typeof(Single)) { return(Bit_Conversion <Single> .From_Bytes(buffer, index)); } else if (type == typeof(Double)) { return(Bit_Conversion <Double> .From_Bytes(buffer, index)); } else if (type.IsEnum) { var obj = From_Bytes(type.GetEnumUnderlyingType(), buffer, index); return(Convert.ChangeType(obj, type)); } else if (type == typeof(Char)) { throw new NotSupportedException("Chars should be converted via a given Encoding!"); } else { throw new NotSupportedException("non templated Bit_Conversion can only be used for primitive types"); } }
public void Deserialize <T>(out T value) { if (Bit_Conversion <T> .Is_Supported) { var bytes = stream.Read_Bytes(Bit_Conversion <T> .Bytes_Needed); if (swap_endianness) { Array.Reverse(bytes); } value = Bit_Conversion <T> .From_Bytes(bytes); } else { Linear_Serialization_Helper <T> .Deserialize(this, out value); } }
//NOTE: C# doesn't support template specialization, so to kind of mimick that we: // 1) use overloading (meaning even for Deserialize we use out, instead of just returning) // 2) use runtime reflection to bind to the given extension method (done only once, using static constructors) public void Serialize <T>(T value) { //primitive types will be handled here... if (Bit_Conversion <T> .Is_Supported) { var bytes = Bit_Conversion <T> .To_Bytes(value); if (swap_endianness) { Array.Reverse(bytes); } stream.Write(bytes, 0, bytes.Length); } else { //...everything else will go via their extension, and come back to this method for individual fields Linear_Serialization_Helper <T> .Serialize(this, value); } }
public static byte[] To_Bytes(object obj) { Type type = obj.GetType(); if (type == typeof(Byte)) { return(Bit_Conversion <Byte> .To_Bytes((Byte)obj)); } else if (type == typeof(SByte)) { return(Bit_Conversion <SByte> .To_Bytes((SByte)obj)); } else if (type == typeof(Boolean)) { return(Bit_Conversion <Boolean> .To_Bytes((Boolean)obj)); } else if (type == typeof(Int16)) { return(Bit_Conversion <Int16> .To_Bytes((Int16)obj)); } else if (type == typeof(UInt16)) { return(Bit_Conversion <UInt16> .To_Bytes((UInt16)obj)); } else if (type == typeof(Int32)) { return(Bit_Conversion <Int32> .To_Bytes((Int32)obj)); } else if (type == typeof(UInt32)) { return(Bit_Conversion <UInt32> .To_Bytes((UInt32)obj)); } else if (type == typeof(Int64)) { return(Bit_Conversion <Int64> .To_Bytes((Int64)obj)); } else if (type == typeof(UInt64)) { return(Bit_Conversion <UInt64> .To_Bytes((UInt64)obj)); } else if (type == typeof(Single)) { return(Bit_Conversion <Single> .To_Bytes((Single)obj)); } else if (type == typeof(Double)) { return(Bit_Conversion <Double> .To_Bytes((Double)obj)); } else if (type.IsEnum) { return(To_Bytes(Convert_Enum_To_Underlying_Type((Enum)obj))); } else if (type == typeof(Char)) { throw new NotSupportedException("Chars should be converted via a given Encoding!"); } else { throw new NotSupportedException("non templated Bit_Conversion can only be used for primitive types"); } }