reflect/any.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_REFLECT_ANY_HPP__
#define NEFORCE_CORE_REFLECT_ANY_HPP__

 
#include "NeForce/core/exception/exception.hpp"
#include "NeForce/core/string/string_view.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_REFLECT__

 
using type_id = size_t; 
 

template <typename T>
struct type_name {
    static constexpr string_view value = "unknown";
};

template <typename T>
NEFORCE_INLINE17 constexpr string_view type_name_v = type_name<T>::value;

#define __NEFORCE_SPECIALIZE_TYPE_NAME(T)        \
    template <>                                  \
    struct type_name<T> {                        \
        static constexpr string_view value = #T; \
    };
 
NEFORCE_MACRO_RANGE_ARITHMETIC(__NEFORCE_SPECIALIZE_TYPE_NAME)
#undef __NEFORCE_SPECIALIZE_TYPE_NAME
 

template <typename T>
NEFORCE_NODISCARD constexpr type_id type_id_for() noexcept {
    if (type_name_v<T>.to_hash() != string_view("unknown").to_hash()) {
        return type_name_v<T>.to_hash();
    } else {
#ifdef NEFORCE_COMPILER_MSVC
        return FNV_hash_string(__FUNCSIG__, sizeof(__FUNCSIG__) - 1);
#else
        return FNV_hash_string(__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1);
#endif
    }
}
 

class meta_any {
public:
    static constexpr size_t SBO_SIZE = sizeof(void*) * 2; 
 
private:
    union storage_internal {
        storage_internal() noexcept = default;
        storage_internal(const storage_internal&) = delete;
        storage_internal& operator=(const storage_internal&) = delete;
 
        void* ptr_ = nullptr;                                               
        aligned_storage_t<SBO_SIZE, alignof(_NEFORCE max_align_t)> buffer_; 
    };

    enum class operation : uint8_t {
        ACCESS,      
        GET_TYPE_ID, 
        COPY,        
        DESTROY,     
        MOVE,        
    };

    union arg_t {
        void* obj_ptr_{};              
        meta_any* any_ptr_;            
        reflect::type_id type_id_val_; 
    };
 
    using manage_func = void (*)(operation, const meta_any*, arg_t*); 

    template <typename T>
    struct internal_manage {
        NEFORCE_NODISCARD static reflect::type_id type_id_val() noexcept { return type_id_for<T>(); }
 
        template <typename... Args>
        static void create(storage_internal& storage, Args&&... args) {
            void* addr = const_cast<void*>(static_cast<const void*>(&storage.buffer_));
            ::new (addr) T(_NEFORCE forward<Args>(args)...);
        }
 
        static T* access(const storage_internal& storage) noexcept {
            const void* addr = &storage.buffer_;
            return static_cast<T*>(const_cast<void*>(addr));
        }
 
        template <typename U = T, enable_if_t<is_copy_constructible_v<U>, int> = 0>
        static void copy_op(const meta_any* self, arg_t* arg) {
            auto* ptr = access(self->storage_);
            create(arg->any_ptr_->storage_, *ptr);
            arg->any_ptr_->manage_ = &manage;
            arg->any_ptr_->type_id_ = type_id_val();
        }
 
        template <typename U = T, enable_if_t<!is_copy_constructible_v<U>, int> = 0>
        static void copy_op(const meta_any* /*unused*/, arg_t* /*unused*/) {}
 
        template <typename U = T, enable_if_t<is_move_constructible_v<U>, int> = 0>
        static void move_op(const meta_any* self, arg_t* arg) {
            auto* ptr = access(self->storage_);
            create(arg->any_ptr_->storage_, _NEFORCE move(*ptr));
            ptr->~T();
            arg->any_ptr_->manage_ = &manage;
            arg->any_ptr_->type_id_ = type_id_val();
        }
 
        template <typename U = T, enable_if_t<!is_move_constructible_v<U>, int> = 0>
        static void move_op(const meta_any* /*unused*/, arg_t* /*unused*/) {}
 
