CallbackHelper.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012 Open Source Robotics Foundation
 *
 * 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 _CALLBACKHELPER_HH_
#define _CALLBACKHELPER_HH_

#include <google/protobuf/message.h>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>

#include <vector>
#include <string>
#include <mutex>

#include "gazebo/common/Console.hh"
#include "gazebo/msgs/msgs.hh"
#include "gazebo/common/Exception.hh"

#include "gazebo/transport/TransportTypes.hh"
#include "gazebo/util/system.hh"

namespace gazebo
{
  namespace transport
  {

    class GZ_TRANSPORT_VISIBLE CallbackHelper
    {
      public: CallbackHelper(bool _latching = false);

      public: virtual ~CallbackHelper();

      public: virtual std::string GetMsgType() const;

      public: virtual bool HandleData(const std::string &_newdata,
                  boost::function<void(uint32_t)> _cb, uint32_t _id) = 0;

      public: virtual bool HandleMessage(MessagePtr _newMsg) = 0;

      public: virtual bool IsLocal() const = 0;

      public: bool GetLatching() const;

      public: void SetLatching(bool _latch);

      public: unsigned int GetId() const;

      protected: bool latching;

      protected: mutable std::mutex latchingMutex;

      private: static unsigned int idCounter;

      private: unsigned int id;
    };

    typedef boost::shared_ptr<CallbackHelper> CallbackHelperPtr;


    template<class M>
    class CallbackHelperT : public CallbackHelper
    {
      public: CallbackHelperT(const boost::function<
                void (const boost::shared_ptr<M const> &)> &_cb,
                bool _latching = false)
              : CallbackHelper(_latching), callback(_cb)
              {
                // Just some code to make sure we have a google protobuf.
                /*M test;
                google::protobuf::Message *m;
                if ((m =dynamic_cast<google::protobuf::Message*>(&test))
                    == NULL)
                  gzthrow("Message type must be a google::protobuf type\n");
                  */
              }

      // documentation inherited
      public: std::string GetMsgType() const
              {
                M test;
                google::protobuf::Message *m;
                if ((m = dynamic_cast<google::protobuf::Message*>(&test))
                    == NULL)
                  gzthrow("Message type must be a google::protobuf type\n");
                return m->GetTypeName();
              }

      // documentation inherited
      public: virtual bool HandleData(const std::string &_newdata,
                  boost::function<void(uint32_t)> _cb, uint32_t _id)
              {
                this->SetLatching(false);
                boost::shared_ptr<M> m(new M);
                m->ParseFromString(_newdata);
                this->callback(m);
                if (!_cb.empty())
                  _cb(_id);
                return true;
              }

      // documentation inherited
      public: virtual bool HandleMessage(MessagePtr _newMsg)
              {
                this->SetLatching(false);
                this->callback(boost::dynamic_pointer_cast<M>(_newMsg));
                return true;
              }

      // documentation inherited
      public: virtual bool IsLocal() const
              {
                return true;
              }

      private: boost::function<void (const boost::shared_ptr<M const> &)>
               callback;
    };

    class GZ_TRANSPORT_VISIBLE RawCallbackHelper : public CallbackHelper
    {
      public: RawCallbackHelper(
                  const boost::function<void (const std::string &)> &_cb,
                  bool _latching = false)
              : CallbackHelper(_latching), callback(_cb)
              {
              }

      // documentation inherited
      public: std::string GetMsgType() const
              {
                return "raw";
              }

      // documentation inherited
      public: virtual bool HandleData(const std::string &_newdata,
                  boost::function<void(uint32_t)> _cb, uint32_t _id)
              {
                this->SetLatching(false);
                this->callback(_newdata);
                if (!_cb.empty())
                  _cb(_id);
                return true;
              }

      // documentation inherited
      public: virtual bool HandleMessage(MessagePtr _newMsg)
              {
                this->SetLatching(false);
                std::string data;
                _newMsg->SerializeToString(&data);
                this->callback(data);
                return true;
              }


      // documentation inherited
      public: virtual bool IsLocal() const
              {
                return true;
              }

      private: boost::function<void (const std::string &)> callback;
    };
  }
}
#endif