Any.h

Go to the documentation of this file.

//-
// =============================================================================
// Copyright 2025 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// =============================================================================
//+
 
 
#ifndef AMINO_ANY_H
#define AMINO_ANY_H
 
//==============================================================================
// EXTERNAL DECLARATIONS
//==============================================================================
 
#include "internal/AnyImpl.h"
 
namespace Amino {
class StringView;
 
//==============================================================================
// CLASS AnyPayloadTraits
//==============================================================================
 
class AnyPayloadTraits {
private:
    template <typename T>
    struct is_amino_array : std::false_type {};
    template <typename T>
    struct is_amino_array<Amino::Array<T>> : std::true_type {};
 
    template <bool Bool>
    using bool_t = std::integral_constant<bool, Bool>;
 
public:
    template <typename ValueType, typename T = std::decay_t<ValueType>>
    using is_cast_enabled = bool_t<(
        // The payload must not be an Any.
        !std::is_same<Any, T>::value &&
 
        // The payload should not be an Amino::Array directly.
        // Need to be wrapped in an Amino::Ptr (i.e. Ptr<Array<T>>).
        !is_amino_array<T>::value &&
 
        // Must not be Amino::StringView.
        // This is almost certainly a programming error since StringView
        // is not value semantics. Most likely need to store a String instead.
        !std::is_same<Amino::StringView, T>::value &&
 
        // Must not be raw pointer type.
        !std::is_pointer<T>::value &&
 
        // Must not be raw array type.
        !std::is_array<ValueType>::value &&
        !std::is_array<std::remove_reference_t<ValueType>>::value)>;
 
    template <typename ValueType, typename T = std::decay_t<ValueType>>
    using is_valid = bool_t<(
        // The type must be queriable
        is_cast_enabled<ValueType>::value &&
 
        // Must be copy constructible (to allow copying
        // the Any with such payload).
        std::is_copy_constructible<T>::value &&
 
        // Must be standard layout.
        std::is_standard_layout<T>::value)>;
 
    template <typename ValueType>
    using enable_if_valid = std::enable_if_t<is_valid<ValueType>::value>;
 
    template <typename ValueType, typename... Args>
    using enable_if_constructible = std::enable_if_t<
        std::is_constructible<std::decay_t<ValueType>, Args...>::value>;
};
 
//==============================================================================
// CLASS Any
//==============================================================================
 
//------------------------------------------------------------------------------
class Any : private Internal::AnyImpl::AnyUntyped {
    using Base   = Internal::AnyImpl::AnyUntyped;
    using Traits = AnyPayloadTraits;
 
public:
    Any() noexcept = default;
 
    Any(Any const& other) = default;
 
    Any(Any&& other) noexcept = default;
 
    template <typename ValueType, typename = Traits::enable_if_valid<ValueType>>
    explicit Any(ValueType&& v) noexcept : Base(std::forward<ValueType>(v)) {}
 
    ~Any() = default;
 
    Any& operator=(Any const& rhs) = default;
 
    Any& operator=(Any&& rhs) noexcept = default;
 
    template <typename ValueType, typename = Traits::enable_if_valid<ValueType>>
    Any& operator=(ValueType&& rhs) & noexcept {
        Any(std::forward<ValueType>(rhs)).swap(*this);
        return *this;
    }
 
    template <
        typename ValueType,
        typename... Args,
        typename = Traits::enable_if_valid<ValueType>,
        typename = Traits::enable_if_constructible<ValueType, Args...>>
    void emplace(Args&&... args) noexcept {
        Base::emplace<ValueType>(std::forward<Args>(args)...);
    }
 
    template <
        typename ValueType,
        typename Up,
        typename... Args,
        typename IL = std::initializer_list<Up>,
        typename    = Traits::enable_if_valid<ValueType>,
        typename    = Traits::enable_if_constructible<ValueType, IL&, Args...>>
    void emplace(std::initializer_list<Up> il, Args&&... args) noexcept {
        Base::emplace<ValueType>(il, std::forward<Args>(args)...);
    }
 
