connection_state.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <atomic>
#include <cstdint>
 
namespace kcenon::network::utils
{
 
    enum class connection_status : uint8_t
    {
        disconnected = 0,  
        connecting = 1,    
        connected = 2,     
        disconnecting = 3  
    };
 
    class connection_state
    {
    public:
        connection_state() = default;
 
        ~connection_state() = default;
 
        // Non-copyable
        connection_state(const connection_state&) = delete;
        connection_state& operator=(const connection_state&) = delete;
 
        // Movable
        connection_state(connection_state&& other) noexcept
            : status_(other.status_.load(std::memory_order_acquire))
        {
            other.status_.store(connection_status::disconnected,
                                std::memory_order_release);
        }
 
        connection_state& operator=(connection_state&& other) noexcept
        {
            if (this != &other)
            {
                status_.store(other.status_.load(std::memory_order_acquire),
                              std::memory_order_release);
                other.status_.store(connection_status::disconnected,
                                    std::memory_order_release);
            }
            return *this;
        }
 
        [[nodiscard]] auto status() const -> connection_status
        {
            return status_.load(std::memory_order_acquire);
        }
 
        [[nodiscard]] auto is_connected() const -> bool
        {
            return status_.load(std::memory_order_acquire) == connection_status::connected;
        }
 
        [[nodiscard]] auto is_disconnected() const -> bool
        {
            return status_.load(std::memory_order_acquire) == connection_status::disconnected;
        }
 
        [[nodiscard]] auto is_connecting() const -> bool
        {
            return status_.load(std::memory_order_acquire) == connection_status::connecting;
        }
 
        [[nodiscard]] auto is_disconnecting() const -> bool
        {
            return status_.load(std::memory_order_acquire) == connection_status::disconnecting;
        }
 
        [[nodiscard]] auto set_connecting() -> bool
        {
            auto expected = connection_status::disconnected;
            return status_.compare_exchange_strong(
                expected, connection_status::connecting, std::memory_order_acq_rel);
        }
 
        auto set_connected() -> void
        {
            status_.store(connection_status::connected, std::memory_order_release);
        }
 
        [[nodiscard]] auto set_disconnecting() -> bool
        {
            auto expected = connection_status::connected;
            return status_.compare_exchange_strong(
                expected, connection_status::disconnecting, std::memory_order_acq_rel);
        }
 
        auto set_disconnected() -> void
        {
            status_.store(connection_status::disconnected, std::memory_order_release);
        }
 
        auto reset() -> void { set_disconnected(); }
 
    private:
        std::atomic<connection_status> status_{connection_status::disconnected};
    };
 
} // namespace kcenon::network::utils