Property implementation to use with custom getter/setter. More...

#include <AUI/Common/AProperty.h>

Public Types#
using	Model = M

using	GetterReturnT = decltype(std::invoke(get, base))

using	Underlying = std::decay_t<GetterReturnT>

Public Member Functions#
	APropertyDef (const M *base, Getter get, Setter set, const emits< SignalArg > &changed)

template<aui::convertible_to< Underlying > U>
APropertyDef &	operator= (U &&u)

GetterReturnT	value () const noexcept

GetterReturnT	operator* () const noexcept

const Underlying *	operator-> () const noexcept

	operator GetterReturnT () const noexcept

M *	boundObject () const

template<aui::invocable< const Underlying & > Projection>
auto	readProjected (Projection &&projection) noexcept
	Makes a readonly projection of this property.

template<aui::invocable< const Underlying & > ProjectionRead, aui::invocable< const std::invoke_result_t< ProjectionRead, Underlying > & > ProjectionWrite>
auto	biProjected (ProjectionRead &&projectionRead, ProjectionWrite &&projectionWrite) noexcept
	Makes a bidirectional projection of this property.

template<aui::detail::property::ProjectionBidirectional< Underlying > Projection>
auto	biProjected (Projection &&projectionBidirectional) noexcept
	Makes a bidirectional projection of this property (by a single aui::lambda_overloaded).

void	notify ()
	Notify observers that a change was occurred (no preconditions).

Signals and public fields#
const M *	base
	AObject which this property belongs to.

Getter	get
	Getter. Can be pointer-to-member(function or field) or lambda.

Setter	set
	Setter. Can be pointer-to-member(function or field) or lambda.

const emits< SignalArg > &	changed
	Reference to underlying signal emitting on value changes.

Detailed Description#

template<typename M, aui::invocable< M & > Getter, aui::invocable< M &, std::invoke_result_t< Getter, M & > > Setter, typename SignalArg>
class APropertyDef< M, Getter, Setter, SignalArg >

Warning: This API is experimental. Experimental APIs are likely to contain bugs, might be changed or removed in the future.

: You can use this way if you are required to define custom behaviour on getter/setter. As a downside, you have to write extra boilerplate code: define property, data field, signal, getter and setter checking equality. Also, APropertyDef requires the class to derive AObject. Most of AView's properties are defined this way.

See property system for usage examples.

Performance considerations#

APropertyDef does not involve extra runtime overhead between assignment and getter/setter.

Declaration#

To declare a property with custom getter/setter, use APropertyDef template. APropertyDef-based property is defined by const member function as follows:

class User : public AObject {
public:
    auto name() const {
        return APropertyDef {
            this,
            &User::getName,   // this works too: &User::mName
            &User::setName,
            mNameChanged,
        };
    }
 
private:
    AString mName;
    emits<AString> mNameChanged;
 
    void setName(AString name) {
        // APropertyDef requires us to emit
        // changed signal if value is actually
        // changed
        if (mName == name) {
            return;
        }
        mName = std::move(name);
        emit mNameChanged(mName);
    }
 
    const AString& getName() const { return mName; }
};

APropertyDef behaves like a class/struct function member:

User u;
u.name() = "Hello";
EXPECT_EQ(u.name(), "Hello");

Note: Properties defined with APropertyDef instead of AProperty impersonate themselves by trailing braces (). We can't get rid of them, as APropertyDef is defined thanks to member function. In comparison to user->name, think of user->name() as the same kind of property except defining custom behaviour via function, hence the braces ().

For the rest, APropertyDef is identical to AProperty including seamless interaction:

User u;
u.name() = "Hello";
u.name() += " world!";
EXPECT_EQ(u.name(), "Hello world!");
EXPECT_EQ(u.name()->length(), AString("Hello world!").length());

Note: In order to honor getters/setters, APropertyDef calls getter/setter instead of using += on your property directly. Equivalent code will be:
u.setName(u.getName() + " world!")

The implicit conversions work the same way as with AProperty:

auto doSomethingWithName = [](const AString& name) { EXPECT_EQ(name, "Hello"); };
User u;
u.name() = "Hello";
doSomethingWithName(u.name());

If it doesn't, simply put an asterisk:

doSomethingWithName(*u.name());

// ^^^ HERE

Observing changes#

All property types offer .changed field which is a signal reporting value changes. Let's make little observer object for demonstration:

class LogObserver : public AObject {
public:
    void log(const AString& msg) {
        ALogger::info("LogObserver") << "Received value: " << msg;
    }
};

The usage is close to AProperty:

auto observer = _new<LogObserver>();
auto u = _new<User>();
u->name() = "Chloe";
// ...
AObject::connect(u->name().changed, slot(observer)::log);

u->name() = "Marinette";

Code produces the following output:

[07:58:59][][LogObserver][INFO]: Received value: Marinette

Making connection to property directly instead of .changed:

auto observer = _new<LogObserver>();
auto u = _new<User>();
u->name() = "Chloe";
// ...
AObject::connect(u->name(), slot(observer)::log);

Code above produces the following output:

[07:58:59][][LogObserver][INFO]: Received value: Chloe

Subsequent changes to field would send updates as well:

u->name() = "Marinette";

Assignment operation above makes an additional line to output:

[07:58:59][][LogObserver][INFO]: Received value: Marinette

Whole program output when connecting to property directly:

[07:58:59][][LogObserver][INFO]: Received value: Chloe

[07:58:59][][LogObserver][INFO]: Received value: Marinette

Examples: /home/runner/work/aui/aui/aui.views/src/AUI/View/AView.h.

Member Data Documentation#

◆ set#

template<typename M, aui::invocable< M & > Getter, aui::invocable< M &, std::invoke_result_t< Getter, M & > > Setter, typename SignalArg>

Setter APropertyDef< M, Getter, Setter, SignalArg >::set

The setter implementation typically emits changed signal. If it is, it must emit changes only if value is actually changed.

void setValue(int value) {
  if (mValue == value) {
    return;
  }
  mValue = value;
  emit mValueChanged(valueChanged);
}

Public Types#

Public Member Functions#

Signals and public fields#

Detailed Description#

Performance considerations#

Declaration#

Observing changes#

Member Data Documentation#

◆ set#

Public Types

Public Member Functions

Signals and public fields

Detailed Description

Performance considerations

Declaration

Observing changes