[meta.define.static]

🔗

template<ranges::input_range R>
  consteval info reflect_constant_string(R&& 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()}.

[Note 1:

P is a potentially non-unique object ([intro.object]).

— end note]

🔗

template<ranges::input_range R>
  consteval info reflect_constant_array(R&& r);

Let T be ranges::range_value_t<R> and

e {i be static_cast < T > (* it {i), where it {i is an iterator to the {i th element of r .}^{th element of r .}}_{i is an iterator to the {i th element of r .}^{th element of r .}}}_{i)}}_{i be static_cast < T > (* it {i), where it {i is an iterator to the {i th element of r .}^{th element of r .}}_{i is an iterator to the {i th element of r .}^{th element of r .}}}_{i)}}

Mandates: T is a structural type ([temp.param]), is_constructible_v<T, ranges::range_reference_t<R>> is true, and T satisfies copy_constructible .

Let V be the pack of values of type info of the same size as r, where the

{i th element is reflect_constant (e {i) .}_{i)}}^{th element is reflect_constant (e {i) .}_{i)}}

Let P be

(11.1)
the template parameter object ([temp.param]) of type const T[sizeof.(V)] initialized with
{[:V:].} if sizeof.(V) > 0 is true, otherwise
(11.2)
the template parameter object of type const array<T, 0> initialized with {}.

Throws: Any exception thrown by the evaluation of any

e {i, or meta ​::​ exception if evaluation of any reflect_constant (e {i) would exit via an exception .}_{i)}}_{i, or meta ​::​ exception if evaluation of any reflect_constant (e {i) would exit via an exception .}_{i)}}

[Note 2:

P is a potentially non-unique object ([intro.object]).

— end note]

🔗

template<ranges::input_range R>
  consteval const ranges::range_value_t<R>* define_static_string(R&& r);

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

🔗

template<ranges::input_range R>
  consteval span<const ranges::range_value_t<R>> define_static_array(R&& 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>(); }

🔗

template<class T>
  consteval const remove_cvref_t<T>* define_static_object(T&& t);

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

[Note 3:

For class types, define_static_object provides the address of the template parameter object ([temp.param]) that is template-argument equivalent to t.

— end note]