AnyAny

QualquerQualquer

Biblioteca para polimorfismo dinâmico eficiente por meio de apagamento de tipo (C++17 ou posterior)

Os objetivos são eficiência, compreensibilidade e extensibilidade.

clang, gcc, msvc

Veja a pasta /examples para início rápido!

• How to build?

Exemplo de uso básico

A base da parte de apagamento de tipo da biblioteca é um método - uma descrição de qual parte do tipo queremos usar após o apagamento.

Vamos criar um para apagar tipos com void draw() :

clique aqui para ver uma breve sintaxe com macros

Há macro anyany_method em <anyany/anyany_macro.hpp> Por exemplo, para o método 'foo', que aceita int e float + retorna 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 ();
  }
};

Podemos usar Draw para apagar tipos:

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

E agora podemos usar any_drawable para armazenar qualquer tipo com .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
}

Não há funções virtuais, herança, ponteiros, gerenciamento de memória, etc.! Legal!

Você pode adicionar qualquer número de métodos :

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

Espere, copie...? Sim, por padrão aa::any_with só tem um destruidor, você pode adicionar um método aa::copy para torná-lo copiável e móvel ou aa::move para torná-lo apenas móvel

Métodos predefinidos:

cópia

torna any_with copiável e móvel, permite aa::materialize para referências (isso também requer um método aa::destroy )

Há também copy_with<Alloc, SooS> , isso permite a cópia quando você usa Allocator personalizado e Small Object Optimization Size( aa::basic_any_with )

mover

torna 'any_with' móvel

Nota: mova o construtor e mova o operador de atribuição para any_with sempre noexcept

hash

habilita a especialização std::hash para any_with , poly_ref /...etc. Se any_with estiver vazio, então hash == 0.

Nota: poly_ptr tem especialização em std::hash por padrão, mas é um hash semelhante a um ponteiro.

tipo_info

ativa aa::any_cast , aa::type_switch , aa::visit_invoke adicionando RTTI em vtable.

Também adiciona .type_descriptor() -> aa::descriptor_t para any_with / poly_ref /...etc.

igual_a

ativa operator== para any_with / poly_ref /...etc.

Dois objetos são iguais se contiverem o mesmo tipo (ou ambos vazios) e os valores armazenados forem iguais.

nave espacial

ativa operator<=> e operator== para any_with / poly_ref /...etc.

Nota: operator<=> sempre retorna std::partial_ordering .

Se dois objetos não contiverem o mesmo tipo, retornará unordered , caso contrário, retornará o resultado do operator <=> para objetos contidos.

Nota: retorna std::partial_ordering::equivalent se ambos estiverem vazios

chamar<R(Args...)>

adiciona R operator()(Args...) para any_with / poly_ref /...etc.

Nota: também suporta assinaturas const , noexcept e const noexcept

exemplo:

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

destruir

adiciona destruidor ( any_with tem por padrão), mas talvez você queira usá-lo com aa::poly_ptr para gerenciar manualmente o tempo de vida. Também permite aa::materialize para referências (também requer aa::copy)

Veja o conceito method em anyany.hpp se quiser todos os detalhes sobre métodos

Tipos polimórficos:

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

Ações:

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

Recipientes polimórficos:

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

Compilar informações de tempo

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

Você pode definir características para suas hierarquias polimórficas (IDs de tipo semelhante a LLVM, funções virutais, etc.).

A biblioteca possui duas dessas características integradas (você pode usá-las como exemplo para implementar as suas próprias):

• anyany_poly_traits - para tipos de <anyany.hpp>
• std_variant_poly_traits - para std::variant (cabeçalho <anyany/utility.hpp>)

Recursos de interface

Por exemplo, você deseja ter o método .foo() no tipo criado por any_with ou poly_ref com seu Method .

Então você deve usar 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!

Nota: Você pode 'sombrear/substituir' outros plug-ins herdando deles em seu plug-in (mesmo que a herança seja privada)

Veja plug-ins aa::spaceship/aa::copy_with por exemplo

Além disso, você pode especializar aa::plugin<Any, Method> para o seu método ou mesmo para 'Any' com alguns requisitos

any_with

Aceita qualquer número de Methods e cria um tipo que pode conter qualquer valor, que suporte esses Methods . Semelhante ao conceito de tempo de execução

Nota: Existe a tag 'aa::force_stable_pointers' para forçar a alocação, portanto poly_ptr/cptr para any_with<...> não será invalidado após a movimentação.

Nota: aa::unreachable_allocator , que interromperá a compilação, se basic_any_with<unreachable_allocator, ...> tentar alocar memória. Então você pode forçar a não alocação de tipos

Interface do tipo criado

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

Todos os construtores e operadores de atribuição de copiar/mover têm forte garantia de exceção

