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>
    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