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 void Initialize(MsgPackContext context)
{
_keyConverter = context.GetConverter <Key>();
_bytesConverter = context.GetConverter <byte[]>();
_stringConverter = context.GetConverter <string>();
_nullConverter = context.NullConverter;
}
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 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 void Write(double value, IMsgPackWriter writer, MsgPackContext context)
{
var binary = new DoubleBinary(value);
writer.Write(DataTypes.Double);
if (BitConverter.IsLittleEndian)
{
writer.Write(binary.byte7);
writer.Write(binary.byte6);
writer.Write(binary.byte5);
writer.Write(binary.byte4);
writer.Write(binary.byte3);
writer.Write(binary.byte2);
writer.Write(binary.byte1);
writer.Write(binary.byte0);
}
else
{
writer.Write(binary.byte0);
writer.Write(binary.byte1);
writer.Write(binary.byte2);
writer.Write(binary.byte3);
writer.Write(binary.byte4);
writer.Write(binary.byte5);
writer.Write(binary.byte6);
writer.Write(binary.byte7);
}
}
public void Initialize(MsgPackContext context)
{
_keyConverter = context.GetConverter <Key>();
_uintConverter = context.GetConverter <uint>();
_iteratorConverter = context.GetConverter <Iterator>();
_selectKeyConverter = context.GetConverter <T>();
}
public void Write(DateTime value, IMsgPackWriter writer, MsgPackContext context)
{
var longValue = DateTimeUtils.FromDateTime(value);
var longConverter = context.GetConverter <long>();
longConverter.Write(longValue, writer, context);
}
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));
}
public void Initialize(MsgPackContext context)
{
_uintConverter = context.GetConverter <uint>();
_stringConverter = context.GetConverter <string>();
_engineConverter = context.GetConverter <StorageEngine>();
_fieldConverter = context.GetConverter <List <SpaceField> >();
}
public void Write(ushort value, IMsgPackWriter writer, MsgPackContext context)
{
switch (value.GetFormatType())
{
case DataTypes.PositiveFixNum:
WritePositiveFixNum((byte)value, writer);
break;
case DataTypes.NegativeFixNum:
WriteNegativeFixNum((sbyte)value, writer);
break;
case DataTypes.UInt8:
WriteMPackValue((byte)value, writer);
break;
case DataTypes.Int8:
WriteMPackValue((sbyte)value, writer);
break;
case DataTypes.UInt16:
WriteMPackValue(value, writer);
break;
case DataTypes.Int16:
WriteMPackValue((short)value, writer);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public void Initialize(MsgPackContext context)
{
_keyConverter = context.GetConverter <Key>();
_requestIdConverter = context.GetConverter <RequestId>();
_codeConverter = context.GetConverter <CommandCode>();
_nullConverter = context.NullConverter;
}
public string Read(IMsgPackReader reader, MsgPackContext context, Func <string> creator)
{
var type = reader.ReadDataType();
switch (type)
{
case DataTypes.Null:
return(null);
case DataTypes.Str8:
return(ReadString(reader, IntConverter.ReadUInt8(reader)));
case DataTypes.Str16:
return(ReadString(reader, IntConverter.ReadUInt16(reader)));
case DataTypes.Str32:
return(ReadString(reader, IntConverter.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 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);
}
// 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 void Initialize(MsgPackContext context)
{
_stringConverter = context.GetConverter <string>();
_listStringConverter = context.GetConverter <List <string> >();
_floatConverter = context.GetConverter <float>();
_context = context;
}
public void WriteOldBinary(byte[] value, byte[] data)
{
var context = new MsgPackContext(binaryCompatibilityMode: true);
var result = Should.NotThrow(() => MsgPackSerializer.Serialize(value, context));
result.ShouldBe(data);
}
public void Initialize(MsgPackContext context)
{
_uintConverter = context.GetConverter <uint>();
_keyConverter = context.GetConverter <Key>();
_selectKeyConverter = context.GetConverter <T>();
_context = context;
}
protected NumberDeserialize()
{
_messagePackSerializer = SerializationContext.Default.GetSerializer <T[]>();
_bytes = _messagePackSerializer.PackSingleObject(Numbers);
_stream = new MemoryStream(_bytes);
_mplightContext = new MsgPackContext();
}
public void WriteUintEnum(UintEnum enumValue)
{
var intEnumContext = new MsgPackContext(convertEnumsAsStrings: false);
var enumResult = MsgPackSerializer.Serialize(enumValue, intEnumContext);
var valueResult = MsgPackSerializer.Serialize((uint)enumValue, intEnumContext);
enumResult.ShouldBe(valueResult);
}
public void ReadUintEnum(UintEnum enumValue)
{
var intEnumContext = new MsgPackContext(convertEnumsAsStrings: false);
var bytes = MsgPackSerializer.Serialize((uint)enumValue, intEnumContext);
var enumResult = MsgPackSerializer.Deserialize <UintEnum>(bytes, intEnumContext);
enumResult.ShouldBe(enumValue);
}
public void GetConverterShouldNotThrow()
{
var context = new MsgPackContext();
var ex = Should.Throw <ConverterNotFoundException>(() => context.GetConverter <MsgPackContextTests>());
ex.ObjectType.ShouldBe(typeof(MsgPackContextTests));
}
public void Initialize(MsgPackContext context)
{
_uintConverter = context.GetConverter <uint>();
_stringConverter = context.GetConverter <string>();
_indexTypeConverter = context.GetConverter <IndexType>();
_optionsConverter = context.GetConverter <IndexCreationOptions>();
_indexPartsConverter = context.GetConverter <List <IndexPart> >();
}
private ClientOptions(ConnectionOptions options, ILog log, MsgPackContext context)
{
ConnectionOptions = options;
MsgPackContext = context ?? new MsgPackContext(binaryCompatibilityMode: true);
if (log != null)
{
LogWriter = new LogWriterWrapper(this, log);
}
}
private ClientOptions(ConnectionOptions options, ILog log, MsgPackContext context)
{
ConnectionOptions = options;
MsgPackContext = context ?? new MsgPackContext();
if (log != null)
{
LogWriter = new LogWriterWrapper(this, log);
}
}
private static IMsgPackConverter <T> GetConverter <T>(MsgPackContext context)
{
var converter = context.GetConverter <T>();
if (converter == null)
{
throw new SerializationException($"Provide converter for {typeof(T).Name}");
}
return(converter);
}
protected MapContextFixture()
{
OldContext = new MsgPackContext();
OldContext.RegisterConverter <IImageInfo>(new ImageInfoMapConverter());
OldContext.RegisterConverter <ImageInfo>(new ImageInfoMapConverter());
OldContext.RegisterConverter <BigImageInfo>(new ImageInfoMapConverter());
OldContext.RegisterConverter <IMegaImageInfo>(new ImageInfoMapConverter());
NewContext = new MsgPackContext();
}
public LogicalConnection(ClientOptions options, RequestIdCounter requestIdCounter)
{
_clientOptions = options;
_requestIdCounter = requestIdCounter;
_msgPackContext = options.MsgPackContext;
_logWriter = options.LogWriter;
_physicalConnection = new NetworkStreamPhysicalConnection();
_responseReader = new ResponseReader(_clientOptions, _physicalConnection);
_requestWriter = new RequestWriter(_clientOptions, _physicalConnection);
}
public object Read(IMsgPackReader reader, MsgPackContext context, Func <object> creator)
{
var type = reader.ReadDataType();
if (type == DataTypes.Null)
{
return(null);
}
throw ExceptionUtils.BadTypeException(type, DataTypes.Null);
}
private static T Deserialize <T>(byte[] data, [NotNull] MsgPackContext context, Func <T> creator)
{
var memoryStream = new MemoryStream(data);
using (var reader = new MsgPackStreamReader(memoryStream))
{
var converter = GetConverter <T>(context);
return(converter.Read(reader, context, creator));
}
}
public void Initialize(MsgPackContext context)
{
_stringConverter = context.GetConverter <string>();
_listStringConverter = context.GetConverter <List <string> >();
_floatConverter = context.GetConverter <float>();
_brand = MsgPackSerializer.Serialize(nameof(Beer.Brand));
_alcohol = MsgPackSerializer.Serialize(nameof(Beer.Alcohol));
_sort = MsgPackSerializer.Serialize(nameof(Beer.Sort));
_brewery = MsgPackSerializer.Serialize(nameof(Beer.Brewery));
_context = context;
}
