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 <rad/msgRequest.hpp>
#include <helloif/requests.pb.h>

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::MsgRequest<helloif::ReqConfig>;

    explicit Config(rad::MsgRequest<helloif::ReqConfig> 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::MsgRequest<helloif::ReqConfig> const& GetPayload() const;
    inline rad::MsgRequest<helloif::ReqConfig>& GetPayload();

 private:
    rad::MsgRequest<helloif::ReqConfig> m_payload;
};

// Inline definitions
rad::MsgRequest<helloif::ReqConfig> const& Config::GetPayload() const {
    return m_payload;
}
rad::MsgRequest<helloif::ReqConfig>& 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::MsgRequest<helloif::ReqDisable>;

    explicit Disable(rad::MsgRequest<helloif::ReqDisable> 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::MsgRequest<helloif::ReqDisable> const& GetPayload() const;
    inline rad::MsgRequest<helloif::ReqDisable>& GetPayload();

 private:
    rad::MsgRequest<helloif::ReqDisable> m_payload;
};

// Inline definitions
rad::MsgRequest<helloif::ReqDisable> const& Disable::GetPayload() const {
    return m_payload;
}
rad::MsgRequest<helloif::ReqDisable>& 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::MsgRequest<helloif::ReqEnable>;

    explicit Enable(rad::MsgRequest<helloif::ReqEnable> 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::MsgRequest<helloif::ReqEnable> const& GetPayload() const;
    inline rad::MsgRequest<helloif::ReqEnable>& GetPayload();

 private:
    rad::MsgRequest<helloif::ReqEnable> m_payload;
};

// Inline definitions
rad::MsgRequest<helloif::ReqEnable> const& Enable::GetPayload() const {
    return m_payload;
}
rad::MsgRequest<helloif::ReqEnable>& 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::MsgRequest<helloif::ReqExit>;

    explicit Exit(rad::MsgRequest<helloif::ReqExit> 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::MsgRequest<helloif::ReqExit> const& GetPayload() const;
    inline rad::MsgRequest<helloif::ReqExit>& GetPayload();

 private:
    rad::MsgRequest<helloif::ReqExit> m_payload;
};

// Inline definitions
rad::MsgRequest<helloif::ReqExit> const& Exit::GetPayload() const {
    return m_payload;
}
rad::MsgRequest<helloif::ReqExit>& 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::MsgRequest<helloif::ReqInit>;

    explicit Init(rad::MsgRequest<helloif::ReqInit> 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::MsgRequest<helloif::ReqInit> const& GetPayload() const;
    inline rad::MsgRequest<helloif::ReqInit>& GetPayload();

 private:
    rad::MsgRequest<helloif::ReqInit> m_payload;
};

// Inline definitions
rad::MsgRequest<helloif::ReqInit> const& Init::GetPayload() const {
    return m_payload;
}
rad::MsgRequest<helloif::ReqInit>& 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::MsgRequest<helloif::ReqReset>;

    explicit Reset(rad::MsgRequest<helloif::ReqReset> 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::MsgRequest<helloif::ReqReset> const& GetPayload() const;
    inline rad::MsgRequest<helloif::ReqReset>& GetPayload();

 private:
    rad::MsgRequest<helloif::ReqReset> m_payload;
};

// Inline definitions
rad::MsgRequest<helloif::ReqReset> const& Reset::GetPayload() const {
    return m_payload;
}
rad::MsgRequest<helloif::ReqReset>& 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::MsgRequest<helloif::ReqSetLogLevel>;

    explicit SetLogLevel(rad::MsgRequest<helloif::ReqSetLogLevel> 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::MsgRequest<helloif::ReqSetLogLevel> const& GetPayload() const;
    inline rad::MsgRequest<helloif::ReqSetLogLevel>& GetPayload();

 private:
    rad::MsgRequest<helloif::ReqSetLogLevel> m_payload;
};

// Inline definitions
rad::MsgRequest<helloif::ReqSetLogLevel> const& SetLogLevel::GetPayload() const {
    return m_payload;
}
rad::MsgRequest<helloif::ReqSetLogLevel>& 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::MsgRequest<helloif::ReqStatus>;

    explicit Status(rad::MsgRequest<helloif::ReqStatus> 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::MsgRequest<helloif::ReqStatus> const& GetPayload() const;
    inline rad::MsgRequest<helloif::ReqStatus>& GetPayload();

 private:
    rad::MsgRequest<helloif::ReqStatus> m_payload;
};

// Inline definitions
rad::MsgRequest<helloif::ReqStatus> const& Status::GetPayload() const {
    return m_payload;
}
rad::MsgRequest<helloif::ReqStatus>& 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::MsgRequest<helloif::ReqStop>;

    explicit Stop(rad::MsgRequest<helloif::ReqStop> 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::MsgRequest<helloif::ReqStop> const& GetPayload() const;
    inline rad::MsgRequest<helloif::ReqStop>& GetPayload();

 private:
    rad::MsgRequest<helloif::ReqStop> m_payload;
};

// Inline definitions
rad::MsgRequest<helloif::ReqStop> const& Stop::GetPayload() const {
    return m_payload;
}
rad::MsgRequest<helloif::ReqStop>& Stop::GetPayload() {
    return m_payload;
}



} // namespace Events


#endif  // EVENTS_EVENTS_RAD_HPP_