summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorSimon Hausmann <simon.hausmann@qt.io>2019-07-10 09:01:14 +0200
committerSimon Hausmann <simon.hausmann@qt.io>2020-03-16 18:19:45 +0100
commit9f9049b486a47aef0c7e2e3852b20aa4ffdce748 (patch)
tree619d55c8c97c7616c257b4f0da7fa2478637c2a2
parent3c7c60e322f934aaac7e4c1941401a03488383be (diff)
Initial import of the Qt C++ property binding system
This implements the core value based property binding system with automatic dependency tracking. More features are to be added later, and the documentation will need further improvements as well. Change-Id: I77ec9163ba4dace6c4451f5933962ebe1b3b4b14 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
-rw-r--r--src/corelib/.prev_CMakeLists.txt3
-rw-r--r--src/corelib/CMakeLists.txt3
-rw-r--r--src/corelib/kernel/kernel.pri10
-rw-r--r--src/corelib/kernel/qproperty.cpp671
-rw-r--r--src/corelib/kernel/qproperty.h451
-rw-r--r--src/corelib/kernel/qproperty_p.h118
-rw-r--r--src/corelib/kernel/qpropertybinding.cpp141
-rw-r--r--src/corelib/kernel/qpropertybinding_p.h98
-rw-r--r--src/corelib/kernel/qpropertyprivate.h249
-rw-r--r--tests/auto/corelib/kernel/kernel.pro6
-rw-r--r--tests/auto/corelib/kernel/qproperty/qproperty.pro4
-rw-r--r--tests/auto/corelib/kernel/qproperty/tst_qproperty.cpp615
12 files changed, 2365 insertions, 4 deletions
diff --git a/src/corelib/.prev_CMakeLists.txt b/src/corelib/.prev_CMakeLists.txt
index d132dbaffc..b9b9e8eb92 100644
--- a/src/corelib/.prev_CMakeLists.txt
+++ b/src/corelib/.prev_CMakeLists.txt
@@ -102,6 +102,9 @@ qt_add_module(Core
kernel/qobjectdefs.h
kernel/qobjectdefs_impl.h
kernel/qpointer.cpp kernel/qpointer.h
+ kernel/qproperty.cpp kernel/qproperty.h kernel/qproperty_p.h
+ kernel/qpropertybinding.cpp kernel/qpropertybinding_p.h
+ kernel/qpropertyprivate.h
kernel/qsharedmemory.cpp kernel/qsharedmemory.h kernel/qsharedmemory_p.h
kernel/qsignalmapper.cpp kernel/qsignalmapper.h
kernel/qsocketnotifier.cpp kernel/qsocketnotifier.h
diff --git a/src/corelib/CMakeLists.txt b/src/corelib/CMakeLists.txt
index e60ef18e17..4f53ab02f0 100644
--- a/src/corelib/CMakeLists.txt
+++ b/src/corelib/CMakeLists.txt
@@ -118,6 +118,9 @@ qt_add_module(Core
kernel/qobjectdefs.h
kernel/qobjectdefs_impl.h
kernel/qpointer.cpp kernel/qpointer.h
+ kernel/qproperty.cpp kernel/qproperty.h kernel/qproperty_p.h
+ kernel/qpropertybinding.cpp kernel/qpropertybinding_p.h
+ kernel/qpropertyprivate.h
kernel/qsharedmemory.cpp kernel/qsharedmemory.h kernel/qsharedmemory_p.h
kernel/qsignalmapper.cpp kernel/qsignalmapper.h
kernel/qsocketnotifier.cpp kernel/qsocketnotifier.h
diff --git a/src/corelib/kernel/kernel.pri b/src/corelib/kernel/kernel.pri
index bd3cabc01a..1b4f6d4923 100644
--- a/src/corelib/kernel/kernel.pri
+++ b/src/corelib/kernel/kernel.pri
@@ -43,7 +43,11 @@ HEADERS += \
kernel/qsystemerror_p.h \
kernel/qmetatype_p.h \
kernel/qmetatypeswitcher_p.h \
- kernel/qtestsupport_core.h
+ kernel/qtestsupport_core.h \
+ kernel/qproperty.h \
+ kernel/qpropertyprivate.h \
+ kernel/qproperty_p.h \
+ kernel/qpropertybinding_p.h
SOURCES += \
kernel/qabstracteventdispatcher.cpp \
@@ -71,7 +75,9 @@ SOURCES += \
kernel/qpointer.cpp \
kernel/qmath.cpp \
kernel/qsystemerror.cpp \
- kernel/qtestsupport_core.cpp
+ kernel/qtestsupport_core.cpp \
+ kernel/qproperty.cpp \
+ kernel/qpropertybinding.cpp
win32 {
SOURCES += \
diff --git a/src/corelib/kernel/qproperty.cpp b/src/corelib/kernel/qproperty.cpp
new file mode 100644
index 0000000000..75110fa031
--- /dev/null
+++ b/src/corelib/kernel/qproperty.cpp
@@ -0,0 +1,671 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qproperty.h"
+#include "qproperty_p.h"
+#include "qpropertybinding_p.h"
+
+#include <qscopedvaluerollback.h>
+
+QT_BEGIN_NAMESPACE
+
+using namespace QtPrivate;
+
+QPropertyBase::QPropertyBase(QPropertyBase &&other, void *propertyDataPtr)
+{
+ std::swap(d_ptr, other.d_ptr);
+ QPropertyBasePointer d{this};
+ d.firstObserverPtr().set(nullptr);
+ if (auto binding = d.bindingPtr())
+ binding->propertyDataPtr = propertyDataPtr;
+}
+
+void QPropertyBase::moveAssign(QPropertyBase &&other, void *propertyDataPtr)
+{
+ if (&other == this)
+ return;
+
+ QPropertyBasePointer d{this};
+ auto observer = d.firstObserver();
+ d.firstObserverPtr().set(nullptr);
+
+ if (auto binding = d.bindingPtr()) {
+ binding->unlinkAndDeref();
+ d_ptr &= FlagMask;
+ }
+
+ std::swap(d_ptr, other.d_ptr);
+
+ if (auto binding = d.bindingPtr())
+ binding->propertyDataPtr = propertyDataPtr;
+
+ d.firstObserverPtr().set(const_cast<QPropertyObserver*>(observer.ptr));
+
+ // The caller will have to notify observers.
+}
+
+QPropertyBase::~QPropertyBase()
+{
+ QPropertyBasePointer d{this};
+ if (auto observer = d.firstObserver())
+ observer.unlink();
+ if (auto binding = d.bindingPtr())
+ binding->unlinkAndDeref();
+}
+
+QUntypedPropertyBinding QPropertyBase::setBinding(const QUntypedPropertyBinding &binding, void *propertyDataPtr)
+{
+ QPropertyBindingPrivatePtr oldBinding;
+ QPropertyBindingPrivatePtr newBinding = binding.d;
+
+ QPropertyBasePointer d{this};
+
+ auto observer = d.firstObserver();
+ if (observer)
+ observer.unlink();
+
+ if (auto *existingBinding = d.bindingPtr()) {
+ if (existingBinding == newBinding.data())
+ return QUntypedPropertyBinding(oldBinding);
+ oldBinding = QPropertyBindingPrivatePtr(existingBinding);
+ oldBinding->unlinkAndDeref();
+ d_ptr &= FlagMask;
+ }
+ if (newBinding) {
+ newBinding.data()->ref.ref();
+ d_ptr = (d_ptr & FlagMask) | reinterpret_cast<quintptr>(newBinding.data());
+ d_ptr |= BindingBit;
+ newBinding->dirty = true;
+ newBinding->propertyDataPtr = propertyDataPtr;
+ if (observer)
+ observer.prependToBinding(newBinding.data());
+ } else {
+ d_ptr &= ~BindingBit;
+ }
+
+ return QUntypedPropertyBinding(oldBinding);
+}
+
+QPropertyBindingPrivatePtr QPropertyBase::binding()
+{
+ QPropertyBasePointer d{this};
+ if (auto binding = d.bindingPtr())
+ return QPropertyBindingPrivatePtr(binding);
+ return QPropertyBindingPrivatePtr();
+}
+
+QPropertyBindingPrivate *QPropertyBasePointer::bindingPtr() const
+{
+ if (ptr->d_ptr & QPropertyBase::BindingBit)
+ return reinterpret_cast<QPropertyBindingPrivate*>(ptr->d_ptr & ~QPropertyBase::FlagMask);
+ return nullptr;
+}
+
+QtPrivate::QPropertyTagPreservingPointerToPointer<QPropertyObserver> QPropertyBasePointer::firstObserverPtr() const
+{
+ if (auto *binding = bindingPtr())
+ return const_cast<QPropertyObserver**>(&binding->firstObserver.ptr);
+ return &ptr->d_ptr;
+}
+
+QPropertyObserverPointer QPropertyBasePointer::firstObserver() const
+{
+ if (auto *binding = bindingPtr())
+ return binding->firstObserver;
+ return {reinterpret_cast<QPropertyObserver*>(ptr->d_ptr & ~QPropertyBase::FlagMask)};
+}
+
+static thread_local BindingEvaluationState *currentBindingEvaluationState = nullptr;
+
+BindingEvaluationState::BindingEvaluationState(QPropertyBindingPrivate *binding)
+ : binding(binding)
+ , dependencyObservers(&binding->dependencyObservers)
+{
+ previousState = currentBindingEvaluationState;
+ currentBindingEvaluationState = this;
+ dependencyObservers->clear();
+}
+
+BindingEvaluationState::~BindingEvaluationState()
+{
+ currentBindingEvaluationState = previousState;
+}
+
+void QPropertyBase::evaluateIfDirty()
+{
+ QPropertyBasePointer d{this};
+ QPropertyBindingPrivate *binding = d.bindingPtr();
+ if (!binding)
+ return;
+ binding->evaluateIfDirtyAndReturnTrueIfValueChanged();
+}
+
+void QPropertyBase::removeBinding()
+{
+ QPropertyBasePointer d{this};
+
+ auto observer = d.firstObserver();
+ if (observer)
+ observer.unlink();
+
+ if (auto *existingBinding = d.bindingPtr()) {
+ existingBinding->unlinkAndDeref();
+ d_ptr &= FlagMask;
+ }
+ d_ptr &= ~BindingBit;
+
+ if (observer)
+ observer.observeProperty(d);
+}
+
+void QPropertyBase::registerWithCurrentlyEvaluatingBinding() const
+{
+ auto currentState = currentBindingEvaluationState;
+ if (!currentState)
+ return;
+
+ QPropertyBasePointer d{this};
+
+ currentState->dependencyObservers->append(QPropertyObserver());
+ QPropertyObserverPointer dependencyObserver{&(*currentState->dependencyObservers)[currentState->dependencyObservers->size() - 1]};
+ dependencyObserver.setBindingToMarkDirty(currentState->binding);
+ dependencyObserver.observeProperty(d);
+}
+
+void QPropertyBase::notifyObservers()
+{
+ QPropertyBasePointer d{this};
+ if (QPropertyObserverPointer observer = d.firstObserver())
+ observer.notify(d.bindingPtr());
+}
+
+int QPropertyBasePointer::observerCount() const
+{
+ int count = 0;
+ for (auto observer = firstObserver(); observer; observer = observer.nextObserver())
+ ++count;
+ return count;
+}
+
+QPropertyObserver::QPropertyObserver(void (*callback)(QPropertyObserver*))
+{
+ QPropertyObserverPointer d{this};
+ d.setChangeHandler(callback);
+}
+
+void QPropertyObserver::setSource(QPropertyBase &property)
+{
+ QPropertyObserverPointer d{this};
+ QPropertyBasePointer propPrivate{&property};
+ d.observeProperty(propPrivate);
+}
+
+
+QPropertyObserver::~QPropertyObserver()
+{
+ QPropertyObserverPointer d{this};
+ d.unlink();
+}
+
+QPropertyObserver::QPropertyObserver(QPropertyObserver &&other)
+{
+ std::swap(bindingToMarkDirty, other.bindingToMarkDirty);
+ std::swap(next, other.next);
+ std::swap(prev, other.prev);
+ if (next)
+ next->prev = reinterpret_cast<quintptr*>(&next);
+ if (prev)
+ prev.set(this);
+}
+
+QPropertyObserver &QPropertyObserver::operator=(QPropertyObserver &&other)
+{
+ if (this == &other)
+ return *this;
+
+ QPropertyObserverPointer d{this};
+ d.unlink();
+ bindingToMarkDirty = nullptr;
+
+ std::swap(bindingToMarkDirty, other.bindingToMarkDirty);
+ std::swap(next, other.next);
+ std::swap(prev, other.prev);
+ if (next)
+ next->prev = reinterpret_cast<quintptr*>(&next);
+ if (prev)
+ prev.set(this);
+
+ return *this;
+}
+
+void QPropertyObserverPointer::unlink()
+{
+ if (ptr->next)
+ ptr->next->prev = ptr->prev;
+ if (ptr->prev)
+ ptr->prev.set(ptr->next.data());
+ ptr->next = nullptr;
+ ptr->prev.clear();
+}
+
+void QPropertyObserverPointer::setChangeHandler(void (*changeHandler)(QPropertyObserver *))
+{
+ ptr->changeHandler = changeHandler;
+ ptr->next.setFlag(true);
+}
+
+void QPropertyObserverPointer::setBindingToMarkDirty(QPropertyBindingPrivate *binding)
+{
+ ptr->bindingToMarkDirty = binding;
+ ptr->next.setFlag(false);
+}
+
+void QPropertyObserverPointer::notify(QPropertyBindingPrivate *triggeringBinding)
+{
+ bool knownIfPropertyChanged = false;
+ bool propertyChanged =true;
+
+ auto observer = const_cast<QPropertyObserver*>(ptr);
+ while (observer) {
+ auto * const next = observer->next.data();
+ if (observer->next.flag()) {
+ if (!knownIfPropertyChanged && triggeringBinding) {
+ knownIfPropertyChanged = true;
+
+ propertyChanged = triggeringBinding->evaluateIfDirtyAndReturnTrueIfValueChanged();
+ }
+ if (!propertyChanged)
+ return;
+
+ if (auto handlerToCall = std::exchange(observer->changeHandler, nullptr)) {
+ handlerToCall(observer);
+ observer->changeHandler = handlerToCall;
+ }
+ } else {
+ if (observer->bindingToMarkDirty)
+ observer->bindingToMarkDirty->markDirtyAndNotifyObservers();
+ }
+ observer = next;
+ }
+}
+
+void QPropertyObserverPointer::observeProperty(QPropertyBasePointer property)
+{
+ unlink();
+ auto firstObserverPtr = property.firstObserverPtr();
+ ptr->prev = firstObserverPtr;
+ ptr->next = firstObserverPtr.get();
+ if (ptr->next)
+ ptr->next->prev = &ptr->next;
+ firstObserverPtr.set(ptr);
+}
+
+void QPropertyObserverPointer::prependToBinding(QPropertyBindingPrivate *binding)
+{
+ ptr->prev = const_cast<QPropertyObserver **>(&binding->firstObserver.ptr);
+ binding->firstObserver = *this;
+}
+
+QPropertyBindingError::QPropertyBindingError(Type type)
+{
+ if (type != NoError) {
+ d = new QPropertyBindingErrorPrivate;
+ d->type = type;
+ }
+}
+
+QPropertyBindingError::QPropertyBindingError(const QPropertyBindingError &other)
+ : d(other.d)
+{
+}
+
+QPropertyBindingError &QPropertyBindingError::operator=(const QPropertyBindingError &other)
+{
+ d = other.d;
+ return *this;
+}
+
+QPropertyBindingError::QPropertyBindingError(QPropertyBindingError &&other)
+ : d(std::move(other.d))
+{
+}
+
+QPropertyBindingError &QPropertyBindingError::operator=(QPropertyBindingError &&other)
+{
+ d = std::move(other.d);
+ return *this;
+}
+
+QPropertyBindingError::~QPropertyBindingError()
+{
+}
+
+QPropertyBindingError::Type QPropertyBindingError::type() const
+{
+ if (!d)
+ return QPropertyBindingError::NoError;
+ return d->type;
+}
+
+void QPropertyBindingError::setDescription(const QString &description)
+{
+ if (!d)
+ d = new QPropertyBindingErrorPrivate;
+ d->description = description;
+}
+
+QString QPropertyBindingError::description() const
+{
+ if (!d)
+ return QString();
+ return d->description;
+}
+
+QPropertyBindingSourceLocation QPropertyBindingError::location() const
+{
+ if (!d)
+ return QPropertyBindingSourceLocation();
+ return d->location;
+}
+
+/*!
+ \class QProperty
+ \inmodule QtCore
+ \brief The QProperty class is a template class that enables automatic property bindings.
+
+ \ingroup tools
+
+ QProperty\<T\> is a generic container that holds an instance of T. You can assign
+ a value to it and you can read it via the value() function or the T conversion
+ operator. You can also tie the property to an expression that computes the value
+ dynamically, the binding expression. It is represented as a C++ lambda and
+ can be used to express relationships between different properties in your
+ application.
+
+ The binding expression computes the value by reading other QProperty values.
+ Behind the scenes this dependency is tracked. Whenever a change in any property's
+ dependency is detected, the binding expression is re-evaluated and the new
+ result is applied to the property. This happens lazily, by marking the binding
+ as dirty and evaluating it only when the property's value is requested. For example:
+
+ \code
+ QProperty<QString> firstname("John");
+ QProperty<QString> lastname("Smith");
+ QProperty<int> age(41);
+
+ QProperty<QString> fullname;
+ fullname.setBinding([&]() { return firstname.value() + " " + lastname.value() + " age:" + QString::number(age.value()); });
+
+ qDebug() << fullname.value(); // Prints "John Smith age: 41"
+
+ firstname = "Emma"; // Marks binding expression as dirty
+
+ qDebug() << fullname.value(); // Re-evaluates the binding expression and prints "Emma Smith age: 41"
+
+ // Birthday is coming up
+ age.setValue(age.value() + 1);
+
+ qDebug() << fullname.value(); // Re-evaluates the binding expression and prints "Emma Smith age: 42"
+ \endcode
+
+ When a new value is assigned to the \c firstname property, the binding
+ expression for \c fullname is marked as dirty. So when the last \c qDebug() statement
+ tries to read the name value of the \c fullname property, the expression is
+ evaluated again, \c firstname() will be called again and return the new value.
+
+ Since bindings are C++ lambda expressions, they may do anything that's possible
+ in C++. This includes calling other functions. If those functions access values
+ held by QProperty, they automatically become dependencies to the binding.
+
+ Binding expressions may use properties of any type, so in the above example the age
+ is an integer and folded into the string value using conversion to integer, but
+ the dependency is fully tracked.
+
+ \section1 Tracking properties
+
+ Sometimes the relationships between properties cannot be expressed using
+ bindings. Instead you may need to run custom code whenever the value of a property
+ changes and instead of assigning the value to another property, pass it to
+ other parts of your application. For example writing data into a network socket
+ or printing debug output. QProperty provides two mechanisms for tracking.
+
+ You can register for a callback function to be called whenever the value of
+ a property changes, by using onValueChanged(). If you want the callback to also
+ be called for the current value of the property, register your callback using
+ subscribe() instead.
+*/
+
+/*!
+ \fn template <typename T> QProperty<T>::QProperty()
+
+ Constructs a property with a default constructed instance of T.
+*/
+
+/*!
+ \fn template <typename T> explicit QProperty<T>::QProperty(const T &initialValue)
+
+ Constructs a property with the provided \a initialValue.
+*/
+
+/*!
+ \fn template <typename T> explicit QProperty<T>::QProperty(T &&initialValue)
+
+ Move-Constructs a property with the provided \a initialValue.
+*/
+
+/*!
+ \fn template <typename T> QProperty<T>::QProperty(QProperty<T> &&other)
+
+ Move-constructs a QProperty instance, making it point at the same object that
+ \a other was pointing to.
+*/
+
+/*!
+ \fn template <typename T> QProperty<T> &QProperty<T>::operator=(QProperty &&other)
+
+ Move-assigns \a other to this QProperty instance.
+*/
+
+/*!
+ \fn template <typename T> QProperty<T>::QProperty(const QPropertyBinding<T> &binding)
+
+ Constructs a property that is tied to the provided \a binding expression. The
+ first time the property value is read, the binding is evaluated. Whenever a
+ dependency of the binding changes, the binding will be re-evaluated the next
+ time the value of this property is read.
+*/
+
+/*!
+ \fn template <typename T> template <typename Functor> QProperty<T>::QProperty(Functor &&f)
+
+ Constructs a property that is tied to the provided binding expression \a f. The
+ first time the property value is read, the binding is evaluated. Whenever a
+ dependency of the binding changes, the binding will be re-evaluated the next
+ time the value of this property is read.
+*/
+
+/*!
+ \fn template <typename T> QProperty<T>::~QProperty()
+
+ Destroys the property.
+*/
+
+/*!
+ \fn template <typename T> T QProperty<T>::value() const
+
+ Returns the value of the property. This may evaluate a binding expression that
+ is tied to this property, before returning the value.
+*/
+
+/*!
+ \fn template <typename T> QProperty<T>::operator T() const
+
+ Returns the value of the property. This may evaluate a binding expression that
+ is tied to this property, before returning the value.
+*/
+
+/*!
+ \fn template <typename T> void QProperty<T>::setValue(const T &newValue)
+
+ Assigns \a newValue to this property and removes the property's associated
+ binding, if present.
+*/
+
+/*!
+ \fn template <typename T> void QProperty<T>::setValue(T &&newValue)
+ \overload
+
+ Assigns \a newValue to this property and removes the property's associated
+ binding, if present.
+*/
+
+/*!
+ \fn template <typename T> QProperty<T> &QProperty<T>::operator=(const T &newValue)
+
+ Assigns \a newValue to this property and returns a reference to this QProperty.
+*/
+
+/*!
+ \fn template <typename T> QProperty<T> &QProperty<T>::operator=(T &&newValue)
+ \overload
+
+ Assigns \a newValue to this property and returns a reference to this QProperty.
+*/
+
+/*!
+ \fn template <typename T> QProperty<T> &QProperty<T>::operator=(const QPropertyBinding<T> &newBinding)
+
+ Associates the value of this property with the provided \a newBinding
+ expression and returns a reference to this property. The first time the
+ property value is read, the binding is evaluated. Whenever a dependency of the
+ binding changes, the binding will be re-evaluated the next time the value of
+ this property is read.
+*/
+
+/*!
+ \fn template <typename T> QPropertyBinding<T> QProperty<T>::setBinding(const QPropertyBinding<T> &newBinding)
+
+ Associates the value of this property with the provided \a newBinding
+ expression and returns the previously associated binding. The first time the
+ property value is read, the binding is evaluated. Whenever a dependency of the
+ binding changes, the binding will be re-evaluated the next time the value of
+ this property is read.
+*/
+
+/*!
+ \fn template <typename T> template <typename Functor> QPropertyBinding<T> QProperty<T>::setBinding(Functor f)
+ \overload
+
+ Associates the value of this property with the provided functor \a f and
+ returns the previously associated binding. The first time the property value
+ is read, the binding is evaluated by invoking the call operator () of \a f.
+ Whenever a dependency of the binding changes, the binding will be re-evaluated
+ the next time the value of this property is read.
+*/
+
+/*!
+ \fn template <typename T> QPropertyBinding<T> QProperty<T>::setBinding(QPropertyBinding<T> &&newBinding)
+ \overload
+
+ Associates the value of this property with the provided \a newBinding
+ expression and returns the previously associated binding. The first time the
+ property value is read, the binding is evaluated. Whenever a dependency of the
+ binding changes, the binding will be re-evaluated the next time the value of
+ this property is read.
+*/
+
+/*!
+ \fn template <typename T> QPropertyBinding<T> QProperty<T>::binding() const
+
+ Returns the binding expression that is associated with this property. A
+ default constructed QPropertyBinding<T> will be returned if no such
+ association exists.
+*/
+
+/*!
+ \fn template <typename T> QPropertyBinding<T> QProperty<T>::takeBinding()
+
+ Disassociates the binding expression from this property and returns it. After
+ calling this function, the value of the property will only change if you
+ assign a new value to it, or when a new binding is set.
+*/
+
+/*!
+ \fn template <typename T> template <typename Functor> QPropertyChangeHandler<T, Functor> QProperty<T>::onValueChanged(Functor f)
+
+ Registers the given functor \a f as a callback that shall be called whenever
+ the value of the property changes.
+
+ The callback \a f is expected to be a type that has a plain call operator () without any
+ parameters. This means that you can provide a C++ lambda expression, an std::function
+ or even a custom struct with a call operator.
+
+ The returned property change handler object keeps track of the registration. When it
+ goes out of scope, the callback is de-registered.
+*/
+
+/*!
+ \fn template <typename T> template <typename Functor> QPropertyChangeHandler<T, Functor> QProperty<T>::subscribe(Functor f)
+
+ Subscribes the given functor \a f as a callback that is called immediately and whenever
+ the value of the property changes in the future.
+
+ The callback \a f is expected to be a type that has a plain call operator () without any
+ parameters. This means that you can provide a C++ lambda expression, an std::function
+ or even a custom struct with a call operator.
+
+ The returned property change handler object keeps track of the subscription. When it
+ goes out of scope, the callback is unsubscribed.
+*/
+
+/*!
+ \class QPropertyChangeHandler
+ \inmodule QtCore
+ \brief The QPropertyChangeHandler class controls the lifecycle of change callback installed on a QProperty.
+
+ \ingroup tools
+
+ QPropertyChangeHandler\<PropertyType, Functor\> is created when registering a
+ callback on a QProperty to listen to changes to the property's value, using QProperty::onValueChanged
+ and QProperty::subscribe. As long as the change handler is alive, the callback remains installed.
+
+ A handler instance can be transferred between C++ scopes using move semantics.
+*/
+
+QT_END_NAMESPACE
diff --git a/src/corelib/kernel/qproperty.h b/src/corelib/kernel/qproperty.h
new file mode 100644
index 0000000000..45acfadd50
--- /dev/null
+++ b/src/corelib/kernel/qproperty.h
@@ -0,0 +1,451 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPROPERTY_H
+#define QPROPERTY_H
+
+#include <QtCore/qglobal.h>
+#include <QtCore/QSharedDataPointer>
+#include <QtCore/QString>
+#include <functional>
+#include <type_traits>
+#include <variant>
+
+#include <QtCore/qpropertyprivate.h>
+
+#if __has_include(<source_location>) && __cplusplus >= 202002L && !defined(Q_CLANG_QDOC)
+#include <experimental/source_location>
+#define QT_PROPERTY_COLLECT_BINDING_LOCATION
+#define QT_PROPERTY_DEFAULT_BINDING_LOCATION QPropertyBindingSourceLocation(std::source_location::current())
+#elif __has_include(<experimental/source_location>) && __cplusplus >= 201703L && !defined(Q_CLANG_QDOC)
+#include <experimental/source_location>
+#define QT_PROPERTY_COLLECT_BINDING_LOCATION
+#define QT_PROPERTY_DEFAULT_BINDING_LOCATION QPropertyBindingSourceLocation(std::experimental::source_location::current())
+#else
+#define QT_PROPERTY_DEFAULT_BINDING_LOCATION QPropertyBindingSourceLocation()
+#endif
+
+QT_BEGIN_NAMESPACE
+
+struct Q_CORE_EXPORT QPropertyBindingSourceLocation
+{
+ const char *fileName = nullptr;
+ const char *functionName = nullptr;
+ quint32 line = 0;
+ quint32 column = 0;
+ QPropertyBindingSourceLocation() = default;
+#ifdef QT_PROPERTY_COLLECT_BINDING_LOCATION
+ QPropertyBindingSourceLocation(const std::experimental::source_location &cppLocation)
+ {
+ fileName = cppLocation.file_name();
+ functionName = cppLocation.function_name();
+ line = cppLocation.line();
+ column = cppLocation.column();
+ }
+#endif
+};
+
+template <typename Functor> class QPropertyChangeHandler;
+
+template <typename T> class QProperty;
+
+class QPropertyBindingErrorPrivate;
+
+class Q_CORE_EXPORT QPropertyBindingError
+{
+public:
+ enum Type {
+ NoError,
+ BindingLoop,
+ EvaluationError,
+ UnknownError
+ };
+
+ QPropertyBindingError(Type type = NoError);
+ QPropertyBindingError(const QPropertyBindingError &other);
+ QPropertyBindingError &operator=(const QPropertyBindingError &other);
+ QPropertyBindingError(QPropertyBindingError &&other);
+ QPropertyBindingError &operator=(QPropertyBindingError &&other);
+ ~QPropertyBindingError();
+
+ Type type() const;
+ void setDescription(const QString &description);
+ QString description() const;
+ QPropertyBindingSourceLocation location() const;
+
+private:
+ QSharedDataPointer<QPropertyBindingErrorPrivate> d;
+};
+
+class Q_CORE_EXPORT QUntypedPropertyBinding
+{
+public:
+ // Returns either a boolean to indicate value change or an error.
+ using BindingEvaluationResult = std::variant<bool, QPropertyBindingError>;
+ // returns true if value changed, false if the binding evaluation lead to the same value as the property
+ // already has.
+ using BindingEvaluationFunction = std::function<BindingEvaluationResult(int version, void *propertyStoragePtr)>;
+
+ QUntypedPropertyBinding() = default;
+ QUntypedPropertyBinding(BindingEvaluationFunction function, const QPropertyBindingSourceLocation &location);
+ QUntypedPropertyBinding(QUntypedPropertyBinding &&other);
+ QUntypedPropertyBinding(const QUntypedPropertyBinding &other);
+ QUntypedPropertyBinding &operator=(const QUntypedPropertyBinding &other);
+ QUntypedPropertyBinding &operator=(QUntypedPropertyBinding &&other);
+ ~QUntypedPropertyBinding();
+
+ bool isNull() const;
+
+ QPropertyBindingError error() const;
+
+private:
+ explicit QUntypedPropertyBinding(const QPropertyBindingPrivatePtr &priv);
+ friend class QtPrivate::QPropertyBase;
+ friend struct QPropertyBindingPrivate;
+ template <typename> friend class QPropertyBinding;
+ QPropertyBindingPrivatePtr d;
+};
+
+template <typename PropertyType>
+class QPropertyBinding : public QUntypedPropertyBinding
+{
+ template <typename Functor>
+ struct BindingAdaptor
+ {
+ Functor impl;
+ QUntypedPropertyBinding::BindingEvaluationResult operator()(int /*version*/, void *propertyStoragePtr)
+ {
+ std::variant<PropertyType, QPropertyBindingError> result(impl());
+ if (auto errorPtr = std::get_if<QPropertyBindingError>(&result))
+ return *errorPtr;
+
+ if (auto valuePtr = std::get_if<PropertyType>(&result)) {
+ auto storagePtr = reinterpret_cast<QtPrivate::QPropertyValueStorage<PropertyType>*>(propertyStoragePtr);
+ return storagePtr->setValueAndReturnTrueIfChanged(std::move(*valuePtr));
+ }
+
+ return false;
+ }
+ };
+
+public:
+ QPropertyBinding() = default;
+
+ template<typename Functor>
+ QPropertyBinding(Functor &&f, const QPropertyBindingSourceLocation &location)
+ : QUntypedPropertyBinding(BindingAdaptor<Functor>{std::forward<Functor>(f)}, location)
+ {}
+
+ QPropertyBinding(const QProperty<PropertyType> &property)
+ : QUntypedPropertyBinding(property.d.priv.binding())
+ {}
+
+private:
+ // Internal
+ explicit QPropertyBinding(const QUntypedPropertyBinding &binding)
+ : QUntypedPropertyBinding(binding)
+ {}
+ friend class QProperty<PropertyType>;
+};
+
+namespace QtPrivate {
+ template<typename... Ts>
+ constexpr auto is_variant_v = false;
+ template<typename... Ts>
+ constexpr auto is_variant_v<std::variant<Ts...>> = true;
+}
+
+namespace Qt {
+ template <typename Functor>
+ auto makePropertyBinding(Functor &&f, const QPropertyBindingSourceLocation &location = QT_PROPERTY_DEFAULT_BINDING_LOCATION,
+ std::enable_if_t<std::is_invocable_v<Functor>> * = 0)
+ {
+ if constexpr (QtPrivate::is_variant_v<std::invoke_result_t<Functor>>) {
+ return QPropertyBinding<std::variant_alternative_t<0, std::invoke_result_t<Functor>>>(std::forward<Functor>(f), location);
+ } else {
+ return QPropertyBinding<std::invoke_result_t<Functor>>(std::forward<Functor>(f), location);
+ }
+ // Work around bogus warning
+ Q_UNUSED(QtPrivate::is_variant_v<bool>)
+ }
+}
+
+struct QPropertyBasePointer;
+
+template <typename T>
+class QProperty
+{
+public:
+ QProperty() = default;
+ explicit QProperty(const T &initialValue) : d(initialValue) {}
+ explicit QProperty(T &&initialValue) : d(std::move(initialValue)) {}
+ QProperty(QProperty &&other) : d(std::move(other.d)) { notify(); }
+ QProperty &operator=(QProperty &&other) { d = std::move(other.d); notify(); return *this; }
+ QProperty(const QPropertyBinding<T> &binding)
+ : QProperty()
+ { operator=(binding); }
+ QProperty(QPropertyBinding<T> &&binding)
+ : QProperty()
+ { operator=(std::move(binding)); }
+#ifndef Q_CLANG_QDOC
+ template <typename Functor>
+ explicit QProperty(Functor &&f, const QPropertyBindingSourceLocation &location = QT_PROPERTY_DEFAULT_BINDING_LOCATION,
+ typename std::enable_if_t<std::is_invocable_r_v<T, Functor&>> * = 0);
+#else
+ template <typename Functor>
+ explicit QProperty(Functor &&f);
+#endif
+ ~QProperty() = default;
+
+ T value() const
+ {
+ if (d.priv.hasBinding())
+ d.priv.evaluateIfDirty();
+ d.priv.registerWithCurrentlyEvaluatingBinding();
+ return d.getValue();
+ }
+
+ operator T() const
+ {
+ return value();
+ }
+
+ void setValue(T &&newValue)
+ {
+ if (d.setValueAndReturnTrueIfChanged(std::move(newValue)))
+ notify();
+ d.priv.removeBinding();
+ }
+
+ void setValue(const T &newValue)
+ {
+ if (d.setValueAndReturnTrueIfChanged(newValue))
+ notify();
+ d.priv.removeBinding();
+ }
+
+ QProperty<T> &operator=(T &&newValue)
+ {
+ setValue(std::move(newValue));
+ return *this;
+ }
+
+ QProperty<T> &operator=(const T &newValue)
+ {
+ setValue(newValue);
+ return *this;
+ }
+
+ QProperty<T> &operator=(const QPropertyBinding<T> &newBinding)
+ {
+ setBinding(newBinding);
+ return *this;
+ }
+
+ QProperty<T> &operator=(QPropertyBinding<T> &&newBinding)
+ {
+ setBinding(std::move(newBinding));
+ return *this;
+ }
+
+ QPropertyBinding<T> setBinding(const QPropertyBinding<T> &newBinding)
+ {
+ QPropertyBinding<T> oldBinding(d.priv.setBinding(newBinding, &d));
+ notify();
+ return oldBinding;
+ }
+
+ QPropertyBinding<T> setBinding(QPropertyBinding<T> &&newBinding)
+ {
+ QPropertyBinding<T> b(std::move(newBinding));
+ QPropertyBinding<T> oldBinding(d.priv.setBinding(b, &d));
+ notify();
+ return oldBinding;
+ }
+
+#ifndef Q_CLANG_QDOC
+ template <typename Functor>
+ QPropertyBinding<T> setBinding(Functor f,
+ const QPropertyBindingSourceLocation &location = QT_PROPERTY_DEFAULT_BINDING_LOCATION)
+ {
+ return setBinding(Qt::makePropertyBinding(f, location));
+ }
+#else
+ template <typename Functor>
+ QPropertyBinding<T> setBinding(Functor f);
+#endif
+
+ bool hasBinding() const { return d.priv.hasBinding(); }
+
+ QPropertyBinding<T> binding() const
+ {
+ return QPropertyBinding<T>(*this);
+ }
+
+ QPropertyBinding<T> takeBinding()
+ {
+ return QPropertyBinding<T>(d.priv.setBinding(QUntypedPropertyBinding(), &d));
+ }
+
+ template<typename Functor>
+ QPropertyChangeHandler<Functor> onValueChanged(Functor f);
+ template<typename Functor>
+ QPropertyChangeHandler<Functor> subscribe(Functor f);
+
+private:
+ void notify()
+ {
+ d.priv.notifyObservers();
+ }
+
+ Q_DISABLE_COPY(QProperty)
+
+ friend struct QPropertyBasePointer;
+ friend struct QPropertyBinding<T>;
+ friend struct QPropertyObserver;
+ // Mutable because querying for the value may require evalating the binding expression, calling
+ // non-const functions on QPropertyBase.
+ mutable QtPrivate::QPropertyValueStorage<T> d;
+};
+
+#ifndef Q_CLANG_QDOC
+template <typename PropertyType>
+template <typename Functor>
+QProperty<PropertyType>::QProperty(Functor &&f, const QPropertyBindingSourceLocation &location,
+ typename std::enable_if_t<std::is_invocable_r_v<PropertyType, Functor&>> *)
+ : QProperty(QPropertyBinding<PropertyType>(std::forward<Functor>(f), location))
+{}
+#endif
+
+namespace Qt {
+ template <typename PropertyType>
+ QPropertyBinding<PropertyType> makePropertyBinding(const QProperty<PropertyType> &otherProperty,
+ const QPropertyBindingSourceLocation &location =
+ QT_PROPERTY_DEFAULT_BINDING_LOCATION)
+ {
+ return Qt::makePropertyBinding([&otherProperty]() -> PropertyType { return otherProperty; }, location);
+ }
+}
+
+struct QPropertyObserverPrivate;
+struct QPropertyObserverPointer;
+
+struct Q_CORE_EXPORT QPropertyObserver
+{
+ QPropertyObserver() = default;
+ QPropertyObserver(QPropertyObserver &&other);
+ QPropertyObserver &operator=(QPropertyObserver &&other);
+ ~QPropertyObserver();
+
+ template <typename PropertyType>
+ void setSource(const QProperty<PropertyType> &property)
+ { setSource(property.d.priv); }
+
+protected:
+ QPropertyObserver(void (*callback)(QPropertyObserver*));
+
+private:
+ void setSource(QtPrivate::QPropertyBase &property);
+
+ QtPrivate::QTaggedPointer<QPropertyObserver> next;
+ // prev is a pointer to the "next" element within the previous node, or to the "firstObserverPtr" if it is the
+ // first node.
+ QtPrivate::QPropertyTagPreservingPointerToPointer<QPropertyObserver> prev;
+
+ union {
+ QPropertyBindingPrivate *bindingToMarkDirty = nullptr;
+ void (*changeHandler)(QPropertyObserver*);
+ };
+
+ QPropertyObserver(const QPropertyObserver &) = delete;
+ QPropertyObserver &operator=(const QPropertyObserver &) = delete;
+
+ friend struct QPropertyObserverPointer;
+};
+
+template <typename Functor>
+class QPropertyChangeHandler : public QPropertyObserver
+{
+ Functor m_handler;
+public:
+ QPropertyChangeHandler(Functor handler)
+ : QPropertyObserver([](QPropertyObserver *self) {
+ auto This = static_cast<QPropertyChangeHandler<Functor>*>(self);
+ This->m_handler();
+ })
+ , m_handler(handler)
+ {
+ }
+
+ template <typename PropertyType>
+ QPropertyChangeHandler(const QProperty<PropertyType> &property, Functor handler)
+ : QPropertyObserver([](QPropertyObserver *self) {
+ auto This = static_cast<QPropertyChangeHandler<Functor>*>(self);
+ This->m_handler();
+ })
+ , m_handler(handler)
+ {
+ setSource(property);
+ }
+};
+
+template <typename T>
+template<typename Functor>
+QPropertyChangeHandler<Functor> QProperty<T>::onValueChanged(Functor f)
+{
+#if defined(__cpp_lib_is_invocable) && (__cpp_lib_is_invocable >= 201703L)
+ static_assert(std::is_invocable_v<Functor>, "Functor callback must be callable without any parameters");
+#endif
+ return QPropertyChangeHandler<Functor>(*this, f);
+}
+
+template <typename T>
+template<typename Functor>
+QPropertyChangeHandler<Functor> QProperty<T>::subscribe(Functor f)
+{
+#if defined(__cpp_lib_is_invocable) && (__cpp_lib_is_invocable >= 201703L)
+ static_assert(std::is_invocable_v<Functor>, "Functor callback must be callable without any parameters");
+#endif
+ f();
+ return onValueChanged(f);
+}
+
+QT_END_NAMESPACE
+
+#endif // QPROPERTY_H
diff --git a/src/corelib/kernel/qproperty_p.h b/src/corelib/kernel/qproperty_p.h
new file mode 100644
index 0000000000..1b96e09d58
--- /dev/null
+++ b/src/corelib/kernel/qproperty_p.h
@@ -0,0 +1,118 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPROPERTY_P_H
+#define QPROPERTY_P_H
+
+//
+// W A R N I N G
+// -------------
+//
+// This file is not part of the Qt API. It exists for the convenience
+// of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp. This header
+// file may change from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qglobal.h>
+#include <qvarlengtharray.h>
+
+#include "qproperty.h"
+
+QT_BEGIN_NAMESPACE
+
+// This is a helper "namespace"
+struct Q_AUTOTEST_EXPORT QPropertyBasePointer
+{
+ const QtPrivate::QPropertyBase *ptr = nullptr;
+
+ QPropertyBindingPrivate *bindingPtr() const;
+
+ QtPrivate::QPropertyTagPreservingPointerToPointer<QPropertyObserver> firstObserverPtr() const;
+ QPropertyObserverPointer firstObserver() const;
+
+ int observerCount() const;
+
+ template <typename T>
+ static QPropertyBasePointer get(QProperty<T> &property)
+ {
+ return QPropertyBasePointer{&property.d.priv};
+ }
+};
+
+// This is a helper "namespace"
+struct QPropertyObserverPointer
+{
+ QPropertyObserver *ptr = nullptr;
+
+ void unlink();
+
+ void setBindingToMarkDirty(QPropertyBindingPrivate *binding);
+ void setChangeHandler(void (*changeHandler)(QPropertyObserver*));
+
+ void notify(QPropertyBindingPrivate *triggeringBinding);
+ void observeProperty(QPropertyBasePointer property);
+ void prependToBinding(QPropertyBindingPrivate *binding);
+
+ explicit operator bool() const { return ptr != nullptr; }
+
+ QPropertyObserverPointer nextObserver() const { return {ptr->next.data()}; }
+};
+
+class QPropertyBindingErrorPrivate : public QSharedData
+{
+public:
+ QPropertyBindingError::Type type = QPropertyBindingError::NoError;
+ QString description;
+ QPropertyBindingSourceLocation location;
+};
+
+struct BindingEvaluationState
+{
+ BindingEvaluationState(QPropertyBindingPrivate *binding);
+ ~BindingEvaluationState();
+ QPropertyBindingPrivate *binding;
+ QVarLengthArray<QPropertyObserver, 4> *dependencyObservers = nullptr;
+ BindingEvaluationState *previousState = nullptr;
+};
+
+QT_END_NAMESPACE
+
+#endif // QPROPERTY_P_H
diff --git a/src/corelib/kernel/qpropertybinding.cpp b/src/corelib/kernel/qpropertybinding.cpp
new file mode 100644
index 0000000000..23f7075998
--- /dev/null
+++ b/src/corelib/kernel/qpropertybinding.cpp
@@ -0,0 +1,141 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qpropertybinding_p.h"
+#include "qproperty_p.h"
+
+#include <QScopedValueRollback>
+
+QT_BEGIN_NAMESPACE
+
+using namespace QtPrivate;
+
+QPropertyBindingPrivate::~QPropertyBindingPrivate()
+{
+ if (firstObserver)
+ firstObserver.unlink();
+}
+
+void QPropertyBindingPrivate::unlinkAndDeref()
+{
+ propertyDataPtr = nullptr;
+ if (!ref.deref())
+ delete this;
+}
+
+void QPropertyBindingPrivate::markDirtyAndNotifyObservers()
+{
+ dirty = true;
+ if (firstObserver)
+ firstObserver.notify(this);
+}
+
+bool QPropertyBindingPrivate::evaluateIfDirtyAndReturnTrueIfValueChanged()
+{
+ if (!dirty)
+ return false;
+
+ if (updating) {
+ error = QPropertyBindingError(QPropertyBindingError::BindingLoop);
+ return false;
+ }
+
+ QScopedValueRollback<bool> updateGuard(updating, true);
+
+ BindingEvaluationState evaluationFrame(this);
+ bool changed = false;
+ auto result = evaluationFunction(/*version*/1, propertyDataPtr);
+ if (auto changedPtr = std::get_if<bool>(&result))
+ changed = *changedPtr;
+ else if (auto errorPtr = std::get_if<QPropertyBindingError>(&result))
+ error = std::move(*errorPtr);
+ dirty = false;
+ return changed;
+}
+
+QUntypedPropertyBinding::QUntypedPropertyBinding(QUntypedPropertyBinding::BindingEvaluationFunction function,
+ const QPropertyBindingSourceLocation &location)
+{
+ d = new QPropertyBindingPrivate(std::move(function), std::move(location));
+}
+
+QUntypedPropertyBinding::QUntypedPropertyBinding(QUntypedPropertyBinding &&other)
+ : d(std::move(other.d))
+{
+}
+
+QUntypedPropertyBinding::QUntypedPropertyBinding(const QUntypedPropertyBinding &other)
+ : d(other.d)
+{
+}
+
+QUntypedPropertyBinding &QUntypedPropertyBinding::operator=(const QUntypedPropertyBinding &other)
+{
+ d = other.d;
+ return *this;
+}
+
+QUntypedPropertyBinding &QUntypedPropertyBinding::operator=(QUntypedPropertyBinding &&other)
+{
+ d = std::move(other.d);
+ return *this;
+}
+
+QUntypedPropertyBinding::QUntypedPropertyBinding(const QPropertyBindingPrivatePtr &priv)
+ : d(priv)
+{
+}
+
+QUntypedPropertyBinding::~QUntypedPropertyBinding()
+{
+}
+
+bool QUntypedPropertyBinding::isNull() const
+{
+ return !d;
+}
+
+QPropertyBindingError QUntypedPropertyBinding::error() const
+{
+ if (!d)
+ return QPropertyBindingError();
+ return d->error;
+}
+
+QT_END_NAMESPACE
diff --git a/src/corelib/kernel/qpropertybinding_p.h b/src/corelib/kernel/qpropertybinding_p.h
new file mode 100644
index 0000000000..12913b3088
--- /dev/null
+++ b/src/corelib/kernel/qpropertybinding_p.h
@@ -0,0 +1,98 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPROPERTYBINDING_P_H
+#define QPROPERTYBINDING_P_H
+
+//
+// W A R N I N G
+// -------------
+//
+// This file is not part of the Qt API. It exists for the convenience
+// of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp. This header
+// file may change from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qglobal.h>
+#include <QtCore/qshareddata.h>
+#include <QtCore/qvarlengtharray.h>
+#include <memory>
+#include <vector>
+#include <functional>
+
+#include "qproperty_p.h"
+
+QT_BEGIN_NAMESPACE
+
+struct QPropertyBindingPrivate : public QSharedData
+{
+ QUntypedPropertyBinding::BindingEvaluationFunction evaluationFunction;
+
+ QPropertyObserverPointer firstObserver;
+ QVarLengthArray<QPropertyObserver, 4> dependencyObservers;
+
+ void *propertyDataPtr = nullptr;
+
+ QPropertyBindingSourceLocation location;
+ QPropertyBindingError error;
+
+ bool dirty = false;
+ bool updating = false;
+
+ QPropertyBindingPrivate(QUntypedPropertyBinding::BindingEvaluationFunction evaluationFunction,
+ const QPropertyBindingSourceLocation &location)
+ : evaluationFunction(std::move(evaluationFunction))
+ , location(location)
+ {}
+ virtual ~QPropertyBindingPrivate();
+
+ void unlinkAndDeref();
+
+ void markDirtyAndNotifyObservers();
+ bool evaluateIfDirtyAndReturnTrueIfValueChanged();
+
+ static QPropertyBindingPrivate *get(const QUntypedPropertyBinding &binding)
+ { return binding.d.data(); }
+};
+
+QT_END_NAMESPACE
+
+#endif // QPROPERTYBINDING_P_H
diff --git a/src/corelib/kernel/qpropertyprivate.h b/src/corelib/kernel/qpropertyprivate.h
new file mode 100644
index 0000000000..6d4a729845
--- /dev/null
+++ b/src/corelib/kernel/qpropertyprivate.h
@@ -0,0 +1,249 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPROPERTYPRIVATE_H
+#define QPROPERTYPRIVATE_H
+
+//
+// W A R N I N G
+// -------------
+//
+// This file is not part of the Qt API. It exists for the convenience
+// of qapplication_*.cpp, qwidget*.cpp and qfiledialog.cpp. This header
+// file may change from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qglobal.h>
+#include <QtCore/QExplicitlySharedDataPointer>
+
+QT_BEGIN_NAMESPACE
+
+class QUntypedPropertyBinding;
+struct QPropertyBindingPrivate;
+using QPropertyBindingPrivatePtr = QExplicitlySharedDataPointer<QPropertyBindingPrivate>;
+struct QPropertyBasePointer;
+
+namespace QtPrivate {
+
+class Q_CORE_EXPORT QPropertyBase
+{
+ // Mutable because the address of the observer of the currently evaluating binding is stored here, for
+ // notification later when the value changes.
+ mutable quintptr d_ptr = 0;
+ friend struct QT_PREPEND_NAMESPACE(QPropertyBasePointer);
+public:
+ QPropertyBase() = default;
+ Q_DISABLE_COPY(QPropertyBase)
+ QPropertyBase(QPropertyBase &&other) = delete;
+ QPropertyBase(QPropertyBase &&other, void *propertyDataPtr);
+ QPropertyBase &operator=(QPropertyBase &&other) = delete;
+ ~QPropertyBase();
+
+ void moveAssign(QPropertyBase &&other, void *propertyDataPtr);
+
+ bool hasBinding() const { return d_ptr & BindingBit; }
+
+ QUntypedPropertyBinding setBinding(const QUntypedPropertyBinding &newBinding, void *propertyDataPtr);
+ QPropertyBindingPrivatePtr binding();
+
+ void evaluateIfDirty();
+ void removeBinding();
+
+ void registerWithCurrentlyEvaluatingBinding() const;
+ void notifyObservers();
+
+ void setExtraBit(bool b)
+ {
+ if (b)
+ d_ptr |= ExtraBit;
+ else
+ d_ptr &= ~ExtraBit;
+ }
+
+ bool extraBit() const { return d_ptr & ExtraBit; }
+
+ static const quintptr ExtraBit = 0x1; // Used for QProperty<bool> specialization
+ static const quintptr BindingBit = 0x2; // Is d_ptr pointing to a binding (1) or list of notifiers (0)?
+ static const quintptr FlagMask = BindingBit | ExtraBit;
+};
+
+template <typename T>
+struct QPropertyValueStorage
+{
+private:
+ T value;
+public:
+ QPropertyBase priv;
+
+ QPropertyValueStorage() : value() {}
+ Q_DISABLE_COPY(QPropertyValueStorage)
+ explicit QPropertyValueStorage(const T &initialValue) : value(initialValue) {}
+ QPropertyValueStorage &operator=(const T &newValue) { value = newValue; return *this; }
+ explicit QPropertyValueStorage(T &&initialValue) : value(std::move(initialValue)) {}
+ QPropertyValueStorage &operator=(T &&newValue) { value = std::move(newValue); return *this; }
+ QPropertyValueStorage(QPropertyValueStorage &&other) : value(std::move(other.value)), priv(std::move(other.priv), this) {}
+ QPropertyValueStorage &operator=(QPropertyValueStorage &&other) { value = std::move(other.value); priv.moveAssign(std::move(other.priv), &value); return *this; }
+
+ T getValue() const { return value; }
+ bool setValueAndReturnTrueIfChanged(T &&v)
+ {
+ if (v == value)
+ return false;
+ value = std::move(v);
+ return true;
+ }
+ bool setValueAndReturnTrueIfChanged(const T &v)
+ {
+ if (v == value)
+ return false;
+ value = v;
+ return true;
+ }
+};
+
+template<>
+struct QPropertyValueStorage<bool>
+{
+ QPropertyBase priv;
+
+ QPropertyValueStorage() = default;
+ Q_DISABLE_COPY(QPropertyValueStorage)
+ explicit QPropertyValueStorage(bool initialValue) { priv.setExtraBit(initialValue); }
+ QPropertyValueStorage &operator=(bool newValue) { priv.setExtraBit(newValue); return *this; }
+ QPropertyValueStorage(QPropertyValueStorage &&other) : priv(std::move(other.priv), this) {}
+ QPropertyValueStorage &operator=(QPropertyValueStorage &&other) { priv.moveAssign(std::move(other.priv), this); return *this; }
+
+ bool getValue() const { return priv.extraBit(); }
+ bool setValueAndReturnTrueIfChanged(bool v)
+ {
+ if (v == priv.extraBit())
+ return false;
+ priv.setExtraBit(v);
+ return true;
+ }
+};
+
+template <typename T> class QTaggedPointer;
+
+template <typename T, quintptr Mask = 0x3>
+class QPropertyTagPreservingPointerToPointer
+{
+ quintptr *data = nullptr;
+
+public:
+ QPropertyTagPreservingPointerToPointer() = default;
+ QPropertyTagPreservingPointerToPointer(T **ptr)
+ : data(reinterpret_cast<quintptr*>(ptr))
+ {}
+ QPropertyTagPreservingPointerToPointer(quintptr *ptr)
+ : data(ptr)
+ {}
+
+ QPropertyTagPreservingPointerToPointer<T> &operator=(T **ptr)
+ {
+ data = reinterpret_cast<quintptr*>(ptr);
+ return *this;
+ }
+
+ QPropertyTagPreservingPointerToPointer<T> &operator=(QTaggedPointer<T> *ptr)
+ {
+ data = reinterpret_cast<quintptr*>(ptr);
+ return *this;
+ }
+
+ void clear()
+ {
+ data = nullptr;
+ }
+
+ void set(T *ptr)
+ {
+ *data = (*data & Mask) | (reinterpret_cast<quintptr>(ptr) & ~Mask);
+ }
+
+ T *get() const
+ {
+ return reinterpret_cast<T*>(*data & ~Mask);
+ }
+
+ explicit operator bool() const { return data != nullptr; }
+};
+
+template <typename T>
+class QTaggedPointer
+{
+public:
+ QTaggedPointer() = default;
+ QTaggedPointer(T *ptr) : tagAndPointer(reinterpret_cast<quintptr>(ptr)) {}
+
+ void setFlag(bool b)
+ {
+ if (b)
+ tagAndPointer |= Flag1Mask;
+ else
+ tagAndPointer &= ~Flag1Mask;
+ }
+
+ bool flag() const { return tagAndPointer & Flag1Mask; }
+
+ QTaggedPointer &operator=(T *ptr)
+ {
+ quintptr tag = tagAndPointer & TagMask;
+ tagAndPointer = reinterpret_cast<quintptr>(ptr) | tag;
+ return *this;
+ }
+
+ T *data() const { return reinterpret_cast<T*>(tagAndPointer & ~TagMask); }
+
+ explicit operator bool() const { return tagAndPointer & ~TagMask; }
+ T *operator->() const { return data(); }
+
+private:
+ quintptr tagAndPointer = 0;
+ static const quintptr Flag1Mask = 0x1;
+ static const quintptr TagMask = 0x3;
+};
+
+} // namespace QtPrivate
+
+QT_END_NAMESPACE
+
+#endif // QPROPERTYPRIVATE_H
diff --git a/tests/auto/corelib/kernel/kernel.pro b/tests/auto/corelib/kernel/kernel.pro
index 09074a9e8a..26cc00ea40 100644
--- a/tests/auto/corelib/kernel/kernel.pro
+++ b/tests/auto/corelib/kernel/kernel.pro
@@ -23,7 +23,8 @@ SUBDIRS=\
qtimer \
qtranslator \
qvariant \
- qwineventnotifier
+ qwineventnotifier \
+ qproperty
!qtHaveModule(gui): SUBDIRS -= \
qmimedata
@@ -35,7 +36,8 @@ SUBDIRS=\
!qtConfig(private_tests): SUBDIRS -= \
qsocketnotifier \
- qsharedmemory
+ qsharedmemory \
+ qproperty
# This test is only applicable on Windows
!win32*|winrt: SUBDIRS -= qwineventnotifier
diff --git a/tests/auto/corelib/kernel/qproperty/qproperty.pro b/tests/auto/corelib/kernel/qproperty/qproperty.pro
new file mode 100644
index 0000000000..bae67e70a4
--- /dev/null
+++ b/tests/auto/corelib/kernel/qproperty/qproperty.pro
@@ -0,0 +1,4 @@
+CONFIG += testcase
+TARGET = tst_qproperty
+QT = core core-private testlib
+SOURCES = tst_qproperty.cpp
diff --git a/tests/auto/corelib/kernel/qproperty/tst_qproperty.cpp b/tests/auto/corelib/kernel/qproperty/tst_qproperty.cpp
new file mode 100644
index 0000000000..7f64072df6
--- /dev/null
+++ b/tests/auto/corelib/kernel/qproperty/tst_qproperty.cpp
@@ -0,0 +1,615 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QObject>
+#include <qtest.h>
+#include <qproperty.h>
+#include <private/qproperty_p.h>
+#include <private/qpropertybinding_p.h>
+
+using namespace QtPrivate;
+
+class tst_QProperty : public QObject
+{
+ Q_OBJECT
+private slots:
+ void functorBinding();
+ void basicDependencies();
+ void multipleDependencies();
+ void bindingWithDeletedDependency();
+ void recursiveDependency();
+ void bindingAfterUse();
+ void switchBinding();
+ void avoidDependencyAllocationAfterFirstEval();
+ void propertyArrays();
+ void boolProperty();
+ void takeBinding();
+ void replaceBinding();
+ void swap();
+ void moveNotifies();
+ void moveCtor();
+ void changeHandler();
+ void propertyChangeHandlerApi();
+ void subscribe();
+ void changeHandlerThroughBindings();
+ void dontTriggerDependenciesIfUnchangedValue();
+ void bindingSourceLocation();
+ void bindingError();
+ void bindingLoop();
+ void changePropertyFromWithinChangeHandler();
+ void changePropertyFromWithinChangeHandlerThroughDependency();
+ void changePropertyFromWithinChangeHandler2();
+ void settingPropertyValueDoesRemoveBinding();
+};
+
+void tst_QProperty::functorBinding()
+{
+ QProperty<int> property([]() { return 42; });
+ QCOMPARE(property.value(), int(42));
+ property = Qt::makePropertyBinding([]() { return 100; });
+ QCOMPARE(property.value(), int(100));
+ property.setBinding([]() { return 50; });
+ QCOMPARE(property.value(), int(50));
+}
+
+void tst_QProperty::basicDependencies()
+{
+ QProperty<int> right(100);
+
+ QProperty<int> left = Qt::makePropertyBinding(right);
+
+ QCOMPARE(left.value(), int(100));
+
+ right = 42;
+
+ QCOMPARE(left.value(), int(42));
+}
+
+void tst_QProperty::multipleDependencies()
+{
+ QProperty<int> firstDependency(1);
+ QProperty<int> secondDependency(2);
+
+ QProperty<int> sum;
+ sum = Qt::makePropertyBinding([&]() { return firstDependency + secondDependency; });
+
+ QCOMPARE(QPropertyBasePointer::get(firstDependency).observerCount(), 0);
+ QCOMPARE(QPropertyBasePointer::get(secondDependency).observerCount(), 0);
+
+ QCOMPARE(sum.value(), int(3));
+ QCOMPARE(QPropertyBasePointer::get(firstDependency).observerCount(), 1);
+ QCOMPARE(QPropertyBasePointer::get(secondDependency).observerCount(), 1);
+
+ firstDependency = 10;
+
+ QCOMPARE(sum.value(), int(12));
+ QCOMPARE(QPropertyBasePointer::get(firstDependency).observerCount(), 1);
+ QCOMPARE(QPropertyBasePointer::get(secondDependency).observerCount(), 1);
+
+ secondDependency = 20;
+
+ QCOMPARE(sum.value(), int(30));
+ QCOMPARE(QPropertyBasePointer::get(firstDependency).observerCount(), 1);
+ QCOMPARE(QPropertyBasePointer::get(secondDependency).observerCount(), 1);
+
+ firstDependency = 1;
+ secondDependency = 1;
+ QCOMPARE(sum.value(), int(2));
+ QCOMPARE(QPropertyBasePointer::get(firstDependency).observerCount(), 1);
+ QCOMPARE(QPropertyBasePointer::get(secondDependency).observerCount(), 1);
+}
+
+void tst_QProperty::bindingWithDeletedDependency()
+{
+ QScopedPointer<QProperty<int>> dynamicProperty(new QProperty<int>(100));
+
+ QProperty<int> staticProperty(1000);
+
+ QProperty<bool> bindingReturnsDynamicProperty(false);
+
+ QProperty<int> propertySelector;
+ propertySelector = Qt::makePropertyBinding([&]() {
+ if (bindingReturnsDynamicProperty && !dynamicProperty.isNull())
+ return dynamicProperty->value();
+ else
+ return staticProperty.value();
+ });
+
+ QCOMPARE(propertySelector.value(), staticProperty.value());
+
+ bindingReturnsDynamicProperty = true;
+
+ QCOMPARE(propertySelector.value(), dynamicProperty->value());
+
+ dynamicProperty.reset();
+
+ QCOMPARE(propertySelector.value(), 100);
+
+ bindingReturnsDynamicProperty = false;
+
+ QCOMPARE(propertySelector.value(), staticProperty.value());
+}
+
+void tst_QProperty::recursiveDependency()
+{
+ QProperty<int> first(1);
+
+ QProperty<int> second;
+ second = Qt::makePropertyBinding(first);
+
+ QProperty<int> third;
+ third = Qt::makePropertyBinding(second);
+
+ QCOMPARE(third.value(), int(1));
+
+ first = 2;
+
+ QCOMPARE(third.value(), int(2));
+}
+
+void tst_QProperty::bindingAfterUse()
+{
+ QProperty<int> propWithBindingLater(1);
+
+ QProperty<int> propThatUsesFirstProp;
+ propThatUsesFirstProp = Qt::makePropertyBinding(propWithBindingLater);
+
+ QCOMPARE(propThatUsesFirstProp.value(), int(1));
+ QCOMPARE(QPropertyBasePointer::get(propWithBindingLater).observerCount(), 1);
+
+ QProperty<int> injectedValue(42);
+ propWithBindingLater = Qt::makePropertyBinding(injectedValue);
+
+ QCOMPARE(propThatUsesFirstProp.value(), int(42));
+ QCOMPARE(QPropertyBasePointer::get(propWithBindingLater).observerCount(), 1);
+}
+
+void tst_QProperty::switchBinding()
+{
+ QProperty<int> first(1);
+
+ QProperty<int> propWithChangingBinding;
+ propWithChangingBinding = Qt::makePropertyBinding(first);
+
+ QCOMPARE(propWithChangingBinding.value(), 1);
+
+ QProperty<int> output;
+ output = Qt::makePropertyBinding(propWithChangingBinding);
+ QCOMPARE(output.value(), 1);
+
+ QProperty<int> second(2);
+ propWithChangingBinding = Qt::makePropertyBinding(second);
+ QCOMPARE(output.value(), 2);
+}
+
+void tst_QProperty::avoidDependencyAllocationAfterFirstEval()
+{
+ QProperty<int> firstDependency(1);
+ QProperty<int> secondDependency(10);
+
+ QProperty<int> propWithBinding;
+ propWithBinding = Qt::makePropertyBinding([&]() { return firstDependency + secondDependency; });
+
+ QCOMPARE(propWithBinding.value(), int(11));
+
+ QVERIFY(QPropertyBasePointer::get(propWithBinding).bindingPtr());
+ QCOMPARE(QPropertyBasePointer::get(propWithBinding).bindingPtr()->dependencyObservers.size(), 2);
+ QVERIFY(QPropertyBasePointer::get(propWithBinding).bindingPtr()->dependencyObservers.capacity() >= 2);
+
+ firstDependency = 100;
+ QCOMPARE(propWithBinding.value(), int(110));
+ QCOMPARE(QPropertyBasePointer::get(propWithBinding).bindingPtr()->dependencyObservers.size(), 2);
+ QVERIFY(QPropertyBasePointer::get(propWithBinding).bindingPtr()->dependencyObservers.capacity() >= 2);
+}
+
+void tst_QProperty::propertyArrays()
+{
+ std::vector<QProperty<int>> properties;
+
+ int expectedSum = 0;
+ for (int i = 0; i < 10; ++i) {
+ properties.emplace_back(i);
+ expectedSum += i;
+ }
+
+ QProperty<int> sum;
+ sum = Qt::makePropertyBinding([&]() {
+ return std::accumulate(properties.begin(), properties.end(), 0);
+ });
+
+ QCOMPARE(sum.value(), expectedSum);
+
+ properties[4] = properties[4] + 42;
+ expectedSum += 42;
+ QCOMPARE(sum.value(), expectedSum);
+}
+
+void tst_QProperty::boolProperty()
+{
+ static_assert(sizeof(QProperty<bool>) == sizeof(void*), "Size of QProperty<bool> specialization must not exceed size of pointer");
+
+ QProperty<bool> first(true);
+ QProperty<bool> second(false);
+ QProperty<bool> all;
+ all = Qt::makePropertyBinding([&]() { return first && second; });
+
+ QCOMPARE(all.value(), false);
+
+ second = true;
+
+ QCOMPARE(all.value(), true);
+}
+
+void tst_QProperty::takeBinding()
+{
+ QPropertyBinding<int> existingBinding;
+ QVERIFY(existingBinding.isNull());
+
+ QProperty<int> first(100);
+ QProperty<int> second = Qt::makePropertyBinding(first);
+
+ QCOMPARE(second.value(), int(100));
+
+ existingBinding = second.takeBinding();
+ QVERIFY(!existingBinding.isNull());
+
+ first = 10;
+ QCOMPARE(second.value(), int(100));
+
+ second = 25;
+ QCOMPARE(second.value(), int(25));
+
+ second = existingBinding;
+ QCOMPARE(second.value(), int(10));
+ QVERIFY(!existingBinding.isNull());
+}
+
+void tst_QProperty::replaceBinding()
+{
+ QProperty<int> first(100);
+ QProperty<int> second = Qt::makePropertyBinding(first);
+
+ QCOMPARE(second.value(), 100);
+
+ auto constantBinding = Qt::makePropertyBinding([]() { return 42; });
+ auto oldBinding = second.setBinding(constantBinding);
+ QCOMPARE(second.value(), 42);
+
+ second = oldBinding;
+ QCOMPARE(second.value(), 100);
+}
+
+void tst_QProperty::swap()
+{
+ QProperty<int> firstDependency(1);
+ QProperty<int> secondDependency(2);
+
+ QProperty<int> first = Qt::makePropertyBinding(firstDependency);
+ QProperty<int> second = Qt::makePropertyBinding(secondDependency);
+
+ QCOMPARE(first.value(), 1);
+ QCOMPARE(second.value(), 2);
+
+ std::swap(first, second);
+
+ QCOMPARE(first.value(), 2);
+ QCOMPARE(second.value(), 1);
+
+ secondDependency = 20;
+ QCOMPARE(first.value(), 20);
+ QCOMPARE(second.value(), 1);
+
+ firstDependency = 100;
+ QCOMPARE(first.value(), 20);
+ QCOMPARE(second.value(), 100);
+}
+
+void tst_QProperty::moveNotifies()
+{
+ QProperty<int> first(1);
+ QProperty<int> second(2);
+
+ QProperty<int> propertyInTheMiddle = Qt::makePropertyBinding(first);
+
+ QProperty<int> finalProp1 = Qt::makePropertyBinding(propertyInTheMiddle);
+ QProperty<int> finalProp2 = Qt::makePropertyBinding(propertyInTheMiddle);
+
+ QCOMPARE(finalProp1.value(), 1);
+ QCOMPARE(finalProp2.value(), 1);
+
+ QCOMPARE(QPropertyBasePointer::get(propertyInTheMiddle).observerCount(), 2);
+
+ QProperty<int> other = Qt::makePropertyBinding(second);
+ QCOMPARE(other.value(), 2);
+
+ QProperty<int> otherDep = Qt::makePropertyBinding(other);
+ QCOMPARE(otherDep.value(), 2);
+ QCOMPARE(QPropertyBasePointer::get(other).observerCount(), 1);
+
+ propertyInTheMiddle = std::move(other);
+
+ QCOMPARE(QPropertyBasePointer::get(other).observerCount(), 0);
+
+ QCOMPARE(finalProp1.value(), 2);
+ QCOMPARE(finalProp2.value(), 2);
+}
+
+void tst_QProperty::moveCtor()
+{
+ QProperty<int> first(1);
+
+ QProperty<int> intermediate = Qt::makePropertyBinding(first);
+ QCOMPARE(intermediate.value(), 1);
+ QCOMPARE(QPropertyBasePointer::get(first).observerCount(), 1);
+
+ QProperty<int> targetProp(std::move(first));
+
+ QCOMPARE(QPropertyBasePointer::get(targetProp).observerCount(), 0);
+}
+
+void tst_QProperty::changeHandler()
+{
+ QProperty<int> testProperty(0);
+ QVector<int> recordedValues;
+
+ {
+ auto handler = testProperty.onValueChanged([&]() {
+ recordedValues << testProperty;
+ });
+
+ testProperty = 1;
+ testProperty = 2;
+ }
+ testProperty = 3;
+
+ QCOMPARE(recordedValues.count(), 2);
+ QCOMPARE(recordedValues.at(0), 1);
+ QCOMPARE(recordedValues.at(1), 2);
+}
+
+void tst_QProperty::propertyChangeHandlerApi()
+{
+ int changeHandlerCallCount = 0;
+ QPropertyChangeHandler handler([&changeHandlerCallCount]() {
+ ++changeHandlerCallCount;
+ });
+
+ QProperty<int> source1;
+ QProperty<int> source2;
+
+ handler.setSource(source1);
+
+ source1 = 100;
+ QCOMPARE(changeHandlerCallCount, 1);
+
+ handler.setSource(source2);
+ source1 = 101;
+ QCOMPARE(changeHandlerCallCount, 1);
+
+ source2 = 200;
+ QCOMPARE(changeHandlerCallCount, 2);
+}
+
+void tst_QProperty::subscribe()
+{
+ QProperty<int> testProperty(42);
+ QVector<int> recordedValues;
+
+ {
+ auto handler = testProperty.subscribe([&]() {
+ recordedValues << testProperty;
+ });
+
+ testProperty = 1;
+ testProperty = 2;
+ }
+ testProperty = 3;
+
+ QCOMPARE(recordedValues.count(), 3);
+ QCOMPARE(recordedValues.at(0), 42);
+ QCOMPARE(recordedValues.at(1), 1);
+ QCOMPARE(recordedValues.at(2), 2);
+}
+
+void tst_QProperty::changeHandlerThroughBindings()
+{
+ QProperty<bool> trigger(false);
+ QProperty<bool> blockTrigger(false);
+ QProperty<bool> condition = Qt::makePropertyBinding([&]() {
+ bool triggerValue = trigger;
+ bool blockTriggerValue = blockTrigger;
+ return triggerValue && !blockTriggerValue;
+ });
+ bool changeHandlerCalled = false;
+ auto handler = condition.onValueChanged([&]() {
+ changeHandlerCalled = true;
+ });
+
+ QVERIFY(!condition);
+ QVERIFY(!changeHandlerCalled);
+
+ trigger = true;
+
+ QVERIFY(condition);
+ QVERIFY(changeHandlerCalled);
+ changeHandlerCalled = false;
+
+ trigger = false;
+
+ QVERIFY(!condition);
+ QVERIFY(changeHandlerCalled);
+ changeHandlerCalled = false;
+
+ blockTrigger = true;
+
+ QVERIFY(!condition);
+ QVERIFY(!changeHandlerCalled);
+}
+
+void tst_QProperty::dontTriggerDependenciesIfUnchangedValue()
+{
+ QProperty<int> property(42);
+
+ bool triggered = false;
+ QProperty<int> observer = Qt::makePropertyBinding([&]() { triggered = true; return property.value(); });
+
+ QCOMPARE(observer.value(), 42);
+ QVERIFY(triggered);
+ triggered = false;
+ property = 42;
+ QCOMPARE(observer.value(), 42);
+ QVERIFY(!triggered);
+}
+
+void tst_QProperty::bindingSourceLocation()
+{
+#if defined(QT_PROPERTY_COLLECT_BINDING_LOCATION)
+ auto bindingLine = std::experimental::source_location::current().line() + 1;
+ auto binding = Qt::makePropertyBinding([]() { return 42; });
+ QCOMPARE(QPropertyBindingPrivate::get(binding)->location.line, bindingLine);
+#else
+ QSKIP("Skipping this in the light of missing binding source location support");
+#endif
+}
+
+void tst_QProperty::bindingError()
+{
+ QProperty<int> prop = Qt::makePropertyBinding([]() -> std::variant<int, QPropertyBindingError> {
+ QPropertyBindingError error(QPropertyBindingError::UnknownError);
+ error.setDescription(QLatin1String("my error"));
+ return error;
+ });
+ QCOMPARE(prop.value(), 0);
+ QCOMPARE(prop.binding().error().description(), QString("my error"));
+}
+
+void tst_QProperty::bindingLoop()
+{
+ QScopedPointer<QProperty<int>> firstProp;
+
+ QProperty<int> secondProp = Qt::makePropertyBinding([&]() -> int {
+ return firstProp ? firstProp->value() : 0;
+ });
+
+ QProperty<int> thirdProp = Qt::makePropertyBinding([&]() -> int {
+ return secondProp.value();
+ });
+
+ firstProp.reset(new QProperty<int>());
+ *firstProp = Qt::makePropertyBinding([&]() -> int {
+ return secondProp.value();
+ });
+
+ QCOMPARE(thirdProp.value(), 0);
+ QCOMPARE(secondProp.binding().error().type(), QPropertyBindingError::BindingLoop);
+}
+
+void tst_QProperty::changePropertyFromWithinChangeHandler()
+{
+ QProperty<int> property(100);
+ bool resetPropertyOnChange = false;
+ int changeHandlerCallCount = 0;
+
+ auto handler = property.onValueChanged([&]() {
+ ++changeHandlerCallCount;
+ if (resetPropertyOnChange)
+ property = 100;
+ });
+
+ QCOMPARE(property.value(), 100);
+
+ resetPropertyOnChange = true;
+ property = 42;
+ QCOMPARE(property.value(), 100);
+ // changing the property value inside the change handler won't result in the change
+ // handler being called again.
+ QCOMPARE(changeHandlerCallCount, 1);
+ changeHandlerCallCount = 0;
+}
+
+void tst_QProperty::changePropertyFromWithinChangeHandlerThroughDependency()
+{
+ QProperty<int> sourceProperty(100);
+ QProperty<int> property = Qt::makePropertyBinding(sourceProperty);
+ bool resetPropertyOnChange = false;
+ int changeHandlerCallCount = 0;
+
+ auto handler = property.onValueChanged([&]() {
+ ++changeHandlerCallCount;
+ if (resetPropertyOnChange)
+ sourceProperty = 100;
+ });
+
+ QCOMPARE(property.value(), 100);
+
+ resetPropertyOnChange = true;
+ sourceProperty = 42;
+ QCOMPARE(property.value(), 100);
+ // changing the property value inside the change handler won't result in the change
+ // handler being called again.
+ QCOMPARE(changeHandlerCallCount, 1);
+ changeHandlerCallCount = 0;
+}
+
+void tst_QProperty::changePropertyFromWithinChangeHandler2()
+{
+ QProperty<int> property(100);
+ int changeHandlerCallCount = 0;
+
+ auto handler = property.onValueChanged([&]() {
+ ++changeHandlerCallCount;
+ property = property.value() + 1;
+ });
+
+ QCOMPARE(property.value(), 100);
+
+ property = 42;
+ QCOMPARE(property.value(), 43);
+}
+
+void tst_QProperty::settingPropertyValueDoesRemoveBinding()
+{
+ QProperty<int> source(42);
+
+ QProperty<int> property = Qt::makePropertyBinding(source);
+
+ QCOMPARE(property.value(), 42);
+ QVERIFY(!property.binding().isNull());
+
+ property = 100;
+ QCOMPARE(property.value(), 100);
+ QVERIFY(property.binding().isNull());
+
+ source = 1;
+ QCOMPARE(property.value(), 100);
+ QVERIFY(property.binding().isNull());
+}
+
+QTEST_MAIN(tst_QProperty);
+
+#include "tst_qproperty.moc"