public override MessageElement CallGetProperty(string membername, WrappedServiceSkelAsyncAdapter async_adapter)
        {
            switch (membername)
            {
            case "d1":
            {
                if (async_obj != null)
                {
                    async_adapter.MakeAsync();
                    async_obj.async_get_d1().ContinueWith(t => async_adapter.EndTask <double>(t, async_ret => MessageElementUtil.PackScalar <double>("return", async_ret)));
                    return(null);
                }
                double ret = obj.d1;
                return(MessageElementUtil.PackScalar <double>("return", ret));
            }

            case "d2":
            {
                if (async_obj != null)
                {
                    async_adapter.MakeAsync();
                    async_obj.async_get_d2().ContinueWith(t => async_adapter.EndTask <double[]>(t, async_ret => MessageElementUtil.PackArray <double>("return", async_ret)));
                    return(null);
                }
                double[] ret = obj.d2;
                return(MessageElementUtil.PackArray <double>("return", ret));
            }

            default:
                break;
            }
            throw new MemberNotFoundException("Member not found");
        }
 public virtual async Task async_set_d2(double[] value, int rr_timeout = RobotRaconteurNode.RR_TIMEOUT_INFINITE)
 {
     using (MessageElement mm = MessageElementUtil.PackArray <double>("value", value))
     {
         await rr_async_PropertySet("d2", mm, rr_timeout);
     }
 }
        public override async Task <MessageEntry> CallGetProperty(MessageEntry m)
        {
            string       ename = m.MemberName;
            MessageEntry mr    = new MessageEntry(MessageEntryType.PropertyGetRes, ename);

            switch (ename)
            {
            case "d1":
            {
                double ret = await obj.get_d1();

                mr.AddElement(MessageElementUtil.PackScalar <double>("value", ret));
                break;
            }

            case "d2":
            {
                double[] ret = await obj.get_d2();

                mr.AddElement(MessageElementUtil.PackArray <double>("value", ret));
                break;
            }

            default:
                throw new MemberNotFoundException("Member not found");
            }
            return(mr);
        }
        public async Task set_d2(double[] value, CancellationToken cancel = default(CancellationToken))
        {
            MessageEntry m = new MessageEntry(MessageEntryType.PropertySetReq, "d2");

            MessageElementUtil.AddMessageElement(m, MessageElementUtil.PackArray <double>("value", value));
            MessageEntry mr = await ProcessRequest(m, cancel);
        }
 public MessageElementNestedElementList PackStructure(object s1)
 {
     using (vectorptr_messageelement m = new vectorptr_messageelement())
     {
         if (s1 == null)
         {
             return(null);
         }
         ostruct2 s = (ostruct2)s1;
         MessageElementUtil.AddMessageElementDispose(m, MessageElementUtil.PackArray <double>("a1", s.a1));
         return(new MessageElementNestedElementList(DataTypes.structure_t, "com.robotraconteur.testing.TestService2.ostruct2", m));
     }
 }
        public MessageElementStructure PackStructure(object s1)
        {
            List <MessageElement> m = new List <MessageElement>();

            if (s1 == null)
            {
                return(null);
            }
            ostruct2 s = (ostruct2)s1;

            MessageElementUtil.AddMessageElement(m, MessageElementUtil.PackArray <double>("a1", s.a1));
            return(new MessageElementStructure("com.robotraconteur.testing.TestService2.ostruct2", m));
        }