Compiler Explorer

Source code

#pragma once

// clang-format off
// Any class with selectable features and small object optimization.
// N - is the maximum size of the small objects
// For the features, see the README.md files.
// clang-format on

#include <algorithm>
#include <any>
#include <cstdint>
#include <cstring>
#include <format>
#include <functional>
#include <initializer_list>
#include <iostream>
#include <memory>
#include <string>
#include <type_traits>
#include <typeindex>
#include <utility>

#include "type_name.h"

namespace ext {

static constexpr const bool rtti_available{
#if defined(_MSC_VER) || defined(_WIN32)
#if defined(_CPPRTTI)
#define ANY_RTTI_ON 1
    true
#else
#define ANY_RTTI_OFF 1
    false
#endif
#elif defined(__clang__)
#if __has_feature(cxx_rtti)
#define ANY_RTTI_ON 1
    true
#else
#define ANY_RTTI_OFF 1
    false
#endif
#elif defined(__GNUC__)
#if defined(__GXX_RTTI) && __GXX_RTTI != 0
#define ANY_RTTI_ON 1
    true
#else
#define ANY_RTTI_OFF 1
    false
#endif
#else
#error "unknown environment"
#endif
};

// clang-format off
// any_properties - The properties of an any<N,Fs...>. The Features based properties are gathered using inheritance.
// It includes the template parameters and values, type_id information, and the different operations.
// Basic function operations: typeid, type_name, clone, destroy, destruct, copy constructor, move constructor, copy assignment, move assignment,
// and the extra operation and properties from the Features
// clang-format on

// forward declarations.
template<size_t N, template<typename> class... Features>
class any;
template<typename T, typename A>
class any_properties_t_data_type;

template<typename T>
struct is_an_any; // true_type for all any<N, ...> types, false_type otherwise.
template<typename T>
constexpr bool is_an_any_v{is_an_any<T>::value};
template<typename T>
struct is_an_any : std::false_type
{
};
template<size_t N, template<typename> class... Features>
struct is_an_any<any<N, Features...>> : std::true_type
{
};

template<typename T>
constexpr size_t required_size()
{
 if constexpr (requires { T::min_required_size(); })
 {
 return T::min_required_size();
 }
 else
 {
 return 0;
 }
}

template<size_t N = 16, template<typename> class... Features>
class any final : public Features<any<N, Features...>>...
{
public:
 using A = any<N, Features...>;

constexpr static size_t storage_size() noexcept
 {
 if constexpr (sizeof...(Features) > 0)
 {
 return std::max({(size_t)N, required_size<Features<A>>()...});
 }
 return N;
 }

class alignas(64) any_properties final : public Features<A>::extend_properties...
 {
 public:
 bool _inplace_flag{false}; // Is SOO active for this type?
 bool _is_move_constructible{false};
 bool _is_copy_constructible{false};
#ifdef ANY_RTTI_ON
 const std::type_info* _type_info{&typeid(void)};
 std::type_index _type_index{std::type_index(typeid(void))};
#endif
 std::string_view _src_type_name{""};
 size_t _value_size{0};

void (*_destroy)(A&){nullptr};
        void (*_delete)(A&){nullptr};
        void (*_clone)(A&, const A&){nullptr};
        void (*_move)(A&, A&&){nullptr};
        void (*_assign_clone)(A&, const A&){nullptr};
        void (*_assign_move)(A&, void*){nullptr};

friend std::ostream& operator<<(std::ostream& os, const any_properties& prop)
 {
 // clang-format off
 return os << "\nAny: " << ext::src_type_name<A>()
 << "\n any::operations<>:" << (void *) &prop
 << "\n type name: " << prop._src_type_name
#ifdef ANY_RTTI_ON
 << "\n typeinfo name: " << prop._type_info->name()
 << "\n type_index hash: " << prop._type_index.hash_code() // std::type_index(prop._type_info)
#endif
 << "\n value size: " << prop._value_size
 << "\n inplace: " << prop._inplace_flag
 << "\n move constructible: " << prop._is_move_constructible
 << "\n copy constructible: " << prop._is_copy_constructible
 << "\n--\n";
 // clang-format on
 }
 };
 friend class any_properties;

public:
 template<typename T>
 T* get_pointer()
 {
 return reinterpret_cast<T*>(_pointer);
 }
 template<typename T>
 const T* get_pointer() const
 {
 return reinterpret_cast<const T*>(_pointer);
 }
 template<typename T>
 void set_pointer(T* value)
 {
 _pointer = reinterpret_cast<void*>(value);
 }

template<typename T>
 T& storage_inplace() noexcept
 {
 return *reinterpret_cast<T*>(&_storage);
 }
 template<typename T>
 const T& storage_inplace() const noexcept
 {
 return *reinterpret_cast<const T*>(&_storage);
 }

template<typename T>
 T& storage_dynamic() noexcept
 {
 return *reinterpret_cast<T*>(_pointer);
 }
 template<typename T>
 const T& storage_dynamic() const noexcept
 {
 return *reinterpret_cast<const T*>(_pointer);
 }

template<typename T>
 constexpr static bool is_inplace() noexcept
 {
 return sizeof(T) <= storage_size() && alignof(T) <= alignof(A);
 }

template<typename T>
 T& inplace_data() noexcept
 {
 static_assert(is_inplace<T>(), "Something is wrong");
 return *reinterpret_cast<T*>(&this->_storage);
 }

template<typename T>
 const T& inplace_data() const noexcept
 {
 static_assert(is_inplace<T>(), "Never use storage_inplace for too large types");
 return *reinterpret_cast<const T*>(&this->_storage);
 }

template<typename T>
 T& data() noexcept
 {
 if constexpr (is_inplace<T>())
 {
 return inplace_data<T>();
 }
 else
 {
 return storage_dynamic<T>();
 }
 }

template<typename T>
 const T& data() const noexcept
 {
 if constexpr (is_inplace<T>())
 {
 return inplace_data<T>();
 }
 else
 {
 return storage_dynamic<T>();
 }
 }

public:
    constexpr explicit any() noexcept
    {
        _properties = nullptr;
        clear_storage();
    }

constexpr any(const any& rhs)
    {
        if (rhs.has_value()) [[likely]]
        {
            _properties = rhs._properties;
            _properties->_clone(*this, rhs);
        }
        else
        {
            _properties = nullptr;
            clear_storage();
        }
    }

any(any&& rhs) noexcept
    {
        if (rhs.has_value()) [[likely]]
        {
            _properties = rhs._properties;
            _properties->_move(*this, std::move(rhs));
        }
        else
        {
            _properties = nullptr;
            clear_storage();
        }
    }

template<typename U,
 typename DU = std::enable_if_t<!std::is_same_v<A, std::remove_cvref_t>, std::remove_cvref_t>>
 constexpr any(const U& value)
 requires(!is_an_any_v && !is_an_any_v<std::remove_cvref_t>)
 {
 _properties = &any_properties_t_data_type<DU, A>::instance;
 if constexpr (is_inplace<DU>())
 {
 new (&inplace_data<DU>()) DU(value);
 }
 else
 {
 set_pointer<DU>(new DU(value));
 }
 }

template<typename U,
 typename DU = std::enable_if_t<!std::is_same_v<A, std::remove_cvref_t>, std::remove_cvref_t>>
 explicit constexpr any(U&& value)
 requires(!is_an_any_v && !is_an_any_v<std::remove_cvref_t>)
 {
 _properties = &any_properties_t_data_type<DU, A>::instance;
 if constexpr (is_inplace<DU>())
 {
 new (&inplace_data<DU>()) DU(std::forward(value));
 }
 else
 {
 set_pointer<DU>(new DU(std::forward(value)));
 }
 }

// #5 https://en.cppreference.com/w/cpp/utility/any/any
 template<class T, class... Args>
 explicit any(std::in_place_type_t<T>, Args&&... args)
 requires(!is_an_any_v<std::decay_t<T>> && !is_an_any_v<std::remove_cvref_t<T>> &&
 std::is_constructible_v<std::decay_t<T>, Args...> && std::is_copy_constructible_v<std::decay_t<T>>)
 {
 using DT = std::decay_t<T>;
 _properties = &any_properties_t_data_type<DT, A>::instance;
 if constexpr (is_inplace<DT>())
 {
 new (&inplace_data<DT>()) DT(std::forward<Args>(args)...);
 }
 else
 {
 set_pointer<DT>(new DT(std::forward<Args>(args)...));
 }
 }

// #6 https://en.cppreference.com/w/cpp/utility/any/any
 template<class T, class U, class... Args>
 explicit any(std::in_place_type_t<T>, std::initializer_list il, Args&&... args)
 requires(!is_an_any_v<std::decay_t<T>> && !is_an_any_v<std::remove_cvref_t<T>> &&
 std::is_constructible_v<std::decay_t<T>, std::initializer_list&, Args...> &&
 std::is_copy_constructible_v<std::decay_t<T>>)
 {
 using DT = std::decay_t<T>;
 _properties = &any_properties_t_data_type<DT, A>::instance;
 if constexpr (is_inplace<DT>())
 {
 new (&inplace_data<DT>()) DT(il, std::forward<Args>(args)...);
 }
 else
 {
 set_pointer<DT>(new DT(il, std::forward<Args>(args)...));
 }
 }

any& operator=(const any& rhs)
    {
        if (this == &rhs) [[unlikely]]
            return *this;

if (rhs.has_value()) [[likely]]
        {
            if (has_value() && _properties == rhs._properties)
            {
                _properties->_assign_clone(*this, rhs);
            }
            else
            {
                reset();
                _properties = rhs._properties;
                _properties->_clone(*this, rhs);
            }
        }
        else
        {
            reset();
        }
        return *this;
    }

any& operator=(any&& rhs) noexcept
    {
        if (this == &rhs) [[unlikely]]
            return *this;

if (!rhs.has_value()) [[unlikely]]
 {
 reset();
 return *this;
 }
 if (has_value())
 {
 if (_properties == rhs._properties)
 {
 _properties->_assign_move(*this, static_cast<void*>(&rhs));
 return *this;
 }
 reset();
 }
 _properties = rhs._properties;
 _properties->_move(*this, std::move(rhs));
 return *this;
 }

~any() { reset(); }

void clear_storage()
    {
        // not needed in release version.
        // memset(_storage, '\0', sizeof(_storage));
    }

void reset()
    {
        // _delete in case of inplace - is not releasing memory, only calling destructor of the element inside _storage.
        if (has_value())
        {
            _properties->_delete(*this);
        }
        _properties = nullptr;
        clear_storage();
    }

// FIXME: TODO: implement template for any<M> where M != N, with different features

template<typename U,
 typename DU = std::enable_if_t<!std::is_same_v<any<N>, std::remove_cvref_t>, std::remove_cvref_t>>
 constexpr any& operator=(U& value) // Check that it is / isn't an Any.
 {
 if (has_value() && _properties == &any_properties_t_data_type<DU, A>::instance) //->_type_info == typeid(DU))
 {
 _properties->_assign_clone(*this, value);
 return *this;
 }
 reset();
 _properties = &any_properties_t_data_type<DU, A>::instance;
 if constexpr (is_inplace<DU>())
 {
 inplace_data<DU>() = value;
 }
 else
 {
 set_pointer<DU>(new DU(value));
 }
 return *this;
 }

template<typename U, typename DU = std::enable_if_t<!std::is_same_v<any<N>, std::decay_t>, U>>
 constexpr any& operator=(U&& value)
 {
 if (has_value() && _properties == &any_properties_t_data_type<DU, A>::instance) //->_type_info == typeid(DU))
 {
 _properties->_assign_move(*this, static_cast<void*>(&value));
 return *this;
 }
 reset();
 _properties = &any_properties_t_data_type<DU, A>::instance;
 if constexpr (is_inplace<DU>())
 {
 new (&_storage) DU(std::forward(value));
 }
 else
 {
 set_pointer<DU>(new DU(std::forward(value)));
 }
 return *this;
 }

[[nodiscard]] constexpr bool inplace() const noexcept
    {  // return true if no stored value
        if (!has_value() || _properties->_inplace_flag) return true;
        return false;
    }
    constexpr static size_t in_place_capacity() noexcept { return storage_size(); }

[[nodiscard]] constexpr bool has_value() const noexcept { return nullptr != _properties; }

// Note: standard cast_any<T> returns T value, a copy of the content of A, while ext::any<> returns a T&
 // std::any_cast is returning T a copy of the stored item, the any_cast below returns T& to the stored item.

template<typename T>
 [[nodiscard]] constexpr friend T& any_cast(any& a)
 {
#ifdef ANY_RTTI_ON
 if (!a.has_value() || *a._properties->_type_info != typeid(T))
 {
 throw std::bad_any_cast{};
 }
#else
 if (!a.has_value() || a.properties() != &any_properties_t_data_type<std::decay_t<T>, A>::instance)
 {
 throw std::bad_any_cast{};
 }

#endif
 return a.data<T>();
 }

template<typename T>
 [[nodiscard]] constexpr friend const T& any_cast(const any& a)
 {
#ifdef ANY_RTTI_ON
 if (!a.has_value() || *a._properties->_type_info != typeid(T))
 {
 throw std::bad_any_cast{};
 }
#else
 if (!a.has_value() || a.properties() != &any_properties_t_data_type<std::decay_t<T>, A>::instance)
 {
 throw std::bad_any_cast{};
 }
#endif
 return a.data<T>();
 }
 // The following code does not work as the access to typeid is happening before the if constexpr.
 // Is it a compilers bug?
 // if constexpr (rtti_available)
 // {
 // if (!a.has_value() || *a._properties->_type_info != typeid(T))
 // {
 // throw std::bad_any_cast{};
 // }
 // }
 // else
 // {
 // if (!a.has_value() || a.properties() != &any_properties_t_data_type<std::decay_t<T>, A>::instance)
 // {
 // throw std::bad_any_cast{};
 // }
 // }
 // return a.data<T>();

template<typename T>
 [[nodiscard]] constexpr friend T* any_cast(any* ap)
 {
#ifdef ANY_RTTI_ON
 if (!ap->has_value() || *ap->_properties->_type_info != typeid(T))
 {
 return nullptr;
 }
#else
 if (!ap->has_value() || ap->properties() != &any_properties_t_data_type<std::decay_t<T>, A>::instance)
 {
 return nullptr;
 }
#endif
 // Nicer code, but does not compile :-)
 // if constexpr (rtti_available)
 // {
 // if (!ap->has_value() || *ap->_properties->_type_info != typeid(T)) return nullptr;
 // }
 // else
 // {
 // if (!ap->has_value() || ap->properties() != &any_properties_t_data_type<std::decay_t<T>,
 // A>::instance)
 // return nullptr;
 // }
 return &ap->data<T>();
 }

template<typename T>
 [[nodiscard]] constexpr friend const T* any_cast(const any* ap)
 {
#ifdef ANY_RTTI_ON
 if (!ap->has_value() || *ap->_properties->_type_info != typeid(T))
 {
 return nullptr;
 }
#else
 if (!ap->has_value() || ap->properties() != &any_properties_t_data_type<std::decay_t<T>, A>::instance)
 {
 return nullptr;
 }
#endif
 return &ap->data<T>();
 }

#ifdef ANY_RTTI_ON
    [[nodiscard]] constexpr const std::type_info& type() const noexcept
    {
        if (has_value()) return *_properties->_type_info;
        return typeid(void);
    }
#endif

template<typename T, typename... Arg>
 T& emplace(Arg&&... args)
 {
 using DT = std::decay_t<T>;
 reset();
 _properties = &any_properties_t_data_type<DT, A>::instance;
 if constexpr (is_inplace<DT>())
 {
 new (&_storage) DT{std::forward<Arg>(args)...};
 return inplace_data<DT>();
 }
 else
 {
 set_pointer<DT>(new DT{std::forward<Arg>(args)...});
 return storage_dynamic<DT>();
 }
 }

[[nodiscard]] std::string_view src_type_name() const
    {
        if (has_value()) return _properties->_src_type_name;
        return "empty";
    }

[[nodiscard]] size_t value_size() const
    {
        if (has_value()) return _properties->_value_size;
        return 0;
    }

explicit any(const char* p) : any(std::string{p}) {}

[[nodiscard]] constexpr const any_properties* properties() const noexcept { return _properties; }

private:
    const any_properties* _properties{nullptr};
    union
    {
        char  _storage[storage_size()];
        void* _pointer;
    };
    static_assert(sizeof(_storage) == storage_size(), "N is too small");
    static_assert(sizeof(_storage) >= sizeof(void*), "_storage size too small");

template<typename T, typename U>
 friend struct any_properties_t_data_type;
};

static_assert(sizeof(any<8>) == 8 + 8, "wrong storage for any");
static_assert(sizeof(any<16>) == 16 + 8, "wrong storage for any");
static_assert(sizeof(any<24>) == 24 + 8, "wrong storage for any");
static_assert(sizeof(any<32>) == 32 + 8, "wrong storage for any");

template<typename T, size_t N, template<typename> class... Features>
struct any_properties_t_data_type<T, any<N, Features...>> final
{
 using A = any<N, Features...>;

public:
 static inline const A::any_properties instance{[]() -> A::any_properties {
 typename A::any_properties properties{};
 properties._inplace_flag = A::template is_inplace<T>();
 properties._is_move_constructible = std::is_move_constructible_v<T>;
 properties._is_copy_constructible = std::is_copy_constructible_v<T>;
#ifdef ANY_RTTI_ON
 properties._type_info = &typeid(T);
 properties._type_index = std::type_index(typeid(T));
#endif
 properties._src_type_name = src_type_name<T>();
 properties._value_size = sizeof(T);

properties._destroy = +[](A& a) -> void {
 T* p = &a.template data<T>();
 p->T::~T();
 };
 properties._delete = +[](A& a) -> void {
 if constexpr (A::template is_inplace<T>())
 {
 (&a.template inplace_data<T>())->T::~T();
 }
 else
 {
 T* p{a.template get_pointer<T>()};
 delete p;
 a.template set_pointer<void>(nullptr);
 }
 };
 properties._clone = +[](A& a, const A& b) -> void {
 if constexpr (!std::is_move_constructible_v<T> || !std::is_copy_constructible_v<T>)
 {
 throw std::runtime_error("trying to clone non-copyable type");
 }
 else
 {
 if constexpr (A::template is_inplace<T>())
 {
 new (&a.template inplace_data<T>()) T(b.template inplace_data<T>());
 }
 else
 {
 const T* cp{b.template get_pointer<T>()};
 a.template set_pointer<T>(new T(*cp));
 }
 }
 };
 properties._move = +[](A& lhs, A&& rhs) -> void {
 if constexpr (A::template is_inplace<T>())
 {
 new (&lhs.template inplace_data<T>()) T(std::move(rhs.template inplace_data<T>()));
 }
 else
 {
 lhs._properties = rhs._properties;
 lhs.template set_pointer<T>(rhs.template get_pointer<T>());
 rhs.template set_pointer<void>(nullptr);
 rhs._properties = nullptr;
 }
 };
 properties._assign_clone = +[](A& a, const A& b) -> void {
 if constexpr (A::template is_inplace<T>())
 {
 a.template inplace_data<T>() = b.template inplace_data<T>();
 }
 else
 {
 auto& ap{*reinterpret_cast<T**>(&a._pointer)};
 auto& bp{*reinterpret_cast<T* const*>(&b._pointer)};
 *ap = *bp;
 }
 };
 properties._assign_move = +[](A& a, void* bvp) -> void {
 if constexpr (A::template is_inplace<T>())
 {
 a.template inplace_data<T>() = std::move(*reinterpret_cast<T*>(bvp));
 }
 else
 {
 auto ap{*reinterpret_cast<T**>(&a._pointer)};
 auto bp{reinterpret_cast<T*>(bvp)};
 *ap = std::move(*bp);
 }
 };
 (void)((Features<A>::template construct_extend_properties<T>(properties)), ...);
 return properties;
 }()};
};

// ====================================================== any_features.h
// Features - optional features for any<N, Features...>
// construct - on the objects themselves.
// properties_construct - once per-type when creating the instance of the properties.
template<typename T>
struct af_streamed;

template<size_t N, template<typename> class... Features> // A is the specific ext::any type.
struct af_streamed<any<N, Features...>>
{
 using A = any<N, Features...>;
 struct extend_properties
 {
 extend_properties() = default;
 std::ostream& (*_ostream)(std::ostream&, const A&){nullptr};
 };

template<typename T>
 static void construct_extend_properties(auto& prop)
 {
 prop._ostream = +[](std::ostream& os, const A& a) -> std::ostream& {
 if constexpr (requires(T t) { os << t; })
 {
 if (a.has_value())
 {
 const T& value{a.template data<T>()};
 return os << value;
 }
 }
 return os;
 };
 }

friend std::ostream& operator<<(std::ostream& os, const A& a)
 {
 if (a.has_value())
 {
 return a.properties()->_ostream(os, a);
 }
 return os;
 }
};

template<typename T>
struct af_strict_streamed;

template<size_t N, template<typename> class... Features>
struct af_strict_streamed<any<N, Features...>>
{
 using A = any<N, Features...>;
 struct extend_properties
 {
 std::ostream& (*_strict_ostream)(std::ostream&, const A&);
 };

template<typename T>
 static void construct_extend_properties(auto& prop)
 requires requires(T t) { std::cout << t; }
 {
 static_assert(requires(T t) { std::cout << t; }, "af_strict_streamed requires type supporting 'operator<< T{}");
 prop._strict_ostream = +[](std::ostream& os, const A& a) -> std::ostream& {
 if (a.has_value())
 {
 const T& value{a.template data<T>()};
 return os << value;
 }
 return os;
 };
 }

friend std::ostream& operator<<(std::ostream& os, const A& a)
 {
 if (a.has_value())
 {
 return a.properties()->_strict_ostream(os, a);
 }
 return os;
 }
};

template<typename T>
struct af_strict_less;

template<size_t N, template<typename> class... Features>
struct af_strict_less<any<N, Features...>>
{
 using A = any<N, Features...>;

struct extend_properties
    {
        bool (*_strict_less)(const A&, const A&){nullptr};
    };

template<typename T>
 static void construct_extend_properties(auto& prop)
 {
 static_assert(requires(T ta, T tb) { ta < tb; }, "af_strict_less requires type supporting 'a < b' compare");

prop._strict_less = +[](const A& a, const A& b) -> bool {
 const T& a_value{a.template data<T>()};
 const T& b_value{b.template data<T>()};
 return a_value < b_value;
 };
 }

friend bool operator<(const A& lhs, const A& rhs)
 {
 if (lhs.has_value() && rhs.has_value())
 {
 if (lhs.properties() == rhs.properties())
 {
 return lhs.properties()->_strict_less(lhs, rhs);
 }
 throw std::runtime_error("any operator less '<': with different types");
 }
 throw std::runtime_error("empty ext::any value in operator less '<'");
 }
};

template<typename T>
struct af_strict_eq;

template<size_t N, template<typename> class... Features>
struct af_strict_eq<any<N, Features...>>
{
 using A = any<N, Features...>;

struct extend_properties
    {
        bool (*_strict_eq)(const A&, const A&){nullptr};
    };

template<typename T>
 static void construct_extend_properties(auto& prop)
 {
 static_assert(requires(T ta, T tb) { ta == tb; }, "af_strict_eq requires type supporting 'a == b' compare");

prop._strict_eq = +[](const A& a, const A& b) -> bool {
 const T& a_value{a.template data<T>()};
 const T& b_value{b.template data<T>()};
 return a_value == b_value;
 };
 }

friend bool operator==(const A& lhs, const A& rhs)
    {
        if (lhs.has_value() && rhs.has_value())
        {
            if (lhs.properties() == rhs.properties())
            {
                return lhs.properties()->_strict_eq(lhs, rhs);
            }
            throw std::runtime_error("any operator eq '==': with different types");
        }
        throw std::runtime_error("empy ext::any in operator eq '=='");
    }
};

template<typename T>
struct af_strict_inplace;

template<size_t N, template<typename> class... Features>
struct af_strict_inplace<any<N, Features...>>
{
 using A = any<N, Features...>;

struct extend_properties
 {
 };
 template<typename T>
 static void construct_extend_properties(auto&)
 requires(A::template is_inplace<T>())
 {
 }
};

template<typename T>
struct af_strict_hash;

template<size_t N, template<typename> class... Features>
struct af_strict_hash<any<N, Features...>>
{
 using A = any<N, Features...>;

struct extend_properties
    {
        uint64_t (*_strict_hash)(const A&){nullptr};
    };

template<typename T>
 static void construct_extend_properties(auto& prop)
 {
 static_assert(requires(T ta) { std::hash<T>{}(ta); }, "af_strict_hash requires type supporting hash{}(a)");

prop._strict_hash = +[](const A& a) -> uint64_t {
 const T& value{a.template data<T>()};
 return std::hash<T>{}(value);
 };
 }

[[nodiscard]] size_t get_hash() const
 {
 auto self = static_cast<const A*>(this);
 if (!self->has_value())
 {
 throw std::runtime_error("hash on an empty ext::any");
 }
 return self->properties()->_strict_hash(*self);
 }
};

template<typename... Ts>
struct af_variant
{
 template<typename T>
 struct types;

template<size_t N, template<typename> class... Features>
 struct types<any<N, Features...>>
 {
 using A = any<N, Features...>;

constexpr static size_t min_required_size() { return std::max({(size_t)0, sizeof(Ts)...}); }

struct extend_properties
        {
        };

template<typename T>
 static void construct_extend_properties(auto&)
 {
 static_assert(std::disjunction_v<std::is_same<T, Ts>...>, "af_variant requires specific types");
 }
 };
};

template<typename T>
struct af_func;

// TODO: Complete the Implementation.
template<size_t N, template<typename> class... Features>
struct af_func<any<N, Features...>>
{
 using A = any<N, Features...>;

struct extend_properties
    {
    };

template<typename F, typename R, typename... Args>
 struct XYZ
 {
 R operator()(Args&&...)
 {
 // TODO: check if the if // if (has_value()&&)
 }
 };
};

template<typename T>
struct af_strict_add;

template<size_t N, template<typename> class... Features>
struct af_strict_add<any<N, Features...>>
{
 using A = any<N, Features...>;

struct extend_properties
    {
        A (*_strict_add)(const A&, const A&){nullptr};
    };

template<typename T>
 static void construct_extend_properties(auto& prop)
 {
 static_assert(requires(T ta) { std::hash<T>{}(ta); }, "af_strict_hash requires type supporting hash{}(a)");

prop._strict_add = +[](const A& a, const A& b) -> A { return A(a.template data<T>() + b.template data<T>()); };
 }

friend A operator+(const A& a, const A& b)
    {
        // more relaxed version can be implemented, which accepts one empty any.
        if (!a.has_value() || !b.has_value() || a.properties() != b.properties())
        {
            throw std::runtime_error("operator+ ext::any without value or different types");
        }
        return a.properties()->_strict_add(a, b);
    }
};

}  // namespace ext

namespace std {
template<size_t N, template<typename> class... Features>
struct hash<ext::any<N, Features...>>
{
 size_t operator()(const ext::any<N, Features...>& x) const { return x.get_hash(); }
};

}  // namespace std