anyxx.hpp File Reference

C++ header only library for external polymorphism. More...

#include <cassert>
#include <concepts>
#include <cstddef>
#include <cstring>
#include <expected>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <ranges>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <utility>
#include <variant>
#include <vector>

Go to the source code of this file.

Classes
struct	anyxx::undefined
	Use this type to indicate, that the ANY_TYPE must be specified in the model map. More...
struct	anyxx::observeable_v_table
struct	anyxx::observeable_rtti_v_table
struct	anyxx::any_v_table
	Basic lifetime functionality. More...
struct	anyxx::unique
union	anyxx::val
	Proxy to manage the captured object as value with small object optimization. More...
class	anyxx::any< Proxy, Trait >
	The core class template to control dispatch for external polymorphism. More...
struct	anyxx::using_< Value >
struct	anyxx::trait_class< Type >
struct	anyxx::key< Tag >
	A key type for factory registration. More...
class	anyxx::factory< Any, Key, Args >
	A class template to implement a factory for any objects. More...
struct	anyxx::members< InObject >
	A class template to implement extension members. More...
struct	anyxx::virtual_< Any >
	A tag to indicate that the corresponding function parameter is an any used for dispatch. More...
class	anyxx::dispatch< R(Args...)>
	Open dispatch method. Solves the expression problem. More...

Concepts
concept	anyxx::is_proxy
	Requirements for a proxy type.
concept	anyxx::has_v_table
	Requirements for a trait type.
concept	anyxx::is_dyn
	Requirements for a dynamic (i.e., type-erased) Proxy.

Macros
#define	ANYXX_USE_EBO
#define	LIFETIMEBOUND
#define	AYXFORCEDINLINE   inline __attribute__((always_inline))
#define	ANYXX_EXTRACT(...)
#define	ANYXX_NOTHING_ANYXX_EXTRACT
#define	ANYXX_PASTE(x, ...)
#define	ANYXX_EVALUATING_PASTE(x, ...)
#define	ANYXX_UNPAREN(x)
#define	ANYXX_JACKET_RETURN(...)
#define	_detail_EXPAND(...)
#define	_detail_EXPAND4(...)
#define	_detail_EXPAND3(...)
#define	_detail_EXPAND2(...)
#define	_detail_EXPAND1(...)
#define	_detail_EXPAND_(...)
#define	_detail_EXPAND_4(...)
#define	_detail_EXPAND_3(...)
#define	_detail_EXPAND_2(...)
#define	_detail_EXPAND_1(...)
#define	_detail_PARENS   ()
#define	_detail_APPLY(macro, args)
#define	_detail_REMOVE_PARENS(l)
#define	_detail_foreach_macro_h(macro, a, ...)
#define	_detail_foreach_macro_a()
#define	_detail_foreach_macro(macro, ...)
#define	_detail_map_macro_h(macro, a, ...)
#define	_detail_map_macro(macro, ...)
#define	_detail_map_macro_a()
#define	_detail_CONCAT_H(a, b)
#define	_detail_CONCAT(a, b)
#define	_detail_ANYXX_FORWARD_PARAM_LIST_H(b, c, f, ...)
#define	_detail_ANYXX_FORWARD_PARAM_LIST_A()
#define	_detail_ANYXX_FORWARD_PARAM_LIST(...)
#define	_detail_ANYXX_CONCEPT_ARG_LIST_H(b, c, f, ...)
#define	_detail_ANYXX_FORWARD_PARAM_LIST_A()
#define	_detail_ANYXX_FORWARD_PARAM_LIST(...)
#define	_detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP_H(b, c, param_type, ...)
#define	_detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP_A()
#define	_detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP(...)
#define	_detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP_H(b, c, param_type, ...)
#define	_detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP_A()
#define	_detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP(...)
#define	_detail_ANYXX_JACKET_PARAM_LIST_H(b, c, param_type, ...)
#define	_detail_ANYXX_JACKET_PARAM_LIST_A()
#define	_detail_ANYXX_JACKET_PARAM_LIST(...)
#define	_detail_EXPAND_LIST(...)
#define	_detail_ANYXX_V_TABLE_PARAM_LIST_H(b, c, param_type, ...)
#define	_detail_ANYXX_V_TABLE_PARAM_LIST_A()
#define	_detail_ANYXX_V_TABLE_PARAM_LIST(...)
#define	_detail_ANYXX_MAP_PARAM_LIST_H(b, c, param_type, ...)
#define	_detail_ANYXX_MAP_PARAM_LIST_A()
#define	_detail_ANYXX_MAP_PARAM_LIST(...)
#define	_detail_ANYXX_CONCEPT_PARAM_LIST_H(b, c, param_type, ...)
#define	_detail_ANYXX_CONCEPT_PARAM_LIST_A()
#define	_detail_ANYXX_CONCEPT_PARAM_LIST(...)
#define	_detail_ANYXX_EXACT_PARAM_LIST_H(b, c, param_type, ...)
#define	_detail_ANYXX_EXACT_PARAM_LIST_A()
#define	_detail_ANYXX_EXACT_PARAM_LIST(...)
#define	_detail_ANYXX_TYPENAME_PARAM_H(t)
#define	_detail_ANYXX_TYPENAME_PARAM(t)
#define	_detail_ANYXX_TYPENAME_PARAM_LIST(head, ...)
#define	_detail_ANYXX_DUMMY_INT_PARAM_LIST_H(b, c, param_type, ...)
#define	_detail_ANYXX_DUMMY_INT_PARAM_LIST_A()
#define	_detail_ANYXX_DUMMY_INT_PARAM_LIST(...)
#define	_detail_ANYXX_OPTIONAL_TEMPLATE(...)
#define	_detail_ANYXX_OPTIONAL_TYPENAME_PARAM_LIST(...)
#define	_detail_ANYXX_OPTIONAL_MORE_TYPENAMES_PARAM_LIST(...)
#define	_detail_ANYXX_TEMPLATE_ARG_H(t)
#define	_detail_ANYXX_TEMPLATE_ARG(t)
#define	_detail_ANYXX_TEMPLATE_ARGS1(head, ...)
#define	_detail_ANYXX_TEMPLATE_ARGS(...)
#define	_detail_ANYXX_OPTIONAL_TEMPLATE_ARGS(...)
#define	_detail_ANYXX_V_TABLE_TEMPLATE_FORMAL_ARGS_H(...)
#define	_detail_ANYXX_V_TABLE_TEMPLATE_FORMAL_ARGS(t)
#define	_detail_LEAD_COMMA_H(...)
#define	_detail_ANYXX_FPD_H(l)
#define	_detail_ANYXX_MEMEBER_LIMP_H(l)
#define	_detail_LEAD_COMMA_H_E(l)
#define	__detail_ANYXX_ADD_HEAD(h, ...)
#define	__detail_ANYXX_ADD_HEAD_LIST(l, ...)
#define	__detail_ANYXX_ADD_TAIL(t, ...)
#define	_typename   _typename1
#define	_typename1(t)
#define	_detail_ANYXX_TEMPLATE_FORMAL_ARG_H(l)
#define	_detail_ANYXX_TEMPLATE_FORMAL_ARG(_typename)
#define	_detail_ANYXX_TEMPLATE_FORMAL_ARGS(...)
#define	_detail_ANYXX_TEMPLATE_FORMAL_ARGS1(h, ...)
#define	_detail_ANYXX_TEMPLATE_FORMAL_ARGS2(l)
#define	_detail_ANYXX_V_TABLE_TEMPLATE_HEADER_H(...)
#define	_detail_ANYXX_V_TABLE_TEMPLATE_HEADER(t)
#define	_detail_ANYXX_INVOKE_TEMPLATE_PARAMS_H(...)
#define	_detail_ANYXX_INVOKE_TEMPLATE_PARAMS(t)
#define	_detail_ANYXX_EXPAND_WITH_LEADING_COMMA(...)
#define	_detail_ANYXX_OPTIONAL_TEMPLATE(...)
#define	_detail_ANYXX_MAP_LIMP_H(l)
#define	_detail_ANYXX_MAP_IMPL(access, overload, type, name, name_ext, exact_const, const_, trait_body, ...)
#define	_detail_ANYXX_CONCEPT_FN_H(l)
#define	_detail_ANYXX_CONCEPT_FN(access, overload, type, name, name_ext, exact_const, const_, trait_body, ...)
#define	_detail_ANYXX_CONCEPT_STATIC_FN_H(l)
#define	_detail_ANYXX_CONCEPT_STATIC_FN(template_params, return_type, name, body, ...)
#define	_detail_ANYXX_CONCEPT_TYPE_H(l)
#define	_detail_ANYXX_CONCEPT_TYPE(template_params, name, erased, default_)
#define	_detail_ANYXX_MAP_STATIC_H(l)
#define	_detail_ANYXX_MAP_STATIC(template_params, return_type, name, body, ...)
#define	_detail_ANYXX_JACKET_STATIC_H(l)
#define	_detail_ANYXX_JACKET_STATIC(template_params, return_type, name, body, ...)
#define	_detail_ANYXX_MAP_TYPE_H(l)
#define	_detail_ANYXX_MAP_TYPE(template_params, name, erased, default_)
#define	_detail_ANYXX_JACKET_TYPE_H(l)
#define	_detail_ANYXX_JACKET_TYPE(template_params, name, erased, default_)
#define	_detail_ANYXX_MAP_VARIANT_LIMP_H(l)
#define	_detail_ANYXX_MAP_VARIANT_IMPL(access, overload, type, name, name_ext, exact_const, const_, trait_body, ...)
#define	_detail_ANYXX_FUNCTION_PTR_DECL(access, overload, type, name, name_ext, exact_const, const_, map_body, ...)
#define	_detail_ANYXX_LAMBDA_TO_MEMEBER_IMPL(access, overload, type, name, name_ext, exact_const, const_, map_body, ...)
#define	_detail_ANYXX_FN_H(l)
#define	_detail_ANYXX_FN(access, overload, type, name, name_ext, exact_const, const_, map_body, ...)
#define	_detail_ANYXX_CONCEPT_FUNCTIONS(...)
#define	_detail_ANYXX_CONCEPT_STATIC_FUNCTIONS(...)
#define	_detail_ANYXX_CONCEPT_TYPES(...)
#define	_detail_ANYXX_MAP_FUNCTIONS(...)
#define	_detail_ANYXX_MAP_STATIC_FUNCTIONS(...)
#define	_detail_ANYXX_MAP_TYPES(...)
#define	_detail_ANYXX_MAP_VARIANT_FUNCTIONS(...)
#define	_detail_ANYXX_V_TABLE_FUNCTION_PTRS(...)
#define	_detail_ANYXX_V_TABLE_LAMBDAS(...)
#define	_detail_ANYXX_FNS(...)
#define	_detail_ANYXX_JACKET_STATIC_FNS(...)
#define	_detail_ANYXX_JACKET_TYPES(...)
#define	_detail_ANYXX_MAKE_V_TABLE_FUNCTION_NAME(n)
#define	TRAIT_META_FUNCTION( any_template_params, model_map_template_params, concrete_template_params, static_dispatch_template_params, variant_model_map_template_params, n, BASE, base_template_params, base_model_map_template_params, l, static_fns, typedefs, decoration)
#define	__detail_ANYXX_TRAIT_(t, n, BASE, l, static_fns, typedefs, decoration)
#define	TRAIT_EX_(n, BASE, l, static_fns, typedefs, decoration)
	TRAIT derived from base with decoration. Macro to define the functional behavior for a any, where the behavior of base is inherited. The decoration are additional functions and typedefs (in brackets).
