from_record()

template<concepts::record_type Type, typename... Ts>

auto from_record ( record< Ts... > const & r )

related

Converts a kumi::record to an instance of a type that models kumi::record_type.

Constructs an instance of Type by passing elements of t to the appropriate constructor.

Template Parameters

Type	Type to generate

Parameters

r	kumi::record to convert

Returns

An instance of Type constructed from each element of t in order.

Example

#include <kumi/kumi.hpp>
#include <iostream>
#include <string>
 
using namespace kumi::literals;
 
struct my_struct
{
  int         i;
  float       f;
  std::string name;
};
 
template<std::size_t I>
decltype(auto) get(my_struct const & m) noexcept
{
  if constexpr (I==0) return kumi::capture_field<"i"_id>(m.i);
  if constexpr (I==1) return kumi::capture_field<"f"_id>(m.f);
  if constexpr (I==2) return kumi::capture_field<"name"_id>(m.name);
}
 
template<std::size_t I>
decltype(auto) get(my_struct & m) noexcept
{
  if constexpr (I==0) return kumi::capture_field<"i"_id>(m.i);
  if constexpr (I==1) return kumi::capture_field<"f"_id>(m.f);
  if constexpr (I==2) return kumi::capture_field<"name"_id>(m.name);
}
 
// Opt-in for Record Type semantic
template<>
struct kumi::is_record_type<my_struct> : std::true_type
{};
 
// Adapt as structured bindable type
template<>
struct  std::tuple_size<my_struct> : std::integral_constant<std::size_t,3> 
{};
 
template<> struct std::tuple_element<0,my_struct> { using type = kumi::field<kumi::name<"i">   , int        >; };
template<> struct std::tuple_element<1,my_struct> { using type = kumi::field<kumi::name<"f">   , float      >; };
template<> struct std::tuple_element<2,my_struct> { using type = kumi::field<kumi::name<"name">, std::string>; };
 
int main()
{
  using namespace kumi::literals;
 
  auto a = kumi::make_record("f"_id=2.3475f, "name"_id="John", "i"_id=1337);
  auto b = from_record<my_struct>( a );
 
  std::cout << a << "\n";
  std::cout << b.i << ' ' << b.f << ' ' << b.name << "\n";
}