        static void manage(const operation op, const meta_any* self, arg_t* arg) {
            auto* ptr = access(self->storage_);
            switch (op) {
                case operation::ACCESS: {
                    arg->obj_ptr_ = static_cast<void*>(ptr);
                    break;
                }
                case operation::GET_TYPE_ID: {
                    arg->type_id_val_ = type_id_val();
                    break;
                }
                case operation::COPY: {
                    copy_op(self, arg);
                    break;
                }
                case operation::DESTROY: {
                    ptr->~T();
                    break;
                }
                case operation::MOVE: {
                    move_op(self, arg);
                    break;
                }
            }
        }
    };

    template <typename T>
    struct external_manage {
        NEFORCE_NODISCARD static reflect::type_id type_id_val() noexcept { return type_id_for<T>(); }
 
        template <typename... Args>
        static void create(storage_internal& storage, Args&&... args) {
            storage.ptr_ = new T(_NEFORCE forward<Args>(args)...);
        }
 
        static T* access(const storage_internal& storage) noexcept { return static_cast<T*>(storage.ptr_); }
 
        template <typename U = T, enable_if_t<is_copy_constructible_v<U>, int> = 0>
        static void copy_op(const meta_any* self, arg_t* arg) {
            auto* ptr = access(self->storage_);
            create(arg->any_ptr_->storage_, *ptr);
            arg->any_ptr_->manage_ = &manage;
            arg->any_ptr_->type_id_ = type_id_val();
        }
 
        template <typename U = T, enable_if_t<!is_copy_constructible_v<U>, int> = 0>
        static void copy_op(const meta_any* /*unused*/, arg_t* /*unused*/) {}
 
        static void manage(const operation op, const meta_any* self, arg_t* arg) {
            auto* ptr = access(self->storage_);
            switch (op) {
                case operation::ACCESS: {
                    arg->obj_ptr_ = static_cast<void*>(ptr);
                    break;
                }
                case operation::GET_TYPE_ID: {
                    arg->type_id_val_ = type_id_val();
                    break;
                }
                case operation::COPY: {
                    copy_op(self, arg);
                    break;
                }
                case operation::DESTROY: {
                    delete ptr;
                    break;
                }
                case operation::MOVE: {
                    arg->any_ptr_->storage_.ptr_ = self->storage_.ptr_;
                    arg->any_ptr_->manage_ = &manage;
                    arg->any_ptr_->type_id_ = type_id_val();
                    break;
                }
            }
        }
    };

    template <typename T>
    struct use_internal_storage : bool_constant<is_nothrow_move_constructible_v<T> && sizeof(T) <= SBO_SIZE &&
                                                alignof(T) <= alignof(storage_internal)> {};
 
    template <typename T>
    using manage_t = conditional_t<use_internal_storage<T>::value, internal_manage<T>, external_manage<T>>;
 
    manage_func manage_ = nullptr; 
    storage_internal storage_;     
    reflect::type_id type_id_ = 0; 
 
    void reset_internal() noexcept {
        if (manage_ != nullptr) {
            manage_(operation::DESTROY, this, nullptr);
            manage_ = nullptr;
        }
        type_id_ = 0;
    }
 
    template <typename T, typename... Args, typename Manager = manage_t<decay_t<T>>>
    void emplace_impl(Args&&... args) {
        reset_internal();
        Manager::create(storage_, _NEFORCE forward<Args>(args)...);
        manage_ = &Manager::manage;
        type_id_ = Manager::type_id_val();
    }
 
public:
    meta_any() noexcept = default;

    template <typename T, typename DecayT = decay_t<T>, typename = enable_if_t<!is_same_v<DecayT, meta_any>>,
              typename = enable_if_t<is_copy_constructible_v<DecayT>>>
    meta_any(T&& value) {
        emplace_impl<T>(_NEFORCE forward<T>(value));
    }

    template <typename T, typename... Args>
    void emplace(Args&&... args) {
        emplace_impl<T>(_NEFORCE forward<Args>(args)...);
    }

