events.rad.hpp

Go to the documentation of this file.

#ifndef EVENTS_EVENTS_RAD_HPP_
#define EVENTS_EVENTS_RAD_HPP_

#include <vector>
#include <rad/anyEvent.hpp>

#include <boost/exception_ptr.hpp>
#include <rad/mal/request.hpp>
#include <Hellomalif.hpp>

namespace Events {
std::vector<rad::EventInfo> listEvents();

// Config

class Config final : public rad::AnyEvent {
 public:
    static constexpr char const* ID = "Events.Config";
    static constexpr rad::EventInfo::Context ctx = rad::EventInfo::Context::any;
    using payload_t = rad::cii::Request<std::string>;

    explicit Config(rad::cii::Request<std::string> const&);

    template <typename... Args,
              typename = typename std::enable_if<std::is_constructible<payload_t, Args... >::value>::type>
    explicit Config(Args&&... args)
        : AnyEvent(ID)
        , m_payload(std::forward<Args>(args)...) {
    }
    Config(Config const&) = default;
    Config(Config&&) = default;
    Config& operator=(Config const& e) = default;

    AnyEvent* Clone() const override;
    inline rad::cii::Request<std::string> const& GetPayload() const;
    inline rad::cii::Request<std::string>& GetPayload();

 private:
    rad::cii::Request<std::string> m_payload;
};

// Inline definitions
rad::cii::Request<std::string> const& Config::GetPayload() const {
    return m_payload;
}
rad::cii::Request<std::string>& Config::GetPayload() {
    return m_payload;
}

// CtrlC

class CtrlC final : public rad::AnyEvent {
 public:
    static constexpr char const* ID = "Events.CtrlC";
    static constexpr rad::EventInfo::Context ctx = rad::EventInfo::Context::any;
    using payload_t = void;

    CtrlC();
    CtrlC(CtrlC const&) = default;
    CtrlC(CtrlC&&) = default;
    CtrlC& operator=(CtrlC const& e) = default;

    AnyEvent* Clone() const override;
};


// Disable

class Disable final : public rad::AnyEvent {
 public:
    static constexpr char const* ID = "Events.Disable";
    static constexpr rad::EventInfo::Context ctx = rad::EventInfo::Context::any;
    using payload_t = rad::cii::Request<std::string>;

    explicit Disable(rad::cii::Request<std::string> const&);

    template <typename... Args,
              typename = typename std::enable_if<std::is_constructible<payload_t, Args... >::value>::type>
    explicit Disable(Args&&... args)
        : AnyEvent(ID)
        , m_payload(std::forward<Args>(args)...) {
    }
    Disable(Disable const&) = default;
    Disable(Disable&&) = default;
    Disable& operator=(Disable const& e) = default;

    AnyEvent* Clone() const override;
    inline rad::cii::Request<std::string> const& GetPayload() const;
    inline rad::cii::Request<std::string>& GetPayload();

 private:
    rad::cii::Request<std::string> m_payload;
};

// Inline definitions
rad::cii::Request<std::string> const& Disable::GetPayload() const {
    return m_payload;
}
rad::cii::Request<std::string>& Disable::GetPayload() {
    return m_payload;
}

// Enable

class Enable final : public rad::AnyEvent {
 public:
    static constexpr char const* ID = "Events.Enable";
    static constexpr rad::EventInfo::Context ctx = rad::EventInfo::Context::any;
    using payload_t = rad::cii::Request<std::string>;

    explicit Enable(rad::cii::Request<std::string> const&);

    template <typename... Args,
              typename = typename std::enable_if<std::is_constructible<payload_t, Args... >::value>::type>
    explicit Enable(Args&&... args)
        : AnyEvent(ID)
        , m_payload(std::forward<Args>(args)...) {
    }
    Enable(Enable const&) = default;
    Enable(Enable&&) = default;
    Enable& operator=(Enable const& e) = default;

