manager.hpp

#pragma once
 
#include "types.hpp"
#include "../response.hpp"
#include "../request.hpp"
 
#include <chrono>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
 
namespace malloy::http::sessions
{
    struct storage;
    struct session;
 
    class manager
    {
    public:
        constexpr static const char* cookie_name = "sessionId";

        explicit
        manager(std::shared_ptr<storage> storage);

        manager(const manager& other) = delete;

        manager(manager&& other) noexcept = delete;

        virtual
        ~manager() = default;

        manager&
        operator=(const manager& rhs) = delete;

        manager&
        operator=(manager&& rhs) noexcept = delete;

        [[nodiscard]]
        std::shared_ptr<session>
        get(const request_header<>& hdr);

        [[nodiscard]]
        std::shared_ptr<session>
        get(const request<>& req)
        {
            return get(req.base());
        }

        [[nodiscard]]
        std::shared_ptr<session>
        get(const id_type& id);

        [[nodiscard]]
        std::shared_ptr<session>
        start(const request<>& req, response<>& resp);

        void
        destroy(const request<>& req, response<>& resp);

        std::size_t
        destroy_expired(const std::chrono::seconds& max_lifetime);

        [[nodiscard]]
        bool
        is_valid(const request<>& req)
        {
            return is_valid(req.base());
        }

        [[nodiscard]]
        bool
        is_valid(const malloy::http::request_header<>& hdr);

        [[nodiscard]]
        bool
        is_valid(const id_type& id);
 
    private:
        std::shared_ptr<storage> m_storage;
        std::mutex m_lock; // protects sessions

        [[nodiscard]]
        std::optional<id_type>
        get_id(const request_header<>& hdr) const;

        [[nodiscard]]
        static
        id_type
        generate_id();
    };
 
}