ugmisc::member_value< Access, CopyValue > Struct Template Reference

#include <ugmisc/member.hpp>

Public Member Functions
template<class... T>
constexpr auto	operator() (T &&...objs) const

Static Public Member Functions
template<class... T>
static constexpr auto	with (T &&...objs)

Static Public Attributes
static constexpr member_value< Access, MEMBER_COPY_AUTO >	copy_auto {}
static constexpr member_value< Access, MEMBER_COPY_ALWAYS >	copy_always {}
static constexpr member_value< Access, MEMBER_COPY_NEVER >	copy_never {}

Detailed Description

template<class Access, member_value_copy CopyValue = MEMBER_COPY_AUTO>
struct ugmisc::member_value< Access, CopyValue >

Template Parameters

Access	A type declared using UGMISC_DECL_MEMBER_ACCESS.
CopyValue	Determines whether the object obtained by calling member_value(objects...) will contain a copy of the found member value, rather than a reference. The default, MEMBER_COPY_AUTO, will return a copy if doing so is trivial and the member could not be modified through the reference.

A template which obtains a named member from one of a sequence of objects, or a fallback default value.

Normally, a reference is returned, but there are two cases in which a value will be copied.

Usage

UGMISC_DECL_MEMBER_ACCESS(GetFoo, foo); // Declares GetFoo.
ugmisc::member_value< GetFoo >::with(x, y).get();
ugmisc::member_value< GetFoo >{}(x, y).get(); // Same as above.
ugmisc::member_value< GetFoo >{}(x, y)(); // Same as above.

TODO: Add support for doing this the other way round: member_value<T>::fallback(f)(objects...) instead of member_value<T>::with(objects...)(f).

The above member_value expressions evaluate to the same reference, which is the first of the following which is valid:

1. x.foo
2. y.foo

If neither of the listed expressions is valid, neither is the get() call, and compilation will fail.

Defaults

UGMISC_DECL_MEMBER_ACCESS(GetFoo, foo); // Declares GetFoo.
ugmisc::member_value< GetFoo >{}(x, y).get( sum, 10, 20 );

This yields the first of:

1. x.foo
2. y.foo
3. sum(10, 20)

Being as constexpr as possible

Consider this example:

constexpr Thing x{}; // x.foo exists
UGMISC_DECL_MEMBER_ACCESS(GetFoo, foo);
constexpr auto fooval = ugmisc::member_value<GetFoo>{}(x).get();

This should work, assuming the type of x.foo can be copied in a constant expression. But this might not:

constexpr Thing x{};
UGMISC_DECL_MEMBER_ACCESS(GetFoo, foo);
constexpr auto x_foo = ugmisc::member_value<GetFoo>{}(x); // Might fail.
constexpr auto fooval = x_foo.get();

The value of x_foo is a small object containing a reference to x.foo. Because x.foo is not static (or might not be; Thing::foo might be static but let's assume it isn't), we can't make x_foo and its reference to x.foo constexpr.

But sometimes we only wanted a copy. We can always revert to creating the object and calling get() in a single expression, but sometimes that is not necessary.

If x.foo can't be modified through its reference anyway, and is trivially copyable, and is not volatile, then x_foo will contain a copy instead of a reference. This behaviour can be changed by passing either MEMBER_COPY_ALWAYS or MEMBER_COPY_NEVER as the second template argument. Alternatively the static member objects copy_auto, copy_always and copy_never may be more convenient.

Definition at line 1050 of file member.hpp.

Member Function Documentation

operator()()

template<class Access, member_value_copy CopyValue = MEMBER_COPY_AUTO>

template<class... T>

auto ugmisc::member_value< Access, CopyValue >::operator() ( T &&... objs ) const

inlineconstexpr

Definition at line 1199 of file member.hpp.

with()

template<class Access, member_value_copy CopyValue = MEMBER_COPY_AUTO>

template<class... T>

constexpr auto ugmisc::member_value< Access, CopyValue >::with ( T &&... objs )

inlinestaticconstexpr

Parameters

objs	Objects to try calling.

Definition at line 1194 of file member.hpp.

Member Data Documentation

copy_always

template<class Access, member_value_copy CopyValue = MEMBER_COPY_AUTO>

member_value<Access, MEMBER_COPY_ALWAYS> ugmisc::member_value< Access, CopyValue >::copy_always {}

staticconstexpr

An instance of member_value with the same Access template argument, and a CopyValue argument of MEMBER_COPY_ALWAYS.

This will copy the found member object rather than referencing it.

See also

Being as constexpr as possible

Definition at line 1223 of file member.hpp.

copy_auto

template<class Access, member_value_copy CopyValue = MEMBER_COPY_AUTO>

member_value<Access, MEMBER_COPY_AUTO> ugmisc::member_value< Access, CopyValue >::copy_auto {}

staticconstexpr

Note

This is the default value of CopyValue so it is rare that copy_auto would be useful.

An instance of member_value with the same Access template argument, and a CopyValue argument of MEMBER_COPY_AUTO. This will copy the found object rather than referencing it iff the object is not volatile, is constant, and is trivially copyable.

See also

Being as constexpr as possible

Definition at line 1213 of file member.hpp.

copy_never

template<class Access, member_value_copy CopyValue = MEMBER_COPY_AUTO>

member_value<Access, MEMBER_COPY_NEVER> ugmisc::member_value< Access, CopyValue >::copy_never {}

staticconstexpr

An instance of member_value with the same Access template argument, and a CopyValue argument of MEMBER_COPY_NEVER.

This will always reference a found member object rather than copying it.

See also

Being as constexpr as possible

Definition at line 1233 of file member.hpp.

---

The documentation for this struct was generated from the following file:

• ugmisc/member.hpp