AnyAny
v1.0.0
通过类型擦除实现高效动态多态性的库（C++17 或更高版本）
目标是效率、可理解性和可扩展性。
铿锵、海湾合作委员会、MSVC 
How to build?库的基础类型擦除部分是一个方法- 描述我们要在擦除后使用类型的哪一部分。
让我们创建一个用于使用void draw()擦除类型的方法：
<anyany/anyany_macro.hpp>中有anyany_method宏，例如，对于Method 'foo'，它接受int和float +返回float
# include < anyany/anyany_macro.hpp >
anyany_method (foo, (&self, int i, float f) requires(self.foo(i, f)) -> float);
...
void example (aa::any_with<foo> obj) {
if (obj. has_value ())
float x = obj. foo ( 5 , 3 . 14f ); // all works
obj = some_type_with_foo{};
obj = some_other_type_with_foo ();
} // For each type T do value.draw()
struct Draw {
template < typename T>
static void do_invoke ( const T& self) {
self. draw ();
}
};我们可以使用Draw进行类型擦除：
# include < anyany/anyany.hpp >
using any_drawable = aa::any_with<Draw>;现在我们可以使用any_drawable通过.draw()来存储任何类型
// some types with .draw()
struct Circle {
void draw () const {
std::cout << " Draw Circle n " ;
}
};
struct Square {
void draw () const {
std::cout << " Draw Square n " ;
}
};
int main () {
any_drawable shape = Circle{};
aa::invoke<Draw>(shape); // prints "Draw Circle"
shape = Square{};
aa::invoke<Draw>(shape); // prints "Draw Square"
// see /examples folder for more
}没有虚函数、继承、指针、内存管理等！好的！
您可以添加任意数量的方法：
using any_my = aa::any_with<Draw, Run, aa::copy>;等等，复制……？是的，默认情况下aa::any_with只有一个析构函数，您可以添加aa::copy方法使其可复制和移动，或者添加aa::move使其仅移动
预定义方法：
使any_with可复制和可移动，启用aa::materialize作为引用（这也需要aa::destroy方法）
还有copy_with<Alloc, SooS> ，当您使用自定义分配器和小对象优化大小（ aa::basic_any_with ）时，这会启用复制
使 'any_with' 可移动
注意： any_with的移动构造函数和移动赋值运算符始终为 noexcept
为any_with 、 poly_ref /...等启用std::hash专门化。如果any_with为空，则hash == 0。
注意： poly_ptr默认情况下具有std::hash的特化，但它是类似指针的哈希。
通过在 vtable 中添加 RTTI 来启用aa::any_cast 、 aa::type_switch 、 aa::visit_invoke 。
还为any_with / poly_ref /...等添加.type_descriptor() -> aa::descriptor_t 。
为any_with / poly_ref /...等启用operator== 。
如果两个对象包含相同的类型（或均为空）并且存储的值相等，则它们相等。
为any_with / poly_ref /...等启用operator<=>和operator== 。
注意：operpator<=> 总是返回std::partial_ordering 。
如果两个对象不包含相同类型，则返回unordered ，否则返回包含对象的operator <=>的结果。
注意：如果两者都为空，则返回std::partial_ordering::equivalent
为any_with / poly_ref /...等添加R operator()(Args...) 。
注意：还支持const 、 noexcept和const noexcept签名
例子：
// stateful::cref is a lightweight thing,
// it stores vtable in itself(in this case only one function ptr)
// and const void* to value
// This is most effective way to erase function
template < typename Signature>
using function_ref = aa::stateful::cref<aa::call<Signature>>;
void foo (function_ref< int ( float ) const > ref) {
int result = ref ( 3.14 );
}
添加析构函数（ any_with默认情况下有它），但也许您想将它与aa::poly_ptr一起使用来手动管理生命周期。还启用aa::materialize进行引用（还需要 aa::copy）
如果您想了解有关方法的所有详细信息，请参阅anyany.hpp 中的method概念
多态类型：
any_with<Methods...>basic_any_with<Methods...>poly_ref<Methods...>poly_ptr<Methods...>cref<Methods...>cptr<Methods...>stateful::ref<Methods...>stateful::cref<Methods...>行动：
any_cast<T>invoke<Method>type_switchvisit_invoke多态容器：
variant_swarm<Ts...>data_parallel_vector<T, Alloc> template < typename T>
concept method = /* ... */ ; // see anyany.hpp
// true if type can be used as poly traits argument in any_cast / type_switch / visit_invoke etc
template < typename T>
concept poly_traits = requires(T val, int some_val) {
{ val. get_type_descriptor (some_val) } -> std::same_as< descriptor_t >;
{ val. to_address (some_val) };
};您可以为多态层次结构定义特征（类似 LLVM 的类型 ID、虚拟函数等）。
库内置了两个这样的特征（您可以使用它们作为实现您自己的特征的示例）：
例如，您希望使用any_with或poly_ref使用您的Method创建类型的方法 .foo() 。
那么你应该使用plugins ：
struct Foo {
template < typename T>
static void do_invoke (T&) { /* do something */ }
// any_with<Foo> will inherit plugin<any_with<Foo>>
template < typename CRTP>
struct plugin {
void foo () const {
auto & self = * static_cast < const CRTP*>( this );
// Note: *this may not contain value, you can check it by calling self.has_value()
aa::invoke<Foo>(self);
}
};
};
//
any_with<Foo> val = /* ... */ ;
val.foo(); // we have method .foo from plugin!
注意：您可以通过在插件中继承其他插件来“隐藏/覆盖”其他插件（即使继承是私有的）
例如，请参阅 aa::spaceship/aa::copy_with 插件
您还可以将 aa::plugin<Any, Method> 专门用于您的方法，甚至是具有某些要求的“任何”
any_with接受任意数量的方法并创建一个可以保存任何值的类型，该类型支持这些方法。类似于运行时概念
注意：有标签'aa::force_stable_pointers'来强制分配，所以poly_ptr/cptr到any_with<...>在移动后不会失效。
注意： aa::unreachable_allocator ，如果basic_any_with<unreachable_allocator, ...>尝试分配内存，这将中断编译。所以你可以强制类型不分配
// All constructors and move assign operators are exception safe
// move and move assign always noexcept
// See 'construct_interface' alias in anyany.hpp and 'struct plugin'for details how it works(comments)
struct Any : construct_interface<basic_any<Alloc, SooS, Methods...>, Methods...>{
// aliases to poly ref/ptr
using ptr = /* ... */ ;
using ref = /* ... */ ;
using const_ptr = /* ... */ ;
using const_ref = /* ... */ ;
// operator & for getting poly ptr
poly_ptr<Methods...> operator &() noexcept ;
const_poly_ptr<Methods...> operator &() const noexcept ;
// main constructors
// creates empty
constexpr Any ();
Any ( auto && value); // from any type
Any ( const Any&) requires aa::copy
Any& operator =( const Any&) requires aa::move and aa::copy
Any (Any&&) noexcept requires aa::move;
Any& operator =(Any&&) requires method aa::move;
// observers
bool has_value () const noexcept ;
// returns true if poly_ptr/ref to *this will not be invalidated after moving value
bool is_stable_pointers () const noexcept
// returns count of bytes sufficient to store current value
// (not guaranteed to be smallest)
// return 0 if !has_value()
size_t sizeof_now() const noexcept ;
// returns descriptor_v<void> if value is empty
type_descriptor_t type_descriptor () const noexcept requires aa::type_info;
// forces that after creation is_stable_pointers() == true (allocates memory)
template < typename T>
Any ( force_stable_pointers_t , T&& value);
// also emplace constructors(std::in_place_type_t<T>), initiaizer list versions
// same with force_stable_pointers_t tag etc etc
// same with Alloc...
// modifiers
// emplaces value in any, if exception thrown - any is empty(use operator= if you need strong exception guarantee here)
template < typename T, typename ... Args>
std:: decay_t <T>& emplace (Args&&...); // returns reference to emplaced value
template < typename T, typename U, typename ... Args>
std:: decay_t <T>& emplace (std::initializer_list<U> list, Args&&... args)
// postcondition: has_value() == false
void reset() noexcept ;
// see aa::equal_to description for behavior
bool operator ==( const Any&) const requires aa::spaceship || aa::equal_to;
// see aa::spaceship description for behavior
std::partial_ordering operator <=>( const Any&) const requires aa::spaceship;
// ... interface from plugins for Methods if presented ...
};
所有构造函数和复制/移动赋值运算符都有强大的异常保证
注意：如果您的类型有 no except 移动构造函数，它确实可以提高性能（就像 std::vector 的情况一样）。
例子：
using any_printable = aa::any_with<Print, aa::move>;basic_any_with与any_with相同，但具有自定义分配和小对象优化缓冲区大小 - 如果您需要可复制的basic_any_with使用copy_with
template < typename Alloc, size_t SooS, TTA... Methods>
using basic_any_with = /* ... */ ;poly_ref非拥有、始终不为空、轻量级(~=void*)
poly_ref<Methods...>隐式转换为较小数量的方法。
poly_ref<A, B, C>可转换为poly_ref<A, B> 、 poly_ref<A> 、 poly_ref<B> ...等。
这意味着您只能在函数接口中添加它们真正需要的方法。然后，如果您将Method添加到any_with类型，则不会有 abi/api 中断。
// you can invoke this function with any poly_ref<..., A, ...>
void foo (poly_ref<A>); template < template < typename > typename ... Methods>
struct poly_ref {
poly_ref ( const poly_ref&) = default ;
poly_ref (poly_ref&&) = default ;
poly_ref& operator =(poly_ref&&) = default ;
poly_ref& operator =( const poly_ref&) = default ;
// only explicit rebind reference after creation
void operator =( auto &&) = delete ;
descriptor_t type_descriptor () const noexcept requires aa::type_info;
// from mutable lvalue
template <not_const_type T> // not shadow copy ctor
poly_ref (T& value) noexcept
poly_ptr<Methods...> operator &() const noexcept ;
// ... interface from plugins for Methods if presented ...
}const_poly_ref与poly_ref相同，但可以从poly_ref和const T&创建
aa::cref是aa::const_poly_ref的模板别名
注意：不延长使用寿命
poly_ptr非拥有、可为空、轻量级(~=void*)
poly_ptr<Methods...>隐式转换为较小数量的方法。
poly_ptr<A, B, C>可转换为poly_ptr<A, B> 、 poly_ptr<A> 、 poly_ptr<B> ...等。
这意味着您只能在函数接口中添加它们真正需要的方法。然后，如果您将Method添加到any_with类型，则不会有 abi/api 中断。
// you can invoke this function with any poly_ptr<..., A, ...>
void foo (poly_ptr<A>);注意： poly_ptr和const_poly_ptr是可以简单复制的，因此std::atomic<poly_ptr<...>>可以工作。
template < template < typename > typename ... Methods>
struct poly_ptr {
poly_ptr () = default ;
poly_ptr (std:: nullptr_t ) noexcept ;
poly_ptr& operator =(std:: nullptr_t ) noexcept ;
poly_ptr (not_const_type auto * ptr) noexcept ;
// from non-const pointer to Any with same methods
template <any_x Any>
poly_ptr (Any* ptr) noexcept ;
// observers
// returns raw pointer to value
void * raw () const noexcept ;
// NOTE: returns unspecified value if *this == nullptr
const vtable<Methods...>* raw_vtable_ptr () const noexcept ;
// returns descriptor_v<void> is nullptr
descriptor_t type_descriptor () const noexcept requires aa::type_info;
bool has_value () const noexcept ;
bool operator ==(std:: nullptr_t ) const noexcept ;
explicit operator bool () const noexcept ;
// similar to common pointer operator* returns reference
poly_ref<Methods...> operator *() const noexcept ;
const poly_ref<Methods...>* operator ->() const noexcept ;
}const_poly_ptr与poly_ptr相同，但可以从poly_ptr和const T* / Any*创建
aa::cptr是aa::const_poly_ptr的模板别名
stateful_ref aa::stateful::ref<Methods...>本身包含 vtable。
还可以包含对 C 数组和函数的引用而不会衰减
它有非常简单的界面，仅从T&/poly_ref创建并调用（例如通过 aa::invoke）
如果您需要擦除 1-2 个方法并且不需要使用any_cast ，它将具有最大性能。
典型用例 - 创建 function_ref
template < typename Signature>
using function_ref = aa::stateful::cref<aa::call<Signature>>;
bool foo ( int ) { return true ; }
void example (function_ref< bool ( int ) const > ref) {
ref ( 5 );
}
int main () {
example (&foo);
example ([]( int x) { return false ; });
}
stateful_cref与stateful::ref相同，但可以从const T&和aa::cref创建
any_cast需要 aa::type_info 方法
带有operator()的函数对象：
用作 std::any_cast - 您可以转换为 T(copy)、T&(take ref) （如果强制转换不好，则抛出 aa::bad_cast）
或者你可以传递指针（或poly_ptr）（如果转换不好，则返回nullptr）
T* ptr = any_cast<T>(&any);
例子：
using any_comparable = aa::any_with<aa::copy, aa::spaceship, aa::move>;
void Foo () {
any_comparable value = 5 ;
value. emplace <std::vector< int >>({ 1 , 2 , 3 , 4 }); // constructed in-place
// any_cast returns pointer to vector<int>(or nullptr if any do not contain vector<int>)
aa::any_cast<std::vector< int >>( std::addressof (value))-> back () = 0 ;
// version for reference
aa::any_cast<std::vector< int >&>(value). back () = 0 ;
// version which returns by copy (or move, if 'value' is rvalue)
auto vec = aa::any_cast<std::vector< int >>(value);
}invoke带有operator()的函数对象，它接受any_with/ref/cref/stateful::ref/stateful::cref作为第一个参数，然后接受所有Method的参数并调用Method
如果 arg 是 const any_with或cref ，则仅允许const 方法。
前提条件：any.has_value() == true
例子：
void example (any_with<Say> pet) {
if (!pet. has_value ())
return ;
// invokes Method `Say`, passes std::cout as first argument
aa::invoke<Say>(pet, std::cout);
}
void foo (std::vector<aa::poly_ref<Foo>> vec) {
// invokes Method `Foo` without arguments for each value in `vec`
std::ranges::for_each (vec, aa::invoke<Foo>);
}
type_switch根据输入 arg 动态类型选择 .case 并使用此动态类型或默认函数调用visitor
还支持poly_traits作为第二个模板参数，因此它支持具有 poly 特征的任何类型
template < typename Result = void , poly_traits Traits = anyany_poly_traits>
struct type_switch_fn {
type_switch_fn (poly_ref<...>);
// invokes Fn if T contained
template < typename T, typename Fn>
type_switch_impl& case_ (Fn&& f);
// If value is one of Ts... F invoked (invokes count <= 1)
template < typename ... Ts, typename Fn>
type_switch_impl& cases (Fn&& f);
// if no one case succeded invokes 'f' with input poly_ref argument
template < typename Fn>
Result default_ (Fn&& f);
// if no one case succeded returns 'v'
Result default_ (Result v);
// if no one case succeded returns 'nullopt'
std::optional<Result> no_default ();
};
例子：
Result val = aa::type_switch<Result>(value)
.case_< float >(foo1)
.case_< bool >(foo2)
.cases< char , int , unsigned char , double >(foo3)
.default_( 15 );visit_invoke它...运行时重载解决方案！ aa::make_visit_invoke<Foos...>使用方法.resolve(Args...)创建重载集对象，该方法根据 Args... 运行时类型执行重载解析。
如果不存在接受输入参数的此类函数，Resolve 将返回nullopt
这个示例非常基础，另请参阅 /examples/visit_invoke_example.hpp 了解更多信息
例子：
auto ship_asteroid = [](spaceship s, asteroid a) -> std::string { ... }
auto ship_star = [](spaceship s, star) -> std::string { ... }
auto star_star = [](star a, star b) -> std::string { ... }
auto ship_ship = [](spaceship a, spaceship b) -> std::string { ... }
// Create multidispacter
constexpr inline auto collision = aa::make_visit_invoke<std::string>(
ship_asteroid,
ship_star,
star_star,
ship_ship);
...
// Perform runtime overload resolution
std::optional<std::string> foo (any_with<A> a, any_with<B> b) {
return collision. resolve (a, b);
}
variant_swarm多态容器适配器，其行为类似于Container<std::variant<Types...>> ，但更有效。
支持操作：
visit<Types...>(visitor) - 使用类型Types的所有包含值调用visitorview<T> - 返回对所有T类型存储值的容器的引用默认情况下，容器是std::vector 。
template < template < typename > typename Container, typename ... Ts>
struct basic_variant_swarm {
// modifiers
void swap (basic_variant_swarm& other) noexcept ;
friend void swap (basic_variant_swarm& a, basic_variant_swarm& b) noexcept ;
// selects right container and inserts [it, sent) into it
template <std::input_iterator It>
requires (tt::one_of<std:: iter_value_t <It>, std::ranges:: range_value_t <Container<Ts>>...>)
auto insert (It it, It sent);
// insert and erase overloads for each type in Ts...
using inserters_type::erase;
using inserters_type::insert;
// observe
bool empty () const noexcept ;
// returns count values, stored in container for T
template <tt::one_of<Ts...> T>
requires (std::ranges::sized_range<container_for<T>>)
auto count () const ;
template <std:: size_t I>
requires (std::ranges::sized_range<decltype(std::get<I>(containers))>)
auto count () const ;
// returns count of values stored in all containers
constexpr auto size () const requires(std::ranges::sized_range<container_for<Ts>> && ...);
// returns tuple of reference to containers #Is
template <std:: size_t ... Is>
auto view ();
template <std:: size_t ... Is>
auto view () const ;
// returns tuple of reference to containers for Types
template <tt::one_of<Ts...>... Types>
auto view ();
template <tt::one_of<Ts...>... Types>
auto view () const ;
// visit
// visits with 'v' and passes its results into 'out_visitor' (if result is not void)
template <tt::one_of<Ts...>... Types>
void visit (visitor_for<Types...> auto && v, auto && out_visitor);
// ignores visitor results
template <tt::one_of<Ts...>... Types>
void visit (visitor_for<Types...> auto && v);
// visits with 'v' and passes its results into 'out_visitor' (if result is not void)
void visit_all (visitor_for<Ts...> auto && v, auto && out_visitor);
// ignores visitor results
constexpr void visit_all (visitor_for<Ts...> auto && v);
template <tt::one_of<Ts...>... Types, std::input_or_output_iterator Out>
constexpr Out visit_copy (visitor_for<Types...> auto && v, Out out);
template <tt::one_of<Ts...>... Types, std::input_or_output_iterator Out>
constexpr Out visit_copy (Out out);
// visits with 'v' and passes its results into output iterator 'out', returns 'out" after all
template <std::input_or_output_iterator Out>
constexpr Out visit_copy_all (visitor_for<Ts...> auto && v, Out out);
// passes all values into 'out' iterator, returns 'out' after all
template <std::input_or_output_iterator Out>
constexpr Out visit_copy_all (Out out);
// ...also const versions for visit...
};
例子：
aa::variant_swarm< int , double , std::string> f;
// no runtime dispatching here, its just overloads
f.inesrt( " hello world " );
f.insert( 5 );
f.insert( 3.14 );
auto visitor = []( auto && x) {
std::cout << x << ' t ' ;
};
f.visit_all(visitor); // prints 5, 3.14, "hello world"data_parallel_vector该容器的行为与std::vector<T>相同，但单独存储字段。
支持的操作： view<T> / view<I>获取该索引的所有字段的范围
T必须是聚合或类元组类型
注意： data_parallel_vector是一个随机访问范围 注意：忽略std::vector<bool>特化，表现为 bool 的法线向量
template < typename T, typename Alloc>
struct data_parallel_vector {
using value_type = T;
using allocator_type = Alloc;
using difference_type = std:: ptrdiff_t ;
using size_type = std:: size_t ;
using reference = proxy; // similar to vector<bool>::reference type
using const_reference = const_proxy;
void swap (data_parallel_vector&) noexcept ;
friend void swap (data_parallel_vector&) noexcept ;
data_parallel_vector () = default ;
explicit data_parallel_vector ( const allocator_type& alloc);
data_parallel_vector (size_type count, const value_type& value,
const allocator_type& alloc = allocator_type());
explicit data_parallel_vector (size_type count, const allocator_type& alloc = allocator_type());
template <std::input_iterator It>
data_parallel_vector (It first, It last, const allocator_type& alloc = allocator_type());
data_parallel_vector ( const data_parallel_vector& other, const allocator_type& alloc);
data_parallel_vector (data_parallel_vector&& other, const allocator_type& alloc);
data_parallel_vector (std::initializer_list<value_type> init,
const allocator_type& alloc = allocator_type());
// copy-move all default
data_parallel_vector& operator =(std::initializer_list<T> ilist);
using iterator;
using const_iterator;
iterator begin ();
const_iterator begin () const ;
iterator end ();
const_iterator end () const ;
const_iterator cbegin () const ;
const_iterator cend () const ;
reference front ();
const_reference front () const ;
reference back ();
reference back () const ;
reference operator [](size_type pos);
const_reference operator [](size_type pos) const ;
size_type capacity () const ;
size_type max_size () const ;
// returns tuple of spans to underlying containers
template < typename ... Types>
auto view ();
template < typename ... Types>
auto view () const ;
template <std:: size_t ... Nbs>
auto view ();
template <std:: size_t ... Nbs>
auto view () const ;
bool empty () const ;
size_type size () const ;
bool operator ==( const data_parallel_impl&) const = default ;
iterator emplace (const_iterator pos, element_t <Is>... fields);
reference emplace_back ( element_t <Is>... fields);
void push_back ( const value_type& v);
void push_back (value_type&& v);
iterator erase (const_iterator pos);
iterator erase (const_iterator b, const_iterator e);
iterator insert (const_iterator pos, const value_type& value);
iterator insert (const_iterator pos, value_type&& value);
iterator insert (const_iterator pos, size_type count, const T& value);
template <std::input_iterator It>
iterator insert (const_iterator pos, It first, It last);
iterator insert (const_iterator pos, std::initializer_list<value_type> ilist);
void assign (size_type count, const value_type& value);
template <std::input_iterator It>
void assign (It first, It last);
void assign (std::initializer_list<T> ilist);
void clear ();
void pop_back ();
void reserve (size_type new_cap);
void resize (size_type sz);
void resize (size_type sz, const value_type& v);
void shrink_to_fit ();
};
例子：
struct my_type {
int x;
float y;
bool l;
};
void foo () {
aa::data_parallel_vector<my_type> magic;
// ints, floats, bools are spans to all stored fields of my_type (&::x, &::y, &::l)
auto [ints, floats, bools] = magic;
magic. emplace_back ( 5 , 6 . f , true );
};获取内容：
include (FetchContent)
FetchContent_Declare(
AnyAny
GIT_REPOSITORY https://github.com/kelbon/AnyAny
GIT_TAG origin/main
)
FetchContent_MakeAvailable(AnyAny)
target_link_libraries (MyTargetName anyanylib) add_subdirectory (AnyAny)
target_link_libraries (MyTargetName PUBLIC anyanylib)buildgit clone https://github.com/kelbon/AnyAny
cd AnyAny
cmake . -B build
cmake --build buildgit clone https://github.com/kelbon/AnyAny
cd AnyAny/examples
cmake . -B build
