Summary description for G2Protocol.
Ejemplo n.º 1
0
 private void AddPairs(G2Protocol protocol, G2Frame sync, byte name, PairList pairs)
 {
     if (pairs != null && pairs.Count > 0)
     {
         protocol.WritePacket(sync, name, pairs.ToBytes());
     }
 }
Ejemplo n.º 2
0
        public static void Test()
        {
            // create
            var packet = new GenericPacket("name");

            packet.Data = new Dictionary <string, string>()
            {
                { "test1", "val1" },
                { "test2", "val2" }
            };

            // send
            var protocol = new G2Protocol();
            var encoded  = packet.Encode(protocol);

            // recv
            var recvPacket   = new G2Header(encoded);
            int start        = 0;
            int size         = encoded.Length;
            var streamStatus = G2Protocol.ReadNextPacket(recvPacket, ref start, ref size);

            // decode
            var check = GenericPacket.Decode(recvPacket);

            Debug.Assert(check.Data["test1"] == "val1");
            Debug.Assert(check.Data["test2"] == "val2");
        }
Ejemplo n.º 3
0
 private void AddSet(G2Protocol protocol, G2Frame sync, byte name, HashSet <int> set)
 {
     if (set != null && set.Count > 0)
     {
         protocol.WritePacket(sync, name, set.ToBytes());
     }
 }
Ejemplo n.º 4
0
 public override byte[] Encode(G2Protocol protocol)
 {
     lock (protocol.WriteSection)
     {
         protocol.WritePacket(null, PacketType.Padding, Filler);
         return(protocol.WriteFinish());
     }
 }
Ejemplo n.º 5
0
 public override byte[] Encode(G2Protocol protocol)
 {
     lock (protocol.WriteSection)
     {
         protocol.WritePacket(null, PacketType.Padding, Filler);
         return protocol.WriteFinish();
     }
 }
Ejemplo n.º 6
0
        public PacketStream(Stream stream, G2Protocol protocol, FileAccess access)
        {
            ParentStream = stream;
            Protocol     = protocol;
            Access       = access;

            if (access == FileAccess.Read)
            {
                ReadBuffer = new byte[4096]; // break/resume relies on 4kb buffer
            }
        }
Ejemplo n.º 7
0
 private void AddPairMap(G2Protocol protocol, G2Frame sync, byte name, Dictionary <int, PairList> map)
 {
     if (map != null && map.Count > 0)
     {
         foreach (var pairList in map)
         {
             var keyValuePair = protocol.WritePacket(sync, name, null);
             protocol.WritePacket(keyValuePair, ChildPacket_ThreadID, BitConverter.GetBytes(pairList.Key));
             protocol.WritePacket(keyValuePair, ChildPacket_PairList, pairList.Value.ToBytes());
         }
     }
 }
Ejemplo n.º 8
0
        public override byte[] Encode(G2Protocol protocol)
        {
            lock (protocol.WriteSection)
            {
                var dat = protocol.WritePacket(null, PacketType.Dat, null);

                protocol.WritePacket(dat, Packet_Pos, BitConverter.GetBytes(Pos));
                protocol.WritePacket(dat, Packet_Data, Data);

                return(protocol.WriteFinish());
            }
        }
Ejemplo n.º 9
0
        public static IEnumerable <G2Header> EnumerateChildren(G2Header root)
        {
            G2Header child = new G2Header(root.Data);

            while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
            {
                // set payload pos vars
                G2Protocol.ReadPayload(child);

                yield return(child);
            }
        }
