diff options
83 files changed, 2342 insertions, 528 deletions
diff --git a/cmake/QtBuildRepoHelpers.cmake b/cmake/QtBuildRepoHelpers.cmake index 05876c1ad6d..ba8e2e57660 100644 --- a/cmake/QtBuildRepoHelpers.cmake +++ b/cmake/QtBuildRepoHelpers.cmake @@ -523,6 +523,7 @@ function(qt_internal_show_extra_ide_sources) add_custom_target(${target_name}) set(recursive_glob_patterns + REUSE.toml ${QT_BUILD_EXTRA_IDE_FILE_RECURSIVE_PATTERNS} ) set(simple_glob_patterns diff --git a/cmake/QtHeadersClean.cmake b/cmake/QtHeadersClean.cmake index 3e59d68629c..9d8c86cf70d 100644 --- a/cmake/QtHeadersClean.cmake +++ b/cmake/QtHeadersClean.cmake @@ -137,6 +137,10 @@ function(qt_internal_add_headersclean_target module_target module_headers) if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") list(APPEND hcleanFLAGS -Wzero-as-null-pointer-constant -Wdouble-promotion -Wfloat-conversion) + if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0.0") + list(APPEND hcleanFLAGS + -Wnrvo) + endif() endif() if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang|IntelLLVM") diff --git a/cmake/QtInternalTargets.cmake b/cmake/QtInternalTargets.cmake index 0815dbe8e42..45e75d4836f 100644 --- a/cmake/QtInternalTargets.cmake +++ b/cmake/QtInternalTargets.cmake @@ -23,6 +23,9 @@ function(qt_internal_set_warnings_are_errors_flags target target_scope) COMPILERS CLANG AppleClang OPTIONS -Werror -Wno-error=\#warnings -Wno-error=deprecated-declarations + CONDITIONS VERSION_GREATER_EQUAL 14 + OPTIONS + -Wno-error=deprecated-pragma COMMON_CONDITIONS ${common_conditions} ${clang_msvc_frontend_args} diff --git a/src/3rdparty/libpng/ANNOUNCE b/src/3rdparty/libpng/ANNOUNCE index 10dee70d834..e9a94e05de3 100644 --- a/src/3rdparty/libpng/ANNOUNCE +++ b/src/3rdparty/libpng/ANNOUNCE @@ -1,4 +1,4 @@ -libpng 1.6.52 - December 3, 2025 +libpng 1.6.53 - December 5, 2025 ================================ This is a public release of libpng, intended for use in production code. @@ -9,10 +9,10 @@ Files available for download Source files: - * libpng-1.6.52.tar.xz (LZMA-compressed, recommended) - * libpng-1.6.52.tar.gz (deflate-compressed) - * lpng1652.7z (LZMA-compressed) - * lpng1652.zip (deflate-compressed) + * libpng-1.6.53.tar.xz (LZMA-compressed, recommended) + * libpng-1.6.53.tar.gz (deflate-compressed) + * lpng1653.7z (LZMA-compressed) + * lpng1653.zip (deflate-compressed) Other information: @@ -22,18 +22,14 @@ Other information: * TRADEMARK.md -Changes from version 1.6.51 to version 1.6.52 +Changes from version 1.6.52 to version 1.6.53 --------------------------------------------- - * Fixed CVE-2025-66293 (high severity): - Out-of-bounds read in `png_image_read_composite`. - (Reported by flyfish101 <[email protected]>.) - * Fixed the Paeth filter handling in the RISC-V RVV implementation. - (Reported by Filip Wasil; fixed by Liang Junzhao.) - * Improved the performance of the RISC-V RVV implementation. - (Contributed by Liang Junzhao.) - * Added allocation failure fuzzing to oss-fuzz. - (Contributed by Philippe Antoine.) + * Fixed a build failure on RISC-V RVV caused by a misspelled intrinsic. + (Contributed by Alexander Smorkalov.) + * Fixed a build failure with CMake 4.1 or newer, on Windows, when using + Visual C++ without MASM installed. + (Reported by Andrew Tribick; fixed by Luis Caro Campos.) Send comments/corrections/commendations to png-mng-implement at lists.sf.net. diff --git a/src/3rdparty/libpng/CHANGES b/src/3rdparty/libpng/CHANGES index f8ad74bbdf3..ea43101538a 100644 --- a/src/3rdparty/libpng/CHANGES +++ b/src/3rdparty/libpng/CHANGES @@ -6315,6 +6315,12 @@ Version 1.6.52 [December 3, 2025] Added allocation failure fuzzing to oss-fuzz. (Contributed by Philippe Antoine.) +Version 1.6.53 [December 5, 2025] + Fixed a build failure on RISC-V RVV caused by a misspelled intrinsic. + (Contributed by Alexander Smorkalov.) + Fixed a build failure with CMake 4.1 or newer, on Windows, when using + Visual C++ without MASM installed. + Send comments/corrections/commendations to png-mng-implement at lists.sf.net. Subscription is required; visit https://lists.sourceforge.net/lists/listinfo/png-mng-implement diff --git a/src/3rdparty/libpng/README b/src/3rdparty/libpng/README index 87e5f8b177e..4041ad86eb3 100644 --- a/src/3rdparty/libpng/README +++ b/src/3rdparty/libpng/README @@ -1,4 +1,4 @@ -README for libpng version 1.6.52 +README for libpng version 1.6.53 ================================ See the note about version numbers near the top of `png.h`. diff --git a/src/3rdparty/libpng/libpng-manual.txt b/src/3rdparty/libpng/libpng-manual.txt index f284d987ba6..750025cfdad 100644 --- a/src/3rdparty/libpng/libpng-manual.txt +++ b/src/3rdparty/libpng/libpng-manual.txt @@ -9,7 +9,7 @@ libpng-manual.txt - A description on how to use and modify libpng Based on: - libpng version 1.6.36, December 2018, through 1.6.52 - December 2025 + libpng version 1.6.36, December 2018, through 1.6.53 - December 2025 Updated and distributed by Cosmin Truta Copyright (c) 2018-2025 Cosmin Truta diff --git a/src/3rdparty/libpng/png.c b/src/3rdparty/libpng/png.c index 11b65d1f13e..85b49496520 100644 --- a/src/3rdparty/libpng/png.c +++ b/src/3rdparty/libpng/png.c @@ -13,7 +13,7 @@ #include "pngpriv.h" /* Generate a compiler error if there is an old png.h in the search path. */ -typedef png_libpng_version_1_6_52 Your_png_h_is_not_version_1_6_52; +typedef png_libpng_version_1_6_53 Your_png_h_is_not_version_1_6_53; /* Sanity check the chunks definitions - PNG_KNOWN_CHUNKS from pngpriv.h and the * corresponding macro definitions. This causes a compile time failure if @@ -817,7 +817,7 @@ png_get_copyright(png_const_structrp png_ptr) return PNG_STRING_COPYRIGHT #else return PNG_STRING_NEWLINE \ - "libpng version 1.6.52" PNG_STRING_NEWLINE \ + "libpng version 1.6.53" PNG_STRING_NEWLINE \ "Copyright (c) 2018-2025 Cosmin Truta" PNG_STRING_NEWLINE \ "Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson" \ PNG_STRING_NEWLINE \ diff --git a/src/3rdparty/libpng/png.h b/src/3rdparty/libpng/png.h index bceb9aa45d7..bdcd243dea2 100644 --- a/src/3rdparty/libpng/png.h +++ b/src/3rdparty/libpng/png.h @@ -1,6 +1,6 @@ /* png.h - header file for PNG reference library * - * libpng version 1.6.52 + * libpng version 1.6.53 * * Copyright (c) 2018-2025 Cosmin Truta * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson @@ -14,7 +14,7 @@ * libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger * libpng versions 0.97, January 1998, through 1.6.35, July 2018: * Glenn Randers-Pehrson - * libpng versions 1.6.36, December 2018, through 1.6.52, December 2025: + * libpng versions 1.6.36, December 2018, through 1.6.53, December 2025: * Cosmin Truta * See also "Contributing Authors", below. */ @@ -238,7 +238,7 @@ * ... * 1.5.30 15 10530 15.so.15.30[.0] * ... - * 1.6.52 16 10651 16.so.16.52[.0] + * 1.6.53 16 10651 16.so.16.53[.0] * * Henceforth the source version will match the shared-library major and * minor numbers; the shared-library major version number will be used for @@ -274,7 +274,7 @@ */ /* Version information for png.h - this should match the version in png.c */ -#define PNG_LIBPNG_VER_STRING "1.6.52" +#define PNG_LIBPNG_VER_STRING "1.6.53" #define PNG_HEADER_VERSION_STRING " libpng version " PNG_LIBPNG_VER_STRING "\n" /* The versions of shared library builds should stay in sync, going forward */ @@ -285,7 +285,7 @@ /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ #define PNG_LIBPNG_VER_MAJOR 1 #define PNG_LIBPNG_VER_MINOR 6 -#define PNG_LIBPNG_VER_RELEASE 52 +#define PNG_LIBPNG_VER_RELEASE 53 /* This should be zero for a public release, or non-zero for a * development version. @@ -316,7 +316,7 @@ * From version 1.0.1 it is: * XXYYZZ, where XX=major, YY=minor, ZZ=release */ -#define PNG_LIBPNG_VER 10652 /* 1.6.52 */ +#define PNG_LIBPNG_VER 10653 /* 1.6.53 */ /* Library configuration: these options cannot be changed after * the library has been built. @@ -426,7 +426,7 @@ extern "C" { /* This triggers a compiler error in png.c, if png.c and png.h * do not agree upon the version number. */ -typedef char* png_libpng_version_1_6_52; +typedef char* png_libpng_version_1_6_53; /* Basic control structions. Read libpng-manual.txt or libpng.3 for more info. * diff --git a/src/3rdparty/libpng/pngconf.h b/src/3rdparty/libpng/pngconf.h index 76b5c20bdff..f4ff19209c6 100644 --- a/src/3rdparty/libpng/pngconf.h +++ b/src/3rdparty/libpng/pngconf.h @@ -1,6 +1,6 @@ /* pngconf.h - machine-configurable file for libpng * - * libpng version 1.6.52 + * libpng version 1.6.53 * * Copyright (c) 2018-2025 Cosmin Truta * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson diff --git a/src/3rdparty/libpng/pnglibconf.h b/src/3rdparty/libpng/pnglibconf.h index f4a993441f7..27fa87045b3 100644 --- a/src/3rdparty/libpng/pnglibconf.h +++ b/src/3rdparty/libpng/pnglibconf.h @@ -1,6 +1,6 @@ /* pnglibconf.h - library build configuration */ -/* libpng version 1.6.52 */ +/* libpng version 1.6.53 */ /* Copyright (c) 2018-2025 Cosmin Truta */ /* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson */ diff --git a/src/3rdparty/libpng/pngread.c b/src/3rdparty/libpng/pngread.c index f8ca2b7e31d..13a93deedcb 100644 --- a/src/3rdparty/libpng/pngread.c +++ b/src/3rdparty/libpng/pngread.c @@ -3278,7 +3278,7 @@ png_image_read_composite(png_voidp argument) /* Clamp to the valid range to defend against * unforeseen cases where the data might be sRGB * instead of linear premultiplied. - * (Belt-and-suspenders for GitHub Issue #764.) + * (Belt-and-suspenders for CVE-2025-66293.) */ if (component > 255*65535) component = 255*65535; diff --git a/src/3rdparty/libpng/qt_attribution.json b/src/3rdparty/libpng/qt_attribution.json index 1f942f8f564..132e5e8d4cd 100644 --- a/src/3rdparty/libpng/qt_attribution.json +++ b/src/3rdparty/libpng/qt_attribution.json @@ -7,8 +7,8 @@ "Description": "libpng is the official PNG reference library.", "Homepage": "http://www.libpng.org/pub/png/libpng.html", - "Version": "1.6.52", - "DownloadLocation": "https://download.sourceforge.net/libpng/libpng-1.6.52.tar.xz", + "Version": "1.6.53", + "DownloadLocation": "https://download.sourceforge.net/libpng/libpng-1.6.53.tar.xz", "PURL": "pkg:github/pnggroup/libpng@v$<VERSION>", "CPE": "cpe:2.3:a:libpng:libpng:$<VERSION>:*:*:*:*:*:*:*", diff --git a/src/corelib/configure.cmake b/src/corelib/configure.cmake index 7216f2920fe..4386b907c13 100644 --- a/src/corelib/configure.cmake +++ b/src/corelib/configure.cmake @@ -1285,7 +1285,7 @@ qt_feature("openssl-hash" PRIVATE qt_feature("async-io" PRIVATE LABEL "Async File I/O" PURPOSE "Provides support for asynchronous file I/O." - CONDITION (QT_FEATURE_thread AND QT_FEATURE_future) OR APPLE + CONDITION (QT_FEATURE_thread AND QT_FEATURE_future) OR APPLE OR (LINUX AND QT_FEATURE_liburing) OR (WIN32 AND QT_FEATURE_windows_ioring) ) qt_configure_add_summary_section(NAME "Qt Core") diff --git a/src/corelib/doc/src/cmake/cmake-configure-variables.qdoc b/src/corelib/doc/src/cmake/cmake-configure-variables.qdoc index 0a0dc0b3c50..42cb3ecb42b 100644 --- a/src/corelib/doc/src/cmake/cmake-configure-variables.qdoc +++ b/src/corelib/doc/src/cmake/cmake-configure-variables.qdoc @@ -133,7 +133,6 @@ use, for example, library files referenced from a Qt installation. \summary {Forces or disables release package signing regardless of the build type.} \cmakevariablesince 6.7 -\preliminarycmakevariable \cmakevariableandroidonly When set to \c Release, the \c --release flag is passed to the \c diff --git a/src/corelib/global/patches/tlexpected/0006-Namespace-TL_-macros-with-Q23_.patch b/src/corelib/global/patches/tlexpected/0006-Namespace-TL_-macros-with-Q23_.patch new file mode 100644 index 00000000000..f3c45f07594 --- /dev/null +++ b/src/corelib/global/patches/tlexpected/0006-Namespace-TL_-macros-with-Q23_.patch @@ -0,0 +1,914 @@ +From 5676e5f83597dc1fb32b551c863633eff102e879 Mon Sep 17 00:00:00 2001 +From: Marc Mutz <[email protected]> +Date: Thu, 27 Nov 2025 07:51:19 +0100 +Subject: [PATCH] Namespace TL_ macros with Q23_ + +Change-Id: Ib5762ec8ebe81e0c750da84be29531b7179c5025 +--- + src/corelib/global/qexpected_p.h | 312 +++++++++++++++---------------- + 1 file changed, 156 insertions(+), 156 deletions(-) + +diff --git a/src/corelib/global/qexpected_p.h b/src/corelib/global/qexpected_p.h +index 24ea5be1e5e..54bcae51102 100644 +--- a/src/corelib/global/qexpected_p.h ++++ b/src/corelib/global/qexpected_p.h +@@ -16,8 +16,8 @@ + // <http://creativecommons.org/publicdomain/zero/1.0/>. + /// + +-#ifndef TL_EXPECTED_HPP +-#define TL_EXPECTED_HPP ++#ifndef Q23_TL_EXPECTED_HPP ++#define Q23_TL_EXPECTED_HPP + + // + // W A R N I N G +@@ -30,9 +30,9 @@ + // We mean it. + // + +-#define TL_EXPECTED_VERSION_MAJOR 1 +-#define TL_EXPECTED_VERSION_MINOR 1 +-#define TL_EXPECTED_VERSION_PATCH 0 ++#define Q23_TL_EXPECTED_VERSION_MAJOR 1 ++#define Q23_TL_EXPECTED_VERSION_MINOR 1 ++#define Q23_TL_EXPECTED_VERSION_PATCH 0 + + #include <QtCore/private/qglobal_p.h> + #include <QtCore/qassert.h> +@@ -44,45 +44,45 @@ + #include <type_traits> + #include <utility> + +-#define TL_ASSERT Q_ASSERT ++#define Q23_TL_ASSERT Q_ASSERT + + #if defined(__EXCEPTIONS) || defined(_CPPUNWIND) +-#define TL_EXPECTED_EXCEPTIONS_ENABLED ++#define Q23_TL_EXPECTED_EXCEPTIONS_ENABLED + #endif + +-#if defined(TL_EXPECTED_EXCEPTIONS_ENABLED) && defined(QT_NO_EXCEPTIONS) +-# undef TL_EXPECTED_EXCEPTIONS_ENABLED ++#if defined(Q23_TL_EXPECTED_EXCEPTIONS_ENABLED) && defined(QT_NO_EXCEPTIONS) ++# undef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED + #endif + + #if (defined(_MSC_VER) && _MSC_VER == 1900) +-#define TL_EXPECTED_MSVC2015 +-#define TL_EXPECTED_MSVC2015_CONSTEXPR ++#define Q23_TL_EXPECTED_MSVC2015 ++#define Q23_TL_EXPECTED_MSVC2015_CONSTEXPR + #else +-#define TL_EXPECTED_MSVC2015_CONSTEXPR constexpr ++#define Q23_TL_EXPECTED_MSVC2015_CONSTEXPR constexpr + #endif + + #if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \ + !defined(__clang__)) +-#define TL_EXPECTED_GCC49 ++#define Q23_TL_EXPECTED_GCC49 + #endif + + #if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && \ + !defined(__clang__)) +-#define TL_EXPECTED_GCC54 ++#define Q23_TL_EXPECTED_GCC54 + #endif + + #if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && \ + !defined(__clang__)) +-#define TL_EXPECTED_GCC55 ++#define Q23_TL_EXPECTED_GCC55 + #endif + +-#if !defined(TL_ASSERT) ++#if !defined(Q23_TL_ASSERT) + //can't have assert in constexpr in C++11 and GCC 4.9 has a compiler bug +-#if (TL_CPLUSPLUS > 201103L) && !defined(TL_EXPECTED_GCC49) ++#if (Q23_TL_CPLUSPLUS > 201103L) && !defined(Q23_TL_EXPECTED_GCC49) + #include <cassert> +-#define TL_ASSERT(x) assert(x) ++#define Q23_TL_ASSERT(x) assert(x) + #else +-#define TL_ASSERT(x) ++#define Q23_TL_ASSERT(x) + #endif + #endif + +@@ -90,22 +90,22 @@ + !defined(__clang__)) + // GCC < 5 doesn't support overloading on const&& for member functions + +-#define TL_EXPECTED_NO_CONSTRR ++#define Q23_TL_EXPECTED_NO_CONSTRR + // GCC < 5 doesn't support some standard C++11 type traits +-#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ ++#define Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ + std::has_trivial_copy_constructor<T> +-#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ ++#define Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ + std::has_trivial_copy_assign<T> + + // This one will be different for GCC 5.7 if it's ever supported +-#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \ ++#define Q23_TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \ + std::is_trivially_destructible<T> + + // GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks + // std::vector for non-copyable types + #elif (defined(__GNUC__) && __GNUC__ < 8 && !defined(__clang__)) +-#ifndef TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX +-#define TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX ++#ifndef Q23_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX ++#define Q23_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX + QT_BEGIN_NAMESPACE + namespace q23 { + namespace detail { +@@ -121,50 +121,50 @@ struct is_trivially_copy_constructible<std::vector<T, A>> : std::false_type {}; + QT_END_NAMESPACE + #endif + +-#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ ++#define Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ + q23::detail::is_trivially_copy_constructible<T> +-#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ ++#define Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ + std::is_trivially_copy_assignable<T> +-#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \ ++#define Q23_TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \ + std::is_trivially_destructible<T> + #else +-#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ ++#define Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ + std::is_trivially_copy_constructible<T> +-#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ ++#define Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ + std::is_trivially_copy_assignable<T> +-#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \ ++#define Q23_TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \ + std::is_trivially_destructible<T> + #endif + + #ifdef _MSVC_LANG +-#define TL_CPLUSPLUS _MSVC_LANG ++#define Q23_TL_CPLUSPLUS _MSVC_LANG + #else +-#define TL_CPLUSPLUS __cplusplus ++#define Q23_TL_CPLUSPLUS __cplusplus + #endif + +-#if TL_CPLUSPLUS > 201103L +-#define TL_EXPECTED_CXX14 ++#if Q23_TL_CPLUSPLUS > 201103L ++#define Q23_TL_EXPECTED_CXX14 + #endif + +-#ifdef TL_EXPECTED_GCC49 +-#define TL_EXPECTED_GCC49_CONSTEXPR ++#ifdef Q23_TL_EXPECTED_GCC49 ++#define Q23_TL_EXPECTED_GCC49_CONSTEXPR + #else +-#define TL_EXPECTED_GCC49_CONSTEXPR constexpr ++#define Q23_TL_EXPECTED_GCC49_CONSTEXPR constexpr + #endif + +-#if (TL_CPLUSPLUS == 201103L || defined(TL_EXPECTED_MSVC2015) || \ +- defined(TL_EXPECTED_GCC49)) +-#define TL_EXPECTED_11_CONSTEXPR ++#if (Q23_TL_CPLUSPLUS == 201103L || defined(Q23_TL_EXPECTED_MSVC2015) || \ ++ defined(Q23_TL_EXPECTED_GCC49)) ++#define Q23_TL_EXPECTED_11_CONSTEXPR + #else +-#define TL_EXPECTED_11_CONSTEXPR constexpr ++#define Q23_TL_EXPECTED_11_CONSTEXPR constexpr + #endif + + QT_BEGIN_NAMESPACE + namespace q23 { + template <class T, class E> class expected; + +-#ifndef TL_MONOSTATE_INPLACE_MUTEX +-#define TL_MONOSTATE_INPLACE_MUTEX ++#ifndef Q23_TL_MONOSTATE_INPLACE_MUTEX ++#define Q23_TL_MONOSTATE_INPLACE_MUTEX + class monostate {}; + + struct in_place_t { +@@ -196,8 +196,8 @@ public: + : m_val(l, std::forward<Args>(args)...) {} + + constexpr const E &error() const & { return m_val; } +- TL_EXPECTED_11_CONSTEXPR E &error() & { return m_val; } +- TL_EXPECTED_11_CONSTEXPR E &&error() && { return std::move(m_val); } ++ Q23_TL_EXPECTED_11_CONSTEXPR E &error() & { return m_val; } ++ Q23_TL_EXPECTED_11_CONSTEXPR E &&error() && { return std::move(m_val); } + constexpr const E &&error() const && { return std::move(m_val); } + + private: +@@ -245,8 +245,8 @@ static constexpr unexpect_t unexpect{}; + + namespace detail { + template <typename E> +-[[noreturn]] TL_EXPECTED_11_CONSTEXPR void throw_exception(E &&e) { +-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED ++[[noreturn]] Q23_TL_EXPECTED_11_CONSTEXPR void throw_exception(E &&e) { ++#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED + throw std::forward<E>(e); + #else + (void)e; +@@ -258,8 +258,8 @@ template <typename E> + #endif + } + +-#ifndef TL_TRAITS_MUTEX +-#define TL_TRAITS_MUTEX ++#ifndef Q23_TL_TRAITS_MUTEX ++#define Q23_TL_TRAITS_MUTEX + // C++14-style aliases for brevity + template <class T> using remove_const_t = typename std::remove_const<T>::type; + template <class T> +@@ -278,13 +278,13 @@ struct conjunction<B, Bs...> + : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {}; + + #if defined(_LIBCPP_VERSION) && __cplusplus == 201103L +-#define TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND ++#define Q23_TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND + #endif + + // In C++11 mode, there's an issue in libc++'s std::mem_fn + // which results in a hard-error when using it in a noexcept expression + // in some cases. This is a check to workaround the common failing case. +-#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND ++#ifdef Q23_TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND + template <class T> + struct is_pointer_to_non_const_member_func : std::false_type {}; + template <class T, class Ret, class... Args> +@@ -315,7 +315,7 @@ template <class T> struct is_const_or_const_ref<T const> : std::true_type {}; + // https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround + template < + typename Fn, typename... Args, +-#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND ++#ifdef Q23_TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND + typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value && + is_const_or_const_ref<Args...>::value)>, + #endif +@@ -574,7 +574,7 @@ template <class T, class E> struct expected_storage_base<T, E, true, true> { + // T is trivial, E is not. + template <class T, class E> struct expected_storage_base<T, E, true, false> { + constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {} +- TL_EXPECTED_MSVC2015_CONSTEXPR expected_storage_base(no_init_t) ++ Q23_TL_EXPECTED_MSVC2015_CONSTEXPR expected_storage_base(no_init_t) + : m_no_init(), m_has_val(false) {} + + template <class... Args, +@@ -675,7 +675,7 @@ template <class E> struct expected_storage_base<void, E, false, true> { + #if __GNUC__ <= 5 + //no constexpr for GCC 4/5 bug + #else +- TL_EXPECTED_MSVC2015_CONSTEXPR ++ Q23_TL_EXPECTED_MSVC2015_CONSTEXPR + #endif + expected_storage_base() : m_has_val(true) {} + +@@ -770,7 +770,7 @@ struct expected_operations_base : expected_storage_base<T, E> { + this->m_has_val = false; + } + +-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED ++#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED + + // These assign overloads ensure that the most efficient assignment + // implementation is used while maintaining the strong exception guarantee. +@@ -820,7 +820,7 @@ struct expected_operations_base : expected_storage_base<T, E> { + auto tmp = std::move(geterr()); + geterr().~unexpected<E>(); + +-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED ++#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED + try { + construct(rhs.get()); + } catch (...) { +@@ -855,7 +855,7 @@ struct expected_operations_base : expected_storage_base<T, E> { + if (!this->m_has_val && rhs.m_has_val) { + auto tmp = std::move(geterr()); + geterr().~unexpected<E>(); +-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED ++#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED + try { + construct(std::move(rhs).get()); + } catch (...) { +@@ -911,27 +911,27 @@ struct expected_operations_base : expected_storage_base<T, E> { + + bool has_value() const { return this->m_has_val; } + +- TL_EXPECTED_11_CONSTEXPR T &get() & { return this->m_val; } ++ Q23_TL_EXPECTED_11_CONSTEXPR T &get() & { return this->m_val; } + constexpr const T &get() const & { return this->m_val; } +- TL_EXPECTED_11_CONSTEXPR T &&get() && { return std::move(this->m_val); } +-#ifndef TL_EXPECTED_NO_CONSTRR ++ Q23_TL_EXPECTED_11_CONSTEXPR T &&get() && { return std::move(this->m_val); } ++#ifndef Q23_TL_EXPECTED_NO_CONSTRR + constexpr const T &&get() const && { return std::move(this->m_val); } + #endif + +- TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & { ++ Q23_TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & { + return this->m_unexpect; + } + constexpr const unexpected<E> &geterr() const & { return this->m_unexpect; } +- TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && { ++ Q23_TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && { + return std::move(this->m_unexpect); + } +-#ifndef TL_EXPECTED_NO_CONSTRR ++#ifndef Q23_TL_EXPECTED_NO_CONSTRR + constexpr const unexpected<E> &&geterr() const && { + return std::move(this->m_unexpect); + } + #endif + +- TL_EXPECTED_11_CONSTEXPR void destroy_val() { get().~T(); } ++ Q23_TL_EXPECTED_11_CONSTEXPR void destroy_val() { get().~T(); } + }; + + // This base class provides some handy member functions which can be used in +@@ -971,20 +971,20 @@ struct expected_operations_base<void, E> : expected_storage_base<void, E> { + + bool has_value() const { return this->m_has_val; } + +- TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & { ++ Q23_TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & { + return this->m_unexpect; + } + constexpr const unexpected<E> &geterr() const & { return this->m_unexpect; } +- TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && { ++ Q23_TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && { + return std::move(this->m_unexpect); + } +-#ifndef TL_EXPECTED_NO_CONSTRR ++#ifndef Q23_TL_EXPECTED_NO_CONSTRR + constexpr const unexpected<E> &&geterr() const && { + return std::move(this->m_unexpect); + } + #endif + +- TL_EXPECTED_11_CONSTEXPR void destroy_val() { ++ Q23_TL_EXPECTED_11_CONSTEXPR void destroy_val() { + // no-op + } + }; +@@ -992,8 +992,8 @@ struct expected_operations_base<void, E> : expected_storage_base<void, E> { + // This class manages conditionally having a trivial copy constructor + // This specialization is for when T and E are trivially copy constructible + template <class T, class E, +- bool = is_void_or<T, TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>:: +- value &&TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value, ++ bool = is_void_or<T, Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>:: ++ value &&Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value, + bool = (is_copy_constructible_or_void<T>::value && + std::is_copy_constructible<E>::value)> + struct expected_copy_base : expected_operations_base<T, E> { +@@ -1025,7 +1025,7 @@ struct expected_copy_base<T, E, false, true> : expected_operations_base<T, E> { + // doesn't implement an analogue to std::is_trivially_move_constructible. We + // have to make do with a non-trivial move constructor even if T is trivially + // move constructible +-#ifndef TL_EXPECTED_GCC49 ++#ifndef Q23_TL_EXPECTED_GCC49 + template <class T, class E, + bool = is_void_or<T, std::is_trivially_move_constructible<T>>::value + &&std::is_trivially_move_constructible<E>::value> +@@ -1058,12 +1058,12 @@ struct expected_move_base<T, E, false> : expected_copy_base<T, E> { + // This class manages conditionally having a trivial copy assignment operator + template <class T, class E, + bool = is_void_or< +- T, conjunction<TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T), +- TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T), +- TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)>>::value +- &&TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(E)::value +- &&TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value +- &&TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(E)::value, ++ T, conjunction<Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T), ++ Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T), ++ Q23_TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)>>::value ++ &&Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(E)::value ++ &&Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value ++ &&Q23_TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(E)::value, + bool = (is_copy_constructible_or_void<T>::value && + std::is_copy_constructible<E>::value && + is_copy_assignable_or_void<T>::value && +@@ -1093,7 +1093,7 @@ struct expected_copy_assign_base<T, E, false, true> : expected_move_base<T, E> { + // doesn't implement an analogue to std::is_trivially_move_assignable. We have + // to make do with a non-trivial move assignment operator even if T is trivially + // move assignable +-#ifndef TL_EXPECTED_GCC49 ++#ifndef Q23_TL_EXPECTED_GCC49 + template <class T, class E, + bool = + is_void_or<T, conjunction<std::is_trivially_destructible<T>, +@@ -1330,10 +1330,10 @@ class expected : private detail::expected_move_assign_base<T, E>, + + template <class U = T, + detail::enable_if_t<!std::is_void<U>::value> * = nullptr> +- TL_EXPECTED_11_CONSTEXPR U &val() { ++ Q23_TL_EXPECTED_11_CONSTEXPR U &val() { + return this->m_val; + } +- TL_EXPECTED_11_CONSTEXPR unexpected<E> &err() { return this->m_unexpect; } ++ Q23_TL_EXPECTED_11_CONSTEXPR unexpected<E> &err() { return this->m_unexpect; } + + template <class U = T, + detail::enable_if_t<!std::is_void<U>::value> * = nullptr> +@@ -1350,19 +1350,19 @@ public: + typedef E error_type; + typedef unexpected<E> unexpected_type; + +-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \ +- !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55) +- template <class F> TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) & { ++#if defined(Q23_TL_EXPECTED_CXX14) && !defined(Q23_TL_EXPECTED_GCC49) && \ ++ !defined(Q23_TL_EXPECTED_GCC54) && !defined(Q23_TL_EXPECTED_GCC55) ++ template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) & { + return and_then_impl(*this, std::forward<F>(f)); + } +- template <class F> TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) && { ++ template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) && { + return and_then_impl(std::move(*this), std::forward<F>(f)); + } + template <class F> constexpr auto and_then(F &&f) const & { + return and_then_impl(*this, std::forward<F>(f)); + } + +-#ifndef TL_EXPECTED_NO_CONSTRR ++#ifndef Q23_TL_EXPECTED_NO_CONSTRR + template <class F> constexpr auto and_then(F &&f) const && { + return and_then_impl(std::move(*this), std::forward<F>(f)); + } +@@ -1370,13 +1370,13 @@ public: + + #else + template <class F> +- TL_EXPECTED_11_CONSTEXPR auto ++ Q23_TL_EXPECTED_11_CONSTEXPR auto + and_then(F &&f) & -> decltype(and_then_impl(std::declval<expected &>(), + std::forward<F>(f))) { + return and_then_impl(*this, std::forward<F>(f)); + } + template <class F> +- TL_EXPECTED_11_CONSTEXPR auto ++ Q23_TL_EXPECTED_11_CONSTEXPR auto + and_then(F &&f) && -> decltype(and_then_impl(std::declval<expected &&>(), + std::forward<F>(f))) { + return and_then_impl(std::move(*this), std::forward<F>(f)); +@@ -1387,7 +1387,7 @@ public: + return and_then_impl(*this, std::forward<F>(f)); + } + +-#ifndef TL_EXPECTED_NO_CONSTRR ++#ifndef Q23_TL_EXPECTED_NO_CONSTRR + template <class F> + constexpr auto and_then(F &&f) const && -> decltype(and_then_impl( + std::declval<expected const &&>(), std::forward<F>(f))) { +@@ -1396,12 +1396,12 @@ public: + #endif + #endif + +-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \ +- !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55) +- template <class F> TL_EXPECTED_11_CONSTEXPR auto map(F &&f) & { ++#if defined(Q23_TL_EXPECTED_CXX14) && !defined(Q23_TL_EXPECTED_GCC49) && \ ++ !defined(Q23_TL_EXPECTED_GCC54) && !defined(Q23_TL_EXPECTED_GCC55) ++ template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto map(F &&f) & { + return expected_map_impl(*this, std::forward<F>(f)); + } +- template <class F> TL_EXPECTED_11_CONSTEXPR auto map(F &&f) && { ++ template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto map(F &&f) && { + return expected_map_impl(std::move(*this), std::forward<F>(f)); + } + template <class F> constexpr auto map(F &&f) const & { +@@ -1412,13 +1412,13 @@ public: + } + #else + template <class F> +- TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl( ++ Q23_TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl( + std::declval<expected &>(), std::declval<F &&>())) + map(F &&f) & { + return expected_map_impl(*this, std::forward<F>(f)); + } + template <class F> +- TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(), ++ Q23_TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(), + std::declval<F &&>())) + map(F &&f) && { + return expected_map_impl(std::move(*this), std::forward<F>(f)); +@@ -1430,7 +1430,7 @@ public: + return expected_map_impl(*this, std::forward<F>(f)); + } + +-#ifndef TL_EXPECTED_NO_CONSTRR ++#ifndef Q23_TL_EXPECTED_NO_CONSTRR + template <class F> + constexpr decltype(expected_map_impl(std::declval<const expected &&>(), + std::declval<F &&>())) +@@ -1440,12 +1440,12 @@ public: + #endif + #endif + +-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \ +- !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55) +- template <class F> TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) & { ++#if defined(Q23_TL_EXPECTED_CXX14) && !defined(Q23_TL_EXPECTED_GCC49) && \ ++ !defined(Q23_TL_EXPECTED_GCC54) && !defined(Q23_TL_EXPECTED_GCC55) ++ template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) & { + return expected_map_impl(*this, std::forward<F>(f)); + } +- template <class F> TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) && { ++ template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) && { + return expected_map_impl(std::move(*this), std::forward<F>(f)); + } + template <class F> constexpr auto transform(F &&f) const & { +@@ -1456,13 +1456,13 @@ public: + } + #else + template <class F> +- TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl( ++ Q23_TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl( + std::declval<expected &>(), std::declval<F &&>())) + transform(F &&f) & { + return expected_map_impl(*this, std::forward<F>(f)); + } + template <class F> +- TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(), ++ Q23_TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(), + std::declval<F &&>())) + transform(F &&f) && { + return expected_map_impl(std::move(*this), std::forward<F>(f)); +@@ -1474,7 +1474,7 @@ public: + return expected_map_impl(*this, std::forward<F>(f)); + } + +-#ifndef TL_EXPECTED_NO_CONSTRR ++#ifndef Q23_TL_EXPECTED_NO_CONSTRR + template <class F> + constexpr decltype(expected_map_impl(std::declval<const expected &&>(), + std::declval<F &&>())) +@@ -1484,12 +1484,12 @@ public: + #endif + #endif + +-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \ +- !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55) +- template <class F> TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) & { ++#if defined(Q23_TL_EXPECTED_CXX14) && !defined(Q23_TL_EXPECTED_GCC49) && \ ++ !defined(Q23_TL_EXPECTED_GCC54) && !defined(Q23_TL_EXPECTED_GCC55) ++ template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) & { + return map_error_impl(*this, std::forward<F>(f)); + } +- template <class F> TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) && { ++ template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) && { + return map_error_impl(std::move(*this), std::forward<F>(f)); + } + template <class F> constexpr auto map_error(F &&f) const & { +@@ -1500,13 +1500,13 @@ public: + } + #else + template <class F> +- TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(), ++ Q23_TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(), + std::declval<F &&>())) + map_error(F &&f) & { + return map_error_impl(*this, std::forward<F>(f)); + } + template <class F> +- TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(), ++ Q23_TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(), + std::declval<F &&>())) + map_error(F &&f) && { + return map_error_impl(std::move(*this), std::forward<F>(f)); +@@ -1518,7 +1518,7 @@ public: + return map_error_impl(*this, std::forward<F>(f)); + } + +-#ifndef TL_EXPECTED_NO_CONSTRR ++#ifndef Q23_TL_EXPECTED_NO_CONSTRR + template <class F> + constexpr decltype(map_error_impl(std::declval<const expected &&>(), + std::declval<F &&>())) +@@ -1527,12 +1527,12 @@ public: + } + #endif + #endif +-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \ +- !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55) +- template <class F> TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) & { ++#if defined(Q23_TL_EXPECTED_CXX14) && !defined(Q23_TL_EXPECTED_GCC49) && \ ++ !defined(Q23_TL_EXPECTED_GCC54) && !defined(Q23_TL_EXPECTED_GCC55) ++ template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) & { + return map_error_impl(*this, std::forward<F>(f)); + } +- template <class F> TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) && { ++ template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) && { + return map_error_impl(std::move(*this), std::forward<F>(f)); + } + template <class F> constexpr auto transform_error(F &&f) const & { +@@ -1543,13 +1543,13 @@ public: + } + #else + template <class F> +- TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(), ++ Q23_TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(), + std::declval<F &&>())) + transform_error(F &&f) & { + return map_error_impl(*this, std::forward<F>(f)); + } + template <class F> +- TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(), ++ Q23_TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(), + std::declval<F &&>())) + transform_error(F &&f) && { + return map_error_impl(std::move(*this), std::forward<F>(f)); +@@ -1561,7 +1561,7 @@ public: + return map_error_impl(*this, std::forward<F>(f)); + } + +-#ifndef TL_EXPECTED_NO_CONSTRR ++#ifndef Q23_TL_EXPECTED_NO_CONSTRR + template <class F> + constexpr decltype(map_error_impl(std::declval<const expected &&>(), + std::declval<F &&>())) +@@ -1570,11 +1570,11 @@ public: + } + #endif + #endif +- template <class F> expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) & { ++ template <class F> expected Q23_TL_EXPECTED_11_CONSTEXPR or_else(F &&f) & { + return or_else_impl(*this, std::forward<F>(f)); + } + +- template <class F> expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) && { ++ template <class F> expected Q23_TL_EXPECTED_11_CONSTEXPR or_else(F &&f) && { + return or_else_impl(std::move(*this), std::forward<F>(f)); + } + +@@ -1582,7 +1582,7 @@ public: + return or_else_impl(*this, std::forward<F>(f)); + } + +-#ifndef TL_EXPECTED_NO_CONSTRR ++#ifndef Q23_TL_EXPECTED_NO_CONSTRR + template <class F> expected constexpr or_else(F &&f) const && { + return or_else_impl(std::move(*this), std::forward<F>(f)); + } +@@ -1664,7 +1664,7 @@ public: + nullptr, + detail::expected_enable_from_other<T, E, U, G, const U &, const G &> + * = nullptr> +- explicit TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs) ++ explicit Q23_TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs) + : ctor_base(detail::default_constructor_tag{}) { + if (rhs.has_value()) { + this->construct(*rhs); +@@ -1679,7 +1679,7 @@ public: + nullptr, + detail::expected_enable_from_other<T, E, U, G, const U &, const G &> + * = nullptr> +- TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs) ++ Q23_TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs) + : ctor_base(detail::default_constructor_tag{}) { + if (rhs.has_value()) { + this->construct(*rhs); +@@ -1693,7 +1693,7 @@ public: + detail::enable_if_t<!(std::is_convertible<U &&, T>::value && + std::is_convertible<G &&, E>::value)> * = nullptr, + detail::expected_enable_from_other<T, E, U, G, U &&, G &&> * = nullptr> +- explicit TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs) ++ explicit Q23_TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs) + : ctor_base(detail::default_constructor_tag{}) { + if (rhs.has_value()) { + this->construct(std::move(*rhs)); +@@ -1707,7 +1707,7 @@ public: + detail::enable_if_t<(std::is_convertible<U &&, T>::value && + std::is_convertible<G &&, E>::value)> * = nullptr, + detail::expected_enable_from_other<T, E, U, G, U &&, G &&> * = nullptr> +- TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs) ++ Q23_TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs) + : ctor_base(detail::default_constructor_tag{}) { + if (rhs.has_value()) { + this->construct(std::move(*rhs)); +@@ -1720,14 +1720,14 @@ public: + class U = T, + detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr, + detail::expected_enable_forward_value<T, E, U> * = nullptr> +- explicit TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v) ++ explicit Q23_TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v) + : expected(in_place, std::forward<U>(v)) {} + + template < + class U = T, + detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr, + detail::expected_enable_forward_value<T, E, U> * = nullptr> +- TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v) ++ Q23_TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v) + : expected(in_place, std::forward<U>(v)) {} + + template < +@@ -1773,7 +1773,7 @@ public: + auto tmp = std::move(err()); + err().~unexpected<E>(); + +-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED ++#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED + try { + ::new (valptr()) T(std::forward<U>(v)); + this->m_has_val = true; +@@ -1842,7 +1842,7 @@ public: + auto tmp = std::move(err()); + err().~unexpected<E>(); + +-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED ++#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED + try { + ::new (valptr()) T(std::forward<Args>(args)...); + this->m_has_val = true; +@@ -1882,7 +1882,7 @@ public: + auto tmp = std::move(err()); + err().~unexpected<E>(); + +-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED ++#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED + try { + ::new (valptr()) T(il, std::forward<Args>(args)...); + this->m_has_val = true; +@@ -1943,7 +1943,7 @@ private: + move_constructing_e_can_throw) { + auto temp = std::move(val()); + val().~T(); +-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED ++#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED + try { + ::new (errptr()) unexpected_type(std::move(rhs.err())); + rhs.err().~unexpected_type(); +@@ -1966,7 +1966,7 @@ private: + e_is_nothrow_move_constructible) { + auto temp = std::move(rhs.err()); + rhs.err().~unexpected_type(); +-#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED ++#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED + try { + ::new (rhs.valptr()) T(std::move(val())); + val().~T(); +@@ -2008,36 +2008,36 @@ public: + } + + constexpr const T *operator->() const { +- TL_ASSERT(has_value()); ++ Q23_TL_ASSERT(has_value()); + return valptr(); + } +- TL_EXPECTED_11_CONSTEXPR T *operator->() { +- TL_ASSERT(has_value()); ++ Q23_TL_EXPECTED_11_CONSTEXPR T *operator->() { ++ Q23_TL_ASSERT(has_value()); + return valptr(); + } + + template <class U = T, + detail::enable_if_t<!std::is_void<U>::value> * = nullptr> + constexpr const U &operator*() const & { +- TL_ASSERT(has_value()); ++ Q23_TL_ASSERT(has_value()); + return val(); + } + template <class U = T, + detail::enable_if_t<!std::is_void<U>::value> * = nullptr> +- TL_EXPECTED_11_CONSTEXPR U &operator*() & { +- TL_ASSERT(has_value()); ++ Q23_TL_EXPECTED_11_CONSTEXPR U &operator*() & { ++ Q23_TL_ASSERT(has_value()); + return val(); + } + template <class U = T, + detail::enable_if_t<!std::is_void<U>::value> * = nullptr> + constexpr const U &&operator*() const && { +- TL_ASSERT(has_value()); ++ Q23_TL_ASSERT(has_value()); + return std::move(val()); + } + template <class U = T, + detail::enable_if_t<!std::is_void<U>::value> * = nullptr> +- TL_EXPECTED_11_CONSTEXPR U &&operator*() && { +- TL_ASSERT(has_value()); ++ Q23_TL_EXPECTED_11_CONSTEXPR U &&operator*() && { ++ Q23_TL_ASSERT(has_value()); + return std::move(val()); + } + +@@ -2046,47 +2046,47 @@ public: + + template <class U = T, + detail::enable_if_t<!std::is_void<U>::value> * = nullptr> +- TL_EXPECTED_11_CONSTEXPR const U &value() const & { ++ Q23_TL_EXPECTED_11_CONSTEXPR const U &value() const & { + if (!has_value()) + detail::throw_exception(bad_expected_access<E>(err().error())); + return val(); + } + template <class U = T, + detail::enable_if_t<!std::is_void<U>::value> * = nullptr> +- TL_EXPECTED_11_CONSTEXPR U &value() & { ++ Q23_TL_EXPECTED_11_CONSTEXPR U &value() & { + if (!has_value()) + detail::throw_exception(bad_expected_access<E>(err().error())); + return val(); + } + template <class U = T, + detail::enable_if_t<!std::is_void<U>::value> * = nullptr> +- TL_EXPECTED_11_CONSTEXPR const U &&value() const && { ++ Q23_TL_EXPECTED_11_CONSTEXPR const U &&value() const && { + if (!has_value()) + detail::throw_exception(bad_expected_access<E>(std::move(err()).error())); + return std::move(val()); + } + template <class U = T, + detail::enable_if_t<!std::is_void<U>::value> * = nullptr> +- TL_EXPECTED_11_CONSTEXPR U &&value() && { ++ Q23_TL_EXPECTED_11_CONSTEXPR U &&value() && { + if (!has_value()) + detail::throw_exception(bad_expected_access<E>(std::move(err()).error())); + return std::move(val()); + } + + constexpr const E &error() const & { +- TL_ASSERT(!has_value()); ++ Q23_TL_ASSERT(!has_value()); + return err().error(); + } +- TL_EXPECTED_11_CONSTEXPR E &error() & { +- TL_ASSERT(!has_value()); ++ Q23_TL_EXPECTED_11_CONSTEXPR E &error() & { ++ Q23_TL_ASSERT(!has_value()); + return err().error(); + } + constexpr const E &&error() const && { +- TL_ASSERT(!has_value()); ++ Q23_TL_ASSERT(!has_value()); + return std::move(err().error()); + } +- TL_EXPECTED_11_CONSTEXPR E &&error() && { +- TL_ASSERT(!has_value()); ++ Q23_TL_EXPECTED_11_CONSTEXPR E &&error() && { ++ Q23_TL_ASSERT(!has_value()); + return std::move(err().error()); + } + +@@ -2096,7 +2096,7 @@ public: + "T must be copy-constructible and convertible to from U&&"); + return bool(*this) ? **this : static_cast<T>(std::forward<U>(v)); + } +- template <class U> TL_EXPECTED_11_CONSTEXPR T value_or(U &&v) && { ++ template <class U> Q23_TL_EXPECTED_11_CONSTEXPR T value_or(U &&v) && { + static_assert(std::is_move_constructible<T>::value && + std::is_convertible<U &&, T>::value, + "T must be move-constructible and convertible to from U&&"); +@@ -2109,7 +2109,7 @@ template <class Exp> using exp_t = typename detail::decay_t<Exp>::value_type; + template <class Exp> using err_t = typename detail::decay_t<Exp>::error_type; + template <class Exp, class Ret> using ret_t = expected<Ret, err_t<Exp>>; + +-#ifdef TL_EXPECTED_CXX14 ++#ifdef Q23_TL_EXPECTED_CXX14 + template <class Exp, class F, + detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr, + class Ret = decltype(detail::invoke(std::declval<F>(), +@@ -2156,7 +2156,7 @@ constexpr auto and_then_impl(Exp &&exp, F &&f) -> Ret { + } + #endif + +-#ifdef TL_EXPECTED_CXX14 ++#ifdef Q23_TL_EXPECTED_CXX14 + template <class Exp, class F, + detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr, + class Ret = decltype(detail::invoke(std::declval<F>(), +@@ -2266,8 +2266,8 @@ auto expected_map_impl(Exp &&exp, F &&f) -> expected<void, err_t<Exp>> { + } + #endif + +-#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \ +- !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55) ++#if defined(Q23_TL_EXPECTED_CXX14) && !defined(Q23_TL_EXPECTED_GCC49) && \ ++ !defined(Q23_TL_EXPECTED_GCC54) && !defined(Q23_TL_EXPECTED_GCC55) + template <class Exp, class F, + detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr, + class Ret = decltype(detail::invoke(std::declval<F>(), +@@ -2382,7 +2382,7 @@ auto map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate> { + } + #endif + +-#ifdef TL_EXPECTED_CXX14 ++#ifdef Q23_TL_EXPECTED_CXX14 + template <class Exp, class F, + class Ret = decltype(detail::invoke(std::declval<F>(), + std::declval<Exp>().error())), +-- +2.25.1 + diff --git a/src/corelib/global/qexpected_p.h b/src/corelib/global/qexpected_p.h index 24ea5be1e5e..54bcae51102 100644 --- a/src/corelib/global/qexpected_p.h +++ b/src/corelib/global/qexpected_p.h @@ -16,8 +16,8 @@ // <http://creativecommons.org/publicdomain/zero/1.0/>. /// -#ifndef TL_EXPECTED_HPP -#define TL_EXPECTED_HPP +#ifndef Q23_TL_EXPECTED_HPP +#define Q23_TL_EXPECTED_HPP // // W A R N I N G @@ -30,9 +30,9 @@ // We mean it. // -#define TL_EXPECTED_VERSION_MAJOR 1 -#define TL_EXPECTED_VERSION_MINOR 1 -#define TL_EXPECTED_VERSION_PATCH 0 +#define Q23_TL_EXPECTED_VERSION_MAJOR 1 +#define Q23_TL_EXPECTED_VERSION_MINOR 1 +#define Q23_TL_EXPECTED_VERSION_PATCH 0 #include <QtCore/private/qglobal_p.h> #include <QtCore/qassert.h> @@ -44,45 +44,45 @@ #include <type_traits> #include <utility> -#define TL_ASSERT Q_ASSERT +#define Q23_TL_ASSERT Q_ASSERT #if defined(__EXCEPTIONS) || defined(_CPPUNWIND) -#define TL_EXPECTED_EXCEPTIONS_ENABLED +#define Q23_TL_EXPECTED_EXCEPTIONS_ENABLED #endif -#if defined(TL_EXPECTED_EXCEPTIONS_ENABLED) && defined(QT_NO_EXCEPTIONS) -# undef TL_EXPECTED_EXCEPTIONS_ENABLED +#if defined(Q23_TL_EXPECTED_EXCEPTIONS_ENABLED) && defined(QT_NO_EXCEPTIONS) +# undef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED #endif #if (defined(_MSC_VER) && _MSC_VER == 1900) -#define TL_EXPECTED_MSVC2015 -#define TL_EXPECTED_MSVC2015_CONSTEXPR +#define Q23_TL_EXPECTED_MSVC2015 +#define Q23_TL_EXPECTED_MSVC2015_CONSTEXPR #else -#define TL_EXPECTED_MSVC2015_CONSTEXPR constexpr +#define Q23_TL_EXPECTED_MSVC2015_CONSTEXPR constexpr #endif #if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \ !defined(__clang__)) -#define TL_EXPECTED_GCC49 +#define Q23_TL_EXPECTED_GCC49 #endif #if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && \ !defined(__clang__)) -#define TL_EXPECTED_GCC54 +#define Q23_TL_EXPECTED_GCC54 #endif #if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && \ !defined(__clang__)) -#define TL_EXPECTED_GCC55 +#define Q23_TL_EXPECTED_GCC55 #endif -#if !defined(TL_ASSERT) +#if !defined(Q23_TL_ASSERT) //can't have assert in constexpr in C++11 and GCC 4.9 has a compiler bug -#if (TL_CPLUSPLUS > 201103L) && !defined(TL_EXPECTED_GCC49) +#if (Q23_TL_CPLUSPLUS > 201103L) && !defined(Q23_TL_EXPECTED_GCC49) #include <cassert> -#define TL_ASSERT(x) assert(x) +#define Q23_TL_ASSERT(x) assert(x) #else -#define TL_ASSERT(x) +#define Q23_TL_ASSERT(x) #endif #endif @@ -90,22 +90,22 @@ !defined(__clang__)) // GCC < 5 doesn't support overloading on const&& for member functions -#define TL_EXPECTED_NO_CONSTRR +#define Q23_TL_EXPECTED_NO_CONSTRR // GCC < 5 doesn't support some standard C++11 type traits -#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ +#define Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ std::has_trivial_copy_constructor<T> -#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ +#define Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ std::has_trivial_copy_assign<T> // This one will be different for GCC 5.7 if it's ever supported -#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \ +#define Q23_TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \ std::is_trivially_destructible<T> // GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks // std::vector for non-copyable types #elif (defined(__GNUC__) && __GNUC__ < 8 && !defined(__clang__)) -#ifndef TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX -#define TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX +#ifndef Q23_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX +#define Q23_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX QT_BEGIN_NAMESPACE namespace q23 { namespace detail { @@ -121,50 +121,50 @@ struct is_trivially_copy_constructible<std::vector<T, A>> : std::false_type {}; QT_END_NAMESPACE #endif -#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ +#define Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ q23::detail::is_trivially_copy_constructible<T> -#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ +#define Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ std::is_trivially_copy_assignable<T> -#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \ +#define Q23_TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \ std::is_trivially_destructible<T> #else -#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ +#define Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ std::is_trivially_copy_constructible<T> -#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ +#define Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ std::is_trivially_copy_assignable<T> -#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \ +#define Q23_TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \ std::is_trivially_destructible<T> #endif #ifdef _MSVC_LANG -#define TL_CPLUSPLUS _MSVC_LANG +#define Q23_TL_CPLUSPLUS _MSVC_LANG #else -#define TL_CPLUSPLUS __cplusplus +#define Q23_TL_CPLUSPLUS __cplusplus #endif -#if TL_CPLUSPLUS > 201103L -#define TL_EXPECTED_CXX14 +#if Q23_TL_CPLUSPLUS > 201103L +#define Q23_TL_EXPECTED_CXX14 #endif -#ifdef TL_EXPECTED_GCC49 -#define TL_EXPECTED_GCC49_CONSTEXPR +#ifdef Q23_TL_EXPECTED_GCC49 +#define Q23_TL_EXPECTED_GCC49_CONSTEXPR #else -#define TL_EXPECTED_GCC49_CONSTEXPR constexpr +#define Q23_TL_EXPECTED_GCC49_CONSTEXPR constexpr #endif -#if (TL_CPLUSPLUS == 201103L || defined(TL_EXPECTED_MSVC2015) || \ - defined(TL_EXPECTED_GCC49)) -#define TL_EXPECTED_11_CONSTEXPR +#if (Q23_TL_CPLUSPLUS == 201103L || defined(Q23_TL_EXPECTED_MSVC2015) || \ + defined(Q23_TL_EXPECTED_GCC49)) +#define Q23_TL_EXPECTED_11_CONSTEXPR #else -#define TL_EXPECTED_11_CONSTEXPR constexpr +#define Q23_TL_EXPECTED_11_CONSTEXPR constexpr #endif QT_BEGIN_NAMESPACE namespace q23 { template <class T, class E> class expected; -#ifndef TL_MONOSTATE_INPLACE_MUTEX -#define TL_MONOSTATE_INPLACE_MUTEX +#ifndef Q23_TL_MONOSTATE_INPLACE_MUTEX +#define Q23_TL_MONOSTATE_INPLACE_MUTEX class monostate {}; struct in_place_t { @@ -196,8 +196,8 @@ public: : m_val(l, std::forward<Args>(args)...) {} constexpr const E &error() const & { return m_val; } - TL_EXPECTED_11_CONSTEXPR E &error() & { return m_val; } - TL_EXPECTED_11_CONSTEXPR E &&error() && { return std::move(m_val); } + Q23_TL_EXPECTED_11_CONSTEXPR E &error() & { return m_val; } + Q23_TL_EXPECTED_11_CONSTEXPR E &&error() && { return std::move(m_val); } constexpr const E &&error() const && { return std::move(m_val); } private: @@ -245,8 +245,8 @@ static constexpr unexpect_t unexpect{}; namespace detail { template <typename E> -[[noreturn]] TL_EXPECTED_11_CONSTEXPR void throw_exception(E &&e) { -#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED +[[noreturn]] Q23_TL_EXPECTED_11_CONSTEXPR void throw_exception(E &&e) { +#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED throw std::forward<E>(e); #else (void)e; @@ -258,8 +258,8 @@ template <typename E> #endif } -#ifndef TL_TRAITS_MUTEX -#define TL_TRAITS_MUTEX +#ifndef Q23_TL_TRAITS_MUTEX +#define Q23_TL_TRAITS_MUTEX // C++14-style aliases for brevity template <class T> using remove_const_t = typename std::remove_const<T>::type; template <class T> @@ -278,13 +278,13 @@ struct conjunction<B, Bs...> : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {}; #if defined(_LIBCPP_VERSION) && __cplusplus == 201103L -#define TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND +#define Q23_TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND #endif // In C++11 mode, there's an issue in libc++'s std::mem_fn // which results in a hard-error when using it in a noexcept expression // in some cases. This is a check to workaround the common failing case. -#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND +#ifdef Q23_TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND template <class T> struct is_pointer_to_non_const_member_func : std::false_type {}; template <class T, class Ret, class... Args> @@ -315,7 +315,7 @@ template <class T> struct is_const_or_const_ref<T const> : std::true_type {}; // https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround template < typename Fn, typename... Args, -#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND +#ifdef Q23_TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value && is_const_or_const_ref<Args...>::value)>, #endif @@ -574,7 +574,7 @@ template <class T, class E> struct expected_storage_base<T, E, true, true> { // T is trivial, E is not. template <class T, class E> struct expected_storage_base<T, E, true, false> { constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {} - TL_EXPECTED_MSVC2015_CONSTEXPR expected_storage_base(no_init_t) + Q23_TL_EXPECTED_MSVC2015_CONSTEXPR expected_storage_base(no_init_t) : m_no_init(), m_has_val(false) {} template <class... Args, @@ -675,7 +675,7 @@ template <class E> struct expected_storage_base<void, E, false, true> { #if __GNUC__ <= 5 //no constexpr for GCC 4/5 bug #else - TL_EXPECTED_MSVC2015_CONSTEXPR + Q23_TL_EXPECTED_MSVC2015_CONSTEXPR #endif expected_storage_base() : m_has_val(true) {} @@ -770,7 +770,7 @@ struct expected_operations_base : expected_storage_base<T, E> { this->m_has_val = false; } -#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED +#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED // These assign overloads ensure that the most efficient assignment // implementation is used while maintaining the strong exception guarantee. @@ -820,7 +820,7 @@ struct expected_operations_base : expected_storage_base<T, E> { auto tmp = std::move(geterr()); geterr().~unexpected<E>(); -#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED +#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED try { construct(rhs.get()); } catch (...) { @@ -855,7 +855,7 @@ struct expected_operations_base : expected_storage_base<T, E> { if (!this->m_has_val && rhs.m_has_val) { auto tmp = std::move(geterr()); geterr().~unexpected<E>(); -#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED +#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED try { construct(std::move(rhs).get()); } catch (...) { @@ -911,27 +911,27 @@ struct expected_operations_base : expected_storage_base<T, E> { bool has_value() const { return this->m_has_val; } - TL_EXPECTED_11_CONSTEXPR T &get() & { return this->m_val; } + Q23_TL_EXPECTED_11_CONSTEXPR T &get() & { return this->m_val; } constexpr const T &get() const & { return this->m_val; } - TL_EXPECTED_11_CONSTEXPR T &&get() && { return std::move(this->m_val); } -#ifndef TL_EXPECTED_NO_CONSTRR + Q23_TL_EXPECTED_11_CONSTEXPR T &&get() && { return std::move(this->m_val); } +#ifndef Q23_TL_EXPECTED_NO_CONSTRR constexpr const T &&get() const && { return std::move(this->m_val); } #endif - TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & { + Q23_TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & { return this->m_unexpect; } constexpr const unexpected<E> &geterr() const & { return this->m_unexpect; } - TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && { + Q23_TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && { return std::move(this->m_unexpect); } -#ifndef TL_EXPECTED_NO_CONSTRR +#ifndef Q23_TL_EXPECTED_NO_CONSTRR constexpr const unexpected<E> &&geterr() const && { return std::move(this->m_unexpect); } #endif - TL_EXPECTED_11_CONSTEXPR void destroy_val() { get().~T(); } + Q23_TL_EXPECTED_11_CONSTEXPR void destroy_val() { get().~T(); } }; // This base class provides some handy member functions which can be used in @@ -971,20 +971,20 @@ struct expected_operations_base<void, E> : expected_storage_base<void, E> { bool has_value() const { return this->m_has_val; } - TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & { + Q23_TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & { return this->m_unexpect; } constexpr const unexpected<E> &geterr() const & { return this->m_unexpect; } - TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && { + Q23_TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && { return std::move(this->m_unexpect); } -#ifndef TL_EXPECTED_NO_CONSTRR +#ifndef Q23_TL_EXPECTED_NO_CONSTRR constexpr const unexpected<E> &&geterr() const && { return std::move(this->m_unexpect); } #endif - TL_EXPECTED_11_CONSTEXPR void destroy_val() { + Q23_TL_EXPECTED_11_CONSTEXPR void destroy_val() { // no-op } }; @@ -992,8 +992,8 @@ struct expected_operations_base<void, E> : expected_storage_base<void, E> { // This class manages conditionally having a trivial copy constructor // This specialization is for when T and E are trivially copy constructible template <class T, class E, - bool = is_void_or<T, TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>:: - value &&TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value, + bool = is_void_or<T, Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>:: + value &&Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value, bool = (is_copy_constructible_or_void<T>::value && std::is_copy_constructible<E>::value)> struct expected_copy_base : expected_operations_base<T, E> { @@ -1025,7 +1025,7 @@ struct expected_copy_base<T, E, false, true> : expected_operations_base<T, E> { // doesn't implement an analogue to std::is_trivially_move_constructible. We // have to make do with a non-trivial move constructor even if T is trivially // move constructible -#ifndef TL_EXPECTED_GCC49 +#ifndef Q23_TL_EXPECTED_GCC49 template <class T, class E, bool = is_void_or<T, std::is_trivially_move_constructible<T>>::value &&std::is_trivially_move_constructible<E>::value> @@ -1058,12 +1058,12 @@ struct expected_move_base<T, E, false> : expected_copy_base<T, E> { // This class manages conditionally having a trivial copy assignment operator template <class T, class E, bool = is_void_or< - T, conjunction<TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T), - TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T), - TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)>>::value - &&TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(E)::value - &&TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value - &&TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(E)::value, + T, conjunction<Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T), + Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T), + Q23_TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)>>::value + &&Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(E)::value + &&Q23_TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value + &&Q23_TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(E)::value, bool = (is_copy_constructible_or_void<T>::value && std::is_copy_constructible<E>::value && is_copy_assignable_or_void<T>::value && @@ -1093,7 +1093,7 @@ struct expected_copy_assign_base<T, E, false, true> : expected_move_base<T, E> { // doesn't implement an analogue to std::is_trivially_move_assignable. We have // to make do with a non-trivial move assignment operator even if T is trivially // move assignable -#ifndef TL_EXPECTED_GCC49 +#ifndef Q23_TL_EXPECTED_GCC49 template <class T, class E, bool = is_void_or<T, conjunction<std::is_trivially_destructible<T>, @@ -1330,10 +1330,10 @@ class expected : private detail::expected_move_assign_base<T, E>, template <class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr> - TL_EXPECTED_11_CONSTEXPR U &val() { + Q23_TL_EXPECTED_11_CONSTEXPR U &val() { return this->m_val; } - TL_EXPECTED_11_CONSTEXPR unexpected<E> &err() { return this->m_unexpect; } + Q23_TL_EXPECTED_11_CONSTEXPR unexpected<E> &err() { return this->m_unexpect; } template <class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr> @@ -1350,19 +1350,19 @@ public: typedef E error_type; typedef unexpected<E> unexpected_type; -#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \ - !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55) - template <class F> TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) & { +#if defined(Q23_TL_EXPECTED_CXX14) && !defined(Q23_TL_EXPECTED_GCC49) && \ + !defined(Q23_TL_EXPECTED_GCC54) && !defined(Q23_TL_EXPECTED_GCC55) + template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) & { return and_then_impl(*this, std::forward<F>(f)); } - template <class F> TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) && { + template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) && { return and_then_impl(std::move(*this), std::forward<F>(f)); } template <class F> constexpr auto and_then(F &&f) const & { return and_then_impl(*this, std::forward<F>(f)); } -#ifndef TL_EXPECTED_NO_CONSTRR +#ifndef Q23_TL_EXPECTED_NO_CONSTRR template <class F> constexpr auto and_then(F &&f) const && { return and_then_impl(std::move(*this), std::forward<F>(f)); } @@ -1370,13 +1370,13 @@ public: #else template <class F> - TL_EXPECTED_11_CONSTEXPR auto + Q23_TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) & -> decltype(and_then_impl(std::declval<expected &>(), std::forward<F>(f))) { return and_then_impl(*this, std::forward<F>(f)); } template <class F> - TL_EXPECTED_11_CONSTEXPR auto + Q23_TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) && -> decltype(and_then_impl(std::declval<expected &&>(), std::forward<F>(f))) { return and_then_impl(std::move(*this), std::forward<F>(f)); @@ -1387,7 +1387,7 @@ public: return and_then_impl(*this, std::forward<F>(f)); } -#ifndef TL_EXPECTED_NO_CONSTRR +#ifndef Q23_TL_EXPECTED_NO_CONSTRR template <class F> constexpr auto and_then(F &&f) const && -> decltype(and_then_impl( std::declval<expected const &&>(), std::forward<F>(f))) { @@ -1396,12 +1396,12 @@ public: #endif #endif -#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \ - !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55) - template <class F> TL_EXPECTED_11_CONSTEXPR auto map(F &&f) & { +#if defined(Q23_TL_EXPECTED_CXX14) && !defined(Q23_TL_EXPECTED_GCC49) && \ + !defined(Q23_TL_EXPECTED_GCC54) && !defined(Q23_TL_EXPECTED_GCC55) + template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto map(F &&f) & { return expected_map_impl(*this, std::forward<F>(f)); } - template <class F> TL_EXPECTED_11_CONSTEXPR auto map(F &&f) && { + template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto map(F &&f) && { return expected_map_impl(std::move(*this), std::forward<F>(f)); } template <class F> constexpr auto map(F &&f) const & { @@ -1412,13 +1412,13 @@ public: } #else template <class F> - TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl( + Q23_TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl( std::declval<expected &>(), std::declval<F &&>())) map(F &&f) & { return expected_map_impl(*this, std::forward<F>(f)); } template <class F> - TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(), + Q23_TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(), std::declval<F &&>())) map(F &&f) && { return expected_map_impl(std::move(*this), std::forward<F>(f)); @@ -1430,7 +1430,7 @@ public: return expected_map_impl(*this, std::forward<F>(f)); } -#ifndef TL_EXPECTED_NO_CONSTRR +#ifndef Q23_TL_EXPECTED_NO_CONSTRR template <class F> constexpr decltype(expected_map_impl(std::declval<const expected &&>(), std::declval<F &&>())) @@ -1440,12 +1440,12 @@ public: #endif #endif -#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \ - !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55) - template <class F> TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) & { +#if defined(Q23_TL_EXPECTED_CXX14) && !defined(Q23_TL_EXPECTED_GCC49) && \ + !defined(Q23_TL_EXPECTED_GCC54) && !defined(Q23_TL_EXPECTED_GCC55) + template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) & { return expected_map_impl(*this, std::forward<F>(f)); } - template <class F> TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) && { + template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) && { return expected_map_impl(std::move(*this), std::forward<F>(f)); } template <class F> constexpr auto transform(F &&f) const & { @@ -1456,13 +1456,13 @@ public: } #else template <class F> - TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl( + Q23_TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl( std::declval<expected &>(), std::declval<F &&>())) transform(F &&f) & { return expected_map_impl(*this, std::forward<F>(f)); } template <class F> - TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(), + Q23_TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(), std::declval<F &&>())) transform(F &&f) && { return expected_map_impl(std::move(*this), std::forward<F>(f)); @@ -1474,7 +1474,7 @@ public: return expected_map_impl(*this, std::forward<F>(f)); } -#ifndef TL_EXPECTED_NO_CONSTRR +#ifndef Q23_TL_EXPECTED_NO_CONSTRR template <class F> constexpr decltype(expected_map_impl(std::declval<const expected &&>(), std::declval<F &&>())) @@ -1484,12 +1484,12 @@ public: #endif #endif -#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \ - !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55) - template <class F> TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) & { +#if defined(Q23_TL_EXPECTED_CXX14) && !defined(Q23_TL_EXPECTED_GCC49) && \ + !defined(Q23_TL_EXPECTED_GCC54) && !defined(Q23_TL_EXPECTED_GCC55) + template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) & { return map_error_impl(*this, std::forward<F>(f)); } - template <class F> TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) && { + template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) && { return map_error_impl(std::move(*this), std::forward<F>(f)); } template <class F> constexpr auto map_error(F &&f) const & { @@ -1500,13 +1500,13 @@ public: } #else template <class F> - TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(), + Q23_TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(), std::declval<F &&>())) map_error(F &&f) & { return map_error_impl(*this, std::forward<F>(f)); } template <class F> - TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(), + Q23_TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(), std::declval<F &&>())) map_error(F &&f) && { return map_error_impl(std::move(*this), std::forward<F>(f)); @@ -1518,7 +1518,7 @@ public: return map_error_impl(*this, std::forward<F>(f)); } -#ifndef TL_EXPECTED_NO_CONSTRR +#ifndef Q23_TL_EXPECTED_NO_CONSTRR template <class F> constexpr decltype(map_error_impl(std::declval<const expected &&>(), std::declval<F &&>())) @@ -1527,12 +1527,12 @@ public: } #endif #endif -#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \ - !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55) - template <class F> TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) & { +#if defined(Q23_TL_EXPECTED_CXX14) && !defined(Q23_TL_EXPECTED_GCC49) && \ + !defined(Q23_TL_EXPECTED_GCC54) && !defined(Q23_TL_EXPECTED_GCC55) + template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) & { return map_error_impl(*this, std::forward<F>(f)); } - template <class F> TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) && { + template <class F> Q23_TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) && { return map_error_impl(std::move(*this), std::forward<F>(f)); } template <class F> constexpr auto transform_error(F &&f) const & { @@ -1543,13 +1543,13 @@ public: } #else template <class F> - TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(), + Q23_TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(), std::declval<F &&>())) transform_error(F &&f) & { return map_error_impl(*this, std::forward<F>(f)); } template <class F> - TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(), + Q23_TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(), std::declval<F &&>())) transform_error(F &&f) && { return map_error_impl(std::move(*this), std::forward<F>(f)); @@ -1561,7 +1561,7 @@ public: return map_error_impl(*this, std::forward<F>(f)); } -#ifndef TL_EXPECTED_NO_CONSTRR +#ifndef Q23_TL_EXPECTED_NO_CONSTRR template <class F> constexpr decltype(map_error_impl(std::declval<const expected &&>(), std::declval<F &&>())) @@ -1570,11 +1570,11 @@ public: } #endif #endif - template <class F> expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) & { + template <class F> expected Q23_TL_EXPECTED_11_CONSTEXPR or_else(F &&f) & { return or_else_impl(*this, std::forward<F>(f)); } - template <class F> expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) && { + template <class F> expected Q23_TL_EXPECTED_11_CONSTEXPR or_else(F &&f) && { return or_else_impl(std::move(*this), std::forward<F>(f)); } @@ -1582,7 +1582,7 @@ public: return or_else_impl(*this, std::forward<F>(f)); } -#ifndef TL_EXPECTED_NO_CONSTRR +#ifndef Q23_TL_EXPECTED_NO_CONSTRR template <class F> expected constexpr or_else(F &&f) const && { return or_else_impl(std::move(*this), std::forward<F>(f)); } @@ -1664,7 +1664,7 @@ public: nullptr, detail::expected_enable_from_other<T, E, U, G, const U &, const G &> * = nullptr> - explicit TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs) + explicit Q23_TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs) : ctor_base(detail::default_constructor_tag{}) { if (rhs.has_value()) { this->construct(*rhs); @@ -1679,7 +1679,7 @@ public: nullptr, detail::expected_enable_from_other<T, E, U, G, const U &, const G &> * = nullptr> - TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs) + Q23_TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs) : ctor_base(detail::default_constructor_tag{}) { if (rhs.has_value()) { this->construct(*rhs); @@ -1693,7 +1693,7 @@ public: detail::enable_if_t<!(std::is_convertible<U &&, T>::value && std::is_convertible<G &&, E>::value)> * = nullptr, detail::expected_enable_from_other<T, E, U, G, U &&, G &&> * = nullptr> - explicit TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs) + explicit Q23_TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs) : ctor_base(detail::default_constructor_tag{}) { if (rhs.has_value()) { this->construct(std::move(*rhs)); @@ -1707,7 +1707,7 @@ public: detail::enable_if_t<(std::is_convertible<U &&, T>::value && std::is_convertible<G &&, E>::value)> * = nullptr, detail::expected_enable_from_other<T, E, U, G, U &&, G &&> * = nullptr> - TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs) + Q23_TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs) : ctor_base(detail::default_constructor_tag{}) { if (rhs.has_value()) { this->construct(std::move(*rhs)); @@ -1720,14 +1720,14 @@ public: class U = T, detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr, detail::expected_enable_forward_value<T, E, U> * = nullptr> - explicit TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v) + explicit Q23_TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v) : expected(in_place, std::forward<U>(v)) {} template < class U = T, detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr, detail::expected_enable_forward_value<T, E, U> * = nullptr> - TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v) + Q23_TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v) : expected(in_place, std::forward<U>(v)) {} template < @@ -1773,7 +1773,7 @@ public: auto tmp = std::move(err()); err().~unexpected<E>(); -#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED +#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED try { ::new (valptr()) T(std::forward<U>(v)); this->m_has_val = true; @@ -1842,7 +1842,7 @@ public: auto tmp = std::move(err()); err().~unexpected<E>(); -#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED +#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED try { ::new (valptr()) T(std::forward<Args>(args)...); this->m_has_val = true; @@ -1882,7 +1882,7 @@ public: auto tmp = std::move(err()); err().~unexpected<E>(); -#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED +#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED try { ::new (valptr()) T(il, std::forward<Args>(args)...); this->m_has_val = true; @@ -1943,7 +1943,7 @@ private: move_constructing_e_can_throw) { auto temp = std::move(val()); val().~T(); -#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED +#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED try { ::new (errptr()) unexpected_type(std::move(rhs.err())); rhs.err().~unexpected_type(); @@ -1966,7 +1966,7 @@ private: e_is_nothrow_move_constructible) { auto temp = std::move(rhs.err()); rhs.err().~unexpected_type(); -#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED +#ifdef Q23_TL_EXPECTED_EXCEPTIONS_ENABLED try { ::new (rhs.valptr()) T(std::move(val())); val().~T(); @@ -2008,36 +2008,36 @@ public: } constexpr const T *operator->() const { - TL_ASSERT(has_value()); + Q23_TL_ASSERT(has_value()); return valptr(); } - TL_EXPECTED_11_CONSTEXPR T *operator->() { - TL_ASSERT(has_value()); + Q23_TL_EXPECTED_11_CONSTEXPR T *operator->() { + Q23_TL_ASSERT(has_value()); return valptr(); } template <class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr> constexpr const U &operator*() const & { - TL_ASSERT(has_value()); + Q23_TL_ASSERT(has_value()); return val(); } template <class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr> - TL_EXPECTED_11_CONSTEXPR U &operator*() & { - TL_ASSERT(has_value()); + Q23_TL_EXPECTED_11_CONSTEXPR U &operator*() & { + Q23_TL_ASSERT(has_value()); return val(); } template <class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr> constexpr const U &&operator*() const && { - TL_ASSERT(has_value()); + Q23_TL_ASSERT(has_value()); return std::move(val()); } template <class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr> - TL_EXPECTED_11_CONSTEXPR U &&operator*() && { - TL_ASSERT(has_value()); + Q23_TL_EXPECTED_11_CONSTEXPR U &&operator*() && { + Q23_TL_ASSERT(has_value()); return std::move(val()); } @@ -2046,47 +2046,47 @@ public: template <class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr> - TL_EXPECTED_11_CONSTEXPR const U &value() const & { + Q23_TL_EXPECTED_11_CONSTEXPR const U &value() const & { if (!has_value()) detail::throw_exception(bad_expected_access<E>(err().error())); return val(); } template <class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr> - TL_EXPECTED_11_CONSTEXPR U &value() & { + Q23_TL_EXPECTED_11_CONSTEXPR U &value() & { if (!has_value()) detail::throw_exception(bad_expected_access<E>(err().error())); return val(); } template <class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr> - TL_EXPECTED_11_CONSTEXPR const U &&value() const && { + Q23_TL_EXPECTED_11_CONSTEXPR const U &&value() const && { if (!has_value()) detail::throw_exception(bad_expected_access<E>(std::move(err()).error())); return std::move(val()); } template <class U = T, detail::enable_if_t<!std::is_void<U>::value> * = nullptr> - TL_EXPECTED_11_CONSTEXPR U &&value() && { + Q23_TL_EXPECTED_11_CONSTEXPR U &&value() && { if (!has_value()) detail::throw_exception(bad_expected_access<E>(std::move(err()).error())); return std::move(val()); } constexpr const E &error() const & { - TL_ASSERT(!has_value()); + Q23_TL_ASSERT(!has_value()); return err().error(); } - TL_EXPECTED_11_CONSTEXPR E &error() & { - TL_ASSERT(!has_value()); + Q23_TL_EXPECTED_11_CONSTEXPR E &error() & { + Q23_TL_ASSERT(!has_value()); return err().error(); } constexpr const E &&error() const && { - TL_ASSERT(!has_value()); + Q23_TL_ASSERT(!has_value()); return std::move(err().error()); } - TL_EXPECTED_11_CONSTEXPR E &&error() && { - TL_ASSERT(!has_value()); + Q23_TL_EXPECTED_11_CONSTEXPR E &&error() && { + Q23_TL_ASSERT(!has_value()); return std::move(err().error()); } @@ -2096,7 +2096,7 @@ public: "T must be copy-constructible and convertible to from U&&"); return bool(*this) ? **this : static_cast<T>(std::forward<U>(v)); } - template <class U> TL_EXPECTED_11_CONSTEXPR T value_or(U &&v) && { + template <class U> Q23_TL_EXPECTED_11_CONSTEXPR T value_or(U &&v) && { static_assert(std::is_move_constructible<T>::value && std::is_convertible<U &&, T>::value, "T must be move-constructible and convertible to from U&&"); @@ -2109,7 +2109,7 @@ template <class Exp> using exp_t = typename detail::decay_t<Exp>::value_type; template <class Exp> using err_t = typename detail::decay_t<Exp>::error_type; template <class Exp, class Ret> using ret_t = expected<Ret, err_t<Exp>>; -#ifdef TL_EXPECTED_CXX14 +#ifdef Q23_TL_EXPECTED_CXX14 template <class Exp, class F, detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr, class Ret = decltype(detail::invoke(std::declval<F>(), @@ -2156,7 +2156,7 @@ constexpr auto and_then_impl(Exp &&exp, F &&f) -> Ret { } #endif -#ifdef TL_EXPECTED_CXX14 +#ifdef Q23_TL_EXPECTED_CXX14 template <class Exp, class F, detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr, class Ret = decltype(detail::invoke(std::declval<F>(), @@ -2266,8 +2266,8 @@ auto expected_map_impl(Exp &&exp, F &&f) -> expected<void, err_t<Exp>> { } #endif -#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \ - !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55) +#if defined(Q23_TL_EXPECTED_CXX14) && !defined(Q23_TL_EXPECTED_GCC49) && \ + !defined(Q23_TL_EXPECTED_GCC54) && !defined(Q23_TL_EXPECTED_GCC55) template <class Exp, class F, detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr, class Ret = decltype(detail::invoke(std::declval<F>(), @@ -2382,7 +2382,7 @@ auto map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate> { } #endif -#ifdef TL_EXPECTED_CXX14 +#ifdef Q23_TL_EXPECTED_CXX14 template <class Exp, class F, class Ret = decltype(detail::invoke(std::declval<F>(), std::declval<Exp>().error())), diff --git a/src/corelib/global/qnumeric.h b/src/corelib/global/qnumeric.h index 4568d089590..db32ae73556 100644 --- a/src/corelib/global/qnumeric.h +++ b/src/corelib/global/qnumeric.h @@ -641,7 +641,7 @@ template <typename T, typename S> [[nodiscard]] constexpr bool fuzzyCompare(const T &lhs, const S &rhs) noexcept { static_assert(noexcept(qIsNull(lhs) && qIsNull(rhs) && qFuzzyIsNull(lhs - rhs) && qFuzzyCompare(lhs, rhs)), - "The operations qIsNull(), qFuzzyIsNull() and qFuzzyCompare() must be noexcept" + "The operations qIsNull(), qFuzzyIsNull() and qFuzzyCompare() must be noexcept " "for both argument types!"); return qIsNull(lhs) || qIsNull(rhs) ? qFuzzyIsNull(lhs - rhs) : qFuzzyCompare(lhs, rhs); } diff --git a/src/corelib/global/qoperatingsystemversion.cpp b/src/corelib/global/qoperatingsystemversion.cpp index d27a71526d8..32364fa8eb4 100644 --- a/src/corelib/global/qoperatingsystemversion.cpp +++ b/src/corelib/global/qoperatingsystemversion.cpp @@ -486,6 +486,12 @@ const QOperatingSystemVersionBase QOperatingSystemVersion::Windows11_22H2; */ /*! + \variable QOperatingSystemVersion::Windows11_25H2 + \brief a version corresponding to Windows 11 Version 25H2 (version 10.0.26200). + \since 6.11 + */ + +/*! \variable QOperatingSystemVersion::OSXMavericks \brief a version corresponding to OS X Mavericks (version 10.9). \since 5.9 diff --git a/src/corelib/global/qoperatingsystemversion.h b/src/corelib/global/qoperatingsystemversion.h index 75801a7ddcf..99866692f8c 100644 --- a/src/corelib/global/qoperatingsystemversion.h +++ b/src/corelib/global/qoperatingsystemversion.h @@ -148,6 +148,7 @@ public: static constexpr QOperatingSystemVersionBase Android14 { QOperatingSystemVersionBase::Android, 14, 0 }; static constexpr QOperatingSystemVersionBase Windows11_23H2 { QOperatingSystemVersionBase::Windows, 10, 0, 22631 }; static constexpr QOperatingSystemVersionBase Windows11_24H2 { QOperatingSystemVersionBase::Windows, 10, 0, 26100 }; + static constexpr QOperatingSystemVersionBase Windows11_25H2 { QOperatingSystemVersionBase::Windows, 10, 0, 26200 }; #if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && !defined(QT_BOOTSTRAPPED) && !defined(Q_QDOC) }; diff --git a/src/corelib/global/qttranslation.qdoc b/src/corelib/global/qttranslation.qdoc index 191b3777db6..c8b3764614e 100644 --- a/src/corelib/global/qttranslation.qdoc +++ b/src/corelib/global/qttranslation.qdoc @@ -179,7 +179,7 @@ \fn QString qTrId(const char *id, int n = -1) \relates <QtTranslation> \reentrant - \since 6.9 + \since 6.11 \brief The qTrId function is an alias for qtTrId. diff --git a/src/corelib/io/qrandomaccessasyncfile_darwin.mm b/src/corelib/io/qrandomaccessasyncfile_darwin.mm index 7231d12fe7d..fca225263ba 100644 --- a/src/corelib/io/qrandomaccessasyncfile_darwin.mm +++ b/src/corelib/io/qrandomaccessasyncfile_darwin.mm @@ -95,10 +95,8 @@ void QRandomAccessAsyncFilePrivate::close() // cancel all operations m_mutex.lock(); m_opToCancel = kAllOperationIds; - m_numChannelsToClose = m_ioChannel ? 1 : 0; for (const auto &op : m_operations) { if (op.channel) { - ++m_numChannelsToClose; closeIoChannel(op.channel); } } @@ -212,8 +210,8 @@ QRandomAccessAsyncFilePrivate::writeFrom(qint64 offset, QSpan<const QSpan<const void QRandomAccessAsyncFilePrivate::notifyIfOperationsAreCompleted() { QMutexLocker locker(&m_mutex); + --m_numChannelsToClose; if (m_opToCancel == kAllOperationIds) { - --m_numChannelsToClose; if (m_numChannelsToClose == 0 && m_runningOps.isEmpty()) m_cancellationCondition.wakeOne(); } @@ -222,11 +220,19 @@ void QRandomAccessAsyncFilePrivate::notifyIfOperationsAreCompleted() dispatch_io_t QRandomAccessAsyncFilePrivate::createMainChannel(int fd) { auto sharedThis = this; - return dispatch_io_create(DISPATCH_IO_RANDOM, fd, - dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), - ^(int /*error*/) { - sharedThis->notifyIfOperationsAreCompleted(); - }); + auto channel = + dispatch_io_create(DISPATCH_IO_RANDOM, fd, + dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), + ^(int /*error*/) { + // main I/O channel uses kInvalidOperationId + // as its identifier + sharedThis->notifyIfOperationsAreCompleted(); + }); + if (channel) { + QMutexLocker locker(&m_mutex); + ++m_numChannelsToClose; + } + return channel; } dispatch_io_t QRandomAccessAsyncFilePrivate::duplicateIoChannel(OperationId opId) @@ -247,6 +253,7 @@ dispatch_io_t QRandomAccessAsyncFilePrivate::duplicateIoChannel(OperationId opId if (channel) { QMutexLocker locker(&m_mutex); m_runningOps.insert(opId); + ++m_numChannelsToClose; } return channel; } @@ -593,6 +600,7 @@ void QRandomAccessAsyncFilePrivate::executeOpen(OperationInfo &opInfo) // So we need to notify the condition variable in // both cases. Q_ASSERT(sharedThis->m_runningOps.isEmpty()); + Q_ASSERT(sharedThis->m_numChannelsToClose == 0); sharedThis->m_cancellationCondition.wakeOne(); } else { auto context = sharedThis->q_ptr; diff --git a/src/corelib/itemmodels/qrangemodeladapter.h b/src/corelib/itemmodels/qrangemodeladapter.h index bd3342e6185..2a23e01eba2 100644 --- a/src/corelib/itemmodels/qrangemodeladapter.h +++ b/src/corelib/itemmodels/qrangemodeladapter.h @@ -141,6 +141,7 @@ public: } DataReference(const DataReference &other) = default; + DataReference(DataReference &&other) = default; // reference (not std::reference_wrapper) semantics DataReference &operator=(const DataReference &other) @@ -149,29 +150,23 @@ public: return *this; } + DataReference &operator=(DataReference &&other) + { + *this = other.get(); + return *this; + } + ~DataReference() = default; DataReference &operator=(const value_type &value) { - constexpr Qt::ItemDataRole dataRole = Qt::RangeModelAdapterRole; + assign(value); + return *this; + } - if (m_index.isValid()) { - auto model = const_cast<QAbstractItemModel *>(m_index.model()); - [[maybe_unused]] bool couldWrite = false; - if constexpr (std::is_same_v<q20::remove_cvref_t<value_type>, QVariant>) - couldWrite = model->setData(m_index, value, dataRole); - else - couldWrite = model->setData(m_index, QVariant::fromValue(value), dataRole); -#ifndef QT_NO_DEBUG - if (!couldWrite) { - qWarning() << "Writing value of type" << QMetaType::fromType<value_type>().name() - << "to role" << dataRole << "at index" << m_index - << "of the model failed"; - } - } else { - qCritical("Data reference for invalid index, can't write to model"); -#endif - } + DataReference &operator=(value_type &&value) + { + assign(std::move(value)); return *this; } @@ -196,6 +191,33 @@ public: private: QModelIndex m_index; + template <typename Value> + void assign(Value &&value) + { + constexpr Qt::ItemDataRole dataRole = Qt::RangeModelAdapterRole; + + if (m_index.isValid()) { + auto model = const_cast<QAbstractItemModel *>(m_index.model()); + [[maybe_unused]] bool couldWrite = false; + if constexpr (std::is_same_v<q20::remove_cvref_t<Value>, QVariant>) { + couldWrite = model->setData(m_index, value, dataRole); + } else { + couldWrite = model->setData(m_index, + QVariant::fromValue(std::forward<Value>(value)), + dataRole); + } +#ifndef QT_NO_DEBUG + if (!couldWrite) { + qWarning() << "Writing value of type" + << QMetaType::fromType<q20::remove_cvref_t<Value>>().name() + << "to role" << dataRole << "at index" << m_index << "failed"; + } + } else { + qCritical("Data reference for invalid index, can't write to model"); +#endif + } + } + friend inline bool comparesEqual(const DataReference &lhs, const DataReference &rhs) { return lhs.m_index == rhs.m_index @@ -1020,60 +1042,55 @@ public: template <typename NewRange = range_type, if_assignable_range<NewRange> = true> void setRange(NewRange &&newRange) { - using namespace QRangeModelDetails; - - auto *impl = storage.implementation(); - const QModelIndex root = storage.root(); - const qsizetype newLastRow = qsizetype(Impl::size(refTo(newRange))) - 1; - auto *oldRange = impl->childRange(root); - const qsizetype oldLastRow = qsizetype(Impl::size(oldRange)) - 1; - - if (!root.isValid()) { - impl->beginResetModel(); - impl->deleteOwnedRows(); - } else if constexpr (is_tree<Impl>) { - if (oldLastRow > 0) { - impl->beginRemoveRows(root, 0, model()->rowCount(root) - 1); - impl->deleteRemovedRows(refTo(oldRange)); - impl->endRemoveRows(); - } - if (newLastRow > 0) - impl->beginInsertRows(root, 0, newLastRow); - } else { - Q_ASSERT_X(false, "QRangeModelAdapter::setRange", - "Internal error: The root index in a table or list must be invalid."); - } - refTo(oldRange) = std::forward<NewRange>(newRange); - if (!root.isValid()) { - impl->endResetModel(); - } else if constexpr (is_tree<Impl>) { - if (newLastRow > 0) { - Q_ASSERT(model()->hasChildren(root)); - // if it was moved, then newRange is now likely to be empty. Get - // the inserted row. - impl->setParentRow(refTo(impl->childRange(storage.root())), - pointerTo(impl->rowData(root))); - impl->endInsertRows(); - } - } - if constexpr (Impl::itemsAreQObjects) { - if (model()->autoConnectPolicy() == QRangeModel::AutoConnectPolicy::Full) { - const auto begin = QRangeModelDetails::begin(refTo(oldRange)); - const auto end = QRangeModelDetails::end(refTo(oldRange)); - int rowIndex = 0; - for (auto it = begin; it != end; ++it, ++rowIndex) - impl->autoConnectPropertiesInRow(*it, rowIndex, root); - } - } + setRangeImpl(qsizetype(Impl::size(QRangeModelDetails::refTo(newRange))) - 1, + [&newRange](auto &oldRange) { + oldRange = std::forward<NewRange>(newRange); + }); } - template <typename NewRange = range_type, if_assignable_range<NewRange> = true> + template <typename NewRange = range_type, if_assignable_range<NewRange> = true, + unless_adapter<NewRange> = true> QRangeModelAdapter &operator=(NewRange &&newRange) { setRange(std::forward<NewRange>(newRange)); return *this; } + template <typename Row, if_assignable_range<std::initializer_list<Row>> = true> + void setRange(std::initializer_list<Row> newRange) + { + setRangeImpl(qsizetype(newRange.size() - 1), [&newRange](auto &oldRange) { + oldRange = newRange; + }); + } + + template <typename Row, if_assignable_range<std::initializer_list<Row>> = true> + QRangeModelAdapter &operator=(std::initializer_list<Row> newRange) + { + setRange(newRange); + return *this; + } + + template <typename Row, if_assignable_range<std::initializer_list<Row>> = true> + void assign(std::initializer_list<Row> newRange) + { + setRange(newRange); + } + + template <typename InputIterator, typename Sentinel, typename I = Impl, if_writable<I> = true> + void setRange(InputIterator first, Sentinel last) + { + setRangeImpl(qsizetype(std::distance(first, last) - 1), [first, last](auto &oldRange) { + oldRange.assign(first, last); + }); + } + + template <typename InputIterator, typename Sentinel, typename I = Impl, if_writable<I> = true> + void assign(InputIterator first, Sentinel last) + { + setRange(first, last); + } + // iterator API ConstRowIterator cbegin() const { @@ -1503,6 +1520,65 @@ private: Q_EMIT storage.implementation()->dataChanged(topLeft, bottomRight, {}); } + void beginSetRangeImpl(Impl *impl, range_type *oldRange, qsizetype newLastRow) + { + const QModelIndex root = storage.root(); + const qsizetype oldLastRow = qsizetype(Impl::size(oldRange)) - 1; + + if (!root.isValid()) { + impl->beginResetModel(); + impl->deleteOwnedRows(); + } else if constexpr (is_tree<Impl>) { + if (oldLastRow > 0) { + impl->beginRemoveRows(root, 0, model()->rowCount(root) - 1); + impl->deleteRemovedRows(QRangeModelDetails::refTo(oldRange)); + impl->endRemoveRows(); + } + if (newLastRow > 0) + impl->beginInsertRows(root, 0, newLastRow); + } else { + Q_ASSERT_X(false, "QRangeModelAdapter::setRange", + "Internal error: The root index in a table or list must be invalid."); + } + } + + void endSetRangeImpl(Impl *impl, qsizetype newLastRow) + { + const QModelIndex root = storage.root(); + if (!root.isValid()) { + impl->endResetModel(); + } else if constexpr (is_tree<Impl>) { + if (newLastRow > 0) { + Q_ASSERT(model()->hasChildren(root)); + // if it was moved, then newRange is now likely to be empty. Get + // the inserted row. + impl->setParentRow(QRangeModelDetails::refTo(impl->childRange(root)), + QRangeModelDetails::pointerTo(impl->rowData(root))); + impl->endInsertRows(); + } + } + } + + template <typename Assigner> + void setRangeImpl(qsizetype newLastRow, Assigner &&assigner) + { + auto *impl = storage.implementation(); + auto *oldRange = impl->childRange(storage.root()); + beginSetRangeImpl(impl, oldRange, newLastRow); + assigner(QRangeModelDetails::refTo(oldRange)); + endSetRangeImpl(impl, newLastRow); + + if constexpr (Impl::itemsAreQObjects) { + if (model()->autoConnectPolicy() == QRangeModel::AutoConnectPolicy::Full) { + const auto begin = QRangeModelDetails::begin(QRangeModelDetails::refTo(oldRange)); + const auto end = QRangeModelDetails::end(QRangeModelDetails::refTo(oldRange)); + int rowIndex = 0; + for (auto it = begin; it != end; ++it, ++rowIndex) + impl->autoConnectPropertiesInRow(*it, rowIndex, storage.root()); + } + } + } + template <typename P> static auto setParentRow(P protocol, row_type &newRow, row_ptr parentRow) -> decltype(protocol.setParentRow(std::declval<row_type&>(), std::declval<row_ptr>())) diff --git a/src/corelib/itemmodels/qrangemodeladapter.qdoc b/src/corelib/itemmodels/qrangemodeladapter.qdoc index 263bff0dd0c..ff595529d34 100644 --- a/src/corelib/itemmodels/qrangemodeladapter.qdoc +++ b/src/corelib/itemmodels/qrangemodeladapter.qdoc @@ -329,16 +329,39 @@ /*! \fn template <typename Range, typename Protocol, typename Model> template <typename NewRange, QRangeModelAdapter<Range, Protocol, Model>::if_assignable_range<NewRange>> void QRangeModelAdapter<Range, Protocol, Model>::setRange(NewRange &&newRange) - \fn template <typename Range, typename Protocol, typename Model> template <typename NewRange, QRangeModelAdapter<Range, Protocol, Model>::if_assignable_range<NewRange>> QRangeModelAdapter &QRangeModelAdapter<Range, Protocol, Model>::operator=(NewRange &&newRange) + \fn template <typename Range, typename Protocol, typename Model> template <typename NewRange, QRangeModelAdapter<Range, Protocol, Model>::if_assignable_range<NewRange>, QRangeModelAdapter<Range, Protocol, Model>::unless_adapter<NewRange>> QRangeModelAdapter &QRangeModelAdapter<Range, Protocol, Model>::operator=(NewRange &&newRange) + + Replaces the contents of the model with the rows in \a newRange, possibly + using move semantics. - Assigns \a newRange to the stored range, possibly using move semantics. This function makes the model() emit the \l{QAbstractItemModel::}{modelAboutToBeReset()} and \l{QAbstractItemModel::}{modelReset()} signals. \constraints \c Range is mutable, and \a newRange is of a type that can be - assigned to \c Range. + assigned to \c Range, but not a QRangeModelAdapter. + + \sa range(), at(), model(), assign() +*/ + +/*! + \fn template <typename Range, typename Protocol, typename Model> template <typename Row, QRangeModelAdapter<Range, Protocol, Model>::if_assignable_range<std::initializer_list<Row>>> void QRangeModelAdapter<Range, Protocol, Model>::setRange(std::initializer_list<Row> newRange) + \fn template <typename Range, typename Protocol, typename Model> template <typename Row, QRangeModelAdapter<Range, Protocol, Model>::if_assignable_range<std::initializer_list<Row>>> QRangeModelAdapter &QRangeModelAdapter<Range, Protocol, Model>::assign(std::initializer_list<Row> newRange) + \fn template <typename Range, typename Protocol, typename Model> template <typename Row, QRangeModelAdapter<Range, Protocol, Model>::if_assignable_range<std::initializer_list<Row>>> QRangeModelAdapter &QRangeModelAdapter<Range, Protocol, Model>::operator=(std::initializer_list<Row> newRange) + + Replaces the contents of the model with the rows in \a newRange. + + \constraints \c Range is mutable, and \a newRange can be assigned to \c Range. + + \sa range(), at, model() +*/ + +/*! + \fn template <typename Range, typename Protocol, typename Model> template <typename InputIterator, typename Sentinel, typename I = Impl, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I>> void QRangeModelAdapter<Range, Protocol, Model>::setRange(InputIterator first, Sentinel last) + \fn template <typename Range, typename Protocol, typename Model> template <typename InputIterator, typename Sentinel, typename I = Impl, QRangeModelAdapter<Range, Protocol, Model>::if_writable<I>> void QRangeModelAdapter<Range, Protocol, Model>::assign(InputIterator first, Sentinel last) + + Replaces the contents of the models with the rows in the range [\a first, \a last). - \sa range(), at(), model() + \sa range(), at, model() */ /*! diff --git a/src/corelib/kernel/qassociativeiterable.h b/src/corelib/kernel/qassociativeiterable.h index 39f66d45fa0..4f9bbf67bfb 100644 --- a/src/corelib/kernel/qassociativeiterable.h +++ b/src/corelib/kernel/qassociativeiterable.h @@ -156,10 +156,12 @@ inline QVariantRef<QAssociativeIterator>::operator QVariant() const if (!metaType.isValid()) return m_pointer->key(); + return [&] { QVariant v(metaType); metaAssociation.mappedAtIterator(m_pointer->constIterator(), metaType == QMetaType::fromType<QVariant>() ? &v : v.data()); return v; + }(); } template<> diff --git a/src/corelib/kernel/qcore_mac.mm b/src/corelib/kernel/qcore_mac.mm index 687fc7e85fa..f5f1f4a8cb8 100644 --- a/src/corelib/kernel/qcore_mac.mm +++ b/src/corelib/kernel/qcore_mac.mm @@ -22,6 +22,10 @@ #include <spawn.h> #include <qdebug.h> +#include <qpoint.h> +#include <qsize.h> +#include <qrect.h> +#include <qmargins.h> #include "qendian.h" #include "qhash.h" @@ -222,6 +226,34 @@ QDebug operator<<(QDebug dbg, CFStringRef stringRef) return dbg; } +QDebug operator<<(QDebug dbg, CGPoint point) +{ + dbg << QPointF::fromCGPoint(point); + return dbg; +} + +QDebug operator<<(QDebug dbg, CGSize size) +{ + dbg << QSizeF::fromCGSize(size); + return dbg; +} + +QDebug operator<<(QDebug dbg, CGRect rect) +{ + dbg << QRectF::fromCGRect(rect); + return dbg; +} + +#if defined(Q_OS_MACOS) +QDebug operator<<(QDebug dbg, NSEdgeInsets insets) +#else +QDebug operator<<(QDebug dbg, UIEdgeInsets insets) +#endif +{ + dbg << QMargins(insets.left, insets.top, insets.right, insets.bottom); + return dbg; +} + // Prevents breaking the ODR in case we introduce support for more types // later on, and lets the user override our default QDebug operators. #define QT_DECLARE_WEAK_QDEBUG_OPERATOR_FOR_CF_TYPE(CFType) \ diff --git a/src/corelib/kernel/qcore_mac_p.h b/src/corelib/kernel/qcore_mac_p.h index 2c4b4c02c55..1e57ee01e1d 100644 --- a/src/corelib/kernel/qcore_mac_p.h +++ b/src/corelib/kernel/qcore_mac_p.h @@ -78,6 +78,15 @@ kern_return_t IOObjectRelease(io_object_t object); Q_FORWARD_DECLARE_OBJC_CLASS(NSObject); Q_FORWARD_DECLARE_OBJC_CLASS(NSString); +struct CGPoint; +struct CGSize; +struct CGRect; +#if defined(Q_OS_MACOS) +struct NSEdgeInsets; +#else +struct UIEdgeInsets; +#endif + // @compatibility_alias doesn't work with categories or their methods #define QtExtras QT_MANGLE_NAMESPACE(QtExtras) @@ -225,6 +234,14 @@ Q_AUTOTEST_EXPORT void qt_mac_ensureResponsible(); #ifndef QT_NO_DEBUG_STREAM Q_CORE_EXPORT QDebug operator<<(QDebug debug, const QMacAutoReleasePool *pool); Q_CORE_EXPORT QDebug operator<<(QDebug debug, const QCFString &string); +Q_CORE_EXPORT QDebug operator<<(QDebug, CGPoint); +Q_CORE_EXPORT QDebug operator<<(QDebug, CGSize); +Q_CORE_EXPORT QDebug operator<<(QDebug, CGRect); +#if defined(Q_OS_MACOS) +Q_CORE_EXPORT QDebug operator<<(QDebug, NSEdgeInsets); +#else +Q_CORE_EXPORT QDebug operator<<(QDebug, UIEdgeInsets); +#endif #endif Q_CORE_EXPORT bool qt_apple_isApplicationExtension(); diff --git a/src/corelib/kernel/qiterable.h b/src/corelib/kernel/qiterable.h index baab2897967..494cec73a3f 100644 --- a/src/corelib/kernel/qiterable.h +++ b/src/corelib/kernel/qiterable.h @@ -502,7 +502,10 @@ public: if (m_metaContainer.hasSize()) return m_metaContainer.size(container); - // ### Qt7: Return -1 here. We shouldn't second-guess the underlying container +#if QT_VERSION >= QT_VERSION_CHECK(7, 0, 0) + // We shouldn't second-guess the underlying container, so we're not synthesizing a size. + return -1; +#else QtPrivate::warnSynthesizedAccess( "size() called on an iterable without native size accessor. This is slow"); @@ -515,6 +518,7 @@ public: m_metaContainer.destroyConstIterator(begin); m_metaContainer.destroyConstIterator(end); return size; +#endif } void clear() diff --git a/src/corelib/kernel/qjniobject.cpp b/src/corelib/kernel/qjniobject.cpp index abef9fdd663..21bfe5af448 100644 --- a/src/corelib/kernel/qjniobject.cpp +++ b/src/corelib/kernel/qjniobject.cpp @@ -27,7 +27,8 @@ using namespace Qt::StringLiterals; garbage-collected and providing access to most \c JNIEnv method calls (member, static) and fields (setter, getter). It eliminates much boiler-plate that would normally be needed, with direct JNI access, for - every operation, including exception-handling. + every operation. Exceptions thrown by called Java methods are cleared by + default, but can since Qt 6.11 also be handled by the caller. \note This API has been designed and tested for use with Android. It has not been tested for other platforms. @@ -129,12 +130,46 @@ using namespace Qt::StringLiterals; Note that while the first template parameter specifies the return type of the Java function, the method will still return a QJniObject. - \section1 Handling Java Exception + \section1 Handling Java Exceptions After calling Java functions that might throw exceptions, it is important to check for, handle and clear out any exception before continuing. All - QJniObject functions handle exceptions internally by reporting and clearing them, - saving client code the need to handle exceptions. + QJniObject functions can handle exceptions internally by reporting and + clearing them. This includes JNI exceptions, for instance when trying to + call a method that doesn't exist, or with bad parameters; and exceptions + are thrown by the method as a way of reporting errors or returning failure + information. + + From Qt 6.11 on, client code can opt in to handle exceptions explicitly in + each call. To do so, use \c{std::expected} from C++ 23 as the return type, + with the value type as the expected, and \c{jthrowable} as the error type. + For instance, trying to read a setting value via the + \c{android.provider.Settings.Secure} type might throw an exception if the + setting does not exist. + + \code + Q_DECLARE_JNI_CLASS(SettingsSecure, "android/provider/Settings$Secure") + using namespace QtJniTypes; + + QString enabledInputMethods() + { + ContentResolver resolver; + SettingsSecure settings; + + auto defaultInputMethods = settings.callMethod<std::expected<QString, jthrowable>>( + "getString", resolver, u"enabled_input_methods"_s + ); + if (defaultInputMethods) + return defaultInputMethods.value(); + QStringList stackTrace = QJniEnvironment::stackTrace(defaultInputMethods.error()); + } + \endcode + + You can use any other type that behaves like \c{std::expected}, so handling + exceptions explicitly is possible without using C++23. The only + requirements are that the type declares three nested types \c{value_type}, + \c{error_type}, and \c{unexpected_type}, can be constructed from the value + type, and from its \c{unexpected_type} holding a \c{jthrowable}. \note The user must handle exceptions manually when doing JNI calls using \c JNIEnv directly. It is unsafe to make other JNI calls when exceptions are pending. For more information, see @@ -921,7 +956,10 @@ QByteArray QJniObject::className() const jint size = myJavaString.callMethod<jint>("length"); \endcode - The method signature is deduced at compile time from \c Ret and the types of \a args. + The method signature is deduced at compile time from \c Ret and the types + of \a args. \c Ret can be a \c{std::expected}-compatible type that returns + a value, or \l{Handling Java Exceptions}{any Java exception thrown} by the + called method. */ /*! @@ -952,7 +990,10 @@ QByteArray QJniObject::className() const jint value = QJniObject::callStaticMethod<jint>("MyClass", "staticMethod"); \endcode - The method signature is deduced at compile time from \c Ret and the types of \a args. + The method signature is deduced at compile time from \c Ret and the types + of \a args. \c Ret can be a \c{std::expected}-compatible type that returns + a value, or \l{Handling Java Exceptions}{any Java exception thrown} by the + called method. */ /*! @@ -1009,7 +1050,10 @@ QByteArray QJniObject::className() const jdouble randNr = QJniObject::callStaticMethod<jdouble>(javaMathClass, "random"); \endcode - The method signature is deduced at compile time from \c Ret and the types of \a args. + The method signature is deduced at compile time from \c Ret and the types + of \a args. \c Ret can be a \c{std::expected}-compatible type that returns + a value, or \l{Handling Java Exceptions}{any Java exception thrown} by the + called method. */ /*! @@ -1020,8 +1064,12 @@ QByteArray QJniObject::className() const \c Ret (unless \c Ret is \c void). If \c Ret is a jobject type, then the returned value will be a QJniObject. - The method signature is deduced at compile time from \c Ret and the types of \a args. - \c Klass needs to be a C++ type with a registered type mapping to a Java type. + The method signature is deduced at compile time from \c Ret and the types + of \a args. \c Klass needs to be a C++ type with a registered type mapping + to a Java type. \c Ret can be a \c{std::expected}-compatible type that + returns a value, or \l{Handling Java Exceptions}{any Java exception thrown} + by the called method. + */ /*! @@ -1150,7 +1198,10 @@ QJniObject QJniObject::callStaticObjectMethod(jclass clazz, jmethodID methodId, QJniObject myJavaString2 = myJavaString1.callObjectMethod<jstring>("toString"); \endcode - The method signature is deduced at compile time from \c Ret and the types of \a args. + The method signature is deduced at compile time from \c Ret and the types + of \a args. \c Ret can be a \c{std::expected}-compatible type that returns + a value, or \l{Handling Java Exceptions}{any Java exception thrown} by the + called method. */ /*! @@ -1164,7 +1215,10 @@ QJniObject QJniObject::callStaticObjectMethod(jclass clazz, jmethodID methodId, QJniObject string = QJniObject::callStaticObjectMethod<jstring>("CustomClass", "getClassName"); \endcode - The method signature is deduced at compile time from \c Ret and the types of \a args. + The method signature is deduced at compile time from \c Ret and the types + of \a args. \c Ret can be a \c{std::expected}-compatible type that returns + a value, or \l{Handling Java Exceptions}{any Java exception thrown} by the + called method. */ /*! diff --git a/src/corelib/kernel/qmetaassociation.h b/src/corelib/kernel/qmetaassociation.h index 6d8de13e90a..d481ae91079 100644 --- a/src/corelib/kernel/qmetaassociation.h +++ b/src/corelib/kernel/qmetaassociation.h @@ -25,8 +25,8 @@ public: using reference = QVariant::Reference<AssociativeIterator>; using pointer = QVariant::Pointer<AssociativeIterator>; - static constexpr bool canNoexceptAssignQVariant = false; - static constexpr bool canNoexceptConvertToQVariant = false; + static constexpr bool CanNoexceptAssignQVariant = false; + static constexpr bool CanNoexceptConvertToQVariant = false; AssociativeIterator(QIterator &&it) : QIterator(std::move(it)) {} @@ -51,7 +51,7 @@ public: using reference = QVariant::ConstReference<AssociativeConstIterator>; using pointer = QVariant::ConstPointer<AssociativeConstIterator>; - static constexpr bool canNoexceptConvertToQVariant = false; + static constexpr bool CanNoexceptConvertToQVariant = false; AssociativeConstIterator(QConstIterator &&it) : QConstIterator(std::move(it)) {} diff --git a/src/corelib/kernel/qmetasequence.h b/src/corelib/kernel/qmetasequence.h index e9505054159..26156e7924f 100644 --- a/src/corelib/kernel/qmetasequence.h +++ b/src/corelib/kernel/qmetasequence.h @@ -24,8 +24,8 @@ public: using reference = QVariant::Reference<SequentialIterator>; using pointer = QVariant::Pointer<SequentialIterator>; - static constexpr bool canNoexceptAssignQVariant = false; - static constexpr bool canNoexceptConvertToQVariant = false; + static constexpr bool CanNoexceptAssignQVariant = false; + static constexpr bool CanNoexceptConvertToQVariant = false; SequentialIterator(QIterator &&it) : QIterator(std::move(it)) {} @@ -41,7 +41,7 @@ public: using reference = QVariant::ConstReference<SequentialConstIterator>; using pointer = QVariant::ConstPointer<SequentialConstIterator>; - static constexpr bool canNoexceptConvertToQVariant = false; + static constexpr bool CanNoexceptConvertToQVariant = false; SequentialConstIterator(QConstIterator &&it) : QConstIterator(std::move(it)) {} @@ -184,13 +184,15 @@ public: return; } - // ### Qt7: Drop this code. We shouldn't second-guess the underlying container +#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) + // We shouldn't second-guess the underlying container. QtPrivate::warnSynthesizedAccess( "at() called on an iterable without native indexed accessors. This is slow"); void *it = meta.constBegin(m_iterable.constPointer()); meta.advanceConstIterator(it, idx); meta.valueAtConstIterator(it, dataPtr); meta.destroyConstIterator(it); +#endif }); } @@ -204,13 +206,15 @@ public: return; } - // ### Qt7: Drop this code. We shouldn't second-guess the underlying container +#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) + // We shouldn't second-guess the underlying container QtPrivate::warnSynthesizedAccess( "set() called on an iterable without native indexed accessors. This is slow"); void *it = meta.begin(m_iterable.mutablePointer()); meta.advanceIterator(it, idx); meta.setValueAtIterator(it, dataPtr); meta.destroyIterator(it); +#endif } void append(const QVariant &value) @@ -248,55 +252,14 @@ public: Unspecified, AtBegin, AtEnd }; - QT_DEPRECATED_VERSION_X_6_11("Use append() or prepend() instead.") void addValue(const QVariant &value, Position position = Unspecified) - { - const QMetaSequence meta = metaContainer(); - QtPrivate::QVariantTypeCoercer coercer; - const void *valuePtr = coercer.coerce(value, meta.valueMetaType()); - - switch (position) { - case AtBegin: - if (meta.canAddValueAtBegin()) - meta.addValueAtBegin(mutableIterable(), valuePtr); - break; - case AtEnd: - if (meta.canAddValueAtEnd()) - meta.addValueAtEnd(mutableIterable(), valuePtr); - break; - case Unspecified: - if (meta.canAddValue()) - meta.addValue(mutableIterable(), valuePtr); - break; - } - } + Q_DECL_EQ_DELETE_X("Use append() or prepend() instead."); - QT_DEPRECATED_VERSION_X_6_11("Use removeLast() or removeFirst() instead.") void removeValue(Position position = Unspecified) - { - const QMetaSequence meta = metaContainer(); + Q_DECL_EQ_DELETE_X("Use removeLast() or removeFirst() instead."); - switch (position) { - case AtBegin: - if (meta.canRemoveValueAtBegin()) - meta.removeValueAtBegin(mutableIterable()); - break; - case AtEnd: - if (meta.canRemoveValueAtEnd()) - meta.removeValueAtEnd(mutableIterable()); - break; - case Unspecified: - if (meta.canRemoveValue()) - meta.removeValue(mutableIterable()); - break; - } - } - - QT_DEPRECATED_VERSION_X_6_11("Use QMetaSequence::valueMetaType() instead.") QMetaType valueMetaType() const - { - return metaContainer().valueMetaType(); - } + Q_DECL_EQ_DELETE_X("Use QMetaSequence::valueMetaType() instead."); QT_WARNING_POP #endif // QT_DEPRECATED_SINCE(6, 11) diff --git a/src/corelib/kernel/qsequentialiterable.h b/src/corelib/kernel/qsequentialiterable.h index 92252cb19dd..76908bdae4b 100644 --- a/src/corelib/kernel/qsequentialiterable.h +++ b/src/corelib/kernel/qsequentialiterable.h @@ -142,10 +142,13 @@ inline QVariantRef<QSequentialIterator>::operator QVariant() const if (m_pointer == nullptr) return QVariant(); const QMetaType metaType(m_pointer->metaContainer().valueMetaType()); + + return [&] { QVariant v(metaType); void *dataPtr = metaType == QMetaType::fromType<QVariant>() ? &v : v.data(); m_pointer->metaContainer().valueAtIterator(m_pointer->constIterator(), dataPtr); return v; + }(); } template<> diff --git a/src/corelib/kernel/qvariant.h b/src/corelib/kernel/qvariant.h index 82eec0693d6..19cd1fea7fb 100644 --- a/src/corelib/kernel/qvariant.h +++ b/src/corelib/kernel/qvariant.h @@ -263,7 +263,7 @@ public: ConstReference &operator=(ConstReference &&value) = delete; // To be specialized for each Referred - operator QVariant() const noexcept(Referred::canNoexceptConvertToQVariant); + operator QVariant() const noexcept(Referred::CanNoexceptConvertToQVariant); }; template<typename Referred> @@ -288,18 +288,18 @@ public: ~Reference() = default; Reference &operator=(const Reference &value) - noexcept(Referred::canNoexceptAssignQVariant) + noexcept(Referred::CanNoexceptAssignQVariant) { return operator=(QVariant(value)); } Reference &operator=(Reference &&value) - noexcept(Referred::canNoexceptAssignQVariant) + noexcept(Referred::CanNoexceptAssignQVariant) { return operator=(QVariant(value)); } - operator QVariant() const noexcept(Referred::canNoexceptConvertToQVariant) + operator QVariant() const noexcept(Referred::CanNoexceptConvertToQVariant) { return ConstReference(m_referred); } @@ -313,7 +313,7 @@ public: } // To be specialized for each Referred - Reference &operator=(const QVariant &value) noexcept(Referred::canNoexceptAssignQVariant); + Reference &operator=(const QVariant &value) noexcept(Referred::CanNoexceptAssignQVariant); }; template<typename Pointed> diff --git a/src/corelib/platform/windows/qbstr_p.h b/src/corelib/platform/windows/qbstr_p.h index 21eecfe2df7..32b1aace76f 100644 --- a/src/corelib/platform/windows/qbstr_p.h +++ b/src/corelib/platform/windows/qbstr_p.h @@ -1,5 +1,6 @@ // Copyright (C) 2024 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 QBSTR_P_H #define QBSTR_P_H @@ -141,4 +142,4 @@ QT_END_NAMESPACE #endif // Q_OS_WIN -#endif // QCOMPTR_P_H +#endif // QBSTR_P_H diff --git a/src/corelib/platform/windows/qcomobject_p.h b/src/corelib/platform/windows/qcomobject_p.h index bd6f81d1c28..b7a9c56555d 100644 --- a/src/corelib/platform/windows/qcomobject_p.h +++ b/src/corelib/platform/windows/qcomobject_p.h @@ -1,5 +1,6 @@ // Copyright (C) 2023 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 QCOMOBJECT_P_H #define QCOMOBJECT_P_H diff --git a/src/corelib/platform/windows/qcomptr_p.h b/src/corelib/platform/windows/qcomptr_p.h index 2a69e7b6038..e640528d3c2 100644 --- a/src/corelib/platform/windows/qcomptr_p.h +++ b/src/corelib/platform/windows/qcomptr_p.h @@ -1,5 +1,6 @@ // Copyright (C) 2024 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 QCOMPTR_P_H #define QCOMPTR_P_H diff --git a/src/corelib/platform/windows/qcomvariant_p.h b/src/corelib/platform/windows/qcomvariant_p.h index 34ce5f179ce..cc4ad104106 100644 --- a/src/corelib/platform/windows/qcomvariant_p.h +++ b/src/corelib/platform/windows/qcomvariant_p.h @@ -1,5 +1,6 @@ // Copyright (C) 2024 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 QCOMVARIANT_P_H #define QCOMVARIANT_P_H diff --git a/src/corelib/platform/windows/qfactorycacheregistration.cpp b/src/corelib/platform/windows/qfactorycacheregistration.cpp index 6bd69c66d14..04c81b7b665 100644 --- a/src/corelib/platform/windows/qfactorycacheregistration.cpp +++ b/src/corelib/platform/windows/qfactorycacheregistration.cpp @@ -1,5 +1,6 @@ // 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 #include "qfactorycacheregistration_p.h" diff --git a/src/corelib/platform/windows/qfactorycacheregistration_p.h b/src/corelib/platform/windows/qfactorycacheregistration_p.h index d0b19b995b4..f6e7d9eb064 100644 --- a/src/corelib/platform/windows/qfactorycacheregistration_p.h +++ b/src/corelib/platform/windows/qfactorycacheregistration_p.h @@ -1,5 +1,6 @@ // 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 QFACTORYCACHEREGISTRATION_P_H #define QFACTORYCACHEREGISTRATION_P_H diff --git a/src/corelib/platform/windows/qt_winrtbase_p.h b/src/corelib/platform/windows/qt_winrtbase_p.h index 79c2bdf6b1c..69a602a59e0 100644 --- a/src/corelib/platform/windows/qt_winrtbase_p.h +++ b/src/corelib/platform/windows/qt_winrtbase_p.h @@ -1,5 +1,6 @@ // 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 QT_WINRTBASE_P_H #define QT_WINRTBASE_P_H diff --git a/src/corelib/tools/qarraydata.cpp b/src/corelib/tools/qarraydata.cpp index 1c0371e463e..d173d824e88 100644 --- a/src/corelib/tools/qarraydata.cpp +++ b/src/corelib/tools/qarraydata.cpp @@ -162,7 +162,7 @@ allocateHelper(QArrayData **dptr, qsizetype objectSize, qsizetype alignment, qsi QArrayData::AllocationOption option) noexcept { *dptr = nullptr; - if (capacity == 0) + if (capacity <= 0) return {}; const qsizetype headerSize = calculateHeaderSize(alignment); diff --git a/src/corelib/tools/qsize.h b/src/corelib/tools/qsize.h index 1c5b02ed1f0..680bf2812d3 100644 --- a/src/corelib/tools/qsize.h +++ b/src/corelib/tools/qsize.h @@ -254,15 +254,11 @@ public: inline QSizeF &operator/=(qreal c); private: - QT_WARNING_PUSH - QT_WARNING_DISABLE_FLOAT_COMPARE friend constexpr bool qFuzzyCompare(const QSizeF &s1, const QSizeF &s2) noexcept { - // if one of the arguments is 0.0. return QtPrivate::fuzzyCompare(s1.wd, s2.wd) && QtPrivate::fuzzyCompare(s1.ht, s2.ht); } - QT_WARNING_POP friend constexpr bool qFuzzyIsNull(const QSizeF &size) noexcept { return qFuzzyIsNull(size.wd) && qFuzzyIsNull(size.ht); } friend constexpr bool comparesEqual(const QSizeF &lhs, const QSizeF &rhs) noexcept diff --git a/src/gui/accessible/qaccessible_base.h b/src/gui/accessible/qaccessible_base.h index 3881c6346a0..04efeddf06f 100644 --- a/src/gui/accessible/qaccessible_base.h +++ b/src/gui/accessible/qaccessible_base.h @@ -175,11 +175,15 @@ public: // quint64 alertMedium : 1; // quint64 alertHigh : 1; + Q_DECL_UNUSED_MEMBER quint64 qt_reserved : 27; + State() { std::memset(this, 0, sizeof(State)); } friend inline bool operator==(const QAccessible::State &first, const QAccessible::State &second) { + static_assert(std::has_unique_object_representations_v<State>, + "memcmp() cannot be used on types with padding"); return std::memcmp(&first, &second, sizeof(QAccessible::State)) == 0; } }; diff --git a/src/gui/accessible/qaccessiblecache.cpp b/src/gui/accessible/qaccessiblecache.cpp index 311b53aeaa3..b5dcdca6270 100644 --- a/src/gui/accessible/qaccessiblecache.cpp +++ b/src/gui/accessible/qaccessiblecache.cpp @@ -19,6 +19,7 @@ Q_STATIC_LOGGING_CATEGORY(lcAccessibilityCache, "qt.accessibility.cache"); */ static QAccessibleCache *accessibleCache = nullptr; +static bool inCacheDestructor = false; static void cleanupAccessibleCache() { @@ -32,6 +33,8 @@ QAccessibleObjectDestroyedEvent::~QAccessibleObjectDestroyedEvent() QAccessibleCache::~QAccessibleCache() { + inCacheDestructor = true; + for (QAccessible::Id id: idToInterface.keys()) deleteInterface(id); } @@ -188,10 +191,9 @@ void QAccessibleCache::deleteInterface(QAccessible::Id id, QObject *obj) return; } - // QObjects sends this from their destructor, but - // the object less interfaces calls deleteInterface - // directly - if (!obj && !iface->object()) { + // QObjects send this from their destructors, but the interfaces + // with no associated object call deleteInterface directly. + if (!inCacheDestructor && !obj && !iface->object()) { if (QGuiApplicationPrivate::is_app_running && !QGuiApplicationPrivate::is_app_closing && QAccessible::isActive()) { QAccessibleObjectDestroyedEvent event(id); QAccessible::updateAccessibility(&event); diff --git a/src/gui/doc/images/coordinatesystem-transformations.png b/src/gui/doc/images/coordinatesystem-transformations.png Binary files differdeleted file mode 100644 index 2736213c072..00000000000 --- a/src/gui/doc/images/coordinatesystem-transformations.png +++ /dev/null diff --git a/src/gui/doc/images/coordinatesystem-transformations.svg b/src/gui/doc/images/coordinatesystem-transformations.svg new file mode 100644 index 00000000000..a3bc17af3ef --- /dev/null +++ b/src/gui/doc/images/coordinatesystem-transformations.svg @@ -0,0 +1,148 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<svg width="760" height="300" + viewBox="0 0 760 300" + xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.2" baseProfile="tiny"> + +<style> + svg .line-style { stroke: black; fill: none; stroke-width: 2 } + svg .text-style { font: 14px arial; fill: black } + svg .mono-text-style { font: 14px monospace; fill: black } + svg .heading-style { font: 14px arial; fill: black; font-weight: bold } + svg .shape-style { stroke: none; fill: black } + svg .dash-style { stroke-dasharray: 4,3; stroke-dashoffset: 0; fill: none; + stroke: black } + + svg .window-line-style { stroke: red; fill: none; stroke-width: 2 } + svg .window-text-style { font: 14px arial; fill: red } + svg .window-shape-style { stroke: none; fill: red } + svg .window-dash-style { stroke-dasharray: 4,3; stroke-dashoffset: 0; fill: none; + stroke: red } + + svg.dark .line-style { stroke: #f2f2f2; fill: none; stroke-width: 2 } + svg.dark .text-style { font: 14px arial; fill: #f2f2f2 } + svg.dark .mono-text-style { font: 14px monospace; fill: #f2f2f2 } + svg.dark .heading-style { font: 14px arial; fill: #f2f2f2; font-weight: bold } + svg.dark .shape-style { stroke: none; fill: #f2f2f2 } + svg.dark .dash-style { stroke-dasharray: 4,3; stroke-dashoffset: 0; fill: none; + stroke: #f2f2f2 } + svg.dark .window-line-style { stroke: yellow; fill: none; stroke-width: 2 } + svg.dark .window-text-style { font: 14px arial; fill: yellow } + svg.dark .window-shape-style { stroke: none; fill: yellow } + svg.dark .window-dash-style { stroke-dasharray: 4,3; stroke-dashoffset: 0; fill: none; + stroke: yellow } + + [data-theme="dark"] svg .line-style { stroke: #f2f2f2; fill: none; stroke-width: 2 } + [data-theme="dark"] svg .text-style { font: 14px arial; fill: #f2f2f2 } + [data-theme="dark"] svg .mono-text-style { font: 14px monospace; fill: #f2f2f2 } + [data-theme="dark"] svg .heading-style { font: 14px arial; fill: #f2f2f2; font-weight: bold } + [data-theme="dark"] svg .shape-style { stroke: none; fill: #f2f2f2 } + [data-theme="dark"] svg .dash-style { stroke-dasharray: 4,3; stroke-dashoffset: 0; fill: none; + stroke: #f2f2f2 } + [data-theme="dark"] svg .window-line-style { stroke: yellow; fill: none; stroke-width: 2 } + [data-theme="dark"] svg .window-text-style { font: 14px arial; fill: yellow } + [data-theme="dark"] svg .window-shape-style { stroke: none; fill: yellow } + [data-theme="dark"] svg .window-dash-style { stroke-dasharray: 4,3; stroke-dashoffset: 0; fill: none; + stroke: yellow } + + [data-theme="light"] svg .line-style { stroke: black; fill: none; stroke-width: 2 } + [data-theme="light"] svg .text-style { font: 14px arial; fill: black } + [data-theme="light"] svg .mono-text-style { font: 14px monospace; fill: black } + [data-theme="light"] svg .heading-style { font: 14px arial; fill: black; font-weight: bold } + [data-theme="light"] svg .shape-style { stroke: none; fill: black } + [data-theme="light"] svg .dash-style { stroke-dasharray: 4,3; stroke-dashoffset: 0; fill: none; + stroke: black } + [data-theme="light"] svg .window-line-style { stroke: red; fill: none; stroke-width: 2 } + [data-theme="light"] svg .window-text-style { font: 14px arial; fill: red } + [data-theme="light"] svg .window-shape-style { stroke: none; fill: red } + [data-theme="light"] svg .window-dash-style { stroke-dasharray: 4,3; stroke-dashoffset: 0; fill: none; + stroke: red } +</style> + +<text x="50" y="20" fill="black" font-size="14px" font-family="arial" + font-weight="bold" + class="heading-style">World coordinates</text> + +<g transform="translate(20, 30)"> + <rect x="0" y="0" width="200" height="200" stroke="black" fill="none" stroke-dasharray="4,3" stroke-dashoffset="0" + class="dash-style" /> + + <path d="M5,5 L16,10 L10,16 L5,5" class="shape-style" /> + <polyline points="5,5 20,20" stroke="black" stroke-width="2" fill="none" class="line-style" /> + <text x="25" y="30" fill="black" font-size="14px" font-family="arial" + class="text-style">(0, 0)</text> + + <path d="M195,195 L184,190 L190,184 L195,195" class="shape-style" /> + <polyline points="195,195 180,180" stroke="black" stroke-width="2" fill="none" class="line-style" /> + <text x="115" y="175" fill="black" font-size="14px" font-family="arial" + class="text-style">(100, 100)</text> + + <polyline points="-3,-3 3,3" stroke="black" stroke-width="2" class="line-style" /> + <polyline points="-3,3 3,-3" stroke="black" stroke-width="2" class="line-style" /> +</g> + +<g transform="translate(45,235)"> + <path d="M 0,0 c 0,25 10,35 25,35" stroke="black" stroke-width="2" fill="none" class="line-style" /> + <path d="M 25,30 l 10,5 l -10,5 z" class="shape-style" /> + <text x="40" y="40" fill="black" font-size="14px" font-family="monospace" + class="mono-text-style">setWindow(-50, -50, 100, 100)</text> + <path d="M 290,35 c 15,0 25,-10 25,-35" stroke="black" stroke-width="2" fill="none" class="line-style" /> + <path d="M 315,0 l 5,10 l -10,0 z" class="shape-style" /> +</g> + +<text x="300" y="20" fill="black" font-size="14px" font-family="arial" + font-weight="bold" + class="heading-style">"Window" coordinates</text> + +<g transform="translate(280, 30)"> + + <rect x="0" y="0" width="200" height="200" stroke="red" fill="none" stroke-dasharray="4,3" stroke-dashoffset="0" + class="window-dash-style" /> + + <path d="M5,5 L16,10 L10,16 L5,5" fill="red" class="window-shape-style" /> + <polyline points="5,5 20,20" stroke="red" stroke-width="2" fill="none" class="window-line-style" /> + <text x="25" y="30" fill="red" font-size="14px" font-family="arial" + class="window-text-style">(-50, -50)</text> + + <path d="M195,195 L184,190 L190,184 L195,195" fill="red" class="window-shape-style" /> + <polyline points="195,195 180,180" stroke="red" stroke-width="2" fill="none" class="window-line-style" /> + <text x="130" y="175" fill="red" font-size="14px" font-family="arial" + class="window-text-style">(50, 50)</text> + + <polyline points="97,97 103,103" stroke="red" stroke-width="2" class="window-line-style" /> + <polyline points="97,103 103,97" stroke="red" stroke-width="2" class="window-line-style" /> +</g> + +<g transform="translate(395,235)"> + <path d="M 0,0 c 0,25 10,35 25,35" stroke="black" stroke-width="2" fill="none" class="line-style" /> + <path d="M 25,30 l 10,5 l -10,5 z" class="shape-style" /> + <text x="40" y="40" fill="black" font-size="14px" font-family="monospace" + class="mono-text-style">setViewport(45, 25, 50, 50)</text> + <path d="M 270,35 c 15,0 25,-10 25,-35" stroke="black" stroke-width="2" fill="none" class="line-style" /> + <path d="M 295,0 l 5,10 l -10,0 z" class="shape-style" /> +</g> + +<text x="570" y="20" fill="black" font-size="14px" font-family="arial" + font-weight="bold" + class="heading-style">Device coordinates</text> + +<g transform="translate(540, 30)"> + + <rect x="0" y="0" width="200" height="200" stroke="black" stroke-width="2" fill="none" class="line-style" /> + + <path d="M5,5 L16,10 L10,16 L5,5" class="shape-style" /> + <polyline points="5,5 20,20" stroke="black" stroke-width="2" fill="none" class="line-style" /> + <text x="25" y="30" fill="black" font-size="14px" font-family="arial" + class="text-style">(0, 0)</text> + + <path d="M195,195 L184,190 L190,184 L195,195" class="shape-style" /> + <polyline points="195,195 180,180" stroke="black" stroke-width="2" fill="none" class="line-style" /> + <text x="115" y="175" fill="black" font-size="14px" font-family="arial" + class="text-style">(100, 100)</text> + + <rect x="90" y="50" width="100" height="100" stroke="red" fill="none" stroke-dasharray="4,3" stroke-dashoffset="0" + class="window-dash-style" /> + <polyline points="137,97 143,103" stroke="red" stroke-width="2" class="window-line-style" /> + <polyline points="137,103 143,97" stroke="red" stroke-width="2" class="window-line-style" /> +</g> + +</svg> diff --git a/src/gui/doc/src/coordsys.qdoc b/src/gui/doc/src/coordsys.qdoc index 3dd064c19bc..22e14121af6 100644 --- a/src/gui/doc/src/coordsys.qdoc +++ b/src/gui/doc/src/coordsys.qdoc @@ -321,7 +321,7 @@ still transformed to the viewport using the same linear algebraic approach. - \image coordinatesystem-transformations.png {Illustration showing + \image coordinatesystem-transformations.svg {Illustration showing how coordinates are mapped using viewport, "window" and transformation matrix} diff --git a/src/gui/kernel/qsurface.cpp b/src/gui/kernel/qsurface.cpp index e2bafa73988..f361ec86c2d 100644 --- a/src/gui/kernel/qsurface.cpp +++ b/src/gui/kernel/qsurface.cpp @@ -68,7 +68,10 @@ QT_IMPL_METATYPE_EXTERN_TAGGED(QSurface*, QSurface_ptr) bool QSurface::supportsOpenGL() const { - return surfaceType() == OpenGLSurface; + static bool openGLOnRasterSurfaceSupported = + QGuiApplicationPrivate::instance()->platformIntegration()->hasCapability(QPlatformIntegration::OpenGLOnRasterSurface); + return surfaceType() == OpenGLSurface + || (surfaceType() == RasterSurface && openGLOnRasterSurfaceSupported); } /*! diff --git a/src/gui/math3d/qmatrix4x4.cpp b/src/gui/math3d/qmatrix4x4.cpp index 95b9524172f..ec6e696ba00 100644 --- a/src/gui/math3d/qmatrix4x4.cpp +++ b/src/gui/math3d/qmatrix4x4.cpp @@ -294,6 +294,7 @@ double QMatrix4x4::determinant() const if ((flagBits & ~(Translation | Rotation2D | Rotation)) == Identity) return 1.0; + Q_DECL_UNINITIALIZED double mm[4][4]; copyToDoubles(m, mm); if (flagBits < Rotation2D) @@ -355,8 +356,10 @@ QMatrix4x4 QMatrix4x4::inverted(bool *invertible) const *invertible = true; return orthonormalInverse(); } else if (flagBits < Perspective) { + Q_DECL_UNINITIALIZED QMatrix4x4 inv(Qt::Uninitialized); + Q_DECL_UNINITIALIZED double mm[4][4]; copyToDoubles(m, mm); @@ -391,8 +394,10 @@ QMatrix4x4 QMatrix4x4::inverted(bool *invertible) const return inv; } + Q_DECL_UNINITIALIZED QMatrix4x4 inv(Qt::Uninitialized); + Q_DECL_UNINITIALIZED double mm[4][4]; copyToDoubles(m, mm); @@ -465,6 +470,7 @@ QMatrix3x3 QMatrix4x4::normalMatrix() const return inv; } + Q_DECL_UNINITIALIZED double mm[4][4]; copyToDoubles(m, mm); double det = matrixDet3(mm, 0, 1, 2, 0, 1, 2); @@ -493,6 +499,7 @@ QMatrix3x3 QMatrix4x4::normalMatrix() const */ QMatrix4x4 QMatrix4x4::transposed() const { + Q_DECL_UNINITIALIZED QMatrix4x4 result(Qt::Uninitialized); for (int row = 0; row < 4; ++row) { for (int col = 0; col < 4; ++col) { @@ -709,6 +716,7 @@ QMatrix4x4& QMatrix4x4::operator/=(float divisor) */ QMatrix4x4 operator/(const QMatrix4x4& matrix, float divisor) { + Q_DECL_UNINITIALIZED QMatrix4x4 m(Qt::Uninitialized); m.m[0][0] = matrix.m[0][0] / divisor; m.m[0][1] = matrix.m[0][1] / divisor; @@ -1141,6 +1149,7 @@ void QMatrix4x4::rotate(float angle, float x, float y, float z) z = float(double(z) / len); } float ic = 1.0f - c; + Q_DECL_UNINITIALIZED QMatrix4x4 rot(Qt::Uninitialized); rot.m[0][0] = x * x * ic + c; rot.m[1][0] = x * y * ic - z * s; @@ -1244,6 +1253,7 @@ void QMatrix4x4::projectedRotate(float angle, float x, float y, float z, float d z = float(double(z) / len); } const float ic = 1.0f - c; + Q_DECL_UNINITIALIZED QMatrix4x4 rot(Qt::Uninitialized); rot.m[0][0] = x * x * ic + c; rot.m[1][0] = x * y * ic - z * s; @@ -1306,6 +1316,7 @@ void QMatrix4x4::rotate(const QQuaternion& quaternion) // Algorithm from: // http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q54 + Q_DECL_UNINITIALIZED QMatrix4x4 m(Qt::Uninitialized); const float f2x = quaternion.x() + quaternion.x(); @@ -1393,6 +1404,7 @@ void QMatrix4x4::ortho(float left, float right, float bottom, float top, float n const float width = right - left; const float invheight = top - bottom; const float clip = farPlane - nearPlane; + Q_DECL_UNINITIALIZED QMatrix4x4 m(Qt::Uninitialized); m.m[0][0] = 2.0f / width; m.m[1][0] = 0.0f; @@ -1431,6 +1443,7 @@ void QMatrix4x4::frustum(float left, float right, float bottom, float top, float return; // Construct the projection. + Q_DECL_UNINITIALIZED QMatrix4x4 m(Qt::Uninitialized); const float width = right - left; const float invheight = top - bottom; @@ -1474,6 +1487,7 @@ void QMatrix4x4::perspective(float verticalAngle, float aspectRatio, float nearP return; // Construct the projection. + Q_DECL_UNINITIALIZED QMatrix4x4 m(Qt::Uninitialized); const float radians = qDegreesToRadians(verticalAngle / 2.0f); const float sine = std::sin(radians); @@ -1524,6 +1538,7 @@ void QMatrix4x4::lookAt(const QVector3D& eye, const QVector3D& center, const QVe QVector3D side = QVector3D::crossProduct(forward, up).normalized(); QVector3D upVector = QVector3D::crossProduct(side, forward); + Q_DECL_UNINITIALIZED QMatrix4x4 m(Qt::Uninitialized); m.m[0][0] = side.x(); m.m[1][0] = side.y(); @@ -1573,6 +1588,7 @@ void QMatrix4x4::viewport(float left, float bottom, float width, float height, f const float w2 = width / 2.0f; const float h2 = height / 2.0f; + Q_DECL_UNINITIALIZED QMatrix4x4 m(Qt::Uninitialized); m.m[0][0] = w2; m.m[1][0] = 0.0f; @@ -1871,6 +1887,7 @@ QRectF QMatrix4x4::mapRect(const QRectF& rect) const // of just rotations and translations. QMatrix4x4 QMatrix4x4::orthonormalInverse() const { + Q_DECL_UNINITIALIZED QMatrix4x4 result(Qt::Uninitialized); result.m[0][0] = m[0][0]; @@ -1943,6 +1960,7 @@ void QMatrix4x4::optimize() flagBits &= ~Scale; } else { // If the columns are orthonormal and form a right-handed system, then there is no scale. + Q_DECL_UNINITIALIZED double mm[4][4]; copyToDoubles(m, mm); double det = matrixDet2(mm, 0, 1, 0, 1); @@ -1957,6 +1975,7 @@ void QMatrix4x4::optimize() } } else { // If the columns are orthonormal and form a right-handed system, then there is no scale. + Q_DECL_UNINITIALIZED double mm[4][4]; copyToDoubles(m, mm); double det = matrixDet3(mm, 0, 1, 2, 0, 1, 2); diff --git a/src/gui/math3d/qmatrix4x4.h b/src/gui/math3d/qmatrix4x4.h index ecbbb199cc9..2a801905ce0 100644 --- a/src/gui/math3d/qmatrix4x4.h +++ b/src/gui/math3d/qmatrix4x4.h @@ -564,6 +564,7 @@ inline bool QMatrix4x4::operator!=(const QMatrix4x4& other) const inline QMatrix4x4 operator+(const QMatrix4x4& m1, const QMatrix4x4& m2) { + Q_DECL_UNINITIALIZED QMatrix4x4 m(Qt::Uninitialized); m.m[0][0] = m1.m[0][0] + m2.m[0][0]; m.m[0][1] = m1.m[0][1] + m2.m[0][1]; @@ -586,6 +587,7 @@ inline QMatrix4x4 operator+(const QMatrix4x4& m1, const QMatrix4x4& m2) inline QMatrix4x4 operator-(const QMatrix4x4& m1, const QMatrix4x4& m2) { + Q_DECL_UNINITIALIZED QMatrix4x4 m(Qt::Uninitialized); m.m[0][0] = m1.m[0][0] - m2.m[0][0]; m.m[0][1] = m1.m[0][1] - m2.m[0][1]; @@ -608,21 +610,34 @@ inline QMatrix4x4 operator-(const QMatrix4x4& m1, const QMatrix4x4& m2) inline QMatrix4x4 operator*(const QMatrix4x4& m1, const QMatrix4x4& m2) { + Q_DECL_UNINITIALIZED + QMatrix4x4 m(Qt::Uninitialized); QMatrix4x4::Flags flagBits = m1.flagBits | m2.flagBits; if (flagBits.toInt() < QMatrix4x4::Rotation2D) { - QMatrix4x4 m = m1; - m.m[3][0] = m.m[3][0] + m.m[0][0] * m2.m[3][0]; - m.m[3][1] = m.m[3][1] + m.m[1][1] * m2.m[3][1]; - m.m[3][2] = m.m[3][2] + m.m[2][2] * m2.m[3][2]; - - m.m[0][0] = m.m[0][0] * m2.m[0][0]; - m.m[1][1] = m.m[1][1] * m2.m[1][1]; - m.m[2][2] = m.m[2][2] * m2.m[2][2]; + // Scale | Translation + m.m[0][0] = m1.m[0][0] * m2.m[0][0]; + m.m[0][1] = 0.0f; + m.m[0][2] = 0.0f; + m.m[0][3] = 0.0f; + + m.m[1][0] = 0.0f; + m.m[1][1] = m1.m[1][1] * m2.m[1][1]; + m.m[1][2] = 0.0f; + m.m[1][3] = 0.0f; + + m.m[2][0] = 0.0f; + m.m[2][1] = 0.0f; + m.m[2][2] = m1.m[2][2] * m2.m[2][2]; + m.m[2][3] = 0.0f; + + m.m[3][0] = m1.m[3][0] + m1.m[0][0] * m2.m[3][0]; + m.m[3][1] = m1.m[3][1] + m1.m[1][1] * m2.m[3][1]; + m.m[3][2] = m1.m[3][2] + m1.m[2][2] * m2.m[3][2]; + m.m[3][3] = 1.0f; m.flagBits = flagBits; return m; } - QMatrix4x4 m(Qt::Uninitialized); m.m[0][0] = m1.m[0][0] * m2.m[0][0] + m1.m[1][0] * m2.m[0][1] + m1.m[2][0] * m2.m[0][2] @@ -843,6 +858,7 @@ inline QPointF operator*(const QMatrix4x4& matrix, const QPointF& point) inline QMatrix4x4 operator-(const QMatrix4x4& matrix) { + Q_DECL_UNINITIALIZED QMatrix4x4 m(Qt::Uninitialized); m.m[0][0] = -matrix.m[0][0]; m.m[0][1] = -matrix.m[0][1]; @@ -865,6 +881,7 @@ inline QMatrix4x4 operator-(const QMatrix4x4& matrix) inline QMatrix4x4 operator*(float factor, const QMatrix4x4& matrix) { + Q_DECL_UNINITIALIZED QMatrix4x4 m(Qt::Uninitialized); m.m[0][0] = matrix.m[0][0] * factor; m.m[0][1] = matrix.m[0][1] * factor; @@ -887,6 +904,7 @@ inline QMatrix4x4 operator*(float factor, const QMatrix4x4& matrix) inline QMatrix4x4 operator*(const QMatrix4x4& matrix, float factor) { + Q_DECL_UNINITIALIZED QMatrix4x4 m(Qt::Uninitialized); m.m[0][0] = matrix.m[0][0] * factor; m.m[0][1] = matrix.m[0][1] * factor; diff --git a/src/gui/opengl/platform/egl/qeglplatformcontext.cpp b/src/gui/opengl/platform/egl/qeglplatformcontext.cpp index e56504833d1..350968b87d4 100644 --- a/src/gui/opengl/platform/egl/qeglplatformcontext.cpp +++ b/src/gui/opengl/platform/egl/qeglplatformcontext.cpp @@ -104,6 +104,14 @@ QT_BEGIN_NAMESPACE #define GL_LOSE_CONTEXT_ON_RESET 0x8252 #endif +// Constants from GL_EXT_robustness. +#ifndef GL_RESET_NOTIFICATION_STRATEGY_EXT +#define GL_RESET_NOTIFICATION_STRATEGY_EXT 0x8256 +#endif +#ifndef GL_LOSE_CONTEXT_ON_RESET_EXT +#define GL_LOSE_CONTEXT_ON_RESET_EXT 0x8252 +#endif + // Constants from EGL_NV_robustness_video_memory_purge #ifndef EGL_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV #define EGL_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV 0x334C @@ -452,11 +460,16 @@ void QEGLPlatformContext::updateFormatFromGL() } } } - if (hasExtension("GL_ARB_robustness")) { + if (m_format.renderableType() == QSurfaceFormat::OpenGL && hasExtension("GL_ARB_robustness")) { GLint value = 0; glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY, &value); if (value == GL_LOSE_CONTEXT_ON_RESET) m_format.setOption(QSurfaceFormat::ResetNotification); + } else if (m_format.renderableType() == QSurfaceFormat::OpenGLES && hasExtension("GL_EXT_robustness")) { + GLint value = 0; + glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_EXT, &value); + if (value == GL_LOSE_CONTEXT_ON_RESET_EXT) + m_format.setOption(QSurfaceFormat::ResetNotification); } } runGLChecks(); diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp index 04433c7703a..697ede42d92 100644 --- a/src/gui/painting/qdrawhelper.cpp +++ b/src/gui/painting/qdrawhelper.cpp @@ -930,7 +930,7 @@ static inline bool canUseFastMatrixPath(const qreal cx, const qreal cy, const qs minc = std::min(minc, std::min(fx, fy)); maxc = std::max(maxc, std::max(fx, fy)); - return minc >= std::numeric_limits<int>::min() && maxc <= std::numeric_limits<int>::max(); + return minc >= std::numeric_limits<int>::min() && maxc <= qreal(std::numeric_limits<int>::max()); } template<TextureBlendType blendType, QPixelLayout::BPP bpp, typename T> @@ -5179,7 +5179,7 @@ static inline bool calculate_fixed_gradient_factors(int count, const QT_FT_Span const int gss = GRADIENT_STOPTABLE_SIZE - 1; qreal ryinc = linear.dy * data->m22 * gss * FIXPT_SIZE; qreal roff = (linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss * FIXPT_SIZE; - const int limit = std::numeric_limits<int>::max() - FIXPT_SIZE; + const qreal limit = qreal(std::numeric_limits<int>::max() - FIXPT_SIZE); if (count && (std::fabs(ryinc) < limit) && (std::fabs(roff) < limit) && (std::fabs(ryinc * spans->y + roff) < limit) && (std::fabs(ryinc * (spans + count - 1)->y + roff) < limit)) { diff --git a/src/gui/painting/qpagelayout.cpp b/src/gui/painting/qpagelayout.cpp index e6f346dcdf2..17fb6491b75 100644 --- a/src/gui/painting/qpagelayout.cpp +++ b/src/gui/painting/qpagelayout.cpp @@ -606,7 +606,7 @@ bool QPageLayout::setLeftMargin(qreal leftMargin, OutOfBoundsPolicy outOfBoundsP if (d->m_mode == StandardMode && outOfBoundsPolicy == OutOfBoundsPolicy::Clamp) leftMargin = qBound(d->m_minMargins.left(), leftMargin, d->m_maxMargins.left()); - if (qFuzzyCompare(leftMargin, d->m_margins.left())) + if (QtPrivate::fuzzyCompare(leftMargin, d->m_margins.left())) return true; if (d->m_mode == FullPageMode @@ -637,7 +637,7 @@ bool QPageLayout::setRightMargin(qreal rightMargin, OutOfBoundsPolicy outOfBound if (d->m_mode == StandardMode && outOfBoundsPolicy == OutOfBoundsPolicy::Clamp) rightMargin = qBound(d->m_minMargins.right(), rightMargin, d->m_maxMargins.right()); - if (qFuzzyCompare(rightMargin, d->m_margins.right())) + if (QtPrivate::fuzzyCompare(rightMargin, d->m_margins.right())) return true; if (d->m_mode == FullPageMode @@ -668,7 +668,7 @@ bool QPageLayout::setTopMargin(qreal topMargin, OutOfBoundsPolicy outOfBoundsPol if (d->m_mode == StandardMode && outOfBoundsPolicy == OutOfBoundsPolicy::Clamp) topMargin = qBound(d->m_minMargins.top(), topMargin, d->m_maxMargins.top()); - if (qFuzzyCompare(topMargin, d->m_margins.top())) + if (QtPrivate::fuzzyCompare(topMargin, d->m_margins.top())) return true; if (d->m_mode == FullPageMode @@ -699,7 +699,7 @@ bool QPageLayout::setBottomMargin(qreal bottomMargin, OutOfBoundsPolicy outOfBou if (d->m_mode == StandardMode && outOfBoundsPolicy == OutOfBoundsPolicy::Clamp) bottomMargin = qBound(d->m_minMargins.bottom(), bottomMargin, d->m_maxMargins.bottom()); - if (qFuzzyCompare(bottomMargin, d->m_margins.bottom())) + if (QtPrivate::fuzzyCompare(bottomMargin, d->m_margins.bottom())) return true; if (d->m_mode == FullPageMode diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp index 74321705ff5..047be5f1c3d 100644 --- a/src/gui/painting/qpaintengine_raster.cpp +++ b/src/gui/painting/qpaintengine_raster.cpp @@ -2952,9 +2952,9 @@ inline bool QRasterPaintEnginePrivate::isUnclipped(const QRectF &rect, int penWidth) const { const QRectF norm = rect.normalized(); - if (norm.left() <= INT_MIN || norm.top() <= INT_MIN - || norm.right() > INT_MAX || norm.bottom() > INT_MAX - || norm.width() > INT_MAX || norm.height() > INT_MAX) + if (norm.left() <= qreal(INT_MIN) || norm.top() <= qreal(INT_MIN) + || norm.right() > qreal(INT_MAX) || norm.bottom() > qreal(INT_MAX) + || norm.width() > qreal(INT_MAX) || norm.height() > qreal(INT_MAX)) return false; return isUnclipped(norm.toAlignedRect(), penWidth); } diff --git a/src/gui/painting/qpainterpath.h b/src/gui/painting/qpainterpath.h index cc80641ded9..ab9e7fe312a 100644 --- a/src/gui/painting/qpainterpath.h +++ b/src/gui/painting/qpainterpath.h @@ -6,9 +6,11 @@ #include <QtGui/qtguiglobal.h> #include <QtGui/qtransform.h> + #include <QtCore/qglobal.h> #include <QtCore/qline.h> #include <QtCore/qlist.h> +#include <QtCore/qpoint.h> #include <QtCore/qrect.h> QT_BEGIN_NAMESPACE diff --git a/src/gui/rhi/qrhivulkan.cpp b/src/gui/rhi/qrhivulkan.cpp index 33e35ba6694..202e28263c2 100644 --- a/src/gui/rhi/qrhivulkan.cpp +++ b/src/gui/rhi/qrhivulkan.cpp @@ -682,6 +682,12 @@ bool QRhiVulkan::create(QRhi::Flags flags) if (devExts.contains("VK_KHR_fragment_shading_rate")) addToChain(&physDevFeaturesChainable, &fragmentShadingRateFeatures); #endif +#ifdef VK_EXT_device_fault + VkPhysicalDeviceFaultFeaturesEXT deviceFaultFeatures = {}; + deviceFaultFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; + if (devExts.contains(VK_EXT_DEVICE_FAULT_EXTENSION_NAME)) + addToChain(&physDevFeaturesChainable, &deviceFaultFeatures); +#endif #endif // Vulkan >=1.2 headers at build time, >=1.2 implementation at run time @@ -825,6 +831,13 @@ bool QRhiVulkan::create(QRhi::Flags flags) requestedDevExts.append(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME); #endif +#ifdef VK_EXT_device_fault + if (devExts.contains(VK_EXT_DEVICE_FAULT_EXTENSION_NAME)) { + requestedDevExts.append(VK_EXT_DEVICE_FAULT_EXTENSION_NAME); + caps.deviceFault = true; + } +#endif + for (const QByteArray &ext : requestedDeviceExtensions) { if (!ext.isEmpty() && !requestedDevExts.contains(ext)) { if (devExts.contains(ext)) { @@ -910,6 +923,7 @@ bool QRhiVulkan::create(QRhi::Flags flags) // Here we have no way to tell if the extensions got enabled or not. // Pretend it's all there and supported. If getProcAddress fails, we'll // handle that gracefully. + caps.deviceFault = true; caps.vertexAttribDivisor = true; caps.renderPass2KHR = true; caps.depthStencilResolveKHR = true; @@ -1126,6 +1140,12 @@ bool QRhiVulkan::create(QRhi::Flags flags) } #endif +#ifdef VK_EXT_device_fault + if (caps.deviceFault) { + vkGetDeviceFaultInfoEXT = reinterpret_cast<PFN_vkGetDeviceFaultInfoEXT>(f->vkGetDeviceProcAddr(dev, "vkGetDeviceFaultInfoEXT")); + } +#endif + deviceLost = false; nativeHandlesStruct.physDev = physDev; @@ -2643,6 +2663,7 @@ QRhi::FrameOpResult QRhiVulkan::beginFrame(QRhiSwapChain *swapChain, QRhi::Begin } else { if (err == VK_ERROR_DEVICE_LOST) { qWarning("Device loss detected in vkAcquireNextImageKHR()"); + printExtraErrorInfo(err); deviceLost = true; return QRhi::FrameOpDeviceLost; } @@ -2803,6 +2824,7 @@ QRhi::FrameOpResult QRhiVulkan::endFrame(QRhiSwapChain *swapChain, QRhi::EndFram } else if (err != VK_SUBOPTIMAL_KHR) { if (err == VK_ERROR_DEVICE_LOST) { qWarning("Device loss detected in vkQueuePresentKHR()"); + printExtraErrorInfo(err); deviceLost = true; return QRhi::FrameOpDeviceLost; } @@ -2862,6 +2884,7 @@ QRhi::FrameOpResult QRhiVulkan::startPrimaryCommandBuffer(VkCommandBuffer *cb) if (err != VK_SUCCESS) { if (err == VK_ERROR_DEVICE_LOST) { qWarning("Device loss detected in vkAllocateCommandBuffers()"); + printExtraErrorInfo(err); deviceLost = true; return QRhi::FrameOpDeviceLost; } @@ -2877,6 +2900,7 @@ QRhi::FrameOpResult QRhiVulkan::startPrimaryCommandBuffer(VkCommandBuffer *cb) if (err != VK_SUCCESS) { if (err == VK_ERROR_DEVICE_LOST) { qWarning("Device loss detected in vkBeginCommandBuffer()"); + printExtraErrorInfo(err); deviceLost = true; return QRhi::FrameOpDeviceLost; } @@ -2894,6 +2918,7 @@ QRhi::FrameOpResult QRhiVulkan::endAndSubmitPrimaryCommandBuffer(VkCommandBuffer if (err != VK_SUCCESS) { if (err == VK_ERROR_DEVICE_LOST) { qWarning("Device loss detected in vkEndCommandBuffer()"); + printExtraErrorInfo(err); deviceLost = true; return QRhi::FrameOpDeviceLost; } @@ -2930,6 +2955,7 @@ QRhi::FrameOpResult QRhiVulkan::endAndSubmitPrimaryCommandBuffer(VkCommandBuffer if (err != VK_SUCCESS) { if (err == VK_ERROR_DEVICE_LOST) { qWarning("Device loss detected in vkQueueSubmit()"); + printExtraErrorInfo(err); deviceLost = true; return QRhi::FrameOpDeviceLost; } @@ -2951,6 +2977,7 @@ QRhi::FrameOpResult QRhiVulkan::waitCommandCompletion(int frameSlot) if (err != VK_SUCCESS) { if (err == VK_ERROR_DEVICE_LOST) { qWarning("Device loss detected in vkWaitForFences()"); + printExtraErrorInfo(err); deviceLost = true; return QRhi::FrameOpDeviceLost; } @@ -4079,10 +4106,87 @@ void QRhiVulkan::prepareUploadSubres(QVkTexture *texD, int layer, int level, void QRhiVulkan::printExtraErrorInfo(VkResult err) { + if (err == VK_ERROR_DEVICE_LOST) + printDeviceLossErrorInfo(); if (err == VK_ERROR_OUT_OF_DEVICE_MEMORY) qWarning() << "Out of device memory, current allocator statistics are" << statistics(); } +void QRhiVulkan::printDeviceLossErrorInfo() const +{ +#ifdef VK_EXT_device_fault + if (!dev || !caps.deviceFault || !vkGetDeviceFaultInfoEXT) + return; + + VkDeviceFaultCountsEXT faultCounts{}; + faultCounts.sType = VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT; + faultCounts.pNext = nullptr; + + VkResult result = vkGetDeviceFaultInfoEXT(dev, &faultCounts, nullptr); + if (result != VK_SUCCESS && result != VK_INCOMPLETE) { + qWarning("vkGetDeviceFaultInfoEXT failed with %d", result); + return; + } + faultCounts.vendorBinarySize = 0; + + QVarLengthArray<VkDeviceFaultAddressInfoEXT> addressInfos; + addressInfos.resize(faultCounts.addressInfoCount); + + QVarLengthArray<VkDeviceFaultVendorInfoEXT> vendorInfos; + vendorInfos.resize(faultCounts.vendorInfoCount); + + VkDeviceFaultInfoEXT info{}; + info.sType = VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT; + info.pNext = nullptr; + info.pAddressInfos = addressInfos.isEmpty() ? nullptr : addressInfos.data(); + info.pVendorInfos = vendorInfos.isEmpty() ? nullptr : vendorInfos.data(); + info.pVendorBinaryData = nullptr; + + result = vkGetDeviceFaultInfoEXT(dev, &faultCounts, &info); + if (result != VK_SUCCESS && result != VK_INCOMPLETE) { + qWarning("vkGetDeviceFaultInfoEXT failed with %d", result); + return; + } + + const char *desc = info.description[0] ? info.description : "n/a"; + qWarning("VK_ERROR_DEVICE_LOST (VK_EXT_device_fault): %u address infos, %u vendor infos, %llu bytes vendor binary: %s", + faultCounts.addressInfoCount, + faultCounts.vendorInfoCount, + (unsigned long long)faultCounts.vendorBinarySize, + desc); + + for (uint32_t i = 0; i < faultCounts.addressInfoCount; ++i) { + const auto &a = addressInfos[i]; + auto addressTypeString = [](const VkDeviceFaultAddressTypeEXT type) { + switch (type) { + case VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT: return "NONE"; + case VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT: return "READ_INVALID"; + case VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT: return "WRITE_INVALID"; + case VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT: return "EXECUTE_INVALID"; + case VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT: return "INSTRUCTION_POINTER_UNKNOWN"; + case VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT: return "INSTRUCTION_POINTER_INVALID"; + case VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT: return "INSTRUCTION_POINTER_FAULT"; + default: return "UNKNOWN"; + }; + }; + qWarning(" AddressInfo[%02u]: type=%s addr=0x%llx precision=%llu", + i, + addressTypeString(a.addressType), + (unsigned long long)a.reportedAddress, + (unsigned long long)a.addressPrecision); + } + + for (uint32_t i = 0; i < faultCounts.vendorInfoCount; ++i) { + const auto &v = vendorInfos[i]; + qWarning(" VendorInfo[%02u]: code=%llu data=%llu desc=%s", + i, + (unsigned long long)v.vendorFaultCode, + (unsigned long long)v.vendorFaultData, + v.description); + } +#endif // VK_EXT_device_fault +} + void QRhiVulkan::enqueueResourceUpdates(QVkCommandBuffer *cbD, QRhiResourceUpdateBatch *resourceUpdates) { QRhiResourceUpdateBatchPrivate *ud = QRhiResourceUpdateBatchPrivate::get(resourceUpdates); diff --git a/src/gui/rhi/qrhivulkan_p.h b/src/gui/rhi/qrhivulkan_p.h index 21044545ad2..eb07d8be448 100644 --- a/src/gui/rhi/qrhivulkan_p.h +++ b/src/gui/rhi/qrhivulkan_p.h @@ -882,6 +882,7 @@ public: void ensureCommandPoolForNewFrame(); double elapsedSecondsFromTimestamp(quint64 timestamp[2], bool *ok); void printExtraErrorInfo(VkResult err); + void printDeviceLossErrorInfo() const; QVulkanInstance *inst = nullptr; QWindow *maybeWindow = nullptr; @@ -942,11 +943,16 @@ public: PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = nullptr; #endif +#ifdef VK_EXT_device_fault + PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT = nullptr; +#endif + struct { bool compute = false; bool depthClamp = false; bool wideLines = false; bool debugUtils = false; + bool deviceFault = false; bool vertexAttribDivisor = false; bool texture3DSliceAs2D = false; bool tessellation = false; diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp index c144820fa24..ba49d538c2c 100644 --- a/src/gui/text/qfont.cpp +++ b/src/gui/text/qfont.cpp @@ -31,6 +31,7 @@ #include <QtCore/QMutexLocker> #include <QtCore/QMutex> +#include <algorithm> #include <array> // #define QFONTCACHE_DEBUG @@ -1853,35 +1854,13 @@ bool QFont::operator<(const QFont &f) const int f2attrs = (d->underline << 3) + (d->overline << 2) + (d->strikeOut<<1) + d->kerning; if (f1attrs != f2attrs) return f1attrs < f2attrs; - if (d->features.size() != f.d->features.size()) - return f.d->features.size() < d->features.size(); - - { - auto it = d->features.constBegin(); - auto jt = f.d->features.constBegin(); - for (; it != d->features.constEnd(); ++it, ++jt) { - if (it.key() != jt.key()) - return jt.key() < it.key(); - if (it.value() != jt.value()) - return jt.value() < it.value(); - } - } - - if (r1.variableAxisValues.size() != r2.variableAxisValues.size()) - return r1.variableAxisValues.size() < r2.variableAxisValues.size(); - - { - auto it = r1.variableAxisValues.constBegin(); - auto jt = r2.variableAxisValues.constBegin(); - for (; it != r1.variableAxisValues.constEnd(); ++it, ++jt) { - if (it.key() != jt.key()) - return jt.key() < it.key(); - if (it.value() != jt.value()) - return jt.value() < it.value(); - } + if (d->features != f.d->features) { + return std::lexicographical_compare(f.d->features.keyValueBegin(), f.d->features.keyValueEnd(), + d->features.keyValueBegin(), d->features.keyValueEnd()); } - return false; + return std::lexicographical_compare(r1.variableAxisValues.keyValueBegin(), r1.variableAxisValues.keyValueEnd(), + r2.variableAxisValues.keyValueBegin(), r2.variableAxisValues.keyValueEnd()); } diff --git a/src/gui/text/qfontengine.cpp b/src/gui/text/qfontengine.cpp index 0ad45b1f280..d41296291f6 100644 --- a/src/gui/text/qfontengine.cpp +++ b/src/gui/text/qfontengine.cpp @@ -402,7 +402,7 @@ bool QFontEngine::processHheaTable() const const qreal unitsPerEm = emSquareSize().toReal(); // Bail out if values are too large for QFixed - const auto limitForQFixed = std::numeric_limits<int>::max() / (fontDef.pixelSize * 64); + const auto limitForQFixed = qreal(std::numeric_limits<int>::max() / 64) / fontDef.pixelSize; if (ascent > limitForQFixed || descent > limitForQFixed || leading > limitForQFixed) return false; m_ascent = QFixed::fromReal(ascent * fontDef.pixelSize / unitsPerEm); @@ -470,7 +470,7 @@ bool QFontEngine::processOS2Table() const if (typoAscent == 0 && typoDescent == 0) return false; // Bail out if values are too large for QFixed - const auto limitForQFixed = std::numeric_limits<int>::max() / (fontDef.pixelSize * 64); + const auto limitForQFixed = qreal(std::numeric_limits<int>::max() / 64) / fontDef.pixelSize; if (typoAscent > limitForQFixed || typoDescent > limitForQFixed || typoLineGap > limitForQFixed) return false; @@ -481,7 +481,7 @@ bool QFontEngine::processOS2Table() const // Some fonts may have invalid OS/2 data. We detect this and bail out. if (winAscent == 0 && winDescent == 0) return false; - const auto limitForQFixed = std::numeric_limits<int>::max() / (fontDef.pixelSize * 64); + const auto limitForQFixed = qreal(std::numeric_limits<int>::max() / 64) / fontDef.pixelSize; if (winAscent > limitForQFixed || winDescent > limitForQFixed) return false; m_ascent = QFixed::fromReal(winAscent * fontDef.pixelSize / unitsPerEm); diff --git a/src/gui/text/qtextdocument.cpp b/src/gui/text/qtextdocument.cpp index eb0f6c3710c..4f01d09fed1 100644 --- a/src/gui/text/qtextdocument.cpp +++ b/src/gui/text/qtextdocument.cpp @@ -1976,7 +1976,7 @@ void QTextDocument::print(QPagedPaintDevice *printer) const return; bool documentPaginated = d->pageSize.isValid() && !d->pageSize.isNull() - && d->pageSize.height() != INT_MAX; + && d->pageSize.height() != qreal(INT_MAX); // ### set page size to paginated size? QMarginsF m = printer->pageLayout().margins(QPageLayout::Millimeter); diff --git a/src/gui/text/windows/qwindowsfontdatabase.cpp b/src/gui/text/windows/qwindowsfontdatabase.cpp index 93af1a9600b..0c6d9a31316 100644 --- a/src/gui/text/windows/qwindowsfontdatabase.cpp +++ b/src/gui/text/windows/qwindowsfontdatabase.cpp @@ -1113,17 +1113,21 @@ void QWindowsFontDatabase::removeApplicationFonts() m_eudcFonts.clear(); } +#if QT_CONFIG(directwrite) QWindowsFontDatabase::FontHandle::FontHandle(IDWriteFontFace *face, const QString &name) : fontFace(face), faceName(name) { fontFace->AddRef(); } +#endif // !QT_NO_DIRECTWRITE QWindowsFontDatabase::FontHandle::~FontHandle() { +#if QT_CONFIG(directwrite) if (fontFace != nullptr) fontFace->Release(); +#endif // !QT_NO_DIRECTWRITE } void QWindowsFontDatabase::releaseHandle(void *handle) diff --git a/src/gui/text/windows/qwindowsfontdatabase_p.h b/src/gui/text/windows/qwindowsfontdatabase_p.h index 92e3f04f968..856a5593722 100644 --- a/src/gui/text/windows/qwindowsfontdatabase_p.h +++ b/src/gui/text/windows/qwindowsfontdatabase_p.h @@ -78,10 +78,14 @@ public: struct FontHandle { FontHandle(const QString &name) : faceName(name) {} +#if QT_CONFIG(directwrite) FontHandle(IDWriteFontFace *face, const QString &name); +#endif // !QT_NO_DIRECTWRITE ~FontHandle(); +#if QT_CONFIG(directwrite) IDWriteFontFace *fontFace = nullptr; +#endif // !QT_NO_DIRECTWRITE QString faceName; }; diff --git a/src/network/access/qformdatabuilder.cpp b/src/network/access/qformdatabuilder.cpp index 470e285c6ad..debefd24634 100644 --- a/src/network/access/qformdatabuilder.cpp +++ b/src/network/access/qformdatabuilder.cpp @@ -9,6 +9,7 @@ #include "QtCore/qmimedatabase.h" #endif +#include <variant> #include <vector> QT_BEGIN_NAMESPACE diff --git a/src/network/access/qformdatabuilder.h b/src/network/access/qformdatabuilder.h index 7d667aea21c..3992776161d 100644 --- a/src/network/access/qformdatabuilder.h +++ b/src/network/access/qformdatabuilder.h @@ -15,7 +15,6 @@ #include <QtCore/qstring.h> #include <memory> -#include <variant> #ifndef Q_OS_WASM QT_REQUIRE_CONFIG(http); diff --git a/src/network/access/qhttpnetworkconnection_p.h b/src/network/access/qhttpnetworkconnection_p.h index f35b89d1aec..3f60c5b3925 100644 --- a/src/network/access/qhttpnetworkconnection_p.h +++ b/src/network/access/qhttpnetworkconnection_p.h @@ -259,7 +259,7 @@ public: QString peerVerifyName; - QTcpKeepAliveConfiguration tcpKeepAliveConfiguration; + QTcpKeepAliveConfiguration tcpKeepAliveConfiguration = {}; friend class QHttpNetworkConnectionChannel; }; diff --git a/src/network/access/qhttpthreaddelegate_p.h b/src/network/access/qhttpthreaddelegate_p.h index f179d95ac17..5005f8c01c2 100644 --- a/src/network/access/qhttpthreaddelegate_p.h +++ b/src/network/access/qhttpthreaddelegate_p.h @@ -92,7 +92,7 @@ public: QString incomingErrorDetail; QHttp1Configuration http1Parameters; QHttp2Configuration http2Parameters; - QTcpKeepAliveConfiguration tcpKeepAliveParameters; + QTcpKeepAliveConfiguration tcpKeepAliveParameters = {}; protected: // The zerocopy download buffer, if used: diff --git a/src/network/access/qnetworkaccesscache.cpp b/src/network/access/qnetworkaccesscache.cpp index bb1bdd87a8a..6ff70cd546d 100644 --- a/src/network/access/qnetworkaccesscache.cpp +++ b/src/network/access/qnetworkaccesscache.cpp @@ -5,11 +5,6 @@ #include "qnetworkaccesscache_p.h" #include "QtCore/qpointer.h" #include "QtCore/qdeadlinetimer.h" -#include "qnetworkaccessmanager_p.h" -#include "qnetworkreply_p.h" -#include "qnetworkrequest.h" - -#include <vector> //#define DEBUG_ACCESSCACHE diff --git a/src/network/access/qnetworkcookie.cpp b/src/network/access/qnetworkcookie.cpp index c20cd43a2fd..6c44e42dbba 100644 --- a/src/network/access/qnetworkcookie.cpp +++ b/src/network/access/qnetworkcookie.cpp @@ -5,7 +5,6 @@ #include "qnetworkcookie.h" #include "qnetworkcookie_p.h" -#include "qnetworkrequest.h" #include "qnetworkreply.h" #include "QtCore/qbytearray.h" #include "QtCore/qdatetime.h" diff --git a/src/plugins/platforms/cocoa/qcocoaglcontext.mm b/src/plugins/platforms/cocoa/qcocoaglcontext.mm index adad12a4242..be05249c1b8 100644 --- a/src/plugins/platforms/cocoa/qcocoaglcontext.mm +++ b/src/plugins/platforms/cocoa/qcocoaglcontext.mm @@ -265,19 +265,26 @@ void QCocoaGLContext::updateSurfaceFormat() return value; }; - int colorSize = pixelFormatAttribute(NSOpenGLPFAColorSize); - colorSize /= 4; // The attribute includes the alpha component - m_format.setRedBufferSize(colorSize); - m_format.setGreenBufferSize(colorSize); - m_format.setBlueBufferSize(colorSize); + // Resolve color channel bits from GL, rather than NSOpenGLPFAColorSize, + // as the latter is not specific enough (combines all channels). + GLint redBits, greenBits, blueBits; + glGetIntegerv(GL_RED_BITS, &redBits); + glGetIntegerv(GL_GREEN_BITS, &greenBits); + glGetIntegerv(GL_BLUE_BITS, &blueBits); + m_format.setRedBufferSize(redBits); + m_format.setGreenBufferSize(greenBits); + m_format.setBlueBufferSize(blueBits); // Surfaces on macOS always have an alpha channel, but unless the user requested // one via setAlphaBufferSize(), which triggered setting NSOpenGLCPSurfaceOpacity // to make the surface non-opaque, we don't want to report back the actual alpha // size, as that will make the user believe the alpha channel can be used for // something useful, when in reality it can't, due to the surface being opaque. - if (m_format.alphaBufferSize() > 0) - m_format.setAlphaBufferSize(pixelFormatAttribute(NSOpenGLPFAAlphaSize)); + if (m_format.alphaBufferSize() > 0) { + GLint alphaBits; + glGetIntegerv(GL_ALPHA_BITS, &alphaBits); + m_format.setAlphaBufferSize(alphaBits); + } m_format.setDepthBufferSize(pixelFormatAttribute(NSOpenGLPFADepthSize)); m_format.setStencilBufferSize(pixelFormatAttribute(NSOpenGLPFAStencilSize)); diff --git a/src/plugins/platforms/windows/qwindowsscreen.cpp b/src/plugins/platforms/windows/qwindowsscreen.cpp index 0236669d6fb..23bbe409caa 100644 --- a/src/plugins/platforms/windows/qwindowsscreen.cpp +++ b/src/plugins/platforms/windows/qwindowsscreen.cpp @@ -450,6 +450,26 @@ QPixmap QWindowsScreen::grabWindow(WId window, int xIn, int yIn, int width, int hwnd = GetDesktopWindow(); const QRect screenGeometry = geometry(); windowSize = screenGeometry.size(); + // When dpi awareness is not set to PerMonitor, windows reports primary display or dummy + // DPI for all displays, so xIn and yIn and windowSize are calculated with a wrong DPI, + // so we need to recalculate them using the actual screen size we get from + // EnumDisplaySettings api. + const auto dpiAwareness = QWindowsContext::instance()->processDpiAwareness(); + if (dpiAwareness != QtWindows::DpiAwareness::PerMonitor && + dpiAwareness != QtWindows::DpiAwareness::PerMonitorVersion2) { + MONITORINFOEX info = {}; + info.cbSize = sizeof(MONITORINFOEX); + if (GetMonitorInfo(handle(), &info)) { + DEVMODE dm = {}; + dm.dmSize = sizeof(dm); + if (EnumDisplaySettings(info.szDevice, ENUM_CURRENT_SETTINGS, &dm)) { + qreal scale = static_cast<qreal>(dm.dmPelsWidth) / windowSize.width(); + x = static_cast<int>(static_cast<qreal>(x) * scale); + y = static_cast<int>(static_cast<qreal>(y) * scale); + windowSize = QSize(dm.dmPelsWidth, dm.dmPelsHeight); + } + } + } x += screenGeometry.x(); y += screenGeometry.y(); } diff --git a/src/plugins/platforms/windows/qwindowswindow.cpp b/src/plugins/platforms/windows/qwindowswindow.cpp index b77e985c965..2816982b1a8 100644 --- a/src/plugins/platforms/windows/qwindowswindow.cpp +++ b/src/plugins/platforms/windows/qwindowswindow.cpp @@ -1732,8 +1732,10 @@ void QWindowsWindow::destroyWindow() m_surface = nullptr; } #endif + DestroyWindow(m_data.hwndTitlebar); DestroyWindow(m_data.hwnd); context->removeWindow(m_data.hwnd); + m_data.hwndTitlebar = nullptr; m_data.hwnd = nullptr; } } diff --git a/src/plugins/platforms/xcb/qxcbwindow.cpp b/src/plugins/platforms/xcb/qxcbwindow.cpp index 2c56603fef0..7d5f0155960 100644 --- a/src/plugins/platforms/xcb/qxcbwindow.cpp +++ b/src/plugins/platforms/xcb/qxcbwindow.cpp @@ -2573,7 +2573,7 @@ void QXcbWindow::setOpacity(qreal level) if (!m_window) return; - quint32 value = qRound64(qBound(qreal(0), level, qreal(1)) * 0xffffffff); + quint32 value = qRound64(qBound(qreal(0), level, qreal(1)) * qreal(0xffffffff)); xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, diff --git a/src/plugins/styles/modernwindows/qwindows11style.cpp b/src/plugins/styles/modernwindows/qwindows11style.cpp index 7caa352afe4..ff2d4bd845f 100644 --- a/src/plugins/styles/modernwindows/qwindows11style.cpp +++ b/src/plugins/styles/modernwindows/qwindows11style.cpp @@ -914,12 +914,17 @@ void QWindows11Style::drawPrimitive(PrimitiveElement element, const QStyleOption break; case PE_IndicatorBranch: { if (option->state & State_Children) { + const QStyleOptionViewItem *vopt = qstyleoption_cast<const QStyleOptionViewItem *>(option); const bool isReverse = option->direction == Qt::RightToLeft; const bool isOpen = option->state & QStyle::State_Open; + const QAbstractItemView *view = qobject_cast<const QAbstractItemView *>(widget); QFont f(d->assetFont); f.setPointSize(8); painter->setFont(f); - painter->setPen(option->palette.color(isOpen ? QPalette::Active : QPalette::Disabled, + if (view && view->alternatingRowColors() && vopt && vopt->state & State_Selected) + painter->setPen(winUI3Color(textOnAccentPrimary)); + else + painter->setPen(option->palette.color(isOpen ? QPalette::Active : QPalette::Disabled, QPalette::WindowText)); const auto ico = isOpen ? Icon::ChevronDownMed : (isReverse ? Icon::ChevronLeftMed @@ -1071,14 +1076,16 @@ void QWindows11Style::drawPrimitive(PrimitiveElement element, const QStyleOption if (option->state & State_Selected && !highContrastTheme) { // keep in sync with CE_ItemViewItem QListView indicator painting - const auto col = option->palette.accent().color(); - painter->setBrush(col); - painter->setPen(col); - const auto xPos = isRtl ? rect.right() - 4.5f : rect.left() + 3.5f; - const auto yOfs = rect.height() / 4.; - QRectF r(QPointF(xPos, rect.y() + yOfs), - QPointF(xPos + 1, rect.y() + rect.height() - yOfs)); - painter->drawRoundedRect(r, 1, 1); + if (!qobject_cast<const QTableView *>(widget)) { + const auto col = option->palette.accent().color(); + painter->setBrush(col); + painter->setPen(col); + const auto xPos = isRtl ? rect.right() - 4.5f : rect.left() + 3.5f; + const auto yOfs = rect.height() / 4.; + QRectF r(QPointF(xPos, rect.y() + yOfs), + QPointF(xPos + 1, rect.y() + rect.height() - yOfs)); + painter->drawRoundedRect(r, 1, 1); + } } const bool isTreeDecoration = vopt->features.testFlag( @@ -1099,7 +1106,7 @@ void QWindows11Style::drawPrimitive(PrimitiveElement element, const QStyleOption } const QAbstractItemView *view = qobject_cast<const QAbstractItemView *>(widget); - painter->setBrush(view->alternatingRowColors() ? vopt->palette.highlight() : WINUI3Colors[colorSchemeIndex][subtleHighlightColor]); + painter->setBrush(view->alternatingRowColors() && state & State_Selected ? calculateAccentColor(option) : WINUI3Colors[colorSchemeIndex][subtleHighlightColor]); painter->setPen(Qt::NoPen); if (isFirst) { QPainterStateGuard psg(painter); @@ -1753,13 +1760,13 @@ void QWindows11Style::drawControl(ControlElement element, const QStyleOption *op } } const bool highlightCurrent = vopt->state.testAnyFlags(State_Selected | State_MouseOver); + const QAbstractItemView *view = qobject_cast<const QAbstractItemView *>(widget); if (highlightCurrent) { if (highContrastTheme) { painter->setBrush(vopt->palette.highlight()); } else { - const QAbstractItemView *view = qobject_cast<const QAbstractItemView *>(widget); - painter->setBrush(view && view->alternatingRowColors() - ? vopt->palette.highlight() + painter->setBrush(view && view->alternatingRowColors() && vopt->state & State_Selected + ? calculateAccentColor(option) : winUI3Color(subtleHighlightColor)); } } else { @@ -1815,8 +1822,13 @@ void QWindows11Style::drawControl(ControlElement element, const QStyleOption *op vopt->icon.paint(painter, iconRect, vopt->decorationAlignment, mode, state); } - painter->setPen(highlightCurrent && highContrastTheme ? vopt->palette.base().color() - : vopt->palette.text().color()); + if (highlightCurrent && highContrastTheme) { + painter->setPen(vopt->palette.base().color()); + } else if ((view && view->alternatingRowColors() && highlightCurrent && vopt->state & State_Selected)) { + painter->setPen(winUI3Color(textOnAccentPrimary)); + } else { + painter->setPen(vopt->palette.text().color()); + } d->viewItemDrawText(painter, vopt, textRect); // paint a vertical marker for QListView diff --git a/src/widgets/CMakeLists.txt b/src/widgets/CMakeLists.txt index d43b6ec4fb2..c47e3bee13c 100644 --- a/src/widgets/CMakeLists.txt +++ b/src/widgets/CMakeLists.txt @@ -412,7 +412,7 @@ qt_internal_extend_target(Widgets CONDITION QT_FEATURE_shortcut qt_internal_extend_target(Widgets CONDITION QT_FEATURE_tooltip SOURCES - kernel/qtooltip.cpp kernel/qtooltip.h + kernel/qtooltip.cpp kernel/qtooltip.h kernel/qtooltip_p.h ) qt_internal_extend_target(Widgets CONDITION QT_FEATURE_whatsthis diff --git a/src/widgets/dialogs/qcolordialog.cpp b/src/widgets/dialogs/qcolordialog.cpp index d51c408ab5c..ce46170bba5 100644 --- a/src/widgets/dialogs/qcolordialog.cpp +++ b/src/widgets/dialogs/qcolordialog.cpp @@ -662,7 +662,7 @@ private: int val2y(int val); void setVal(int v); - QPixmap *pix; + QPixmap pix; }; @@ -682,14 +682,12 @@ QColorLuminancePicker::QColorLuminancePicker(QWidget* parent) :QWidget(parent) { hue = 100; val = 100; sat = 100; - pix = nullptr; // setAttribute(WA_NoErase, true); setFocusPolicy(Qt::StrongFocus); } QColorLuminancePicker::~QColorLuminancePicker() { - delete pix; } void QColorLuminancePicker::keyPressEvent(QKeyEvent *event) @@ -725,7 +723,7 @@ void QColorLuminancePicker::setVal(int v) if (val == v) return; val = qMax(0, qMin(v,255)); - delete pix; pix=nullptr; + pix = QPixmap(); repaint(); emit newHsv(hue, sat, val); } @@ -744,8 +742,7 @@ void QColorLuminancePicker::paintEvent(QPaintEvent *) QRect r(0, foff, w, height() - 2*foff); int wi = r.width() - 2; int hi = r.height() - 2; - if (!pix || pix->height() != hi || pix->width() != wi) { - delete pix; + if (pix.isNull() || pix.height() != hi || pix.width() != wi) { QImage img(wi, hi, QImage::Format_RGB32); int y; uint *pixel = (uint *) img.scanLine(0); @@ -754,10 +751,10 @@ void QColorLuminancePicker::paintEvent(QPaintEvent *) std::fill(pixel, end, QColor::fromHsv(hue, sat, y2val(y + coff)).rgb()); pixel = end; } - pix = new QPixmap(QPixmap::fromImage(img)); + pix = QPixmap::fromImage(img); } QPainter p(this); - p.drawPixmap(1, coff, *pix); + p.drawPixmap(1, coff, pix); const QPalette &g = palette(); qDrawShadePanel(&p, r, g, true); p.setPen(g.windowText().color()); @@ -773,7 +770,7 @@ void QColorLuminancePicker::setCol(int h, int s , int v) val = v; hue = h; sat = s; - delete pix; pix=nullptr; + pix = QPixmap(); repaint(); } diff --git a/src/widgets/kernel/qtooltip.cpp b/src/widgets/kernel/qtooltip.cpp index fa17c94a23f..3417d93d587 100644 --- a/src/widgets/kernel/qtooltip.cpp +++ b/src/widgets/kernel/qtooltip.cpp @@ -29,6 +29,7 @@ #include <qtooltip.h> #include <QtCore/qbasictimer.h> +#include <QtWidgets/private/qtooltip_p.h> QT_BEGIN_NAMESPACE @@ -93,57 +94,6 @@ using namespace Qt::StringLiterals; \sa QWidget::toolTip, QAction::toolTip */ -class QTipLabel : public QLabel -{ - Q_OBJECT -public: - QTipLabel(const QString &text, const QPoint &pos, QWidget *w, int msecDisplayTime); - ~QTipLabel(); - static QTipLabel *instance; - - void adjustTooltipScreen(const QPoint &pos); - void updateSize(const QPoint &pos); - - bool eventFilter(QObject *, QEvent *) override; - - QBasicTimer hideTimer, expireTimer; - - bool fadingOut; - - void reuseTip(const QString &text, int msecDisplayTime, const QPoint &pos); - void hideTip(); - void hideTipImmediately(); - void setTipRect(QWidget *w, const QRect &r); - void restartExpireTimer(int msecDisplayTime); - bool tipChanged(const QPoint &pos, const QString &text, QObject *o); - void placeTip(const QPoint &pos, QWidget *w); - - static QScreen *getTipScreen(const QPoint &pos, QWidget *w); -protected: - void timerEvent(QTimerEvent *e) override; - void paintEvent(QPaintEvent *e) override; - void mouseMoveEvent(QMouseEvent *e) override; - void resizeEvent(QResizeEvent *e) override; - -#if QT_CONFIG(style_stylesheet) -public slots: - /** \internal - Cleanup the _q_stylesheet_parent property. - */ - void styleSheetParentDestroyed() { - setProperty("_q_stylesheet_parent", QVariant()); - styleSheetParent = nullptr; - } - -private: - QWidget *styleSheetParent; -#endif - -private: - QWidget *widget; - QRect rect; -}; - QTipLabel *QTipLabel::instance = nullptr; QTipLabel::QTipLabel(const QString &text, const QPoint &pos, QWidget *w, int msecDisplayTime) @@ -152,6 +102,7 @@ QTipLabel::QTipLabel(const QString &text, const QPoint &pos, QWidget *w, int mse , styleSheetParent(nullptr) #endif , widget(nullptr) + , fadingOut(false) { delete instance; instance = this; @@ -166,7 +117,6 @@ QTipLabel::QTipLabel(const QString &text, const QPoint &pos, QWidget *w, int mse qApp->installEventFilter(this); setWindowOpacity(style()->styleHint(QStyle::SH_ToolTipLabel_Opacity, nullptr, this) / 255.0); setMouseTracking(true); - fadingOut = false; reuseTip(text, msecDisplayTime, pos); } @@ -433,6 +383,15 @@ bool QTipLabel::tipChanged(const QPoint &pos, const QString &text, QObject *o) return false; } +/** \internal + Cleanup the _q_stylesheet_parent property. + */ +void QTipLabel::styleSheetParentDestroyed() +{ + setProperty("_q_stylesheet_parent", QVariant()); + styleSheetParent = nullptr; +} + /*! Shows \a text as a tool tip, with the global position \a pos as the point of interest. The tool tip will be shown with a platform @@ -594,4 +553,4 @@ void QToolTip::setFont(const QFont &font) QT_END_NAMESPACE -#include "qtooltip.moc" +#include "moc_qtooltip_p.cpp" diff --git a/src/widgets/kernel/qtooltip_p.h b/src/widgets/kernel/qtooltip_p.h new file mode 100644 index 00000000000..51faaf58c34 --- /dev/null +++ b/src/widgets/kernel/qtooltip_p.h @@ -0,0 +1,74 @@ +// Copyright (C) 2016 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 QTOOLTIP_P_H +#define QTOOLTIP_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of qlayout*.cpp, and qabstractlayout.cpp. This header +// file may change from version to version without notice, or even be removed. +// +// We mean it. +// + +#include <QLabel> +#include <QString> +#include <QRect> +#include <QToolTip> + +QT_REQUIRE_CONFIG(tooltip); +QT_BEGIN_NAMESPACE + +class Q_WIDGETS_EXPORT QTipLabel final : public QLabel +{ + Q_OBJECT +public: + explicit QTipLabel(const QString &text, const QPoint &pos, QWidget *w, int msecDisplayTime); + ~QTipLabel() override; + + void adjustTooltipScreen(const QPoint &pos); + void updateSize(const QPoint &pos); + + bool eventFilter(QObject *, QEvent *) override; + + void reuseTip(const QString &text, int msecDisplayTime, const QPoint &pos); + void hideTip(); + void hideTipImmediately(); + void setTipRect(QWidget *w, const QRect &r); + void restartExpireTimer(int msecDisplayTime); + bool tipChanged(const QPoint &pos, const QString &text, QObject *o); + void placeTip(const QPoint &pos, QWidget *w); + + static QScreen *getTipScreen(const QPoint &pos, QWidget *w); +protected: + void timerEvent(QTimerEvent *e) override; + void paintEvent(QPaintEvent *e) override; + void mouseMoveEvent(QMouseEvent *e) override; + void resizeEvent(QResizeEvent *e) override; + +#if QT_CONFIG(style_stylesheet) +public Q_SLOTS: + void styleSheetParentDestroyed(); + +private: + QWidget *styleSheetParent; +#endif + +private: + friend class QToolTip; + + static QTipLabel *instance; + QBasicTimer hideTimer, expireTimer; + QWidget *widget; + QRect rect; + bool fadingOut; +}; + +QT_END_NAMESPACE + +#endif // QTOOLTIP_P_H diff --git a/tests/auto/corelib/animation/qparallelanimationgroup/tst_qparallelanimationgroup.cpp b/tests/auto/corelib/animation/qparallelanimationgroup/tst_qparallelanimationgroup.cpp index c2c09a234c8..d134afc4323 100644 --- a/tests/auto/corelib/animation/qparallelanimationgroup/tst_qparallelanimationgroup.cpp +++ b/tests/auto/corelib/animation/qparallelanimationgroup/tst_qparallelanimationgroup.cpp @@ -463,9 +463,7 @@ void tst_QParallelAnimationGroup::deleteChildrenWithRunningGroup() QCOMPARE(group.state(), QAnimationGroup::Running); QCOMPARE(anim1->state(), QAnimationGroup::Running); - QTest::qWaitFor([&]{ - return group.currentLoopTime() > 0; - }, 200ms); + QVERIFY(QTest::qWaitFor([&] { return group.currentLoopTime() > 0; }, 200ms)); delete anim1; QCOMPARE(group.animationCount(), 0); diff --git a/tests/auto/corelib/itemmodels/qrangemodeladapter/tst_qrangemodeladapter.cpp b/tests/auto/corelib/itemmodels/qrangemodeladapter/tst_qrangemodeladapter.cpp index 4124b723b4c..ef4a535dcac 100644 --- a/tests/auto/corelib/itemmodels/qrangemodeladapter/tst_qrangemodeladapter.cpp +++ b/tests/auto/corelib/itemmodels/qrangemodeladapter/tst_qrangemodeladapter.cpp @@ -1025,8 +1025,18 @@ void tst_QRangeModelAdapter::modelReset() QCOMPARE(adapter[0], 3); QCOMPARE(adapter, (std::vector<int>{3, 2, 1})); + modelAboutToBeResetSpy.clear(); + modelResetSpy.clear(); std::vector<int> modifiedData = adapter; + + adapter.assign(modifiedData.begin(), modifiedData.end()); + QCOMPARE(modelResetSpy.count(), 1); + adapter.setRange(std::vector<int>{3, 2, 1}); + QCOMPARE(modelResetSpy.count(), 2); + std::vector<short> shorts = {10, 11, 12}; + adapter.assign(shorts.begin(), shorts.end()); + QCOMPARE(modelResetSpy.count(), 3); } { @@ -1533,7 +1543,7 @@ void tst_QRangeModelAdapter::tableWriteAccess() QTest::ignoreMessage(QtCriticalMsg, QRegularExpression("Not able to assign QVariant")); QTest::ignoreMessage(QtWarningMsg, QRegularExpression("Writing value of type Object\\* to " - "role Qt::RangeModelAdapterRole at index .* of the model failed")); + "role Qt::RangeModelAdapterRole at index .* failed")); #endif adapter.at(0, 0) = new Object; QCOMPARE(dataChangedSpy.count(), 0); @@ -2620,11 +2630,35 @@ using ObjectTree = std::vector<ObjectTreeItem>; class ObjectTreeItem : public ObjectRow { public: - ObjectTreeItem(Object *item = nullptr) + ObjectTreeItem() = default; + + explicit ObjectTreeItem(Object *item) { m_objects[0] = item; } + ObjectTreeItem(const ObjectTreeItem &other) = delete; + ObjectTreeItem &operator=(const ObjectTreeItem &other) = delete; + ObjectTreeItem(ObjectTreeItem &&other) noexcept + { + m_children = std::move(other.m_children); + m_objects = std::move(other.m_objects); + other.m_objects = {}; + } + + ObjectTreeItem &operator=(ObjectTreeItem &&other) noexcept + { + m_children = std::move(other.m_children); + m_objects = std::move(other.m_objects); + other.m_objects = {}; + return *this; + } + + ~ObjectTreeItem() + { + qDeleteAll(m_objects); + } + ObjectTreeItem *parentRow() const { return m_parentRow; } void setParentRow(ObjectTreeItem *parentRow) { m_parentRow = parentRow; } const auto &childRows() const { return m_children; } @@ -2646,9 +2680,7 @@ namespace std { void tst_QRangeModelAdapter::insertAutoConnectObjects() { - ObjectTree emptyTree; - - QRangeModelAdapter adapter(emptyTree); + QRangeModelAdapter adapter(ObjectTree{}); QSignalSpy dataChangedSpy(adapter.model(), &QAbstractItemModel::dataChanged); adapter.model()->setAutoConnectPolicy(QRangeModel::AutoConnectPolicy::Full); @@ -2662,11 +2694,11 @@ void tst_QRangeModelAdapter::insertAutoConnectObjects() Object *newChild = new Object; auto firstRow = adapter.begin(); - (*firstRow).children() = ObjectTree{ - ObjectTreeItem(newChild), - ObjectTreeItem(), - ObjectTreeItem() - }; + { + ObjectTree children(3); + children[0] = ObjectTreeItem(newChild); + (*firstRow).children() = std::move(children); + } QCOMPARE(dataChangedSpy.count(), 0); QVERIFY(adapter.hasChildren(0)); newChild->setString("0.0"); @@ -2684,12 +2716,14 @@ void tst_QRangeModelAdapter::insertAutoConnectObjects() newChild = new Object; Object *newGrandChild = new Object; ObjectTreeItem newBranch(newChild); - newBranch.childRows() = ObjectTree{ - ObjectTreeItem(), // skip the first row to verify that we continue through nullptr - ObjectTreeItem(newGrandChild), - ObjectTreeItem() - }; - adapter.at({0, 2}) = newBranch; + { + ObjectTree children(3); + // skip the first row to verify that we continue through nullptr + children[1] = ObjectTreeItem(newGrandChild); + newBranch.childRows() = std::move(children); + } + adapter.at({0, 2}) = std::move(newBranch); + QCOMPARE(adapter.rowCount({0, 2}), 3); QCOMPARE(dataChangedSpy.count(), 1); newChild->setNumber(1); QCOMPARE(dataChangedSpy.count(), 2); diff --git a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp index 2fcfd056882..a30ed901fe6 100644 --- a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp +++ b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp @@ -6,6 +6,8 @@ #include <qvariant.h> #include <QtCore/qttypetraits.h> +#include <QtCore/qsequentialiterable.h> +#include <QtCore/qassociativeiterable.h> // don't assume <type_traits> template <typename T, typename U> @@ -5025,7 +5027,7 @@ void sortIterable(QMetaSequence::Iterable *iterable) } template<typename Container> -static void testSequentialIteration() +static void testMetaSequenceIteration() { QFETCH(bool, hasSizeAccessor); QFETCH(bool, hasIndexedAccessors); @@ -5157,7 +5159,7 @@ static void testSequentialIteration() } template<typename Container> -static void testAssociativeIteration() +static void testMetaAssociationIteration() { using Key = typename Container::key_type; using Mapped = typename Container::mapped_type; @@ -5228,12 +5230,268 @@ static void testAssociativeIteration() QCOMPARE(f, iter.constEnd()); } +#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && QT_DEPRECATED_SINCE(6, 15) +QT_WARNING_PUSH +QT_WARNING_DISABLE_DEPRECATED + +template<typename Iterator> +void sortIterable(QSequentialIterable *iterable) +{ + std::sort(Iterator(iterable->mutableBegin()), Iterator(iterable->mutableEnd()), + [&](const QVariant &a, const QVariant &b) { + return a.toInt() < b.toInt(); + }); +} + +template<typename Container> +static void testSequentialIteration() +{ + QFETCH(bool, hasSizeAccessor); + const auto ignoreSizeWarning = [hasSizeAccessor]() { + if (hasSizeAccessor) + return; + QTest::ignoreMessage( + QtWarningMsg, + "size() called on an iterable without native size accessor. This is slow"); + }; + QTest::failOnWarning(); + + int numSeen = 0; + Container sequence; + ContainerAPI<Container>::insert(sequence, 1); + ContainerAPI<Container>::insert(sequence, 2); + ContainerAPI<Container>::insert(sequence, 3); + + QVariant listVariant = QVariant::fromValue(sequence); + QVERIFY(listVariant.canConvert<QVariantList>()); + QVariantList varList = listVariant.value<QVariantList>(); + ignoreSizeWarning(); + QCOMPARE(varList.size(), (int)std::distance(sequence.begin(), sequence.end())); + QSequentialIterable listIter = listVariant.view<QSequentialIterable>(); + ignoreSizeWarning(); + QCOMPARE(varList.size(), listIter.size()); + + typename Container::iterator containerIter = sequence.begin(); + const typename Container::iterator containerEnd = sequence.end(); + ignoreSizeWarning(); + for (int i = 0, end = listIter.size(); i < end; ++i, ++containerIter, ++numSeen) + { + QVERIFY(ContainerAPI<Container >::compare(listIter.at(i), *containerIter)); + QVERIFY(ContainerAPI<Container >::compare(listIter.at(i), varList.at(i))); + } + QCOMPARE(numSeen, (int)std::distance(sequence.begin(), sequence.end())); + QCOMPARE(containerIter, containerEnd); + + numSeen = 0; + containerIter = sequence.begin(); + for (QVariant v : listIter) { + QVERIFY(ContainerAPI<Container>::compare(v, *containerIter)); + QVERIFY(ContainerAPI<Container>::compare(v, varList.at(numSeen))); + ++containerIter; + ++numSeen; + } + QCOMPARE(numSeen, (int)std::distance(sequence.begin(), sequence.end())); + + auto compareLists = [&]() { + int numSeen = 0; + auto varList = listVariant.value<QVariantList>(); + auto varIter = varList.begin(); + for (const QVariant &v : std::as_const(listIter)) { + QVERIFY(ContainerAPI<Container>::compare(v, *varIter)); + ++varIter; + ++numSeen; + } + QCOMPARE(varIter, varList.end()); + numSeen = 0; + auto constVarIter = varList.constBegin(); + for (QVariant v : listIter) { + QVERIFY(ContainerAPI<Container>::compare(v, *constVarIter)); + ++constVarIter; + ++numSeen; + } + QCOMPARE(numSeen, (int)std::distance(varList.begin(), varList.end())); + }; + compareLists(); + + QVariant first = listIter.at(0); + QVariant second = listIter.at(1); + QVariant third = listIter.at(2); + compareLists(); + listIter.addValue(third); + compareLists(); + listIter.addValue(second); + compareLists(); + listIter.addValue(first); + compareLists(); + + QCOMPARE(listIter.size(), 6); + + if (listIter.canRandomAccessIterate()) + sortIterable<QSequentialIterable::RandomAccessIterator>(&listIter); + else if (listIter.canReverseIterate()) + sortIterable<QSequentialIterable::BidirectionalIterator>(&listIter); + else if (listIter.canForwardIterate()) + return; // std::sort cannot sort with only forward iterators. + else + QFAIL("The container has no meaningful iterators"); + + compareLists(); + ignoreSizeWarning(); + QCOMPARE(listIter.size(), 6); + QCOMPARE(listIter.at(0), first); + QCOMPARE(listIter.at(1), first); + QCOMPARE(listIter.at(2), second); + QCOMPARE(listIter.at(3), second); + QCOMPARE(listIter.at(4), third); + QCOMPARE(listIter.at(5), third); + + if (listIter.metaContainer().canRemoveValue()) { + listIter.removeValue(); + compareLists(); + ignoreSizeWarning(); + QCOMPARE(listIter.size(), 5); + QCOMPARE(listIter.at(0), first); + QCOMPARE(listIter.at(1), first); + QCOMPARE(listIter.at(2), second); + QCOMPARE(listIter.at(3), second); + QCOMPARE(listIter.at(4), third); + } else { + // QString and QByteArray have no pop_back or pop_front and it's unclear what other + // method we should use to remove an item. + QVERIFY((std::is_same_v<Container, QString> || std::is_same_v<Container, QByteArray>)); + } + + auto i = listIter.mutableBegin(); + QVERIFY(i != listIter.mutableEnd()); + + *i = QStringLiteral("17"); + if (listIter.metaContainer().valueMetaType() == QMetaType::fromType<int>()) + QCOMPARE(listIter.at(0).toInt(), 17); + else if (listIter.metaContainer().valueMetaType() == QMetaType::fromType<bool>()) + QCOMPARE(listIter.at(0).toBool(), false); + + *i = QStringLiteral("true"); + if (listIter.metaContainer().valueMetaType() == QMetaType::fromType<int>()) + QCOMPARE(listIter.at(0).toInt(), 0); + else if (listIter.metaContainer().valueMetaType() == QMetaType::fromType<bool>()) + QCOMPARE(listIter.at(0).toBool(), true); +} + +template<typename Container> +static void testAssociativeIteration() +{ + using Key = typename Container::key_type; + using Mapped = typename Container::mapped_type; + + int numSeen = 0; + Container mapping; + mapping[5] = true; + mapping[15] = false; + + QVariant mappingVariant = QVariant::fromValue(mapping); + QVariantMap varMap = mappingVariant.value<QVariantMap>(); + QVariantMap varHash = mappingVariant.value<QVariantMap>(); + QAssociativeIterable mappingIter = mappingVariant.view<QAssociativeIterable>(); + + typename Container::const_iterator containerIter = mapping.begin(); + const typename Container::const_iterator containerEnd = mapping.end(); + for ( ;containerIter != containerEnd; ++containerIter, ++numSeen) + { + Mapped expected = KeyGetter<Container>::value(containerIter); + Key key = KeyGetter<Container>::get(containerIter); + Mapped actual = qvariant_cast<Mapped>(mappingIter.value(key)); + QCOMPARE(qvariant_cast<Mapped>(varMap.value(QString::number(key))), expected); + QCOMPARE(qvariant_cast<Mapped>(varHash.value(QString::number(key))), expected); + QCOMPARE(actual, expected); + const QAssociativeIterable::const_iterator it = mappingIter.find(key); + QVERIFY(it != mappingIter.end()); + QCOMPARE(it.value().value<Mapped>(), expected); + } + QCOMPARE(numSeen, (int)std::distance(mapping.begin(), mapping.end())); + QCOMPARE(containerIter, containerEnd); + QVERIFY(mappingIter.find(10) == mappingIter.end()); + + auto i = mappingIter.mutableFind(QStringLiteral("nonono")); + QCOMPARE(i, mappingIter.mutableEnd()); + i = mappingIter.mutableFind(QStringLiteral("5")); + QVERIFY(i != mappingIter.mutableEnd()); + + *i = QStringLiteral("17"); + + if (mappingIter.metaContainer().mappedMetaType() == QMetaType::fromType<int>()) + QCOMPARE(mappingIter.value(5).toInt(), 17); + else if (mappingIter.metaContainer().mappedMetaType() == QMetaType::fromType<bool>()) + QCOMPARE(mappingIter.value(5).toBool(), true); + + *i = QStringLiteral("true"); + if (mappingIter.metaContainer().mappedMetaType() == QMetaType::fromType<int>()) + QCOMPARE(mappingIter.value(5).toInt(), 0); + else if (mappingIter.metaContainer().mappedMetaType() == QMetaType::fromType<bool>()) + QCOMPARE(mappingIter.value(5).toBool(), true); + + QVERIFY(mappingIter.containsKey("5")); + mappingIter.removeKey(QStringLiteral("5")); + QCOMPARE(mappingIter.find(5), mappingIter.end()); + + mappingIter.setValue(5, 44); + if (mappingIter.metaContainer().mappedMetaType() == QMetaType::fromType<int>()) + QCOMPARE(mappingIter.value(5).toInt(), 44); + else if (mappingIter.metaContainer().mappedMetaType() == QMetaType::fromType<bool>()) + QCOMPARE(mappingIter.value(5).toBool(), true); + + // Test that find() does not coerce + auto container = Container(); + container[0] = true; + + QVariant containerVariant = QVariant::fromValue(container); + QAssociativeIterable iter = containerVariant.value<QAssociativeIterable>(); + auto f = iter.constFind(QStringLiteral("anything")); + QCOMPARE(f, iter.constEnd()); +} + +template<typename T> +static void addRowSequential(const char *name, bool hasSizeAccessor, bool hasIndexedAccessor) +{ + QTest::newRow(name) + << &testMetaSequenceIteration<T> << hasSizeAccessor << hasIndexedAccessor; + QTest::addRow("%s_old", name) + << &testSequentialIteration<T> << hasSizeAccessor << hasIndexedAccessor; +} + +template<typename C> +static void addRowAssociative(const char *name) +{ + QTest::newRow(name) + << &testMetaAssociationIteration<C>; + QTest::addRow("%s_old", name) + << &testAssociativeIteration<C>; +} + +QT_WARNING_POP +#else + +template<typename T> +static void addRowSequential(const char *name, bool hasSizeAccessor, bool hasIndexedAccessor) +{ + QTest::newRow(name) + << &testMetaSequenceIteration<T> << hasSizeAccessor << hasIndexedAccessor; +} + +template<typename C> +static void addRowAssociative(const char *name) +{ + QTest::newRow(name) + << &testMetaAssociationIteration<C>; +} + +#endif // QT_VERSION < QT_VERSION_CHECK(7, 0, 0) && QT_DEPRECATED_SINCE(6, 15) + void tst_QVariant::iterateSequentialContainerElements_data() { QTest::addColumn<QFunctionPointer>("testFunction"); QTest::addColumn<bool>("hasSizeAccessor"); QTest::addColumn<bool>("hasIndexedAccessors"); -#define ADD(T) QTest::newRow(#T) << &testSequentialIteration<T> << true << true +#define ADD(T) addRowSequential<T>(#T, true, true) ADD(QQueue<int>); ADD(QQueue<QVariant>); ADD(QQueue<QString>); @@ -5253,13 +5511,13 @@ void tst_QVariant::iterateSequentialContainerElements_data() ADD(QByteArray); #undef ADD -#define ADD(T) QTest::newRow(#T) << &testSequentialIteration<T> << true << false +#define ADD(T) addRowSequential<T>(#T, true, false) ADD(std::list<int>); ADD(std::list<QVariant>); ADD(std::list<QString>); #undef ADD -#define ADD(T) QTest::newRow(#T) << &testSequentialIteration<T> << false << false +#define ADD(T) addRowSequential<T>(#T, false, false) #ifdef TEST_FORWARD_LIST ADD(std::forward_list<int>); ADD(std::forward_list<QVariant>); @@ -5271,7 +5529,7 @@ void tst_QVariant::iterateSequentialContainerElements_data() void tst_QVariant::iterateAssociativeContainerElements_data() { QTest::addColumn<QFunctionPointer>("testFunction"); -#define ADD(C, K, V) QTest::newRow(#C #K #V) << &testAssociativeIteration<C<K, V>>; +#define ADD(C, K, V) addRowAssociative<C<K, V>>(#C "<" #K "," #V ">"); ADD(QHash, int, bool); ADD(QHash, int, int); ADD(QMap, int, bool); @@ -6448,15 +6706,15 @@ void tst_QVariant::get_NonDefaultConstructible() struct QVariantWrapper { public: - static constexpr bool canNoexceptConvertToQVariant + static constexpr bool CanNoexceptConvertToQVariant = std::is_nothrow_copy_constructible_v<QVariant>; - static constexpr bool canNoexceptAssignQVariant + static constexpr bool CanNoexceptAssignQVariant = std::is_nothrow_copy_assignable_v<QVariant>; QVariantWrapper(QVariant *content = nullptr) noexcept : m_content(content) {} - QVariant content() const noexcept(canNoexceptConvertToQVariant) { return *m_content; } - void setContent(const QVariant &content) noexcept(canNoexceptAssignQVariant) + QVariant content() const noexcept(CanNoexceptConvertToQVariant) { return *m_content; } + void setContent(const QVariant &content) noexcept(CanNoexceptAssignQVariant) { *m_content = content; } @@ -6468,14 +6726,14 @@ private: QT_BEGIN_NAMESPACE template<> QVariant::ConstReference<QVariantWrapper>::operator QVariant() const - noexcept(QVariantWrapper::canNoexceptConvertToQVariant) + noexcept(QVariantWrapper::CanNoexceptConvertToQVariant) { return m_referred.content(); } template<> QVariant::Reference<QVariantWrapper> &QVariant::Reference<QVariantWrapper>::operator=( - const QVariant &content) noexcept(QVariantWrapper::canNoexceptAssignQVariant) + const QVariant &content) noexcept(QVariantWrapper::CanNoexceptAssignQVariant) { m_referred.setContent(content); return *this; diff --git a/tests/auto/corelib/plugin/qpluginloader/tst_qpluginloader.cpp b/tests/auto/corelib/plugin/qpluginloader/tst_qpluginloader.cpp index 2d9d351286f..f1f88891015 100644 --- a/tests/auto/corelib/plugin/qpluginloader/tst_qpluginloader.cpp +++ b/tests/auto/corelib/plugin/qpluginloader/tst_qpluginloader.cpp @@ -63,11 +63,11 @@ using namespace Qt::StringLiterals; #elif defined(Q_OS_WIN) # undef dll_VALID # define dll_VALID true -//# ifdef QT_NO_DEBUG +# if !defined(QT_NO_DEBUG) && defined(Q_CC_MSVC) +# define SUFFIX "d.dll" +# else # define SUFFIX ".dll" -//# else -//# define SUFFIX "d.dll" -//# endif +# endif # define PREFIX "" #else // all other Unix diff --git a/tests/auto/widgets/widgets/qcombobox/tst_qcombobox.cpp b/tests/auto/widgets/widgets/qcombobox/tst_qcombobox.cpp index 10a67daa02a..0f8a6da823e 100644 --- a/tests/auto/widgets/widgets/qcombobox/tst_qcombobox.cpp +++ b/tests/auto/widgets/widgets/qcombobox/tst_qcombobox.cpp @@ -3572,6 +3572,7 @@ void tst_QComboBox::popupPositionAfterStyleChange() QFrame *container = box.findChild<QComboBoxPrivateContainer *>(); QVERIFY(container); QVERIFY(QTest::qWaitForWindowExposed(container)); + container->resize(80, 80); // Select the last menu item, which will close the popup. This item is then expected // to be centered on top of the combobox the next time the popup opens. diff --git a/tests/benchmarks/gui/painting/qcolor/tst_qcolor.cpp b/tests/benchmarks/gui/painting/qcolor/tst_qcolor.cpp index 02fe3f986e9..54ba45c1256 100644 --- a/tests/benchmarks/gui/painting/qcolor/tst_qcolor.cpp +++ b/tests/benchmarks/gui/painting/qcolor/tst_qcolor.cpp @@ -2,8 +2,24 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <qtest.h> + #include <QColor> +#include <vector> + +static std::vector<QColor> all_rgb_colors() +{ + std::vector<QColor> colors; + colors.reserve(256 * 256 * 256); + for (int r = 0; r < 256; ++r) { + for (int g = 0; g < 256; ++g) { + for (int b = 0; b < 256; ++b) + colors.emplace_back(r, g, b); + } + } + return colors; +} + class tst_QColor : public QObject { @@ -12,6 +28,11 @@ class tst_QColor : public QObject private slots: void nameRgb(); void nameArgb(); + void toHsl(); + void toHsv(); + +private: + const std::vector<QColor> m_all_rgb = all_rgb_colors(); }; void tst_QColor::nameRgb() @@ -32,6 +53,22 @@ void tst_QColor::nameArgb() } } +void tst_QColor::toHsl() +{ + QBENCHMARK { + for (const QColor &c : m_all_rgb) + [[maybe_unused]] const auto r = c.toHsl(); + } +} + +void tst_QColor::toHsv() +{ + QBENCHMARK { + for (const QColor &c : m_all_rgb) + [[maybe_unused]] const auto r = c.toHsv(); + } +} + QTEST_MAIN(tst_QColor) #include "tst_qcolor.moc" |
