session_handle.h

Go to the documentation of this file.

/*****************************************************************************
BSD 3-Clause License
 
Copyright (c) 2025, kcenon
All rights reserved.
*****************************************************************************/
 
#pragma once
 
#include "internal/core/session_concept.h"
#include "internal/core/session_model.h"
 
#include <memory>
#include <optional>
#include <string>
#include <string_view>
 
namespace kcenon::network::core {
 
// Import VoidResult from network namespace for convenience
using kcenon::network::VoidResult;
 
class session_handle {
public:
    session_handle() = default;
 
    explicit session_handle(std::unique_ptr<session_concept> session_concept_ptr)
        : concept_(std::move(session_concept_ptr)) {}
 
    template <typename SessionType>
    explicit session_handle(std::shared_ptr<SessionType> session)
        : concept_(make_session_model(std::move(session))) {}
 
    // Move-only semantics
    session_handle(session_handle&&) = default;
    session_handle& operator=(session_handle&&) = default;
 
    session_handle(const session_handle&) = delete;
    session_handle& operator=(const session_handle&) = delete;
 
    ~session_handle() = default;
 
    // =========================================================================
    // Validity Check
    // =========================================================================
 
    [[nodiscard]] explicit operator bool() const noexcept {
        return concept_ != nullptr;
    }
 
    [[nodiscard]] auto valid() const noexcept -> bool {
        return concept_ != nullptr;
    }
 
    // =========================================================================
    // Core Session Operations
    // =========================================================================
 
    [[nodiscard]] auto id() const -> std::string_view {
        return concept_ ? concept_->id() : std::string_view{};
    }
 
    [[nodiscard]] auto is_connected() const -> bool {
        return concept_ && concept_->is_connected();
    }
 
    [[nodiscard]] auto send(std::vector<uint8_t>&& data) -> VoidResult {
        if (!concept_) {
            return VoidResult::err(-1, "Invalid session handle");
        }
        return concept_->send(std::move(data));
    }
 
    auto close() -> void {
        if (concept_) {
            concept_->close();
        }
    }
 
    auto stop() -> void {
        if (concept_) {
            concept_->stop();
        }
    }
 
    // =========================================================================
    // Type Recovery
    // =========================================================================
 
    template <typename T>
    [[nodiscard]] auto as() noexcept -> T* {
        if (!concept_ || concept_->type() != typeid(T)) {
            return nullptr;
        }
        return static_cast<T*>(concept_->get_raw());
    }
 
    template <typename T>
    [[nodiscard]] auto as() const noexcept -> const T* {
        if (!concept_ || concept_->type() != typeid(T)) {
            return nullptr;
        }
        return static_cast<const T*>(concept_->get_raw());
    }
 
    template <typename T>
    [[nodiscard]] auto is_type() const noexcept -> bool {
        return concept_ && concept_->type() == typeid(T);
    }
 
    [[nodiscard]] auto type() const noexcept -> const std::type_info& {
        return concept_ ? concept_->type() : typeid(void);
    }
 
    // =========================================================================
    // Activity Tracking
    // =========================================================================
 
    [[nodiscard]] auto has_activity_tracking() const noexcept -> bool {
        return concept_ && concept_->has_activity_tracking();
    }
 
    [[nodiscard]] auto created_at() const -> std::chrono::steady_clock::time_point {
        return concept_ ? concept_->created_at()
                        : std::chrono::steady_clock::time_point{};
    }
 
    [[nodiscard]] auto last_activity() const -> std::chrono::steady_clock::time_point {
        return concept_ ? concept_->last_activity()
                        : std::chrono::steady_clock::time_point{};
    }
 
    auto update_activity() -> void {
        if (concept_) {
            concept_->update_activity();
        }
    }
 
    [[nodiscard]] auto idle_duration() const -> std::chrono::milliseconds {
        return concept_ ? concept_->idle_duration() : std::chrono::milliseconds{0};
    }
 
    // =========================================================================
    // Access to Underlying Concept
    // =========================================================================
 
    [[nodiscard]] auto get_concept() noexcept -> session_concept* {
        return concept_.get();
    }
 
    [[nodiscard]] auto get_concept() const noexcept -> const session_concept* {
        return concept_.get();
    }
 
    [[nodiscard]] auto release() noexcept -> std::unique_ptr<session_concept> {
        return std::move(concept_);
    }
 
    auto reset() noexcept -> void {
        concept_.reset();
    }
 
private:
    std::unique_ptr<session_concept> concept_;
};
 
template <typename SessionType>
[[nodiscard]] auto make_session_handle(std::shared_ptr<SessionType> session)
    -> session_handle {
    return session_handle(std::move(session));
}
 
} // namespace kcenon::network::core