internal static SqlInfo ReadSqlInfo(IMsgPackReader reader, IMsgPackConverter <Key> keyConverter, IMsgPackConverter <int> intConverter)
{
var length = reader.ReadMapLength();
if (length == null)
{
return(null);
}
var result = default(SqlInfo);
for (var i = 0; i < length; i++)
{
switch (keyConverter.Read(reader))
{
case Key.SqlRowCount:
result = new SqlInfo(intConverter.Read(reader));
break;
default:
reader.SkipToken();
break;
}
}
return(result);
}
public EmptyResponse Read(IMsgPackReader reader)
{
var length = reader.ReadMapLength();
if (length > 1)
{
throw ExceptionHelper.InvalidMapLength(length, 0, 1);
}
if (length == 1)
{
var dataKey = _keyConverter.Read(reader);
if (dataKey != Key.Data)
{
throw ExceptionHelper.UnexpectedKey(dataKey, Key.Data);
}
var arrayLength = reader.ReadArrayLength();
if (arrayLength != 0)
{
throw ExceptionHelper.InvalidArrayLength(0, length);
}
}
return(new EmptyResponse());
}
private IndexPart ReadFromMap(IMsgPackReader reader, uint length)
{
uint? fieldNo = null;
IndexPartType?indexPartType = null;
for (var i = 0; i < length; i++)
{
switch (_stringConverter.Read(reader))
{
case "field":
fieldNo = _uintConverter.Read(reader);
break;
case "type":
indexPartType = _indexPartTypeConverter.Read(reader);
break;
default:
reader.SkipToken();
break;
}
}
if (fieldNo.HasValue && indexPartType.HasValue)
{
return(new IndexPart(fieldNo.Value, indexPartType.Value));
}
throw new SerializationException("Can't read fieldNo or indexPart from map of index metadata");
}
public DataResponse Read(IMsgPackReader reader)
{
var length = reader.ReadMapLength();
if (!(1u <= length && length <= 3))
{
throw ExceptionHelper.InvalidMapLength(length, 1u, 2u);
}
var sqlInfo = default(SqlInfo);
for (var i = 0; i < length; i++)
{
var dataKey = _keyConverter.Read(reader);
switch (dataKey)
{
case Key.SqlInfo:
sqlInfo = ReadSqlInfo(reader, _keyConverter, _intConverter);
break;
default:
throw ExceptionHelper.UnexpectedKey(dataKey, Key.Data, Key.Metadata);
}
}
return(new DataResponse(sqlInfo));
}
public ErrorResponse Read(IMsgPackReader reader)
{
string errorMessage = null;
var length = reader.ReadMapLength();
for (var i = 0; i < length; i++)
{
var errorKey = _keyConverter.Read(reader);
switch (errorKey)
{
case Key.Error24:
errorMessage = _stringConverter.Read(reader);
break;
case Key.Error:
// TODO: add parsing of new error metadata
reader.SkipToken();
break;
default:
reader.SkipToken();
break;
}
}
return(new ErrorResponse(errorMessage));
}
public IndexPart Read(IMsgPackReader reader)
{
var type = reader.ReadDataType();
switch (type)
{
case DataTypes.Map16:
return(ReadFromMap(reader, ReadUInt16(reader)));
case DataTypes.Map32:
return(ReadFromMap(reader, ReadUInt32(reader)));
case DataTypes.Array16:
return(ReadFromArray(reader, ReadUInt16(reader)));
case DataTypes.Array32:
return(ReadFromArray(reader, ReadUInt32(reader)));
}
var length = TryGetLengthFromFixMap(type);
if (length.HasValue)
{
return(ReadFromMap(reader, length.Value));
}
length = TryGetLengthFromFixArray(type);
if (length != null)
{
return(ReadFromArray(reader, length.Value));
}
throw ExceptionUtils.BadTypeException(type, DataTypes.Map16, DataTypes.Map32, DataTypes.FixMap, DataTypes.Array16, DataTypes.Array32, DataTypes.FixArray);
}
public sbyte Read(IMsgPackReader reader, MsgPackContext context, Func <sbyte> creator)
{
var type = reader.ReadDataType();
byte temp;
if (TryGetFixPositiveNumber(type, out temp))
{
return((sbyte)temp);
}
sbyte tempInt8;
if (TryGetNegativeNumber(type, out tempInt8))
{
return(tempInt8);
}
if (type == DataTypes.Int8)
{
return(ReadInt8(reader));
}
throw ExceptionUtils.IntDeserializationFailure(type);
}
public byte Read(IMsgPackReader reader, MsgPackContext context, Func <byte> creator)
{
var type = reader.ReadDataType();
byte temp;
if (TryGetFixPositiveNumber(type, out temp))
{
return(temp);
}
sbyte tempInt8;
if (TryGetNegativeNumber(type, out tempInt8))
{
return((byte)tempInt8);
}
switch (type)
{
case DataTypes.UInt8:
return(ReadUInt8(reader));
case DataTypes.Int8:
return((byte)ReadInt8(reader));
default:
throw ExceptionUtils.IntDeserializationFailure(type);
}
}
public InnerClass Read(IMsgPackReader reader)
{
var instance = new InnerClass();
var nullable = reader.ReadMapLength();
if (!nullable.HasValue)
{
return(null);
}
for (var index = 0; index < nullable.Value; ++index)
{
var str = _stringConverter.Value.Read(reader);
switch (str)
{
case "Qwer":
instance.B = _stringConverter.Value.Read(reader);
break;
default:
reader.SkipToken();
break;
}
}
return(instance);
}
private static byte[] ReadBytes(IMsgPackReader reader, int length)
{
var bytes = new byte[length];
reader.ReadBytes(bytes);
return(bytes);
}
public T?Read(IMsgPackReader reader, MsgPackContext context, Func <T?> creator)
{
var type = reader.ReadDataType();
if (type == DataTypes.Null)
{
return(null);
}
var structConverter = context.GetConverter <T>();
Func <T> nullableCreator;
if (creator == null)
{
nullableCreator = null;
}
else
{
nullableCreator = () =>
{
var result = creator();
return(result ?? default(T));
};
}
reader.Seek(-1, SeekOrigin.Current);
return(structConverter.Read(reader, context, nullableCreator));
}
public ushort Read(IMsgPackReader reader)
{
var type = reader.ReadDataType();
if (TryGetFixPositiveNumber(type, out byte temp))
{
return(temp);
}
if (TryGetNegativeNumber(type, out sbyte tempInt8))
{
return((ushort)tempInt8);
}
switch (type)
{
case DataTypes.UInt8:
return(ReadUInt8(reader));
case DataTypes.UInt16:
return(ReadUInt16(reader));
case DataTypes.Int8:
return((ushort)ReadInt8(reader));
case DataTypes.Int16:
return((ushort)ReadInt16(reader));
default:
throw ExceptionUtils.IntDeserializationFailure(type);
}
}
public SpaceField Read(IMsgPackReader reader)
{
var dictLength = reader.ReadMapLength();
string name = null;
var type = (FieldType)(-1);
for (int i = 0; i < dictLength.Value; i++)
{
var key = _stringConverter.Read(reader);
switch (key)
{
case "name":
name = _stringConverter.Read(reader);
break;
case "type":
type = _typeConverter.Read(reader);
break;
default:
reader.SkipToken();
break;
}
}
return(new SpaceField(name, type));
}
public DateTimeOffset Read(IMsgPackReader reader, MsgPackContext context, Func <DateTimeOffset> creator)
{
var longConverter = context.GetConverter <long>();
var longValue = longConverter.Read(reader, context, null);
return(DateTimeUtils.ToDateTimeOffset(longValue));
}
IMegaImageInfo IMsgPackConverter <IMegaImageInfo> .Read(IMsgPackReader reader)
{
var imageInfo = new MegaImageInfo();
var nullable = reader.ReadMapLength();
if (!nullable.HasValue)
{
return(null);
}
for (var index = 0; index < nullable.Value; ++index)
{
var str = _stringConverter.Value.Read(reader);
if (ReadImageInfoBody(str, imageInfo, reader))
{
continue;
}
if (str == "CreationDate")
{
imageInfo.SomeDate = _dateTimeConverter.Value.Read(reader);
}
else
{
reader.SkipToken();
}
}
return(imageInfo);
}
public override TArray Read(IMsgPackReader reader, MsgPackContext context, Func <TArray> creator)
{
var type = reader.ReadDataType();
switch (type)
{
case DataTypes.Null:
return(default(TArray));
case DataTypes.Array16:
return(ReadArray(reader, context, creator, IntConverter.ReadUInt16(reader)));
case DataTypes.Array32:
return(ReadArray(reader, context, creator, IntConverter.ReadUInt32(reader)));
}
uint length;
if (TryGetLengthFromFixArray(type, out length))
{
return(ReadArray(reader, context, creator, length));
}
throw ExceptionUtils.BadTypeException(type, DataTypes.Array16, DataTypes.Array32, DataTypes.FixArray);
}
public BigImageInfo Read(IMsgPackReader reader)
{
var imageInfo = new BigImageInfo();
var nullable = reader.ReadMapLength();
if (!nullable.HasValue)
{
return(null);
}
for (var index = 0; index < nullable.Value; ++index)
{
var str = _stringConverter.Value.Read(reader);
if (ReadImageInfoBody(str, imageInfo, reader))
{
continue;
}
if (str == "Size2")
{
imageInfo.Size = _intConverter.Value.Read(reader);
}
else
{
reader.SkipToken();
}
}
return(imageInfo);
}
public string Read(IMsgPackReader reader)
{
var type = reader.ReadDataType();
switch (type)
{
case DataTypes.Null:
return(null);
case DataTypes.Str8:
return(ReadString(reader, NumberConverter.ReadUInt8(reader)));
case DataTypes.Str16:
return(ReadString(reader, NumberConverter.ReadUInt16(reader)));
case DataTypes.Str32:
return(ReadString(reader, NumberConverter.ReadUInt32(reader)));
}
uint length;
if (TryGetFixstrLength(type, out length))
{
return(ReadString(reader, length));
}
throw ExceptionUtils.BadTypeException(type, DataTypes.FixStr, DataTypes.Str8, DataTypes.Str16, DataTypes.Str32);
}
public void Test(byte[] data, int objectsCount)
{
var msgPackReaders = new IMsgPackReader[]
{
// new MsgPackMemoryStreamReader(new MemoryStream(data)),
new MsgPackByteArrayReader(data)
};
var readTokenBytes = new List <byte>();
foreach (var msgPackReader in msgPackReaders)
{
for (var i = 0; i < objectsCount; i++)
{
var tokenBytes = msgPackReader.ReadToken();
readTokenBytes.AddRange(tokenBytes);
}
var endOfStream = false;
try
{
msgPackReader.ReadDataType();
}
catch (Exception e)
{
endOfStream = e != null;
}
endOfStream.ShouldBe(true);
}
readTokenBytes.ToArray().ShouldBe(data);
}
// We will have problem with binary blobs greater than int.MaxValue bytes.
public byte[] Read(IMsgPackReader reader, MsgPackContext context, Func <byte[]> creator)
{
var type = reader.ReadDataType();
uint length;
switch (type)
{
case DataTypes.Null:
return(null);
case DataTypes.Bin8:
length = IntConverter.ReadUInt8(reader);
break;
case DataTypes.Bin16:
length = IntConverter.ReadUInt16(reader);
break;
case DataTypes.Bin32:
length = IntConverter.ReadUInt32(reader);
break;
default:
throw ExceptionUtils.BadTypeException(type, DataTypes.Bin8, DataTypes.Bin16, DataTypes.Bin32, DataTypes.Null);
}
return(ReadByteArray(reader, length));
}
public Space Read(IMsgPackReader reader)
{
var actual = reader.ReadArrayLength();
const uint expected = 7u;
if (actual != expected)
{
throw ExceptionHelper.InvalidArrayLength(expected, actual);
}
var id = _uintConverter.Read(reader);
//TODO Find what skipped number means
reader.SkipToken();
var name = _stringConverter.Read(reader);
var engine = _engineConverter.Read(reader);
var fieldCount = _uintConverter.Read(reader);
//TODO Find what skipped dictionary used for
reader.SkipToken();
var fields = _fieldConverter.Read(reader);
return(new Space(id, fieldCount, name, engine, fields.AsReadOnly()));
}
public IndexCreationOptions Read(IMsgPackReader reader)
{
var optionsCount = reader.ReadMapLength();
var stringConverter = context.GetConverter <string>();
var boolConverter = context.GetConverter <bool>();
var unique = false;
for (int i = 0; i < optionsCount.Value; i++)
{
var key = stringConverter.Read(reader);
switch (key)
{
case "unique":
unique = boolConverter.Read(reader);
break;
default:
reader.SkipToken();
break;
}
}
return(new IndexCreationOptions(unique));
}
public void Test(byte[] data, int objectsCount)
{
var msgPackReaders = new IMsgPackReader[]
{
new MsgPackMemoryStreamReader(new MemoryStream(data)),
new MsgPackByteArrayReader(data)
};
foreach (var msgPackReader in msgPackReaders)
{
for (var i = 0; i < objectsCount; i++)
{
msgPackReader.SkipToken();
}
var endOfStream = false;
try
{
msgPackReader.ReadDataType();
}
catch (Exception e)
{
endOfStream = e != null;
}
endOfStream.ShouldBe(true);
}
}
internal static byte[] ReadByteArray(IMsgPackReader reader, uint length)
{
var buffer = new byte[length];
reader.ReadBytes(buffer);
return(buffer);
}
internal static uint ReadUInt32(IMsgPackReader reader)
{
var temp = (uint)(reader.ReadByte() << 24);
temp += (uint)reader.ReadByte() << 16;
temp += (uint)reader.ReadByte() << 8;
temp += reader.ReadByte();
return(temp);
}
private static short ReadInt16(IMsgPackReader reader)
{
var temp = ReadUInt16(reader);
if (temp <= short.MaxValue)
{
return((short)temp);
}
return((short)(temp - 1 - ushort.MaxValue));
}
private TArray ReadList(IMsgPackReader reader, uint length)
{
var array = (TArray)Context.GetObjectActivator(typeof(TArray))();
for (var i = 0u; i < length; i++)
{
array.Add(ElementConverter.Read(reader));
}
return(array);
}
private static long ReadInt64(IMsgPackReader reader)
{
var temp = ReadUInt64(reader);
if (temp <= long.MaxValue)
{
return((long)temp);
}
return((long)(temp - 1 - ulong.MaxValue));
}
private static int ReadInt32(IMsgPackReader reader)
{
var temp = ReadUInt32(reader);
if (temp <= int.MaxValue)
{
return((int)temp);
}
return((int)(temp - 1 - uint.MaxValue));
}
private static sbyte ReadInt8(IMsgPackReader reader)
{
var temp = reader.ReadByte();
if (temp <= sbyte.MaxValue)
{
return((sbyte)temp);
}
return((sbyte)(temp - byte.MaxValue - 1));
}
