public override void addCallback(CallbackInterface cb, UInt64 owner_id) { ICallbackInfo info = new ICallbackInfo { Callback = cb, removal_id = owner_id }; lock (mutex) { if (!enabled) { return; } callbacks.Add(info); Count++; } lock (id_info_mutex) { if (!id_info.ContainsKey(owner_id)) { id_info.Add(owner_id, new IDInfo { calling_rw_mutex = new object(), id = owner_id }); } } notify_one(); }
/// <summary> /// Creates a subscriber /// </summary> /// <typeparam name="M">Topic type</typeparam> /// <param name="topic">Topic name</param> /// <param name="queue_size">How many messages to qeueue</param> /// <param name="cb">Function to fire when a message is recieved</param> /// <param name="allow_concurrent_callbacks">Probably breaks things when true</param> /// <returns>A subscriber</returns> public Subscriber <M> subscribe <M>(string topic, uint queue_size, CallbackInterface cb, bool allow_concurrent_callbacks) where M : IRosMessage, new() { if (_callback == null) { _callback = ROS.GlobalCallbackQueue; } SubscribeOptions <M> ops = new SubscribeOptions <M>(topic, queue_size, cb.func) { callback_queue = _callback, allow_concurrent_callbacks = allow_concurrent_callbacks }; ops.callback_queue.addCallback(cb); return(subscribe(ops)); }
/// <summary> /// Creates a subscriber /// </summary> /// <typeparam name="M">Topic type</typeparam> /// <param name="topic">Topic name</param> /// <param name="queue_size">How many messages to qeueue</param> /// <param name="cb">Function to fire when a message is recieved</param> /// <param name="thisisveryverybad">internal use</param> /// <returns>A subscriber</returns> public Subscriber <M> subscribe <M>(string topic, uint queue_size, CallbackInterface cb, string thisisveryverybad) where M : IRosMessage, new() { if (_callback == null) { _callback = ROS.GlobalCallbackQueue; } SubscribeOptions <M> ops = new SubscribeOptions <M>(topic, queue_size, cb.func) { callback_queue = _callback }; ops.callback_queue.addCallback(cb); return(subscribe(ops)); }
public CallOneResult callOneCB(TLS tls) { ICallbackInfo info = tls.head; if (info == null) { return(CallOneResult.Empty); } IDInfo idinfo = null; idinfo = getIDInfo(info.removal_id); if (idinfo != null) { CallbackInterface cb = info.Callback; lock (idinfo.calling_rw_mutex) { CallbackInterface.CallResult result = CallbackInterface.CallResult.Invalid; tls.spliceout(info); if (!info.marked_for_removal) { result = cb.Call(); } if (result == CallbackInterface.CallResult.TryAgain && !info.marked_for_removal) { lock (mutex) { callbacks.Add(info); Count++; } return(CallOneResult.TryAgain); } } return(CallOneResult.Called); } ICallbackInfo cbi = tls.spliceout(info); if (cbi != null) { cbi.Callback.Call(); } return(CallOneResult.Called); }
public virtual void addCallback(CallbackInterface callback, UInt64 owner_id) { throw new NotImplementedException(); }
public virtual void addCallback(CallbackInterface callback) { addCallback(callback, callback.Get()); }
/// <summary> /// Creates a subscriber /// </summary> /// <typeparam name="M">Topic type</typeparam> /// <param name="topic">Topic name</param> /// <param name="queue_size">How many messages to qeueue</param> /// <param name="cb">Function to fire when a message is recieved</param> /// <returns>A subscriber</returns> public Subscriber <M> subscribe <M>(string topic, uint queue_size, CallbackInterface cb) where M : IRosMessage, new() { return(subscribe <M>(topic, queue_size, cb, null)); }
public virtual void addCallback(CallbackInterface callback) { addCallback(callback, ROS.getPID()); }
public virtual CallbackInterface callback(CallbackInterface cb) { _callback = cb; return(_callback); }
protected ISubscriptionCallbackHelper(CallbackInterface Callback) { //EDB.WriteLine("ISubscriptionCallbackHelper: 1 arg constructor"); //throw new NotImplementedException(); _callback = Callback; }
public SubscriptionCallbackHelper(CallbackInterface q) : base(q) { //EDB.WriteLine("SubscriptionCallbackHelper: callbackinterface constructor"); }
public SubscriptionCallbackHelper(CallbackInterface q) : base(q) { }