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));
}
/// <summary>
/// 枚举类型解析
/// </summary>
/// <param name="value">目标数据</param>
private unsafe void parseEnum <valueType>(ref valueType value)
{
BufferIndex *indexs = queryIndex + 1;
if (indexs->Length == 0)
{
value = default(valueType);
}
else
{
current = bufferStart + indexs->StartIndex;
*(current + indexs->Length) = *(current - 1) = (byte)'"';
AutoCSer.JsonDeSerializer parser = Interlocked.Exchange(ref enumJsonParser, null);
if (parser == null)
{
parser = AutoCSer.JsonDeSerializer.YieldPool.Default.Pop() ?? new AutoCSer.JsonDeSerializer();
parser.SetEnum();
}
if (!parser.DeSerializeEnum(header.UnescapeUtf8(bufferStart, indexs->StartIndex - 1, indexs->Length + 2), ref value))
{
state = HeaderQueryParseState.Unknown;
}
if ((parser = Interlocked.Exchange(ref enumJsonParser, parser)) != null)
{
parser.Free();
}
}
}
/// <summary>
/// 清除缓存数据
/// </summary>
/// <param name="count">保留缓存数据数量</param>
private static void clearCache(int count)
{
if (count == 0)
{
enumJsonParser = null;
}
}
private void parseJson(AutoCSer.JsonDeSerializer parser)
{
if (MemberMap == null)
{
MemberMap = new MemberMap <memberMapType>();
}
parser.MemberMap = MemberMap;
if (Value == null)
{
valueType poolValue = Value = MemberMapValueLinkPool <valueType> .Pop();
try
{
AutoCSer.Json.TypeDeSerializer <valueType> .DeSerialize(parser, ref Value);
}
finally
{
if (poolValue != null && poolValue != Value)
{
MemberMapValueLinkPool <valueType> .PushNotNull(poolValue);
}
}
}
else
{
memberMapType parseValue = Value;
AutoCSer.Json.TypeDeSerializer <memberMapType> .DeSerialize(parser, ref parseValue);
}
}
internal void ParseJson(AutoCSer.JsonDeSerializer parser)
{
if (MemberMap == null)
{
MemberMap = AutoCSer.Metadata.MemberMap <valueType> .NewEmpty();
}
parser.MemberMap = MemberMap;
parser.TypeDeSerialize(ref Value);
}
private void parseJson(AutoCSer.JsonDeSerializer parser)
{
if (MemberMap == null)
{
MemberMap = new MemberMap <valueType>();
}
parser.MemberMap = MemberMap;
parser.TypeDeSerialize(ref Value);
}
protected bool parseJson <parameterType>(ref parameterType parameter, string json) where parameterType : struct
{
AutoCSer.JsonDeSerializer parser = Interlocked.Exchange(ref JsonParser, null) ?? AutoCSer.JsonDeSerializer.YieldPool.Default.Pop() ?? new AutoCSer.JsonDeSerializer();
bool isParse = parser.DeSerializeWebViewNotEmpty(ref parameter, json, jsonParserConfig);
if ((parser = Interlocked.Exchange(ref JsonParser, parser)) != null)
{
parser.Free();
}
return(isParse);
}
private unsafe void deSerialize(AutoCSer.JsonDeSerializer parser)
{
switch (parser.TypeDeSerialize <int>())
{
case 1: Value = null; return;
case 2: Value = string.Empty; return;
default: parser.MoveRead(-1); return;
}
}
/// <summary>
/// 参数反序列化
/// </summary>
/// <typeparam name="parameterType"></typeparam>
/// <param name="jsonDeSerializer"></param>
/// <param name="parameter"></param>
protected void deSerializeParameter <parameterType>(AutoCSer.JsonDeSerializer jsonDeSerializer, ref parameterType parameter)
{
if (jsonDeSerializer.DeSerializeState == Json.DeSerializeState.Success)
{
if (*jsonDeSerializer.Current++ == ',')
{
AutoCSer.Json.TypeDeSerializer <parameterType> .DeSerialize(jsonDeSerializer, ref parameter);
return;
}
jsonDeSerializer.DeSerializeState = Json.DeSerializeState.Custom;
}
}
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();
}
}
internal void FreeReceiveDeSerializer()
{
if (ReceiveDeSerializer != null)
{
ReceiveDeSerializer.Free();
ReceiveDeSerializer = null;
}
if (ReceiveJsonDeSerializer != null)
{
ReceiveJsonDeSerializer.Free();
ReceiveJsonDeSerializer = null;
}
}
/// <summary>
/// 服务端反序列化
/// </summary>
/// <param name="jsonDeSerializer"></param>
/// <param name="value"></param>
internal static void DeSerialize(AutoCSer.JsonDeSerializer jsonDeSerializer, ref Node value)
{
if (*jsonDeSerializer.Current++ == '[')
{
int serverNodeId = 0;
jsonDeSerializer.CallSerialize(ref serverNodeId);
if (jsonDeSerializer.State == Json.DeSerializeState.Success)
{
(value = createNodes.Array[serverNodeId]()).deSerialize(jsonDeSerializer);
}
return;
}
jsonDeSerializer.DeSerializeState = Json.DeSerializeState.Custom;
}
/// <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 DeSerializeJson <valueType>(ref SubArray <byte> data, ref valueType value)
where valueType : struct
{
AutoCSer.JsonDeSerializer jsonDeSerializer = Interlocked.Exchange(ref ReceiveJsonDeSerializer, null);
if (jsonDeSerializer == null)
{
jsonDeSerializer = AutoCSer.JsonDeSerializer.YieldPool.Default.Pop() ?? new AutoCSer.JsonDeSerializer();
jsonDeSerializer.SetTcpServer();
}
bool isValue = jsonDeSerializer.DeSerializeTcpServer(ref data, ref value);
if (Interlocked.CompareExchange(ref ReceiveJsonDeSerializer, jsonDeSerializer, null) != null)
{
jsonDeSerializer.Free();
}
return(isValue);
}
private unsafe static void deSerialize(AutoCSer.JsonDeSerializer jsonDeSerializer, ref ReturnValue value)
{
if (*jsonDeSerializer.Current++ == '[')
{
if (*jsonDeSerializer.Current == ']')
{
++jsonDeSerializer.Current;
return;
}
int clientNodeId = 0;
jsonDeSerializer.CallSerialize(ref clientNodeId);
if (jsonDeSerializer.State == Json.DeSerializeState.Success)
{
value = createReturnValues.Array[clientNodeId]();
value.deSerialize(jsonDeSerializer);
}
return;
}
jsonDeSerializer.DeSerializeState = Json.DeSerializeState.Custom;
}
private static unsafe void deSerialize(AutoCSer.JsonDeSerializer parser, ref CustomClass value)
{
char *read = parser.CustomRead;
if (parser.VerifyRead(1))
{
switch (*(char *)read)
{
case '1': value = new CustomClass {
Value = null
}; return;
case '2': value = new CustomClass {
Value = string.Empty
}; return;
default: parser.MoveRead(-1); return;
}
}
}
private unsafe void deSerialize(AutoCSer.JsonDeSerializer jsonDeSerializer)
{
if (*jsonDeSerializer.Current++ == '[')
{
jsonDeSerializer.CallSerialize(ref ClientNodeId);
if (jsonDeSerializer.State == Json.DeSerializeState.Success)
{
if (*jsonDeSerializer.Current++ == ',')
{
Node.DeSerialize(jsonDeSerializer, ref Node);
if (jsonDeSerializer.State != Json.DeSerializeState.Success || *jsonDeSerializer.Current++ == ']')
{
return;
}
}
}
else
{
return;
}
}
jsonDeSerializer.DeSerializeState = Json.DeSerializeState.Custom;
}
/// <summary>
/// 客户端反序列化返回值
/// </summary>
/// <param name="jsonDeSerializer"></param>
protected void deSerializeParent(AutoCSer.JsonDeSerializer jsonDeSerializer)
{
if (jsonDeSerializer.DeSerializeState == Json.DeSerializeState.Success)
{
char split = *jsonDeSerializer.Current++;
if ((split & 1) == 0)
{
if (split == ',')
{
DeSerialize(jsonDeSerializer, ref Parent);
if (jsonDeSerializer.State != Json.DeSerializeState.Success || *jsonDeSerializer.Current++ == ']')
{
return;
}
}
}
else if (split == ']')
{
return;
}
jsonDeSerializer.DeSerializeState = Json.DeSerializeState.Custom;
}
}
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 void deSerialize(AutoCSer.JsonDeSerializer jsonDeSerializer)
{
deSerializeParameter(jsonDeSerializer);
deSerializeParent(jsonDeSerializer);
}
/// <summary>
/// 服务端反序列化
/// </summary>
/// <param name="jsonDeSerializer"></param>
protected virtual void deSerializeParameter(AutoCSer.JsonDeSerializer jsonDeSerializer)
{
}
protected override void deSerializeParameter(AutoCSer.JsonDeSerializer parser)
{
#region LOOP IntputParameters
base.deSerializeParameter(parser, ref @ParameterName);
#endregion LOOP IntputParameters
}
/// <summary>
/// 客户端反序列化返回值
/// </summary>
/// <param name="jsonDeSerializer"></param>
protected virtual void deSerialize(AutoCSer.JsonDeSerializer jsonDeSerializer)
{
}
