AnyAny

Irgendjemand

Bibliothek für effizienten dynamischen Polymorphismus durch Typlöschung (C++17 oder höher)

Ziele sind Effizienz, Verständlichkeit und Erweiterbarkeit.

clang, gcc, msvc

Siehe Ordner /examples für einen schnellen Start!

• How to build?

Grundlegendes Anwendungsbeispiel

Die Grundlage des Typlöschteils einer Bibliothek ist eine Methode – eine Beschreibung, welchen Teil des Typs wir nach dem Löschen verwenden möchten.

Erstellen wir eines zum Löschen von Typen mit void draw() :

Klicken Sie hier, um eine kurze Syntax mit Makros anzuzeigen

Es gibt das Makro anyany_method in <anyany/anyany_macro.hpp>, zum Beispiel für die Methode „foo“, die int akzeptiert und float + float zurückgibt

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

Wir können Draw zum Löschen von Schriftarten verwenden:

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

Und jetzt können wir any_drawable verwenden, um jeden Typ mit .draw() zu speichern

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

Es gibt keine virtuellen Funktionen, Vererbung, Zeiger, Speicherverwaltung usw.! Hübsch!

Sie können beliebig viele Methoden hinzufügen:

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

Warten, kopieren...? Ja, standardmäßig verfügt aa::any_with nur über einen Destruktor. Sie können die Methode aa::copy hinzufügen, um es kopierbar und verschiebbar zu machen, oder aa::move , um es nur verschieben zu lassen

Vordefinierte Methoden :

Kopie

Macht any_with kopierbar und verschiebbar, aktiviert aa::materialize für Referenzen (dies erfordert auch aa::destroy -Methode)

Es gibt auch copy_with<Alloc, SooS> , dies ermöglicht das Kopieren, wenn Sie einen benutzerdefinierten Allocator und Small Object Optimization Size ( aa::basic_any_with ) verwenden.

bewegen

macht 'any_with' beweglich

Hinweis: Verschiebekonstruktor und Verschiebezuweisungsoperator für any_with immer „noexclusive“.

Hash

Aktiviert std::hash -Spezialisierung für any_with , poly_ref /...etc. Wenn any_with leer ist, dann ist hash == 0.

Hinweis: poly_ptr verfügt standardmäßig über die Spezialisierung std::hash , es handelt sich jedoch um einen zeigerähnlichen Hash.

type_info

Aktiviert aa::any_cast , aa::type_switch , aa::visit_invoke durch Hinzufügen von RTTI in vtable.

Fügt außerdem .type_descriptor() -> aa::descriptor_t für any_with / poly_ref /...etc hinzu.

equal_to

aktiviert operator== für any_with / poly_ref /...etc.

Zwei Objekte sind gleich, wenn sie denselben Typ enthalten (oder beide leer sind) und die gespeicherten Werte gleich sind.

Raumschiff

Aktiviert operator<=> und operator== für any_with / poly_ref /...etc“.

Hinweis: operapator<=> gibt immer std::partial_ordering zurück.

Wenn zwei Objekte nicht denselben Typ enthalten, wird unordered zurückgegeben, andernfalls wird das Ergebnis des operator <=> für enthaltene Objekte zurückgegeben.

Hinweis: Gibt std::partial_ordering::equivalent zurück, wenn beide leer sind

call<R(Args...)>

fügt R operator()(Args...) für any_with / poly_ref /...usw. hinzu.

Hinweis: Es werden auch die Signaturen const , noexcept und const noexcept unterstützt

Beispiel:

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

zerstören

fügt den Destruktor hinzu ( any_with hat ihn standardmäßig), aber vielleicht möchten Sie ihn mit aa::poly_ptr verwenden, um die Lebensdauer manuell zu verwalten. Aktiviert außerdem aa::materialize für Referenzen (erfordert auch aa::copy)

Weitere Informationen zu Methoden finden Sie im method in anyany.hpp

Polymorphe Typen:

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

