/// <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>
/// 注册扩展类型数据valueStored
/// </summary>
/// <param name="valueStored">数据处理器实例</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public static void Regist(BaseValueStored valueStored)
{
if (valueStored == null)
{
throw new ArgumentNullException("valueStored");
}
_valueStoreds[valueStored.TypeId] = valueStored;
}
/// <summary>
/// 设置一个指定key的属性值
/// </summary>
/// <param name="id">设置属性对应的id</param>
/// <param name="baseValueStored">设置属性的value</param>
/// <exception cref="ArgumentNullException">baseValueStored不能为空</exception>
public virtual ResourceBlock SetAttribute(byte id, BaseValueStored baseValueStored)
{
if (baseValueStored == null)
{
throw new ArgumentNullException("baseValueStored");
}
_valueStoreds[id] = baseValueStored;
return(this);
}
/// <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="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");
}
ResourceBlock[] value = baseValueMessage.GetValue <ResourceBlock[]>();
proxy.WriteUInt32((uint)value.Length);
for (int i = 0; i < value.Length; i++)
{
if (value[i] == null)
{
proxy.WriteUInt32(0);
continue;
}
MetadataObjectEngine.ToBytes(value[i], proxy);
}
}
/// <summary>
/// 注册扩展类型数据valueStored
/// </summary>
/// <param name="type">数据处理器类型</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public static void Regist(Type type)
{
BaseValueStored valueStored = (BaseValueStored)type.GetTypeInfo().Assembly.CreateInstance(type.FullName);
if (valueStored == null)
{
throw new ArgumentNullException(nameof(type));
}
if (valueStored.TypeId <= MetadataObjectSetting.TYPE_BOUNDARY)
{
throw new ArgumentException(string.Format("#Extensionable Type id can not be setted in System Type range, boundary type id is {0}", MetadataObjectSetting.TYPE_BOUNDARY));
}
if (valueStored.Clone() == null)
{
throw new NullReferenceException("#There is a null reference object instance when called Clone method.");
}
if (!(valueStored.Clone().GetType().GetTypeInfo().IsSubclassOf(typeof(BaseValueStored))))
{
throw new ArgumentException("#Generated instance of Clone method was not the sub class of BaseValueStored");
}
_valueStoreds[valueStored.TypeId] = valueStored;
}
/// <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");
}
IPEndPoint[] array = baseValueMessage.GetValue <IPEndPoint[]>();
if (array == null)
{
throw new NullReferenceException(string.Format("#The processed value is null, type Id is: {0}", baseValueMessage.TypeId));
}
if (array.Length == 0)
{
return;
}
for (int i = 0; i < array.Length; i++)
{
proxy.WriteIPEndPoint(array[i]);
}
}
/// <summary>
/// 将一个二进制元数据转换为对象字段
/// </summary>
/// <param name="byteData">需要反序列化的二进制数组</param>
/// <param name="offset">内存段偏移</param>
/// <param name="length">内存段长度</param>
public static MetadataContainer GetObject(byte[] byteData, uint offset, uint length)
{
MetadataContainer metadataObject = new MetadataContainer();
#region 解析数据部分
//记录当前解析数据段的绝对偏移起始位置
uint offsetFlag = offset;
//计算当前解析数据段的总长度
uint totalLength = BitConverter.ToUInt32(byteData, (int)offset);
if (byteData.Length - offset < length - 4)
{
throw new System.Exception("Illegal binary data length! #length: " + totalLength);
}
//计算当前解析数据段的markRange个数（即包含元素的个数）
//offset+4表示计算完后偏移4bytes（当前数据段总长所占的4Bytes）
ushort markRangeCount = BitConverter.ToUInt16(byteData, (int)(offset += 4));
//计算当前解析数据段markRange所占总字节数
uint markRangeLength = (uint)(markRangeCount * 5);
//offset+2表示偏移2bytes（当前数据段mark Range个数所占的2Bytes）
offset += 2;
MarkRange markRange1 = new MarkRange(), markRange2 = new MarkRange();
for (int i = 0; i < markRangeCount; i++)
{
uint offsetFlagStart, offsetFlagEnd;
//解析mark Range
//提取当前数据段前一个元素的ID
markRange1.Id = (i == 0) ? byteData[offset + 5 * i] : markRange2.Id;
//提取当前数据段前一个元素的Flag
markRange1.Flag = (i == 0) ? BitConverter.ToUInt32(byteData, (int)(offset + 5 * i + 1)) : markRange2.Flag;
//提取当前数据段后一个元素的ID
markRange2.Id = (i == markRangeCount - 1) ? (byte)0 : byteData[offset + 5 * (i + 1)];
//提取当前数据段后一个元素的Flag
markRange2.Flag = (i == markRangeCount - 1) ? 0 : BitConverter.ToUInt32(byteData, (int)(offset + 5 * (i + 1) + 1));
//计算偏移
//当前解析数据段某一个元素的相对偏移起始位置（相对于当前的mark range）
offsetFlagStart = (markRange1.Flag & 0xFFFFFF00) >> 8;
//当前解析数据段某一个元素的相对偏移结束位置（相对于当前的mark range）
if (i < markRangeCount - 1)
{
offsetFlagEnd = (markRange2.Flag & 0xFFFFFF00) >> 8;
}
else
{
offsetFlagEnd = totalLength - 6 - markRangeLength;
}
//提取当前解析数据段某一个元素的类型值
PropertyTypes idFlag = (PropertyTypes)byteData[offset + 5 * i + 1];
//计算当前解析数据段某一个元素的绝对偏移起始位置(整个完整数据段的偏移)
uint offsetStart = offsetFlagStart + 6 + markRangeLength + offsetFlag;
//计算当前解析数据段某一个元素的长度（所占字节数）
uint offsetLength = offsetFlagEnd - offsetFlagStart;
//开始解析........................................................................
//系统内置类型
if ((byte)idFlag <= MetadataObjectSetting.TYPE_BOUNDARY)
{
BaseValueStored valueStored = (BaseValueStored)SystemTypeMapping.GetValueStored((byte)idFlag).Clone();
valueStored.ToData(metadataObject, markRange1.Id, byteData, (int)offsetStart, offsetLength);
}
//用户自定义类型
else
{
BaseValueStored valueStored = (BaseValueStored)ExtensionTypeMapping.GetValueStored((byte)idFlag).Clone();
valueStored.ToData(metadataObject, markRange1.Id, byteData, (int)offsetStart, offsetLength);
}
}
#endregion
return(metadataObject);
}