Ejemplo n.º 10
0
        public override byte[] Encode(G2Protocol protocol)
        {
            lock (protocol.WriteSection)
            {
                var sync = protocol.WritePacket(null, PacketType.Sync, null);

                AddSet(protocol, sync, Packet_FunctionHit, FunctionHits);
                AddSet(protocol, sync, Packet_ExceptionHit, ExceptionHits);
                AddSet(protocol, sync, Packet_ConstructedHit, ConstructedHits);
                AddSet(protocol, sync, Packet_DisposedHit, DisposeHits);

                AddPairs(protocol, sync, Packet_NewCalls, NewCalls);
                AddSet(protocol, sync, Packet_CallHits, CallHits);

                if (CallStats != null)
                {
                    protocol.WritePacket(sync, Packet_CallStats, CallStats.ToBytes());
                }

                AddPairs(protocol, sync, Packet_Inits, Inits);

                if (NewThreads != null)
                {
                    foreach (var item in NewThreads)
                    {
                        var keyValuePair = protocol.WritePacket(sync, Packet_NewThreads, null);
                        protocol.WritePacket(keyValuePair, ChildPacket_ThreadID, BitConverter.GetBytes(item.Key));
                        protocol.WritePacket(keyValuePair, ChildPacket_ThreadName, UTF8Encoding.UTF8.GetBytes(item.Value.Item1));
                        protocol.WritePacket(keyValuePair, ChildPacket_ThreadAlive, BitConverter.GetBytes(item.Value.Item2));
                    }
                }

                if (ThreadChanges != null)
                {
                    foreach (var item in ThreadChanges)
                    {
                        var keyValuePair = protocol.WritePacket(sync, Packet_ThreadChanges, null);
                        protocol.WritePacket(keyValuePair, ChildPacket_ThreadID, BitConverter.GetBytes(item.Key));
                        protocol.WritePacket(keyValuePair, ChildPacket_ThreadAlive, BitConverter.GetBytes(item.Value));
                    }
                }

                AddPairs(protocol, sync, Packet_NodeThreads, NodeThreads);
                AddPairs(protocol, sync, Packet_CallThreads, CallThreads);

                AddPairMap(protocol, sync, Packet_Threadlines, Threadlines);
                AddPairMap(protocol, sync, Packet_ThreadStacks, ThreadStacks);

                return(protocol.WriteFinish());
            }
        }
Ejemplo n.º 11
0
        public override byte[] Encode(G2Protocol protocol)
        {
            lock (protocol.WriteSection)
            {
                var packet = protocol.WritePacket(null, PacketType.Generic, UTF8Encoding.UTF8.GetBytes(Name));

                if (Data != null)
                {
                    foreach (var item in Data)
                    {
                        var keyValuePair = protocol.WritePacket(packet, Packet_Item, null);
                        protocol.WritePacket(keyValuePair, Packet_Key, UTF8Encoding.UTF8.GetBytes(item.Key));
                        protocol.WritePacket(keyValuePair, Packet_Value, UTF8Encoding.UTF8.GetBytes(item.Value));
                    }
                }

                return(protocol.WriteFinish());
            }
        }
Ejemplo n.º 12
0
        public override byte[] Encode(G2Protocol protocol)
        {
            lock (protocol.WriteSection)
            {
                var instance = protocol.WritePacket(null, PacketType.Instance, null);

                protocol.WritePacket(instance, Packet_Type, BitConverter.GetBytes((int)Type));
                protocol.WritePacket(instance, Packet_ThreadID, BitConverter.GetBytes(ThreadID));
                protocol.WritePacket(instance, Packet_FieldID, BitConverter.GetBytes(FieldID));

                if (Details != null)
                {
                    protocol.WritePacket(instance, Packet_Details, UTF8Encoding.UTF8.GetBytes(Details));
                }

                if (Columns != null)
                {
                    foreach (var column in Columns)
                    {
                        protocol.WritePacket(instance, Packet_Column, UTF8Encoding.UTF8.GetBytes(column));
                    }
                }

                if (Fields != null)
                {
                    foreach (var field in Fields)
                    {
                        var fieldPacket = protocol.WritePacket(instance, Packet_Field, null);

                        protocol.WritePacket(fieldPacket, Packet_SubNodesFlag, BitConverter.GetBytes(field.PossibleSubNodes));
                        protocol.WritePacket(fieldPacket, Packet_FieldID, BitConverter.GetBytes(field.ID));

                        foreach (var cell in field.Cells)
                        {
                            protocol.WritePacket(fieldPacket, Packet_Cell, UTF8Encoding.UTF8.GetBytes(cell));
                        }
                    }
                }

                return(protocol.WriteFinish());
            }
        }
Ejemplo n.º 13
0
        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);
        }
