\macro Q_OBJECT_COMPAT_PROPERTY(containingClass, type, name, callback) More...

#include <qproperty.h>

Inheritance diagram for QObjectComputedProperty< Class, T, Offset, Getter >:

Collaboration diagram for QObjectComputedProperty< Class, T, Offset, Getter >:

Public Types
using	value_type = T

using	parameter_type = T

Public Member Functions
	QObjectComputedProperty ()=default

parameter_type	value () const

std::conditional_t< QTypeTraits::is_dereferenceable_v< T >, parameter_type, void >	operator-> () const

parameter_type	operator* () const

	operator parameter_type () const

constexpr bool	hasBinding () const

template<typename Functor >
QPropertyChangeHandler< Functor >	onValueChanged (Functor f)

template<typename Functor >
QPropertyChangeHandler< Functor >	subscribe (Functor f)

template<typename Functor >
QPropertyNotifier	addNotifier (Functor f)

QtPrivate::QPropertyBindingData &	bindingData () const

void	notify ()

Related Symbols
(Note that these are not member symbols.)
template< typename Class, typename T, auto offset, auto Callback >	QObjectBindableProperty ()
	\macro Q_OBJECT_COMPUTED_PROPERTY(containingClass, type, name, callback)

Detailed Description

template<typename Class, typename T, auto Offset, auto Getter>
class QObjectComputedProperty< Class, T, Offset, Getter >

\macro Q_OBJECT_COMPAT_PROPERTY(containingClass, type, name, callback)

Since: 6.0

Declares a \l QObjectCompatProperty inside containingClass of type type with name name. The argument callback specifies a setter function to be called when the property is changed through the binding.

See also: QObjectBindableProperty, {Qt's Property System}, {Qt Bindable Properties}

\macro Q_OBJECT_COMPAT_PROPERTY_WITH_ARGS(containingClass, type, name, callback, value)

Since: 6.0

Declares a \l QObjectCompatProperty inside of containingClass of type type with name name. The argument callback specifies a setter function to be called when the property is changed through the binding. value specifies an initialization value.

\inmodule QtCore

The QObjectComputedProperty class is a template class to help port old properties to the bindable property system.

Since: 6.0

QObjectComputedProperty is a read-only property which is recomputed on each read. It does not store the computed value. It is one of the Qt internal classes implementing \l {Qt Bindable Properties}. QObjectComputedProperty is usually not used directly, instead an instance of it is created by using the Q_OBJECT_COMPUTED_PROPERTY macro.

See the following example.

class Client{};
 
class MyClassPrivate : public QObjectPrivate
{
public:
    QList<Client> clients;
    bool hasClientsActualCalculation() const { return clients.size() > 0; }
    Q_OBJECT_COMPUTED_PROPERTY(MyClassPrivate, bool, hasClientsData,
                               &MyClassPrivate::hasClientsActualCalculation)
};
 
class MyClass : public QObject
{
    Q_OBJECT
    Q_PROPERTY(bool hasClients READ hasClients STORED false BINDABLE bindableHasClients)
public:
    QBindable<bool> bindableHasClients()
    {
        return QBindable<bool>(&d_func()->hasClientsData);
    }
    bool hasClients() const
    {
        return d_func()->hasClientsData.value();
    }
    void addClient(const Client &c)
    {
        Q_D(MyClass);
        d->clients.push_back(c);
        // notify that the value could have changed
        d->hasClientsData.notify();
    }
private:
    Q_DECLARE_PRIVATE(MyClass)
};

The rules for getters in \l {Bindable Property Getters and Setters} also apply for QObjectComputedProperty. Especially, the getter should be trivial and only return the value of the QObjectComputedProperty object. The callback given to the QObjectComputedProperty should usually be a private method which is only called by the QObjectComputedProperty.

No setter is required or allowed, as QObjectComputedProperty is read-only.

To correctly participate in dependency handling, QObjectComputedProperty has to know when its value, the result of the callback given to it, might have changed. Whenever a bindable property used in the callback changes, this happens automatically. If the result of the callback might change because of a change in a value which is not a bindable property, it is the developer's responsibility to call notify on the QObjectComputedProperty object. This will inform dependent properties about the potential change.

Note that calling notify might trigger change handlers in dependent properties, which might in turn use the object the QObjectComputedProperty is a member of. So notify must not be called when in a transitional or invalid state.

QObjectComputedProperty is not suitable for use with a computation that depends on any input that might change without notice, such as the contents of a file.

See also: Q_OBJECT_COMPUTED_PROPERTY, QProperty, QObjectBindableProperty, {Qt's Property System}, {Qt Bindable Properties}

Definition at line 1273 of file qproperty.h.