EIC code displayed by LXR master/​include/​QtCore/​qpropertyprivate.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-08-29 09:18:31

 // Copyright (C) 2020 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 // Qt-Security score:significant reason:default
 
 #ifndef QPROPERTYPRIVATE_H
 #define QPROPERTYPRIVATE_H
 
 //
 //  W A R N I N G
 //  -------------
 //
 // This file is not part of the Qt API.  It exists purely as an
 // implementation detail.  This header file may change from version to
 // version without notice, or even be removed.
 //
 // We mean it.
 //
 
 #include <QtCore/qglobal.h>
 #include <QtCore/qtaggedpointer.h>
 #include <QtCore/qmetatype.h>
 #include <QtCore/qcontainerfwd.h>
 #include <QtCore/qttypetraits.h>
 
 #include <functional>
 
 QT_BEGIN_NAMESPACE
 
 class QBindingStorage;
 
 template<typename Class, typename T, auto Offset, auto Setter, auto Signal, auto Getter>
 class QObjectCompatProperty;
 
 class QPropertyBindingPrivatePtr;
 using PendingBindingObserverList = QVarLengthArray<QPropertyBindingPrivatePtr>;
 
 namespace QtPrivate {
 // QPropertyBindingPrivatePtr operates on a RefCountingMixin solely so that we can inline
 // the constructor and copy constructor
 struct RefCounted {
 
     int refCount() const { return ref; }
     void addRef() { ++ref; }
     bool deref() { return --ref != 0; }
 
 private:
     int ref = 0;
 };
 }
 
 class QQmlPropertyBinding;
 class QPropertyBindingPrivate;
 class QPropertyBindingPrivatePtr
 {
 public:
     using T = QtPrivate::RefCounted;
     T &operator*() const { return *d; }
     T *operator->() noexcept { return d; }
     T *operator->() const noexcept { return d; }
     explicit operator T *() { return d; }
     explicit operator const T *() const noexcept { return d; }
     T *data() const noexcept { return d; }
     T *get() const noexcept { return d; }
     const T *constData() const noexcept { return d; }
     T *take() noexcept { T *x = d; d = nullptr; return x; }
 
     QPropertyBindingPrivatePtr() noexcept : d(nullptr) { }
     ~QPropertyBindingPrivatePtr()
     {
         if (d && !d->deref())
             destroyAndFreeMemory();
     }
     Q_CORE_EXPORT void destroyAndFreeMemory();
 
     explicit QPropertyBindingPrivatePtr(T *data) noexcept : d(data) { if (d) d->addRef(); }
     QPropertyBindingPrivatePtr(const QPropertyBindingPrivatePtr &o) noexcept
         : d(o.d) { if (d) d->addRef(); }
 
     void reset(T *ptr = nullptr) noexcept;
 
     QPropertyBindingPrivatePtr &operator=(const QPropertyBindingPrivatePtr &o) noexcept
     {
         reset(o.d);
         return *this;
     }
     QPropertyBindingPrivatePtr &operator=(T *o) noexcept
     {
         reset(o);
         return *this;
     }
     QPropertyBindingPrivatePtr(QPropertyBindingPrivatePtr &&o) noexcept : d(std::exchange(o.d, nullptr)) {}
     QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_MOVE_AND_SWAP(QPropertyBindingPrivatePtr)
 
     operator bool () const noexcept { return d != nullptr; }
     bool operator!() const noexcept { return d == nullptr; }
 
     void swap(QPropertyBindingPrivatePtr &other) noexcept
     { qt_ptr_swap(d, other.d); }
 
 private:
     friend bool comparesEqual(const QPropertyBindingPrivatePtr &lhs,
                               const QPropertyBindingPrivatePtr &rhs) noexcept
     { return lhs.d == rhs.d; }
     Q_DECLARE_EQUALITY_COMPARABLE(QPropertyBindingPrivatePtr)
     friend bool comparesEqual(const QPropertyBindingPrivatePtr &lhs,
                               const T *rhs) noexcept
     { return lhs.d == rhs; }
     Q_DECLARE_EQUALITY_COMPARABLE(QPropertyBindingPrivatePtr, T*)
     friend bool comparesEqual(const QPropertyBindingPrivatePtr &lhs,
                               std::nullptr_t) noexcept
     { return !lhs; }
     Q_DECLARE_EQUALITY_COMPARABLE(QPropertyBindingPrivatePtr, std::nullptr_t)
 
     QtPrivate::RefCounted *d;
 };
 
 class QUntypedPropertyBinding;
 class QPropertyBindingPrivate;
 struct QPropertyBindingDataPointer;
 class QPropertyObserver;
 struct QPropertyObserverPointer;
 
 class QUntypedPropertyData
 {
 };
 
 namespace QtPrivate {
 template <typename T>
 using IsUntypedPropertyData = std::enable_if_t<std::is_base_of_v<QUntypedPropertyData, T>, bool>;
 }
 
 template <typename T>
 class QPropertyData;
 
 // Used for grouped property evaluations
 namespace QtPrivate {
 class QPropertyBindingData;
 }
 struct QPropertyDelayedNotifications;
 struct QPropertyProxyBindingData
 {
     // acts as QPropertyBindingData::d_ptr
     quintptr d_ptr;
     /*
         The two members below store the original binding data and property
         data pointer of the property which gets proxied.
         They are set in QPropertyDelayedNotifications::addProperty
     */
     const QtPrivate::QPropertyBindingData *originalBindingData;
     QUntypedPropertyData *propertyData;
 };
 
 namespace QtPrivate {
 struct BindingEvaluationState;
 
 /*  used in BindingFunctionVTable::createFor; on all other compilers, void would work, but on
     MSVC this causes C2182 when compiling in C++20 mode. As we only need to provide some default
     value which gets ignored, we introduce this dummy type.
 */
 struct MSVCWorkAround {};
 
 struct BindingFunctionVTable
 {
     using CallFn = bool(*)(QMetaType, QUntypedPropertyData *, void *);
     using DtorFn = void(*)(void *);
     using MoveCtrFn = void(*)(void *, void *);
     const CallFn call;
     const DtorFn destroy;
     const MoveCtrFn moveConstruct;
     const qsizetype size;
 
     template<typename Callable, typename PropertyType=MSVCWorkAround>
     static constexpr BindingFunctionVTable createFor()
     {
         static_assert (alignof(Callable) <= alignof(std::max_align_t), "Bindings do not support overaligned functors!");
         return {
             /*call=*/[](QMetaType metaType, QUntypedPropertyData *dataPtr, void *f){
                 if constexpr (!std::is_invocable_v<Callable>) {
                     // we got an untyped callable
                     static_assert (std::is_invocable_r_v<bool, Callable, QMetaType, QUntypedPropertyData *> );
                     auto untypedEvaluationFunction = static_cast<Callable *>(f);
                     return std::invoke(*untypedEvaluationFunction, metaType, dataPtr);
                 } else if constexpr (!std::is_same_v<PropertyType, MSVCWorkAround>) {
                     Q_UNUSED(metaType);
                     QPropertyData<PropertyType> *propertyPtr = static_cast<QPropertyData<PropertyType> *>(dataPtr);
                     // That is allowed by POSIX even if Callable is a function pointer
                     auto evaluationFunction = static_cast<Callable *>(f);
                     PropertyType newValue = std::invoke(*evaluationFunction);
                     if constexpr (QTypeTraits::has_operator_equal_v<PropertyType>) {
                         if (newValue == propertyPtr->valueBypassingBindings())
                             return false;
                     }
                     propertyPtr->setValueBypassingBindings(std::move(newValue));
                     return true;
                 } else {
                     // Our code will never instantiate this
                     Q_UNREACHABLE_RETURN(false);
                 }
             },
             /*destroy*/[](void *f){ static_cast<Callable *>(f)->~Callable(); },
             /*moveConstruct*/[](void *addr, void *other){
                 new (addr) Callable(std::move(*static_cast<Callable *>(other)));
             },
             /*size*/sizeof(Callable)
         };
     }
 };
 
 template<typename Callable, typename PropertyType=MSVCWorkAround>
 inline constexpr BindingFunctionVTable bindingFunctionVTable = BindingFunctionVTable::createFor<Callable, PropertyType>();
 
 
 // writes binding result into dataPtr
 struct QPropertyBindingFunction {
     const QtPrivate::BindingFunctionVTable *vtable;
     void *functor;
 };
 
 using QPropertyObserverCallback = void (*)(QUntypedPropertyData *);
 using QPropertyBindingWrapper = bool(*)(QMetaType, QUntypedPropertyData *dataPtr, QPropertyBindingFunction);
 
 /*!
     \internal
     A property normally consists of the actual property value and metadata for the binding system.
     QPropertyBindingData is the latter part. It stores a pointer to either
     - a (potentially empty) linked list of notifiers, in case there is no binding set,
     - an actual QUntypedPropertyBinding when the property has a binding,
     - or a pointer to QPropertyProxyBindingData when notifications occur inside a grouped update.
 
     \sa QPropertyDelayedNotifications, beginPropertyUpdateGroup
  */
 class Q_CORE_EXPORT QPropertyBindingData
 {
     // 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(QPropertyBindingDataPointer);
     friend class QT_PREPEND_NAMESPACE(QQmlPropertyBinding);
     friend struct QT_PREPEND_NAMESPACE(QPropertyDelayedNotifications);
 
     template<typename Class, typename T, auto Offset, auto Setter, auto Signal, auto Getter>
     friend class QT_PREPEND_NAMESPACE(QObjectCompatProperty);
 
     Q_DISABLE_COPY(QPropertyBindingData)
 public:
     QPropertyBindingData() = default;
     QPropertyBindingData(QPropertyBindingData &&other);
     QPropertyBindingData &operator=(QPropertyBindingData &&other) = delete;
     ~QPropertyBindingData();
 
     // Is d_ptr pointing to a binding (1) or list of notifiers (0)?
     static inline constexpr quintptr BindingBit = 0x1;
     // Is d_ptr pointing to QPropertyProxyBindingData (1) or to an actual binding/list of notifiers?
     static inline constexpr quintptr DelayedNotificationBit = 0x2;
 
     bool hasBinding() const { return d_ptr & BindingBit; }
     bool isNotificationDelayed() const { return d_ptr & DelayedNotificationBit; }
 
     QUntypedPropertyBinding setBinding(const QUntypedPropertyBinding &newBinding,
                                        QUntypedPropertyData *propertyDataPtr,
                                        QPropertyObserverCallback staticObserverCallback = nullptr,
                                        QPropertyBindingWrapper bindingWrapper = nullptr);
 
     QPropertyBindingPrivate *binding() const
     {
         quintptr dd = d();
         if (dd & BindingBit)
             return reinterpret_cast<QPropertyBindingPrivate*>(dd - BindingBit);
         return nullptr;
 
     }
 
     void evaluateIfDirty(const QUntypedPropertyData *) const; // ### Kept for BC reasons, unused
 
     void removeBinding()
     {
         if (hasBinding())
             removeBinding_helper();
     }
 
     void registerWithCurrentlyEvaluatingBinding(QtPrivate::BindingEvaluationState *currentBinding) const
     {
         if (!currentBinding)
             return;
         registerWithCurrentlyEvaluatingBinding_helper(currentBinding);
     }
     void registerWithCurrentlyEvaluatingBinding() const;
     void notifyObservers(QUntypedPropertyData *propertyDataPtr) const;
     void notifyObservers(QUntypedPropertyData *propertyDataPtr, QBindingStorage *storage) const;
 private:
     /*!
         \internal
         Returns a reference to d_ptr, except when d_ptr points to a proxy.
         In that case, a reference to proxy->d_ptr is returned instead.
 
         To properly support proxying, direct access to d_ptr only occurs when
         - a function actually deals with proxying (e.g.
           QPropertyDelayedNotifications::addProperty),
         - only the tag value is accessed (e.g. hasBinding) or
         - inside a constructor.
      */
     quintptr &d_ref() const
     {
         quintptr &d = d_ptr;
         if (isNotificationDelayed())
             return proxyData()->d_ptr;
         return d;
     }
     quintptr d() const { return d_ref(); }
     QPropertyProxyBindingData *proxyData() const
     {
         Q_ASSERT(isNotificationDelayed());
         return reinterpret_cast<QPropertyProxyBindingData *>(d_ptr & ~(BindingBit|DelayedNotificationBit));
     }
     void registerWithCurrentlyEvaluatingBinding_helper(BindingEvaluationState *currentBinding) const;
     void removeBinding_helper();
 
     enum NotificationResult { Delayed, Evaluated };
     NotificationResult notifyObserver_helper(
             QUntypedPropertyData *propertyDataPtr, QBindingStorage *storage,
             QPropertyObserverPointer observer,
             PendingBindingObserverList &bindingObservers) const;
 };
 
 template <typename T, typename Tag>
 class QTagPreservingPointerToPointer
 {
 public:
     constexpr QTagPreservingPointerToPointer() = default;
 
     QTagPreservingPointerToPointer(T **ptr)
         : d(reinterpret_cast<quintptr*>(ptr))
     {}
 
     QTagPreservingPointerToPointer<T, Tag> &operator=(T **ptr)
     {
         d = reinterpret_cast<quintptr *>(ptr);
         return *this;
     }
 
     QTagPreservingPointerToPointer<T, Tag> &operator=(QTaggedPointer<T, Tag> *ptr)
     {
         d = reinterpret_cast<quintptr *>(ptr);
         return *this;
     }
 
     void clear()
     {
         d = nullptr;
     }
 
     void setPointer(T *ptr)
     {
         *d = reinterpret_cast<quintptr>(ptr) | (*d & QTaggedPointer<T, Tag>::tagMask());
     }
 
     T *get() const
     {
         return reinterpret_cast<T*>(*d & QTaggedPointer<T, Tag>::pointerMask());
     }
 
     explicit operator bool() const
     {
         return d != nullptr;
     }
 
 private:
     quintptr *d = nullptr;
 };
 
 namespace detail {
     template <typename F>
     struct ExtractClassFromFunctionPointer;
 
     template<typename T, typename C>
     struct ExtractClassFromFunctionPointer<T C::*> { using Class = C; };
 
     constexpr size_t getOffset(size_t o)
     {
         return o;
     }
     constexpr size_t getOffset(size_t (*offsetFn)())
     {
         return offsetFn();
     }
 }
 
 } // namespace QtPrivate
 
 QT_END_NAMESPACE
 
 #endif // QPROPERTYPRIVATE_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team