Ejemplo n.º 14
0
        void ReceivePackets()
        {
            int          Start        = 0;
            G2ReadResult streamStatus = G2ReadResult.PACKET_GOOD;

            while (streamStatus == G2ReadResult.PACKET_GOOD)
            {
                G2ReceivedPacket packet = new G2ReceivedPacket();
                packet.Root = new G2Header(FinalRecvBuffer);

                streamStatus = G2Protocol.ReadNextPacket(packet.Root, ref Start, ref FinalRecvBuffSize);

                if (streamStatus != G2ReadResult.PACKET_GOOD)
                {
                    break;
                }

                packet.Tcp = this;

                // extract data from final recv buffer so it can be referenced without being overwritten by this thread
                byte[] extracted = Utilities.ExtractBytes(packet.Root.Data, packet.Root.PacketPos, packet.Root.PacketSize);
                packet.Root = new G2Header(extracted);
                G2Protocol.ReadPacket(packet.Root);

                PacketLogEntry logEntry = new PacketLogEntry(DateTime.Now, DirectionType.In, ToString(), packet.Root.Data);
                LogPacket(logEntry);

                Remote.IncomingPacket(this, packet);
            }

            // re-align buffer
            if (Start > 0 && FinalRecvBuffSize > 0)
            {
                Buffer.BlockCopy(FinalRecvBuffer, Start, FinalRecvBuffer, 0, FinalRecvBuffSize);
                //Network.UpdateConsole(PacketBytesReady.ToString() + " bytes moved to front of receive buffer");
            }
        }
Ejemplo n.º 15
0
        private bool ReadNext(G2Header root)
        {
            if (ReadSize > 0)
            {
                int prevStart = Start;

                ReadStatus = G2Protocol.ReadNextPacket(root, ref Start, ref ReadSize);

                ParentPos += (Start - prevStart);

                if (ReadStatus == G2ReadResult.PACKET_GOOD)
                {
                    return(true);
                }
            }

            // hit the exact end of the buffer read in, signal to read the next buffer in
            else
            {
                ReadStatus = G2ReadResult.PACKET_INCOMPLETE;
            }

            return(false);
        }
Ejemplo n.º 16
0
        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;
        }
Ejemplo n.º 17
0
        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);
        }
Ejemplo n.º 18
0
 private void AddSet(G2Protocol protocol, G2Frame sync, byte name, HashSet<int> set)
 {
     if (set != null && set.Count > 0)
         protocol.WritePacket(sync, name, set.ToBytes());
 }
Ejemplo n.º 19
0
 private void AddPairs(G2Protocol protocol, G2Frame sync, byte name, PairList pairs)
 {
     if (pairs != null && pairs.Count > 0)
         protocol.WritePacket(sync, name, pairs.ToBytes());
 }
Ejemplo n.º 20
0
 private void AddPairMap(G2Protocol protocol, G2Frame sync, byte name, Dictionary<int, PairList> map)
 {
     if (map != null && map.Count > 0)
         foreach (var pairList in map)
         {
             var keyValuePair = protocol.WritePacket(sync, name, null);
             protocol.WritePacket(keyValuePair, ChildPacket_ThreadID, BitConverter.GetBytes(pairList.Key));
             protocol.WritePacket(keyValuePair, ChildPacket_PairList, pairList.Value.ToBytes());
         }
 }
Ejemplo n.º 21
0
        public PacketStream(Stream stream, G2Protocol protocol, FileAccess access)
        {
            ParentStream = stream;
            Protocol = protocol;
            Access = access;

            if(access == FileAccess.Read)
                ReadBuffer = new byte[4096]; // break/resume relies on 4kb buffer
        }
Ejemplo n.º 22
0
        public override byte[] Encode(G2Protocol protocol)
        {
            lock (protocol.WriteSection)
            {
                var sync = protocol.WritePacket(null, PacketType.Sync, null);

                AddSet(protocol, sync, Packet_FunctionHit, FunctionHits);
                AddSet(protocol, sync, Packet_ExceptionHit, ExceptionHits);
                AddSet(protocol, sync, Packet_ConstructedHit, ConstructedHits);
                AddSet(protocol, sync, Packet_DisposedHit, DisposeHits);

                AddPairs(protocol, sync, Packet_NewCalls, NewCalls);
                AddSet(protocol, sync, Packet_CallHits, CallHits);

                if (CallStats != null)
                    protocol.WritePacket(sync, Packet_CallStats, CallStats.ToBytes());

                AddPairs(protocol, sync, Packet_Inits, Inits);

                if (NewThreads != null)
                    foreach (var item in NewThreads)
                    {
                        var keyValuePair = protocol.WritePacket(sync, Packet_NewThreads, null);
                        protocol.WritePacket(keyValuePair, ChildPacket_ThreadID, BitConverter.GetBytes(item.Key));
                        protocol.WritePacket(keyValuePair, ChildPacket_ThreadName, UTF8Encoding.UTF8.GetBytes(item.Value.Item1));
                        protocol.WritePacket(keyValuePair, ChildPacket_ThreadAlive, BitConverter.GetBytes(item.Value.Item2));
                    }

                if (ThreadChanges != null)
                    foreach (var item in ThreadChanges)
                    {
                        var keyValuePair = protocol.WritePacket(sync, Packet_ThreadChanges, null);
                        protocol.WritePacket(keyValuePair, ChildPacket_ThreadID, BitConverter.GetBytes(item.Key));
                        protocol.WritePacket(keyValuePair, ChildPacket_ThreadAlive, BitConverter.GetBytes(item.Value));
                    }

                AddPairs(protocol, sync, Packet_NodeThreads, NodeThreads);
                AddPairs(protocol, sync, Packet_CallThreads, CallThreads);

                AddPairMap(protocol, sync, Packet_Threadlines, Threadlines);
                AddPairMap(protocol, sync, Packet_ThreadStacks, ThreadStacks);

                return protocol.WriteFinish();
            }
        }
