/// <summary>
/// Unpack and override target from packet
/// </summary>
/// <typeparam name="T">unpackable type</typeparam>
/// <param name="target">unpackable target</param>
public static void Unpack <T>(ref T target, GSFPacket packet)
{
Type type = typeof(T);
PacketUtility packer = GetUtil(type);
packer.unpack(ref target, packet);
}
/// <summary>
/// Unpack and override target from packet
/// </summary>
/// <typeparam name="T">unpackable type</typeparam>
public static T Unpack <T>(GSFPacket packet)
{
Type type = typeof(T);
PacketUtility packer = GetUtil(type);
return(packer.unpack <T>(packet));
}
/// <summary>
/// Unpack packet and override values of target
/// </summary>
/// <param name="target">overrided target</param>
public override void unpack(ref object target, GSFPacket packet)
{
Dictionary <byte, object> dict = (Dictionary <byte, object>)packet.data;
for (int i = 0; i < memberUtils.Length; i++)
{
object value;
if (dict.TryGetValue(memberUtils[i].memberID, out value))
{
// unpack value and set unpacked value to member
memberUtils[i].Set(target, memberUtils[i].unpack((GSFPacket)value));
}
}
}
public override void unpack(ref object target, GSFPacket packet)
{
Type type = target.GetType();
Dictionary <byte, object> values = (Dictionary <byte, object>)((object[])packet.data)[1];
List <MemberUtility> memUtils = initMemberUtils(type);
object value;
for (int i = 0; i < memUtils.Count; i++)
{
if (values.TryGetValue(memUtils[i].memberID, out value))
{
memUtils[i].Set(target, memUtils[i].unpack((GSFPacket)value));
}
}
}
public override GSFPacket pack(object obj)
{
Type type = obj.GetType();
Type elementType = type.GetElementType();
TypeInfo typeInfo = PackType(type);
PacketUtility util = GetUtil(elementType);
int length = (int)type.GetProperty("Length").GetValue(obj);
MethodInfo getMethod = type.GetMethod("Get");
GSFPacket[] values = new GSFPacket[length];
for (int i = 0; i < length; i++)
{
values[i] = util.pack(getMethod.Invoke(obj, new object[] { i }));
}
return(new GSFPacket(classID, new object[] { typeInfo, values }));
}
public override object unpack(GSFPacket packet)
{
object[] data = (object[])packet.data;
Type type = UnpackType((TypeInfo)data[0]);
GSFPacket[] values = (GSFPacket[])data[1];
// get utility of element type
PacketUtility util = GetUtil(type.GetElementType());
object array = Activator.CreateInstance(type, new object[] { values.Length });
MethodInfo setMethod = type.GetMethod("Set");
for (int i = 0; i < values.Length; i++)
{
setMethod.Invoke(array, new object[] { i, util.unpack(values[i]) });
}
return(array);
}
public override T unpack <T>(GSFPacket packet)
{
object[] data = (object[])packet.data;
Type type = typeof(T);
T instance = Activator.CreateInstance <T>();
Dictionary <byte, object> values = (Dictionary <byte, object>)((object[])packet.data)[1];
List <MemberUtility> memUtils = initMemberUtils(type);
object value;
for (int i = 0; i < memUtils.Count; i++)
{
if (values.TryGetValue(memUtils[i].memberID, out value))
{
memUtils[i].Set(instance, memUtils[i].unpack((GSFPacket)value));
}
}
return(instance);
}
public override object unpack(GSFPacket packet, Type type)
{
object[] data = (object[])packet.data;
Type keyType = type.GetGenericArguments()[0];
Type valType = type.GetGenericArguments()[1];
PacketUtility keyUtil = GetUtil(keyType);
PacketUtility valUtil = GetUtil(valType);
object dict = Activator.CreateInstance(type);
object[] values = (object[])data[1];
MethodInfo addMethod = type.GetMethod("Add");
for (int i = 0; i < values.Length; i += 2)
{
addMethod.Invoke(dict, new object[] { keyUtil.unpack((GSFPacket)values[i]), valUtil.unpack((GSFPacket)values[i + 1]) });
}
return(dict);
}
public override void unpack(ref object target, GSFPacket packet)
{
object[] data = (object[])packet.data;
Type dictType = target.GetType();
Type keyType = dictType.GetGenericArguments()[0];
Type valType = dictType.GetGenericArguments()[1];
PacketUtility keyUtil = GetUtil(keyType);
PacketUtility valUtil = GetUtil(valType);
object[] values = (object[])data[1];
MethodInfo clearMethod = dictType.GetMethod("Clear");
clearMethod.Invoke(target, new object[0]);
MethodInfo addMethod = dictType.GetMethod("Add");
for (int i = 0; i < values.Length; i += 2)
{
addMethod.Invoke(target, new object[] { keyUtil.unpack((GSFPacket)values[i], keyType), valUtil.unpack((GSFPacket)values[i + 1], valType) });
}
}
/// <summary>
/// Unpack packet
/// </summary>
public override object unpack(GSFPacket packet)
{
if (packet.classID != classID)
{
throw new InvalidOperationException("Cannot unpack packet by different class id.");
}
object instance = Activator.CreateInstance(classType);
Dictionary <byte, object> dict = (Dictionary <byte, object>)packet.data;
for (int i = 0; i < memberUtils.Length; i++)
{
object value;
if (dict.TryGetValue(memberUtils[i].memberID, out value))
{
// unpack value and set unpacked value to member
memberUtils[i].Set(instance, memberUtils[i].unpack((GSFPacket)value));
}
}
return(instance);
}
public override ulong Unpack(GSFPacket packet)
{
return((ulong)packet.data);
}
public override byte Unpack(GSFPacket packet)
{
return((byte)packet.data);
}
public override short Unpack(GSFPacket packet)
{
return((short)packet.data);
}
public abstract void unpack(ref object target, GSFPacket packet);
public virtual T unpack <T>(GSFPacket packet)
{
return((T)unpack(packet));
}
public override int Unpack(GSFPacket packet)
{
return((int)packet.data);
}
public override string Unpack(GSFPacket packet)
{
return((string)packet.data);
}
public override double Unpack(GSFPacket packet)
{
return((double)packet.data);
}
public override float Unpack(GSFPacket packet)
{
return((float)packet.data);
}
public abstract object unpack(GSFPacket packet);
public override object unpack(GSFPacket packet)
{
return(proxy.unpack(packet));
}
public virtual object unpack(GSFPacket packet, Type type)
{
PacketUtility util = GetUtil(type);
return(util.unpack(packet));
}
public override void unpack(ref object target, GSFPacket packet)
{
proxy.unpack(ref target, packet);
}
public virtual void unpack <T>(ref T target, GSFPacket packet)
{
object temp = target;
unpack(ref temp, packet);
}
public override bool Unpack(GSFPacket packet)
{
return((bool)packet.data);
}
public override char Unpack(GSFPacket packet)
{
return((char)packet.data);
}
public override object Unpack(GSFPacket packet)
{
PacketUtility util = GetUtil(packet.classID);
return(util.unpack(packet));
}
