Event.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012-2015 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 _EVENT_HH_
#define _EVENT_HH_

#include <iostream>
#include <vector>
#include <map>

#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread/mutex.hpp>

#include <gazebo/gazebo_config.h>
#include <gazebo/common/Time.hh>
#include <gazebo/common/CommonTypes.hh>
#include <gazebo/math/Helpers.hh>
#include "gazebo/util/system.hh"

namespace gazebo
{
  namespace event
  {

    // Private data members for Event class.
    // This must be in the header due to templatization.
    class GAZEBO_VISIBLE EventPrivate
    {
      // \brief Constructor
      public: EventPrivate();

      public: bool signaled;
    };

    class GAZEBO_VISIBLE Event
    {
      public: Event();

      public: virtual ~Event();

      public: virtual void Disconnect(ConnectionPtr _c) = 0;

      public: virtual void Disconnect(int _id) = 0;

      public: bool GetSignaled() const;

      protected: Event(EventPrivate &_d);

      protected: EventPrivate *dataPtr;
    };

    // Private data members for Connection class.
    class GAZEBO_VISIBLE ConnectionPrivate
    {
      public: ConnectionPrivate();

      public: ConnectionPrivate(Event *_e, int _i);

      public: Event *event;

      public: int id;

      public: common::Time creationTime;
    };

    class GAZEBO_VISIBLE Connection
    {
      public: Connection();

      public: Connection(Event *_e, int _i);

      public: ~Connection();

      public: int GetId() const;

      private: ConnectionPrivate *dataPtr;

      public: template<typename T> friend class EventT;
    };

    // Private data members for EventT<T> class.
    template< typename T>
    class GAZEBO_VISIBLE EventTPrivate : public EventPrivate
    {
      typedef std::map<int, boost::function<T>*> EvtConnectionMap;

      public: EvtConnectionMap connections;

      public: std::vector<int> connectionsToErase;

      public: boost::mutex connectionsEraseMutex;
    };

    template< typename T>
    class GAZEBO_VISIBLE EventT : public Event
    {
      typedef std::map<int, boost::function<T>*> EvtConnectionMap;

      public: EventT();

      public: virtual ~EventT();

      public: ConnectionPtr Connect(const boost::function<T> &_subscriber);

      public: virtual void Disconnect(ConnectionPtr _c);

      public: virtual void Disconnect(int _id);

      public: unsigned int ConnectionCount() const;

      public: void operator()()
              {this->Signal();}

      public: void Signal()
              {
                this->myDataPtr->signaled = true;
                this->Cleanup();
                for (typename EvtConnectionMap::iterator iter =
                    this->myDataPtr->connections.begin();
                    iter != this->myDataPtr->connections.end(); ++iter)
                {
                  (*iter->second)();
                }
              }

      public: template< typename P >
              void operator()(const P &_p)
              { this->Signal(_p); }

      public: template< typename P1, typename P2 >
              void operator()(const P1 &_p1, const P2 &_p2)
              { this->Signal(_p1, _p2); }

      public: template< typename P1, typename P2, typename P3 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3)
              { this->Signal(_p1, _p2, _p3); }

