Object.hpp

Go to the documentation of this file.

 
#ifndef ECHOMAP_OBJECT_HPP
#define ECHOMAP_OBJECT_HPP
 
#include <format>
#include <string>
#include <string_view>
#include <utility>
 
#include "IDAllocator.hpp"
 
namespace echomap
{

template <typename Derived> class Object
{
public:
    ~Object() = default;
 
    [[nodiscard]] id_type get_id() const noexcept
    {
        assert(is_valid());
        return id;
    }
 
    [[nodiscard]] bool is_valid() const noexcept
    {
        return id != IDAllocator<Derived>::invalid_id;
    }
 
    void set_name(
            const std::string_view new_name
    )
    {
        assert(is_valid());
        this->name = std::string(new_name);
    }
 
    [[nodiscard]] std::string_view get_name() const noexcept
    {
        assert(is_valid());
        return name;
    }
 
    [[nodiscard]] const char* get_imgui_name() const noexcept
    {
        assert(is_valid());
        return name.c_str();
    }
 
    [[nodiscard]] static std::string_view get_class_name() noexcept
    {
        return class_name;
    }
 
    Object(const Object&) = delete;
    Object& operator=(const Object&) = delete;
    Object& operator=(Object&&) = delete;

    [[nodiscard]] bool operator==(
            const Object& other
    ) const noexcept
    {
        return id == other.id;
    }
 
protected:
    struct CopyTag
    {};

    Object() :
        id(IDAllocator<Derived>::allocate()),
        name(std::string(class_name) + ' ' + std::to_string(id))
    {
    }

    explicit Object(
            const std::string_view object_name
    ) :
        id(IDAllocator<Derived>::allocate()),
        name(object_name.empty() ? std::string(class_name) + ' ' + std::to_string(id) : object_name)
    {
    }
 
    Object(
            Object&& other
    ) noexcept :
        id(std::exchange(
                other.id,
                IDAllocator<Derived>::invalid_id
        )),
        copy_count(
                std::exchange(
                        other.copy_count,
                        0
                )
        ),
        name(std::move(other.name))
    {
    }

    Object(
            [[maybe_unused]] CopyTag tag,
            const Object& old
    ) :
        id(IDAllocator<Derived>::allocate()),
        copy_count(old.copy_count + 1),
        name(std::format(
                "{} ({})",
                old.get_name(),
                copy_count
        ))
    {
        ++old.copy_count;
    }

    Object(
            [[maybe_unused]] CopyTag tag,
            const Object& old,
            const std::string_view new_name
    ) :
        id(IDAllocator<Derived>::allocate()),
        copy_count(old.copy_count),
        name(new_name)
    {
    }

    void move_identity_from(
            Object&& other // NOLINT(*-rvalue-reference-param-not-moved)
    ) noexcept
    {
        if (this == &other)
            return;
 
        assert(other.is_valid());
 
        id = std::exchange(other.id, IDAllocator<Derived>::invalid_id);
        copy_count = std::exchange(other.copy_count, 0);
        name = std::move(other.name);
    }
 
private:
    static constexpr std::string_view class_name = "Object";
 
    id_type id;                         
    mutable std::size_t copy_count = 0; 
    std::string name;                   
};
 
} // namespace echomap
 
#endif // ECHOMAP_OBJECT_HPP