00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035 #ifndef MESSAGE_FILTERS_SIGNAL1_H
00036 #define MESSAGE_FILTERS_SIGNAL1_H
00037
00038 #include <boost/noncopyable.hpp>
00039
00040 #include "connection.h"
00041 #include <ros/message_event.h>
00042 #include <ros/parameter_adapter.h>
00043
00044 #include <boost/bind.hpp>
00045 #include <boost/thread/mutex.hpp>
00046
00047 namespace message_filters
00048 {
00049 template<class M>
00050 class CallbackHelper1
00051 {
00052 public:
00053 virtual ~CallbackHelper1() {}
00054
00055 virtual void call(const ros::MessageEvent<M const>& event, bool nonconst_need_copy) = 0;
00056
00057 typedef boost::shared_ptr<CallbackHelper1<M> > Ptr;
00058 };
00059
00060 template<typename P, typename M>
00061 class CallbackHelper1T : public CallbackHelper1<M>
00062 {
00063 public:
00064 typedef ros::ParameterAdapter<P> Adapter;
00065 typedef boost::function<void(typename Adapter::Parameter)> Callback;
00066 typedef typename Adapter::Event Event;
00067
00068 CallbackHelper1T(const Callback& cb)
00069 : callback_(cb)
00070 {
00071 }
00072
00073 virtual void call(const ros::MessageEvent<M const>& event, bool nonconst_force_copy)
00074 {
00075 Event my_event(event, nonconst_force_copy || event.nonConstWillCopy());
00076 callback_(Adapter::getParameter(my_event));
00077 }
00078
00079 private:
00080 Callback callback_;
00081 };
00082
00083 template<class M>
00084 class Signal1
00085 {
00086 typedef boost::shared_ptr<CallbackHelper1<M> > CallbackHelper1Ptr;
00087 typedef std::vector<CallbackHelper1Ptr> V_CallbackHelper1;
00088
00089 public:
00090 template<typename P>
00091 CallbackHelper1Ptr addCallback(const boost::function<void(P)>& callback)
00092 {
00093 CallbackHelper1T<P, M>* helper = new CallbackHelper1T<P, M>(callback);
00094
00095 boost::mutex::scoped_lock lock(mutex_);
00096 callbacks_.push_back(CallbackHelper1Ptr(helper));
00097 return callbacks_.back();
00098 }
00099
00100 void removeCallback(const CallbackHelper1Ptr& helper)
00101 {
00102 boost::mutex::scoped_lock lock(mutex_);
00103 typename V_CallbackHelper1::iterator it = std::find(callbacks_.begin(), callbacks_.end(), helper);
00104 if (it != callbacks_.end())
00105 {
00106 callbacks_.erase(it);
00107 }
00108 }
00109
00110 void call(const ros::MessageEvent<M const>& event)
00111 {
00112 boost::mutex::scoped_lock lock(mutex_);
00113 bool nonconst_force_copy = callbacks_.size() > 1;
00114 typename V_CallbackHelper1::iterator it = callbacks_.begin();
00115 typename V_CallbackHelper1::iterator end = callbacks_.end();
00116 for (; it != end; ++it)
00117 {
00118 const CallbackHelper1Ptr& helper = *it;
00119 helper->call(event, nonconst_force_copy);
00120 }
00121 }
00122
00123 private:
00124 boost::mutex mutex_;
00125 V_CallbackHelper1 callbacks_;
00126 };
00127
00128 }
00129
00130 #endif // MESSAGE_FILTERS_SIGNAL1_H
00131
00132