public override IDictionary <K, V> Deserialize(IByteBuffer buffer, TarsConvertOptions options)
{
switch (options.TarsType)
{
case TarsStructType.Map:
{
int size = buffer.ReadInt();
var dict = new Dictionary <K, V>(size);
var op = options.Create();
for (int i = 0; i < size; ++i)
{
headHandler.ReadHead(buffer, op);
var k = convert.Deserialize <K>(buffer, op);
headHandler.ReadHead(buffer, op);
var v = convert.Deserialize <V>(buffer, op);
if (dict.ContainsKey(k))
{
dict[k] = v;
}
else
{
dict.Add(k, v);
}
}
return(dict);
}
default:
throw new TarsDecodeException($"DictionaryTarsConvert can not deserialize {options}");
}
}
public void WhenIntEnumShouldEqualExpect(short version, Codec codec, int tag)
{
var enums = new IntEnum[] { IntEnum.A, IntEnum.B, IntEnum.C };
var types = new byte[] { TarsStructType.Zero, TarsStructType.Short, TarsStructType.Int };
for (int i = 0; i < enums.Length; i++)
{
var item = enums[i];
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag,
};
sut.Serialize(item, buffer, options);
Assert.True(options.HasValue);
Assert.True(buffer.ReadableBytes > 0);
options.Tag = 0;
headHandler.ReadHead(buffer, options);
Assert.Equal(types[i], options.TarsType);
Assert.Equal(tag, options.Tag);
Assert.Equal(item, sut.Deserialize <IntEnum>(buffer, options));
}
}
public void ShouldEqualExpect(byte obj, short version, Codec codec, int tag, int length)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
sut.Serialize(obj, buffer, options);
Assert.Equal(length, buffer.ReadableBytes);
var bytes = new byte[length];
buffer.ReadBytes(bytes);
Assert.Equal(obj, bytes.Last());
options.Tag = 0;
buffer = buffer.ResetReaderIndex();
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <byte>(buffer, options);
Assert.Equal(result, obj);
Assert.Equal(tag, options.Tag);
Assert.Equal(TarsStructType.Byte, options.TarsType);
}
public void Deserialize(IByteBuffer buffer, TarsConvertOptions options)
{
var contentBuffer = convert.Deserialize <IByteBuffer>(buffer, options);
headHandler.ReadHead(contentBuffer, options);
Temp = convert.Deserialize <IDictionary <string, IByteBuffer> >(contentBuffer, options);
}
public void ShouldEqualExpect(long obj, short version, Codec codec, int tag, byte tarsStructType)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
sut.Serialize(obj, buffer, options);
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <long>(buffer, options);
Assert.Equal(obj, result);
Assert.Equal(tag, options.Tag);
Assert.Equal(tarsStructType, options.TarsType);
}
public void WhenEmptyShouldBeEmpty(short version, Codec codec, int tag)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag,
};
sut.Serialize(Unpooled.Empty, buffer, options);
Assert.True(options.HasValue);
Assert.True(buffer.ReadableBytes > 0);
options.Tag = 0;
headHandler.ReadHead(buffer, options);
Assert.Equal(TarsStructType.ByteArray, options.TarsType);
Assert.Equal(tag, options.Tag);
Assert.Equal(Unpooled.Empty, sut.Deserialize <IByteBuffer>(buffer, options));
}
public void ShouldEqualExpect(byte type, int tag)
{
var buffer = Unpooled.Buffer(2);
sut.WriteHead(buffer, type, tag);
var options = new TarsConvertOptions();
sut.ReadHead(buffer, options);
Assert.Equal(type, options.TarsType);
Assert.Equal(tag, options.Tag);
}
public override T Deserialize(IByteBuffer buffer, TarsConvertOptions options)
{
if (options.TarsType == TarsStructType.StructBegin)
{
var op = options.Create();
headHandler.ReadHead(buffer, op);
var result = new T();
while (op.TarsType != TarsStructType.StructEnd)
{
var p = properties[op.Tag];
p.SetValue(result, convert.Deserialize(buffer, p.GetMemberInfo().PropertyType, op));
headHandler.ReadHead(buffer, op);
}
return(result);
}
else
{
throw new TarsDecodeException($"StructTarsConvert can not deserialize {options}");
}
}
public override IByteBuffer Deserialize(IByteBuffer buffer, TarsConvertOptions options)
{
switch (options.TarsType)
{
case TarsStructType.ByteArray:
headHandler.ReadHead(buffer, options);
int size = buffer.ReadInt();
return(buffer.ReadBytes(size));
default:
throw new TarsDecodeException($"ByteBufferTarsConvert can not deserialize {options}");
}
}
public void ShouldEqualExpect(short version, Codec codec, int tag)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
var dict = new Dictionary <string, string>
{
{ "str", "ok" }
} as IDictionary <string, string>;
sut.Serialize(dict, buffer, options);
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <IDictionary <string, string> >(buffer, options);
Assert.Single(result);
Assert.Equal("ok", result["str"]);
Assert.Equal(tag, options.Tag);
Assert.Equal(TarsStructType.Map, options.TarsType);
}
public void ShouldEqualExpect(short version, Codec codec, int tag)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
var list = new List <string>()
{
"str", "ok"
} as IList <string>;
sut.Serialize(list, buffer, options);
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <IList <string> >(buffer, options);
Assert.Equal(2, result.Count);
Assert.Equal("str", result[0]);
Assert.Equal("ok", result[1]);
Assert.Equal(tag, options.Tag);
Assert.Equal(TarsStructType.List, options.TarsType);
}
public override Response Deserialize(IByteBuffer buffer, TarsConvertOptions options)
{
var resp = new Response();
headHandler.ReadHead(buffer, options);
options.Version = resp.Version = shortConvert.Deserialize(buffer, options);
switch (options.Version)
{
case TarsCodecsVersion.V2:
case TarsCodecsVersion.V3:
DeserializeV2OrV3(buffer, options, resp);
break;
default:
DeserializeV1(buffer, options, resp);
break;
}
return(resp);
}
public override IList <T> Deserialize(IByteBuffer buffer, TarsConvertOptions options)
{
switch (options.TarsType)
{
case TarsStructType.List:
{
int size = buffer.ReadInt();
var list = new List <T>(size);
var op = options.Create();
for (int i = 0; i < size; ++i)
{
headHandler.ReadHead(buffer, op);
var t = convert.Deserialize(buffer, op);
list.Add(t);
}
return(list);
}
default:
throw new TarsDecodeException($"DictionaryTarsConvert can not deserialize {options}");
}
}
public void UniAttributeTest(Codec codec, int tag)
{
var test = new TestTarsConvert();
var sut = new UniAttributeV2(test.ConvertRoot, test.HeadHandler)
{
Temp = new Dictionary <string, IDictionary <string, IByteBuffer> >(3)
};
var options = new TarsConvertOptions()
{
Codec = codec,
Version = TarsCodecsVersion.V2,
Tag = tag,
};
sut.Put(string.Empty, 1, typeof(int), options);
sut.Put("23", "66", typeof(string), options);
sut.Put("23", "23", typeof(string), options);
sut.Put("dd", 0d, typeof(double), options);
sut.Put("ddd", 0d, typeof(double), options);
sut.Put("ddd", null, typeof(double), options);
var buf = Unpooled.Buffer(128);
sut.Serialize(buf, options);
sut.Temp = null;
headHandler.ReadHead(buf, options);
sut.Deserialize(buf, options);
Assert.Equal(3, sut.Temp.Count);
var buffer = sut.Temp[string.Empty][string.Empty];
test.HeadHandler.ReadHead(buffer, options);
Assert.Equal(1, test.ConvertRoot.Deserialize <int>(buffer, options));
buffer = sut.Temp["23"][string.Empty];
test.HeadHandler.ReadHead(buffer, options);
Assert.Equal("23", test.ConvertRoot.Deserialize <string>(buffer, options));
buffer = sut.Temp["dd"][string.Empty];
test.HeadHandler.ReadHead(buffer, options);
Assert.Equal(0d, test.ConvertRoot.Deserialize <double>(buffer, options));
}
public void ShouldEqualExpect(short version, Codec codec, int tag, int age, string name)
{
var buffer = Unpooled.Buffer(1);
var options = new TarsConvertOptions()
{
Codec = codec,
Version = version,
Tag = tag
};
TestData data = new TestData()
{
Age = age,
Name = name
};
sut.Serialize(data, buffer, options);
headHandler.ReadHead(buffer, options);
var result = sut.Deserialize <TestData>(buffer, options);
Assert.Equal(tag, options.Tag);
Assert.Equal(age, result.Age);
Assert.Equal(name, result.Name);
}
public override Request Deserialize(IByteBuffer buffer, TarsConvertOptions options)
{
var req = new Request();
var tag = options.Tag = 1;
while (tag != 0 && buffer.IsReadable())
{
headHandler.ReadHead(buffer, options);
tag = options.Tag;
switch (tag)
{
case 1:
req.Version = shortConvert.Deserialize(buffer, options);
options.Version = req.Version;
break;
case 2:
req.PacketType = byteConvert.Deserialize(buffer, options);
break;
case 3:
req.MessageType = intConvert.Deserialize(buffer, options);
break;
case 4:
req.RequestId = intConvert.Deserialize(buffer, options);
break;
case 5:
req.ServantName = stringConvert.Deserialize(buffer, options);
break;
case 6:
req.FuncName = stringConvert.Deserialize(buffer, options);
var(method, isOneway, outParameters, codec, version, serviceType) = rpcMetadata.FindRpcMethod(req.ServantName, req.FuncName);
req.IsOneway = isOneway;
req.Mehtod = method;
req.ReturnParameterTypes = outParameters;
req.ServiceType = serviceType;
req.ParameterTypes = method.GetParameters();
break;
case 7 when options.Version == TarsCodecsVersion.V1:
{
var contentBuffer = bufferConvert.Deserialize(buffer, options);
req.Parameters = new object[req.ParameterTypes.Length];
while (contentBuffer.IsReadable())
{
headHandler.ReadHead(contentBuffer, options);
var index = options.Tag - 1;
var type = req.ParameterTypes[index];
req.Parameters[index] = convertRoot.Deserialize(contentBuffer, type.ParameterType, options);
}
}
break;
case 7 when options.Version == TarsCodecsVersion.V2:
{
var uni = new UniAttributeV2(convertRoot, headHandler);
uni.Deserialize(buffer, options);
req.Parameters = new object[req.ParameterTypes.Length];
foreach (var pt in req.ParameterTypes)
{
var pBuffer = uni.Temp[pt.Name].Values.First();
headHandler.ReadHead(pBuffer, options);
req.Parameters[pt.Position] = convertRoot.Deserialize(pBuffer, pt.ParameterType, options);
}
}
break;
case 7 when options.Version == TarsCodecsVersion.V3:
{
var uni = new UniAttributeV3(convertRoot, headHandler);
uni.Deserialize(buffer, options);
req.Parameters = new object[req.ParameterTypes.Length];
foreach (var pt in req.ParameterTypes)
{
var pBuffer = uni.Temp[pt.Name];
headHandler.ReadHead(pBuffer, options);
req.Parameters[pt.Position] = convertRoot.Deserialize(pBuffer, pt.ParameterType, options);
}
}
break;
case 8:
req.Timeout = intConvert.Deserialize(buffer, options);
break;
case 9:
req.Context = dictConvert.Deserialize(buffer, options);
break;
case 10:
req.Status = dictConvert.Deserialize(buffer, options);
tag = 0;
break;
default:
break;
}
}
return(req);
}