#define	TRAIT_(n, BASE, l)
	TRAIT derived from base.
#define	TRAIT(n, fns)
	Macro to define the functional behavior for an any.
#define	TRAIT_EX(n, ...)
	TRAIT with decoration.
#define	TRAIT_TEMPLATE_EX_(t, n, base, base_template_types, l, static_fns, typedefs, decoration)
	TRAIT template with base and decoration.
#define	TRAIT_TEMPLATE_EX(t, n, l, static_fns, typedefs, decoration)
	TRAIT template with decoration.
#define	TRAIT_TEMPLATE_(t, n, base, base_template_types, l)
	TRAIT template with a base TRAIT.(.
#define	TRAIT_TEMPLATE(t, n, l)
	TRAIT template.
#define	ANY_META_FUNCTION(pure_template_params, any_template_params_with_defaults, n)
#define	__detail_ANYXX_ANY_CMF(t, t_with_defaults, n)
#define	__detail_ANYXX_ANY_EX_(n, proxy_default)
#define	ANY_EX_(n, BASE, l, proxy_default, decoration)
	ANY with a base and decorationSee ANY for explanation.
#define	ANY_EX(n, l, proxy_default, decoration)
	ANY with decorationSee ANY for explanation.
#define	ANY_(n, BASE, l, proxy_default)
	ANY with a baseSee ANY for explanation.
#define	ANY(n, l, ...)
	Simple ANY macro.
#define	__detail_ANYXX_ANY_TEMPLATE_CMF(t, n, proxy_default)
#define	ANY_TEMPLATE_EX_(t, n, BASE, bt, l, proxy_default, decoration)
	ANY template with a base and decoration.See ANY for explanation.
#define	ANY_TEMPLATE_(t, n, BASE, bt, l, proxy_default)
	ANY template with a base.See ANY for explanation.
#define	ANY_TEMPLATE(t, n, l, proxy_default)
	ANY template.See ANY for explanation.
#define	ANY_TEMPLATE_EX(t, n, l, proxy_default, static_fns, typedefs, decoration)
#define	ANY_FN_(...)
#define	ANY_OVERLOAD(name)
#define	__detail_ANYXX_MEMBER_FN(access, overload, ret, name, name_ext, exact_const, const_, params)
#define	ANY_FN_PURE(ret, name, params, const_)
	TRAIT function, which must be provided by the model.
#define	ANY_FN_PURE_EXACT(ret, name, params, const_)
	TRAIT function, which must be provided by the model.
#define	ANY_FN_DEF(access, ret, name, params, const_, ...)
	TRAIT function with default behavior.
#define	ANY_FN_DEF_EXACT(access, ret, name, params, const_, ...)
	TRAIT function with default behavior.
#define	ANY_FN(ret, name, params, const_)
	TRAIT function whose default behavior is to call an equally named member function of the model.
#define	ANY_FN_EXACT(ret, name, params, const_)
	TRAIT function whose default behavior is to call an equally named member function of the model.
#define	ANY_FN_OVERLOAD(ret, name, params, const_)
	TRAIT function whose default behavior is to call an equally named member function of the model.
#define	ANY_FN_OVERLOAD_EXACT(ret, name, params, const_)
	TRAIT function whose default behavior is to call an equally named member function of the model.
#define	ANY_OP_MAP_NAMED(ret, op, name, params, const_)
	TRAIT operator with default behavior is to call the related operator of the model and a programmer-chosen name in the map.
#define	ANY_OP(ret, op, params, const_)
	TRAIT operator with default behavior is to call the related operator of the model.
#define	ANY_OP_DEF(access, ret, op, name, params, const_, ...)
	TRAIT operator with default behavior.
#define	ANY_OP_EXACT_MAP_NAMED(ret, op, name, params, const_)
#define	ANY_OP_EXACT(ret, op, params, const_)
#define	ANY_OP_EXACT_DEF(access, ret, op, name, params, const_, ...)
	TRAIT operator with default behavior is to call the related operator of the model.
#define	ANY_OP_EXACT_OVERLOAD_MAP_NAMED(ret, op, name, params, const_)
	TRAIT operator with default behavior and a programmer-chosen name in the map.
#define	ANY_OP_EXACT_OVERLOAD(ret, op, params, const_)
	TRAIT operator with default behavior is to call the related operator of the model.
#define	ANY_OP_EXACT_OVERLOAD_DEF(access, ret, op, name, params, const_, ...)
	TRAIT operator with default behavior.
#define	ANY_FN_STATIC_PURE(template_params, return_type, name, params, ...)
	Static TRAIT function, which must be provided by the model. This function will NOT go into the v-Table ad is only avalable for the using_ Proxy.
#define	ANY_FN_STATIC_DEF(template_params, return_type, name, params, ...)
	Static TRAIT function, which has a default implementation. This function will NOT go into the v-Table ad is only avalable for the using_ und trait_class Proxy.
#define	ANY_TYPE(...)
	Dependent type definition in a TRAIT. This is useful for defining associated types, e.g. Return typs using_ Proxy.
#define	__ANY_MODEL_MAP(trait_, t)
#define	ANY_TEMPLATE_MODEL_MAP(model_, trait_, trait_types)
	ANY_TEMPLATE_MODEL_MAP macro.
#define	TRAIT_TYPE(Name, T, Trait, ...)
	translates to the type defined in the model map of a trait. This is useful for associated types, e.g. Return types, which are defined via ANY_TYPE in the trait
#define	ANY_MODEL_MAP(model_, trait_)
	ANY_MODEL_MAP macro.
#define	_detail_ANYXX_TRAIT_ERROR_MESSAGE(name, ret)
#define	ANY_MERGE_(a, b)
#define	ANY_LABEL_(a)
#define	ANY_UNIQUE_NAME_   ANY_LABEL_(__COUNTER__)
#define	ANY_UNIQUE_NAME   ANY_UNIQUE_NAME_
#define	__   ANY_UNIQUE_NAME_
#define	ANY_SINGLETON_DECLARE(export_, name, ...)
	Declare access to a singleton object in a header file.
#define	ANY_SINGLETON(namespace_, name, ...)
	Define a singleton object in a source file.
#define	VANY_DISPACH_DECLARE(export_, name, vany, signature, static_dispatch)
	Declare a singleton object for open vany dispatch.
#define	VANY_DISPACH(namespace_, name)
	Define a vany dispatch singleton object in a source file.
#define	ANY_META_CLASS_FWD(...)
	Declare access to the meta data for a specific model any. Must be in global namespace.
#define	ANY_META_CLASS(...)
	Define the meta data for a specific model any. Must be in global namespace.
#define	ANY_META_CLASS_STATIC(...)
#define	ANY_REGISTER_MODEL(class_, interface_, ...)
	Register a model class for a specific any interface. Must be in global namespace.
#define	ANY_MEMBERS_COUNT_FWD(...)
#define	ANY_MEMBERS_COUNT_IMPL(...)
#define	ANY_MEMBER_FWD(...)
#define	ANY_MEMBER_IMPL(...)
#define	ANY_DISPATCH_COUNT_FWD(...)
	Declare access to the dispatch counter for a specific any. Must be placed in global namespace.
#define	ANY_DISPATCH_COUNT(...)
	Define the dispatch counter for a specific any. Must be placed in global namespace.
#define	ANY_DISPATCH_FOR_FWD(...)
	Declare access to the dispatch table instance function for a model. Must be placed in global namespace.
#define	ANY_DISPATCH_FOR(...)
	Define the dispatch table instance function for a model. Must be placed in global namespace.

Typedefs
using	anyxx::const_void = void const*
using	anyxx::mutable_void = void*
using	anyxx::dispatch_table_function_t = void (*)()
using	anyxx::dispatch_table_dispatch_index_t = std::size_t
using	anyxx::dispatch_table_entry_t = unsigned long long
using	anyxx::dispatch_table_t = std::vector<dispatch_table_entry_t>
template<is_proxy Data>
using	anyxx::data_void = proxy_trait<Data>::void_t
template<is_proxy Proxy, typename ConstructedWith>
using	anyxx::unerased
template<template< typename > typename Any, is_proxy Proxy, typename... Types>
using	anyxx::vany_variant = std::variant<Any<Proxy>, Types...>
template<template< typename > typename Any, is_proxy Proxy, typename... Types>
using	anyxx::make_vany = Any<using_<vany_variant<Any, Proxy, Types...>>>
	A factory type to direct get the any for the vany.
template<voidness Voidness>
using	anyxx::observer = Voidness
using	anyxx::cref = observer<const_void>
using	anyxx::mutref = observer<mutable_void>
using	anyxx::shared = std::shared_ptr<void const>
using	anyxx::weak = std::weak_ptr<void const>
template<typename Type, typename Trait>
using	anyxx::use_as = any<using_<Type>, Trait>
template<typename Type, template< typename... > typename Trait, typename... Ts>
using	anyxx::use_as_ = any<using_<Type>, Trait<Ts...>>
template<typename Type, typename Trait>
using	anyxx::any_trait_class = any<trait_class<Type>, Trait>
template<typename AnyValue>
using	anyxx::v_table_return = AnyValue
template<typename Model>
using	anyxx::map_return = Model
template<typename Model>
using	anyxx::concept_arg = Model
template<typename AnyValue, typename Param>
using	anyxx::v_table_param = TRAIT_TYPE(v_table_param, Param, translate_sig, AnyValue)

Functions
template<typename Model>
constexpr std::size_t	anyxx::compute_model_size ()
template<typename AnyVTable, typename Class>
dispatch_table_t *	anyxx::dispatch_table_instance_implementation ()
template<typename AnyVTable, typename Class>
dispatch_table_t *	anyxx::dispatch_table_instance ()
template<typename VTable, typename Concrete>
VTable *	anyxx::v_table_instance ()
template<typename VTable>
void	anyxx::set_is_derived_from (auto v_table)
bool	anyxx::is_derived_from (const std::type_info &from, any_v_table const *v_table)
std::size_t	anyxx::model_size (any_v_table *v_table)
mutable_void	anyxx::copy_construct_at (any_v_table *v_table, mutable_void placement, const_void from)
mutable_void	anyxx::copy_construct (any_v_table *v_table, const_void from)
mutable_void	anyxx::move_construct_at (any_v_table *v_table, mutable_void placement, mutable_void from)
mutable_void	anyxx::move_construct (any_v_table *v_table, mutable_void from)
void	anyxx::delete_ (any_v_table *v_table, mutable_void &data) noexcept
template<typename U>
bool	anyxx::type_match (any_v_table *v_table)
template<typename U>
void	anyxx::check_type_match (any_v_table *v_table)
constexpr bool	anyxx::is_const_correct_call_for_proxy_and_self (bool call_is_const, bool proxy_is_const, bool self_is_const, bool exact)
template<is_proxy Proxy, typename From>
Proxy	anyxx::erased (From &&from)
template<is_proxy Proxy> requires std::same_as<void const*, typename proxy_trait<Proxy>::void_t>
void const *	anyxx::get_proxy_ptr (Proxy const &vv, typename proxy_trait< Proxy >::required_v_table_t *v_table)
template<is_proxy Proxy> requires std::same_as<void*, typename proxy_trait<Proxy>::void_t>
void *	anyxx::get_proxy_ptr (Proxy const &vv, typename proxy_trait< Proxy >::required_v_table_t *v_table)
template<typename U>
auto	anyxx::unchecked_unerase_cast (void const *p)
template<typename U>
auto	anyxx::unchecked_unerase_cast (void *p)
template<typename U, is_proxy Proxy>
auto	anyxx::unchecked_unerase_cast (Proxy const &o, typename proxy_trait< Proxy >::required_v_table_t *v_table)
template<typename U, is_proxy Proxy> requires (!is_const_data<Proxy>)
auto	anyxx::unchecked_unerase_cast (Proxy const &o, typename proxy_trait< Proxy >::required_v_table_t *v_table)
template<typename U, is_proxy Proxy>
auto	anyxx::unerase_cast (Proxy const &o, any_v_table *v_table)
template<typename U, is_proxy Proxy>
U const *	anyxx::unerase_cast_if (Proxy const &o, any_v_table *v_table)
template<typename U, is_proxy Proxy> requires (!is_const_data<Proxy>)
U *	anyxx::unerase_cast_if (Proxy const &o, any_v_table *v_table)
template<typename V>
auto	anyxx::visit_value (auto &&visitor, V &&v, std::size_t size) -> decltype(auto)
template<typename V2>
auto	anyxx::visit_value (auto &&visitor, val &v1, std::size_t size1, V2 &&v2, std::size_t size2) -> decltype(auto)
template<typename T, typename... Args>
auto	anyxx::make_local_value (Args &&... args)
template<typename T, typename... Args>
auto	anyxx::make_value (Args &&... args)
template<typename TYPE>
auto &	anyxx::runtime_implementation ()
template<typename T>
meta_data &	anyxx::get_meta_data ()
void	anyxx::insert_function (dispatch_table_t *table, std::size_t index, auto fp)
dispatch_table_function_t	anyxx::get_function (dispatch_table_t *table, std::size_t index)
dispatch_table_dispatch_index_t	anyxx::get_multi_dispatch_index_at (dispatch_table_t *table, std::size_t index)
void	anyxx::set_multi_dispatch_index_at (dispatch_table_t *table, std::size_t index_multi_dispatch, dispatch_table_dispatch_index_t dispatch_index_of_class_in_dispatch_matrix)
template<typename VTable, typename Concrete>
auto	anyxx::bind_v_table_to_meta_data ()
template<typename To, typename From, typename FromVTable>
To	anyxx::borrow_as (From const &from, FromVTable *v_table)
template<is_proxy To, is_proxy From>
To	anyxx::clone_to (From const &from, any_v_table *v_table)
template<is_proxy To, is_proxy From>
void	anyxx::move_to (To &to, any_v_table *to_v_table, From &&from, any_v_table *from_v_table)
template<is_any Any>
auto &	anyxx::get_proxy (Any const &any)
template<is_any Any>
auto &	anyxx::get_proxy (Any &any)
template<typename Any>
auto &	anyxx::get_proxy_value (Any &&any)
template<typename Any>
auto const &	anyxx::get_proxy_value (Any const &any)
template<is_any Any>
decltype(auto)	anyxx::move_proxy (Any &&any)
template<is_any Any>
auto	anyxx::get_proxy_ptr (Any const &any)
template<is_any Any>
const auto &	anyxx::get_meta_data (Any const &any)
template<is_any Any>
std::type_info const &	anyxx::get_type_info (Any const &any)
template<is_any Any>
bool	anyxx::is_derived_from (const std::type_info &from, Any const &any)
template<is_any From, is_any Any>
bool	anyxx::is_derived_from (Any const &any)
template<typename To>
auto	anyxx::unchecked_v_table_downcast_to (observeable_v_table *v_table)
template<typename Any>
auto	anyxx::get_v_table (Any const &any)
template<is_any To, is_any From> requires (std::derived_from<typename To::v_table_t, typename From::v_table_t>)
To	anyxx::unchecked_downcast_to (From from)
template<is_any To, is_any From> requires (std::derived_from<typename To::v_table_t, typename From::v_table_t>)
std::optional< To >	anyxx::downcast_to (From from)
	Safe downcast to a derived trait using runtime information from the v-Tables.
template<typename U, is_any Any>
auto	anyxx::unchecked_unerase_cast (Any const &o)
template<typename U, typename Any>
auto	anyxx::unerase_cast (Any const &o)
	Safe downcast to an unerased type using runtime information from the v-Tables.
template<typename U, typename Any>
auto	anyxx::unerase_cast_if (Any const &o)
	Safe downcast to an unerased type using runtime information from the v-Tables.
template<typename Trait, typename T>
auto	anyxx::trait_as (T &&v)
template<is_any ToAny>
auto	anyxx::query_v_table (any_v_table *from) -> std::expected< typename ToAny::v_table_t *, anyxx::cast_error >
template<typename ToAny>
auto	anyxx::query_v_table (any_v_table *from)
	anyxx::TRAIT_EX (translate_sig,,,(ANY_TYPE(((AnyValue)), v_table_param, void,(T)), ANY_TYPE(((AnyValue)), v_table_return, void,(T)), ANY_TYPE(((Model)), map_return, void,(T)), ANY_TYPE(((Model)), concept_arg, void,(T))),()) ANY_MODEL_MAP((self)
	anyxx::ANY_MODEL_MAP ((self const &), translate_sig)
	anyxx::ANY_MODEL_MAP ((self &), translate_sig)
template<typename V, is_any Any>
auto	anyxx::as (Any source)
template<typename To, typename V, is_any Any> requires std::convertible_to<V*, To*>
auto	anyxx::as (typed_any< V, Any > source)
template<is_any ToAny, is_proxy FromProxy, typename FromVTable>
std::expected< ToAny, cast_error >	anyxx::borrow_as (FromProxy const &from, FromVTable *from_v_table)
template<is_any ToAny, is_any FromAny>
std::expected< ToAny, cast_error >	anyxx::borrow_as (FromAny const &from)
	Safe crosscast via runtime information to another any without changing the ownership.
template<is_any ToAny, is_any FromAny>
std::expected< ToAny, cast_error >	anyxx::clone_to (FromAny const &from)
	Clone via runtime information.
template<is_any FromAny>
auto	anyxx::lock (FromAny const &from_interface)
	Lock a shared any.
template<is_any ToAny, is_any FromAny>
ToAny	anyxx::move_to (FromAny &&from)
	Move ownership to another any. Uses runtime information to crosscast, if necessary.
template<typename InObject>
std::size_t &	anyxx::members_count ()
template<typename AnyVTable>
std::size_t &	anyxx::dispatchs_count ()
	A counter for dispatch tables per v-table type.
template<std::size_t I, typename First, typename... Args>
auto	anyxx::arg_n (First first, Args... args)
template<std::size_t FirstN, typename... Ts>
auto	anyxx::get_tuple_head (std::tuple< Ts... > from)
template<std::size_t FromN, typename... Ts>
auto	anyxx::get_tuple_tail (std::tuple< Ts... > from)
template<size_t At, typename Tuple, size_t... Is>
auto	anyxx::make_tuple_from_elements (Tuple &&tuple, std::index_sequence< Is... >)
template<size_t At, size_t N, typename Tuple>
auto	anyxx::make_tuple_from_elements_at (Tuple &&tuple)

Variables
template<typename T>
constexpr bool	anyxx::is_variant = is_variant_impl<T>::value
constexpr bool	anyxx::is_in_dll_mode = false
template<typename T>
constexpr bool	anyxx::is_type_class
template<>
bool constexpr	anyxx::can_move_to_from< shared, unique > = true
template<>
bool constexpr	anyxx::can_move_to_from< weak, shared > = true
	anyxx::translate_sig
template<std::size_t COUNT, typename... Args>
constexpr std::size_t	anyxx::dispatch_dimension_count = COUNT
template<std::size_t COUNT, is_any Any, typename... Args>
constexpr std::size_t	anyxx::dispatch_dimension_count< COUNT, virtual_< Any >, Args... >

Detailed Description

C++ header only library for external polymorphism.

for Microsoft C++, you must enable the C-Preprocessor with this flag: /Zc:preprocessor (see CMakeLists.txt for example)

Macro Definition Documentation

__detail_ANYXX_ADD_HEAD

#define __detail_ANYXX_ADD_HEAD	(		h,
			... )

Value:

h __VA_OPT__(, ) __VA_ARGS__

__detail_ANYXX_ADD_HEAD_LIST

#define __detail_ANYXX_ADD_HEAD_LIST	(		l,
			... )

