anyEvent.hpp

Go to the documentation of this file.

 
#ifndef RAD_ANYEVENT_HPP
#define RAD_ANYEVENT_HPP
 
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <typeindex>
 
namespace rad {
 
struct IncorrectEventType : public std::runtime_error {
    using std::runtime_error::runtime_error;
};
 
struct EventInfo {
    enum class Context { any, statemachine };
 
    std::string id;
 
    std::type_index payload;
 
    Context context;
};
 
class AnyEvent;
using SharedEvent = std::shared_ptr<const AnyEvent>;
using UniqueEvent = std::unique_ptr<AnyEvent>;
 
class AnyEvent {
   public:
    virtual ~AnyEvent();
 
    inline char const* GetId() const { return m_id; }
 
    virtual AnyEvent* Clone() const = 0;
 
   protected:
    AnyEvent(char const* id);
 
    AnyEvent(AnyEvent const& e) = default;
    AnyEvent(AnyEvent&& e) = default;
    AnyEvent& operator=(AnyEvent const& e) = default;
 
   private:
    // needs to point to a static area in memory
    char const* m_id;
};
 
template <typename EventTrait>
class EventT final : public ::rad::AnyEvent {
   public:
    static constexpr char const* ID = EventTrait::ID;
    using payload_t = typename EventTrait::payload_t;
 
    template <typename... Args, typename = typename std::enable_if<
                                    std::is_constructible<payload_t, Args...>::value>::type>
    explicit EventT(Args&&... args) : AnyEvent(EventT::ID), m_payload(std::forward<Args>(args)...) {}
 
    EventT(EventT const&) = default;
    EventT(EventT&&) = default;
    EventT& operator=(EventT const& e) = default;
 
    payload_t const& GetPayload() const { return m_payload; }
 
    payload_t& GetPayload() { return m_payload; }
 
    AnyEvent* Clone() const override { return new EventT(*this); }
 
   private:
    payload_t m_payload;
};
 
}  // namespace rad
 
#endif  // RAD_ANYEVENT_HPP