Node.hh

Go to the documentation of this file.

/*
 * Copyright 2012 Nate Koenig
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/

#ifndef _NODE_HH_
#define _NODE_HH_

#include <boost/enable_shared_from_this.hpp>
#include <map>
#include <list>
#include <string>
#include <vector>

#include "transport/TransportTypes.hh"
#include "transport/TopicManager.hh"

namespace gazebo
{
  namespace transport
  {

    class Node : public boost::enable_shared_from_this<Node>
    {
      public: Node();

      public: virtual ~Node();

      public: void Init(const std::string &_space ="");

      public: void Fini();

      public: std::string GetTopicNamespace() const;

      public: std::string DecodeTopicName(const std::string &_topic);

      public: std::string EncodeTopicName(const std::string &_topic);

      public: unsigned int GetId() const;

      public: void ProcessPublishers();

      public: void ProcessIncoming();

      template<typename M>
      transport::PublisherPtr Advertise(const std::string &_topic,
                                        unsigned int _queueLimit = 1000,
                                        bool _latch = false)
      {
        std::string decodedTopic = this->DecodeTopicName(_topic);
        PublisherPtr publisher =
          transport::TopicManager::Instance()->Advertise<M>(
              decodedTopic, _queueLimit, _latch);

        boost::recursive_mutex::scoped_lock lock(this->publisherMutex);
        this->publishers.push_back(publisher);
        this->publishersEnd = this->publishers.end();

        return publisher;
      }

      template<typename M, typename T>
      SubscriberPtr Subscribe(const std::string &_topic,
          void(T::*_fp)(const boost::shared_ptr<M const> &), T *_obj,
          bool _latching = false)
      {
        SubscribeOptions ops;
        std::string decodedTopic = this->DecodeTopicName(_topic);
        ops.template Init<M>(decodedTopic, shared_from_this(), _latching);

        boost::recursive_mutex::scoped_lock lock(this->incomingMutex);
        this->callbacks[decodedTopic].push_back(CallbackHelperPtr(
              new CallbackHelperT<M>(boost::bind(_fp, _obj, _1))));

        return transport::TopicManager::Instance()->Subscribe(ops);
      }

      template<typename M>
      SubscriberPtr Subscribe(const std::string &_topic,
          void(*_fp)(const boost::shared_ptr<M const> &),
                     bool _latching = false)
      {
        SubscribeOptions ops;
        std::string decodedTopic = this->DecodeTopicName(_topic);
        ops.template Init<M>(decodedTopic, shared_from_this(), _latching);

        boost::recursive_mutex::scoped_lock lock(this->incomingMutex);
        this->callbacks[decodedTopic].push_back(
            CallbackHelperPtr(new CallbackHelperT<M>(_fp)));

        return transport::TopicManager::Instance()->Subscribe(ops);
      }

      public: bool HandleData(const std::string &_topic,
                              const std::string &_msg);

      public: void InsertLatchedMsg(const std::string &_topic,
                                    const std::string &_msg);


      public: std::string GetMsgType(const std::string &_topic) const;

      private: std::string topicNamespace;
      private: std::vector<PublisherPtr> publishers;
      private: std::vector<PublisherPtr>::iterator publishersIter;
      private: std::vector<PublisherPtr>::iterator publishersEnd;
      private: static unsigned int idCounter;
      private: unsigned int id;

      private: typedef std::list<CallbackHelperPtr> Callback_L;
      private: typedef std::map<std::string, Callback_L> Callback_M;
      private: Callback_M callbacks;
      private: std::map<std::string, std::list<std::string> > incomingMsgs;
      private: boost::recursive_mutex publisherMutex;
      private: boost::recursive_mutex incomingMutex;

      private: bool initialized;
    };
  }
}
#endif