Aktionen:

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

Polymorphe Container:

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

Informationen zur Kompilierungszeit

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

Sie können Merkmale für Ihre polymorphen Hierarchien definieren (LLVM-ähnliche Typ-IDs, virtuelle Funktionen usw.).

In der Bibliothek sind zwei solcher Merkmale integriert (Sie können sie als Beispiel für die Implementierung Ihrer eigenen verwenden):

• anyany_poly_traits – für Typen aus <anyany.hpp>
• std_variant_poly_traits – für std::variant (<anyany/utility.hpp> Header)

Schnittstellenfunktionen

Beispielsweise möchten Sie, dass die Methode .foo() im Typ any_with oder poly_ref mit Ihrer Methode erstellt wird.

Dann sollten Sie plugins verwenden:

 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!

Hinweis: Sie können andere Plugins „überschreiben/überschreiben“, indem Sie sie in Ihrem Plugin erben (auch wenn die Vererbung privat ist).

Siehe zum Beispiel aa::spaceship/aa::copy_with Plugins

Sie können auch aa::plugin<Any, Method> für Ihre Methode oder sogar für „Any“ mit einigen Anforderungen spezialisieren

any_with

Akzeptiert eine beliebige Anzahl von Methoden und erstellt einen Typ, der jeden Wert enthalten kann, der diese Methoden unterstützt. Ähnlich dem Laufzeitkonzept

Hinweis: Es gibt das Tag „aa::force_stable_pointers“, um die Zuweisung zu erzwingen, sodass poly_ptr/cptr zu any_with<...> nach dem Verschieben nicht ungültig wird.

Hinweis: aa::unreachable_allocator , wodurch die Kompilierung unterbrochen wird, wenn basic_any_with<unreachable_allocator, ...> versucht, Speicher zuzuweisen. Sie können also die Nichtzuweisung in Typen erzwingen

Schnittstelle des erstellten Typs

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

Alle Konstruktoren und Kopier-/Verschiebezuweisungsoperatoren verfügen über eine starke Ausnahmegarantie

Hinweis: Wenn Ihr Typ über den Konstruktor „noexclusive move“ verfügt, kann dies die Leistung erheblich steigern (wie im Fall „std::vector“).

Beispiel:

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

basic_any_with

Wie any_with , aber mit benutzerdefinierter Zuordnung und kleiner Puffergröße für die Objektoptimierung – wenn Sie ein kopierbares basic_any_with benötigen, verwenden Sie copy_with

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

poly_ref

Nicht besitzend, immer nicht null, leichtgewichtig (~=void*)

poly_ref<Methods...> implizit in eine kleinere Anzahl von Methoden konvertierbar.

poly_ref<A, B, C> ist konvertierbar in poly_ref<A, B> , poly_ref<A> , poly_ref<B> ... usw. usw.

Das bedeutet, dass Sie in der Schnittstelle von Funktionen nur Methoden hinzufügen können, die sie wirklich benötigen. Wenn Sie dann Method zu Ihrem Typ any_with hinzufügen, gibt es KEINE Abi/API-Unterbrechung.

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

Schnittstelle

 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

Wie poly_ref , kann aber aus poly_ref und const T& erstellt werden

aa::cref ist ein Vorlagenalias für aa::const_poly_ref

Hinweis: Verlängert nicht die Lebensdauer

poly_ptr

Nicht besitzend, nullbar, leichtgewichtig (~=void*)

poly_ptr<Methods...> implizit in eine kleinere Anzahl von Methoden konvertierbar.

poly_ptr<A, B, C> ist konvertierbar in poly_ptr<A, B> , poly_ptr<A> , poly_ptr<B> ... usw. usw.

Das bedeutet, dass Sie in der Schnittstelle von Funktionen nur Methoden hinzufügen können, die sie wirklich benötigen. Wenn Sie dann Method zu Ihrem Typ any_with hinzufügen, gibt es KEINE Abi/API-Unterbrechung.

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

