explicit()

template<typename... Ts>

template<typename... Us>
requires ((sizeof...(Us) == sizeof...(Ts)) && (!std::same_as<tuple<Ts...>, tuple<Us...>>) && _::piecewise_constructible<tuple<Ts const&...>, tuple<Us...>>)

kumi::tuple< Ts >::explicit ( !_::piecewise_convertible< tuple< Ts const &... >, tuple< Us... > >  ) const

inline

Enables static casting a tuple<Ts...> to a tuple<Us...>.

Template Parameters

Us	Types composing the destination tuple

Note

This permits the conversion from a tuple<T>& to a tuple<T&> which makes it suitable for some zip-like cases such as building a structure of arrays iterator.

Example :

 
#include <kumi/kumi.hpp>
#include <iostream>
 
int main()
{
  kumi::tuple a = { 65, 2.3, 4.5f};
  auto b = static_cast<kumi::tuple<char,int,double>>(a);
 
  std::cout << a << "\n";
  std::cout << b << "\n";
}

#include <iostream>
#include <kumi/kumi.hpp>
 
#include <algorithm>
#include <ranges>
#include <vector>
 
template <class... Ts>
struct soa
{
  kumi::tuple<std::vector<Ts>...> fields;
 
  struct iterator 
  {
    using value_type = kumi::tuple<Ts...>;
 
    soa* s;
    std::size_t i;
 
    auto operator==(iterator b)   const -> bool { return i ==  b.i; }
    auto operator<=>(iterator b)  const         { return i <=> b.i; }
 
    auto operator++() ->iterator& { ++i; return *this; }
    auto operator--() ->iterator& { --i; return *this; }
    auto operator++(int) ->iterator { auto copy = *this; ++*this; return copy; }
    auto operator--(int) ->iterator { auto copy = *this; --*this; return copy; }
 
    friend auto operator+(iterator a, std::size_t b) -> iterator{ return {.s = a.s, .i = a.i + b}; }
    friend auto operator+(std::size_t a, iterator b) -> iterator{ return {.s = b.s, .i = a + b.i}; }
    friend auto operator-(iterator a, std::size_t b) -> iterator{ return {.s = a.s, .i = a.i - b}; }
    friend auto operator-(std::size_t a, iterator b) -> iterator{ return {.s = b.s, .i = a - b.i}; }
 
    auto operator+=(std::size_t b) -> iterator& { i += b; return *this; }
    auto operator-=(std::size_t b) -> iterator& { i -= b; return *this; }
    
    auto operator-(iterator b) const -> std::ptrdiff_t { return i - b.i; }
 
    auto operator*() const 
    {
      return kumi::apply([&](auto&... vs) { return kumi::tie(vs[i]...); }, s->fields);
    }
    
    auto operator[](std::ptrdiff_t b) const 
    { 
      return kumi::apply([&](auto&... vs) { return kumi::tie(vs[i + b]...); }, s->fields);
    }
  };
 
    auto begin()  -> iterator { return {.s = this, .i = 0                           }; }
    auto end()    -> iterator { return {.s = this, .i = kumi::get<0>(fields).size() }; }
};
 
static_assert(std::random_access_iterator<soa<int>::iterator>);
 
int main()
{
  soa<float,int> s;
  get<0>(s.fields) = {1.2,2.3,3.4,4.5};
  get<1>(s.fields) = {10,20,30,40};
 
  for(auto e : s)
    std::cout << e << "\n";
}