Event.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2016 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 GZ_COMMON_EVENT_HH_
#define GZ_COMMON_EVENT_HH_
 
#include <atomic>
#include <chrono>
#include <functional>
#include <list>
#include <map>
#include <memory>
#include <mutex>
#include <utility>
 
#include <gz/common/config.hh>
#include <gz/common/events/Export.hh>
#include <gz/common/events/Types.hh>
 
namespace gz
{
  namespace common
  {
    class GZ_COMMON_EVENTS_VISIBLE Event
    {
      public: Event();
 
      public: virtual ~Event();
 
      public: virtual void Disconnect(int _id) = 0;
 
      public: bool Signaled() const;
 
      public: void SetSignaled(bool _sig);
 
      private: bool signaled;
    };
 
    class GZ_COMMON_EVENTS_VISIBLE Connection
    {
      public: Connection(Event *_e, int _i);
 
      public: ~Connection();
 
      public: int Id() const;
 
      private: Event *event = nullptr;
 
      private: int id = -1;
 
#ifdef _WIN32
// Disable warning C4251
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
      private: std::chrono::time_point<std::chrono::system_clock> creationTime;
#ifdef _WIN32
#pragma warning(pop)
#endif
 
      public: template<typename T, typename N> friend class EventT;
    };
 
    template<typename T, typename N = void>
    class EventT : public Event
    {
      public: using CallbackT = std::function<T>;
      static_assert(std::is_same<typename CallbackT::result_type, void>::value,
          "Event callback must have void return type");
 
      public: EventT();
 
      public: virtual ~EventT();
 
      public: ConnectionPtr Connect(const CallbackT &_subscriber);
 
      public: virtual void Disconnect(int _id);
 
      public: unsigned int ConnectionCount() const;
 
      public: template<typename ... Args>
              void operator()(Args && ... args)
      {
        this->Signal(std::forward<Args>(args)...);
      }
 
      public: template <typename ... Args>
              void Signal(Args && ... args)
      {
        this->Cleanup();
 
        this->SetSignaled(true);
        for (const auto &iter : this->connections)
        {
          if (iter.second->on)
            iter.second->callback(std::forward<Args>(args)...);
        }
      }
 
      private: void Cleanup();
 
      private: class EventConnection
      {
        public: EventConnection(bool _on, const std::function<T> &_cb,
                        const ConnectionPtr &_publicConn)
            : callback(_cb), publicConnection(_publicConn)
        {
          // 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;
 
        public: std::weak_ptr<Connection> publicConnection;
      };
 
      typedef std::map<int, std::unique_ptr<EventConnection>> EvtConnectionMap;
 
      private: EvtConnectionMap connections;
 
      private: std::mutex mutex;
 
      private: std::list<typename EvtConnectionMap::const_iterator>
              connectionsToRemove;
    };
 
    template<typename T, typename N>
    EventT<T, N>::EventT()
    : Event()
    {
    }
 
    template<typename T, typename N>
    EventT<T, N>::~EventT()
    {
      // Clear the Event pointer on all connections so that they are not
      // accessed after this Event is destructed.
      for (auto &conn : this->connections)
      {
        auto publicCon = conn.second->publicConnection.lock();
        if (publicCon)
        {
          publicCon->event = nullptr;
        }
      }
      this->connections.clear();
    }
 
    template<typename T, typename N>
    ConnectionPtr EventT<T, N>::Connect(const std::function<T> &_subscriber)
    {
      int index = 0;
      if (!this->connections.empty())
      {
        auto const &iter = this->connections.rbegin();
        index = iter->first + 1;
      }
      auto connection = ConnectionPtr(new Connection(this, index));
      this->connections[index].reset(
          new EventConnection(true, _subscriber, connection));
      return connection;
    }
 
    template<typename T, typename N>
    unsigned int EventT<T, N>::ConnectionCount() const
    {
      return this->connections.size();
    }
 
    template<typename T, typename N>
    void EventT<T, N>::Disconnect(int _id)
    {
      // Find the connection
      auto const &it = this->connections.find(_id);
 
      if (it != this->connections.end())
      {
        it->second->on = false;
        // The destructor of std::function seems to crashes if the function it
        // points to is in a shared library and has been unloaded by the time
        // the destructor is invoked. It's not clear whether this is a bug in
        // the implementation of std::function or not. To avoid the crash,
        // we call the destructor here by setting `callback = nullptr` because
        // it is likely that EventT::Disconnect is called before the shared
        // library is unloaded via Connection::~Connection.
        it->second->callback = nullptr;
        this->connectionsToRemove.push_back(it);
      }
    }
 
    template<typename T, typename N>
    void EventT<T, N>::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