/// <summary>
/// 反序列化父节点
/// </summary>
/// <param name="deSerializer"></param>
protected void deSerializeParent(AutoCSer.BinaryDeSerializer deSerializer)
{
if (deSerializer.CheckNullValue() != 0)
{
DeSerialize(deSerializer, out Parent);
}
}
protected void deSerializeParameter <parameterType>(AutoCSer.BinaryDeSerializer deSerializer, ref parameterType parameter)
{
if (deSerializer.CheckNullValue() != 0)
{
AutoCSer.BinarySerialize.TypeDeSerializer <parameterType> .DeSerialize(deSerializer, ref parameter);
}
}
internal bool DeSerialize <valueType>(ref SubArray <byte> data, ref valueType value, bool isSimpleSerialize)
where valueType : struct
{
if ((CommandIndex & (uint)CommandFlags.JsonSerialize) == 0)
{
if (isSimpleSerialize)
{
fixed(byte *dataFixed = data.GetFixedBuffer())
{
byte *start = dataFixed + data.Start, end = start + data.Length;
return(SimpleSerialize.TypeDeSerializer <valueType> .DeSerialize(start, ref value, end) == end);
}
}
if (ReceiveDeSerializer == null)
{
ReceiveDeSerializer = AutoCSer.BinaryDeSerializer.YieldPool.Default.Pop() ?? new AutoCSer.BinaryDeSerializer();
ReceiveDeSerializer.SetTcpServer(binaryDeSerializeConfig, this);
}
return(ReceiveDeSerializer.DeSerializeTcpServer(ref data, ref value));
//if (ReceiveDeSerializer.DeSerializeTcpServer(ref data, ref value)) return true;
//if (data.Length > 1 << 20) System.IO.File.WriteAllBytes((++testIdentity).ToString() + "." + data.Length.ToString(), data.ToArray());
//return false;
}
if (ReceiveJsonDeSerializer == null)
{
ReceiveJsonDeSerializer = AutoCSer.JsonDeSerializer.YieldPool.Default.Pop() ?? new AutoCSer.JsonDeSerializer();
ReceiveJsonDeSerializer.SetTcpServer();
}
return(ReceiveJsonDeSerializer.DeSerializeTcpServer(ref data, ref value));
}
private unsafe void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
byte *read = deSerializer.Read;
int size = *(int *)read;
if (size <= 0)
{
if (size == 0)
{
Buffer.SetNull();
State = (MemberState)(byte)*(int *)(read + sizeof(int));
deSerializer.Read += sizeof(int) * 2;
}
else
{
Buffer.Start = -size;
deSerializer.Read += sizeof(int);
}
}
else if (size == Buffer.Length)
{
if (deSerializer.MoveReadAny(sizeof(int) + size + (-size & 3)))
{
fixed(byte *bufferFixed = Buffer.GetFixedBuffer()) AutoCSer.Memory.Common.CopyNotNull(read + sizeof(int), bufferFixed + Buffer.Start, size);
State = MemberState.Remote;
}
}
else
{
deSerializer.State = BinarySerialize.DeSerializeState.IndexOutOfRange;
}
}
internal static void GetQueryData(AutoCSer.BinaryDeSerializer deSerializer, ref SubArray <byte> queryData)
{
byte *read = deSerializer.Read;
if (deSerializer.MoveRead(*(int *)read))
{
deSerializer.DeSerializeTcpServer(ref queryData, read, *(int *)read);
}
}
private void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
if (deSerializer.CheckNullValue() != 0)
{
byte *read = deSerializer.Read;
deSerializer.DeSerializeTcpServer(ref LoadData, read + sizeof(int), *(int *)read);
deSerializer.MoveRead(LoadData.Length + sizeof(int));
}
}
private void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
AutoCSer.Metadata.MemberMap oldMemberMap = deSerializer.SetCustomMemberMap(MemberMap);
try
{
deSerializer.TypeDeSerialize(ref Value);
}
finally { MemberMap = (AutoCSer.Metadata.MemberMap <valueType>)deSerializer.SetCustomMemberMap(oldMemberMap); }
}
private void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
byte *read = deSerializer.Read;
if (deSerializer.MoveRead((*(int *)read + (sizeof(int) + 3)) & (int.MaxValue - 3)))
{
deSerializer.DeSerializeTcpServer(ref Data, read + sizeof(int), *(int *)read);
}
}
private void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
MemberMap memberMap = deSerializer.SetCustomMemberMap(MemberMap);
try
{
deSerializer.TypeDeSerialize(ref Value);
}
finally { MemberMap = deSerializer.SetCustomMemberMap(memberMap); }
}
protected override void deSerializeParameter(AutoCSer.BinaryDeSerializer deSerializer)
{
#region LOOP IntputParameters
#region IF ParameterType.IsNull
base.deSerializeParameter(deSerializer, ref @ParameterName);
#endregion IF ParameterType.IsNull
#region NOT ParameterType.IsNull
base.deSerializeParameterStruct(deSerializer, ref @ParameterName);
#endregion NOT ParameterType.IsNull
#endregion LOOP IntputParameters
}
private unsafe void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
if (deSerializer.MoveReadAny(sizeof(ulong) * 4))
{
byte *dataStart = deSerializer.Read;
Ticks = *(ulong *)(dataStart - sizeof(ulong) * 4);
Identity = *(ulong *)(dataStart - sizeof(ulong) * 3);
Low = *(ulong *)(dataStart - sizeof(ulong) * 2);
High = *(ulong *)(dataStart - sizeof(ulong));
}
}
private unsafe void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
switch (deSerializer.TypeDeSerialize <int>())
{
case 1: Value = null; return;
case 2: Value = string.Empty; return;
default: deSerializer.MoveRead(-1); return;
}
}
/// <summary>
/// 获取操作数据
/// </summary>
/// <param name="deSerializer"></param>
/// <returns></returns>
internal static Buffer GetOperationData(AutoCSer.BinaryDeSerializer deSerializer)
{
byte *read = deSerializer.Read;
int size = *(int *)read;
if (deSerializer.MoveRead(size))
{
Buffer buffer = BufferCount.GetBuffer(size);
deSerializer.CopyTo(read, ref buffer.Array);
return(buffer);
}
return(null);
}
internal void FreeReceiveDeSerializer()
{
if (ReceiveDeSerializer != null)
{
ReceiveDeSerializer.Free();
ReceiveDeSerializer = null;
}
if (ReceiveJsonDeSerializer != null)
{
ReceiveJsonDeSerializer.Free();
ReceiveJsonDeSerializer = null;
}
}
internal void FreeReceiveDeSerializer()
{
AutoCSer.BinaryDeSerializer deSerializer = Interlocked.Exchange(ref ReceiveDeSerializer, null);
if (deSerializer != null)
{
deSerializer.Free();
}
AutoCSer.JsonDeSerializer jsonDeSerializer = Interlocked.Exchange(ref ReceiveJsonDeSerializer, null);
if (jsonDeSerializer != null)
{
jsonDeSerializer.Free();
}
}
/// <summary>
/// 数据反序列化
/// </summary>
/// <typeparam name="outputParameterType"></typeparam>
/// <param name="commandInfo"></param>
/// <param name="outputParameter"></param>
/// <param name="clientBuffer"></param>
private unsafe void deSerialize <outputParameterType>(TcpServer.CommandInfoBase commandInfo, ref outputParameterType outputParameter, ref ClientBuffer clientBuffer)
where outputParameterType : struct
{
if ((commandInfo.CommandFlags & TcpServer.CommandFlags.JsonSerialize) == 0)
{
if (commandInfo.SimpleSerializeOutputParamter == 0)
{
if (receiveDeSerializer == null)
{
receiveDeSerializer = AutoCSer.BinaryDeSerializer.YieldPool.Default.Pop() ?? new AutoCSer.BinaryDeSerializer();
receiveDeSerializer.SetTcpServer(AutoCSer.BinaryDeSerializer.DefaultConfig, null);
}
if (receiveDeSerializer.DeSerializeTcpServer(ref clientBuffer.Data, ref outputParameter))
{
clientBuffer.ReturnType = TcpServer.ReturnType.Success;
return;
}
}
else
{
fixed(byte *dataFixed = clientBuffer.Data.GetFixedBuffer())
{
byte *start = dataFixed + clientBuffer.Data.Start, end = start + clientBuffer.Data.Length;
if (SimpleSerialize.TypeDeSerializer <outputParameterType> .DeSerialize(start, ref outputParameter, end) == end)
{
clientBuffer.ReturnType = TcpServer.ReturnType.Success;
return;
}
}
}
}
else
{
if (receiveJsonParser == null)
{
receiveJsonParser = AutoCSer.JsonDeSerializer.YieldPool.Default.Pop() ?? new AutoCSer.JsonDeSerializer();
receiveJsonParser.SetTcpServer();
}
if (receiveJsonParser.DeSerializeTcpServer(ref clientBuffer.Data, ref outputParameter))
{
clientBuffer.ReturnType = TcpServer.ReturnType.Success;
return;
}
}
clientBuffer.ReturnType = TcpServer.ReturnType.ClientDeSerializeError;
}
internal bool DeSerialize <valueType>(ref SubArray <byte> data, ref valueType value)
where valueType : struct
{
AutoCSer.BinaryDeSerializer deSerializer = Interlocked.Exchange(ref ReceiveDeSerializer, null);
if (deSerializer == null)
{
deSerializer = AutoCSer.BinaryDeSerializer.YieldPool.Default.Pop() ?? new AutoCSer.BinaryDeSerializer();
deSerializer.SetTcpServer(AutoCSer.BinaryDeSerializer.DefaultConfig, null);
}
bool isValue = deSerializer.DeSerializeTcpServer(ref data, ref value);
if (Interlocked.CompareExchange(ref ReceiveDeSerializer, deSerializer, null) != null)
{
deSerializer.Free();
}
return(isValue);
}
private void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
if (deSerializer.GetBuffer(ref Buffer))
{
int size;
fixed(byte *bufferFixed = Buffer.BufferArray) size = *(int *)(bufferFixed + Buffer.StartIndex);
if (deSerializer.MoveRead(size))
{
Buffer = Buffer.GetSub(sizeof(int), size - sizeof(int));
}
}
else
{
deSerializer.MoveRead(-1);
}
}
private unsafe void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
byte *read = deSerializer.Read;
int size = *(int *)read;
if (size > 0)
{
int offset = -(size + sizeof(ushort)) & 3;
if (deSerializer.MoveReadAny(size + offset + (sizeof(int) + sizeof(ulong) + sizeof(ushort))))
{
Index = *(ulong *)(read + sizeof(int));
deSerializer.DeSerializeTcpServer(ref Buffer, read += sizeof(int) + sizeof(ulong), size);
BlockIndex = *(ushort *)(read + size);
}
}
else
{
deSerializer.State = BinarySerialize.DeSerializeState.IndexOutOfRange;
}
}
private static unsafe void deSerialize(AutoCSer.BinaryDeSerializer deSerializer, ref CustomClass value)
{
byte *read = deSerializer.CustomRead;
if (deSerializer.MoveReadAny(sizeof(int)))
{
switch (*(int *)read)
{
case 1: value = new CustomClass {
Value = null
}; return;
case 2: value = new CustomClass {
Value = string.Empty
}; return;
default: deSerializer.MoveRead(-1); return;
}
}
}
private void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
if (deSerializer.CheckNullValue() == 0)
{
Value = default(valueType);
}
else
{
MemberMap oldMemberMap = deSerializer.MemberMap;
deSerializer.MemberMap = MemberMap;
try
{
if (Value == null)
{
valueType poolValue = Value = MemberMapValueLinkPool <valueType> .Pop();
try
{
AutoCSer.BinarySerialize.TypeDeSerializer <valueType> .DeSerialize(deSerializer, ref Value);
}
finally
{
if (poolValue != null && poolValue != Value)
{
MemberMapValueLinkPool <valueType> .PushNotNull(poolValue);
}
}
}
else
{
memberMapType parseValue = Value;
AutoCSer.BinarySerialize.TypeDeSerializer <memberMapType> .DeSerialize(deSerializer, ref parseValue);
}
}
finally
{
MemberMap = (MemberMap <memberMapType>)deSerializer.MemberMap;
deSerializer.MemberMap = oldMemberMap;
}
}
}
internal void FreeSerializer()
{
OutputStream = null;
if (ReceiveDeSerializer != null)
{
ReceiveDeSerializer.Free();
ReceiveDeSerializer = null;
}
if (ReceiveJsonParser != null)
{
ReceiveJsonParser.Free();
ReceiveJsonParser = null;
}
if (OutputSerializer != null)
{
OutputSerializer.Free();
OutputSerializer = null;
}
if (OutputJsonSerializer != null)
{
OutputJsonSerializer.Free();
OutputJsonSerializer = null;
}
}
private unsafe void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
byte *read = deSerializer.Read;
int size = *(int *)read;
if (deSerializer.MoveRead(size))
{
Identity = new ShortPathIdentity(read + Serializer.HeaderSize);
int bufferSize = size + Identity.PacketSize - ShortPathIdentity.SerializeSize;
if (bufferSize >= Serializer.HeaderSize + IndexIdentity.SerializeSize)
{
Buffer = BufferCount.GetBuffer(bufferSize);
fixed(byte *bufferFixed = Buffer.GetFixedBuffer())
{
byte *start = bufferFixed + Buffer.Array.Start;
*(int *)start = Buffer.Array.Length;
*(uint *)(start + sizeof(int)) = *(uint *)(read + sizeof(int));
}
deSerializer.CopyTo(read + (Serializer.HeaderSize + ShortPathIdentity.SerializeSize), ref Buffer.Array, Serializer.HeaderSize + Identity.PacketSize);
}
}
}
protected void deSerializeParameterStruct <parameterType>(AutoCSer.BinaryDeSerializer deSerializer, ref parameterType parameter)
{
AutoCSer.BinarySerialize.TypeDeSerializer <parameterType> .StructDeSerialize(deSerializer, ref parameter);
}
private unsafe void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
Serializer.GetQueryData(deSerializer, ref QueryData);
}
private void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
deSerializeParameter(deSerializer);
deSerializeParent(deSerializer);
}
/// <summary>
/// 服务端反序列化
/// </summary>
/// <param name="deSerializer"></param>
/// <param name="value"></param>
internal static void DeSerialize(AutoCSer.BinaryDeSerializer deSerializer, out Node value)
{
(value = createNodes.Array[deSerializer.ReadInt()]()).deSerialize(deSerializer);
}
private void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
Identity = deSerializer.ReadULong();
Parameter.DeSerializeReturnParameter(deSerializer);
}
private unsafe void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
Buffer = Serializer.GetOperationData(deSerializer);
}
private void deSerialize(AutoCSer.BinaryDeSerializer deSerializer)
{
ClientNodeId = deSerializer.ReadInt();
Node.DeSerialize(deSerializer, out Node);
}