    AnyEvent* Clone() const override;
    inline rad::cii::Request<std::string> const& GetPayload() const;
    inline rad::cii::Request<std::string>& GetPayload();

 private:
    rad::cii::Request<std::string> m_payload;
};

// Inline definitions
rad::cii::Request<std::string> const& Enable::GetPayload() const {
    return m_payload;
}
rad::cii::Request<std::string>& Enable::GetPayload() {
    return m_payload;
}

// Exit

class Exit final : public rad::AnyEvent {
 public:
    static constexpr char const* ID = "Events.Exit";
    static constexpr rad::EventInfo::Context ctx = rad::EventInfo::Context::any;
    using payload_t = rad::cii::Request<std::string>;

    explicit Exit(rad::cii::Request<std::string> const&);

    template <typename... Args,
              typename = typename std::enable_if<std::is_constructible<payload_t, Args... >::value>::type>
    explicit Exit(Args&&... args)
        : AnyEvent(ID)
        , m_payload(std::forward<Args>(args)...) {
    }
    Exit(Exit const&) = default;
    Exit(Exit&&) = default;
    Exit& operator=(Exit const& e) = default;

    AnyEvent* Clone() const override;
    inline rad::cii::Request<std::string> const& GetPayload() const;
    inline rad::cii::Request<std::string>& GetPayload();

 private:
    rad::cii::Request<std::string> m_payload;
};

// Inline definitions
rad::cii::Request<std::string> const& Exit::GetPayload() const {
    return m_payload;
}
rad::cii::Request<std::string>& Exit::GetPayload() {
    return m_payload;
}

// Init

class Init final : public rad::AnyEvent {
 public:
    static constexpr char const* ID = "Events.Init";
    static constexpr rad::EventInfo::Context ctx = rad::EventInfo::Context::any;
    using payload_t = rad::cii::Request<std::string>;

    explicit Init(rad::cii::Request<std::string> const&);

    template <typename... Args,
              typename = typename std::enable_if<std::is_constructible<payload_t, Args... >::value>::type>
    explicit Init(Args&&... args)
        : AnyEvent(ID)
        , m_payload(std::forward<Args>(args)...) {
    }
    Init(Init const&) = default;
    Init(Init&&) = default;
    Init& operator=(Init const& e) = default;

    AnyEvent* Clone() const override;
    inline rad::cii::Request<std::string> const& GetPayload() const;
    inline rad::cii::Request<std::string>& GetPayload();

 private:
    rad::cii::Request<std::string> m_payload;
};

// Inline definitions
rad::cii::Request<std::string> const& Init::GetPayload() const {
    return m_payload;
}
rad::cii::Request<std::string>& Init::GetPayload() {
    return m_payload;
}

// Reset

class Reset final : public rad::AnyEvent {
 public:
    static constexpr char const* ID = "Events.Reset";
    static constexpr rad::EventInfo::Context ctx = rad::EventInfo::Context::any;
    using payload_t = rad::cii::Request<std::string>;

    explicit Reset(rad::cii::Request<std::string> const&);

    template <typename... Args,
              typename = typename std::enable_if<std::is_constructible<payload_t, Args... >::value>::type>
    explicit Reset(Args&&... args)
        : AnyEvent(ID)
        , m_payload(std::forward<Args>(args)...) {
    }
    Reset(Reset const&) = default;
    Reset(Reset&&) = default;
    Reset& operator=(Reset const& e) = default;

    AnyEvent* Clone() const override;
    inline rad::cii::Request<std::string> const& GetPayload() const;
    inline rad::cii::Request<std::string>& GetPayload();

 private:
    rad::cii::Request<std::string> m_payload;
};

// Inline definitions
rad::cii::Request<std::string> const& Reset::GetPayload() const {
    return m_payload;
}
rad::cii::Request<std::string>& Reset::GetPayload() {
    return m_payload;
}

// SetLogLevel

class SetLogLevel final : public rad::AnyEvent {
 public:
    static constexpr char const* ID = "Events.SetLogLevel";
    static constexpr rad::EventInfo::Context ctx = rad::EventInfo::Context::any;
    using payload_t = rad::cii::Request<std::string, std::shared_ptr<hellomalif::LogInfo>>;

