utility/any.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_UTILITY_ANY_HPP__
#define NEFORCE_CORE_UTILITY_ANY_HPP__

 
#include <initializer_list>
#include <typeinfo>
#include "NeForce/core/exception/breakpoint.hpp"
#include "NeForce/core/exception/exception.hpp"
NEFORCE_BEGIN_NAMESPACE__
 
class NEFORCE_API any;

 
NEFORCE_BEGIN_INNER__
 
struct any_cast_true_tag {};
struct any_cast_false_tag {};

template <typename T, typename U>
const T* __any_cast_aux_dispatch_impl(const _NEFORCE any* value, any_cast_true_tag /*unused*/) noexcept;
 
NEFORCE_END_INNER__


struct anycast_exception final : typecast_exception {
    explicit anycast_exception(const char* info = "Cast From any Type Failed.", const char* type = static_type,
                               const int code = 0) noexcept :
    typecast_exception(info, type, code) {}
 
    explicit anycast_exception(const exception& e) :
    typecast_exception(e) {}
 
    ~anycast_exception() override = default;
 
    static constexpr auto static_type = "anycast_exception";
};
 // Exceptions


class NEFORCE_API any {
    union storage_internal {
        storage_internal() = default;
        storage_internal(const storage_internal&) = delete;
        storage_internal& operator=(const storage_internal&) = delete;
 
        void* ptr_ = nullptr;                                    
        aligned_storage_t<sizeof(ptr_), alignof(void*)> buffer_; 
    };

    enum any_operation {
        ACCESS,        
        GET_TYPE_INFO, 
        COPY,          
        DESTROY,       
        SWAP           
    };

    union ArgT {
        void* obj_ptr_;                  
        const std::type_info* type_ptr_; 
        any* any_ptr_;                   
    };

    template <typename T>
    struct internal_manage {
        static void manage(any_operation op, const any* value, ArgT* arg);

        template <typename... Args>
        static void create(storage_internal& storage, Args&&... args) {
            void* ptr = &storage.buffer_;
            new (ptr) T(_NEFORCE forward<Args>(args)...);
        }

        static T* access(const storage_internal& storage) {
            const void* ptr = &storage.buffer_;
            return static_cast<T*>(const_cast<void*>(ptr));
        }
    };

    template <typename T>
    struct external_manage {
        static void manage(any_operation op, const any* value, ArgT* arg);

        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) { return static_cast<T*>(storage.ptr_); }
    };

    template <typename T>
    using manage_t = conditional_t<is_nothrow_move_constructible_v<T> && sizeof(T) <= sizeof(storage_internal) &&
                                           alignof(T) <= alignof(storage_internal),
                                   internal_manage<T>, external_manage<T>>;
 
    using manage_func = void (*)(any_operation, const any*, ArgT*); 
 
    manage_func manage_ = nullptr; 
    storage_internal storage_;     
 
    template <typename T, typename U>
    friend const T* inner::__any_cast_aux_dispatch_impl(const any* value, inner::any_cast_true_tag /*unused*/) noexcept;

    template <typename T, typename... Args, typename Manager = manage_t<T>>
    void try_emplace(Args&&... args) {
        any::reset();
        Manager::create(storage_, _NEFORCE forward<Args>(args)...);
        manage_ = &Manager::manage;
    }

    template <typename T, typename U, typename... Args, typename Manager = manage_t<T>>
    void try_emplace(std::initializer_list<U> ilist, Args&&... args) {
        any::reset();
        Manager::create(storage_, ilist, _NEFORCE forward<Args>(args)...);
        manage_ = &Manager::manage;
    }
 
public:
    any() noexcept = default;

    any(const any& other);

    any& operator=(const any& other) {
        *this = any(other);
        return *this;
    }

    any(any&& other) noexcept;

    any& operator=(any&& other) noexcept;

    template <typename T, typename VT = decay_t<T>, typename Manager = manage_t<VT>,
              enable_if_t<is_copy_constructible_v<VT> && !is_same_v<inplace_construct_tag, VT> && !is_same_v<VT, any>,
                          int> = 0>
    explicit any(T&& value) :
    manage_(&Manager::manage) {
        Manager::create(storage_, _NEFORCE forward<T>(value));
    }

    template <typename T, typename VT = decay_t<T>,
              enable_if_t<!is_same_v<VT, any> && is_copy_constructible_v<VT>, int> = 0>
    any& operator=(T&& value) {
        *this = any(_NEFORCE forward<T>(value));
        return *this;
    }

    template <typename T, typename... Args, typename VT = decay_t<T>, typename Manager = manage_t<VT>,
              enable_if_t<conjunction_v<is_copy_constructible<VT>, is_constructible<VT, Args&&...>>, int> = 0>
    explicit any(pass_template_construct_tag<T> /*unused*/, Args&&... args) :
    manage_(&Manager::manage) {
        Manager::create(storage_, _NEFORCE forward<Args>(args)...);
    }
 
    template <typename T, typename U, typename... Args, typename VT = decay_t<T>, typename Manager = manage_t<VT>,
              enable_if_t<conjunction_v<is_copy_constructible<VT>,
                                        is_constructible<VT, std::initializer_list<U>&, Args&&...>>,
                          int> = 0>
    explicit any(pass_template_construct_tag<T> /*unused*/, std::initializer_list<U> ilist, Args&&... args) :
    manage_(&Manager::manage) {
        Manager::create(storage_, ilist, _NEFORCE forward<Args>(args)...);
    }

    ~any() { reset(); }

    template <typename T, typename... Args, typename DT = decay_t<T>,
              enable_if_t<conjunction_v<is_copy_constructible<DT>, is_constructible<DT, Args&&...>>, int> = 0>
    DT& emplace(Args&&... args) {
        any::try_emplace<DT>(_NEFORCE forward<Args>(args)...);
        return *manage_t<DT>::access(storage_);
    }

    template <typename T, typename U, typename... Args, typename DT = decay_t<T>,
              enable_if_t<conjunction_v<is_copy_constructible<DT>,
                                        is_constructible<DT, std::initializer_list<U>&, Args&&...>>,
                          int> = 0>
    DT& emplace(std::initializer_list<U> ilist, Args&&... args) {
        any::try_emplace<DT, U>(ilist, _NEFORCE forward<Args>(args)...);
        return *manage_t<DT>::access(storage_);
    }

    void reset() noexcept {
        if (has_value()) {
            manage_(DESTROY, this, nullptr);
            manage_ = nullptr;
        }
    }

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

    NEFORCE_NODISCARD const std::type_info& type() const noexcept;

    void swap(any& rhs) noexcept;
};

