public void TestFixedArrayHeader()
{
MsgPackWriter writer = new MsgPackWriter(Allocator.Temp);
writer.WriteArrayHeader(0);
writer.WriteArrayHeader(0xF);
var asArray = writer.ToArray(Allocator.Temp);
Assert.That(asArray.Length, Is.EqualTo(2)); // such small numbers should be stored as fixed numbers
MsgPackReader reader = new MsgPackReader(asArray);
Assert.That(reader.ReadArrayHeader(out var len1), Is.True);
Assert.That(len1, Is.EqualTo(0));
Assert.That(reader.ReadArrayHeader(out var len2), Is.True);
Assert.That(len2, Is.EqualTo(0xF));
}
private Message ReadCompletion(MsgPackReader reader)
{
// https://github.com/aspnet/AspNetCore/blob/master/src/SignalR/docs/specs/HubProtocol.md#completion-message-encoding-1
ReadHeaders(reader);
string invocationId = reader.ReadString();
byte resultKind = reader.ReadByte();
switch (resultKind)
{
// 1 - Error result - Result contains a String with the error message
case 1:
string error = reader.ReadString();
return(new Message
{
type = MessageTypes.Completion,
invocationId = invocationId,
error = error
});
// 2 - Void result - Result is absent
case 2:
return(new Message
{
type = MessageTypes.Completion,
invocationId = invocationId
});
// 3 - Non-Void result - Result contains the value returned by the server
case 3:
object item = ReadItem(reader, invocationId);
return(new Message
{
type = MessageTypes.Completion,
invocationId = invocationId,
item = item,
result = item
});
default:
throw new NotImplementedException("Unknown resultKind: " + resultKind);
}
}
public static Sphere ReadSphere(this MsgPackReader reader)
{
var sphere = new Sphere();
reader.ReadPrefix(TypePrefixes.FixMap);
for (int i = 0; i < 2; i++)
{
var key = reader.ReadString();
switch (key)
{
case "center": sphere.Center = reader.ReadPoint3d(); break;
case "radius": sphere.Radius = reader.ReadDouble(); break;
default: throw new InvalidOperationException(Resources.ParseError);
}
}
return(sphere);
}
private TreeNode CreateNode(MsgPackReader reader)
{
var formatName = GetFormatName(reader.Format);
var text = GetNodeText(reader);
var tooltip = String.Format("{0} ({1:x2}) ({2} bytes)", formatName, reader.FormatByte, reader.TotalSize);
if (reader.IsExtended)
{
tooltip += String.Format(" (Extended Type {0})", reader.ExtendedType);
}
else if ((reader.ContentSize > 0) && (reader.ContentSize <= 32) && !reader.IsBinary)
{
tooltip += " " + GetHex(reader.ContentBytes);
}
return(CreateNode(text, tooltip));
}
private Message ReadClose(MsgPackReader reader)
{
// https://github.com/aspnet/AspNetCore/blob/master/src/SignalR/docs/specs/HubProtocol.md#close-message-encoding-1
string error = reader.ReadString();
bool allowReconnect = false;
try
{
allowReconnect = reader.ReadBoolean();
}
catch { }
return(new Message
{
type = MessageTypes.Close,
error = error,
allowReconnect = allowReconnect
});
}
private Message ReadInvocation(MsgPackReader reader)
{
// https://github.com/aspnet/AspNetCore/blob/master/src/SignalR/docs/specs/HubProtocol.md#invocation-message-encoding-1
ReadHeaders(reader);
string invocationId = reader.ReadString();
string target = reader.ReadString();
object[] arguments = ReadArguments(reader, target);
string[] streamIds = ReadStreamIds(reader);
return(new Message
{
type = MessageTypes.Invocation,
invocationId = invocationId,
target = target,
arguments = arguments,
streamIds = streamIds
});
}
public static Ellipse ReadEllipse(this MsgPackReader reader)
{
var ellipse = new Ellipse();
reader.ReadPrefix(TypePrefixes.FixMap);
for (int i = 0; i < 3; i++)
{
var key = reader.ReadString();
switch (key)
{
case "center": ellipse.Center = reader.ReadPoint2d(); break;
case "angle": ellipse.Angle = reader.ReadDouble(); break;
case "axes": ellipse.Axes = reader.ReadPoint2d(); break;
default: throw new InvalidOperationException(Resources.ParseError);
}
}
return(ellipse);
}
public static Circle3d ReadCircle3d(this MsgPackReader reader)
{
var circle = new Circle3d();
reader.ReadPrefix(TypePrefixes.FixMap);
for (int i = 0; i < 3; i++)
{
var key = reader.ReadString();
switch (key)
{
case "center": circle.Center = reader.ReadPoint3d(); break;
case "radius": circle.Radius = reader.ReadDouble(); break;
case "normal": circle.Normal = reader.ReadPoint3d(); break;
default: throw new InvalidOperationException(Resources.ParseError);
}
}
return(circle);
}
public static object Deserialize(Type objectType, Stream msgPackInput, SerializationContext context)
{
if (objectType == null)
{
throw new ArgumentNullException("objectType");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (msgPackInput == null)
{
throw new ArgumentNullException("msgPackInput");
}
if (!msgPackInput.CanRead)
{
throw JsonSerializationException.StreamIsNotReadable();
}
var reader = new MsgPackReader(msgPackInput, context);
return(reader.ReadValue(objectType, false));
}
private object[] ReadArguments(MsgPackReader reader, string target)
{
var subscription = this.Connection.GetSubscription(target);
object[] args;
if (subscription == null || subscription.callbacks == null || subscription.callbacks.Count == 0)
{
args = reader.ReadValue(typeof(object[])) as object[];
}
else
{
reader.NextToken();
args = new object[subscription.callbacks[0].ParamTypes.Length];
for (int i = 0; i < subscription.callbacks[0].ParamTypes.Length; ++i)
{
args[i] = reader.ReadValue(subscription.callbacks[0].ParamTypes[i]);
}
reader.NextToken();
}
return(args);
}
public IncomingPacket Parse(SocketManager manager, BufferSegment data, TransportEventTypes transportEvent = TransportEventTypes.Unknown)
{
using (var stream = new System.IO.MemoryStream(data.Data, data.Offset, data.Count))
{
var buff = BufferPool.Get(MsgPackReader.DEFAULT_BUFFER_SIZE, true);
try
{
var context = new SerializationContext
{
Options = SerializationOptions.SuppressTypeInformation/*,
* ExtensionTypeHandler = CustomMessagePackExtensionTypeHandler.Instance*/
};
IJsonReader reader = new MsgPackReader(stream, context, Endianness.BigEndian, buff);
reader.ReadObjectBegin();
int type = -1, id = -1;
string nsp = null;
bool hasData = false, readData = false;
IncomingPacket packet = IncomingPacket.Empty;
READ:
while (reader.Token != JsonToken.EndOfObject)
{
string key = reader.ReadMember();
switch (key)
{
case "type":
type = reader.ReadByte();
break;
case "nsp":
nsp = reader.ReadString();
break;
case "id":
id = reader.ReadInt32();
break;
case "data":
if (!hasData)
{
hasData = true;
SkipData(reader, (SocketIOEventTypes)type);
}
else
{
readData = true;
packet = new IncomingPacket(transportEvent != TransportEventTypes.Unknown ? transportEvent : TransportEventTypes.Message, (SocketIOEventTypes)type, nsp, id);
(string eventName, object[] args) = ReadData(manager, packet, reader);
packet.EventName = eventName;
if (args != null)
{
if (args.Length == 1)
{
packet.DecodedArg = args[0];
}
else
{
packet.DecodedArgs = args;
}
}
}
break;
}
}
// type, nsp, id and data can come in any order. To read data strongly typed we need to know all the additional fields before processing the data field.
// In order to do it, when we first encounter the data field we skip it than we do a reset and an additional turn but reading the data too now.
if (hasData && !readData)
{
reader.Reset();
stream.Position = 0;
reader.ReadObjectBegin();
goto READ;
}
reader.ReadObjectEnd();
return(packet.Equals(IncomingPacket.Empty) ? new IncomingPacket(transportEvent != TransportEventTypes.Unknown ? transportEvent : TransportEventTypes.Message, (SocketIOEventTypes)type, nsp, id) : packet);
}
finally
{
BufferPool.Release(buff);
}
}
}
private Dictionary <string, string> ReadHeaders(MsgPackReader reader)
{
return(reader.ReadValue(typeof(Dictionary <string, string>)) as Dictionary <string, string>);
}
private string[] ReadStreamIds(MsgPackReader reader)
{
return(reader.ReadValue(typeof(string[])) as string[]);
}
private static string GetNodeText(MsgPackReader reader)
{
if (reader.IsArray)
return String.Format("Array ({0} items)", reader.ChildObjectCount);
if (reader.IsMap)
return String.Format("Map ({0} items)", reader.ChildObjectCount/2);
var value = reader.GetValue();
if (value == null)
return "null";
var stringValue = value as string;
if (stringValue != null)
return "\"" + stringValue.Replace("\"", "\\\"").Replace("\0", "\\0") + "\"";
var byteValue = value as byte[];
if (byteValue != null)
return GetHex(byteValue);
return value.ToString();
}
private TreeNode CreateNode(MsgPackReader reader)
{
var formatName = GetFormatName(reader.Format);
var text = GetNodeText(reader);
var tooltip = String.Format("{0} ({1:x2}) ({2} bytes)", formatName, reader.FormatByte, reader.TotalSize);
if (reader.IsExtended)
tooltip += String.Format(" (Extended Type {0})", reader.ExtendedType);
else if ((reader.ContentSize > 0) && (reader.ContentSize <= 32) && !reader.IsBinary)
tooltip += " " + GetHex(reader.ContentBytes);
return CreateNode(text, tooltip);
}
public void DisplayData(byte[] data)
{
Clear();
TreeNode root = null;
TreeNode parent = null;
var remainingCountStack = new Stack<int>();
var remainingCount = 1;
using (var stream = new MemoryStream(data))
using (var reader = new MsgPackReader(stream))
{
try
{
while (reader.ReadNext())
{
var node = CreateNode(reader);
if (parent != null)
parent.Nodes.Add(node);
else
{
root = node;
parent = node;
}
remainingCount--;
if (reader.IsArray || reader.IsMap)
{
remainingCountStack.Push(remainingCount);
remainingCount = reader.ChildObjectCount;
parent = node;
}
while ((remainingCount == 0) && (remainingCountStack.Count > 0))
{
remainingCount = remainingCountStack.Pop();
parent = parent.Parent;
}
if ((remainingCount == 0) && (remainingCountStack.Count == 0))
break;
}
if (reader.ReadNext())
throw new Exception("content after the root node");
}
catch (Exception ex)
{
var message = String.Format("Error at byte {0}: {1}", stream.Position, ex.Message);
var node = CreateNode(message, ex.ToString());
if (root == null)
root = node;
else
root.Nodes.Add(node);
}
}
if (root != null)
{
tree.Nodes.Add(root);
tree.ExpandAll();
tree.SelectedNode = root;
}
}
void Test(WriteDelegate writeProc, ReadDelegate readProc, byte[] expectedBytes)
{
byte[] raw;
using (MemoryStream ms = new MemoryStream ()) {
MsgPackWriter writer = new MsgPackWriter (ms);
writeProc (writer);
raw = ms.ToArray ();
}
Assert.AreEqual (expectedBytes, raw, "pack failed");
using (MemoryStream ms = new MemoryStream (raw)) {
MsgPackReader reader = new MsgPackReader (ms);
readProc (reader);
}
}
public void DisplayData(byte[] data)
{
Clear();
TreeNode root = null;
TreeNode parent = null;
var remainingCountStack = new Stack <int>();
var remainingCount = 1;
using (var stream = new MemoryStream(data))
using (var reader = new MsgPackReader(stream))
{
try
{
while (reader.ReadNext())
{
var node = CreateNode(reader);
if (parent != null)
{
parent.Nodes.Add(node);
}
else
{
root = node;
parent = node;
}
remainingCount--;
if (reader.IsArray || reader.IsMap)
{
remainingCountStack.Push(remainingCount);
remainingCount = reader.ChildObjectCount;
parent = node;
}
while ((remainingCount == 0) && (remainingCountStack.Count > 0))
{
remainingCount = remainingCountStack.Pop();
parent = parent.Parent;
}
if ((remainingCount == 0) && (remainingCountStack.Count == 0))
{
break;
}
}
if (reader.ReadNext())
{
throw new Exception("content after the root node");
}
}
catch (Exception ex)
{
var message = String.Format("Error at byte {0}: {1}", stream.Position, ex.Message);
var node = CreateNode(message, ex.ToString());
if (root == null)
{
root = node;
}
else
{
root.Nodes.Add(node);
}
}
}
if (root != null)
{
tree.Nodes.Add(root);
tree.ExpandAll();
tree.SelectedNode = root;
}
}
public void Reset(Stream _stream)
{
stream = _stream;
structs_pos.Clear();
io = new MsgPackReader(stream);
}
public static string ReadString(this MsgPackReader reader)
{
reader.ReadPrefix(TypePrefixes.FixRaw);
return(reader.ReadRawString());
}