Value:

__detail_ANYXX_ADD_HEAD(_detail_REMOVE_PARENS(l), __VA_ARGS__)

__detail_ANYXX_ADD_TAIL

#define __detail_ANYXX_ADD_TAIL	(		t,
			... )

Value:

__VA_ARGS__ __VA_OPT__(, ) t

__detail_ANYXX_MEMBER_FN

#define __detail_ANYXX_MEMBER_FN	(		access,
			overload,
			ret,
			name,
			name_ext,
			exact_const,
			const_,
			params )

Value:

ANY_FN_(access, overload, ret, name, name_ext, exact_const, const_,   \
        (x.name_ext), _detail_EXPAND params)

__detail_ANYXX_TRAIT_

#define __detail_ANYXX_TRAIT_	(		t,
			n,
			BASE,
			l,
			static_fns,
			typedefs,
			decoration )

Value:

TRAIT_META_FUNCTION(, (T), (Concrete), (StaticDispatchType), (V), n, BASE, , \
                    (T), l, static_fns, typedefs, decoration)

_detail_ANYXX_CONCEPT_ARG_LIST_H

#define _detail_ANYXX_CONCEPT_ARG_LIST_H	(		b,
			c,
			f,
			... )

Value:

c __VA_OPT__(, _detail_ANYXX_FORWARD_PARAM_LIST_A _detail_PARENS( \
                   b, _detail_CONCAT(b, c), __VA_ARGS__))

