Event.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 GAZEBO_COMMON_EVENT_HH_
#define GAZEBO_COMMON_EVENT_HH_
 
#include <atomic>
#include <functional>
#include <list>
#include <map>
#include <memory>
#include <mutex>
 
#include "gazebo/gazebo_config.h"
#include "gazebo/common/Time.hh"
#include "gazebo/common/CommonTypes.hh"
#include "gazebo/util/system.hh"
 
#include "ignition/common/Profiler.hh"
 
namespace gazebo
{
  namespace event
  {
 
    class GZ_COMMON_VISIBLE Event
    {
      public: Event();
 
      public: virtual ~Event();
 
      public: virtual void Disconnect(int _id) = 0;
 
      public: bool Signaled() const;
 
      public: void SetSignaled(const bool _sig);
 
      private: bool signaled;
    };
 
    class GZ_COMMON_VISIBLE Connection
    {
      public: Connection(Event *_e, const int _i);
 
      public: ~Connection();
 
      public: int Id() const;
 
      private: Event *event = nullptr;
 
      private: int id = -1;
 
      private: common::Time creationTime;
 
      public: template<typename T> friend class EventT;
    };
 
    template<typename T>
    class EventT : public Event
    {
      public: EventT();
 
      public: virtual ~EventT();
 
      public: ConnectionPtr Connect(const std::function<T> &_subscriber);
 
      public: virtual void Disconnect(int _id);
 
      public: unsigned int ConnectionCount() const;
 
      public: void operator()()
              {this->Signal();}
 
      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: void Signal()
      {
        IGN_PROFILE("Event::Signal");
 
        this->Cleanup();
 
        this->SetSignaled(true);
        for (const auto &iter: this->connections)
        {
          if ((iter.second != NULL) && iter.second->on)
          {
            IGN_PROFILE_BEGIN("callback0");
            iter.second->callback();
            IGN_PROFILE_END();
          }
        }
      }
 
      public: template< typename P >
              void Signal(const P &_p)
      {
        IGN_PROFILE("Event::Signal");
 
        this->Cleanup();
 
        this->SetSignaled(true);
        for (const auto &iter: this->connections)
        {
          if ((iter.second != NULL) && iter.second->on)
          {
            IGN_PROFILE_BEGIN("callback1");
            iter.second->callback(_p);
            IGN_PROFILE_END();
          }
        }
      }
 
      public: template< typename P1, typename P2 >
              void Signal(const P1 &_p1, const P2 &_p2)
      {
        IGN_PROFILE("Event::Signal");
 
        this->Cleanup();
 
        this->SetSignaled(true);
        for (const auto &iter: this->connections)
        {
          if ((iter.second != NULL) && iter.second->on)
          {
            IGN_PROFILE_BEGIN("callback2");
            iter.second->callback(_p1, _p2);
            IGN_PROFILE_END();
          }
        }
      }
 
      public: template< typename P1, typename P2, typename P3 >
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3)
      {
        IGN_PROFILE("Event::Signal");
 
        this->Cleanup();
 
        this->SetSignaled(true);
        for (const auto &iter: this->connections)
        {
          if ((iter.second != NULL) && iter.second->on)
          {
            IGN_PROFILE_BEGIN("callback3");
            iter.second->callback(_p1, _p2, _p3);
            IGN_PROFILE_END();
          }
        }
      }
 
