[meta.reflection.define.aggregate]

The classes data_member_options and data_member_options::name-type are consteval-only types ([basic.types.general]), and are not structural types ([temp.param]).

🔗

template<class T>
  requires constructible_from<u8string, T>
  consteval name-type(T&& value);

Effects: Initializes contents with u8string(std::forward<T>(value)).

🔗

template<class T>
  requires constructible_from<string, T>
  consteval name-type(T&& value);

Effects: Initializes contents with string(std::forward<T>(value)).

[Note 1:

The class name-type allows the function data_member_spec to accept an ordinary string literal (or string_view, string, etc.)

or a UTF-8 string literal (or u8string_view, u8string, etc.)

equally well.

[Example 1: consteval void fn() { data_member_options o1 = {.name = "ordinary_literal_encoding"}; data_member_options o2 = {.name = u8"utf8_encoding"}; } — end example]

— end note]

🔗

consteval info data_member_spec(info type, data_member_options options);

Returns: A reflection of a data member description

(T, N, A, W, N U A) ([class. mem. general]) where (4.1) T is the type represented by dealias (type), (4.2) N is either the identifier encoded by options . name or ⊥ if options . name does not contain a value, (4.3) A is either the alignment value held by options . alignment or ⊥ if options . alignment does not contain a value, (4.4) W is either the value held by options . bit_width or ⊥ if options . bit_width does not contain a value, and (4.5) NUA is the value held by options . no_unique_address .

[Note 2:

The returned reflection value is primarily useful in conjunction with define_aggregate; it can also be queried by certain other functions in std::meta (e.g., type_of, identifier_of).

— end note]

Throws: meta::exception unless the following conditions are met:

(5.1)
dealias(type) represents either an object type or a reference type;
(5.2)
if options.name contains a value, then:
- (5.2.1)
  holds_alternative<u8string>(options.name->contents) is true and get<u8string>(options.name->contents) contains the spelling of a valid token that is an identifier ([lex.name]) when interpreted with UTF-8, or
- (5.2.2)
  holds_alternative<string>(options.name->contents) is true and get<string>(options.name->contents) contains the spelling of a valid token that is an identifier ([lex.name]) when interpreted with the ordinary literal encoding;
[Note 3:
Lexical constructs like universal-character-names ([lex.universal.char]) are not processed.

For example, R"(\u03B1)" is an invalid identifier and is not interpreted as "α".
— end note]
(5.3)
if options.name does not contain a value, then options.bit_width contains a value;
(5.4)
if options.bit_width contains a value V, then
- (5.4.1)
  is_integral_type(type) || is_enum_type(type) is true,
- (5.4.2)
  options.alignment does not contain a value,
- (5.4.3)
  options.no_unique_address is false,
- (5.4.4)
  V is not negative, and
- (5.4.5)
  if V equals 0, then options.name does not contain a value; and
(5.5)
if options.alignment contains a value, it is an alignment value ([basic.align]) not less than alignment_of(type).

🔗

consteval bool is_data_member_spec(info r);

Returns: true if r represents a data member description.

Otherwise, false.

🔗

template<reflection_range R = initializer_list<info>>
  consteval info define_aggregate(info class_type, R&& mdescrs);

Let C be the type represented by class_type and

{r K be the {K th reflection value in mdescrs .}^{th reflection value in mdescrs .}}_{K be the {K th reflection value in mdescrs .}^{th reflection value in mdescrs .}}

For every

Constant When:

(8.1)
class_type represents a cv-unqualified class type;
(8.2)
C is incomplete from every point in the evaluation context;
[Note 4:
C can be a class template specialization for which there is a reachable definition of the class template.

In this case, the injected declaration is an explicit specialization.
— end note]
(8.3)
is_data_member_spec( ${r K) is true for every {r K;}_{K;}}_{K)}$
(8.4)
is_complete_type( ${T K) is true for every {r K; and}_{K; and}}_{K)}$
(8.5)
for every pair
(rK,rL) where $K < L, if {N K is not ⊥ and {N L is not ⊥, then either: (8.5.1) {N K is not the same identifier as {N L or}_{L or}}_{K is not the same identifier as {N L or}_{L or}} (8.5.2) {N K is the identifier_(U+005f low line) . [Note 5 : Every provided identifier is unique or "_" . — end note]}_{K is the identifier_(U+005f low line) . [Note 5 : Every provided identifier is unique or "_" . — end note]}}_{L is not ⊥, then either: (8.5.1) {N K is not the same identifier as {N L or}_{L or}}_{K is not the same identifier as {N L or}_{L or}} (8.5.2) {N K is the identifier_(U+005f low line) . [Note 5 : Every provided identifier is unique or "_" . — end note]}_{K is the identifier_(U+005f low line) . [Note 5 : Every provided identifier is unique or "_" . — end note]}}}_{K is not ⊥ and {N L is not ⊥, then either: (8.5.1) {N K is not the same identifier as {N L or}_{L or}}_{K is not the same identifier as {N L or}_{L or}} (8.5.2) {N K is the identifier_(U+005f low line) . [Note 5 : Every provided identifier is unique or "_" . — end note]}_{K is the identifier_(U+005f low line) . [Note 5 : Every provided identifier is unique or "_" . — end note]}}_{L is not ⊥, then either: (8.5.1) {N K is not the same identifier as {N L or}_{L or}}_{K is not the same identifier as {N L or}_{L or}} (8.5.2) {N K is the identifier_(U+005f low line) . [Note 5 : Every provided identifier is unique or "_" . — end note]}_{K is the identifier_(U+005f low line) . [Note 5 : Every provided identifier is unique or "_" . — end note]}}}$

Effects: Produces an injected declaration D ([expr.const]) that defines C and has properties as follows:

(9.1)
The target scope of D is the scope to which C belongs ([basic.scope.scope]).
(9.2)
The locus of D follows immediately after the core constant expression currently under evaluation.
(9.3)
The characteristic sequence of D ([expr.const]) is the sequence of reflection values ${r K .}_{K .}$
(9.4)
If C is a specialization of a templated class T, and C is not a local class, then D is an explicit specialization of T.
(9.5)
For each
(9.6)
For every ${r L in mdescrs such that K < L, the declaration corresponding to {r K precedes the declaration corresponding to {r L .}_{L .}}_{K precedes the declaration corresponding to {r L .}_{L .}}}_{L in mdescrs such that K < L, the declaration corresponding to {r K precedes the declaration corresponding to {r L .}_{L .}}_{K precedes the declaration corresponding to {r L .}_{L .}}}$

Remarks: If C is a specialization of a templated class and it has not been instantiated, C is treated as an explicit specialization.

21 Metaprogramming library [meta]

21.4 Reflection [meta.reflection]

21.4.16 Reflection class definition generation [meta.reflection.define.aggregate]