GeometryThread.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 CERN for the benefit of the SHiP Collaboration
//
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
 
#include <thread>
#include <type_traits>
 
#include <concepts>
#include <condition_variable>
#include <deque>
#include <functional>
#include <future>
#include <mutex>
#include <stop_token>
#include <utility>
 
namespace ship {
 
class GeometryThread {
   public:
    // jthread requests stop and joins; queued tasks are drained first.
    ~GeometryThread() = default;
 
    GeometryThread(const GeometryThread&) = delete;
    GeometryThread& operator=(const GeometryThread&) = delete;
    GeometryThread(GeometryThread&&) = delete;
    GeometryThread& operator=(GeometryThread&&) = delete;
 
    // Constrained on lvalue invocation: f is called as an lvalue here and
    // by the packaged_task below.
    template <typename F>
        requires std::invocable<F&>
    std::invoke_result_t<F&> run(F&& f) {
        if (std::this_thread::get_id() == m_thread.get_id())
            return f();
        using R = std::invoke_result_t<F&>;
        std::packaged_task<R()> task{std::forward<F>(f)};
        auto result = task.get_future();
        // The reference capture is safe: result.get() below keeps this frame
        // alive until the task has run.
        post([&task] { task(); });
        return result.get();
    }
 
   private:
    // Constructible only through geometry_thread(): a second instance would
    // break the single geometry-creating-thread invariant documented there.
    GeometryThread();
    friend GeometryThread& geometry_thread();
 
    void post(std::function<void()> task);
    void loop(std::stop_token stopToken);
 
    std::mutex m_mutex;
    std::condition_variable_any m_cv;
    std::deque<std::function<void()>> m_tasks;
    std::jthread m_thread;  
};
 
GeometryThread& geometry_thread();
 
}  // namespace ship