WithUUID.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 <atomic>
#include <limits>
 
namespace shambase {

    template<typename T, class Tint, bool thread_safe = true>
    class WithUUID {
 
        protected:
        Tint uuid;
 
        public:
        static constexpr Tint invalid_uuid = std::numeric_limits<Tint>::max();

        inline Tint get_uuid() const { return uuid; }

        inline bool is_alive() const { return uuid != invalid_uuid; }

        inline void invalidate() { uuid = invalid_uuid; }

        inline WithUUID() {
            if constexpr (thread_safe) {
                // local atomic static storage for the UUID
                static std::atomic<Tint> _uuid = 0;
                // increment and store the UUID (atomic)
                uuid = _uuid.fetch_add(1, std::memory_order_relaxed);
            } else {
                // we need to redo the static storage in this case otherwise
                // some lock xadd would be emitted as std::atomic is thread safe.
                static Tint _uuid = 0;
                uuid              = _uuid++;
            }
        }
 
        WithUUID(const WithUUID &)            = delete; 
        WithUUID &operator=(const WithUUID &) = delete; 

        inline WithUUID(WithUUID &&other) noexcept : uuid(other.uuid) { other.invalidate(); }

        inline WithUUID &operator=(WithUUID &&other) noexcept {
            if (this != &other) {
                uuid = other.uuid;
                other.invalidate();
            }
            return *this;
        }
    };
 
} // namespace shambase