    meta_any(const meta_any& other) {
        if (other.manage_ != nullptr) {
            arg_t arg;
            arg.any_ptr_ = this;
            other.manage_(operation::COPY, &other, &arg);
        }
    }

    meta_any(meta_any&& other) noexcept {
        if (other.manage_ != nullptr) {
            arg_t arg;
            arg.any_ptr_ = this;
            other.manage_(operation::MOVE, &other, &arg);
            other.manage_ = nullptr;
            other.type_id_ = 0;
        }
    }

    ~meta_any() { reset_internal(); }

    meta_any& operator=(const meta_any& other) {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        reset_internal();
        if (other.manage_ != nullptr) {
            arg_t arg;
            arg.any_ptr_ = this;
            other.manage_(operation::COPY, &other, &arg);
        }
        return *this;
    }

    meta_any& operator=(meta_any&& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        reset_internal();
        if (other.manage_ != nullptr) {
            arg_t arg;
            arg.any_ptr_ = this;
            other.manage_(operation::MOVE, &other, &arg);
            other.manage_ = nullptr;
            other.type_id_ = 0;
        }
        return *this;
    }

    NEFORCE_NODISCARD reflect::type_id type_id() const noexcept { return type_id_; }

    NEFORCE_NODISCARD bool has_value() const noexcept { return manage_ != nullptr; }

    explicit operator bool() const noexcept { return has_value(); }

    template <typename T>
    NEFORCE_NODISCARD T* cast() noexcept {
        if (!manage_ || type_id_ != type_id_for<T>()) {
            return nullptr;
        }
        arg_t arg;
        manage_(operation::ACCESS, this, &arg);
        return static_cast<T*>(arg.obj_ptr_);
    }

    template <typename T>
    NEFORCE_NODISCARD const T* cast() const noexcept {
        if (!manage_ || type_id_ != type_id_for<T>()) {
            return nullptr;
        }
        arg_t arg;
        manage_(operation::ACCESS, this, &arg);
        return static_cast<const T*>(arg.obj_ptr_);
    }

    template <typename T>
    NEFORCE_NODISCARD T& get() {
        if (auto* ptr = cast<T>()) {
            return *ptr;
        }
        NEFORCE_THROW_EXCEPTION(typecast_exception("Not a valid type"));
        unreachable();
    }

    template <typename T>
    NEFORCE_NODISCARD const T& get() const {
        if (auto* ptr = cast<T>()) {
            return *ptr;
        }
        NEFORCE_THROW_EXCEPTION(typecast_exception("Not a valid type"));
        unreachable();
    }

    template <typename T>
    NEFORCE_NODISCARD bool can_cast() const noexcept {
        return cast<T>() != nullptr;
    }

    template <typename T>
    NEFORCE_NODISCARD T convert() const {
        if (auto* ptr = cast<T>()) {
            return *ptr;
        }
        NEFORCE_THROW_EXCEPTION(typecast_exception("Not a valid type"));
        unreachable();
    }

    NEFORCE_NODISCARD void* raw() noexcept {
        if (manage_ == nullptr) {
            return nullptr;
        }
        arg_t arg;
        manage_(operation::ACCESS, this, &arg);
        return arg.obj_ptr_;
    }

    NEFORCE_NODISCARD const void* raw() const noexcept {
        if (manage_ == nullptr) {
            return nullptr;
        }
        arg_t arg;
        manage_(operation::ACCESS, this, &arg);
        return arg.obj_ptr_;
    }

    void reset() noexcept { reset_internal(); }

    void swap(meta_any& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return;
        }
        meta_any tmp(_NEFORCE move(*this));
        *this = _NEFORCE move(other);
        other = _NEFORCE move(tmp);
    }
};

inline void swap(meta_any& lhs, meta_any& rhs) noexcept { lhs.swap(rhs); }
 // Reflection
 
NEFORCE_END_REFLECT__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_REFLECT_ANY_HPP__