1 files changed, 123 insertions, 60 deletions

diff --git a/src/corelib/kernel/qpermissions.h b/src/corelib/kernel/qpermissions.h
index 94ca5fff5b..9573e377e5 100644
--- a/src/corelib/kernel/qpermissions.h
+++ b/src/corelib/kernel/qpermissions.h
@@ -16,6 +16,8 @@
 #include <QtCore/qtypeinfo.h>
 #include <QtCore/qmetatype.h>
 
+#include <optional>
+
 #if !defined(Q_QDOC)
 QT_REQUIRE_CONFIG(permissions);
 #endif
@@ -29,124 +31,185 @@ class QDebug;
 struct QMetaObject;
 class QCoreApplication;
 
-class Q_CORE_EXPORT QPermission
+class QPermission
 {
-    Q_GADGET
-
     template <typename T, typename Enable = void>
-    struct is_permission : public std::false_type {};
+    static constexpr inline bool is_permission_v = false;
 
     template <typename T>
-    struct is_permission<T, typename T::QtPermissionHelper> : public std::true_type {};
-
+    using if_permission = std::enable_if_t<is_permission_v<T>, bool>;
 public:
     explicit QPermission() = default;
 
-#ifdef Q_QDOC
-    template <typename Type>
-    QPermission(const Type &type);
-#else
-    template <typename T, std::enable_if_t<is_permission<T>::value, bool> = true>
+    template <typename T, if_permission<T> = true>
     QPermission(const T &t) : m_data(QVariant::fromValue(t)) {}
-#endif
 
-    Qt::PermissionStatus status() const;
+    Qt::PermissionStatus status() const { return m_status; }
 
-    QMetaType type() const;
+    QMetaType type() const { return m_data.metaType(); }
 
-#ifdef Q_QDOC
-    template <typename Type>
-    Type data() const;
-#else
-    template <typename T, std::enable_if_t<is_permission<T>::value, bool> = true>
-    T data() const
+    template <typename T, if_permission<T> = true>
+    std::optional<T> value() const
     {
-        auto requestedType = QMetaType::fromType<T>();
-        if (type() != requestedType) {
-            qWarning() << "Can not convert from" << type().name()
-                       << "to" << requestedType.name();
-            return T{};
-        }
-        return m_data.value<T>();
+        if (auto p = data(QMetaType::fromType<T>()))
+            return *static_cast<const T *>(p);
+        return std::nullopt;
     }
-#endif
 
 #ifndef QT_NO_DEBUG_STREAM
     friend Q_CORE_EXPORT QDebug operator<<(QDebug debug, const QPermission &);
 #endif
 
 private:
+    Q_CORE_EXPORT const void *data(QMetaType id) const;
+
     Qt::PermissionStatus m_status = Qt::PermissionStatus::Undetermined;
     QVariant m_data;
 
     friend class QCoreApplication;
 };
 
+template <typename T>
+constexpr bool QPermission::is_permission_v<T, typename T::QtPermissionHelper> = true;
+
 #define QT_PERMISSION(ClassName) \
-    Q_GADGET \
     using QtPermissionHelper = void; \
     friend class QPermission; \
