21 Metaprogramming library [meta]

Let CharT be ranges​::​range_value_t<R>.

Mandates: CharT is one of char, wchar_t, char8_t, char16_t, char32_t.

Let V be the pack of values of type CharT whose elements are the corresponding elements of r, except that if r is a reference to a string literal object, then V does not include the terminating U+0000 null character of r.

Let P be the template parameter object ([temp.param]) of type const CharT[sizeof...(V) + 1] initialized with {V..., CharT()}.

Returns: ^^P.

Let U be ranges​::​range_value_t<R> and T be remove_all_extents_t<U>.

Mandates:

• (9.1)
  T is a structural type ([temp.param]),
• (9.2)
  T satisfies copy_constructible, and
• (9.3)
  if U is not an array type, then is_constructible_v<T, ranges​::​range_reference_t<R>> is true.

Let V be the pack of values of type info of the same size as r, where the $i^{\text{th}}$ element is

• (10.1)
  reflect_constant_array(*$\text{it}{}_i$) if U is an array type,
• (10.2)
  reflect_constant(static_cast<T>(*$\text{it}{}_i$)) otherwise,

and $\text{it}{}_i$ is an iterator to the $i^{\text{th}}$ element of r.

Let P be

• (11.1)
  the template parameter object ([temp.param]) of type const T[sizeof...(V)], such that P[I] is template-argument-equivalent ([temp.type]) to the object represented by V...[I] for all I in the range [0, sizeof...(V)) if sizeof...(V) > 0 is true, otherwise
• (11.2)
  the template parameter object of type const array<T, 0> initialized with {}.

Returns: ^^P.

Throws: Any of

• (13.1)
  an exception thrown by any operation on r or on iterators and sentinels referring to r,
• (13.2)
  an exception thrown by the evaluation of any argument of reflect_constant or by any evaluation of reflect_constant_array, or
• (13.3)
  meta​::​exception if any invocation of reflect_constant would exit via an exception.

Effects: Equivalent to: return meta::extract<const ranges::range_value_t<R>*>(meta::reflect_constant_string(r));

Effects: Equivalent to: using T = ranges::range_value_t<R>; meta::info array = meta::reflect_constant_array(r); if (meta::is_array_type(meta::type_of(array))) { return span<const T>(meta::extract<const T*>(array), meta::extent(meta::type_of(array))); } else { return span<const T>(); }

Effects: Equivalent to: using U = remove_cvref_t<T>; if constexpr (meta::is_class_type(^^U) || meta::is_union_type(^^U)) { return addressof(meta::extract<const U&>( meta::reflect_constant(std::forward<T>(t)))); } else if constexpr (meta::is_array_type(^^U)) { return addressof(meta::extract<const U&>( meta::reflect_constant_array(std::forward<T>(t)))); } else { return define_static_array(span(addressof(t), 1)).data(); }