_detail_ANYXX_CONCEPT_FN

#define _detail_ANYXX_CONCEPT_FN	(		access,
			overload,
			type,
			name,
			name_ext,
			exact_const,
			const_,
			trait_body,
			... )

Value:

requires requires(                                                          \
    __VA_OPT__(_detail_ANYXX_CONCEPT_PARAM_LIST_H(a, sig_, __VA_ARGS__))) { \
  {                                                                         \
    model_map.name(model __VA_OPT__(                                        \
        , _detail_ANYXX_CONCEPT_ARG_LIST_H(a, sig_, __VA_ARGS__)))          \
  } -> std::convertible_to<anyxx::map_return<T, ANYXX_UNPAREN(type)>>;      \
};

_detail_ANYXX_CONCEPT_FN_H

#define _detail_ANYXX_CONCEPT_FN_H

(

l

)

Value:

_detail_ANYXX_CONCEPT_FN l

_detail_ANYXX_CONCEPT_FUNCTIONS

#define _detail_ANYXX_CONCEPT_FUNCTIONS

(

...

)

Value:

__VA_OPT__(_detail_foreach_macro(_detail_ANYXX_CONCEPT_FN_H, \
                                 _detail_EXPAND_LIST __VA_ARGS__))

_detail_ANYXX_CONCEPT_PARAM_LIST

#define _detail_ANYXX_CONCEPT_PARAM_LIST

(

...

)

Value:

_detail_EXPAND_(_detail_ANYXX_CONCEPT_PARAM_LIST_H(__VA_ARGS__))

_detail_ANYXX_CONCEPT_PARAM_LIST_A

#define _detail_ANYXX_CONCEPT_PARAM_LIST_A

(

)

Value:

_detail_ANYXX_CONCEPT_PARAM_LIST_H

_detail_ANYXX_CONCEPT_PARAM_LIST_H

#define _detail_ANYXX_CONCEPT_PARAM_LIST_H	(		b,
			c,
			param_type,
			... )

Value:

[[maybe_unused]] anyxx::concept_arg<T, ANYXX_UNPAREN(param_type)> c \
__VA_OPT__(, _detail_ANYXX_CONCEPT_PARAM_LIST_A _detail_PARENS(     \
                 b, _detail_CONCAT(b, c), __VA_ARGS__))

_detail_ANYXX_CONCEPT_STATIC_FN

#define _detail_ANYXX_CONCEPT_STATIC_FN	(		template_params,
			return_type,
			name,
			body,
			... )

Value:

requires requires(                                                          \
    __VA_OPT__(_detail_ANYXX_CONCEPT_PARAM_LIST_H(a, sig_, __VA_ARGS__))) { \
  {                                                                         \
    model_map.name(trait_class __VA_OPT__(                                  \
        , _detail_ANYXX_CONCEPT_ARG_LIST_H(a, sig_, __VA_ARGS__)))          \
  }                                                                         \
  -> std::convertible_to<anyxx::map_return<T, ANYXX_UNPAREN(return_type)>>; \
};

_detail_ANYXX_CONCEPT_STATIC_FN_H

#define _detail_ANYXX_CONCEPT_STATIC_FN_H

