public override MessageElement CallFunction(string rr_membername, vectorptr_messageelement rr_m)
{
switch (rr_membername)
{
case "changeCalibration":
{
byte config = (MessageElementUtil.CastDataAndDispose <byte[]>(vectorptr_messageelement_util.FindElement(rr_m, "config")))[0];
this.obj.changeCalibration(config);
return(new MessageElement("return", (int)0));
}
case "bias":
{
this.obj.bias();
return(new MessageElement("return", (int)0));
}
case "startRecordingData":
{
string filename = MessageElementUtil.CastDataAndDispose <string>(vectorptr_messageelement_util.FindElement(rr_m, "filename"));
this.obj.startRecordingData(filename);
return(new MessageElement("return", (int)0));
}
case "stopRecordingData":
{
this.obj.stopRecordingData();
return(new MessageElement("return", (int)0));
}
default:
break;
}
throw new MemberNotFoundException("Member not found");
}
public override void CallSetProperty(string membername, MessageElement m, WrappedServiceSkelAsyncAdapter async_adapter)
{
switch (membername)
{
case "d1":
{
if (async_obj != null)
{
async_adapter.MakeAsync();
async_obj.async_set_d1((MessageElementUtil.UnpackScalar <double>(m))).ContinueWith(t => async_adapter.EndTask(t));
return;
}
obj.d1 = (MessageElementUtil.UnpackScalar <double>(m));
return;
}
case "d2":
{
if (async_obj != null)
{
async_adapter.MakeAsync();
async_obj.async_set_d2(MessageElementUtil.UnpackArray <double>(m)).ContinueWith(t => async_adapter.EndTask(t));
return;
}
obj.d2 = MessageElementUtil.UnpackArray <double>(m);
return;
}
default:
break;
}
throw new MemberNotFoundException("Member not found");
}
public virtual void async_set_recording_data(byte value, Action <Exception> rr_handler, int rr_timeout = RobotRaconteurNode.RR_TIMEOUT_INFINITE)
{
using (MessageElement mm = MessageElementUtil.NewMessageElementDispose("value", new byte[] { value }))
{
rr_async_PropertySet("recording_data", mm, rrend_async_set_recording_data, rr_handler, rr_timeout);
}
}
public override async Task <MessageEntry> CallSetProperty(MessageEntry m)
{
string ename = m.MemberName;
MessageElement me = m.FindElement("value");
MessageEntry mr = new MessageEntry(MessageEntryType.PropertySetRes, ename);
switch (ename)
{
case "d1":
{
await obj.set_d1((MessageElementUtil.UnpackScalar <double>(me)));
break;
}
case "d2":
{
await obj.set_d2(MessageElementUtil.UnpackArray <double>(me));
break;
}
default:
throw new MemberNotFoundException("Member not found");
}
return(mr);
}
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 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 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 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 virtual void async_set_wrench(double[] value, Action <Exception> rr_handler, int rr_timeout = RobotRaconteurNode.RR_TIMEOUT_INFINITE)
{
using (MessageElement mm = MessageElementUtil.NewMessageElementDispose("value", value))
{
rr_async_PropertySet("wrench", mm, rrend_async_set_wrench, rr_handler, rr_timeout);
}
}
public virtual async Task <double[]> async_get_d2(int rr_timeout = RobotRaconteurNode.RR_TIMEOUT_INFINITE)
{
using (var rr_value = await rr_async_PropertyGet("d2", rr_timeout)) {
var rr_ret = MessageElementUtil.UnpackArray <double>(rr_value);
return(rr_ret);
}
}
public virtual void async_changeCalibration(byte config, Action <Exception> rr_handler, int rr_timeout = RobotRaconteurNode.RR_TIMEOUT_INFINITE)
{
using (vectorptr_messageelement rr_param = new vectorptr_messageelement())
{
MessageElementUtil.AddMessageElementDispose(rr_param, MessageElementUtil.NewMessageElementDispose("config", new byte[] { config }));
rr_async_FunctionCall("changeCalibration", rr_param, rrend_async_changeCalibration, rr_handler, rr_timeout);
}
}
public virtual void async_startRecordingData(string filename, Action <Exception> rr_handler, int rr_timeout = RobotRaconteurNode.RR_TIMEOUT_INFINITE)
{
using (vectorptr_messageelement rr_param = new vectorptr_messageelement())
{
MessageElementUtil.AddMessageElementDispose(rr_param, MessageElementUtil.NewMessageElementDispose("filename", filename));
rr_async_FunctionCall("startRecordingData", rr_param, rrend_async_startRecordingData, rr_handler, rr_timeout);
}
}
public async Task <double[]> get_d2(CancellationToken cancel = default(CancellationToken))
{
MessageEntry m = new MessageEntry(MessageEntryType.PropertyGetReq, "d2");
MessageEntry mr = await ProcessRequest(m, cancel);
MessageElement me = mr.FindElement("value");
return(MessageElementUtil.UnpackArray <double>(me));
}
public virtual MessageElementPodArray PackPodToArray(ref T s2)
{
var mm = new List <MessageElement>();
MessageElementUtil.AddMessageElement(mm,
MessageElementUtil.NewMessageElement(0, PackPod(ref s2))
);
return(new MessageElementPodArray(TypeName, mm));
}
public async Task <double> add_val(double v, CancellationToken cancel = default(CancellationToken))
{
MessageEntry rr_m = new MessageEntry(MessageEntryType.FunctionCallReq, "add_val");
MessageElementUtil.AddMessageElement(rr_m, MessageElementUtil.PackScalar <double>("v", v));
MessageEntry rr_me = await ProcessRequest(rr_m, cancel);
return(MessageElementUtil.UnpackScalar <double>(rr_me.FindElement("return")));
}
public virtual MessageElementNamedArray PackNamedArrayStructToArray(ref T s2)
{
var mm = new List <MessageElement>();
MessageElementUtil.AddMessageElement(mm,
MessageElementUtil.NewMessageElement("array", GetNumericArrayFromNamedArrayStruct(ref s2))
);
return(new MessageElementNamedArray(TypeName, mm));
}
public async Task <double> func3(double d1, double d2, CancellationToken cancel = default(CancellationToken))
{
MessageEntry rr_m = new MessageEntry(MessageEntryType.FunctionCallReq, "func3");
MessageElementUtil.AddMessageElement(rr_m, MessageElementUtil.PackScalar <double>("d1", d1));
MessageElementUtil.AddMessageElement(rr_m, MessageElementUtil.PackScalar <double>("d2", d2));
MessageEntry rr_me = await ProcessRequest(rr_m, cancel);
return(MessageElementUtil.UnpackScalar <double>(rr_me.FindElement("return")));
}
public void changeCalibration(byte config)
{
using (vectorptr_messageelement rr_param = new vectorptr_messageelement())
{
MessageElementUtil.AddMessageElementDispose(rr_param, MessageElementUtil.NewMessageElementDispose("config", new byte[] { config }));
using (MessageElement rr_me = rr_innerstub.FunctionCall("changeCalibration", rr_param))
{
}
}
}
public void startRecordingData(string filename)
{
using (vectorptr_messageelement rr_param = new vectorptr_messageelement())
{
MessageElementUtil.AddMessageElementDispose(rr_param, MessageElementUtil.NewMessageElementDispose("filename", filename));
using (MessageElement rr_me = rr_innerstub.FunctionCall("startRecordingData", rr_param))
{
}
}
}
public double add_val(double v)
{
using (vectorptr_messageelement rr_param = new vectorptr_messageelement())
{
MessageElementUtil.AddMessageElementDispose(rr_param, MessageElementUtil.PackScalar <double>("v", v));
using (MessageElement rr_me = rr_innerstub.FunctionCall("add_val", rr_param))
{
return(MessageElementUtil.UnpackScalar <double>(rr_me));
}
}
}
public virtual async Task <double> async_add_val(double v, int rr_timeout = RobotRaconteurNode.RR_TIMEOUT_INFINITE)
{
using (vectorptr_messageelement rr_param = new vectorptr_messageelement())
{
MessageElementUtil.AddMessageElementDispose(rr_param, MessageElementUtil.PackScalar <double>("v", v));
using (var rr_return = await rr_async_FunctionCall("add_val", rr_param, rr_timeout)) {
var rr_ret = (MessageElementUtil.UnpackScalar <double>(rr_return));
return(rr_ret);
}
}
}
public double func3(double d1, double d2)
{
using (vectorptr_messageelement rr_param = new vectorptr_messageelement())
{
MessageElementUtil.AddMessageElementDispose(rr_param, MessageElementUtil.PackScalar <double>("d1", d1));
MessageElementUtil.AddMessageElementDispose(rr_param, MessageElementUtil.PackScalar <double>("d2", d2));
using (MessageElement rr_me = rr_innerstub.FunctionCall("func3", rr_param))
{
return(MessageElementUtil.UnpackScalar <double>(rr_me));
}
}
}
public virtual MessageElementNamedMultiDimArray PackNamedMultiDimArray(NamedMultiDimArray s3)
{
if (s3 == null)
{
return(null);
}
var l = new List <MessageElement>();
MessageElementUtil.AddMessageElement(l, "dims", s3.Dims);
MessageElementUtil.AddMessageElement(l, "array", PackNamedArray((T[])s3.namedarray_array));
return(new MessageElementNamedMultiDimArray(TypeName, l));
}
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 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 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));
}
public object UnpackNamedArray(object m)
{
string typename;
if (CompareNamespace(MessageElementUtil.GetMessageElementDataTypeString(m), out typename))
{
return(FindNamedArrayStub(typename).UnpackNamedArray(m));
}
else
{
return(node.UnpackNamedArray(m, context));
}
}
public virtual MessageElementNamedArray PackNamedArray(T[] s2)
{
if (s2 == null)
{
return(null);
}
var mm = new List <MessageElement>();
MessageElementUtil.AddMessageElement(mm,
MessageElementUtil.NewMessageElement("array", GetNumericArrayFromNamedArray(s2))
);
return(new MessageElementNamedArray(TypeName, mm));
}
public MessageElementStructure PackStructure(object s1)
{
using (vectorptr_messageelement m = new vectorptr_messageelement())
{
if (s1 == null)
{
return(null);
}
FTData s = (FTData)s1;
MessageElementUtil.AddMessageElementDispose(m, MessageElementUtil.NewMessageElementDispose("time", new long[] { s.time }));
MessageElementUtil.AddMessageElementDispose(m, MessageElementUtil.NewMessageElementDispose("ft_data", s.ft_data));
return(new MessageElementStructure("sensors.ati.mini45.FTData", m));
}
}
public virtual MessageElementPodMultiDimArray PackPodMultiDimArray(PodMultiDimArray s3)
{
if (s3 == null)
{
return(null);
}
var l = new List <MessageElement>();
MessageElementUtil.AddMessageElement(l, "dims", s3.Dims);
var s4 = PackPodArray((T[])s3.pod_array);
MessageElementUtil.AddMessageElement(l, "array", s4);
return(new MessageElementPodMultiDimArray(TypeName, l));
}