Hinweis: poly_ptr und const_poly_ptr sind trivial kopierbar, daher funktioniert std::atomic<poly_ptr<...>> .

Schnittstelle

 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

Wie poly_ptr , kann aber aus poly_ptr und const T* / Any* erstellt werden

aa::cptr ist ein Vorlagenalias für aa::const_poly_ptr

stateful_ref

aa::stateful::ref<Methods...> enthält vtable in sich.

Kann auch Verweise auf C-Arrays und Funktionen ohne Zerfall enthalten

Es hat eine ziemlich einfache Schnittstelle, die nur aus T&/poly_ref erstellt und aufgerufen wird (z. B. durch aa::invoke).

Die maximale Leistung wird erzielt, wenn Sie 1-2 Methoden löschen müssen und nicht any_cast verwenden müssen.

Typischer Anwendungsfall – Erstellen einer 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

Identisch mit stateful::ref , kann aber aus const T& und aa::cref erstellt werden

Aktionen

any_cast

erfordert die Methode aa::type_info

Funktionsobjekt mit Operator():

Funktioniert als std::any_cast – Sie können in T(copy), T&(take ref) konvertieren (wird aa::bad_cast auslösen, wenn die Umwandlung fehlerhaft ist)

Oder Sie können einen Zeiger (oder poly_ptr) übergeben (gibt nullptr zurück, wenn die Umwandlung fehlerhaft ist)

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

Beispiel:

 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

Funktionales Objekt mit „operator()“, das any_with/ref/cref/stateful::ref/stateful::cref als erstes Argument und dann alle Argumente von „Method“ akzeptiert und „Method“ aufruft

Wenn arg const any_with oder cref ist, sind nur const-Methoden zulässig.

Voraussetzung: any.has_value() == true

Beispiel:

 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

Wählt .case basierend auf dem dynamischen Typ des Eingabearguments aus und ruft visitor mit diesem dynamischen Typ oder dieser Standardfunktion auf

Unterstützt auch poly_traits als zweites Vorlagenargument, sodass es jeden Typ unterstützt, für den Sie Poly-Traits haben

Schnittstelle

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

};

Beispiel:

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

visit_invoke

Es ist... Laufzeitüberlastungsauflösung! aa::make_visit_invoke<Foos...> erstellt ein Überlastungssatzobjekt mit der Methode .resolve(Args...) , die eine Überlastungsauflösung basierend auf Args...-Laufzeittypen durchführt.

Resolve gibt nullopt zurück, wenn keine solche Funktion zum Akzeptieren von Eingabeargumenten vorhanden ist

Dieses Beispiel ist sehr einfach, siehe auch /examples/visit_invoke_example.hpp für mehr

Beispiel:

 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

Polymorpher Containeradapter, der sich wie Container<std::variant<Types...>> verhält, aber viel effektiver ist.

Unterstützt Operationen:

• visit<Types...>(visitor) – ruft visitor mit allen enthaltenen Werten der Typen Types auf
• view<T> – gibt einen Verweis auf den Container aller gespeicherten Werte vom Typ T zurück

Der Container ist standardmäßig ein std::vector .

Schnittstelle

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

Beispiel:

  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

Dieser Container verhält sich wie std::vector<T> , speichert Felder jedoch separat.

Unterstützte Operation: view<T> / view<I> um alle Felder dieses Index abzurufen

T muss ein aggregierter oder tupelartiger Typ sein

Hinweis: data_parallel_vector ist ein Direktzugriffsbereich. Hinweis: ignoriert die Spezialisierung std::vector<bool> und verhält sich wie ein normaler Vektor für Bools

Schnittstelle

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

Beispiel:

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

Verwendung mit CMake

Inhalt abrufen:

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

oder verwenden Sie add_subdirectory

1. Klonen Sie dieses Repository in den Ordner mit Ihrem Projekt. 2. Fügen Sie diese Zeilen zu seiner CMakeLists.txt hinzu

 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

Baubeispiele

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