guarded.hpp

Go to the documentation of this file.

// guarded — a callback that does nothing once its screen is gone.
//
// A screen (a tab, an activity) owns an `alive` token; what finishes later
// (aurore::sync after a background task, a flow that waits for the network or
// a dialog) takes guarded(alive, fn) instead of a bare [this]: fn runs only
// while the token is held and true. Checked where the callback is called,
// which is the UI thread: a worker thread hands it to aurore::sync, never calls
// it itself. No Aurore: host-tested (tests/host/guarded_tests.cpp).
// Copyright (C) 2026 JigSawFr.  GPLv3-or-later (see LICENSE.GPL).
#pragma once
 
#include <memory>
#include <utility>
 
namespace ui
{
 
using Alive = std::shared_ptr<bool>;
using Weak = std::weak_ptr<bool>;
inline Alive make_alive() { return std::make_shared<bool>(true); }
 
template <typename F>
auto guarded(Weak alive, F fn)
{
    return [weak = std::move(alive), fn = std::move(fn)](auto&&... args)
    {
        const Alive held = weak.lock();
        if (!held || !*held)
            return;
        fn(std::forward<decltype(args)>(args)...);
    };
}
template <typename F>
auto guarded(const Alive& alive, F fn)
{
    return guarded(Weak(alive), std::move(fn));
}
 
} // namespace ui