AnyEvent.hpp

Go to the documentation of this file.

#ifndef RAD_ANYEVENT_HPP_
#define RAD_ANYEVENT_HPP_

#include <stdexcept>
#include <memory>
#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>/*, typename = typename std::enable_if<
                               !std::is_void<typename EventTrait::payload_t>::value>::type>*/
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 event

#endif