AnyAny

Apa saja

Pustaka untuk polimorfisme dinamis yang efisien melalui penghapusan tipe (C++17 atau lebih baru)

Sasarannya adalah efisiensi, pemahaman, dan ekstensibilitas.

dentang, gcc, msvc

Lihat folder /examples untuk memulai dengan cepat!

• How to build?

Contoh penggunaan dasar

Landasan bagian tipe penghapusan perpustakaan adalah Metode - deskripsi bagian tipe mana yang ingin kita gunakan setelah penghapusan.

Mari kita buat satu untuk menghapus tipe dengan void draw() :

klik di sini untuk melihat sintaksis singkat dengan makro

Ada makro anyany_method di <anyany/anyany_macro.hpp> Misalnya, untuk Metode 'foo', yang menerima int dan float + mengembalikan 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 ();
  }
};

Kita dapat menggunakan Draw untuk penghapusan tipe:

# include < anyany/anyany.hpp >
using any_drawable = aa::any_with<Draw>;

Dan sekarang kita bisa menggunakan any_drawable untuk menyimpan tipe apa pun dengan .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
}

Tidak ada fungsi virtual, warisan, pointer, manajemen memori, dll! Bagus!

Anda dapat menambahkan sejumlah Metode :

 using any_my = aa::any_with<Draw, Run, aa::copy>;

Tunggu, salin...? Ya, secara default aa::any_with hanya memiliki destruktor, Anda dapat menambahkan metode aa::copy untuk membuatnya dapat disalin dan dipindahkan atau aa::move untuk membuatnya hanya bergerak

Metode yang Telah Ditentukan Sebelumnya:

menyalin

membuat any_with dapat disalin dan dipindahkan, mengaktifkan aa::materialize untuk referensi (ini juga memerlukan metode aa::destroy )

Ada juga copy_with<Alloc, SooS> , ini memungkinkan penyalinan saat Anda menggunakan Allocator khusus dan Ukuran Pengoptimalan Objek Kecil ( aa::basic_any_with )

bergerak

membuat 'any_with' dapat dipindahkan

Catatan: pindahkan konstruktor dan pindahkan operator penugasan untuk any_with selalu tanpa kecuali

hash

mengaktifkan std::hash spesialisasi untuk any_with , poly_ref /...etc. Jika any_with kosong, maka hash == 0.

Catatan: poly_ptr memiliki spesialisasi std::hash secara default, tetapi ini adalah hash seperti penunjuk.

ketik_info

mengaktifkan aa::any_cast , aa::type_switch , aa::visit_invoke dengan menambahkan RTTI di vtable.

Juga menambahkan .type_descriptor() -> aa::descriptor_t untuk any_with / poly_ref /...etc.

sama_dengan

mengaktifkan operator== untuk any_with / poly_ref /...etc.

Dua objek dikatakan sama jika keduanya berisi tipe yang sama (atau keduanya kosong) dan nilai yang disimpan adalah sama.

pesawat ruang angkasa

mengaktifkan operator<=> dan operator== untuk any_with / poly_ref /...etc.

Catatan: operpator<=> selalu mengembalikan std::partial_ordering .

Jika dua objek tidak berisi tipe yang sama, kembalikan unordered , jika tidak, kembalikan hasil operator <=> untuk objek yang terkandung.

Catatan: mengembalikan std::partial_ordering::equivalent jika keduanya kosong

panggilan<R(Args...)>

menambahkan R operator()(Args...) untuk any_with / poly_ref /...etc.

Catatan: juga mendukung tanda tangan const , noexcept dan const noexcept

contoh:

 // 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 );
}

menghancurkan

menambahkan destruktor ( any_with memilikinya secara default), tetapi mungkin Anda ingin menggunakannya dengan aa::poly_ptr untuk mengelola seumur hidup secara manual. Juga mengaktifkan aa::materialize untuk referensi (juga memerlukan aa::copy)

Lihat konsep method di anyany.hpp jika Anda ingin semua detail tentang Metode

Jenis polimorfik:

• any_with<Methods...>
• basic_any_with<Methods...>
• poly_ref<Methods...>
• poly_ptr<Methods...>
• cref<Methods...>
• cptr<Methods...>
• stateful::ref<Methods...>
• stateful::cref<Methods...>

Tindakan:

• any_cast<T>
• invoke<Method>
• type_switch
• visit_invoke

