Revision control
++ // Copyright (C) 2022 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 QPERMISSIONS_H
++ #define QPERMISSIONS_H
++
++ #if 0
++ #pragma qt_class(QPermissions)
++ #endif
++
++ #include <QtCore/qglobal.h>
++ #include <QtCore/qtmetamacros.h>
++ #include <QtCore/qvariant.h>
++
++ #include <QtCore/qshareddata_impl.h>
++ #include <QtCore/qtypeinfo.h>
++ #include <QtCore/qmetatype.h>
++
++ #include <optional>
++
++ #if !defined(Q_QDOC)
++ QT_REQUIRE_CONFIG(permissions);
++ #endif
++
++ QT_BEGIN_NAMESPACE
++
++ #ifndef QT_NO_DEBUG_STREAM
++ class QDebug;
++ #endif
++
++ struct QMetaObject;
++ class QCoreApplication;
++
++ class QPermission
++ {
++ template <typename T, typename Enable = void>
++ static constexpr inline bool is_permission_v = false;
++
++ template <typename T>
++ using if_permission = std::enable_if_t<is_permission_v<T>, bool>;
++ public:
++ explicit QPermission() = default;
++
++ template <typename T, if_permission<T> = true>
++ QPermission(const T &t) : m_data(QVariant::fromValue(t)) {}
++
++ Qt::PermissionStatus status() const { return m_status; }
++
++ QMetaType type() const { return m_data.metaType(); }
++
++ template <typename T, if_permission<T> = true>
++ std::optional<T> value() const
++ {
++ if (auto p = data(QMetaType::fromType<T>()))
++ return *static_cast<const T *>(p);
++ return std::nullopt;
++ }
++
++ #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) \
++ 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: \
++ 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: \
++ /*end*/
++
++ class QLocationPermissionPrivate;
++ class QLocationPermission
++ {
++ Q_GADGET_EXPORT(Q_CORE_EXPORT)
++ public:
++ enum Accuracy : quint8 {
++ Approximate,
++ Precise,
++ };
++ Q_ENUM(Accuracy)
++
++ Q_CORE_EXPORT void setAccuracy(Accuracy accuracy);
++ Q_CORE_EXPORT Accuracy accuracy() const;
++
++ enum Availability : quint8 {
++ WhenInUse,
++ Always,
++ };
++ Q_ENUM(Availability)
++
++ 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)
++
++ class QCalendarPermissionPrivate;
++ class QCalendarPermission
++ {
++ Q_GADGET_EXPORT(Q_CORE_EXPORT)
++ public:
++ enum AccessMode : quint8 {
++ ReadOnly,
++ ReadWrite,
++ WriteOnly,
++ };
++ 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)
++
++ class QContactsPermissionPrivate;
++ 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:
++ 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_OPERATORS_FOR_FLAGS(QBluetoothPermission::CommunicationModes)
++ Q_DECLARE_SHARED(QBluetoothPermission)
++
++ #define Q_DECLARE_MINIMAL_PERMISSION(ClassName) \
++ class ClassName##Private; \
++ class ClassName \
++ { \
++ struct ShortData { char reserved[sizeof(void*)]; }; \
++ QT_PERMISSION(ClassName) \
++ }; \
++ Q_DECLARE_SHARED(ClassName)
++
++ Q_DECLARE_MINIMAL_PERMISSION(QCameraPermission)
++ Q_DECLARE_MINIMAL_PERMISSION(QMicrophonePermission)
++
++ #undef QT_PERMISSION
++ #undef Q_DECLARE_MINIMAL_PERMISSION
++
++ QT_END_NAMESPACE
++
++ #endif // QPERMISSIONS_H