A base object class. More...

#include <AUI/Common/AObject.h>

Public Member Functions#
_< AObject >	sharedPtr ()

_weak< AObject >	weakPtr ()

template<typename Connectable, ACompatibleSlotFor< Connectable > Function>
decltype(auto)	connect (const Connectable &connectable, Function &&function)
	Connects signal or property to slot of `"this"` object.

void	setSignalsEnabled (bool enabled)

bool	isSignalsEnabled () const noexcept

template<ASignalInvokable T>
void	operator^ (T &&t) noexcept

_< AAbstractThread >	getThread () const

bool	isSlotsCallsOnlyOnMyThread () const noexcept

void	setSlotsCallsOnlyOnMyThread (bool slotsCallsOnlyOnMyThread)

Public Member Functions inherited from AObjectBase
	AObjectBase (AObjectBase &&rhs) noexcept

	AObjectBase (const AObjectBase &rhs) noexcept

AObjectBase &	operator= (const AObjectBase &rhs) noexcept

AObjectBase &	operator= (AObjectBase &&rhs) noexcept

Public Member Functions inherited from aui::noncopyable
	noncopyable (const noncopyable &)=delete

noncopyable &	operator= (const noncopyable &)=delete

Static Public Member Functions#
static void	disconnect ()

template<AAnySignal Signal, aui::derived_from< AObjectBase > Object, ACompatibleSlotFor< Signal > Function>
static decltype(auto)	connect (const Signal &signal, Object *object, Function &&function)
	Connects signal to the slot of the specified object.

template<AAnyProperty Property, aui::derived_from< AObjectBase > Object, typename Function>
static decltype(auto)	connect (const Property &property, Object *object, Function &&function)
	Connects property to the slot of the specified object.

template<APropertyReadable PropertySource, APropertyWritable PropertyDestination> requires requires { { propertySource } -> aui::convertible_to<std::decay_t<decltype(propertyDestination)>>; }
static void	connect (PropertySource &&propertySource, PropertyDestination &&propertyDestination)
	Connects source property to the destination property.

template<APropertyWritable PropertySource, APropertyWritable PropertyDestination> requires requires { { propertySource } -> aui::convertible_to<std::decay_t<decltype(propertyDestination)>>; { propertyDestination } -> aui::convertible_to<std::decay_t<decltype(propertySource)>>; }
static void	biConnect (PropertySource &&propertySource, PropertyDestination &&propertyDestination)
	Connects source property to the destination property and opposite (bidirectionally).

template<AAnySignalOrProperty Connectable, aui::derived_from< AObjectBase > Object, ACompatibleSlotFor< Connectable > Function>
static decltype(auto)	connect (const Connectable &connectable, Object &object, Function &&function)
	Connects signal or property to the slot of the specified object.

template<AAnySignalOrProperty Connectable, aui::derived_from< AObjectBase > Object, ACompatibleSlotFor< Connectable > Function>
static decltype(auto)	connect (const Connectable &connectable, _< Object > object, Function &&function)
	Connects signal or property to the slot of the specified object.

template<AAnySignalOrProperty Connectable, aui::derived_from< AObjectBase > Object, typename Function>
static decltype(auto)	connect (const Connectable &connectable, ASlotDef< Object *, Function > slotDef)
	Connects signal to the slot of the specified object. Slot is packed to single argument.

template<AAnyProperty Property, typename Object, ACompatibleSlotFor< Property > Function> requires (!aui::derived_from<Object, AObject>)
static void	connect (const Property &property, _< Object > object, Function &&function)
	Connects signal or property to the slot of the specified non-AObject type.

static void	moveToThread (aui::no_escape< AObject > object, _< AAbstractThread > thread)

Static Public Attributes#
static constexpr AObjectBase *	GENERIC_OBSERVER = nullptr
	Indicates that a connection should not be explicitly linked to receiver's lifetime.

Static Public Attributes inherited from AObjectBase
static ASpinlockMutex	SIGNAL_SLOT_GLOBAL_SYNC

Protected Member Functions#
void	setThread (_< AAbstractThread > thread)
	Set thread of the object.

Protected Member Functions inherited from AObjectBase
void	clearAllIngoingConnections () noexcept

virtual void	handleSlotException (std::exception_ptr exception)
	Called then an exception has thrown during slot processing of the signal emitted by this object.

Detailed Description#

AObject is required to use signal-slot system.

AObject keeps reference to itself via std::enable_shared_from_this. It can be accessed with sharedPtr() and weakPtr() functions.

Examples: /home/runner/work/aui/aui/aui.views/src/AUI/View/AView.h, and examples/app/game_of_life/src/main.cpp.

Member Function Documentation#

◆ connect()#

template<AAnySignalOrProperty Connectable, aui::derived_from< AObjectBase > Object, typename Function>

static decltype(auto) AObject::connect	(	const Connectable &	connectable,
		ASlotDef< Object *, Function >	slotDef )

inlinestatic

Parameters

connectable	signal or property
slotDef	instance of `AObject` + slot

Returns: Connection instance

See signal-slot system for more info.

connect(view->clicked, ASlotDef { slot(otherObject)::handleButtonClicked });

connect(textField->text(), ASlotDef { slot(otherObject)::handleText });

AObject::connect

static decltype(auto) connect(const Signal &signal, Object *object, Function &&function)

Connects signal to the slot of the specified object.

Definition AObject.h:86

ASlotDef

Definition concepts.h:188

Note: This overload is applicable for cases when you NEED to pass object and its slot via single argument. If possible, consider using shorter overload:
connect(view->clicked, slot(otherObject)::handleButtonClicked);

slot
#define slot(v)
Passes some variable and type of the variable separated by comma. It's convenient to use with the con...
Definition kAUI.h:88

Member Data Documentation#

◆ GENERIC_OBSERVER#

AObjectBase* AObject::GENERIC_OBSERVER = nullptr

staticconstexpr

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

: Normally, a connection is broken when either sender or receiver die. You can indicate that you actually don't need the connection to be broken if receiver dies, or you don't have a receiver AObject either. In such case, the connection is breaks only when the sender (signal) dies.

This can be useful in situations when you don't want to introduce some receiver AObject and when slot just to observe property or signal, i.e., you just want to make a generic observer.

Use this in combination with lambda.

    struct State {
        bool called = false;
    };
    auto state = _new<State>();
    AObject::connect(master->message, AObject::GENERIC_OBSERVER, [state] {
        state->called = true;
    });
    master->broadcastMessage("hello");
    EXPECT_TRUE(state->called);