Ejemplo n.º 23
0
        public override byte[] Encode(G2Protocol protocol)
        {
            lock (protocol.WriteSection)
            {
                var instance = protocol.WritePacket(null, PacketType.Instance, null);

                protocol.WritePacket(instance, Packet_Type, BitConverter.GetBytes((int)Type));
                protocol.WritePacket(instance, Packet_ThreadID, BitConverter.GetBytes(ThreadID));
                protocol.WritePacket(instance, Packet_FieldID, BitConverter.GetBytes(FieldID));

                if(Details != null)
                    protocol.WritePacket(instance, Packet_Details, UTF8Encoding.UTF8.GetBytes(Details));

                if (Columns != null)
                    foreach(var column in Columns)
                        protocol.WritePacket(instance, Packet_Column, UTF8Encoding.UTF8.GetBytes(column));

                if (Fields != null)
                    foreach (var field in Fields)
                    {
                        var fieldPacket = protocol.WritePacket(instance, Packet_Field, null);

                        protocol.WritePacket(fieldPacket, Packet_SubNodesFlag, BitConverter.GetBytes(field.PossibleSubNodes));
                        protocol.WritePacket(fieldPacket, Packet_FieldID, BitConverter.GetBytes(field.ID));

                        foreach(var cell in field.Cells)
                            protocol.WritePacket(fieldPacket, Packet_Cell, UTF8Encoding.UTF8.GetBytes(cell));
                    }

                return protocol.WriteFinish();
            }
        }
Ejemplo n.º 24
0
        public override byte[] Encode(G2Protocol protocol)
        {
            lock (protocol.WriteSection)
            {
                var packet = protocol.WritePacket(null, PacketType.Generic, UTF8Encoding.UTF8.GetBytes(Name));

                if(Data != null)
                    foreach (var item in Data)
                    {
                        var keyValuePair = protocol.WritePacket(packet, Packet_Item, null);
                        protocol.WritePacket(keyValuePair, Packet_Key, UTF8Encoding.UTF8.GetBytes(item.Key));
                        protocol.WritePacket(keyValuePair, Packet_Value, UTF8Encoding.UTF8.GetBytes(item.Value));
                    }

                return protocol.WriteFinish();
            }
        }
Ejemplo n.º 25
0
        public static void Test()
        {
            // create
            var packet = new GenericPacket("name");
            packet.Data = new Dictionary<string, string>()
            {
                {"test1", "val1"},
                {"test2", "val2"}
            };

            // send
            var protocol = new G2Protocol();
            var encoded = packet.Encode(protocol);

            // recv
            var recvPacket = new G2Header(encoded);
            int start = 0;
            int size = encoded.Length;
            var streamStatus = G2Protocol.ReadNextPacket(recvPacket, ref start, ref size);

            // decode
            var check = GenericPacket.Decode(recvPacket);

            Debug.Assert(check.Data["test1"] == "val1");
            Debug.Assert(check.Data["test2"] == "val2");
        }
Ejemplo n.º 26
0
        public override byte[] Encode(G2Protocol protocol)
        {
            lock (protocol.WriteSection)
            {
                var dat = protocol.WritePacket(null, PacketType.Dat, null);

                protocol.WritePacket(dat, Packet_Pos, BitConverter.GetBytes(Pos));
                protocol.WritePacket(dat, Packet_Data, Data);

                return protocol.WriteFinish();
            }
        }
Ejemplo n.º 27
0
 public virtual byte[] Encode(G2Protocol protocol)
 {
     return(null);
 }
Ejemplo n.º 28
0
        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);
        }
Ejemplo n.º 29
0
        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);
        }
Ejemplo n.º 30
0
 public virtual byte[] Encode(G2Protocol protocol)
 {
     return null;
 }