Nie możesz wybrać więcej, niż 25 tematów
Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
2051 wiersze
57 KiB
2051 wiersze
57 KiB
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.IO;
|
|
using MiscUtil.Conversion;
|
|
using MiscUtil.IO;
|
|
|
|
namespace GenProto
|
|
{
|
|
public static class ProtocolCore
|
|
{
|
|
public interface ISerialize
|
|
{
|
|
void Serialize(EndianBinaryWriter binaryWriter);
|
|
byte[] Serialize();
|
|
}
|
|
|
|
public interface IDeserialize<T>
|
|
{
|
|
void Deserialize(EndianBinaryReader binaryReader);
|
|
void Deserialize(byte[] data);
|
|
}
|
|
|
|
public enum BasicTypeEnum
|
|
{
|
|
Custom = 0x00,
|
|
Boolean = 0x01,
|
|
Int8 = 0x02,
|
|
UInt8 = 0x03,
|
|
UInt16 = 0x04,
|
|
Int16 = 0x05,
|
|
Int32 = 0x06,
|
|
UInt32 = 0x07,
|
|
Int64 = 0x08,
|
|
UInt64 = 0x09,
|
|
Float = 0x10,
|
|
Double = 0x11,
|
|
String = 0x12,
|
|
}
|
|
|
|
public static BasicTypeEnum JudgeType<T>(T value)
|
|
{
|
|
return value switch
|
|
{
|
|
bool => BasicTypeEnum.Boolean,
|
|
byte => BasicTypeEnum.Int8,
|
|
sbyte => BasicTypeEnum.UInt8,
|
|
ushort => BasicTypeEnum.UInt16,
|
|
short => BasicTypeEnum.Int16,
|
|
int => BasicTypeEnum.Int32,
|
|
uint => BasicTypeEnum.UInt32,
|
|
long => BasicTypeEnum.Int64,
|
|
ulong => BasicTypeEnum.UInt64,
|
|
float => BasicTypeEnum.Float,
|
|
double => BasicTypeEnum.Double,
|
|
string => BasicTypeEnum.String,
|
|
_ => BasicTypeEnum.Custom,
|
|
};
|
|
}
|
|
|
|
public static void WriteValue<T>(this EndianBinaryWriter binaryWriter, T value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case bool boolValue:
|
|
binaryWriter.Write(boolValue);
|
|
break;
|
|
case byte byteValue:
|
|
binaryWriter.Write(byteValue);
|
|
break;
|
|
case sbyte sbyteValue:
|
|
binaryWriter.Write(sbyteValue);
|
|
break;
|
|
case ushort ushortValue:
|
|
binaryWriter.Write(ushortValue);
|
|
break;
|
|
case short shortValue:
|
|
binaryWriter.Write(shortValue);
|
|
break;
|
|
case int intValue:
|
|
binaryWriter.Write(intValue);
|
|
break;
|
|
case uint uintValue:
|
|
binaryWriter.Write(uintValue);
|
|
break;
|
|
case long longValue:
|
|
binaryWriter.Write(longValue);
|
|
break;
|
|
case ulong ulongValue:
|
|
binaryWriter.Write(ulongValue);
|
|
break;
|
|
case float floatValue:
|
|
binaryWriter.Write(floatValue);
|
|
break;
|
|
case double doubleValue:
|
|
binaryWriter.Write(doubleValue);
|
|
break;
|
|
case string stringValue:
|
|
var bytesLength = (ushort)binaryWriter.Encoding.GetByteCount(stringValue);
|
|
binaryWriter.Write(bytesLength);
|
|
var bytes = binaryWriter.Encoding.GetBytes(stringValue);
|
|
binaryWriter.Write(bytes);
|
|
break;
|
|
default:
|
|
{
|
|
switch (value)
|
|
{
|
|
case IList listValue:
|
|
binaryWriter.WriteList(listValue);
|
|
break;
|
|
case ISerialize serialize:
|
|
serialize.Serialize(binaryWriter);
|
|
break;
|
|
default:
|
|
if (value != null)
|
|
{
|
|
throw new InvalidOperationException($"unexpect type: {value.GetType().FullName}");
|
|
}
|
|
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static void WriteList(this EndianBinaryWriter binaryWriter, IList list)
|
|
{
|
|
var length = (ushort)(list?.Count ?? 0);
|
|
binaryWriter.Write(length);
|
|
|
|
if (list == null) return;
|
|
for (var idx = 0; idx < length; idx++)
|
|
{
|
|
var value = list[idx];
|
|
binaryWriter.WriteValue(value);
|
|
}
|
|
}
|
|
|
|
public static void ReadValue(this EndianBinaryReader binaryReader, out bool value)
|
|
{
|
|
value = binaryReader.ReadBoolean();
|
|
}
|
|
|
|
public static void ReadValue(this EndianBinaryReader binaryReader, out sbyte value)
|
|
{
|
|
value = binaryReader.ReadSByte();
|
|
}
|
|
|
|
public static void ReadValue(this EndianBinaryReader binaryReader, out byte value)
|
|
{
|
|
value = binaryReader.ReadByte();
|
|
}
|
|
|
|
public static void ReadValue(this EndianBinaryReader binaryReader, out ushort value)
|
|
{
|
|
value = binaryReader.ReadUInt16();
|
|
}
|
|
|
|
public static void ReadValue(this EndianBinaryReader binaryReader, out short value)
|
|
{
|
|
value = binaryReader.ReadInt16();
|
|
}
|
|
|
|
public static void ReadValue(this EndianBinaryReader binaryReader, out int value)
|
|
{
|
|
value = binaryReader.ReadInt32();
|
|
}
|
|
|
|
public static void ReadValue(this EndianBinaryReader binaryReader, out uint value)
|
|
{
|
|
value = binaryReader.ReadUInt32();
|
|
}
|
|
|
|
public static void ReadValue(this EndianBinaryReader binaryReader, out long value)
|
|
{
|
|
value = binaryReader.ReadInt64();
|
|
}
|
|
|
|
public static void ReadValue(this EndianBinaryReader binaryReader, out ulong value)
|
|
{
|
|
value = binaryReader.ReadUInt64();
|
|
}
|
|
|
|
public static void ReadValue(this EndianBinaryReader binaryReader, out float value)
|
|
{
|
|
value = binaryReader.ReadSingle();
|
|
}
|
|
|
|
public static void ReadValue(this EndianBinaryReader binaryReader, out double value)
|
|
{
|
|
value = binaryReader.ReadDouble();
|
|
}
|
|
|
|
public static void ReadValue(this EndianBinaryReader binaryReader, out string value)
|
|
{
|
|
var bytesLength = binaryReader.ReadUInt16();
|
|
var bytes = binaryReader.ReadBytes(bytesLength);
|
|
value = binaryReader.Encoding.GetString(bytes, 0, bytes.Length);
|
|
}
|
|
|
|
public static void ReadValue<T>(this EndianBinaryReader binaryReader, out T value) where T : new()
|
|
{
|
|
value = default;
|
|
value = new T();
|
|
if (value is not IDeserialize<T> deserialize)
|
|
{
|
|
throw new InvalidOperationException($"error type: {typeof(T).FullName}");
|
|
}
|
|
|
|
deserialize.Deserialize(binaryReader);
|
|
}
|
|
|
|
public static void ReadValue<T>(this EndianBinaryReader binaryReader, out List<T> outList, BasicTypeEnum basicTypeEnum) where T : new()
|
|
{
|
|
outList = default;
|
|
IList list = default;
|
|
|
|
var length = binaryReader.ReadUInt16();
|
|
if (length <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (var idx = 0; idx < length; idx++)
|
|
{
|
|
switch (basicTypeEnum)
|
|
{
|
|
case BasicTypeEnum.Boolean:
|
|
list ??= new List<bool>(length);
|
|
var boolValue = binaryReader.ReadBoolean();
|
|
list.Add(boolValue);
|
|
break;
|
|
case BasicTypeEnum.Int8:
|
|
list ??= new List<sbyte>(length);
|
|
var sbyteValue = binaryReader.ReadSByte();
|
|
list.Add(sbyteValue);
|
|
break;
|
|
case BasicTypeEnum.UInt8:
|
|
list ??= new List<byte>(length);
|
|
var byteValue = binaryReader.ReadByte();
|
|
list.Add(byteValue);
|
|
break;
|
|
case BasicTypeEnum.UInt16:
|
|
list ??= new List<ushort>(length);
|
|
var ushortValue = binaryReader.ReadUInt16();
|
|
list.Add(ushortValue);
|
|
break;
|
|
case BasicTypeEnum.Int16:
|
|
list ??= new List<short>(length);
|
|
var shortValue = binaryReader.ReadInt16();
|
|
list.Add(shortValue);
|
|
break;
|
|
case BasicTypeEnum.Int32:
|
|
list ??= new List<int>(length);
|
|
var intValue = binaryReader.ReadInt32();
|
|
list.Add(intValue);
|
|
break;
|
|
case BasicTypeEnum.UInt32:
|
|
list ??= new List<uint>(length);
|
|
var uintValue = binaryReader.ReadUInt32();
|
|
list.Add(uintValue);
|
|
break;
|
|
case BasicTypeEnum.Int64:
|
|
list ??= new List<long>(length);
|
|
var longValue = binaryReader.ReadInt64();
|
|
list.Add(longValue);
|
|
break;
|
|
case BasicTypeEnum.UInt64:
|
|
list ??= new List<ulong>(length);
|
|
var ulongValue = binaryReader.ReadUInt64();
|
|
list.Add(ulongValue);
|
|
break;
|
|
case BasicTypeEnum.Float:
|
|
list ??= new List<float>(length);
|
|
var singleValue = binaryReader.ReadSingle();
|
|
list.Add(singleValue);
|
|
break;
|
|
case BasicTypeEnum.Double:
|
|
list ??= new List<double>(length);
|
|
var doubleValue = binaryReader.ReadDouble();
|
|
list.Add(doubleValue);
|
|
break;
|
|
case BasicTypeEnum.String:
|
|
list ??= new List<string>(length);
|
|
var stringValue = binaryReader.ReadString();
|
|
list.Add(stringValue);
|
|
break;
|
|
case BasicTypeEnum.Custom:
|
|
list ??= new List<T>(length);
|
|
if (new T() is IDeserialize<T> item)
|
|
{
|
|
item.Deserialize(binaryReader);
|
|
list.Add(item);
|
|
}
|
|
break;
|
|
default:
|
|
throw new InvalidOperationException();
|
|
}
|
|
}
|
|
|
|
outList = list as List<T>;
|
|
}
|
|
} public class test : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<test>
|
|
{
|
|
public const int ProtoId = 1;
|
|
public string aa;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(aa);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out aa);
|
|
}
|
|
}
|
|
public class phoneNumber : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<phoneNumber>
|
|
{
|
|
public const int ProtoId = 2;
|
|
public test number;
|
|
public int type;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
if (number != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(number);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
binaryWriter.WriteValue(type);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out number);
|
|
}
|
|
binaryReader.ReadValue(out type);
|
|
}
|
|
}
|
|
public class person : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<person>
|
|
{
|
|
public const int ProtoId = 3;
|
|
public string name;
|
|
public int id;
|
|
public string email;
|
|
public List<phoneNumber> phone;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(name);
|
|
binaryWriter.WriteValue(id);
|
|
binaryWriter.WriteValue(email);
|
|
binaryWriter.WriteValue(phone);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out name);
|
|
binaryReader.ReadValue(out id);
|
|
binaryReader.ReadValue(out email);
|
|
binaryReader.ReadValue(out phone, ProtocolCore.BasicTypeEnum.Custom);
|
|
}
|
|
}
|
|
public class addressBook : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<addressBook>
|
|
{
|
|
public const int ProtoId = 4;
|
|
public List<person> person;
|
|
public List<person> other;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(person);
|
|
binaryWriter.WriteValue(other);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out person, ProtocolCore.BasicTypeEnum.Custom);
|
|
binaryReader.ReadValue(out other, ProtocolCore.BasicTypeEnum.Custom);
|
|
}
|
|
}
|
|
public class union : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<union>
|
|
{
|
|
public const int ProtoId = 5;
|
|
public string test;
|
|
public int type;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(test);
|
|
binaryWriter.WriteValue(type);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out test);
|
|
binaryReader.ReadValue(out type);
|
|
}
|
|
}
|
|
public class tbool : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tbool>
|
|
{
|
|
public const int ProtoId = 6;
|
|
public bool bool;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(bool);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out bool);
|
|
}
|
|
}
|
|
public class tint8 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tint8>
|
|
{
|
|
public const int ProtoId = 7;
|
|
public sbyte int1;
|
|
public sbyte int2;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
binaryWriter.WriteValue(int2);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
binaryReader.ReadValue(out int2);
|
|
}
|
|
}
|
|
public class tuint8 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tuint8>
|
|
{
|
|
public const int ProtoId = 8;
|
|
public byte int1;
|
|
public byte int2;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
binaryWriter.WriteValue(int2);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
binaryReader.ReadValue(out int2);
|
|
}
|
|
}
|
|
public class tint16 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tint16>
|
|
{
|
|
public const int ProtoId = 9;
|
|
public short int1;
|
|
public short int2;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
binaryWriter.WriteValue(int2);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
binaryReader.ReadValue(out int2);
|
|
}
|
|
}
|
|
public class tuint16 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tuint16>
|
|
{
|
|
public const int ProtoId = 10;
|
|
public ushort int1;
|
|
public ushort int2;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
binaryWriter.WriteValue(int2);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
binaryReader.ReadValue(out int2);
|
|
}
|
|
}
|
|
public class tint32 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tint32>
|
|
{
|
|
public const int ProtoId = 11;
|
|
public int int1;
|
|
public int int2;
|
|
public int int3;
|
|
public int int4;
|
|
public int int5;
|
|
public int int6;
|
|
public int int7;
|
|
public int int8;
|
|
public int int9;
|
|
public int int10;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
binaryWriter.WriteValue(int2);
|
|
binaryWriter.WriteValue(int3);
|
|
binaryWriter.WriteValue(int4);
|
|
binaryWriter.WriteValue(int5);
|
|
binaryWriter.WriteValue(int6);
|
|
binaryWriter.WriteValue(int7);
|
|
binaryWriter.WriteValue(int8);
|
|
binaryWriter.WriteValue(int9);
|
|
binaryWriter.WriteValue(int10);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
binaryReader.ReadValue(out int2);
|
|
binaryReader.ReadValue(out int3);
|
|
binaryReader.ReadValue(out int4);
|
|
binaryReader.ReadValue(out int5);
|
|
binaryReader.ReadValue(out int6);
|
|
binaryReader.ReadValue(out int7);
|
|
binaryReader.ReadValue(out int8);
|
|
binaryReader.ReadValue(out int9);
|
|
binaryReader.ReadValue(out int10);
|
|
}
|
|
}
|
|
public class tuint32 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tuint32>
|
|
{
|
|
public const int ProtoId = 12;
|
|
public uint int1;
|
|
public uint int2;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
binaryWriter.WriteValue(int2);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
binaryReader.ReadValue(out int2);
|
|
}
|
|
}
|
|
public class tint64 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tint64>
|
|
{
|
|
public const int ProtoId = 13;
|
|
public long int1;
|
|
public long int2;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
binaryWriter.WriteValue(int2);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
binaryReader.ReadValue(out int2);
|
|
}
|
|
}
|
|
public class tuint64 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tuint64>
|
|
{
|
|
public const int ProtoId = 14;
|
|
public ulong int1;
|
|
public ulong int2;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
binaryWriter.WriteValue(int2);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
binaryReader.ReadValue(out int2);
|
|
}
|
|
}
|
|
public class tinteger : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tinteger>
|
|
{
|
|
public const int ProtoId = 15;
|
|
public integer int1;
|
|
public integer int2;
|
|
public integer int3;
|
|
public integer int4;
|
|
public integer int5;
|
|
public integer int6;
|
|
public integer int7;
|
|
public integer int8;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
if (int1 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int2 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int2);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int3 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int3);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int4 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int4);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int5 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int5);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int6 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int6);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int7 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int7);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int8 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int8);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int2);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int3);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int4);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int5);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int6);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int7);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int8);
|
|
}
|
|
}
|
|
}
|
|
public class tnumber : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tnumber>
|
|
{
|
|
public const int ProtoId = 16;
|
|
public number int1;
|
|
public number int2;
|
|
public number int3;
|
|
public number int4;
|
|
public number int5;
|
|
public number int6;
|
|
public number int7;
|
|
public number int8;
|
|
public number float1;
|
|
public number float2;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
if (int1 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int2 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int2);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int3 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int3);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int4 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int4);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int5 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int5);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int6 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int6);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int7 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int7);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (int8 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(int8);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (float1 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(float1);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (float2 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(float2);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int2);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int3);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int4);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int5);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int6);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int7);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out int8);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out float1);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out float2);
|
|
}
|
|
}
|
|
}
|
|
public class tfloat : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tfloat>
|
|
{
|
|
public const int ProtoId = 17;
|
|
public float int1;
|
|
public float int2;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
binaryWriter.WriteValue(int2);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
binaryReader.ReadValue(out int2);
|
|
}
|
|
}
|
|
public class tdouble : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tdouble>
|
|
{
|
|
public const int ProtoId = 18;
|
|
public double int1;
|
|
public double int2;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
binaryWriter.WriteValue(int2);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
binaryReader.ReadValue(out int2);
|
|
}
|
|
}
|
|
public class tstring : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tstring>
|
|
{
|
|
public const int ProtoId = 19;
|
|
public string int1;
|
|
public string int2;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
binaryWriter.WriteValue(int2);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1);
|
|
binaryReader.ReadValue(out int2);
|
|
}
|
|
}
|
|
public class tlistbool : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistbool>
|
|
{
|
|
public const int ProtoId = 20;
|
|
public List<bool> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.Boolean);
|
|
}
|
|
}
|
|
public class tlistint8 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistint8>
|
|
{
|
|
public const int ProtoId = 21;
|
|
public List<sbyte> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.Int8);
|
|
}
|
|
}
|
|
public class tlistuint8 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistuint8>
|
|
{
|
|
public const int ProtoId = 22;
|
|
public List<byte> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.UInt8);
|
|
}
|
|
}
|
|
public class tlistint16 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistint16>
|
|
{
|
|
public const int ProtoId = 23;
|
|
public List<short> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.Int16);
|
|
}
|
|
}
|
|
public class tlistuint16 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistuint16>
|
|
{
|
|
public const int ProtoId = 24;
|
|
public List<ushort> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.UInt16);
|
|
}
|
|
}
|
|
public class tlistint32 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistint32>
|
|
{
|
|
public const int ProtoId = 25;
|
|
public List<int> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.Int32);
|
|
}
|
|
}
|
|
public class tlistuint32 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistuint32>
|
|
{
|
|
public const int ProtoId = 26;
|
|
public List<uint> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.UInt32);
|
|
}
|
|
}
|
|
public class tlistint64 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistint64>
|
|
{
|
|
public const int ProtoId = 27;
|
|
public List<long> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.Int64);
|
|
}
|
|
}
|
|
public class tlistuint64 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistuint64>
|
|
{
|
|
public const int ProtoId = 28;
|
|
public List<ulong> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.UInt64);
|
|
}
|
|
}
|
|
public class tlistinteger : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistinteger>
|
|
{
|
|
public const int ProtoId = 29;
|
|
public List<integer> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.Custom);
|
|
}
|
|
}
|
|
public class tlistnumber : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistnumber>
|
|
{
|
|
public const int ProtoId = 30;
|
|
public List<number> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.Custom);
|
|
}
|
|
}
|
|
public class tlistfloat : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistfloat>
|
|
{
|
|
public const int ProtoId = 31;
|
|
public List<float> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.Float);
|
|
}
|
|
}
|
|
public class tlistdouble : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistdouble>
|
|
{
|
|
public const int ProtoId = 32;
|
|
public List<double> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.Double);
|
|
}
|
|
}
|
|
public class tliststring : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tliststring>
|
|
{
|
|
public const int ProtoId = 33;
|
|
public List<string> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.String);
|
|
}
|
|
}
|
|
public class tlistunion : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistunion>
|
|
{
|
|
public const int ProtoId = 34;
|
|
public List<union> int1;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(int1);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out int1, ProtocolCore.BasicTypeEnum.Custom);
|
|
}
|
|
}
|
|
public class allType : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<allType>
|
|
{
|
|
public const int ProtoId = 35;
|
|
public bool bool;
|
|
public sbyte int8;
|
|
public byte uint8;
|
|
public short int16;
|
|
public ushort uint16;
|
|
public int int32;
|
|
public uint uint32;
|
|
public long int64;
|
|
public ulong uint64;
|
|
public integer inte8;
|
|
public integer uinte8;
|
|
public integer inte16;
|
|
public integer uinte16;
|
|
public integer inte32;
|
|
public integer uinte32;
|
|
public integer inte64;
|
|
public integer uinte64;
|
|
public number num8;
|
|
public number unum8;
|
|
public number num16;
|
|
public number unum16;
|
|
public number num32;
|
|
public number unum32;
|
|
public number num64;
|
|
public number unum64;
|
|
public number numfloat;
|
|
public number numdouble;
|
|
public float float;
|
|
public double double;
|
|
public string string1;
|
|
public string string2;
|
|
public union union;
|
|
public List<bool> lbool;
|
|
public List<sbyte> lint8;
|
|
public List<byte> luint8;
|
|
public List<short> lint16;
|
|
public List<ushort> luint16;
|
|
public List<int> lint32;
|
|
public List<uint> luint32;
|
|
public List<long> lint64;
|
|
public List<ulong> luint64;
|
|
public List<integer> linte8;
|
|
public List<integer> linte16;
|
|
public List<integer> linte32;
|
|
public List<integer> linte64;
|
|
public List<number> lnum8;
|
|
public List<number> lnum16;
|
|
public List<number> lnum32;
|
|
public List<number> lnum64;
|
|
public List<number> lnfloat32;
|
|
public List<number> lnfloat64;
|
|
public List<float> lfloat;
|
|
public List<double> ldouble;
|
|
public List<string> lstring;
|
|
public List<union> lunion;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(bool);
|
|
binaryWriter.WriteValue(int8);
|
|
binaryWriter.WriteValue(uint8);
|
|
binaryWriter.WriteValue(int16);
|
|
binaryWriter.WriteValue(uint16);
|
|
binaryWriter.WriteValue(int32);
|
|
binaryWriter.WriteValue(uint32);
|
|
binaryWriter.WriteValue(int64);
|
|
binaryWriter.WriteValue(uint64);
|
|
if (inte8 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(inte8);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (uinte8 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(uinte8);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (inte16 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(inte16);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (uinte16 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(uinte16);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (inte32 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(inte32);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (uinte32 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(uinte32);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (inte64 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(inte64);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (uinte64 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(uinte64);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (num8 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(num8);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (unum8 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(unum8);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (num16 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(num16);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (unum16 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(unum16);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (num32 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(num32);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (unum32 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(unum32);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (num64 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(num64);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (unum64 != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(unum64);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (numfloat != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(numfloat);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
if (numdouble != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(numdouble);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
binaryWriter.WriteValue(float);
|
|
binaryWriter.WriteValue(double);
|
|
binaryWriter.WriteValue(string1);
|
|
binaryWriter.WriteValue(string2);
|
|
if (union != null)
|
|
{
|
|
binaryWriter.WriteValue(1);
|
|
binaryWriter.WriteValue(union);
|
|
}
|
|
else
|
|
{
|
|
binaryWriter.WriteValue(0);
|
|
}
|
|
binaryWriter.WriteValue(lbool);
|
|
binaryWriter.WriteValue(lint8);
|
|
binaryWriter.WriteValue(luint8);
|
|
binaryWriter.WriteValue(lint16);
|
|
binaryWriter.WriteValue(luint16);
|
|
binaryWriter.WriteValue(lint32);
|
|
binaryWriter.WriteValue(luint32);
|
|
binaryWriter.WriteValue(lint64);
|
|
binaryWriter.WriteValue(luint64);
|
|
binaryWriter.WriteValue(linte8);
|
|
binaryWriter.WriteValue(linte16);
|
|
binaryWriter.WriteValue(linte32);
|
|
binaryWriter.WriteValue(linte64);
|
|
binaryWriter.WriteValue(lnum8);
|
|
binaryWriter.WriteValue(lnum16);
|
|
binaryWriter.WriteValue(lnum32);
|
|
binaryWriter.WriteValue(lnum64);
|
|
binaryWriter.WriteValue(lnfloat32);
|
|
binaryWriter.WriteValue(lnfloat64);
|
|
binaryWriter.WriteValue(lfloat);
|
|
binaryWriter.WriteValue(ldouble);
|
|
binaryWriter.WriteValue(lstring);
|
|
binaryWriter.WriteValue(lunion);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out bool);
|
|
binaryReader.ReadValue(out int8);
|
|
binaryReader.ReadValue(out uint8);
|
|
binaryReader.ReadValue(out int16);
|
|
binaryReader.ReadValue(out uint16);
|
|
binaryReader.ReadValue(out int32);
|
|
binaryReader.ReadValue(out uint32);
|
|
binaryReader.ReadValue(out int64);
|
|
binaryReader.ReadValue(out uint64);
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out inte8);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out uinte8);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out inte16);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out uinte16);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out inte32);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out uinte32);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out inte64);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out uinte64);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out num8);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out unum8);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out num16);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out unum16);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out num32);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out unum32);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out num64);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out unum64);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out numfloat);
|
|
}
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out numdouble);
|
|
}
|
|
binaryReader.ReadValue(out float);
|
|
binaryReader.ReadValue(out double);
|
|
binaryReader.ReadValue(out string1);
|
|
binaryReader.ReadValue(out string2);
|
|
if (binaryReader.ReadBoolean())
|
|
{
|
|
binaryReader.ReadValue(out union);
|
|
}
|
|
binaryReader.ReadValue(out lbool, ProtocolCore.BasicTypeEnum.Boolean);
|
|
binaryReader.ReadValue(out lint8, ProtocolCore.BasicTypeEnum.Int8);
|
|
binaryReader.ReadValue(out luint8, ProtocolCore.BasicTypeEnum.UInt8);
|
|
binaryReader.ReadValue(out lint16, ProtocolCore.BasicTypeEnum.Int16);
|
|
binaryReader.ReadValue(out luint16, ProtocolCore.BasicTypeEnum.UInt16);
|
|
binaryReader.ReadValue(out lint32, ProtocolCore.BasicTypeEnum.Int32);
|
|
binaryReader.ReadValue(out luint32, ProtocolCore.BasicTypeEnum.UInt32);
|
|
binaryReader.ReadValue(out lint64, ProtocolCore.BasicTypeEnum.Int64);
|
|
binaryReader.ReadValue(out luint64, ProtocolCore.BasicTypeEnum.UInt64);
|
|
binaryReader.ReadValue(out linte8, ProtocolCore.BasicTypeEnum.Custom);
|
|
binaryReader.ReadValue(out linte16, ProtocolCore.BasicTypeEnum.Custom);
|
|
binaryReader.ReadValue(out linte32, ProtocolCore.BasicTypeEnum.Custom);
|
|
binaryReader.ReadValue(out linte64, ProtocolCore.BasicTypeEnum.Custom);
|
|
binaryReader.ReadValue(out lnum8, ProtocolCore.BasicTypeEnum.Custom);
|
|
binaryReader.ReadValue(out lnum16, ProtocolCore.BasicTypeEnum.Custom);
|
|
binaryReader.ReadValue(out lnum32, ProtocolCore.BasicTypeEnum.Custom);
|
|
binaryReader.ReadValue(out lnum64, ProtocolCore.BasicTypeEnum.Custom);
|
|
binaryReader.ReadValue(out lnfloat32, ProtocolCore.BasicTypeEnum.Custom);
|
|
binaryReader.ReadValue(out lnfloat64, ProtocolCore.BasicTypeEnum.Custom);
|
|
binaryReader.ReadValue(out lfloat, ProtocolCore.BasicTypeEnum.Float);
|
|
binaryReader.ReadValue(out ldouble, ProtocolCore.BasicTypeEnum.Double);
|
|
binaryReader.ReadValue(out lstring, ProtocolCore.BasicTypeEnum.String);
|
|
binaryReader.ReadValue(out lunion, ProtocolCore.BasicTypeEnum.Custom);
|
|
}
|
|
}
|
|
public class testnull : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<testnull>
|
|
{
|
|
public const int ProtoId = 36;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
}
|
|
}
|
|
public class person1 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<person1>
|
|
{
|
|
public const int ProtoId = 1001;
|
|
public string name;
|
|
public int id;
|
|
public string email;
|
|
public List<phoneNumber> phone;
|
|
|
|
public byte[] Serialize()
|
|
{
|
|
using var memoryStream = new MemoryStream();
|
|
using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
|
|
Serialize(binaryWriter);
|
|
return memoryStream.ToArray();
|
|
}
|
|
|
|
public void Deserialize(byte[] data)
|
|
{
|
|
using var memoryStream = new MemoryStream(data);
|
|
using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
|
|
Deserialize(binaryReader);
|
|
}
|
|
public void Serialize(EndianBinaryWriter binaryWriter)
|
|
{
|
|
binaryWriter.WriteValue(name);
|
|
binaryWriter.WriteValue(id);
|
|
binaryWriter.WriteValue(email);
|
|
binaryWriter.WriteValue(phone);
|
|
}
|
|
public void Deserialize(EndianBinaryReader binaryReader)
|
|
{
|
|
binaryReader.ReadValue(out name);
|
|
binaryReader.ReadValue(out id);
|
|
binaryReader.ReadValue(out email);
|
|
binaryReader.ReadValue(out phone, ProtocolCore.BasicTypeEnum.Custom);
|
|
}
|
|
}
|
|
}
|