[meta.reflection.define.aggregate]

Files changed (1) hide show

tmp/tmpj_3x929e/{from.md → to.md} +173 -0

tmp/tmpj_3x929e/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,173 @@

+### Reflection class definition generation <a id="meta.reflection.define.aggregate">[[meta.reflection.define.aggregate]]</a>
+``` cpp
+namespace std::meta {
+  struct data_member_options {
+    struct name-type {                          // exposition only
+      template<class T>
+        requires constructible_from<u8string, T>
+        consteval name-type(T&&);
+      template<class T>
+        requires constructible_from<string, T>
+        consteval name-type(T&&);
+    private:
+      variant<u8string, string> contents;       // exposition only
+    };
+    optional<name-type> name;
+    optional<int> alignment;
+    optional<int> bit_width;
+    bool no_unique_address = false;
+  };
+}
+```
+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]].
+``` cpp
+template<class T>
+  requires constructible_from<u8string, T>
+  consteval name-type(T&& value);
+```
+*Effects:* Initializes *contents* with
+`u8string(std::forward<T>(value))`.
+``` cpp
+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*]
+``` cpp
+consteval info data_member_spec(info type, data_member_options options);
+```
+*Returns:* A reflection of a data member description
+(T, N, A, W, *NUA*)[[class.mem.general]] where
+- T is the type represented by `dealias(type)`,
+- N is either the identifier encoded by `options.name` or $\bot$ if
+  `options.name` does not contain a value,
+- A is either the alignment value held by `options.alignment` or $\bot$
+  if `options.alignment` does not contain a value,
+- W is either the value held by `options.bit_width` or $\bot$ if
+  `options.bit_width` does not contain a value, and
+- *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:
+- `dealias(type)` represents either an object type or a reference type;
+- if `options.name` contains a value, then:
+  - `holds_alternative<u8string>(options.name->`*`contents`*`)` is
+    `true` and `get<u8string>(options.name->`*`contents`*`)` contains a
+    valid identifier [[lex.name]] that is not a keyword [[lex.key]] when
+    interpreted with UTF-8, or
+  - `holds_alternative<string>(options.name->`*`contents`*`)` is `true`
+    and `get<string>(options.name->`*`contents`*`)` contains a valid
+    identifier [[lex.name]] that is not a keyword [[lex.key]] when
+    interpreted with the ordinary literal encoding;
+  \[*Note 1*: The name corresponds to the spelling of an
+  identifier token after phase 6 of translation [[lex.phases]].
+  Lexical constructs like
+  *universal-character-name*s [[lex.universal.char]] are not
+  processed and will cause evaluation to fail. For example,
+  `R"(\u03B1)"` is an invalid identifier and is not interpreted as
+  `"`α`"`. — *end note*]
+- if `options.name` does not contain a value, then `options.bit_width`
+  contains a value;
+- if `options.bit_width` contains a value V, then
+  - `is_integral_type(type) || is_enum_type(type)` is `true`,
+  - `options.alignment` does not contain a value,
+  - `options.no_unique_address` is `false`, and
+  - if V equals `0`, then `options.name` does not contain a value; and
+- if `options.alignment` contains a value, it is an alignment
+  value [[basic.align]] not less than `alignment_of(type)`.
+``` cpp
+consteval bool is_data_member_spec(info r);
+```
+*Returns:* `true` if `r` represents a data member description.
+Otherwise, `false`.
+``` cpp
+template<reflection_range R = initializer_list<info>>
+  consteval info define_aggregate(info class_type, R&& mdescrs);
+```
+Let C be the class represented by `class_type` and $r_K$ be the Kᵗʰ
+reflection value in `mdescrs`. For every $r_K$ in `mdescrs`, let
+$(T_K, N_K, A_K, W_K, *NUA*_K)$ be the corresponding data member
+description represented by $r_K$.
+- C is incomplete from every point in the evaluation context;
+  \[*Note 2*: 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*]
+- `is_data_member_spec(`$r_K$`)` is `true` for every $r_K$;
+- `is_complete_type(`$T_K$`)` is `true` for every $r_K$; and
+- for every pair $(r_K, r_L)$ where K < L, if $N_K$ is not $\bot$ and
+  $N_L$ is not $\bot$, then either:
+  - $N_K$` != `$N_L$ is `true` or
+  - $N_K$` == u8"_"` is `true`. \[*Note 3*: Every provided identifier is
+    unique or `"_"`. — *end note*]
+*Effects:* Produces an injected declaration D[[expr.const]] that defines
+C and has properties as follows:
+- The target scope of D is the scope to which C
+  belongs [[basic.scope.scope]].
+- The locus of D follows immediately after the core constant expression
+  currently under evaluation.
+- The characteristic sequence of D[[expr.const]] is the sequence of
+  reflection values $r_K$.
+- 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.
+- For each $r_K$, there is a corresponding entity $M_K$ belonging to the
+  class scope of D with the following properties:
+  - If $N_K$ is $\bot$, $M_K$ is an unnamed bit-field. Otherwise, $M_K$
+    is a non-static data member whose name is the identifier determined
+    by the character sequence encoded by $N_K$ in UTF-8.
+  - The type of $M_K$ is $T_K$.
+  - $M_K$ is declared with the attribute `[[no_unique_address]]` if and
+    only if *NUA*_K is `true`.
+  - If $W_K$ is not $\bot$, $M_K$ is a bit-field whose width is that
+    value. Otherwise, $M_K$ is not a bit-field.
+  - If $A_K$ is not $\bot$, $M_K$ has the *alignment-specifier*
+    `alignas(`$A_K$`)`. Otherwise, $M_K$ has no *alignment-specifier*.
+- For every $r_L$ in `mdescrs` such that K < L, the declaration
+  corresponding to $r_K$ precedes the declaration corresponding to
+  $r_L$.
+*Returns:* `class_type`.

Diff to HTML by rtfpessoa