Any.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include <cstddef>
#include <new>
#include <type_traits>
#include <typeinfo>
#include <utility>
 
AST_NAMESPACE_BEGIN
 
// Any 是重度模板/类型擦除的运行时容器（含 SFINAE 构造），SWIG 无法解析其签名，
#ifndef SWIG
 
class bad_any_cast : public std::bad_cast
{
public:
    const char* what() const noexcept override
    {
        return "bad_any_cast";
    }
};
 
 
class Any
{
public:
    // ============================================================
    // 构造 / 析构
    // ============================================================
 
    Any() noexcept = default;
 
    Any(const Any& other)
    {
        copyFrom(other);
    }
 
    Any(Any&& other) noexcept
    {
        stealFrom(other);
    }
 
    ~Any() { reset(); }
 
    template<typename ValueType,
        typename D = typename std::decay<ValueType>::type,
        typename std::enable_if<!std::is_same<D, Any>::value &&
                                std::is_copy_constructible<D>::value, int>::type = 0>
    Any(ValueType&& value)
    {
        emplace<D>(std::forward<ValueType>(value));
    }
 
    // ============================================================
    // 赋值
    // ============================================================
 
    Any& operator=(const Any& other)
    {
        if (this != &other)
        {
            Any tmp(other);
            swap(tmp);
        }
        return *this;
    }
 
    Any& operator=(Any&& other) noexcept
    {
        if (this != &other)
        {
            reset();
            stealFrom(other);
        }
        return *this;
    }
 
    template<typename ValueType,
        typename D = typename std::decay<ValueType>::type,
        typename std::enable_if<!std::is_same<D, Any>::value &&
                                std::is_copy_constructible<D>::value, int>::type = 0>
    Any& operator=(ValueType&& value)
    {
        emplace<D>(std::forward<ValueType>(value));
        return *this;
    }
 
    // ============================================================
    // 观察
    // ============================================================
 
    bool has_value() const noexcept { return data_ != nullptr; }
 
    const std::type_info& type() const noexcept
    {
        return data_ ? *ops_->type : typeid(void);
    }
 
    // ============================================================
    // 修改
    // ============================================================
 
    void reset() noexcept
    {
        if (data_)
        {
            ops_->destroy(data_);
            ::operator delete(data_);
            data_ = nullptr;
            ops_  = nullptr;
        }
    }
 
    template<typename T, typename... Args>
    typename std::enable_if<!std::is_reference<T>::value, T&>::type
    emplace(Args&&... args)
    {
        reset();
        void* storage = ::operator new(sizeof(T));
        try
        {
            ::new (storage) T(std::forward<Args>(args)...);
        }
        catch (...)
        {
            ::operator delete(storage);
            throw;
        }
        ops_  = &opsFor<T>();
        data_ = storage;
        return *static_cast<T*>(data_);
    }
 
    void swap(Any& other) noexcept
    {
        std::swap(ops_, other.ops_);
        std::swap(data_, other.data_);
    }
 
private:
    // ---- 类型擦除操作表 ----
    struct TypeOps
    {
        void (*destroy)(void*);                       
        void (*copyConstruct)(void* dst, const void* src);  
        const std::type_info* type;                   
        size_t size;                                  
    };
 
    template<typename T>
    static const TypeOps& opsFor()
    {
        static const TypeOps ops = {
            [](void* p) { static_cast<T*>(p)->~T(); },
            [](void* dst, const void* src) { ::new (dst) T(*static_cast<const T*>(src)); },
            &typeid(T),
            sizeof(T),
        };
        return ops;
    }
 
    void copyFrom(const Any& other)
    {
        if (!other.data_)
            return;
        void* storage = ::operator new(other.ops_->size);
        try
        {
            other.ops_->copyConstruct(storage, other.data_);
        }
        catch (...)
        {
            ::operator delete(storage);
            throw;
        }
        ops_  = other.ops_;
        data_ = storage;
    }
 
    void stealFrom(Any& other) noexcept
    {
        ops_  = other.ops_;
        data_ = other.data_;
        other.ops_  = nullptr;
        other.data_ = nullptr;
    }
 
    // ---- 成员 ----
    const TypeOps* ops_{nullptr};    
    void*          data_{nullptr};   
 
    // 允许 any_cast 家族访问私有数据
    template<typename T> friend const T* any_cast(const Any*) noexcept;
    template<typename T> friend T* any_cast(Any*) noexcept;
    template<typename T> friend T any_cast(const Any&);
    template<typename T> friend T any_cast(Any&);
    template<typename T> friend T any_cast(Any&&);
};
 
 
// ================================================================
// any_cast — 类型安全的取回
// ================================================================
 
template<typename T>
inline const T* any_cast(const Any* operand) noexcept
{
    using U = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
    if (operand && operand->type() == typeid(U))
        return static_cast<const T*>(operand->data_);
    return nullptr;
}
 
template<typename T>
inline T* any_cast(Any* operand) noexcept
{
    using U = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
    if (operand && operand->type() == typeid(U))
        return static_cast<T*>(operand->data_);
    return nullptr;
}
 
template<typename T>
inline T any_cast(const Any& operand)
{
    using U = typename std::decay<T>::type;
    const U* p = any_cast<U>(&operand);
    if (!p)
        throw bad_any_cast();
    return *p;
}
 
template<typename T>
inline T any_cast(Any& operand)
{
    using U = typename std::decay<T>::type;
    U* p = any_cast<U>(&operand);
    if (!p)
        throw bad_any_cast();
    return *p;
}
 
template<typename T>
inline T any_cast(Any&& operand)
{
    using U = typename std::decay<T>::type;
    U* p = any_cast<U>(&operand);
    if (!p)
        throw bad_any_cast();
    return static_cast<U&&>(*p);
}
 
 
// ================================================================
// make_any — 便捷构造
// ================================================================
 
template<typename T, typename... Args>
inline Any make_any(Args&&... args)
{
    Any a;
    a.emplace<T>(std::forward<Args>(args)...);
    return a;
}
 
#endif // SWIG
 
AST_NAMESPACE_END