      public: template<typename P1, typename P2, typename P3, typename P4>
              void Signal(const P1 &_p1, const P2 &_p2, const P3 &_p3,
                          const P4 &_p4)
      {
        IGN_PROFILE("Event::Signal");
 
        this->Cleanup();
 
        this->SetSignaled(true);
        for (const auto &iter: this->connections)
        {
          if ((iter.second != NULL) && iter.second->on)
          {
            IGN_PROFILE_BEGIN("callback4");
            iter.second->callback(_p1, _p2, _p3, _p4);
            IGN_PROFILE_END();
          }
        }
      }
 
      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)
      {
        IGN_PROFILE("Event::Signal");
 
        this->Cleanup();
 
        this->SetSignaled(true);
        for (const auto &iter: this->connections)
        {
          if ((iter.second != NULL) && iter.second->on)
          {
            IGN_PROFILE_BEGIN("callback5");
            iter.second->callback(_p1, _p2, _p3, _p4, _p5);
            IGN_PROFILE_END();
          }
        }
      }
 
      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)
      {
        IGN_PROFILE("Event::Signal");
 
        this->Cleanup();
 
        this->SetSignaled(true);
        for (const auto &iter: this->connections)
        {
          if ((iter.second != NULL) && iter.second->on)
          {
            IGN_PROFILE_BEGIN("callback6");
            iter.second->callback(_p1, _p2, _p3, _p4, _p5, _p6);
            IGN_PROFILE_END();
          }
        }
      }
 
      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)
      {
        IGN_PROFILE("Event::Signal");
 
        this->Cleanup();
 
        this->SetSignaled(true);
        for (const auto &iter: this->connections)
        {
          if ((iter.second != NULL) && iter.second->on)
          {
            IGN_PROFILE_BEGIN("callback7");
            iter.second->callback(_p1, _p2, _p3, _p4, _p5, _p6, _p7);
            IGN_PROFILE_END();
          }
        }
      }
 
      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)
      {
        IGN_PROFILE("Event::Signal");
 
        this->Cleanup();
 
        this->SetSignaled(true);
        for (const auto &iter: this->connections)
        {
          if ((iter.second != NULL) && iter.second->on)
          {
            IGN_PROFILE_BEGIN("callback8");
            iter.second->callback(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8);
            IGN_PROFILE_END();
          }
        }
      }
 
      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)
      {
        IGN_PROFILE("Event::Signal");
 
        this->Cleanup();
 
        this->SetSignaled(true);
        for (const auto &iter: this->connections)
        {
          if ((iter.second != NULL) && iter.second->on)
          {
            IGN_PROFILE_BEGIN("callback9");
            iter.second->callback(
                _p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9);
            IGN_PROFILE_END();
          }
        }
      }
 
      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)
      {
        IGN_PROFILE("Event::Signal");
 
        this->Cleanup();
 
        this->SetSignaled(true);
        for (const auto &iter: this->connections)
        {
          if ((iter.second != NULL) && iter.second->on)
          {
            IGN_PROFILE_BEGIN("callback10");
            iter.second->callback(
                _p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9, _p10);
            IGN_PROFILE_END();
          }
        }
      }
 
      private: void Cleanup();
 
      private: class EventConnection
      {
        public: EventConnection(const bool _on, const std::function<T> &_cb)
                : callback(_cb)
        {
          // Windows Visual Studio 2012 does not have atomic_bool constructor,
          // so we have to set "on" using operator=
          this->on = _on;
        }
 
        public: std::atomic_bool on;
 
        public: std::function<T> callback;
      };
 
      typedef std::map<int, std::unique_ptr<EventConnection>> EvtConnectionMap;
 
      private: EvtConnectionMap connections;
 
      private: mutable std::mutex mutex;
 
      private: std::list<typename EvtConnectionMap::const_iterator>
              connectionsToRemove;
    };
 
    template<typename T>
    EventT<T>::EventT()
    : Event()
    {
    }
 
    template<typename T>
    EventT<T>::~EventT()
    {
      std::lock_guard<std::mutex> lock(this->mutex);
      this->connections.clear();
    }
 
    template<typename T>
    ConnectionPtr EventT<T>::Connect(const std::function<T> &_subscriber)
    {
      std::lock_guard<std::mutex> lock(this->mutex);
      int index = 0;
      if (!this->connections.empty())
      {
        auto const &iter = this->connections.rbegin();
        index = iter->first + 1;
      }
      this->connections[index].reset(new EventConnection(true, _subscriber));
      return ConnectionPtr(new Connection(this, index));
    }
 
    template<typename T>
    unsigned int EventT<T>::ConnectionCount() const
    {
      std::lock_guard<std::mutex> lock(this->mutex);
      return this->connections.size();
    }
 
    template<typename T>
    void EventT<T>::Disconnect(int _id)
    {
      std::lock_guard<std::mutex> lock(this->mutex);
      // Find the connection
      auto const &it = this->connections.find(_id);
 
      if (it != this->connections.end())
      {
        it->second->on = false;
        this->connectionsToRemove.push_back(it);
      }
    }
 
    template<typename T>
    void EventT<T>::Cleanup()
    {
      std::lock_guard<std::mutex> lock(this->mutex);
      // Remove all queue connections.
      for (auto &conn : this->connectionsToRemove)
        this->connections.erase(conn);
      this->connectionsToRemove.clear();
    }
  }
}
#endif