(

l

)

Value:

_detail_ANYXX_CONCEPT_STATIC_FN l

_detail_ANYXX_CONCEPT_STATIC_FUNCTIONS

#define _detail_ANYXX_CONCEPT_STATIC_FUNCTIONS

(

...

)

Value:

__VA_OPT__(_detail_foreach_macro(_detail_ANYXX_CONCEPT_STATIC_FN_H, \
                                 _detail_EXPAND_LIST __VA_ARGS__))

_detail_ANYXX_CONCEPT_TYPE

#define _detail_ANYXX_CONCEPT_TYPE	(		template_params,
			name,
			erased,
			default_ )

Value:

requires !std::same_as<                                                     \
    typename decltype(model_map)::_detail_ANYXX_OPTIONAL_TEMPLATE(          \
        _detail_REMOVE_PARENS(template_params)) name                        \
        _detail_ANYXX_DUMMY_INT_PARAM_LIST(ANYXX_UNPAREN(template_params)), \
    anyxx::undefined>;

_detail_ANYXX_CONCEPT_TYPE_H

#define _detail_ANYXX_CONCEPT_TYPE_H

(

l

)

Value:

_detail_ANYXX_CONCEPT_TYPE l

_detail_ANYXX_CONCEPT_TYPES

#define _detail_ANYXX_CONCEPT_TYPES

(

...

)

Value:

__VA_OPT__(_detail_foreach_macro(_detail_ANYXX_CONCEPT_TYPE_H, \
                                 _detail_EXPAND_LIST __VA_ARGS__))

_detail_ANYXX_DUMMY_INT_PARAM_LIST

#define _detail_ANYXX_DUMMY_INT_PARAM_LIST

(

...

)

Value:

__VA_OPT__(                                   \
    <_detail_ANYXX_DUMMY_INT_PARAM_LIST_H(dummy1, dummy2, __VA_ARGS__)>)

_detail_ANYXX_DUMMY_INT_PARAM_LIST_A

#define _detail_ANYXX_DUMMY_INT_PARAM_LIST_A

(

)

Value:

_detail_ANYXX_DUMMY_INT_PARAM_LIST_H

_detail_ANYXX_DUMMY_INT_PARAM_LIST_H

#define _detail_ANYXX_DUMMY_INT_PARAM_LIST_H	(		b,
			c,
			param_type,
			... )

Value:

int __VA_OPT__(, _detail_ANYXX_DUMMY_INT_PARAM_LIST_A _detail_PARENS( \
                     b, _detail_CONCAT(b, c), __VA_ARGS__))

_detail_ANYXX_EXACT_PARAM_LIST

#define _detail_ANYXX_EXACT_PARAM_LIST

(

...

)

Value:

_detail_EXPAND_(_detail_ANYXX_EXACT_PARAM_LIST_H(__VA_ARGS__))

_detail_ANYXX_EXACT_PARAM_LIST_A

#define _detail_ANYXX_EXACT_PARAM_LIST_A

(

)

Value:

_detail_ANYXX_EXACT_PARAM_LIST_H

_detail_ANYXX_EXACT_PARAM_LIST_H

#define _detail_ANYXX_EXACT_PARAM_LIST_H	(		b,
			c,
			param_type,
			... )

Value:

[[maybe_unused]] ANYXX_UNPAREN(param_type) c __VA_OPT__(      \
    , _detail_ANYXX_EXACT_PARAM_LIST_A _detail_PARENS(        \
          b, _detail_CONCAT(b, c), __VA_ARGS__))

_detail_ANYXX_EXPAND_WITH_LEADING_COMMA

#define _detail_ANYXX_EXPAND_WITH_LEADING_COMMA

(

...

)

Value:

__VA_OPT__(, ) __VA_ARGS__

_detail_ANYXX_FN_H

#define _detail_ANYXX_FN_H

(

l

)

Value:

_detail_ANYXX_FN l

_detail_ANYXX_FNS

#define _detail_ANYXX_FNS

(

...

)

Value:

__VA_OPT__(_detail_foreach_macro(_detail_ANYXX_FN_H, \
                                 _detail_EXPAND_LIST __VA_ARGS__))

_detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP

#define _detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP

(

...

)

Value:

_detail_EXPAND_(_detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP_H(__VA_ARGS__))

_detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP_A

#define _detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP_A

(

)

Value:

_detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP_H

_detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP_H

#define _detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP_H	(		b,
			c,
			param_type,
			... )

Value:

anyxx::forward_trait_to_map<traited_t, ANYXX_UNPAREN(param_type)>::         \
    template forward<decltype(c)>(std::forward<decltype(c)>(c)) __VA_OPT__( \
        , _detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP_A _detail_PARENS(  \
              b, _detail_CONCAT(b, c), __VA_ARGS__))

_detail_ANYXX_FORWARD_PARAM_LIST [1/2]

#define _detail_ANYXX_FORWARD_PARAM_LIST

(

...

)

Value:

_detail_EXPAND_(_detail_ANYXX_FORWARD_PARAM_LIST_H(__VA_ARGS__))

_detail_ANYXX_FORWARD_PARAM_LIST [2/2]

#define _detail_ANYXX_FORWARD_PARAM_LIST

(

...

)

Value:

_detail_EXPAND_(_detail_ANYXX_FORWARD_PARAM_LIST_H(__VA_ARGS__))

_detail_ANYXX_FORWARD_PARAM_LIST_A [1/2]

#define _detail_ANYXX_FORWARD_PARAM_LIST_A

(

)

Value:

_detail_ANYXX_FORWARD_PARAM_LIST_H

_detail_ANYXX_FORWARD_PARAM_LIST_A [2/2]

#define _detail_ANYXX_FORWARD_PARAM_LIST_A

(

)

Value:

_detail_ANYXX_FORWARD_PARAM_LIST_H

_detail_ANYXX_FORWARD_PARAM_LIST_H

#define _detail_ANYXX_FORWARD_PARAM_LIST_H	(		b,
			c,
			f,
			... )

Value:

std::forward<decltype(c)>(c)                                        \
    __VA_OPT__(, _detail_ANYXX_FORWARD_PARAM_LIST_A _detail_PARENS( \
                     b, _detail_CONCAT(b, c), __VA_ARGS__))

_detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP

#define _detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP

(

...

)

Value:

_detail_EXPAND_(_detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP_H(__VA_ARGS__))

_detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP_A

#define _detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP_A

(

)

Value:

_detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP_H

_detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP_H

#define _detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP_H	(		b,
			c,
			param_type,
			... )

Value:

anyxx::v_table_to_map<Concrete, ANYXX_UNPAREN(param_type)>::                \
    template forward<decltype(c)>(std::forward<decltype(c)>(c)) __VA_OPT__( \
        , _detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP_A _detail_PARENS(         \
              b, _detail_CONCAT(b, c), __VA_ARGS__))

_detail_ANYXX_FPD_H

#define _detail_ANYXX_FPD_H

(

l

)

Value:

_detail_ANYXX_FUNCTION_PTR_DECL l

_detail_ANYXX_FUNCTION_PTR_DECL

#define _detail_ANYXX_FUNCTION_PTR_DECL	(		access,
			overload,
			type,
			name,
			name_ext,
			exact_const,
			const_,
			map_body,
			... )

Value:

anyxx::v_table_return<any_value_t, ANYXX_UNPAREN(type)> (*name)(     \
    void const_* __VA_OPT__(                                         \
        , _detail_ANYXX_V_TABLE_PARAM_LIST(a, _sig, __VA_ARGS__)));

_detail_ANYXX_INVOKE_TEMPLATE_PARAMS

#define _detail_ANYXX_INVOKE_TEMPLATE_PARAMS

(

t

)

Value:

_detail_ANYXX_INVOKE_TEMPLATE_PARAMS_H t

_detail_ANYXX_INVOKE_TEMPLATE_PARAMS_H

#define _detail_ANYXX_INVOKE_TEMPLATE_PARAMS_H

(

...

)

Value:

__VA_OPT__(<__VA_ARGS__>)

_detail_ANYXX_JACKET_PARAM_LIST

#define _detail_ANYXX_JACKET_PARAM_LIST

(

...

)

Value:

_detail_EXPAND_(_detail_ANYXX_JACKET_PARAM_LIST_H(__VA_ARGS__))

_detail_ANYXX_JACKET_PARAM_LIST_A

#define _detail_ANYXX_JACKET_PARAM_LIST_A

(

)

Value:

_detail_ANYXX_JACKET_PARAM_LIST_H

_detail_ANYXX_JACKET_PARAM_LIST_H

#define _detail_ANYXX_JACKET_PARAM_LIST_H	(		b,
			c,
			param_type,
			... )

Value:

[[maybe_unused]] auto&& c __VA_OPT__(                          \
    , _detail_ANYXX_JACKET_PARAM_LIST_A _detail_PARENS(        \
          b, _detail_CONCAT(b, c), __VA_ARGS__))

_detail_ANYXX_JACKET_STATIC

