public T UnpackStructure <T>(MessageElementStructure m)
        {
            if (m == null)
            {
                return(default(T));
            }
            ostruct2 s = new ostruct2();

            s.a1 = MessageElementUtil.UnpackArray <double>(MessageElement.FindElement(m.Elements, "a1"));
            T st; try { st = (T)((object)s); } catch (InvalidCastException) { throw new DataTypeMismatchException("Wrong structuretype"); }

            return(st);
        }
        public T UnpackStructure <T>(MessageElementNestedElementList m)
        {
            if (m == null)
            {
                return(default(T));
            }
            ostruct2 s = new ostruct2();

            using (vectorptr_messageelement mm = m.Elements)
            {
                s.a1 = MessageElementUtil.UnpackArray <double>(MessageElement.FindElement(mm, "a1"));
                T st; try { st = (T)((object)s); } catch (InvalidCastException) { throw new DataTypeMismatchException("Wrong structuretype"); }
                return(st);
            }
        }
        public T UnpackStructure <T>(MessageElementStructure m)
        {
            if (m == null)
            {
                return(default(T));
            }
            NodeInfo s = new NodeInfo();

            s.NodeName = MessageElement.FindElement(m.Elements, "NodeName").CastData <string>();
            s.NodeID   = MessageElement.FindElement(m.Elements, "NodeID").CastData <byte[]>();
            s.ServiceIndexConnectionURL = (Dictionary <int, string>)def.UnpackMapType <int, string>(MessageElement.FindElement(m.Elements, "ServiceIndexConnectionURL").Data);
            T st; try { st = (T)((object)s); } catch (InvalidCastException e) { throw new DataTypeMismatchException("Wrong structuretype"); }

            return(st);
        }
        public T UnpackStructure <T>(MessageElementStructure m)
        {
            if (m == null)
            {
                return(default(T));
            }
            FTData s = new FTData();

            using (vectorptr_messageelement mm = m.Elements)
            {
                s.time    = (MessageElementUtil.CastDataAndDispose <long[]>(MessageElement.FindElement(mm, "time")))[0];
                s.ft_data = MessageElementUtil.CastDataAndDispose <double[]>(MessageElement.FindElement(mm, "ft_data"));
                T st; try { st = (T)((object)s); } catch (InvalidCastException) { throw new DataTypeMismatchException("Wrong structuretype"); }
                return(st);
            }
        }
        public T UnpackStructure <T>(MessageElementStructure m)
        {
            if (m == null)
            {
                return(default(T));
            }
            ServiceInfo s = new ServiceInfo();

            s.Name                 = MessageElement.FindElement(m.Elements, "Name").CastData <string>();
            s.RootObjectType       = MessageElement.FindElement(m.Elements, "RootObjectType").CastData <string>();
            s.RootObjectImplements = (Dictionary <int, string>)def.UnpackMapType <int, string>(MessageElement.FindElement(m.Elements, "RootObjectImplements").Data);
            s.ConnectionURL        = (Dictionary <int, string>)def.UnpackMapType <int, string>(MessageElement.FindElement(m.Elements, "ConnectionURL").Data);
            s.Attributes           = (Dictionary <string, object>)def.UnpackMapType <string, object>(MessageElement.FindElement(m.Elements, "Attributes").Data);
            T st; try { st = (T)((object)s); } catch (InvalidCastException e) { throw new DataTypeMismatchException("Wrong structuretype"); }

            return(st);
        }
        protected T UnpackPacket(List <MessageElement> me, out TimeSpec timespec)
        {
            MessageElementStructure s = (MessageElement.FindElement(me, "packettime").CastData <MessageElementStructure>());
            long seconds     = MessageElement.FindElement(s.Elements, "seconds").CastData <long[]>()[0];
            int  nanoseconds = MessageElement.FindElement(s.Elements, "nanoseconds").CastData <int[]>()[0];

            timespec = new TimeSpec(seconds, nanoseconds);
            object data;

            if (!rawelements)
            {
                data = UnpackAnyType(MessageElement.FindElement(me, "packet"));
            }
            else
            {
                data = MessageElement.FindElement(me, "packet");
            }

            return((T)data);
        }
Beispiel #7
0
        protected bool DispatchPacket(MessageElement me, PipeEndpoint e, out uint packetnumber)
        {
            int index = Int32.Parse(me.ElementName);
            List <MessageElement> elems = ((MessageElementMap <string>)me.Data).Elements;

            packetnumber = (MessageElement.FindElement(elems, "packetnumber").CastData <uint[]>())[0];
            object data;

            if (!rawelements)
            {
                data = UnpackAnyType(MessageElement.FindElement(elems, "packet"));
            }
            else
            {
                data = MessageElement.FindElement(elems, "packet");
            }
            e.PipePacketReceived((T)data, packetnumber);

            bool requestack = (elems.Any(x => x.ElementName == "requestack"));

            return(requestack);
        }