public static EPacketFieldType GetFieldType(ISerializableField Field)
{
if (Field is BoolBitField)
{
if (Field.val.ToString() == "0")
{
return(EPacketFieldType.False);
}
else
{
return(EPacketFieldType.True);
}
}
foreach (KeyValuePair <EPacketFieldType, ISerializableField> F in FieldsTypes)
{
if (F.Value.GetType() == Field.GetType())
{
return(F.Key);
}
}
Log.Error("PacketProcessor", "Unhandled Field : " + Field);
return(EPacketFieldType.Invalid);
}
public override void Deserialize(ref PacketInStream Data)
{
long DicData = Data.ReadEncoded7Bit();
int KeyType;
int ValueType;
int Count;
PacketInStream.Decode3Parameters(DicData, out KeyType, out ValueType, out Count);
Dictionary <ISerializableField, ISerializableField> Dic = new Dictionary <ISerializableField, ISerializableField>();
Log.Debug("DicBit", "KeyType=" + KeyType + ",ValueType=" + ValueType + ",Count=" + Count);
for (int i = 0; i < Count; ++i)
{
Log.Debug("DicBit", "Deserialise : Index=" + i + ",Type=" + KeyType);
ISerializableField Key = PacketProcessor.ReadField(ref Data, i, KeyType);
ISerializableField Value = PacketProcessor.ReadField(ref Data, i, ValueType);
if (Key != null && Value != null)
{
Dic.Add(Key, Value);
}
}
val = Dic;
}
public static ISerializableField ReadField(ref PacketInStream Stream, int FieldIndex, int FieldType)
{
if (FieldType == (int)EPacketFieldType.Terminator)
{
return(null);
}
if (!Enum.IsDefined(typeof(EPacketFieldType), FieldType))
{
Log.Error("Field", "Not Defined : " + FieldType);
return(null);
}
ISerializableField Field = GetFieldType((EPacketFieldType)FieldType);
if (Field == null)
{
Log.Error("PacketProcessor", "Unhandled Field : Type = " + FieldType);
return(null);
}
Log.Success("ReadField", "Index = " + FieldIndex + ",Type=" + FieldType);
Field.Index = FieldIndex;
Field.PacketType = (EPacketFieldType)FieldType;
Field.Deserialize(ref Stream);
return(Field);
}
public static bool WriteField(ref PacketOutStream Stream, ISerializableField Field)
{
if (Field == null)
{
return(false);
}
return(WriteField(ref Stream, Field, Field.Index, (int)Field.PacketType));
}
public void AddField(int Index, ISerializableField Field)
{
if (!Fields.ContainsKey(Index))
Fields.Add(Index, Field);
else
{
Log.Error("ISerializablePacket", "Duplicate Field Index : " + GetType().Name);
Fields.Remove(Index);
AddField(Index, Field);
}
}
public void AddField(int Index, EPacketFieldType Type, object Value)
{
ISerializableField Field = PacketProcessor.GetFieldType(Type);
if (Field != null)
{
Field.Index = Index;
Field.val = Value;
Field.PacketType = Type;
AddField(Index, Field);
}
}
public static bool WriteField(ref PacketOutStream Stream, EPacketFieldType FieldType, object Value)
{
ISerializableField Field = GetFieldType(FieldType);
Log.Success("WriteField", "Type=" + FieldType + ",Val=" + Value + ",Field=" + Field);
if (Field != null)
{
Field.val = Value;
Field.Serialize(ref Stream);
return(true);
}
return(false);
}
public void AddField(int Index, ISerializableField Field)
{
if (!Fields.ContainsKey(Index))
{
Fields.Add(Index, Field);
}
else
{
Log.Error("ISerializablePacket", "Duplicate Field Index : " + GetType().Name);
Fields.Remove(Index);
AddField(Index, Field);
}
}
public void ConvertToField()
{
FieldInfo[] Fields = GetType().GetFields();
foreach (FieldInfo Info in Fields)
{
ISerializableFieldAttribute[] FieldsAttr = Info.GetCustomAttributes(typeof(ISerializableFieldAttribute), true) as ISerializableFieldAttribute[];
if (FieldsAttr != null && FieldsAttr.Length > 0)
{
ISerializableField Field = Activator.CreateInstance(FieldsAttr[0].GetSerializableType()) as ISerializableField;
Field.Index = FieldsAttr[0].Index;
Field.val = Info.GetValue(this);
Field.PacketType = PacketProcessor.GetFieldType(Field);
AddField(Field.Index, Field);
}
}
}
public static ISerializableField GetFieldType(EPacketFieldType Type)
{
Log.Info("GetFieldType", "Type = " + Type);
ISerializableField Field;
FieldsTypes.TryGetValue(Type, out Field);
if (Field != null)
{
ISerializableField IField = Activator.CreateInstance(Field.GetType()) as ISerializableField;
IField.PacketType = Type;
return(IField);
}
Log.Error("PacketProcessor", "Unhandled Field Type : " + Type);
return(null);
}
public static EPacketFieldType GetFieldType(ISerializableField Field)
{
if (Field is BoolBitField)
{
if (Field.val.ToString() == "0")
return EPacketFieldType.False;
else
return EPacketFieldType.True;
}
foreach (KeyValuePair<EPacketFieldType, ISerializableField> F in FieldsTypes)
if (F.Value.GetType() == Field.GetType() )
return F.Key;
Log.Error("PacketProcessor", "Unhandled Field : " + Field);
return EPacketFieldType.Invalid;
}
public static ISerializablePacket ReadPacket(ref PacketInStream Stream)
{
try
{
ISerializableField Field = ReadField(ref Stream, 0, (int)EPacketFieldType.Packet);
if (Field == null)
{
return(null);
}
return(Field.val as ISerializablePacket);
}
catch (Exception e)
{
Log.Error("ReadPacket", e.ToString());
return(null);
}
}
public static bool WriteField(ref PacketOutStream Stream, ISerializableField Field, int FieldIndex, int FieldType)
{
if (FieldType == (int)EPacketFieldType.Invalid)
{
return(false);
}
PacketOutStream NewStream = new PacketOutStream();
long FieldResult;
PacketOutStream.Encode2Parameters(out FieldResult, FieldType, FieldIndex);
NewStream.WriteEncoded7Bit(FieldResult);
if (Field == null || Field.Serialize(ref NewStream))
{
Stream.Write(NewStream.ToArray());
}
return(true);
}
public override void Deserialize(ref PacketInStream Data)
{
long ListData = Data.ReadEncoded7Bit();
int ListType;
int ListCount;
PacketInStream.Decode2Parameters(ListData, out ListType, out ListCount);
List <ISerializableField> Fields = new List <ISerializableField>();
Log.Success("Packet", "------> List : " + ListType + "(" + ListCount + ")");
for (int i = 0; i < ListCount; ++i)
{
ISerializableField Field = PacketProcessor.GetFieldType((EPacketFieldType)ListType);
if (Field != null)
{
Field.Deserialize(ref Data);
Fields.Add(Field);
}
}
val = Fields;
}
public override void Deserialize(ref PacketInStream Data)
{
long Opcode = Data.ReadEncoded7Bit();
PacketHandlerDefinition Handler = PacketProcessor.GetPacketHandler(Opcode);
ISerializablePacket Packet = Activator.CreateInstance(Handler.GetClass()) as ISerializablePacket;
Packet.Opcode = Opcode;
ISerializableField Field = null;
Log.Debug("Packet", "----------------------> New " + Opcode.ToString("X8"));
while ((Field = PacketProcessor.ReadField(ref Data)) != null)
{
Log.Success("Packet", "------> ++T : " + Field.PacketType);
Packet.AddField(Field.Index, Field);
}
Log.Debug("Packet", "----------------------> End ");
Packet.ApplyToFieldInfo();
val = Packet;
}
public static bool WriteField(ref PacketOutStream Stream, ISerializableField Field, int FieldIndex, int FieldType)
{
if (FieldType == (int)EPacketFieldType.Invalid)
return false;
PacketOutStream NewStream = new PacketOutStream();
long FieldResult;
PacketOutStream.Encode2Parameters(out FieldResult, FieldType, FieldIndex);
NewStream.WriteEncoded7Bit(FieldResult);
if(Field == null || Field.Serialize(ref NewStream))
Stream.Write(NewStream.ToArray());
return true;
}
public override bool Serialize(ref PacketOutStream Data)
{
Log.Success("WriteList", "Serialize : " + val);
if (val is List <ISerializablePacket> )
{
List <ISerializablePacket> Packets = val as List <ISerializablePacket>;
/*if (Packets.Count <= 0)
* return false;*/
long ListData;
PacketOutStream.Encode2Parameters(out ListData, (int)EPacketFieldType.Packet, Packets.Count);
Data.WriteEncoded7Bit(ListData);
foreach (ISerializablePacket Packet in Packets)
{
PacketProcessor.WritePacket(ref Data, Packet, false, true, true);
}
}
else if (val is List <long> )
{
List <long> Values = val as List <long>;
/*if (Values.Count <= 0)
* return false;*/
long ListData;
PacketOutStream.Encode2Parameters(out ListData, (int)EPacketFieldType.Unsigned7BitEncoded, Values.Count);
Data.WriteEncoded7Bit(ListData);
for (int i = 0; i < Values.Count; ++i)
{
PacketProcessor.WriteField(ref Data, EPacketFieldType.Unsigned7BitEncoded, (long)Values[i]);
}
}
else if (val is List <uint> )
{
List <uint> Values = val as List <uint>;
/*if (Values.Count <= 0)
* return false;*/
long ListData;
PacketOutStream.Encode2Parameters(out ListData, (int)EPacketFieldType.Raw4Bytes, Values.Count);
Data.WriteEncoded7Bit(ListData);
for (int i = 0; i < Values.Count; ++i)
{
PacketProcessor.WriteField(ref Data, EPacketFieldType.Raw4Bytes, (uint)Values[i]);
}
}
else if (val is List <float> )
{
List <float> Values = val as List <float>;
/*if (Values.Count <= 0)
* return false;*/
long ListData;
PacketOutStream.Encode2Parameters(out ListData, (int)EPacketFieldType.Raw4Bytes, Values.Count);
Data.WriteEncoded7Bit(ListData);
for (int i = 0; i < Values.Count; ++i)
{
PacketProcessor.WriteField(ref Data, EPacketFieldType.Raw4Bytes, Values[i]);
}
}
else if (val is List <string> )
{
List <string> Strs = val as List <string>;
/*if (Strs.Count <= 0)
* return false;*/
long ListData;
PacketOutStream.Encode2Parameters(out ListData, (int)EPacketFieldType.ByteArray, Strs.Count);
Data.WriteEncoded7Bit(ListData);
for (int i = 0; i < Strs.Count; ++i)
{
PacketProcessor.WriteField(ref Data, EPacketFieldType.ByteArray, (string)Strs[i]);
}
return(true);
}
else if (val is List <ISerializableField> )
{
List <ISerializableField> Strs = val as List <ISerializableField>;
if (Strs.Count <= 0)
{
return(false);
}
ISerializableField Field = Strs[0];
long ListData;
PacketOutStream.Encode2Parameters(out ListData, (int)Field.PacketType, Strs.Count);
Data.WriteEncoded7Bit(ListData);
for (int i = 0; i < Strs.Count; ++i)
{
PacketProcessor.WriteField(ref Data, Strs[i].PacketType, Strs[i].val);
}
return(true);
}
else
{
return(false);
}
return(true);
}
public static bool WriteField(ref PacketOutStream Stream, ISerializableField Field)
{
if (Field == null)
return false;
return WriteField(ref Stream, Field, Field.Index, (int)Field.PacketType);
}