#define _detail_ANYXX_JACKET_STATIC	(		template_params,
			return_type,
			name,
			body,
			... )

Value:

template <typename Self _detail_ANYXX_OPTIONAL_MORE_TYPENAMES_PARAM_LIST(    \
    _detail_REMOVE_PARENS(template_params))>                                 \
AYXFORCEDINLINE decltype(auto) name(                                         \
    [[maybe_unused]] this Self&& self __VA_OPT__(, )                         \
        __VA_OPT__(_detail_ANYXX_JACKET_PARAM_LIST(a, _sig, __VA_ARGS__))) { \
  using self_t = std::decay_t<Self>;                                         \
  static_assert(!self_t::dyn);                                               \
  using T = typename self_t::T;                                              \
  using proxy_t = typename self_t::proxy_t;                                  \
  using map_t = typename self_t::template static_dispatch_map_t<T>;          \
  using traited_t = typename proxy_t::value_t;                               \
  using trait_t = typename self_t::trait_t;                                  \
  return ANYXX_JACKET_RETURN(return_type)::forward(                          \
      map_t::_detail_ANYXX_OPTIONAL_TEMPLATE(                                \
          _detail_REMOVE_PARENS(template_params))                            \
          name _detail_ANYXX_OPTIONAL_TEMPLATE_ARGS(                         \
              _detail_REMOVE_PARENS(template_params))(                       \
              anyxx::trait_class_<T, trait_t> __VA_OPT__(                    \
                  , _detail_ANYXX_FORWARD_JACKET_PARAM_LIST_TO_MAP(          \
                        a, _sig, __VA_ARGS__))),                             \
      std::forward<Self>(self));                                             \
};

_detail_ANYXX_JACKET_STATIC_FNS

#define _detail_ANYXX_JACKET_STATIC_FNS

(

...

)

Value:

__VA_OPT__(_detail_foreach_macro(_detail_ANYXX_JACKET_STATIC_H, \
                                 _detail_EXPAND_LIST __VA_ARGS__))

_detail_ANYXX_JACKET_STATIC_H

#define _detail_ANYXX_JACKET_STATIC_H

(

l

)

Value:

_detail_ANYXX_JACKET_STATIC l

_detail_ANYXX_JACKET_TYPE

#define _detail_ANYXX_JACKET_TYPE	(		template_params,
			name,
			erased,
			default_ )

Value:

template <typename Q _detail_ANYXX_OPTIONAL_MORE_TYPENAMES_PARAM_LIST(   \
    _detail_REMOVE_PARENS(template_params))>                             \
using name = std::conditional_t<                                         \
    std::same_as<void, Q>, erased,                                       \
    typename static_dispatch_map_t<Q>::_detail_ANYXX_OPTIONAL_TEMPLATE(  \
        _detail_REMOVE_PARENS(template_params))                          \
        name _detail_ANYXX_OPTIONAL_TEMPLATE_ARGS(                       \
            _detail_REMOVE_PARENS(template_params))>;

_detail_ANYXX_JACKET_TYPE_H

#define _detail_ANYXX_JACKET_TYPE_H

(

l

)

Value:

_detail_ANYXX_JACKET_TYPE l

_detail_ANYXX_JACKET_TYPES

#define _detail_ANYXX_JACKET_TYPES

(

...

)

Value:

__VA_OPT__(_detail_foreach_macro(_detail_ANYXX_JACKET_TYPE_H, \
                                 _detail_EXPAND_LIST __VA_ARGS__))

_detail_ANYXX_LAMBDA_TO_MEMEBER_IMPL

#define _detail_ANYXX_LAMBDA_TO_MEMEBER_IMPL	(		access,
			overload,
			type,
			name,
			name_ext,
			exact_const,
			const_,
			map_body,
			... )

Value:

name = [](void const_* _vp __VA_OPT__(                                    \
           , _detail_ANYXX_V_TABLE_PARAM_LIST(a, _sig, __VA_ARGS__)))     \
    -> anyxx::v_table_return<any_value_t, ANYXX_UNPAREN(type)> {          \
  if constexpr (std::same_as<anyxx::self&, ANYXX_UNPAREN(type)>) {        \
    model_map{}.name(                                                     \
        *anyxx::unchecked_unerase_cast<Concrete>(_vp) __VA_OPT__(, )      \
            __VA_OPT__(_detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP(           \
                a, _sig, __VA_ARGS__)));                                  \
    return anyxx::handle_self_ref_return<ANYXX_UNPAREN(type)>{}();        \
  } else {                                                                \
    return model_map{}.name(                                              \
        *anyxx::unchecked_unerase_cast<Concrete>(_vp) __VA_OPT__(, )      \
            __VA_OPT__(_detail_ANYXX_FORWARD_PARAM_LIST_TO_MAP(           \
                a, _sig, __VA_ARGS__)));                                  \
  }                                                                       \
};

_detail_ANYXX_MAKE_V_TABLE_FUNCTION_NAME

#define _detail_ANYXX_MAKE_V_TABLE_FUNCTION_NAME

(

n

)

Value:

_detail_CONCAT(make_, _detail_CONCAT(n, _v_table))

_detail_ANYXX_MAP_FUNCTIONS

#define _detail_ANYXX_MAP_FUNCTIONS

(

...

)

Value:

__VA_OPT__(_detail_foreach_macro(_detail_ANYXX_MAP_LIMP_H, \
                                 _detail_EXPAND_LIST __VA_ARGS__))

_detail_ANYXX_MAP_IMPL

#define _detail_ANYXX_MAP_IMPL	(		access,
			overload,
			type,
			name,
			name_ext,
			exact_const,
			const_,
			trait_body,
			... )

Value:

access:                                                                    \
static AYXFORCEDINLINE auto name([[maybe_unused]] T const_& x __VA_OPT__(  \
    , _detail_ANYXX_MAP_PARAM_LIST_H(a, _sig, __VA_ARGS__)))               \
    -> anyxx::map_return<T, ANYXX_UNPAREN(type)> {                         \
  using namespace anyxx;                                                   \
  return _detail_REMOVE_PARENS(trait_body)(                                \
      __VA_OPT__(_detail_ANYXX_FORWARD_PARAM_LIST(a, _sig, __VA_ARGS__))); \
};

_detail_ANYXX_MAP_LIMP_H

#define _detail_ANYXX_MAP_LIMP_H

(

l

)

Value:

_detail_ANYXX_MAP_IMPL l

_detail_ANYXX_MAP_PARAM_LIST

#define _detail_ANYXX_MAP_PARAM_LIST

(

...

)

Value:

_detail_EXPAND_(_detail_ANYXX_MAP_PARAM_LIST_H(__VA_ARGS__))

_detail_ANYXX_MAP_PARAM_LIST_A

#define _detail_ANYXX_MAP_PARAM_LIST_A

(

)

Value:

_detail_ANYXX_MAP_PARAM_LIST_H

_detail_ANYXX_MAP_PARAM_LIST_H

#define _detail_ANYXX_MAP_PARAM_LIST_H	(		b,
			c,
			param_type,
			... )

Value:

[[maybe_unused]] auto&& c __VA_OPT__(                                        \
    , _detail_ANYXX_MAP_PARAM_LIST_A _detail_PARENS(b, _detail_CONCAT(b, c), \
                                                    __VA_ARGS__))

_detail_ANYXX_MAP_STATIC

#define _detail_ANYXX_MAP_STATIC	(		template_params,
			return_type,
			name,
			body,
			... )

Value:

public:                                                                   \
 _detail_ANYXX_OPTIONAL_TYPENAME_PARAM_LIST(                              \
     _detail_REMOVE_PARENS(template_params)) static AYXFORCEDINLINE auto  \
 name([[maybe_unused]] auto trait_class __VA_OPT__(                       \
     , _detail_ANYXX_MAP_PARAM_LIST_H(a, _sig, __VA_ARGS__)))             \
     -> anyxx::map_return<T, ANYXX_UNPAREN(return_type)> {                \
   using namespace anyxx;                                                 \
   return _detail_REMOVE_PARENS(body).template                            \
   operator()<anyxx::use_as<T, typename decltype(trait_class)::trait_t>>( \
       trait_class __VA_OPT__(                                            \
           , _detail_ANYXX_FORWARD_PARAM_LIST(a, _sig, __VA_ARGS__)));    \
 };

_detail_ANYXX_MAP_STATIC_FUNCTIONS

#define _detail_ANYXX_MAP_STATIC_FUNCTIONS

(

...

)

Value:

__VA_OPT__(_detail_foreach_macro(_detail_ANYXX_MAP_STATIC_H, \
                                 _detail_EXPAND_LIST __VA_ARGS__))

_detail_ANYXX_MAP_STATIC_H

#define _detail_ANYXX_MAP_STATIC_H

(

l

)

Value:

_detail_ANYXX_MAP_STATIC l

_detail_ANYXX_MAP_TYPE

#define _detail_ANYXX_MAP_TYPE	(		template_params,
			name,
			erased,
			default_ )

