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
