public baseobj_stub(WrappedServiceStub innerstub) : base(innerstub)
 {
     rr_cb2 = new CallbackClient <Action <double, double> >("cb2");
     rr_p1  = new Pipe <double[]>(innerstub.GetPipe("p1"));
     rr_w1  = new Wire <double[]>(innerstub.GetWire("w1"));
     rr_m1  = new ArrayMemoryClient <double>(innerstub.GetArrayMemory("m1"));
 }
Exemple #2
0
        internal object GetClientStub(WrappedServiceStub innerstub)
        {
            if (innerstub == null)
            {
                return(null);
            }

            lock (this)
            {
                int    id = innerstub.GetObjectHeapID();
                object stub;
                if (id != 0 && client_stubs.TryGetValue(id, out stub))
                {
                    return(stub);
                }
                else
                {
                    ServiceFactory f;

                    f = RobotRaconteurNode.s.GetServiceType(innerstub.RR_objecttype.GetServiceDefinition().Name);

                    stub = f.CreateStub(innerstub);
                    int id2 = innerstub.GetObjectHeapID();
                    if (id2 == 0)
                    {
                        return(null);
                    }
                    client_stubs.Add(id2, stub);
                    return(stub);
                }
            }
        }
        public override ServiceStub CreateStub(WrappedServiceStub innerstub)
        {
            string objecttype = innerstub.RR_objecttype.GetServiceDefinition().Name + "." + innerstub.RR_objecttype.Name;    if (RobotRaconteurNode.SplitQualifiedName(objecttype)[0].TrimEnd(new char[] { '_' }) == "sensors.ati.mini45")

            {
                string objshort = RemovePath(objecttype);
                switch (objshort)
                {
                case "ATImini45Host":
                    return(new ATImini45Host_stub(innerstub));

                case "ATImini45":
                    return(new ATImini45_stub(innerstub));

                default:
                    break;
                }
            }
            else
            {
                string ext_service_type = RobotRaconteurNode.SplitQualifiedName(objecttype)[0].TrimEnd(new char[] { '_' });
                return(RobotRaconteurNode.s.GetServiceType(ext_service_type).CreateStub(innerstub));
            }
            throw new ServiceException("Could not create stub");
        }
        public override void handler(WrappedServiceStub innerstub, HandlerErrorInfo error)
        {
            try
            {
                if (error.error_code != 0)
                {
                    using (MessageEntry merr = new MessageEntry())
                    {
                        this.handler_task.SetException(RobotRaconteurExceptionUtil.ErrorInfoToException(error));
                        return;
                    }
                }

                object s  = null;
                T      s1 = default(T);
                try
                {
                    int id = innerstub.GetObjectHeapID();
                    if (id != 0)
                    {
                        handler_task.SetResult((T)RRObjectHeap.GetObject(id));
                        return;
                    }

                    ServiceFactory f;
                    if (factory == null)
                    {
                        f = RobotRaconteurNode.s.GetServiceType(innerstub.RR_objecttype.GetServiceDefinition().Name);
                    }
                    else
                    {
                        f = factory;
                    }
                    s  = f.CreateStub(innerstub);
                    s1 = (T)s;
                }
                catch (Exception e)
                {
                    handler_task.SetException(e);
                    return;
                }

                handler_task.SetResult(s1);
            }
            catch (Exception e)
            {
                using (MessageEntry merr = new MessageEntry())
                {
                    RobotRaconteurExceptionUtil.ExceptionToMessageEntry(e, merr);
                    RRDirectorExceptionHelper.SetError(merr, e.ToString());
                }
            }
        }
Exemple #5
0
        internal object DeleteClientStub(WrappedServiceStub innerstub)
        {
            if (innerstub == null)
            {
                return(null);
            }

            lock (this)
            {
                int id = innerstub.GetObjectHeapID();

                if (id != 0)
                {
                    object stub;
                    if (client_stubs.TryGetValue(id, out stub))
                    {
                        client_stubs.Remove(id);
                        return(stub);
                    }
                }
                return(null);
            }
        }
Exemple #6
0
            public override void ClientDisconnected(WrappedServiceSubscription subscription,
                                                    WrappedServiceSubscriptionClientID id, WrappedServiceStub client)
            {
                var s = (ServiceSubscription)subscription1.Target;

                if (s == null)
                {
                    return;
                }
                if (s.ClientDisconnected == null)
                {
                    return;
                }

                var client2 = s.DeleteClientStub(client);

                try
                {
                    s.ClientDisconnected(s, new ServiceSubscriptionClientID(id), client2);
                }
                catch
                {}
            }
 public ATImini45_stub(WrappedServiceStub innerstub) : base(innerstub)
 {
     rr_FTDataStream = new Pipe <FTData>(innerstub.GetPipe("FTDataStream"));
 }
 public ATImini45Host_stub(WrappedServiceStub innerstub) : base(innerstub)
 {
 }