Value:

public:                                                                \
 _detail_ANYXX_OPTIONAL_TYPENAME_PARAM_LIST(_detail_REMOVE_PARENS(     \
     template_params)) using name = _detail_REMOVE_PARENS(default_);

_detail_ANYXX_MAP_TYPE_H

#define _detail_ANYXX_MAP_TYPE_H

(

l

)

Value:

_detail_ANYXX_MAP_TYPE l

_detail_ANYXX_MAP_TYPES

#define _detail_ANYXX_MAP_TYPES

(

...

)

Value:

__VA_OPT__(_detail_foreach_macro(_detail_ANYXX_MAP_TYPE_H, \
                                 _detail_EXPAND_LIST __VA_ARGS__))

_detail_ANYXX_MAP_VARIANT_FUNCTIONS

#define _detail_ANYXX_MAP_VARIANT_FUNCTIONS

(

...

)

Value:

__VA_OPT__(_detail_foreach_macro(_detail_ANYXX_MAP_VARIANT_LIMP_H, \
                                 _detail_EXPAND_LIST __VA_ARGS__))

_detail_ANYXX_MAP_VARIANT_IMPL

#define _detail_ANYXX_MAP_VARIANT_IMPL	(		access,
			overload,
			type,
			name,
			name_ext,
			exact_const,
			const_,
			trait_body,
			... )

Value:

static AYXFORCEDINLINE auto name([[maybe_unused]] T const_& x __VA_OPT__(    \
    , _detail_ANYXX_MAP_PARAM_LIST_H(a, _sig, __VA_ARGS__)))                 \
    -> decltype(auto) {                                                      \
  return std::visit(                                                         \
      anyxx::overloads{                                                      \
          [&]<typename V>(V&& v) {                                           \
            return x_model_map<std::decay_t<V>>::name(                       \
                std::forward<V>(v) __VA_OPT__(, )                            \
                    __VA_OPT__(_detail_ANYXX_FORWARD_PARAM_LIST(             \
                        a, _sig, __VA_ARGS__)));                             \
          },                                                                 \
          [&]<anyxx::is_any Any>([[maybe_unused]] Any&& any) {               \
            return std::forward<Any>(any).name(__VA_OPT__(                   \
                _detail_ANYXX_FORWARD_PARAM_LIST(a, _sig, __VA_ARGS__)));    \
          }},                                                                \
      x);                                                                    \
};

_detail_ANYXX_MAP_VARIANT_LIMP_H

#define _detail_ANYXX_MAP_VARIANT_LIMP_H

(

l

)

Value:

_detail_ANYXX_MAP_VARIANT_IMPL l

_detail_ANYXX_MEMEBER_LIMP_H

#define _detail_ANYXX_MEMEBER_LIMP_H

(

l

)

Value:

_detail_ANYXX_LAMBDA_TO_MEMEBER_IMPL l

_detail_ANYXX_OPTIONAL_MORE_TYPENAMES_PARAM_LIST

#define _detail_ANYXX_OPTIONAL_MORE_TYPENAMES_PARAM_LIST

(

...

)

Value:

__VA_OPT__(, _detail_ANYXX_TYPENAME_PARAM_LIST(__VA_ARGS__))

_detail_ANYXX_OPTIONAL_TEMPLATE [1/2]

#define _detail_ANYXX_OPTIONAL_TEMPLATE

(

...

)

Value:

__VA_OPT__(template)

_detail_ANYXX_OPTIONAL_TEMPLATE [2/2]

#define _detail_ANYXX_OPTIONAL_TEMPLATE

(

...

)

Value:

__VA_OPT__(template)

_detail_ANYXX_OPTIONAL_TEMPLATE_ARGS

#define _detail_ANYXX_OPTIONAL_TEMPLATE_ARGS

(

...

)

Value:

__VA_OPT__(<_detail_ANYXX_TEMPLATE_ARGS(__VA_ARGS__)>)

_detail_ANYXX_OPTIONAL_TYPENAME_PARAM_LIST

#define _detail_ANYXX_OPTIONAL_TYPENAME_PARAM_LIST

(

...

)

Value:

__VA_OPT__(template <_detail_ANYXX_TYPENAME_PARAM_LIST(__VA_ARGS__)>)

_detail_ANYXX_TEMPLATE_ARG

#define _detail_ANYXX_TEMPLATE_ARG

(

t

)

Value:

, t

_detail_ANYXX_TEMPLATE_ARG_H

#define _detail_ANYXX_TEMPLATE_ARG_H

(

t

)

Value:

_detail_ANYXX_TEMPLATE_ARG t

_detail_ANYXX_TEMPLATE_ARGS

#define _detail_ANYXX_TEMPLATE_ARGS

(

...

)

Value:

__VA_OPT__(_detail_ANYXX_TEMPLATE_ARGS1(__VA_ARGS__))

_detail_ANYXX_TEMPLATE_ARGS1

#define _detail_ANYXX_TEMPLATE_ARGS1	(		head,
			... )

Value:

_detail_REMOVE_PARENS(head) __VA_OPT__(       \
    _detail_foreach_macro(_detail_ANYXX_TEMPLATE_ARG_H, __VA_ARGS__))

_detail_ANYXX_TEMPLATE_FORMAL_ARG

#define _detail_ANYXX_TEMPLATE_FORMAL_ARG

(

_typename

)

Value:

, typename _typename

_detail_ANYXX_TEMPLATE_FORMAL_ARG_H

#define _detail_ANYXX_TEMPLATE_FORMAL_ARG_H

(

l

)

Value:

_detail_ANYXX_TEMPLATE_FORMAL_ARG l

_detail_ANYXX_TEMPLATE_FORMAL_ARGS

#define _detail_ANYXX_TEMPLATE_FORMAL_ARGS

(

...

)

Value:

__VA_OPT__(_detail_ANYXX_TEMPLATE_FORMAL_ARGS1(__VA_ARGS__))

_detail_ANYXX_TEMPLATE_FORMAL_ARGS1

#define _detail_ANYXX_TEMPLATE_FORMAL_ARGS1	(		h,
			... )

Value:

typename _typename h __VA_OPT__(                  \
    _detail_ANYXX_TEMPLATE_FORMAL_ARGS2((__VA_ARGS__)))

_detail_ANYXX_TEMPLATE_FORMAL_ARGS2

#define _detail_ANYXX_TEMPLATE_FORMAL_ARGS2

(

l

)

Value:

_detail_foreach_macro(_detail_ANYXX_TEMPLATE_FORMAL_ARG_H, \
                      _detail_EXPAND_LIST l)

_detail_ANYXX_TRAIT_ERROR_MESSAGE

#define _detail_ANYXX_TRAIT_ERROR_MESSAGE	(		name,
			ret )

Value:

[]<typename... Args>([[maybe_unused]] Args...) -> ret {                     \
  static_assert(anyxx::missing_trait_error<T>::not_specialized,             \
                "'" #name                                                   \
                "' is missing in the specialization of this proxy_trait!"); \
  return {};                                                                \
}

_detail_ANYXX_TYPENAME_PARAM

#define _detail_ANYXX_TYPENAME_PARAM

(

t

)

Value:

, typename t

_detail_ANYXX_TYPENAME_PARAM_H

#define _detail_ANYXX_TYPENAME_PARAM_H

(

t

)

Value:

_detail_ANYXX_TYPENAME_PARAM t

_detail_ANYXX_TYPENAME_PARAM_LIST

#define _detail_ANYXX_TYPENAME_PARAM_LIST	(		head,
			... )

Value:

typename _detail_REMOVE_PARENS(head) __VA_OPT__(   \
    _detail_foreach_macro(_detail_ANYXX_TYPENAME_PARAM_H, __VA_ARGS__))

_detail_ANYXX_V_TABLE_FUNCTION_PTRS

#define _detail_ANYXX_V_TABLE_FUNCTION_PTRS

(

...

)

Value:

__VA_OPT__(_detail_foreach_macro(_detail_ANYXX_FPD_H, \
                                 _detail_EXPAND_LIST __VA_ARGS__));

_detail_ANYXX_V_TABLE_LAMBDAS

#define _detail_ANYXX_V_TABLE_LAMBDAS

(

...

)

Value:

__VA_OPT__(_detail_foreach_macro(_detail_ANYXX_MEMEBER_LIMP_H, \
                                 _detail_EXPAND_LIST __VA_ARGS__));

_detail_ANYXX_V_TABLE_PARAM_LIST

#define _detail_ANYXX_V_TABLE_PARAM_LIST

(

...

)

Value:

_detail_EXPAND_(_detail_ANYXX_V_TABLE_PARAM_LIST_H(__VA_ARGS__))

_detail_ANYXX_V_TABLE_PARAM_LIST_A

#define _detail_ANYXX_V_TABLE_PARAM_LIST_A

(

)

Value:

_detail_ANYXX_V_TABLE_PARAM_LIST_H

_detail_ANYXX_V_TABLE_PARAM_LIST_H

