event.h

Go to the documentation of this file.

 
/*******************************************************************************
 * Copyright (c) 2024 Frank Pagliughi <fpagliughi@mindspring.com>
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * and Eclipse Distribution License v1.0 which accompany this distribution.
 *
 * The Eclipse Public License is available at
 *    http://www.eclipse.org/legal/epl-v20.html
 * and the Eclipse Distribution License is available at
 *   http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *    Frank Pagliughi - initial implementation and documentation
 *******************************************************************************/
 
#ifndef __mqtt_event_h
#define __mqtt_event_h
 
#include <variant>
 
#include "mqtt/message.h"
#include "mqtt/properties.h"
#include "mqtt/reason_code.h"
#include "mqtt/types.h"
 
namespace mqtt {


struct connected_event
{
    string cause;
};

struct connection_lost_event
{
    string cause;
};

struct disconnected_event
{
    properties props;
    ReasonCode reasonCode;
};

struct shutdown_event
{
};
 
/* Event for when a message arrives is just a message pointer */


class event
{
public:
    using event_type = std::variant<
        const_message_ptr, connected_event, connection_lost_event, disconnected_event,
        shutdown_event>;
 
private:
    event_type evt_{};
 
public:
    event() {}
    event(event_type evt) : evt_{std::move(evt)} {}
    event(message_ptr msg) : evt_{std::move(msg)} {}
    event(const_message_ptr msg) : evt_{std::move(msg)} {}
    event(connected_event evt) : evt_{std::move(evt)} {}
    event(connection_lost_event evt) : evt_{std::move(evt)} {}
    event(disconnected_event evt) : evt_{std::move(evt)} {}
    event(shutdown_event evt) : evt_{std::move(evt)} {}
    event(const event& evt) : evt_{evt.evt_} {}
    event(event&& evt) : evt_{std::move(evt.evt_)} {}
    event& operator=(event_type evt) {
        evt_ = std::move(evt);
        return *this;
    }

    event& operator=(const event& rhs) {
        if (&rhs != this)
            evt_ = rhs.evt_;
        return *this;
    }

    event& operator=(event&& rhs) {
        if (&rhs != this)
            evt_ = std::move(rhs.evt_);
        return *this;
    }

    bool is_message() const { return std::holds_alternative<const_message_ptr>(evt_); }
    bool is_connected() const { return std::holds_alternative<connected_event>(evt_); }
    bool is_connection_lost() const {
        return std::holds_alternative<connection_lost_event>(evt_);
    }

    bool is_disconnected() const { return std::holds_alternative<disconnected_event>(evt_); }
    bool is_shutdown() const { return std::holds_alternative<disconnected_event>(evt_); }
    bool is_any_disconnect() const {
        return std::holds_alternative<connection_lost_event>(evt_) ||
               std::holds_alternative<disconnected_event>(evt_) ||
               std::holds_alternative<shutdown_event>(evt_);
    }

    const_message_ptr get_message() { return std::get<const_message_ptr>(evt_); }
    disconnected_event get_disconnected() { return std::get<disconnected_event>(evt_); }
    constexpr std::add_pointer_t<const_message_ptr> get_message_if() noexcept {
        return std::get_if<const_message_ptr>(&evt_);
    }

    constexpr std::add_pointer_t<disconnected_event> get_disconnected_if() noexcept {
        return std::get_if<disconnected_event>(&evt_);
    }
};

}  // namespace mqtt
 
#endif  // __mqtt_event_h