public static void WriteString(string value, MsgPackStream stream)
{
if (value == null)
{
stream.WriteUInt8(FormatCode.Nil);
return;
}
var length = Encoding.UTF8.GetByteCount(value);
if (length <= FormatRange.MaxFixStringLength)
{
stream.WriteUInt8(unchecked ((byte)(FormatCode.MinFixStr | length)));
}
else if (length <= byte.MaxValue)
{
stream.WriteUInt8(FormatCode.Str8);
stream.WriteUInt8(unchecked ((byte)length));
}
else if (length <= ushort.MaxValue)
{
stream.WriteUInt8(FormatCode.Str16);
stream.WriteUInt16(unchecked ((ushort)length));
}
else
{
stream.WriteUInt8(FormatCode.Str32);
stream.WriteInt32(length);
}
stream.WriteString(value);
}
public static void WriteBytes(BufferSegment value, MsgPackStream stream)
{
if (value.Array == null)
{
stream.WriteUInt8(FormatCode.Nil);
return;
}
var length = value.Length;
if (length <= byte.MaxValue)
{
stream.WriteUInt8(FormatCode.Bin8);
stream.WriteUInt8(unchecked ((byte)length));
}
else if (length <= ushort.MaxValue)
{
stream.WriteUInt8(FormatCode.Bin16);
stream.WriteUInt16(unchecked ((ushort)length));
}
else if (length < uint.MaxValue)
{
stream.WriteUInt8(FormatCode.Bin32);
stream.WriteUInt32(unchecked ((uint)length));
}
else
{
throw new MsgPackException("Max bin length exceeded");
}
stream.WriteBytes(value);
}
public static void WriteInt8(sbyte value, MsgPackStream stream)
{
if (value < FormatRange.MinFixNegativeInt)
{
stream.WriteUInt8(FormatCode.Int8);
}
stream.WriteInt8(value);
}
public static void WriteUInt8(byte value, MsgPackStream stream)
{
if (value > FormatCode.MaxFixInt)
{
stream.WriteUInt8(FormatCode.UInt8);
}
stream.WriteUInt8(value);
}
/// <summary>
/// From Json String to MessagePack binary
/// </summary>
public static byte[] FromJson(TextReader reader)
{
using (var jr = new TinyJsonReader(reader, false))
{
var stream = new MsgPackStream(1024);
FromJsonCore(jr, stream);
return(stream.Output.ToArray());
}
}
public static void WriteUInt64(ulong value, MsgPackStream stream)
{
if (value <= uint.MaxValue)
{
WriteUInt32(unchecked ((uint)value), stream);
return;
}
stream.WriteUInt8(FormatCode.UInt64);
stream.WriteUInt64(value);
}
public static void WriteUInt16(ushort value, MsgPackStream stream)
{
if (value <= byte.MaxValue)
{
WriteUInt8(unchecked ((byte)value), stream);
return;
}
stream.WriteUInt8(FormatCode.UInt16);
stream.WriteUInt16(value);
}
public static void WriteUInt32(uint value, MsgPackStream stream)
{
if (value <= ushort.MaxValue)
{
WriteUInt16(unchecked ((ushort)value), stream);
return;
}
stream.WriteUInt8(FormatCode.UInt32);
stream.WriteUInt32(value);
}
/// <summary>
/// Dump message-pack binary to JSON string.
/// </summary>
public static string ToJson(byte[] bytes, long offset = 0)
{
if (bytes == null || bytes.Length == 0)
{
return(string.Empty);
}
var sb = new StringBuilder();
var stream = new MsgPackStream(bytes, offset);
ToJsonCore(stream, sb);
return(sb.ToString());
}
public static void WriteInt16(short value, MsgPackStream stream)
{
if (value >= 0)
{
WriteUInt16(unchecked ((ushort)value), stream);
return;
}
if (value >= sbyte.MinValue)
{
WriteInt8(unchecked ((sbyte)value), stream);
return;
}
stream.WriteUInt8(FormatCode.Int16);
stream.WriteInt16(value);
}
public static void WriteInt64(long value, MsgPackStream stream)
{
if (value >= 0)
{
WriteUInt64(unchecked ((ulong)value), stream);
return;
}
if (value >= int.MinValue)
{
WriteInt32(unchecked ((int)value), stream);
return;
}
stream.WriteUInt8(FormatCode.Int64);
stream.WriteInt64(value);
}
public static void WriteInt32(int value, MsgPackStream stream)
{
if (value >= 0)
{
WriteUInt32(unchecked ((uint)value), stream);
return;
}
if (value >= short.MinValue)
{
WriteInt16(unchecked ((short)value), stream);
return;
}
stream.WriteUInt8(FormatCode.Int32);
stream.WriteInt32(value);
}
public static void WriteMapHeader(uint length, MsgPackStream stream)
{
if (length <= FormatRange.MaxFixMapCount)
{
stream.WriteUInt8(unchecked ((byte)(FormatCode.MinFixMap | length)));
}
else if (length <= ushort.MaxValue)
{
stream.WriteUInt8(FormatCode.Map16);
stream.WriteUInt16(unchecked ((ushort)length));
}
else
{
stream.WriteUInt8(FormatCode.Map32);
stream.WriteUInt32(length);
}
}
public static void WriteExtensionHeader(ExtensionHeader header, MsgPackStream stream)
{
switch (header.Length)
{
case 1: stream.WriteUInt8(FormatCode.FixExt1); break;
case 2: stream.WriteUInt8(FormatCode.FixExt2); break;
case 4: stream.WriteUInt8(FormatCode.FixExt4); break;
case 8: stream.WriteUInt8(FormatCode.FixExt8); break;
case 16: stream.WriteUInt8(FormatCode.FixExt16); break;
default:
if (header.Length <= byte.MaxValue)
{
stream.WriteUInt8(FormatCode.Ext8);
stream.WriteUInt8(unchecked ((byte)header.Length));
}
else if (header.Length <= ushort.MaxValue)
{
stream.WriteUInt8(FormatCode.Ext16);
stream.WriteUInt16(unchecked ((ushort)header.Length));
}
else
{
stream.WriteUInt8(FormatCode.Ext32);
stream.WriteUInt32(header.Length);
}
break;
}
stream.WriteInt8(header.TypeCode);
}
private static uint FromJsonCore(TinyJsonReader jr, MsgPackStream stream)
{
uint count = 0;
while (jr.Read())
{
switch (jr.TokenType)
{
case TinyJsonToken.None: break;
case TinyJsonToken.EndObject: return(count);
case TinyJsonToken.EndArray: return(count);
case TinyJsonToken.StartObject:
{
var innerStream = new MsgPackStream(1024);
var mapCount = FromJsonCore(jr, innerStream) / 2;
StreamWriter.WriteMapHeader(mapCount, stream);
stream.WriteBytes(innerStream.Output);
count++;
break;
}
case TinyJsonToken.StartArray:
{
var innerStream = new MsgPackStream(1024);
var arrayCount = FromJsonCore(jr, innerStream);
StreamWriter.WriteArrayHeader(arrayCount, stream);
stream.WriteBytes(innerStream.Output);
count++;
break;
}
case TinyJsonToken.Number:
var v = jr.ValueType;
if (v == ValueType.Double)
{
StreamWriter.WriteDouble(jr.DoubleValue, stream);
}
else if (v == ValueType.Long)
{
StreamWriter.WriteInt64(jr.LongValue, stream);
}
else if (v == ValueType.ULong)
{
StreamWriter.WriteUInt64(jr.ULongValue, stream);
}
else if (v == ValueType.Decimal)
{
StreamWriter.WriteString(jr.DecimalValue.ToString(CultureInfo.InvariantCulture), stream);
}
count++;
break;
case TinyJsonToken.String:
StreamWriter.WriteString(jr.StringValue, stream);
count++;
break;
case TinyJsonToken.True:
StreamWriter.WriteBool(true, stream);
count++;
break;
case TinyJsonToken.False:
StreamWriter.WriteBool(false, stream);
count++;
break;
case TinyJsonToken.Null:
StreamWriter.WriteNil(stream);
count++;
break;
}
}
return(count);
}
public static void WriteNil(MsgPackStream stream)
{
stream.WriteUInt8(FormatCode.Nil);
}
public static void WriteBool(bool value, MsgPackStream stream)
{
stream.WriteUInt8(value ? FormatCode.True : FormatCode.False);
}
public static void WriteSingle(float value, MsgPackStream stream)
{
stream.WriteUInt8(FormatCode.Float32);
stream.WriteSingle(value);
}
static void ToJsonCore(MsgPackStream stream, StringBuilder builder)
{
var code = stream.Peek();
var type = StreamReader.GetType(stream);
switch (type)
{
case FormatType.Integer:
builder.Append(FormatCode.IsSignedInteger(code)
? StreamReader.ReadInt64(stream).ToString(CultureInfo.InvariantCulture)
: StreamReader.ReadUInt64(stream).ToString(CultureInfo.InvariantCulture));
break;
case FormatType.Boolean:
builder.Append(StreamReader.ReadBool(stream) ? "true" : "false");
break;
case FormatType.Float:
builder.Append(code == FormatCode.Float32
? StreamReader.ReadSingle(stream).ToString(CultureInfo.InvariantCulture)
: StreamReader.ReadDouble(stream).ToString(CultureInfo.InvariantCulture));
break;
case FormatType.String:
WriteJsonString(StreamReader.ReadString(stream), builder);
break;
case FormatType.Binary:
builder.Append("\"" + System.Convert.ToBase64String(StreamReader.ReadBytes(stream).ToArray()) + "\"");
break;
case FormatType.Array:
{
var length = StreamReader.ReadArrayHeader(stream);
builder.Append("[");
for (int i = 0; i < length; i++)
{
ToJsonCore(stream, builder);
if (i != length - 1)
{
builder.Append(",");
}
}
builder.Append("]");
return;
}
case FormatType.Map:
{
var length = StreamReader.ReadMapHeader(stream);
builder.Append("{");
for (int i = 0; i < length; i++)
{
var keyType = StreamReader.GetType(stream);
if (keyType == FormatType.String || keyType == FormatType.Binary)
{
ToJsonCore(stream, builder);
}
else
{
builder.Append("\"");
ToJsonCore(stream, builder);
builder.Append("\"");
}
builder.Append(":");
ToJsonCore(stream, builder);
if (i != length - 1)
{
builder.Append(",");
}
}
builder.Append("}");
return;
}
case FormatType.Extension:
var header = StreamReader.ReadExtensionHeader(stream);
if (header.TypeCode == DateTimeFormatter.TypeCode)
{
var dt = DateTimeFormatter.Unpack(stream, header.Length);
builder.Append("\"");
builder.Append(dt.ToString("o", CultureInfo.InvariantCulture));
builder.Append("\"");
}
else
{
builder.Append("[");
builder.Append(header.TypeCode);
builder.Append(",");
builder.Append("\"");
builder.Append(System.Convert.ToBase64String(stream.ReadBytes(header.Length).ToArray()));
builder.Append("\"");
builder.Append("]");
}
break;
default:
builder.Append("null");
StreamReader.Skip(stream);
break;
}
}
public static void WriteDouble(double value, MsgPackStream stream)
{
stream.WriteUInt8(FormatCode.Float64);
stream.WriteDouble(value);
}
