std::meta::access_context::via

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

Symbols index

External libraries

 

Metaprogramming library

Type traits (C++11)

Compile-time rational arithmetic (C++11)

Compile-time integer sequences (C++14)

integer_sequence (C++14)

Compile-time reflection (C++26)

 

Reflection library

Checking string literals is_string_literal Types info meta::exception access_context data_member_options member_offset operators Concepts reflection_range Promoting to static storage reflect_constant_string reflect_constant_array define_static_string define_static_array define_static_object Operator representations operator_of symbol_of u8symbol_of Names and locations has_identifier identifier_of u8identifier_of display_string_of u8display_string_of source_location_of Reflection queries ➜ Member accessibility queries is_accessible has_inaccessible_nonstatic_   data_members has_inaccessible_bases has_inaccessible_subobjects

Scope identification current_function current_class current_namespace Reflection member queries members_of bases_of static_data_members_of nonstatic_data_members_of      subobjects_of enumerators_of Reflection layout queries offset_of size_of alignment_of bit_size_of Annotation reflection annotations_of annotations_of_with_type Value extraction extract Reflection substitution can_substitute substitute Expression result reflection reflect_constant reflect_object reflect_function Class definition generation data_member_spec is_data_member_spec define_aggregate

Primary type categories is_void_type is_null_pointer_type is_integral_type is_floating_point_type is_array_type is_pointer_type is_lvalue_reference_type is_rvalue_reference_type is_member_object_pointer_type is_member_function_pointer_type      is_enum_type is_union_type is_class_type is_function_type is_reflection_type Composite type categories is_reference_type is_arithmetic_type is_fundamental_type is_object_type is_scalar_type is_compound_type is_member_pointer_type Type properties ➜ Type relations is_same_type is_base_of_type is_virtual_base_of_type is_convertible_type is_nothrow_convertible_type is_layout_compatible_type is_pointer_interconvertible_   base_of_type is_invocable_type is_invocable_r_type is_nothrow_invocable_type is_nothrow_invocable_r_type

Const-volatile modifications remove_const remove_volatile remove_cv add_const add_volatile add_cv Reference modifications remove_reference add_lvalue_reference add_rvalue_reference Sign modifications make_signed make_unsigned Array modifications remove_extent remove_all_extents Pointer modifications remove_pointer add_pointer Other transformations remove_cvref decay common_type common_reference underlying_type invoke_result unwrap_reference unwrap_ref_decay tuple_size tuple_element is_applicable_type is_nothrow_applicable_type apply_result variant_size variant_alternative type_order

 

std::meta::access_context

Member functions

access_context::scopeaccess_context::designating_class

access_context::current

access_context::unprivileged

access_context::unchecked

access_context::via

 

consteval std::meta::access_context via( std::meta::info cls ) const;

Returns a new access_context whose associated scope is this->scope() and whose designating class is cls.

Parameters

cls

-

a reflection of a class type or a null reflection

Return value

A access_context as described above.

Exceptions

Throws std::meta::exception unless cls is either the null reflection or a reflection of a complete class type.

Notes

The designating class is the class used to name a member. For example, in C::member, the designating class is C; in obj.member, the designating class is the type of obj.

The same member may have different accessibility when designated in different classes.

Example

Run this code

#include <meta>

struct Base { static constexpr int mem = 42; };

struct Derived : private Base
{
    static constexpr auto ctx = std::meta::access_context::current();
};

constexpr auto ctx = std::meta::access_context::unprivileged();

int x = Base::mem; // OK, Base::mem is public
static_assert(std::meta::is_accessible(^^Base::mem, ctx));

// int y = Derived::mem; // Error: Base::mem is private in Derived
static_assert(!std::meta::is_accessible(^^Base::mem, ctx.via(^^Derived)));

// The private Derived::mem is accessible in the scope of Derived
static_assert(std::meta::is_accessible(^^Base::mem, Derived::ctx.via(^^Derived)));

int main() {}

See also

scopedesignating_class

returns the associated scope and designating class, respectively (public member function)