+    union U { \
+        U() : d(nullptr) {} \
+        U(ShortData _data) : data(_data) {} \
+        U(ClassName##Private *_d) : d(_d) {} \
+        ShortData data; \
+        ClassName##Private *d; \
+    } u; \
 public: \
-    ClassName(); \
-    ClassName(const ClassName &other) noexcept; \
-    ClassName(ClassName &&other) noexcept; \
-    ~ClassName() noexcept; \
-    ClassName &operator=(const ClassName &other) noexcept; \
-    QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(ClassName) \
-    void swap(ClassName &other) noexcept { d.swap(other.d); } \
+    Q_CORE_EXPORT ClassName(); \
+    Q_CORE_EXPORT ClassName(const ClassName &other) noexcept; \
+    ClassName(ClassName &&other) noexcept \
+        : u{other.u} { other.u.d = nullptr; } \
+    Q_CORE_EXPORT ~ClassName(); \
+    Q_CORE_EXPORT ClassName &operator=(const ClassName &other) noexcept; \
+    QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_MOVE_AND_SWAP(ClassName) \
+    void swap(ClassName &other) noexcept { std::swap(u, other.u); } \
 private: \
-    QtPrivate::QExplicitlySharedDataPointerV2<ClassName##Private> d;
+    /*end*/
 
 class QLocationPermissionPrivate;
-class Q_CORE_EXPORT QLocationPermission
+class QLocationPermission
 {
-    QT_PERMISSION(QLocationPermission)
+    Q_GADGET_EXPORT(Q_CORE_EXPORT)
 public:
-    enum Accuracy { Approximate, Precise };
+    enum Accuracy : quint8 {
+        Approximate,
+        Precise,
+    };
     Q_ENUM(Accuracy)
 
-    void setAccuracy(Accuracy accuracy);
-    Accuracy accuracy() const;
+    Q_CORE_EXPORT void setAccuracy(Accuracy accuracy);
+    Q_CORE_EXPORT Accuracy accuracy() const;
 
-    enum Availability { WhenInUse, Always };
+    enum Availability : quint8 {
+        WhenInUse,
+        Always,
+    };
     Q_ENUM(Availability)
 
-    void setAvailability(Availability availability);
-    Availability availability() const;
+    Q_CORE_EXPORT void setAvailability(Availability availability);
+    Q_CORE_EXPORT Availability availability() const;
+
+private:
+    struct ShortData {
+        Accuracy accuracy;
+        Availability availability;
+        char reserved[sizeof(void*) - sizeof(accuracy) - sizeof(availability)];
+    };
+    QT_PERMISSION(QLocationPermission)
 };
-Q_DECLARE_SHARED(QLocationPermission);
+Q_DECLARE_SHARED(QLocationPermission)
 
 class QCalendarPermissionPrivate;
-class Q_CORE_EXPORT QCalendarPermission
+class QCalendarPermission
 {
-    QT_PERMISSION(QCalendarPermission)
+    Q_GADGET_EXPORT(Q_CORE_EXPORT)
 public:
-    void setReadOnly(bool enable);
-    bool isReadOnly() const;
+    enum AccessMode : quint8 {
+        ReadOnly,
+        ReadWrite,
+    };
+    Q_ENUM(AccessMode)
+
+    Q_CORE_EXPORT void setAccessMode(AccessMode mode);
+    Q_CORE_EXPORT AccessMode accessMode() const;
+
+private:
+    struct ShortData {
+        AccessMode mode;
+        char reserved[sizeof(void*) - sizeof(mode)];
+    };
+    QT_PERMISSION(QCalendarPermission)
 };
-Q_DECLARE_SHARED(QCalendarPermission);
+Q_DECLARE_SHARED(QCalendarPermission)
 
 class QContactsPermissionPrivate;
-class Q_CORE_EXPORT QContactsPermission
+class QContactsPermission
 {
+    Q_GADGET_EXPORT(Q_CORE_EXPORT)
+public:
+    enum AccessMode : quint8 {
+        ReadOnly,
+        ReadWrite,
+    };
+    Q_ENUM(AccessMode)
+
+    Q_CORE_EXPORT void setAccessMode(AccessMode mode);
+    Q_CORE_EXPORT AccessMode accessMode() const;
+
+private:
+    struct ShortData {
+        AccessMode mode;
+        char reserved[sizeof(void*) - sizeof(mode)];
+    };
     QT_PERMISSION(QContactsPermission)
+};
+Q_DECLARE_SHARED(QContactsPermission)
+
+class QBluetoothPermissionPrivate;
+class QBluetoothPermission
+{
+    Q_GADGET_EXPORT(Q_CORE_EXPORT)
 public:
-    void setReadOnly(bool enable);
-    bool isReadOnly() const;
+    enum CommunicationMode : quint8 {
+        Access = 0x01,
+        Advertise = 0x02,
+        Default = Access | Advertise,
+    };
+    Q_DECLARE_FLAGS(CommunicationModes, CommunicationMode)
+    Q_FLAG(CommunicationModes)
+
+    Q_CORE_EXPORT void setCommunicationModes(CommunicationModes modes);
+    Q_CORE_EXPORT CommunicationModes communicationModes() const;
+
+private:
+    struct ShortData {
+        CommunicationMode mode;
+        char reserved[sizeof(void*) - sizeof(mode)];
+    };
+    QT_PERMISSION(QBluetoothPermission)
 };
-Q_DECLARE_SHARED(QContactsPermission);
+Q_DECLARE_OPERATORS_FOR_FLAGS(QBluetoothPermission::CommunicationModes)
+Q_DECLARE_SHARED(QBluetoothPermission)
 
 #define Q_DECLARE_MINIMAL_PERMISSION(ClassName) \
     class ClassName##Private; \
-    class Q_CORE_EXPORT ClassName \
+    class ClassName \
     { \
+        struct ShortData { char reserved[sizeof(void*)]; }; \
         QT_PERMISSION(ClassName) \
     }; \
-    Q_DECLARE_SHARED(ClassName);
+    Q_DECLARE_SHARED(ClassName)
 
-Q_DECLARE_MINIMAL_PERMISSION(QCameraPermission);
-Q_DECLARE_MINIMAL_PERMISSION(QMicrophonePermission);
-Q_DECLARE_MINIMAL_PERMISSION(QBluetoothPermission);
+Q_DECLARE_MINIMAL_PERMISSION(QCameraPermission)
+Q_DECLARE_MINIMAL_PERMISSION(QMicrophonePermission)
 
 #undef QT_PERMISSION
 #undef Q_DECLARE_MINIMAL_PERMISSION