Nota: se o seu tipo tiver noexcept move construtor, ele pode realmente aumentar o desempenho (como no caso std::vector).

Exemplo:

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

basic_any_with

O mesmo que any_with , mas com alocação personalizada e tamanho de buffer de otimização de objeto pequeno - se você precisar de um basic_any_with copiável, use copy_with

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

poly_ref

Sem propriedade, sempre não nulo, leve(~=void*)

poly_ref<Methods...> implicitamente conversível em uma contagem menor de métodos.

poly_ref<A, B, C> é conversível para poly_ref<A, B> , poly_ref<A> , poly_ref<B> ... etc etc.

Isso significa que você pode adicionar na interface das funções apenas os métodos que elas realmente exigem. Então, se você adicionar Método ao seu tipo any_with , NÃO haverá quebra de abi/api.

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

Interface

 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

O mesmo que poly_ref , mas pode ser criado a partir de poly_ref e const T&

aa::cref é um alias de modelo para aa::const_poly_ref

Nota: não prolonga a vida útil

poly_ptr

Não proprietário, anulável, leve(~=void*)

poly_ptr<Methods...> implicitamente conversível em uma contagem menor de métodos.

poly_ptr<A, B, C> é conversível para poly_ptr<A, B> , poly_ptr<A> , poly_ptr<B> ... etc etc.

Isso significa que você pode adicionar na interface das funções apenas os métodos que elas realmente exigem. Então, se você adicionar Método ao seu tipo any_with , NÃO haverá quebra de abi/api.

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

Nota: poly_ptr e const_poly_ptr são trivialmente copiáveis, então std::atomic<poly_ptr<...>> funciona.

Interface

 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

O mesmo que poly_ptr , mas pode ser criado a partir de poly_ptr e const T* / Any*

aa::cptr é um alias de modelo para aa::const_poly_ptr

stateful_ref

aa::stateful::ref<Methods...> contém vtable em si.

Também pode conter referências a matrizes C e funções sem decaimento

Possui interface bastante simples, apenas criando a partir de T&/poly_ref e invocando (por aa::invoke por exemplo)

Ele terá desempenho máximo se você precisar apagar 1-2 métodos e não precisar usar any_cast .

Caso de uso típico - criação de uma 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

O mesmo que stateful::ref , mas pode ser criado a partir de const T& e aa::cref

Ações

any_cast

requer o método aa::type_info

Objeto funcional com operador():

Funciona como std::any_cast - você pode converter para T(copy), T&(take ref) (lança aa::bad_cast se a conversão for ruim)

Ou você pode passar pointer(ou poly_ptr) (retorna nullptr, se a conversão for ruim)

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

Exemplo:

 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

Objeto funcional com operador(), que aceita any_with/ref/cref/stateful::ref/stateful::cref como primeiro argumento e depois todos os argumentos de Method e invoca Method

Se arg for const any_with ou cref , apenas métodos const serão permitidos.

pré-condição: any.has_value() == true

Exemplo:

 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

Seleciona .case com base no tipo dinâmico de argumento de entrada e invoca visitor com este tipo dinâmico ou função padrão

Também suporta poly_traits como segundo argumento de modelo, portanto suporta qualquer tipo para o qual você tenha poly traits

Interface

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

};

Exemplo:

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

visit_invoke

É... resolução de sobrecarga de tempo de execução! aa::make_visit_invoke<Foos...> cria um objeto de conjunto de sobrecarga com o método .resolve(Args...) , que executa a resolução de sobrecarga com base nos tipos de tempo de execução Args....

Resolve retorna nullopt se não existir tal função para aceitar argumentos de entrada

Este exemplo é muito básico, consulte também /examples/visit_invoke_example.hpp para obter mais informações

Exemplo:

 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

Adaptador de contêiner polimórfico, que se comporta como Container<std::variant<Types...>> , mas muito mais eficaz.

Suporta operações:

• visit<Types...>(visitor) - invoca visitor com todos os valores contidos dos tipos Types
• view<T> - retorna referência ao contêiner de todos os valores armazenados do tipo T

O contêiner é um std::vector por padrão.

Interface

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

Exemplo:

  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

Este contêiner se comporta como std::vector<T> , mas armazena campos separadamente.

Operação suportada: view<T> / view<I> para obter span para todos os campos deste índice

T deve ser do tipo agregado ou semelhante a tupla

Nota: data_parallel_vector é um intervalo de acesso aleatório Nota: ignora a especialização std::vector<bool> , se comporta como um vetor normal para bools

Interface

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

Exemplo:

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

Usando com CMake

Buscar conteúdo:

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

ou use add_subdirectory

1. Clone este repositório na pasta com seu projeto 2. Adicione estas linhas ao CMakeLists.txt

 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

construir exemplos

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