LifetimeGuard.hpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 */
 
#pragma once
 
#include <atomic>
#include <memory>
#include <utility>
 
// Utility condivisa per proteggere i lambda che catturano `this` e vengono
// eseguiti asincronicamente (std::thread::detach, Glib::signal_idle,
// callback di Gio::AsyncResult, ecc.) dal rischio di accedere a un oggetto
// già distrutto.
//
// PATTERN DI USO:
//
// class MyPage : public Gtk::Box {
// public:
//     MyPage() {
//         alive_ = std::make_shared<std::atomic<bool>>(true);
//     }
//
//     ~MyPage() override {
//         // Segnala ai lambda in volo che l'oggetto è morto.
//         // I lambda faranno early-return invece di toccare `this`.
//         if (alive_) alive_->store(false);
//     }
//
//     void do_async_work() {
//         auto alive = alive_;  // cattura per valore (copy dello shared_ptr)
//         std::thread([this, alive]() {
//             // ... lavoro in background ...
//             if (!alive || !alive->load()) return;  // oggetto morto
//             Glib::signal_idle().connect_once([this, alive]() {
//                 if (!alive || !alive->load()) return;
//                 // safe: possiamo usare `this`
//                 update_ui();
//             });
//         }).detach();
//     }
//
// private:
//     std::shared_ptr<std::atomic<bool>> alive_;
// };
//
// NOTE:
// - Il flag è `std::shared_ptr<std::atomic<bool>>`: garantisce sia
//   atomicità sulla lettura/scrittura del bool, sia che la memoria che
//   contiene il flag resti valida finché almeno un lambda lo referenzia.
// - Il costo è trascurabile (una refcount atomic inc/dec per lambda).
// - Non protegge da tutti i use-after-free possibili: se il lambda
//   dereferenzia `this` PRIMA del check, crasha lo stesso. Il check va
//   fatto come prima istruzione utile del lambda.
 
namespace BastionGuard {
 
using AliveFlag = std::shared_ptr<std::atomic<bool>>;
 
inline AliveFlag make_alive_flag() {
    return std::make_shared<std::atomic<bool>>(true);
}
 
// Esegue `fn()` solo se `alive` è ancora valido e settato a true.
// Utile come wrapper leggibile nei lambda.
template <typename Fn>
inline void if_alive(const AliveFlag& alive, Fn&& fn) {
    if (alive && alive->load(std::memory_order_acquire)) {
        std::forward<Fn>(fn)();
    }
}
 
} // namespace BastionGuard