neighbor_comm.h

Go to the documentation of this file.

#ifndef NEIGHBOR_COMM_H_
#define NEIGHBOR_COMM_H_

#include <iostream>

#include "micros_swarm/runtime_handle.h"
#include "micros_swarm/listener_helper.h"
#include "micros_swarm/msg_queue_manager.h"
#include "gsdf_msgs/NeighborBroadcastKeyValue.h"

namespace micros_swarm{
    
    template<class Type>
    class Broadcaster{
        public:
            Broadcaster(const std::string& key)
            {
                key_ = key;
                rth_ = Singleton<RuntimeHandle>::getSingleton();
                mqm_ = Singleton<MsgQueueManager>::getSingleton();
            }

            ~Broadcaster()
            {
                rth_.reset();
                mqm_.reset();
            }
            
            void broadcast(const Type& value)
            {
                std::vector<uint8_t> value_vec = serialize_ros(value);
                gsdf_msgs::NeighborBroadcastKeyValue nbkv;

                nbkv.key = key_;
                nbkv.value = value_vec;
                std::vector<uint8_t> nbkv_vec = serialize_ros(nbkv);
                
                gsdf_msgs::CommPacket p;
                p.header.source = rth_->getRobotID();
                p.header.type = NEIGHBOR_BROADCAST_KEY_VALUE;
                p.header.data_len = nbkv_vec.size();
                p.header.version = 1;
                p.header.checksum = 0;
                p.content.buf = nbkv_vec;
                std::vector<uint8_t> msg_data = serialize_ros(p);
                mqm_->getOutMsgQueue("nc")->push(msg_data);
            }
        private:
            boost::shared_ptr<RuntimeHandle> rth_;
            boost::shared_ptr<micros_swarm::MsgQueueManager> mqm_;
            std::string key_;
    };
    
    template<typename Type>
    class Listener{
        public:        
            Listener(const std::string& key, const boost::function<void(const Type&)>& callback)
            {
                key_ = key;
                rth_ = Singleton<RuntimeHandle>::getSingleton();
                
                helper_.reset(new ListenerHelperT<Type>(key, callback));
                rth_->insertOrUpdateListenerHelper(key_, helper_);
            }

            ~Listener()
            {
                rth_.reset();
                helper_.reset();
            }
            
            void ignore()
            {
                rth_->deleteListenerHelper(key_);
            }
        private:
            std::string key_;
            boost::shared_ptr<RuntimeHandle> rth_;
            boost::shared_ptr<ListenerHelper> helper_;
    };
};
#endif