/// <summary>
/// ��Ԫ����ת��Ϊ�������ͻ�����
/// </summary>
/// <param name="instance">Ŀ�����</param>
/// <param name="result">�������</param>
/// <param name="container">������������</param>
public override GetObjectResultTypes Process(object instance, GetObjectAnalyseResult result, INetworkDataContainer container)
{
int value;
if(!container.TryReadInt32(out value)) return GetObjectResultTypes.NotEnoughData;
result.SetValue(instance, value.ToLittleEndian());
return GetObjectResultTypes.Succeed;
}
/// <summary>
/// ��Ԫ����ת��Ϊ�������ͻ�����
/// </summary>
/// <param name="instance">Ŀ�����</param>
/// <param name="result">�������</param>
/// <param name="container">������������</param>
public override GetObjectResultTypes Process(object instance, GetObjectAnalyseResult result, INetworkDataContainer container)
{
MessageIdentity identity;
if(!container.TryReadMessageIdentity(out identity)) return GetObjectResultTypes.NotEnoughData;
result.SetValue(instance, identity);
return GetObjectResultTypes.Succeed;
}
/// <summary>
/// ��Ԫ����ת��Ϊ�������ͻ�����
/// </summary>
/// <param name="instance">Ŀ�����</param>
/// <param name="result">�������</param>
/// <param name="container">������������</param>
public override GetObjectResultTypes Process(object instance, GetObjectAnalyseResult result, INetworkDataContainer container)
{
byte value;
if(!container.TryReadByte(out value)) return GetObjectResultTypes.NotEnoughData;
result.SetValue(instance, value);
return GetObjectResultTypes.Succeed;
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="container">网络数据容器</param>
public override GetObjectResultTypes Process(object instance, GetObjectAnalyseResult result, INetworkDataContainer container)
{
byte type;
int count;
if (!container.TryReadByte(out type))
{
return(GetObjectResultTypes.NotEnoughData);
}
if (!container.TryReadInt32(out count))
{
return(GetObjectResultTypes.NotEnoughData);
}
count = count.ToLittleEndian();
string[] value = new string[count];
for (int i = 0; i < count; i++)
{
int length;
if (!container.TryReadInt32(out length))
{
return(GetObjectResultTypes.NotEnoughData);
}
length = length.ToLittleEndian();
string content;
if (!container.TryReadString(Encoding.UTF8, length, out content))
{
return(GetObjectResultTypes.NotEnoughData);
}
value[i] = content;
}
result.SetValue(instance, value);
return(GetObjectResultTypes.Succeed);
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="data">元数据</param>
/// <param name="offset">元数据所在的偏移量</param>
/// <param name="length">元数据长度</param>
public override void Process(object instance, GetObjectAnalyseResult result, byte[] data, int offset, int length = 0)
{
unsafe
{
fixed(byte *pData = &data[offset])
{
if (result.Nullable)
{
result.SetValue <Guid?>(instance, *((Guid *)pData));
}
else
{
result.SetValue(instance, *((Guid *)pData));
}
}
}
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="data">元数据</param>
/// <param name="offset">元数据所在的偏移量</param>
/// <param name="length">元数据长度</param>
public override void Process(object instance, GetObjectAnalyseResult result, byte[] data, int offset, int length = 0)
{
TransactionIdentityTypes identityType = (TransactionIdentityTypes)data[offset];
if (identityType == TransactionIdentityTypes.TCP)
{
result.SetValue(instance, TCPTransactionIdentity.Deserialize(data, offset, length));
}
else if (identityType == TransactionIdentityTypes.NamedPipe)
{
result.SetValue(instance, NamedPipeTransactionIdentity.Deserialize(data, offset, length));
}
else
{
throw new NotSupportedException(string.Format("#We were not support current type of Transaction-Identity yet! {0}", identityType));
}
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="data">元数据</param>
/// <param name="offset">元数据所在的偏移量</param>
/// <param name="length">元数据长度</param>
public override void Process(object instance, GetObjectAnalyseResult result, byte[] data, int offset, int length = 0)
{
unsafe
{
fixed(byte *pData = &data[offset])
result.SetValue(instance, *(MessageIdentity *)pData);
}
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="data">元数据</param>
/// <param name="offset">元数据所在的偏移量</param>
/// <param name="length">元数据长度</param>
public override void Process(object instance, GetObjectAnalyseResult result, byte[] data, int offset, int length = 0)
{
unsafe
{
fixed(byte *pByte = &data[offset])
{
if (result.Nullable)
{
result.SetValue <decimal?>(instance, *(decimal *)pByte);
}
else
{
result.SetValue(instance, *(decimal *)pByte);
}
}
}
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="data">元数据</param>
/// <param name="offset">元数据所在的偏移量</param>
/// <param name="length">元数据长度</param>
public override void Process(object instance, GetObjectAnalyseResult result, byte[] data, int offset, int length = 0)
{
if (length == 0)
{
return;
}
Color color = new Color(data, offset, length);
result.SetValue(instance, color);
}
/// <summary>
/// ��Ԫ����ת��Ϊ�������ͻ�����
/// </summary>
/// <param name="instance">Ŀ�����</param>
/// <param name="result">�������</param>
/// <param name="container">������������</param>
public override GetObjectResultTypes Process(object instance, GetObjectAnalyseResult result, INetworkDataContainer container)
{
int value;
if(!container.TryReadInt32(out value)) return GetObjectResultTypes.NotEnoughData;
value = value.ToLittleEndian();
string content;
if (!container.TryReadString(Encoding.UTF8, value, out content)) return GetObjectResultTypes.NotEnoughData;
result.SetValue(instance, content);
return GetObjectResultTypes.Succeed;
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="data">元数据</param>
/// <param name="offset">元数据所在的偏移量</param>
/// <param name="length">元数据长度</param>
public override void Process(object instance, GetObjectAnalyseResult result, byte[] data, int offset, int length = 0)
{
if (length == 0 || data == null || data.Length == 0)
{
return;
}
byte[] realData = new byte[length];
Buffer.BlockCopy(data, offset, realData, 0, length);
result.SetValue(instance, new Blob(realData));
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="data">元数据</param>
/// <param name="offset">元数据所在的偏移量</param>
/// <param name="length">元数据长度</param>
public override void Process(object instance, GetObjectAnalyseResult result, byte[] data, int offset, int length = 0)
{
unsafe
{
fixed(byte *pData = &data[offset])
{
result.SetValue(instance, new IPEndPoint(new IPAddress(BitConverter.GetBytes(*(int *)pData)), *(int *)(pData + 4)));
}
}
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="container">网络数据容器</param>
public override GetObjectResultTypes Process(object instance, GetObjectAnalyseResult result, INetworkDataContainer container)
{
byte value;
if (!container.TryReadByte(out value))
{
return(GetObjectResultTypes.NotEnoughData);
}
result.SetValue(instance, value);
return(GetObjectResultTypes.Succeed);
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="container">网络数据容器</param>
public override GetObjectResultTypes Process(object instance, GetObjectAnalyseResult result, INetworkDataContainer container)
{
int value;
if (!container.TryReadInt32(out value))
{
return(GetObjectResultTypes.NotEnoughData);
}
result.SetValue(instance, value.ToLittleEndian());
return(GetObjectResultTypes.Succeed);
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="container">网络数据容器</param>
public override GetObjectResultTypes Process(object instance, GetObjectAnalyseResult result, INetworkDataContainer container)
{
MessageIdentity identity;
if (!container.TryReadMessageIdentity(out identity))
{
return(GetObjectResultTypes.NotEnoughData);
}
result.SetValue(instance, identity);
return(GetObjectResultTypes.Succeed);
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="container">网络数据容器</param>
public override GetObjectResultTypes Process(object instance, GetObjectAnalyseResult result, INetworkDataContainer container)
{
byte keyType, valueType;
int count;
if (!container.TryReadByte(out keyType))
{
return(GetObjectResultTypes.NotEnoughData);
}
if (!container.TryReadByte(out valueType))
{
return(GetObjectResultTypes.NotEnoughData);
}
if (!container.TryReadInt32(out count))
{
return(GetObjectResultTypes.NotEnoughData);
}
count = count.ToLittleEndian();
Dictionary <string, string> value = new Dictionary <string, string>(count);
for (int i = 0; i < count; i++)
{
int stringCount;
if (!container.TryReadInt32(out stringCount))
{
return(GetObjectResultTypes.NotEnoughData);
}
stringCount = stringCount.ToLittleEndian();
string keyContent;
if (!container.TryReadString(Encoding.UTF8, stringCount, out keyContent))
{
return(GetObjectResultTypes.NotEnoughData);
}
if (!container.TryReadInt32(out stringCount))
{
return(GetObjectResultTypes.NotEnoughData);
}
stringCount = stringCount.ToLittleEndian();
string valueContent;
if (!container.TryReadString(Encoding.UTF8, stringCount, out valueContent))
{
return(GetObjectResultTypes.NotEnoughData);
}
value.Add(keyContent, valueContent);
}
result.SetValue(instance, value);
return(GetObjectResultTypes.Succeed);
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="data">元数据</param>
/// <param name="offset">元数据所在的便宜量</param>
/// <param name="length">元数据长度</param>
public override void Process(object instance, GetObjectAnalyseResult result, byte[] data, int offset, int length = 0)
{
if (length == 4)
{
result.SetValue(instance, new bool[0]);
return;
}
unsafe
{
bool[] ret;
fixed(byte *pByte = &data[offset])
{
int arrLength = *(int *)pByte;
ret = new bool[arrLength];
if (arrLength > 10)
{
fixed(bool *bArrry = ret)
{
Buffer.MemoryCopy((void *)new IntPtr(pByte + 4), (void *)new IntPtr((byte *)bArrry), (uint)(Size.Bool * arrLength), (uint)(Size.Bool * arrLength));
//Native.Win32API.memcpy(new IntPtr((byte*)bArrry), new IntPtr(pByte + 4), (uint)(Size.Bool * arrLength));
}
}
else
{
bool *bArray = (bool *)(pByte + 4);
for (int i = 0; i < arrLength; i++)
{
ret[i] = *(bArray++);
}
}
}
result.SetValue(instance, ret);
}
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="container">网络数据容器</param>
public override GetObjectResultTypes Process(object instance, GetObjectAnalyseResult result, INetworkDataContainer container)
{
int value;
if (!container.TryReadInt32(out value))
{
return(GetObjectResultTypes.NotEnoughData);
}
value = value.ToLittleEndian();
string content;
if (!container.TryReadString(Encoding.UTF8, value, out content))
{
return(GetObjectResultTypes.NotEnoughData);
}
result.SetValue(instance, content);
return(GetObjectResultTypes.Succeed);
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="container">网络数据容器</param>
public override GetObjectResultTypes Process(object instance, GetObjectAnalyseResult result, INetworkDataContainer container)
{
byte type;
int count;
if (!container.TryReadByte(out type)) return GetObjectResultTypes.NotEnoughData;
if (!container.TryReadInt32(out count)) return GetObjectResultTypes.NotEnoughData;
count = count.ToLittleEndian();
string[] value = new string[count];
for (int i = 0; i < count; i++)
{
int length;
if (!container.TryReadInt32(out length)) return GetObjectResultTypes.NotEnoughData;
length = length.ToLittleEndian();
string content;
if (!container.TryReadString(Encoding.UTF8, length, out content)) return GetObjectResultTypes.NotEnoughData;
value[i] = content;
}
result.SetValue(instance, value);
return GetObjectResultTypes.Succeed;
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="data">元数据</param>
/// <param name="offset">元数据所在的便宜量</param>
/// <param name="length">元数据长度</param>
public override void Process(object instance, GetObjectAnalyseResult result, byte[] data, int offset, int length = 0)
{
result.SetValue(instance, new BitFlag(data[offset]));
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="data">元数据</param>
/// <param name="offset">元数据所在的偏移量</param>
/// <param name="length">元数据长度</param>
public override void Process(object instance, GetObjectAnalyseResult result, byte[] data, int offset, int length = 0)
{
int innerOffset = offset;
int chunkSize = offset + length;
int arrLen = BitConverter.ToInt32(data, innerOffset);
if (arrLen == 0)
{
result.SetValue(instance, new string[0]);
return;
}
string[] strArr = new string[arrLen];
innerOffset += 4;
int arrIndex = 0;
short size;
do
{
size = BitConverter.ToInt16(data, innerOffset);
innerOffset += 2;
if ((data.Length - innerOffset) < size)
{
throw new System.Exception("Illegal remaining binary data length!");
}
//use unmanagement method by default.
if (size == 0)
{
strArr[arrIndex] = null;
}
else
{
string str;
unsafe
{
fixed(byte *old = &data[innerOffset])
{
int charCount = Encoding.UTF8.GetCharCount(old, size);
//allcate memory at thread stack.
if (charCount <= MemoryAllotter.CharSizeCanAllcateAtStack)
{
char *newObj = stackalloc char[charCount];
int len = Encoding.UTF8.GetChars(old, size, newObj, charCount);
str = new string(newObj, 0, len);
}
//allocate memory at heap.
else
{
fixed(char *newObj = new char[charCount])
{
int len = Encoding.UTF8.GetChars(old, size, newObj, charCount);
str = new string(newObj, 0, len);
}
}
}
}
strArr[arrIndex] = str;
}
innerOffset += size;
arrIndex++;
} while (innerOffset < data.Length && innerOffset < chunkSize);
result.SetValue(instance, strArr);
}
/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="instance">目标对象</param>
/// <param name="result">分析结果</param>
/// <param name="container">网络数据容器</param>
public override GetObjectResultTypes Process(object instance, GetObjectAnalyseResult result, INetworkDataContainer container)
{
byte keyType, valueType;
int count;
if (!container.TryReadByte(out keyType)) return GetObjectResultTypes.NotEnoughData;
if (!container.TryReadByte(out valueType)) return GetObjectResultTypes.NotEnoughData;
if (!container.TryReadInt32(out count)) return GetObjectResultTypes.NotEnoughData;
count = count.ToLittleEndian();
Dictionary<string, Cell> value = new Dictionary<string, Cell>(count);
for (int i = 0; i < count; i++)
{
int stringCount;
if (!container.TryReadInt32(out stringCount)) return GetObjectResultTypes.NotEnoughData;
stringCount = stringCount.ToLittleEndian();
string keyContent;
if (!container.TryReadString(Encoding.UTF8, stringCount, out keyContent)) return GetObjectResultTypes.NotEnoughData;
Cell valueContent;
GetObjectResultTypes type = ThriftObjectEngine.TryGetObject(typeof(Cell), container, out valueContent, true);
if (type != GetObjectResultTypes.Succeed) return type;
value.Add(keyContent, valueContent);
}
result.SetValue(instance, value);
return GetObjectResultTypes.Succeed;
}