Wadah polimorfik:

• variant_swarm<Ts...>
• data_parallel_vector<T, Alloc>

Kumpulkan informasi waktu

 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) };
                      };

Anda dapat menentukan ciri-ciri untuk hierarki polimorfik Anda (ID tipe seperti LLVM, fungsi virutal, dll).

Perpustakaan memiliki dua sifat bawaan (Anda dapat menggunakannya sebagai contoh untuk menerapkan sifat Anda sendiri):

• anyany_poly_traits - untuk tipe dari <anyany.hpp>
• std_variant_poly_traits - untuk std::variant (tajuk <anyany/utility.hpp>)

Fitur antarmuka

Misalnya, Anda ingin memiliki metode .foo() dalam tipe yang dibuat oleh any_with atau poly_ref dengan Method Anda.

Maka Anda harus menggunakan 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!

Catatan: Anda dapat 'membayangi/menimpa' plugin lain dengan mewarisi plugin tersebut di plugin Anda (meskipun warisan bersifat pribadi)

Lihat plugin aa::spaceship/aa::copy_with misalnya

Anda juga dapat mengkhususkan aa::plugin<Any, Method> untuk Metode Anda atau bahkan untuk 'Apa Pun' dengan beberapa persyaratan

any_with

Menerima sejumlah Methods dan membuat tipe yang dapat menyimpan nilai apa pun, yang mendukung Methods tersebut. Mirip dengan konsep runtime

Catatan: Ada tag 'aa::force_stable_pointers' untuk memaksa alokasi, jadi poly_ptr/cptr ke any_with<...> tidak akan dibatalkan setelah dipindahkan.

Catatan: aa::unreachable_allocator , yang akan merusak kompilasi, jika basic_any_with<unreachable_allocator, ...> mencoba mengalokasikan memori. Jadi Anda bisa memaksakan tipe tanpa alokasi

Antarmuka tipe yang dibuat

 // 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 ...
};

Semua konstruktor dan operator penugasan salin/pindah memiliki jaminan pengecualian yang kuat

Catatan: jika tipe Anda tidak memiliki konstruktor pemindahan, itu benar-benar dapat meningkatkan kinerja (seperti dalam kasus std::vector).

Contoh:

 using any_printable = aa::any_with<Print, aa::move>;

basic_any_with

Sama seperti any_with , tetapi dengan alokasi khusus dan ukuran buffer pengoptimalan objek kecil - jika Anda memerlukan basic_any_with yang dapat disalin, gunakan copy_with

 template < typename Alloc, size_t SooS, TTA... Methods>
using basic_any_with = /* ... */ ;

poly_ref

Tidak memiliki, selalu bukan null, ringan(~=void*)

poly_ref<Methods...> secara implisit dapat dikonversi ke jumlah Metode yang lebih kecil.

poly_ref<A, B, C> dapat diubah menjadi poly_ref<A, B> , poly_ref<A> , poly_ref<B> ... dll.

Ini berarti Anda dapat menambahkan antarmuka fungsi hanya Metode yang benar-benar diperlukan. Kemudian jika Anda menambahkan Metode ke tipe any_with Anda, TIDAK ada jeda abi/api.

 // you can invoke this function with any poly_ref<..., A, ...>
void foo (poly_ref<A>);

Antarmuka

 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

Sama seperti poly_ref , tetapi dapat dibuat dari poly_ref dan const T&

aa::cref adalah alias templat untuk aa::const_poly_ref

Catatan: jangan memperpanjang seumur hidup

poly_ptr

Tidak memiliki, dapat dibatalkan, ringan (~=void*)

poly_ptr<Methods...> secara implisit dapat dikonversi ke jumlah Metode yang lebih kecil.

poly_ptr<A, B, C> dapat diubah menjadi poly_ptr<A, B> , poly_ptr<A> , poly_ptr<B> ... dll.

Ini berarti Anda dapat menambahkan antarmuka fungsi hanya Metode yang benar-benar diperlukan. Kemudian jika Anda menambahkan Metode ke tipe any_with Anda, TIDAK ada jeda abi/api.

 // you can invoke this function with any poly_ptr<..., A, ...>
void foo (poly_ptr<A>);

Catatan: poly_ptr dan const_poly_ptr dapat disalin dengan mudah, jadi std::atomic<poly_ptr<...>> berfungsi.

Antarmuka

 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

