public global::Server.SharedThings.Packets.ServerPackets.LoginSucceeded Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __SessionId__ = default(string);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__SessionId__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Server.SharedThings.Packets.ServerPackets.LoginSucceeded();
____result.SessionId = __SessionId__;
return(____result);
}
private string ReadInvocationId(ref MessagePackReader reader) => ReadString(ref reader, "invocationId");
public global::Server.SharedThings.Packets.ServerPackets.Game.EntityUpdatePosition Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __Id__ = default(string);
var __X__ = default(float);
var __Y__ = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__Id__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
break;
case 1:
__X__ = reader.ReadSingle();
break;
case 2:
__Y__ = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Server.SharedThings.Packets.ServerPackets.Game.EntityUpdatePosition();
____result.Id = __Id__;
____result.X = __X__;
____result.Y = __Y__;
return(____result);
}
public Tuple <T1> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(default);
public ImmutableArray <T> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(default);
public RgbaFloat Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(new RgbaFloat((float)reader.ReadDouble(), (float)reader.ReadDouble(), (float)reader.ReadDouble(), (float)reader.ReadDouble()));
}
public Result <T> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
return(default);
public byte[] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(reader.ReadBytes()?.ToArray());
}
public string Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(reader.ReadString());
}
public decimal Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(decimal.Parse(reader.ReadString(), CultureInfo.InvariantCulture));
}
public TimeSpan Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(new TimeSpan(reader.ReadInt64()));
}
public VersionRange?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
// stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf
options.Security.DepthStep(ref reader);
try
{
FloatRange? floatRange = null;
bool? isMaxInclusive = null;
bool? isMinInclusive = null;
NuGetVersion?maxVersion = null;
NuGetVersion?minVersion = null;
string? originalString = null;
int propertyCount = reader.ReadMapHeader();
for (var propertyIndex = 0; propertyIndex < propertyCount; ++propertyIndex)
{
switch (reader.ReadString())
{
case FloatRangePropertyName:
floatRange = FloatRangeFormatter.Instance.Deserialize(ref reader, options);
break;
case IsMaxInclusivePropertyName:
isMaxInclusive = reader.ReadBoolean();
break;
case IsMinInclusivePropertyName:
isMinInclusive = reader.ReadBoolean();
break;
case MaxVersionPropertyName:
maxVersion = NuGetVersionFormatter.Instance.Deserialize(ref reader, options);
break;
case MinVersionPropertyName:
minVersion = NuGetVersionFormatter.Instance.Deserialize(ref reader, options);
break;
case OriginalStringPropertyName:
originalString = reader.ReadString();
break;
default:
reader.Skip();
break;
}
}
Assumes.True(isMinInclusive.HasValue);
Assumes.True(isMaxInclusive.HasValue);
return(new VersionRange(
minVersion,
isMinInclusive.Value,
maxVersion,
isMaxInclusive.Value,
floatRange,
originalString));
}
finally
{
// stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf
reader.Depth--;
}
}
public global::Fenix.Packet Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
options.Security.DepthStep(ref reader);
IFormatterResolver formatterResolver = options.Resolver;
var length = reader.ReadArrayHeader();
var __Id__ = default(ulong);
var __ProtoCode__ = default(uint);
var __FromHostId__ = default(uint);
var __ToHostId__ = default(uint);
var __FromActorId__ = default(uint);
var __ToActorId__ = default(uint);
var __Payload__ = default(byte[]);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__Id__ = reader.ReadUInt64();
break;
case 1:
__ProtoCode__ = reader.ReadUInt32();
break;
case 2:
__FromHostId__ = reader.ReadUInt32();
break;
case 3:
__ToHostId__ = reader.ReadUInt32();
break;
case 4:
__FromActorId__ = reader.ReadUInt32();
break;
case 5:
__ToActorId__ = reader.ReadUInt32();
break;
case 6:
__Payload__ = formatterResolver.GetFormatterWithVerify <byte[]>().Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
var ____result = new global::Fenix.Packet();
____result.Id = __Id__;
____result.ProtoCode = __ProtoCode__;
____result.FromHostId = __FromHostId__;
____result.ToHostId = __ToHostId__;
____result.FromActorId = __FromActorId__;
____result.ToActorId = __ToActorId__;
____result.Payload = __Payload__;
reader.Depth--;
return(____result);
}
public global::Fenix.Common.DefaultErrCode Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
return((global::Fenix.Common.DefaultErrCode)reader.ReadInt16());
}
public string Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var s = reader.ReadString();
return(s + s);
}
async Task HandleMessageAsync()
{
var ct = Context.CallContext.CancellationToken;
var reader = Context.RequestStream !;
var writer = Context.ResponseStream !;
var handlers = StreamingHubHandlerRepository.GetHandlers(Context.MethodHandler);
// Main loop of StreamingHub.
// Be careful to allocation and performance.
while (await reader.MoveNext(ct)) // must keep SyncContext.
{
(int methodId, int messageId, int offset) FetchHeader(byte[] msgData)
{
var messagePackReader = new MessagePackReader(msgData);
var length = messagePackReader.ReadArrayHeader();
if (length == 2)
{
// void: [methodId, [argument]]
var mid = messagePackReader.ReadInt32();
var consumed = (int)messagePackReader.Consumed;
return(mid, -1, consumed);
}
else if (length == 3)
{
// T: [messageId, methodId, [argument]]
var msgId = messagePackReader.ReadInt32();
var metId = messagePackReader.ReadInt32();
var consumed = (int)messagePackReader.Consumed;
return(metId, msgId, consumed);
}
else
{
throw new InvalidOperationException("Invalid data format.");
}
}
var data = reader.Current;
var(methodId, messageId, offset) = FetchHeader(data);
if (messageId == -1)
{
if (handlers.TryGetValue(methodId, out var handler))
{
var context = new StreamingHubContext() // create per invoke.
{
AsyncWriterLock = Context.AsyncWriterLock,
SerializerOptions = handler.serializerOptions,
HubInstance = this,
ServiceContext = Context,
Request = new ArraySegment <byte>(data, offset, data.Length - offset),
Path = handler.ToString(),
MethodId = handler.MethodId,
MessageId = -1,
Timestamp = DateTime.UtcNow
};
var isErrorOrInterrupted = false;
Context.MethodHandler.logger.BeginInvokeHubMethod(context, context.Request, handler.RequestType);
try
{
await handler.MethodBody.Invoke(context);
}
catch (Exception ex)
{
isErrorOrInterrupted = true;
Context.MethodHandler.logger.Error(ex, context);
}
finally
{
Context.MethodHandler.logger.EndInvokeHubMethod(context, context.responseSize, context.responseType, (DateTime.UtcNow - context.Timestamp).TotalMilliseconds, isErrorOrInterrupted);
}
}
else
{
throw new InvalidOperationException("Handler not found in received methodId, methodId:" + methodId);
}
}
else
{
if (handlers.TryGetValue(methodId, out var handler))
{
var context = new StreamingHubContext() // create per invoke.
{
AsyncWriterLock = Context.AsyncWriterLock,
SerializerOptions = handler.serializerOptions,
HubInstance = this,
ServiceContext = Context,
Request = new ArraySegment <byte>(data, offset, data.Length - offset),
Path = handler.ToString(),
MethodId = handler.MethodId,
MessageId = messageId,
Timestamp = DateTime.UtcNow
};
var isErrorOrInterrupted = false;
Context.MethodHandler.logger.BeginInvokeHubMethod(context, context.Request, handler.RequestType);
try
{
await handler.MethodBody.Invoke(context);
}
catch (ReturnStatusException ex)
{
await context.WriteErrorMessage((int)ex.StatusCode, ex.Detail, null, false);
}
catch (Exception ex)
{
isErrorOrInterrupted = true;
Context.MethodHandler.logger.Error(ex, context);
await context.WriteErrorMessage((int)StatusCode.Internal, $"An error occurred while processing handler '{handler.ToString()}'.", ex, Context.MethodHandler.isReturnExceptionStackTraceInErrorDetail);
}
finally
{
Context.MethodHandler.logger.EndInvokeHubMethod(context, context.responseSize, context.responseType, (DateTime.UtcNow - context.Timestamp).TotalMilliseconds, isErrorOrInterrupted);
}
}
else
{
throw new InvalidOperationException("Handler not found in received methodId, methodId:" + methodId);
}
}
}
}
public Vector2 Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(new Vector2((float)reader.ReadDouble(), (float)reader.ReadDouble()));
}
public global::UnityEngine.GradientMode Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
return((global::UnityEngine.GradientMode)reader.ReadInt32());
}
public override T Deserialize(ref MessagePackReader reader)
{
ulong value = reader.ReadUInt64();
return(MessagePackUnsafeUtility.As <ulong, T>(ref value));
}
public global::UnityEngine.Matrix4x4 Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
var length = reader.ReadArrayHeader();
var __m00__ = default(float);
var __m10__ = default(float);
var __m20__ = default(float);
var __m30__ = default(float);
var __m01__ = default(float);
var __m11__ = default(float);
var __m21__ = default(float);
var __m31__ = default(float);
var __m02__ = default(float);
var __m12__ = default(float);
var __m22__ = default(float);
var __m32__ = default(float);
var __m03__ = default(float);
var __m13__ = default(float);
var __m23__ = default(float);
var __m33__ = default(float);
for (int i = 0; i < length; i++)
{
var key = i;
switch (key)
{
case 0:
__m00__ = reader.ReadSingle();
break;
case 1:
__m10__ = reader.ReadSingle();
break;
case 2:
__m20__ = reader.ReadSingle();
break;
case 3:
__m30__ = reader.ReadSingle();
break;
case 4:
__m01__ = reader.ReadSingle();
break;
case 5:
__m11__ = reader.ReadSingle();
break;
case 6:
__m21__ = reader.ReadSingle();
break;
case 7:
__m31__ = reader.ReadSingle();
break;
case 8:
__m02__ = reader.ReadSingle();
break;
case 9:
__m12__ = reader.ReadSingle();
break;
case 10:
__m22__ = reader.ReadSingle();
break;
case 11:
__m32__ = reader.ReadSingle();
break;
case 12:
__m03__ = reader.ReadSingle();
break;
case 13:
__m13__ = reader.ReadSingle();
break;
case 14:
__m23__ = reader.ReadSingle();
break;
case 15:
__m33__ = reader.ReadSingle();
break;
default:
reader.Skip();
break;
}
}
var ____result = default(global::UnityEngine.Matrix4x4);
____result.m00 = __m00__;
____result.m10 = __m10__;
____result.m20 = __m20__;
____result.m30 = __m30__;
____result.m01 = __m01__;
____result.m11 = __m11__;
____result.m21 = __m21__;
____result.m31 = __m31__;
____result.m02 = __m02__;
____result.m12 = __m12__;
____result.m22 = __m22__;
____result.m32 = __m32__;
____result.m03 = __m03__;
____result.m13 = __m13__;
____result.m23 = __m23__;
____result.m33 = __m33__;
return(____result);
}
public override bool Deserialize(MessagePackReader reader)
{
return(reader.ReadBool());
}
public StackItem Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
var count = reader.ReadArrayHeader();
if (count != 2)
{
throw new MessagePackSerializationException($"Invalid StackItem Array Header {count}");
}
var type = options.Resolver.GetFormatterWithVerify <StackItemType>().Deserialize(ref reader, options);
switch (type)
{
case StackItemType.Any:
reader.ReadNil();
return(StackItem.Null);
case StackItemType.Boolean:
return(reader.ReadBoolean() ? StackItem.True : StackItem.False);
case StackItemType.Buffer:
{
var bytes = options.Resolver.GetFormatter <byte[]>().Deserialize(ref reader, options);
return(new NeoBuffer(bytes));
}
case StackItemType.ByteString:
{
var bytes = options.Resolver.GetFormatter <byte[]>().Deserialize(ref reader, options);
return(new NeoByteString(bytes));
}
case StackItemType.Integer:
{
var integer = options.Resolver.GetFormatterWithVerify <BigInteger>().Deserialize(ref reader, options);
return(new NeoInteger(integer));
}
case StackItemType.InteropInterface:
{
var typeName = options.Resolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options);
return(new TraceInteropInterface(typeName));
}
case StackItemType.Pointer:
reader.ReadNil();
return(new NeoPointer(Array.Empty <byte>(), 0));
case StackItemType.Map:
{
var map = new NeoMap();
var mapCount = reader.ReadMapHeader();
for (int i = 0; i < mapCount; i++)
{
var key = (PrimitiveType)Deserialize(ref reader, options);
map[key] = Deserialize(ref reader, options);
}
return(map);
}
case StackItemType.Array:
case StackItemType.Struct:
{
var array = type == StackItemType.Array
? new NeoArray()
: new NeoStruct();
var arrayCount = reader.ReadArrayHeader();
for (int i = 0; i < arrayCount; i++)
{
array.Add(Deserialize(ref reader, options));
}
return(array);
}
}
throw new MessagePackSerializationException($"Invalid StackItem {type}");
}
public ExecutionId Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(new ExecutionId(options.Resolver.GetFormatterWithVerify <System.Guid>().Deserialize(ref reader, options)));
}
public override T Deserialize(ref MessagePackReader reader)
{
int value = reader.ReadInt32();
return(MessagePackUnsafeUtility.As <int, T>(ref value));
}
protected abstract object DeserializeObject(ref MessagePackReader reader, Type type, string field);
public Int16 Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(reader.ReadInt16());
}
public global::Server.SharedThings.Packets.ServerPackets.Enums.CharacterCreateResponseType Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options)
{
return((global::Server.SharedThings.Packets.ServerPackets.Enums.CharacterCreateResponseType)reader.ReadInt32());
}
public int Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
return(reader.ReadInt32() * 10);
}
public void ReadSingle_CanReadDouble()
{
var reader = new MessagePackReader(Encode((ref MessagePackWriter w) => w.Write(1.23)));
Assert.Equal(1.23f, reader.ReadSingle());
}
public int Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
throw new NotImplementedException();
}