      public: template< typename P1, typename P2, typename P3, typename P4 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4)
              { this->Signal(_p1, _p2, _p3, _p4); }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4, const P5 &_p5)
              { this->Signal(_p1, _p2, _p3, _p4, _p5); }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4, const P5 &_p5, const P6 &_p6)
              { this->Signal(_p1, _p2, _p3, _p4, _p5, _p6); }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6, typename P7 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4, const P5 &_p5, const P6 &_p6,
                              const P7 &_p7)
              { this->Signal(_p1, _p2, _p3, _p4, _p5, _p6, _p7); }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6, typename P7, typename P8 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4, const P5 &_p5, const P6 &_p6,
                              const P7 &_p7, const P8 &_p8)
              { this->Signal(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8); }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6, typename P7, typename P8,
                        typename P9 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4, const P5 &_p5, const P6 &_p6,
                              const P7 &_p7, const P8 &_p8, const P9 &_p9)
              { this->Signal(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9); }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6, typename P7, typename P8,
                        typename P9, typename P10 >
              void operator()(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                              const P4 &_p4, const P5 &_p5, const P6 &_p6,
                              const P7 &_p7, const P8 &_p8, const P9 &_p9,
                              const P10 &_p10)
              {
                this->Signal(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9, _p10);
              }

      public: template< typename P >
              void Signal(const P &_p)
              {
                this->myDataPtr->signaled = true;
                this->Cleanup();
                for (typename EvtConnectionMap::iterator iter =
                    this->myDataPtr->connections.begin();
                    iter != this->myDataPtr->connections.end(); ++iter)
                {
                  (*iter->second)(_p);
                }
              }

      public: template< typename P1, typename P2 >
              void Signal(const P1 &_p1, const P2 &_p2)
              {
                this->myDataPtr->signaled = true;
                this->Cleanup();
                for (typename EvtConnectionMap::iterator iter =
                    this->myDataPtr->connections.begin();
                    iter != this->myDataPtr->connections.end(); ++iter)
                {
                  (*iter->second)(_p1, _p2);
                }
              }

      public: template< typename P1, typename P2, typename P3 >
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3)
              {
                this->myDataPtr->signaled = true;
                this->Cleanup();
                for (typename EvtConnectionMap::iterator iter =
                    this->myDataPtr->connections.begin();
                      iter != this->myDataPtr->connections.end(); ++iter)
                {
                  (*iter->second)(_p1, _p2, _p3);
                }
              }

      public: template<typename P1, typename P2, typename P3, typename P4>
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                          const P4 &_p4)
              {
                this->myDataPtr->signaled = true;
                this->Cleanup();
                for (typename EvtConnectionMap::iterator iter =
                    this->myDataPtr->connections.begin();
                        iter != this->myDataPtr->connections.end(); ++iter)
                {
                  (*iter->second)(_p1, _p2, _p3, _p4);
                }
              }

      public: template<typename P1, typename P2, typename P3, typename P4,
                       typename P5>
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                          const P4 &_p4, const P5 &_p5)
              {
                this->myDataPtr->signaled = true;
                this->Cleanup();
                for (typename EvtConnectionMap::iterator iter =
                    this->myDataPtr->connections.begin();
                          iter != this->myDataPtr->connections.end(); ++iter)
                {
                  (*iter->second)(_p1, _p2, _p3, _p4, _p5);
                }
              }


      public: template<typename P1, typename P2, typename P3, typename P4,
                       typename P5, typename P6>
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                  const P4 &_p4, const P5 &_p5, const P6 &_p6)
              {
                this->myDataPtr->signaled = true;
                this->Cleanup();
                for (typename EvtConnectionMap::iterator iter =
                    this->myDataPtr->connections.begin();
                    iter != this->myDataPtr->connections.end(); ++iter)
                {
                  (*iter->second)(_p1, _p2, _p3, _p4, _p5, _p6);
                }
              }

      public: template<typename P1, typename P2, typename P3, typename P4,
                       typename P5, typename P6, typename P7>
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                  const P4 &_p4, const P5 &_p5, const P6 &_p6, const P7 &_p7)
              {
                this->myDataPtr->signaled = true;
                this->Cleanup();
                for (typename EvtConnectionMap::iterator iter =
                    this->myDataPtr->connections.begin();
                    iter != this->myDataPtr->connections.end(); ++iter)
                {
                  (*iter->second)(_p1, _p2, _p3, _p4, _p5, _p6, _p7);
                }
              }

      public: template<typename P1, typename P2, typename P3, typename P4,
                       typename P5, typename P6, typename P7, typename P8>
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                  const P4 &_p4, const P5 &_p5, const P6 &_p6, const P7 &_p7,
                  const P8 &_p8)
              {
                this->myDataPtr->signaled = true;
                this->Cleanup();
                for (typename EvtConnectionMap::iterator iter =
                    this->myDataPtr->connections.begin();
                    iter != this->myDataPtr->connections.end(); ++iter)
                {
                  (*iter->second)(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8);
                }
              }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6, typename P7, typename P8,
                        typename P9 >
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                  const P4 &_p4, const P5 &_p5, const P6 &_p6, const P7 &_p7,
                  const P8 &_p8, const P9 &_p9)
          {
            this->myDataPtr->signaled = true;
            this->Cleanup();
            for (typename EvtConnectionMap::iterator iter =
                this->myDataPtr->connections.begin();
                iter != this->myDataPtr->connections.end(); ++iter)
            {
              (*iter->second)(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9);
            }
          }

      public: template< typename P1, typename P2, typename P3, typename P4,
                        typename P5, typename P6, typename P7, typename P8,
                        typename P9, typename P10 >
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                  const P4 &_p4, const P5 &_p5, const P6 &_p6, const P7 &_p7,
                  const P8 &_p8, const P9 &_p9, const P10 &_p10)
              {
                this->myDataPtr->signaled = true;
                this->Cleanup();
                for (typename EvtConnectionMap::iterator iter =
                    this->myDataPtr->connections.begin();
                    iter != this->myDataPtr->connections.end(); ++iter)
                {
                  (*iter->second)(_p1, _p2, _p3, _p4, _p5,
                      _p6, _p7, _p8, _p9, _p10);
                }
              }

      private: void Cleanup();

      private: EventTPrivate<T> *myDataPtr;
    };

    template<typename T>
    EventT<T>::EventT()
    : Event(*(new EventTPrivate<T>()))
    {
      this->myDataPtr = static_cast<EventTPrivate<T>*>(this->dataPtr);
    }

    template<typename T>
    EventT<T>::~EventT()
    {
      for (typename EvtConnectionMap::iterator iter =
          this->myDataPtr->connections.begin();
          iter != this->myDataPtr->connections.end(); ++iter)
      {
        delete iter->second;
      }

      this->myDataPtr->connections.clear();
    }

    template<typename T>
    ConnectionPtr EventT<T>::Connect(const boost::function<T> &_subscriber)
    {
      int index = 0;
      if (!this->myDataPtr->connections.empty())
      {
        typename EvtConnectionMap::reverse_iterator iter =
          this->myDataPtr->connections.rbegin();
        index = iter->first + 1;
      }
      this->myDataPtr->connections[index] = new boost::function<T>(_subscriber);
      return ConnectionPtr(new Connection(this, index));
    }

    template<typename T>
    void EventT<T>::Disconnect(ConnectionPtr _c)
    {
      if (!_c)
        return;

      this->Disconnect(_c->GetId());
      _c->dataPtr->event = NULL;
      _c->dataPtr->id = -1;
    }

    template<typename T>
    unsigned int EventT<T>::ConnectionCount() const
    {
      return this->myDataPtr->connections.size();
    }

    template<typename T>
    void EventT<T>::Disconnect(int _id)
    {
      boost::mutex::scoped_lock lock(this->myDataPtr->connectionsEraseMutex);
      this->myDataPtr->connectionsToErase.push_back(_id);
    }

    template<typename T>
    void EventT<T>::Cleanup()
    {
      if (this->myDataPtr->connectionsToErase.empty())
        return;
      boost::mutex::scoped_lock lock(this->myDataPtr->connectionsEraseMutex);

      for (std::vector<int>::iterator iter =
          this->myDataPtr->connectionsToErase.begin();
          iter != this->myDataPtr->connectionsToErase.end(); ++iter)
      {
        typename EvtConnectionMap::iterator iter2 =
          this->myDataPtr->connections.find(*iter);
        if (iter2 != this->myDataPtr->connections.end())
        {
          delete iter2->second;
          this->myDataPtr->connections.erase(iter2);
        }
      }
      this->myDataPtr->connectionsToErase.clear();
    }
  }
}
#endif