|
public static EnumerateChildren ( |
||
| root | ||
| return | IEnumerable |
|
public static DatPacket Decode(G2Header root)
{
var dat = new DatPacket();
foreach (var child in G2Protocol.EnumerateChildren(root))
{
switch (child.Name)
{
case Packet_Pos:
dat.Pos = BitConverter.ToInt64(child.Data, child.PayloadPos);
break;
case Packet_Data:
dat.Data = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
}
}
return(dat);
}
public static GenericPacket Decode(G2Header root)
{
var generic = new GenericPacket();
if (G2Protocol.ReadPayload(root))
{
generic.Name = UTF8Encoding.UTF8.GetString(root.Data, root.PayloadPos, root.PayloadSize);
}
foreach (var child in G2Protocol.EnumerateChildren(root))
{
if (generic.Data == null)
{
generic.Data = new Dictionary <string, string>();
}
string key = null;
string value = null;
foreach (var sub in G2Protocol.EnumerateChildren(child))
{
if (sub.Name == Packet_Key)
{
key = UTF8Encoding.UTF8.GetString(sub.Data, sub.PayloadPos, sub.PayloadSize);
}
else if (sub.Name == Packet_Value)
{
value = UTF8Encoding.UTF8.GetString(sub.Data, sub.PayloadPos, sub.PayloadSize);
}
}
generic.Data[key] = value;
}
return(generic);
}
private static void ReadPairListMap(ref Dictionary <int, PairList> map, SyncPacket sync, G2Header child)
{
if (map == null)
{
map = new Dictionary <int, PairList>();
}
int id = 0;
PairList list = new PairList();
foreach (var sub in G2Protocol.EnumerateChildren(child))
{
if (sub.Name == ChildPacket_ThreadID)
{
id = BitConverter.ToInt32(sub.Data, sub.PayloadPos);
}
else if (sub.Name == ChildPacket_PairList)
{
list = PairList.FromBytes(sub.Data, sub.PayloadPos, sub.PayloadSize);
}
}
map[id] = list;
}
public static InstancePacket Decode(G2Header root)
{
var instance = new InstancePacket();
instance.Fields = new List <IFieldModel>(); // needs to be initd
foreach (var child in G2Protocol.EnumerateChildren(root))
{
switch (child.Name)
{
case Packet_Type:
instance.Type = (InstancePacketType)BitConverter.ToInt32(child.Data, child.PayloadPos);
break;
case Packet_ThreadID:
instance.ThreadID = BitConverter.ToInt32(child.Data, child.PayloadPos);
break;
case Packet_FieldID:
instance.FieldID = BitConverter.ToInt32(child.Data, child.PayloadPos);
break;
case Packet_Details:
instance.Details = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Column:
if (instance.Columns == null)
{
instance.Columns = new List <string>();
}
instance.Columns.Add(UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize));
break;
case Packet_Field:
if (instance.Fields == null)
{
instance.Fields = new List <IFieldModel>();
}
var field = new RemoteFieldModel();
foreach (var sub in G2Protocol.EnumerateChildren(child))
{
switch (sub.Name)
{
case Packet_SubNodesFlag:
field.PossibleSubNodes = BitConverter.ToBoolean(sub.Data, sub.PayloadPos);
break;
case Packet_FieldID:
field.ID = BitConverter.ToInt32(sub.Data, sub.PayloadPos);
break;
case Packet_Cell:
if (field.Cells == null)
{
field.Cells = new List <string>();
}
field.Cells.Add(UTF8Encoding.UTF8.GetString(sub.Data, sub.PayloadPos, sub.PayloadSize));
break;
}
}
instance.Fields.Add(field);
break;
}
}
return(instance);
}
public static SyncPacket Decode(G2Header root)
{
var sync = new SyncPacket();
foreach (var child in G2Protocol.EnumerateChildren(root))
{
switch (child.Name)
{
case Packet_FunctionHit:
sync.FunctionHits = PacketExts.HashSetFromBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_ExceptionHit:
sync.ExceptionHits = PacketExts.HashSetFromBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_ConstructedHit:
sync.ConstructedHits = PacketExts.HashSetFromBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_DisposedHit:
sync.DisposeHits = PacketExts.HashSetFromBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_NewCalls:
sync.NewCalls = PairList.FromBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_CallHits:
sync.CallHits = PacketExts.HashSetFromBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_CallStats:
sync.CallStats = PacketExts.StatsFromBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Inits:
sync.Inits = PairList.FromBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_NewThreads:
if (sync.NewThreads == null)
{
sync.NewThreads = new Dictionary <int, Tuple <string, bool> >();
}
int id = 0;
string name = null;
bool alive = false;
foreach (var sub in G2Protocol.EnumerateChildren(child))
{
if (sub.Name == ChildPacket_ThreadID)
{
id = BitConverter.ToInt32(sub.Data, sub.PayloadPos);
}
else if (sub.Name == ChildPacket_ThreadName)
{
name = UTF8Encoding.UTF8.GetString(sub.Data, sub.PayloadPos, sub.PayloadSize);
}
else if (sub.Name == ChildPacket_ThreadAlive)
{
alive = BitConverter.ToBoolean(sub.Data, sub.PayloadPos);
}
}
sync.NewThreads[id] = new Tuple <string, bool>(name, alive);
break;
case Packet_ThreadChanges:
if (sync.ThreadChanges == null)
{
sync.ThreadChanges = new Dictionary <int, bool>();
}
int id2 = 0;
bool alive2 = false;
foreach (var sub in G2Protocol.EnumerateChildren(child))
{
if (sub.Name == ChildPacket_ThreadID)
{
id2 = BitConverter.ToInt32(sub.Data, sub.PayloadPos);
}
else if (sub.Name == ChildPacket_ThreadAlive)
{
alive2 = BitConverter.ToBoolean(sub.Data, sub.PayloadPos);
}
}
sync.ThreadChanges[id2] = alive2;
break;
case Packet_NodeThreads:
sync.NodeThreads = PairList.FromBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_CallThreads:
sync.CallThreads = PairList.FromBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Threadlines:
ReadPairListMap(ref sync.Threadlines, sync, child);
break;
case Packet_ThreadStacks:
ReadPairListMap(ref sync.ThreadStacks, sync, child);
break;
}
}
return(sync);
}