    explicit SetLogLevel(rad::cii::Request<std::string, std::shared_ptr<hellomalif::LogInfo>> const&);

    template <typename... Args,
              typename = typename std::enable_if<std::is_constructible<payload_t, Args... >::value>::type>
    explicit SetLogLevel(Args&&... args)
        : AnyEvent(ID)
        , m_payload(std::forward<Args>(args)...) {
    }
    SetLogLevel(SetLogLevel const&) = default;
    SetLogLevel(SetLogLevel&&) = default;
    SetLogLevel& operator=(SetLogLevel const& e) = default;

    AnyEvent* Clone() const override;
    inline rad::cii::Request<std::string, std::shared_ptr<hellomalif::LogInfo>> const& GetPayload() const;
    inline rad::cii::Request<std::string, std::shared_ptr<hellomalif::LogInfo>>& GetPayload();

 private:
    rad::cii::Request<std::string, std::shared_ptr<hellomalif::LogInfo>> m_payload;
};

// Inline definitions
rad::cii::Request<std::string, std::shared_ptr<hellomalif::LogInfo>> const& SetLogLevel::GetPayload() const {
    return m_payload;
}
rad::cii::Request<std::string, std::shared_ptr<hellomalif::LogInfo>>& SetLogLevel::GetPayload() {
    return m_payload;
}

// Status

class Status final : public rad::AnyEvent {
 public:
    static constexpr char const* ID = "Events.Status";
    static constexpr rad::EventInfo::Context ctx = rad::EventInfo::Context::any;
    using payload_t = rad::cii::Request<std::string>;

    explicit Status(rad::cii::Request<std::string> const&);

    template <typename... Args,
              typename = typename std::enable_if<std::is_constructible<payload_t, Args... >::value>::type>
    explicit Status(Args&&... args)
        : AnyEvent(ID)
        , m_payload(std::forward<Args>(args)...) {
    }
    Status(Status const&) = default;
    Status(Status&&) = default;
    Status& operator=(Status const& e) = default;

    AnyEvent* Clone() const override;
    inline rad::cii::Request<std::string> const& GetPayload() const;
    inline rad::cii::Request<std::string>& GetPayload();

 private:
    rad::cii::Request<std::string> m_payload;
};

// Inline definitions
rad::cii::Request<std::string> const& Status::GetPayload() const {
    return m_payload;
}
rad::cii::Request<std::string>& Status::GetPayload() {
    return m_payload;
}

// Stop

class Stop final : public rad::AnyEvent {
 public:
    static constexpr char const* ID = "Events.Stop";
    static constexpr rad::EventInfo::Context ctx = rad::EventInfo::Context::any;
    using payload_t = rad::cii::Request<std::string>;

    explicit Stop(rad::cii::Request<std::string> const&);

    template <typename... Args,
              typename = typename std::enable_if<std::is_constructible<payload_t, Args... >::value>::type>
    explicit Stop(Args&&... args)
        : AnyEvent(ID)
        , m_payload(std::forward<Args>(args)...) {
    }
    Stop(Stop const&) = default;
    Stop(Stop&&) = default;
    Stop& operator=(Stop const& e) = default;

    AnyEvent* Clone() const override;
    inline rad::cii::Request<std::string> const& GetPayload() const;
    inline rad::cii::Request<std::string>& GetPayload();

 private:
    rad::cii::Request<std::string> m_payload;
};

// Inline definitions
rad::cii::Request<std::string> const& Stop::GetPayload() const {
    return m_payload;
}
rad::cii::Request<std::string>& Stop::GetPayload() {
    return m_payload;
}



} // namespace Events


#endif  // EVENTS_EVENTS_RAD_HPP_