#define _detail_ANYXX_V_TABLE_PARAM_LIST_H	(		b,
			c,
			param_type,
			... )

Value:

[[maybe_unused]] anyxx::v_table_param<any_value_t,                 \
                                      ANYXX_UNPAREN(param_type)> c \
__VA_OPT__(, _detail_ANYXX_V_TABLE_PARAM_LIST_A _detail_PARENS(    \
                 b, _detail_CONCAT(b, c), __VA_ARGS__))

_detail_ANYXX_V_TABLE_TEMPLATE_FORMAL_ARGS

#define _detail_ANYXX_V_TABLE_TEMPLATE_FORMAL_ARGS

(

t

)

Value:

_detail_ANYXX_V_TABLE_TEMPLATE_FORMAL_ARGS_H t

_detail_ANYXX_V_TABLE_TEMPLATE_FORMAL_ARGS_H

#define _detail_ANYXX_V_TABLE_TEMPLATE_FORMAL_ARGS_H

(

...

)

Value:

__VA_OPT__(<_detail_ANYXX_TEMPLATE_ARGS(__VA_ARGS__), anyxx::dyn>)

_detail_ANYXX_V_TABLE_TEMPLATE_HEADER

#define _detail_ANYXX_V_TABLE_TEMPLATE_HEADER

(

t

)

Value:

_detail_ANYXX_V_TABLE_TEMPLATE_HEADER_H t

_detail_ANYXX_V_TABLE_TEMPLATE_HEADER_H

#define _detail_ANYXX_V_TABLE_TEMPLATE_HEADER_H

(

...

)

Value:

__VA_OPT__(template <_detail_ANYXX_TEMPLATE_FORMAL_ARGS(__VA_ARGS__)>)

_detail_APPLY

#define _detail_APPLY	(		macro,
			args )

Value:

macro args

_detail_CONCAT

#define _detail_CONCAT	(		a,
			b )

Value:

_detail_CONCAT_H(a, b)

_detail_CONCAT_H

#define _detail_CONCAT_H	(		a,
			b )

Value:

a##b

_detail_EXPAND

#define _detail_EXPAND

(

...

)

Value:

_detail_EXPAND4(          \
    _detail_EXPAND4(_detail_EXPAND4(_detail_EXPAND4(__VA_ARGS__))))

_detail_EXPAND1

#define _detail_EXPAND1

(

...

)

Value:

__VA_ARGS__

_detail_EXPAND2

#define _detail_EXPAND2

(

...

)

Value:

_detail_EXPAND1(           \
    _detail_EXPAND1(_detail_EXPAND1(_detail_EXPAND1(__VA_ARGS__))))

_detail_EXPAND3

#define _detail_EXPAND3

(

...

)

Value:

_detail_EXPAND2(           \
    _detail_EXPAND2(_detail_EXPAND2(_detail_EXPAND2(__VA_ARGS__))))

_detail_EXPAND4

#define _detail_EXPAND4

(

...

)

Value:

_detail_EXPAND3(           \
    _detail_EXPAND3(_detail_EXPAND3(_detail_EXPAND3(__VA_ARGS__))))

_detail_EXPAND_

#define _detail_EXPAND_

(

...

)

Value:

_detail_EXPAND_4(          \
    _detail_EXPAND_4(_detail_EXPAND_4(_detail_EXPAND_4(__VA_ARGS__))))

_detail_EXPAND_1

#define _detail_EXPAND_1

(

...

)

Value:

__VA_ARGS__

_detail_EXPAND_2

#define _detail_EXPAND_2

(

...

)

Value:

_detail_EXPAND_1(           \
    _detail_EXPAND_1(_detail_EXPAND_1(_detail_EXPAND_1(__VA_ARGS__))))

_detail_EXPAND_3

#define _detail_EXPAND_3

(

...

)

Value:

_detail_EXPAND_2(           \
    _detail_EXPAND_2(_detail_EXPAND_2(_detail_EXPAND_2(__VA_ARGS__))))

_detail_EXPAND_4

#define _detail_EXPAND_4

(

...

)

Value:

_detail_EXPAND_3(           \
    _detail_EXPAND_3(_detail_EXPAND_3(_detail_EXPAND_3(__VA_ARGS__))))

_detail_EXPAND_LIST

#define _detail_EXPAND_LIST

(

...

)

Value:

__VA_ARGS__

_detail_foreach_macro

#define _detail_foreach_macro	(		macro,
			... )

Value:

_detail_EXPAND(_detail_foreach_macro_h(macro, __VA_ARGS__))

_detail_foreach_macro_a

#define _detail_foreach_macro_a

(

)

Value:

_detail_foreach_macro_h

_detail_foreach_macro_h

#define _detail_foreach_macro_h	(		macro,
			a,
			... )

Value:

macro(a)                                     \
    __VA_OPT__(_detail_foreach_macro_a _detail_PARENS(macro, __VA_ARGS__))

_detail_LEAD_COMMA_H

#define _detail_LEAD_COMMA_H

(

...

)

Value:

__VA_OPT__(, )

_detail_LEAD_COMMA_H_E

#define _detail_LEAD_COMMA_H_E

(

l

)

Value:

_detail_LEAD_COMMA_H l

_detail_map_macro

#define _detail_map_macro	(		macro,
			... )

Value:

_detail_EXPAND(_detail_map_macro_h(macro, __VA_ARGS__))

_detail_map_macro_a

#define _detail_map_macro_a

(

)

Value:

_detail_map_macro_h

_detail_map_macro_h

#define _detail_map_macro_h	(		macro,
			a,
			... )

Value:

macro(a) __VA_OPT__(, _detail_map_macro_a _detail_PARENS(macro, __VA_ARGS__))

_detail_REMOVE_PARENS

#define _detail_REMOVE_PARENS

(

l

)

Value:

_detail_APPLY(_detail_EXPAND_1, l)

_typename1

#define _typename1

(

t

)

Value:

t

ANY_FN_

#define ANY_FN_

(

...

)

Value:

(__VA_ARGS__)

ANY_LABEL_

#define ANY_LABEL_

(

a

)

Value:

ANY_MERGE_(unique_name_, a)

ANY_MERGE_

#define ANY_MERGE_	(		a,
			b )

Value:

a##b

ANY_OVERLOAD

#define ANY_OVERLOAD

(

name

)

Value:

using base_t::name;

ANYXX_EVALUATING_PASTE

#define ANYXX_EVALUATING_PASTE	(		x,
			... )

Value:

ANYXX_PASTE(x, __VA_ARGS__)

ANYXX_EXTRACT

#define ANYXX_EXTRACT

(

...

)

Value:

ANYXX_EXTRACT __VA_ARGS__

ANYXX_JACKET_RETURN

#define ANYXX_JACKET_RETURN

(

...

)

Value:

anyxx::jacket_return<ANYXX_UNPAREN(ANYXX_UNPAREN(__VA_ARGS__))>

ANYXX_PASTE

#define ANYXX_PASTE	(		x,
			... )

Value:

x##__VA_ARGS__

ANYXX_UNPAREN

#define ANYXX_UNPAREN

(

x

)

Value:

ANYXX_EVALUATING_PASTE(ANYXX_NOTHING_, ANYXX_EXTRACT x)

Typedef Documentation

any_trait_class

template<typename Type, typename Trait>

using anyxx::any_trait_class = any<trait_class<Type>, Trait>

Helper type alias template to get a trait_class for a type dispatch. Has no data member, so it doesn't capture any value and has no size

Template Parameters

Type	The captured type

unerased

template<is_proxy Proxy, typename ConstructedWith>

using anyxx::unerased

Initial value:

 
proxy_trait<Proxy>::template unerased<std::decay_t<ConstructedWith>>

use_as

template<typename Type, typename Trait>

using anyxx::use_as = any<using_<Type>, Trait>

A template to get an any trait for a type See also using_::as.

use_as_

template<typename Type, template< typename... > typename Trait, typename... Ts>

using anyxx::use_as_ = any<using_<Type>, Trait<Ts...>>

A template to get an templatetd any trait for a type See also using_::as.

Function Documentation

trait_as()

template<typename Trait, typename T>

auto anyxx::trait_as

(

T &&

v

)

A factory function to bind an object as a model to an any with a trait. See also using_::as.

Examples

_2b_trait_monoid.cpp, _2c_trait_any_variant.cpp, and _2d_trait_self.cpp.

Variable Documentation

dispatch_dimension_count< COUNT, virtual_< Any >, Args... >

template<std::size_t COUNT, is_any Any, typename... Args>

std::size_t anyxx::dispatch_dimension_count< COUNT, virtual_< Any >, Args... >

constexpr

Initial value:

                                           =
dispatch_dimension_count<COUNT + 1, Args...>

is_type_class

template<typename T>

bool anyxx::is_type_class

inlineconstexpr

Initial value:

                                =
is_proxy<T> && is_type_class_impl<T>::value

translate_sig

anyxx::translate_sig

Initial value:

{
  template <typename AnyValue>
  using v_table_param = any<cref>