LifetimeTracker.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once

 
#include "shambase/WithUUID.hpp"
#include "shambase/aliases_int.hpp"
#include <string_view>
#include <utility>
 
namespace shamrock::solvergraph {

    template<typename T>
    class LifetimeTracker : public shambase::WithUUID<LifetimeTracker<T>, u64> {
        public:
        inline static void (*on_create)(u64 uuid) = nullptr;
        inline static void (*on_destroy)(u64 uuid) = nullptr;

        inline static void (*on_state_update)(T &object) = nullptr;
        inline static void (*on_event)(u64 uuid, std::string_view s) = nullptr;

        LifetimeTracker() : shambase::WithUUID<LifetimeTracker, u64>() {
            if (on_create != nullptr) {
                on_create(this->get_uuid());
            }
        };
 
        LifetimeTracker(const LifetimeTracker &)            = delete; 
        LifetimeTracker &operator=(const LifetimeTracker &) = delete; 

        LifetimeTracker(LifetimeTracker &&) noexcept = default;

        inline LifetimeTracker &operator=(LifetimeTracker &&other) noexcept {
            if (this != &other) {
                trace_destroy();
                shambase::WithUUID<LifetimeTracker, u64>::operator=(std::move(other));
            }
            return *this;
        }

        inline void trace_create() {
            if (on_create) {
                on_create(this->uuid);
            }
        }

        inline void trace_destroy() {
            if (this->is_alive()) {
                if (on_destroy) {
                    on_destroy(this->uuid);
                }
                this->invalidate();
            }
        }
 
        // notify and update of the owning object.
        inline void trace_state_update(T &object) {
            if (this->is_alive() && on_state_update) {
                on_state_update(object);
            }
        }

        template<class F>
        inline void trace_event(F &&event_info_builder) {
            if (this->is_alive() && on_event) {
                on_event(this->uuid, event_info_builder());
            }
        }

        ~LifetimeTracker() { trace_destroy(); };
    };
 
} // namespace shamrock::solvergraph