Sama seperti poly_ptr , tetapi dapat dibuat dari poly_ptr dan const T* / Any*

aa::cptr adalah alias templat untuk aa::const_poly_ptr

stateful_ref

aa::stateful::ref<Methods...> berisi vtable itu sendiri.

Juga dapat berisi referensi ke C-array dan fungsi tanpa pembusukan

Ini memiliki antarmuka yang cukup sederhana, hanya membuat dari T&/poly_ref dan memanggil (misalnya dengan aa::invoke)

Ini akan memiliki kinerja maksimal jika Anda perlu menghapus 1-2 Metode dan tidak perlu menggunakan any_cast .

Kasus penggunaan umum - membuat 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

Sama seperti stateful::ref , tetapi dapat dibuat dari const T& dan aa::cref

Tindakan

any_cast

membutuhkan metode aa::type_info

Objek fungsional dengan operator():

Berfungsi sebagai std::any_cast - Anda dapat mengonversi ke T(copy), T&(take ref) (melempar aa::bad_cast jika castnya buruk)

Atau Anda dapat meneruskan pointer (atau poly_ptr) (mengembalikan nullptr, jika cast buruk)

T* ptr = any_cast<T>(&any);

Contoh:

 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

Objek fungsional dengan operator(), yang menerima any_with/ref/cref/stateful::ref/stateful::cref sebagai argumen pertama dan kemudian semua argumen Method dan memanggil Method

Jika arg adalah const any_with atau cref , maka hanya Metode const yang diizinkan.

prasyarat: any.has_value() == true

Contoh:

 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

Memilih .case berdasarkan tipe dinamis arg input dan memanggil visitor dengan tipe dinamis atau fungsi default ini

Juga mendukung poly_traits sebagai argumen templat kedua, sehingga mendukung semua jenis yang Anda miliki sifat polinya

Antarmuka

 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 ();

};

Contoh:

  Result val = aa::type_switch<Result>(value)
      .case_< float >(foo1)
      .case_< bool >(foo2)
      .cases< char , int , unsigned char , double >(foo3)
      .default_( 15 );

visit_invoke

Ini... resolusi kelebihan waktu proses! aa::make_visit_invoke<Foos...> membuat objek kumpulan kelebihan beban dengan metode .resolve(Args...) , yang melakukan resolusi kelebihan beban berdasarkan jenis runtime Args....

Resolve mengembalikan nullopt jika tidak ada fungsi yang menerima argumen input

Contoh ini sangat mendasar, lihat juga /examples/visit_invoke_example.hpp untuk informasi lebih lanjut

Contoh:

 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

Adaptor kontainer polimorfik, yang berperilaku seperti Container<std::variant<Types...>> , tetapi jauh lebih efektif.

Mendukung operasi:

• visit<Types...>(visitor) - memanggil visitor dengan semua nilai tipe Types yang terkandung
• view<T> - mengembalikan referensi ke wadah semua nilai tersimpan tipe T

Kontainer adalah std::vector secara default.

Antarmuka

 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...
};

Contoh:

  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

Wadah ini berperilaku seperti std::vector<T> , tetapi menyimpan bidang secara terpisah.

Operasi yang didukung: view<T> / view<I> untuk menjangkau semua bidang indeks ini

T harus berupa tipe agregat atau seperti tuple

Catatan: data_parallel_vector adalah rentang akses acak Catatan: mengabaikan spesialisasi std::vector<bool> , berperilaku seperti vektor normal untuk bools

Antarmuka

 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 ();
};

Contoh:

 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 );
};

Menggunakan dengan CMake

Ambil konten:

 include (FetchContent)
FetchContent_Declare(
  AnyAny
  GIT_REPOSITORY https://github.com/kelbon/AnyAny
  GIT_TAG        origin/main
)
FetchContent_MakeAvailable(AnyAny)
target_link_libraries (MyTargetName anyanylib)

atau gunakan add_subdirektori

1. Kloning repositori ini ke folder dengan proyek Anda 2. Tambahkan baris ini ke CMakeLists.txt-nya

 add_subdirectory (AnyAny)
target_link_libraries (MyTargetName PUBLIC anyanylib)

build

git clone https://github.com/kelbon/AnyAny
cd AnyAny
cmake . -B build
cmake --build build

membangun contoh

git clone https://github.com/kelbon/AnyAny
cd AnyAny/examples
cmake . -B build