    void reset() noexcept { Base::reset(); }
 
    Any& swap(Any& rhs) noexcept {
        Base::swap(*this, rhs);
        return rhs;
    }
 
    bool has_value() const noexcept { return Base::has_value(); }
 
    AMINO_INTERNAL_DEPRECATED("Use any.type() == other.type() instead.")
    bool has_same_type(Any const& other) const noexcept {
        return type() == other.type();
    }
 
    TypeId type() const noexcept { return Base::type(); }
 
private:
    friend Internal::RuntimeAny;
    friend Internal::AnyCast;
};
 
//------------------------------------------------------------------------------
//
// enforce expected layout, size and alignment of Amino::Any
static_assert(
    std::is_standard_layout<Any>::value,
    "Amino::Any must be standard layout. ");
static_assert(
    sizeof(Any) == Internal::AnyTraits::sBufferSize + sizeof(void*),
    "Incorrect Amino::Any size");
static_assert(
    alignof(Any) == Internal::AnyTraits::sBufferAlign,
    "Incorrect Amino::Any alignment");
 
//==============================================================================
// NON MEMBER FUNCTIONS
//==============================================================================
 
//------------------------------------------------------------------------------
//
inline void swap(Any& lhs, Any& rhs) noexcept { lhs.swap(rhs); }
 
//==============================================================================
// ANY CAST FUNCTIONS
//==============================================================================
 
//------------------------------------------------------------------------------
//
template <
    class ValueType,
    typename = std::enable_if_t<!std::is_same<void, ValueType>::value>>
inline std::add_pointer_t<std::add_const_t<ValueType>> any_cast(
    Any const* v) noexcept {
    static_assert(
        AnyPayloadTraits::is_cast_enabled<ValueType>::value,
        "ValueType must be a valid payload type");
    if (!v) return nullptr; // assert?
    return Internal::AnyCast::cast<ValueType>(v);
}
 
//------------------------------------------------------------------------------
//
template <
    class ValueType,
    typename = std::enable_if_t<!std::is_same<void, ValueType>::value>>
inline std::add_pointer_t<ValueType> any_cast(Any* v) noexcept {
    static_assert(
        AnyPayloadTraits::is_cast_enabled<ValueType>::value,
        "ValueType must be a valid payload type");
    if (!v) return nullptr; // assert?
    return Internal::AnyCast::cast<ValueType>(v);
}
 
//------------------------------------------------------------------------------
//
template <
    class ValueType,
    typename = std::enable_if_t<std::is_same<void, ValueType>::value>>
AMINO_INTERNAL_DEPRECATED("Use any_cast<ValueType> instead.")
inline void const* any_cast(Any const* v) noexcept {
    if (!v) return nullptr; // assert?
    return Internal::AnyCast::cast<void>(v);
}
 
//------------------------------------------------------------------------------
//
template <typename ValueType>
inline ValueType any_cast(Any const& v) noexcept {
    static_assert(
        AnyPayloadTraits::is_valid<ValueType>::value,
        "ValueType must be a valid payload type");
    using Tp = std::add_const_t<std::remove_reference_t<ValueType>>;
    Tp* tmp  = any_cast<Tp>(&v);
    return tmp ? *tmp : ValueType();
}
 
//------------------------------------------------------------------------------
//
template <typename ValueType>
inline ValueType any_cast(Any&& v) noexcept {
    static_assert(
        AnyPayloadTraits::is_valid<ValueType>::value,
        "ValueType must be a valid payload type");
    using Tp = std::add_const_t<std::remove_reference_t<ValueType>>;
    Any any{std::move(v)};
    Tp* tmp = any_cast<Tp>(&any);
    return tmp ? std::move(*tmp) : ValueType();
}
 
} // namespace Amino
 
#endif