/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
public override void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
byte[] value = analyseResult.GetValue <byte[]>(target);
if (value == null)
{
if (!attribute.IsRequire)
{
return;
}
throw new PropertyNullValueException(string.Format(ExceptionMessage.EX_PROPERTY_VALUE, attribute.Id, analyseResult.Property.Name, analyseResult.Property.PropertyType));
}
//id(1) + total length(4) + rank(4)
proxy.WriteByte((byte)attribute.Id);
MemoryPosition position = proxy.GetPosition();
proxy.Skip(4U);
proxy.WriteInt32(value.Length);
if (value.Length == 0)
{
proxy.WriteBackInt32(position, 4);
return;
}
unsafe
{
fixed(byte *pByte = value) proxy.WriteMemory(pByte, (uint)value.Length * Size.Byte);
}
proxy.WriteBackInt32(position, (int)(value.Length * Size.Byte + 4));
}
/// <summary>
/// 第三方数据转换成元数据
/// </summary>
/// <param name="proxy">内存段实例</param>
/// <param name="baseValueMessage">存储属性的实例对象</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public void ValueProcessor(IMemorySegmentProxy proxy, BaseValueStored baseValueMessage)
{
if (proxy == null)
{
throw new ArgumentNullException("proxy");
}
if (baseValueMessage == null)
{
throw new ArgumentNullException("baseValueMessage");
}
string[] value = baseValueMessage.GetValue <string[]>();
proxy.WriteInt32(value.Length);
if (value.Length == 0)
{
return;
}
for (int j = 0; j < value.Length; j++)
{
string elementValue = value[j];
if (string.IsNullOrEmpty(elementValue))
{
proxy.WriteUInt16(0);
}
else
{
byte[] elementData = Encoding.UTF8.GetBytes(elementValue);
proxy.WriteUInt16((ushort)elementData.Length);
proxy.WriteMemory(elementData, 0U, (uint)elementData.Length);
}
}
}
/// <summary>
/// �ӵ������ͻ�����ת��ΪԪ����
/// </summary>
/// <param name="proxy">�ڴ�Ƭ�δ�����</param>
/// <param name="attribute">�ֶ�����</param>
/// <param name="analyseResult">�������</param>
/// <param name="target">Ŀ�����ʵ��</param>
/// <param name="isArrayElement">��ǰд���ֵ�Ƿ�Ϊ����Ԫ�ر�ʾ</param>
public override void Process(IMemorySegmentProxy proxy, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
MessageIdentity value = analyseResult.GetValue<MessageIdentity>(target);
byte[] data = Encoding.UTF8.GetBytes(value.Command);
proxy.WriteInt32(value.Version.ToBigEndian());
proxy.WriteInt32(((int)value.CommandLength).ToBigEndian());
proxy.WriteMemory(data, 0, (uint)data.Length);
proxy.WriteInt32(((int)value.SequenceId).ToBigEndian());
}
/// <summary>
/// �ӵ������ͻ�����ת��ΪԪ����
/// </summary>
/// <param name="proxy">�ڴ�Ƭ�δ�����</param>
/// <param name="attribute">�ֶ�����</param>
/// <param name="analyseResult">�������</param>
/// <param name="target">Ŀ�����ʵ��</param>
/// <param name="isArrayElement">��ǰд���ֵ�Ƿ�Ϊ����Ԫ�ر�ʾ</param>
public override void Process(IMemorySegmentProxy proxy, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
string value = analyseResult.GetValue<string>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(((short)attribute.Id).ToBigEndian());
byte[] data = Encoding.UTF8.GetBytes(value);
proxy.WriteInt32(data.Length.ToBigEndian());
proxy.WriteMemory(data, 0, (uint) data.Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
public override void Process(IMemorySegmentProxy proxy, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
MessageIdentity value = analyseResult.GetValue <MessageIdentity>(target);
byte[] data = Encoding.UTF8.GetBytes(value.Command);
proxy.WriteInt32(value.Version.ToBigEndian());
proxy.WriteInt32(((int)value.CommandLength).ToBigEndian());
proxy.WriteMemory(data, 0, (uint)data.Length);
proxy.WriteInt32(((int)value.SequenceId).ToBigEndian());
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>
/// * 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)
/// </para>
/// </summary>
/// <param name="proxy">内存片段代理器</param><param name="target">目标对象实例</param><param name="isArrayElement">当前写入的值是否为数组元素标示</param><param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
Color value = (Color)target;
if (value == null)
{
return;
}
proxy.WriteMemory(value.Data, 0U, (uint)value.Data.Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
public override void Process(IMemorySegmentProxy proxy, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
byte[] value = analyseResult.GetValue<byte[]>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(attribute.Id.ToBigEndian());
//proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteInt32(value.Length.ToBigEndian());
proxy.WriteMemory(value, 0, (uint) value.Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
public override void Process(IMemorySegmentProxy proxy, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
byte[] value = analyseResult.GetValue <byte[]>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(attribute.Id.ToBigEndian());
//proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteInt32(value.Length.ToBigEndian());
proxy.WriteMemory(value, 0, (uint)value.Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
public override void Process(IMemorySegmentProxy proxy, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
string value = analyseResult.GetValue <string>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(((short)attribute.Id).ToBigEndian());
byte[] data = Encoding.UTF8.GetBytes(value);
proxy.WriteInt32(data.Length.ToBigEndian());
proxy.WriteMemory(data, 0, (uint)data.Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
Dictionary<string, Cell> value = analyseResult.GetValue<Dictionary<string, Cell>>(target);
if (value == null) return;
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(attribute.Id.ToBigEndian());
proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteByte((byte)PropertyTypes.Struct);
proxy.WriteInt32((value.Count).ToBigEndian());
foreach (KeyValuePair<string, Cell> pair in value)
{
byte[] data = Encoding.UTF8.GetBytes(pair.Key);
proxy.WriteInt32(data.Length.ToBigEndian());
proxy.WriteMemory(data, 0, (uint)data.Length);
pair.Value.Bind();
data = pair.Value.Body;
proxy.WriteMemory(data, 0, (uint)data.Length);
}
}
/// <summary>
/// 第三方数据转换成元数据
/// </summary>
/// <param name="proxy">内存段实例</param>
/// <param name="baseValueMessage">存储属性的实例对象</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public unsafe void ValueProcessor(IMemorySegmentProxy proxy, BaseValueStored baseValueMessage)
{
if (proxy == null)
{
throw new ArgumentNullException("proxy");
}
if (baseValueMessage == null)
throw new ArgumentNullException("baseValueMessage");
fixed(IntPtr *pByte = baseValueMessage.GetValue <IntPtr[]>())
proxy.WriteMemory(pByte, (uint)baseValueMessage.GetValue <IntPtr[]>().Length *Size.IntPtr);
}
/// <summary>
/// 第三方数据转换成元数据
/// </summary>
/// <param name="proxy">内存段实例</param>
/// <param name="baseValueMessage">存储属性的实例对象</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public void ValueProcessor(IMemorySegmentProxy proxy, BaseValueStored baseValueMessage)
{
if (proxy == null)
{
throw new ArgumentNullException("proxy");
}
if (baseValueMessage == null)
{
throw new ArgumentNullException("baseValueMessage");
}
proxy.WriteMemory(baseValueMessage.GetValue <byte[]>(), 0, (uint)baseValueMessage.GetValue <byte[]>().Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
Dictionary <string, string> value = analyseResult.GetValue <Dictionary <string, string> >(target);
if (value == null)
{
return;
}
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(attribute.Id.ToBigEndian());
proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteInt32((value.Count).ToBigEndian());
foreach (KeyValuePair <string, string> pair in value)
{
byte[] data = Encoding.UTF8.GetBytes(pair.Key);
proxy.WriteInt32(data.Length.ToBigEndian());
proxy.WriteMemory(data, 0, (uint)data.Length);
data = Encoding.UTF8.GetBytes(pair.Value);
proxy.WriteInt32(data.Length.ToBigEndian());
proxy.WriteMemory(data, 0, (uint)data.Length);
}
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
public override void Process(IMemorySegmentProxy proxy, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
string[] value = analyseResult.GetValue <string[]>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(attribute.Id.ToBigEndian());
proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteInt32(value.Length.ToBigEndian());
foreach (string data in value)
{
byte[] bytes = Encoding.UTF8.GetBytes(data);
proxy.WriteInt32(bytes.Length.ToBigEndian());
proxy.WriteMemory(bytes, 0, (uint)data.Length);
}
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
Blob value = (Blob)target;
if (value == null)
{
return;
}
byte[] data = value.Compress();
if (data == null)
{
return;
}
proxy.WriteMemory(data, 0U, (uint)data.Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
public override void Process(IMemorySegmentProxy proxy, ThriftPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
string[] value = analyseResult.GetValue<string[]>(target);
proxy.WriteSByte((sbyte)attribute.PropertyType);
proxy.WriteInt16(attribute.Id.ToBigEndian());
proxy.WriteByte((byte)PropertyTypes.String);
proxy.WriteInt32(value.Length.ToBigEndian());
foreach (string data in value)
{
byte[] bytes = Encoding.UTF8.GetBytes(data);
proxy.WriteInt32(bytes.Length.ToBigEndian());
proxy.WriteMemory(bytes, 0, (uint)data.Length);
}
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public unsafe override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
short[] array = (short[])target;
if (array == null || array.Length == 0)
{
return;
}
if (array.Length > 10)
fixed(short *pByte = array) proxy.WriteMemory(pByte, (uint)array.Length * Size.Int16);
else
{
for (int i = 0; i < array.Length; i++)
{
proxy.WriteInt16(array[i]);
}
}
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
Color value = analyseResult.GetValue <Color>(target);
if (value == null || value.Data == null)
{
if (attribute.IsRequire)
{
if (attribute.IsRequire)
{
throw new Exception(string.Format("#Currently property data is required! Id: {0}", attribute.Id));
}
}
return;
}
proxy.WriteByte((byte)attribute.Id);
proxy.WriteMemory(value.Data, 0U, (uint)value.Data.Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
Blob value = analyseResult.GetValue <Blob>(target);
if (value == null)
{
if (!attribute.IsRequire)
{
return;
}
throw new PropertyNullValueException(string.Format(ExceptionMessage.EX_PROPERTY_VALUE, attribute.Id, analyseResult.Property.Name, analyseResult.Property.PropertyType));
}
byte[] data = value.Compress();
if (data == null)
{
throw new UnexpectedValueException(string.Format(ExceptionMessage.EX_UNEXPRECTED_VALUE, attribute.Id, analyseResult.Property.Name));
}
proxy.WriteByte((byte)attribute.Id);
proxy.WriteInt32(data.Length);
proxy.WriteMemory(data, 0U, (uint)data.Length);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
public override void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
string[] value = analyseResult.GetValue <string[]>(target);
if (value == null)
{
if (!attribute.IsRequire)
{
return;
}
throw new PropertyNullValueException(string.Format(ExceptionMessage.EX_PROPERTY_VALUE, attribute.Id, analyseResult.Property.Name, analyseResult.Property.PropertyType));
}
//id(1) + total length(4) + rank(4)
proxy.WriteByte((byte)attribute.Id);
MemoryPosition position = proxy.GetPosition();
proxy.Skip(4U);
proxy.WriteInt32(value.Length);
if (value.Length == 0)
{
proxy.WriteBackInt32(position, 4);
return;
}
for (int i = 0; i < value.Length; i++)
{
string elementValue = value[i];
if (string.IsNullOrEmpty(elementValue))
{
proxy.WriteUInt16(0);
}
else
{
byte[] elementData = Encoding.UTF8.GetBytes(elementValue);
proxy.WriteUInt16((ushort)elementData.Length);
proxy.WriteMemory(elementData, 0U, (uint)elementData.Length);
}
}
MemoryPosition endPosition = proxy.GetPosition();
proxy.WriteBackInt32(position, MemoryPosition.CalcLength(proxy.SegmentCount, position, endPosition) - 4);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
string[] array = (string[])target;
if (array == null || array.Length == 0)
{
return;
}
proxy.WriteUInt32((uint)array.Length);
for (int i = 0; i < array.Length; i++)
{
string elementValue = array[i];
if (string.IsNullOrEmpty(elementValue))
{
proxy.WriteUInt16(0);
}
else
{
byte[] elementData = Encoding.UTF8.GetBytes(elementValue);
proxy.WriteUInt16((ushort)elementData.Length);
proxy.WriteMemory(elementData, 0U, (uint)elementData.Length);
}
}
}
