21 Metaprogramming library [meta]

21.4 Reflection [meta.reflection]

21.4.13 Annotation reflection [meta.reflection.annotation]

consteval vector<info> annotations_of(info item);

For a function F, let S(F) be the set of declarations, ignoring any explicit instantiations, that declare either F or a templated function of which F is a specialization.

Returns: A vector containing all of the reflections R representing each annotation applying to:

(2.1)
if item represents a function parameter P of a function F, then the declaration of P in each declaration of F in S(F),
(2.2)
otherwise, if item represents a function F, then each declaration of F in S(F),
(2.3)
otherwise, if item represents a direct base class relationship $(D, B)$ , then the corresponding base-specifier in the definition of D,
(2.4)
otherwise, each declaration of the entity represented by item,

such that each specified declaration is reachable from either some point in the evaluation context ([expr.const.reflect]) or a point immediately following the class-specifier of the outermost class for which such a point is in a complete-class context.

For any two reflections

R_{1}

and

R_{2}

in the returned vector, if the annotation represented by

R_{1}

precedes the annotation represented by

R_{2}

, then

R_{1}

appears before

R_{2}

R_{1}

and

R_{2}

represent annotations from the same translation unit T, any element in the returned vector between

R_{1}

and

R_{2}

represents an annotation from T.

[Note 1:

The order in which two annotations appear is otherwise unspecified.

— end note]

Throws: meta::exception unless item represents a type, type alias, variable, function, function parameter, namespace, enumerator, direct base class relationship, or non-static data member.

[Example 1: [[=1]] void f(); [[=2, =3]] void g(); void g [[=4]] (); static_assert(annotations_of(^^f).size() == 1); static_assert(annotations_of(^^g).size() == 3); static_assert([: constant_of(annotations_of(^^g)[0]) :] == 2); static_assert(extract<int>(annotations_of(^^g)[1]) == 3); static_assert(extract<int>(annotations_of(^^g)[2]) == 4); struct Option { bool value; }; struct C { [[=Option{true}]] int a; [[=Option{false}]] int b; }; static_assert(extract<Option>(annotations_of(^^C::a)[0]).value); static_assert(!extract<Option>(annotations_of(^^C::b)[0]).value); template<class T> struct [[=42]] D { }; constexpr std::meta::info a1 = annotations_of(^^D<int>)[0]; constexpr std::meta::info a2 = annotations_of(^^D<char>)[0]; static_assert(a1 != a2); static_assert(constant_of(a1) == constant_of(a2)); [[=1]] int x, y; static_assert(annotations_of(^^x)[0] == annotations_of(^^y)[0]); — end example]

🔗

consteval vector<info> annotations_of_with_type(info item, info type);

Returns: A vector containing each element e of annotations_of(item) where remove_const(type_of(e)) == remove_const(type) is true, preserving their order.

Throws: meta::exception unless

(6.1)
the evaluation of annotations_of(item) would not exit via an exception and
(6.2)
dealias(type) represents a type and is_complete_type(type) is true.