template <typename T, typename... Args,
          enable_if_t<is_constructible_v<any, pass_template_construct_tag<T>, Args...>, int> = 0>
any make_any(Args&&... args) {
    return any(pass_template_construct_tag<T>{}, _NEFORCE forward<Args>(args)...);
}

NEFORCE_BEGIN_INNER__
 
template <typename T, typename U>
const T* __any_cast_aux_dispatch_impl(const any* value, any_cast_true_tag /*unused*/) noexcept {
    if (value->manage_ == &any::manage_t<U>::manage) {
        return static_cast<const T*>(any::manage_t<U>::access(value->storage_));
    }
    return nullptr;
}
 
template <typename T, typename U>
const T* __any_cast_aux_dispatch_impl(const any* /*unused*/, any_cast_false_tag /*unused*/) noexcept {
    return nullptr;
}
 
template <typename T, typename U>
const T* __any_cast_aux_dispatch(const any* value) noexcept {
    using tag = conditional_t<(is_same_v<decay_t<U>, U> || is_copy_constructible_v<U>), any_cast_true_tag,
                              any_cast_false_tag>;
    return inner::__any_cast_aux_dispatch_impl<T, U>(value, tag{});
}
 
template <typename T, enable_if_t<is_object_v<T>, int> = 0>
const T* __any_cast_aux(const any* value) noexcept {
    if (value) {
        return __any_cast_aux_dispatch<T, remove_cv_t<T>>(value);
    }
    return nullptr;
}
 
template <typename T, enable_if_t<!is_object_v<T>, int> = 0>
const T* __any_cast_aux(const any* /*unused*/) noexcept {
    return nullptr;
}
 
NEFORCE_END_INNER__

template <typename T>
const T* any_cast(const any* value) noexcept {
    return inner::__any_cast_aux<T>(value);
}

template <typename T>
T* any_cast(any* value) noexcept {
    return const_cast<T*>(any_cast<T>(const_cast<const any*>(value)));
}

template <typename T>
T any_cast(const any& value) {
    using U = remove_cvref_t<T>;
    static_assert(disjunction_v<is_reference<T>, is_copy_constructible<T>, is_constructible<T, const U&>>,
                  "type T must be valid to cast from any.");
 
    auto ptr = any_cast<U>(&value);
    if (ptr != nullptr) {
        return static_cast<T>(*ptr);
    }
    NEFORCE_THROW_EXCEPTION(anycast_exception());
    unreachable();
}
 

 
template <typename T>
void any::internal_manage<T>::manage(const any_operation op, const any* value, ArgT* arg) {
    auto ptr = reinterpret_cast<const T*>(&value->storage_.buffer_);
    switch (op) {
        case ACCESS: {
            arg->obj_ptr_ = const_cast<T*>(ptr);
            break;
        }
        case GET_TYPE_INFO: {
            arg->type_ptr_ = &typeid(T);
            break;
        }
        case COPY: {
            ::new (&arg->any_ptr_->storage_.buffer_) T(*ptr);
            arg->any_ptr_->manage_ = value->manage_;
            break;
        }
        case DESTROY: {
            ptr->~T();
            break;
        }
        case SWAP: {
            ::new (&arg->any_ptr_->storage_.buffer_) T(_NEFORCE move(*const_cast<T*>(ptr)));
            ptr->~T();
            arg->any_ptr_->manage_ = value->manage_;
            const_cast<any*>(value)->manage_ = nullptr;
            break;
        }
        default: {
            unreachable();
        }
    }
}
 
template <typename T>
void any::external_manage<T>::manage(const any_operation op, const any* value, ArgT* arg) {
    auto ptr = static_cast<const T*>(value->storage_.ptr_);
    switch (op) {
        case ACCESS: {
            arg->obj_ptr_ = const_cast<T*>(ptr);
            break;
        }
        case GET_TYPE_INFO: {
            arg->type_ptr_ = &typeid(T);
            break;
        }
        case COPY: {
            arg->any_ptr_->storage_.ptr_ = ::new T(*ptr);
            arg->any_ptr_->manage_ = value->manage_;
            break;
        }
        case DESTROY: {
            delete ptr;
            break;
        }
        case SWAP: {
            arg->any_ptr_->storage_.ptr_ = value->storage_.ptr_;
            arg->any_ptr_->manage_ = value->manage_;
            const_cast<any*>(value)->manage_ = nullptr;
            break;
        }
        default: {
            unreachable();
        }
    }
}

 // Any
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_UTILITY_ANY_HPP__