diff options
Diffstat (limited to 'src/corelib')
164 files changed, 5216 insertions, 2604 deletions
diff --git a/src/corelib/CMakeLists.txt b/src/corelib/CMakeLists.txt index e1fb0d7e39..a2e07d7e35 100644 --- a/src/corelib/CMakeLists.txt +++ b/src/corelib/CMakeLists.txt @@ -111,6 +111,7 @@ qt_internal_add_module(Core io/qfilesystementry.cpp io/qfilesystementry_p.h io/qfilesystemiterator_p.h io/qfilesystemmetadata_p.h + io/qfloat16format.h io/qfsfileengine.cpp io/qfsfileengine_p.h io/qfsfileengine_iterator.cpp io/qfsfileengine_iterator_p.h io/qiodevice.cpp io/qiodevice.h io/qiodevice_p.h @@ -127,6 +128,7 @@ qt_internal_add_module(Core io/qstorageinfo.cpp io/qstorageinfo.h io/qstorageinfo_p.h io/qtemporarydir.cpp io/qtemporarydir.h io/qtemporaryfile.cpp io/qtemporaryfile.h io/qtemporaryfile_p.h + io/qtformat_impl.h io/qurl.cpp io/qurl.h io/qurl_p.h io/qurlidna.cpp io/qurlquery.cpp io/qurlquery.h @@ -456,7 +458,7 @@ endif() set(core_version_tagging_files global/qversiontagging.cpp) qt_internal_extend_target(Core - CONDITION TEST_ld_version_script OR APPLE OR WIN32 + CONDITION QT_FEATURE_version_tagging SOURCES ${core_version_tagging_files} ) @@ -897,7 +899,7 @@ qt_internal_extend_target(Core CONDITION QT_FEATURE_timezone AND UNIX AND NOT AN qt_internal_extend_target(Core CONDITION - QT_FEATURE_icu AND QT_FEATURE_timezone AND NOT ANDROID AND NOT APPLE + QT_FEATURE_icu AND QT_FEATURE_timezone AND NOT UNIX SOURCES time/qtimezoneprivate_icu.cpp ) @@ -1484,3 +1486,39 @@ qt_internal_extend_target(Core # QReadWriteLock::destroyRecursive(QReadWriteLockPrivate*) "_ZN*14QReadWriteLock16destroyRecursiveEP*21QReadWriteLockPrivate*" ) + +function(qt_internal_library_deprecation_level) + # QT_DISABLE_DEPRECATED_UP_TO controls which version we use as a cut-off + # compiling in to the library. E.g. if it is set to QT_VERSION then no + # code which was deprecated before QT_VERSION will be compiled in. + if(NOT DEFINED QT_DISABLE_DEPRECATED_UP_TO) + if(WIN32) + # On Windows, due to the way DLLs work, we need to export all functions, + # including the inlines + set(QT_DISABLE_DEPRECATED_UP_TO "0x040800") + else() + # On other platforms, Qt's own compilation does need to compile the Qt 5.0 API + set(QT_DISABLE_DEPRECATED_UP_TO "0x050000") + endif() + elseif(NOT QT_DISABLE_DEPRECATED_UP_TO MATCHES "^0x[0-9][0-9][0-9][0-9][0-9][0-9]$") + message(FATAL_ERROR "Ivalid format of the QT_DISABLE_DEPRECATED_UP_TO macro:" + " ${QT_DISABLE_DEPRECATED_UP_TO}. The expected format is the hexadecimal number," + " e.g. 0x060102") + endif() + # QT_WARN_DEPRECATED_UP_TO controls the upper-bound of deprecation + # warnings that are emitted. E.g. if it is set to 0x060500 then all use of + # things deprecated in or before 6.5.0 will be warned against. + set(QT_WARN_DEPRECATED_UP_TO 0x070000) + + set(output_header "${CMAKE_CURRENT_BINARY_DIR}/global/qtdeprecationdefinitions.h") + configure_file( + "${CMAKE_CURRENT_SOURCE_DIR}/global/qtdeprecationdefinitions.h.in" + "${output_header}" + @ONLY + NEWLINE_STYLE UNIX + ) + + target_sources(Core PRIVATE "${output_header}") + set_source_files_properties("${output_header}" PROPERTIES GENERATED TRUE) +endfunction() +qt_internal_library_deprecation_level() diff --git a/src/corelib/Qt6AndroidMacros.cmake b/src/corelib/Qt6AndroidMacros.cmake index 6218df1947..a78a5a1af6 100644 --- a/src/corelib/Qt6AndroidMacros.cmake +++ b/src/corelib/Qt6AndroidMacros.cmake @@ -217,6 +217,10 @@ function(qt6_android_generate_deployment_settings target) ${target} "_qt_android_native_package_source_dir") # version code + _qt_internal_add_android_deployment_property(file_contents "android-package-name" + ${target} "QT_ANDROID_PACKAGE_NAME") + + # version code _qt_internal_add_android_deployment_property(file_contents "android-version-code" ${target} "QT_ANDROID_VERSION_CODE") @@ -296,6 +300,13 @@ function(qt6_android_generate_deployment_settings target) string(APPEND file_contents " \"zstdCompression\": ${is_zstd_enabled},\n") + if(QT_ANDROID_GENERATE_JAVA_QML_COMPONENTS) + set(is_generate_java_qml_components "true") + else() + set(is_generate_java_qml_components "false") + endif() + string(APPEND file_contents + " \"generate-java-qml-components\": ${is_generate_java_qml_components},\n") # Last item in json file # base location of stdlibc++, will be suffixed by androiddeploy qt @@ -381,6 +392,9 @@ function(qt6_android_add_apk_target target) if(TARGET aab) add_dependencies(aab ${target}_make_aab) endif() + if(TARGET aar) + add_dependencies(aar ${target}_make_aar) + endif() if(TARGET apk) add_dependencies(apk ${target}_make_apk) _qt_internal_create_global_apk_all_target_if_needed() @@ -418,8 +432,10 @@ function(qt6_android_add_apk_target target) endif() set(apk_file_name "${target}.apk") + set(aar_file_name "${target}.aar") set(dep_file_name "${target}.d") set(apk_final_file_path "${apk_final_dir}/${apk_file_name}") + set(aar_final_file_path "${apk_final_dir}/${aar_file_name}") set(dep_file_path "${apk_final_dir}/${dep_file_name}") set(target_file_copy_relative_path "libs/${CMAKE_ANDROID_ARCH_ABI}/$<TARGET_FILE_NAME:${target}>") @@ -523,10 +539,33 @@ function(qt6_android_add_apk_target target) VERBATIM ${uses_terminal} ) + + # Add custom command that creates the aar and triggers rebuild if files listed in + # ${dep_file_path} are changed. + add_custom_command(OUTPUT "${aar_final_file_path}" + COMMAND ${CMAKE_COMMAND} + -E copy "$<TARGET_FILE:${target}>" + "${apk_final_dir}/${target_file_copy_relative_path}" + COMMAND "${deployment_tool}" + --input "${deployment_file}" + --output "${apk_final_dir}" + --apk "${aar_final_file_path}" + --depfile "${dep_file_path}" + --builddir "${relative_to_dir}" + --build-aar + ${extra_args} + COMMENT "Creating AAR for ${target}" + DEPENDS "${target}" "${deployment_file}" ${extra_deps} + DEPFILE "${dep_file_path}" + VERBATIM + ${uses_terminal} + ) cmake_policy(POP) # Create a ${target}_make_apk target to trigger the apk build. add_custom_target(${target}_make_apk DEPENDS "${apk_final_file_path}") + # Create a ${target}_make_aar target to trigger the aar build. + add_custom_target(${target}_make_aar DEPENDS "${aar_final_file_path}") else() add_custom_target(${target}_make_apk DEPENDS ${target}_prepare_apk_dir @@ -540,6 +579,19 @@ function(qt6_android_add_apk_target target) VERBATIM ${uses_terminal} ) + + add_custom_target(${target}_make_aar + DEPENDS ${target}_prepare_apk_dir + COMMAND ${deployment_tool} + --input ${deployment_file} + --output ${apk_final_dir} + --apk ${aar_final_file_path} + --build-aar + ${extra_args} + COMMENT "Creating AAR for ${target}" + VERBATIM + ${uses_terminal} + ) endif() # Add target triggering AAB creation. Since the _make_aab target is not added to the ALL @@ -638,6 +690,11 @@ function(_qt_internal_create_global_android_targets) # It will trigger building all the apk build targets that are added as part of the project. # Allow opting out. _qt_internal_create_global_android_targets_impl(aab) + + # Create a top-level "aar" target for convenience, so that users can call 'ninja aar'. + # It will trigger building all the aar build targets that are added as part of the project. + # Allow opting out. + _qt_internal_create_global_android_targets_impl(aar) endfunction() # The function collects all known non-imported shared libraries that are created in the build tree. diff --git a/src/corelib/Qt6CoreConfigExtras.cmake.in b/src/corelib/Qt6CoreConfigExtras.cmake.in index 7fd929e59b..b7ac0925af 100644 --- a/src/corelib/Qt6CoreConfigExtras.cmake.in +++ b/src/corelib/Qt6CoreConfigExtras.cmake.in @@ -1,3 +1,5 @@ +# Copyright (C) 2024 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause if(NOT DEFINED QT_DEFAULT_MAJOR_VERSION) set(QT_DEFAULT_MAJOR_VERSION 6) endif() diff --git a/src/corelib/Qt6CoreMacros.cmake b/src/corelib/Qt6CoreMacros.cmake index 9e71b4265a..1a449b4aa3 100644 --- a/src/corelib/Qt6CoreMacros.cmake +++ b/src/corelib/Qt6CoreMacros.cmake @@ -3155,13 +3155,17 @@ endfunction() # Write deployment information for the targets of the project. function(_qt_internal_write_target_deploy_info out_file) set(targets "") + set(dynamic_target_types EXECUTABLE SHARED_LIBRARY MODULE_LIBRARY) _qt_internal_collect_buildsystem_targets(targets - "${CMAKE_SOURCE_DIR}" INCLUDE EXECUTABLE SHARED_LIBRARY MODULE_LIBRARY) + "${CMAKE_SOURCE_DIR}" INCLUDE ${dynamic_target_types} STATIC_LIBRARY) set(content "") foreach(target IN LISTS targets) set(var_prefix "__QT_DEPLOY_TARGET_${target}") string(APPEND content "set(${var_prefix}_FILE $<TARGET_FILE:${target}>)\n") - if(WIN32 AND CMAKE_VERSION GREATER_EQUAL "3.21") + get_target_property(target_type ${target} TYPE) + string(APPEND content "set(${var_prefix}_TYPE ${target_type})\n") + if(WIN32 AND CMAKE_VERSION GREATER_EQUAL "3.21" + AND target_type IN_LIST dynamic_target_types) string(APPEND content "set(${var_prefix}_RUNTIME_DLLS $<TARGET_RUNTIME_DLLS:${target}>)\n") endif() diff --git a/src/corelib/compat/removed_api.cpp b/src/corelib/compat/removed_api.cpp index 6101e71f79..40ef9875b0 100644 --- a/src/corelib/compat/removed_api.cpp +++ b/src/corelib/compat/removed_api.cpp @@ -4,7 +4,6 @@ #define QT_CORE_BUILD_REMOVED_API #include "qglobal.h" -#include "qnumeric.h" QT_USE_NAMESPACE @@ -929,10 +928,41 @@ QUrl QUrl::fromEncoded(const QByteArray &input, ParsingMode mode) #endif // QT_CORE_REMOVED_SINCE(6, 7) #if QT_CORE_REMOVED_SINCE(6, 8) +#include "qabstractitemmodel.h" + +bool QPersistentModelIndex::operator<(const QPersistentModelIndex &other) const noexcept +{ + return is_lt(compareThreeWay(*this, other)); +} + +bool QPersistentModelIndex::operator==(const QPersistentModelIndex &other) const noexcept +{ + return comparesEqual(*this, other); +} + +bool QPersistentModelIndex::operator==(const QModelIndex &other) const noexcept +{ + return comparesEqual(*this, other); +} + +bool QPersistentModelIndex::operator!=(const QModelIndex &other) const noexcept +{ + return !comparesEqual(*this, other); +} + #include "qbitarray.h" // inlined API #include "qbytearray.h" // inlined API +QT_BEGIN_NAMESPACE +namespace QtPrivate { +Q_CORE_EXPORT qsizetype lastIndexOf(QByteArrayView haystack, qsizetype from, char needle) noexcept +{ + return lastIndexOf(haystack, from, uchar(needle)); +} +} +QT_END_NAMESPACE + #include "qcborarray.h" // inlined API #include "qcbormap.h" // inlined API @@ -953,6 +983,15 @@ bool QDir::operator==(const QDir &dir) const return comparesEqual(*this, dir); } +#if QT_CONFIG(easingcurve) +#include "qeasingcurve.h" + +bool QEasingCurve::operator==(const QEasingCurve &other) const +{ + return comparesEqual(*this, other); +} +#endif // QT_CONFIG(easingcurve) + #include "qfileinfo.h" // inlined API bool QFileInfo::operator==(const QFileInfo &fileinfo) const @@ -960,7 +999,9 @@ bool QFileInfo::operator==(const QFileInfo &fileinfo) const return comparesEqual(*this, fileinfo); } +#if QT_CONFIG(itemmodel) #include "qitemselectionmodel.h" // inlined API +#endif // itemmodel #include "qjsonarray.h" @@ -1006,7 +1047,19 @@ bool QJsonValue::operator!=(const QJsonValue &other) const return !comparesEqual(*this, other); } +#include "qline.h" // inlined API + +#if QT_CONFIG(mimetype) +#include "qmimetype.h" + +bool QMimeType::operator==(const QMimeType &other) const +{ + return comparesEqual(*this, other); +} +#endif // QT_CONFIG(mimetype) + #include "qobject.h" +#include "qnumeric.h" int QObject::startTimer(std::chrono::milliseconds time, Qt::TimerType timerType) { @@ -1062,8 +1115,33 @@ qsizetype QRegularExpressionMatch::capturedEnd(QStringView name) const { return capturedEnd(QAnyStringView(name)); } + +bool QRegularExpression::operator==(const QRegularExpression &other) const +{ + return comparesEqual(*this, other); +} #endif // QT_CONFIG(regularexpression) +#if QT_CONFIG(future) +#include "qresultstore.h" + +bool QtPrivate::ResultIteratorBase::operator==(const QtPrivate::ResultIteratorBase &other) const +{ + return comparesEqual(*this, other); +} + +bool QtPrivate::ResultIteratorBase::operator!=(const QtPrivate::ResultIteratorBase &other) const +{ + return !comparesEqual(*this, other); +} +#endif // QT_CONFIG(future) + +#include "qstring.h" // inlined API + +#if QT_CONFIG(thread) +# include "qthreadpool.h" // inlined API +#endif + #include "qurl.h" bool QUrl::operator<(const QUrl &url) const @@ -1088,9 +1166,31 @@ bool QUrlQuery::operator==(const QUrlQuery &other) const return comparesEqual(*this, other); } -#include "qstring.h" // inlined API +#include "quuid.h" + +bool QUuid::operator<(const QUuid &other) const noexcept +{ + return is_lt(compareThreeWay(*this, other)); +} + +bool QUuid::operator>(const QUuid &other) const noexcept +{ + return is_gt(compareThreeWay(*this, other)); +} + +QUuid QUuid::createUuidV3(const QUuid &ns, const QByteArray &baseData) noexcept +{ + return createUuidV3(ns, qToByteArrayViewIgnoringNull(baseData)); +} + +QUuid QUuid::createUuidV5(const QUuid &ns, const QByteArray &baseData) noexcept +{ + return createUuidV5(ns, qToByteArrayViewIgnoringNull(baseData)); +} +#if QT_CONFIG(xmlstream) #include "qxmlstream.h" // inlined API +#endif // QT_CONFIG(xmlstream) // #include "qotherheader.h" // // implement removed functions from qotherheader.h diff --git a/src/corelib/configure.cmake b/src/corelib/configure.cmake index 80e6d93193..b34086c8ad 100644 --- a/src/corelib/configure.cmake +++ b/src/corelib/configure.cmake @@ -324,6 +324,37 @@ linkat(AT_FDCWD, \"foo\", AT_FDCWD, \"bar\", AT_SYMLINK_FOLLOW); } ") +# memmem +qt_config_compile_test(memmem + LABEL "memmem()" + CODE +#define _APPLE_SAUCE 1 /* Apple doesn't require anything */ +"#define _BSD_SOURCE 1 /* For FreeBSD */ +#define _GNU_SOURCE 1 /* For glibc, Bionic */ +#include <string.h> + +int main(void) +{ + const void *r = memmem(\"abc\", 3, \"bc\", 2); + (void)r; + return 0; +}") + +# memrchr +qt_config_compile_test(memrchr + LABEL "memrchr()" + CODE +"#define _BSD_SOURCE 1 /* For FreeBSD */ +#define _GNU_SOURCE 1 /* For glibc, Bionic */ +#include <string.h> + +int main(void) +{ + const void *r = memrchr(\"abc\", 'a', 3); + (void)r; + return 0; +}") + # ppoll qt_config_compile_test(ppoll LABEL "ppoll()" @@ -430,6 +461,34 @@ const auto backtrace = std::stacktrace::current(); CXX_STANDARD 23 ) +# <future> +qt_config_compile_test(cxx_std_async_noncopyable + LABEL "std::async() NonCopyable" + CODE +"// Calling std::async with lambda which takes non-copyable argument causes compilation error on +// some platforms (VxWorks 24.03 and older with C++17-compatibility for example) +#include <future> + +class NonCopyable { +public: + NonCopyable(const NonCopyable&) = delete; + NonCopyable(NonCopyable&&) = default; + + NonCopyable(int value) + :value (value) + {} + + int value; +}; + +int main(int argc, char** argv) { + return std::async( + std::launch::deferred, + [](NonCopyable value) { return value.value; }, + NonCopyable(argc - 1)).get(); +} +") + #### Features qt_feature("clock-gettime" PRIVATE @@ -458,7 +517,7 @@ qt_feature("system-doubleconversion" PRIVATE ) qt_feature("cxx11_future" PUBLIC LABEL "C++11 <future>" - CONDITION NOT VXWORKS + CONDITION TEST_cxx_std_async_noncopyable ) qt_feature("cxx17_filesystem" PUBLIC LABEL "C++17 <filesystem>" @@ -526,6 +585,14 @@ qt_feature("std-atomic64" PUBLIC LABEL "64 bit atomic operations" CONDITION WrapAtomic_FOUND ) +qt_feature("memmem" PRIVATE + LABEL "C library function memmem()" + CONDITION TEST_memmem +) +qt_feature("memrchr" PRIVATE + LABEL "C library function memrchr()" + CONDITION TEST_memrchr +) qt_feature("mimetype" PUBLIC SECTION "Utilities" LABEL "Mimetype handling" @@ -832,7 +899,8 @@ qt_feature("timezone_locale" PRIVATE SECTION "Utilities" LABEL "QTimeZone" PURPOSE "Provides support for localized time-zone display names." - DISABLE ON # Implementation is currently incomplete, so leave turned off + CONDITION + QT_FEATURE_timezone AND ( ( UNIX AND NOT APPLE AND NOT ANDROID ) OR QT_FEATURE_icu ) ) qt_feature("datetimeparser" PRIVATE SECTION "Utilities" diff --git a/src/corelib/doc/snippets/signalsandslots/signalsandslots.h b/src/corelib/doc/snippets/signalsandslots/signalsandslots.h index 2f5a53231c..a590e8fd5e 100644 --- a/src/corelib/doc/snippets/signalsandslots/signalsandslots.h +++ b/src/corelib/doc/snippets/signalsandslots/signalsandslots.h @@ -33,6 +33,8 @@ class Counter : public QObject { Q_OBJECT +// Note. The Q_OBJECT macro starts a private section. +// To declare public members, use the 'public:' access modifier. public: Counter() { m_value = 0; } diff --git a/src/corelib/doc/src/cmake/cmake-configure-variables.qdoc b/src/corelib/doc/src/cmake/cmake-configure-variables.qdoc index b710ba7275..8422a688f0 100644 --- a/src/corelib/doc/src/cmake/cmake-configure-variables.qdoc +++ b/src/corelib/doc/src/cmake/cmake-configure-variables.qdoc @@ -318,6 +318,29 @@ The mentioned variables are used internally by \l{androiddeployqt}. */ /*! +\page cmake-variable-qt-android-generate-java-qml-components.html +\ingroup cmake-variables-qtcore +\ingroup cmake-android-build-properties + +\title QT_ANDROID_GENERATE_JAVA_QML_COMPONENTS +\target cmake-variable-QT_ANDROID_GENERATE_JAVA_QML_COMPONENTS + +\summary {Enables the generation of QtQmlComponent-based classes.} +\cmakevariablesince 6.8 +\preliminarycmakevariable +\cmakevariableandroidonly + +This variable enables Java code generation for QML components of the target application. The +generated code will be included in the resulting package. The Java package name of generated +classes will be the same as the Android app package. If the leaf part of the package name is +not the same as the target executable, an extra static class with the same name as the +capitalized target executable will surround all QML modules enclosing Java classes. Each QML +module class, again in a capitalized form, will contain QtQmlComponent extension classes that +represent QML components of that module. +*/ + +\sa{androiddeployqt} +/*! \page cmake-variable-qt-use-target-android-build-dir.html \ingroup cmake-variables-qtcore diff --git a/src/corelib/doc/src/cmake/cmake-properties.qdoc b/src/corelib/doc/src/cmake/cmake-properties.qdoc index 8fe2b0e88f..4b602d5d07 100644 --- a/src/corelib/doc/src/cmake/cmake-properties.qdoc +++ b/src/corelib/doc/src/cmake/cmake-properties.qdoc @@ -245,6 +245,56 @@ CMake will attempt to use the latest installed version. */ /*! +\page cmake-target-property-qt-android-package-name.html +\ingroup cmake-properties-qtcore +\ingroup cmake-target-properties-qtcore +\ingroup cmake-android-build-properties + +\title QT_ANDROID_PACKAGE_NAME +\target cmake-target-property-QT_ANDROID_PACKAGE_NAME + +\summary {The app's package name.} + +\cmakepropertysince 6.8 +\preliminarycmakeproperty +\cmakepropertyandroidonly + +Specifies the app's package name. This is usually a unique dot separated +name for the app, that will be used to identify the app on devices or in +the Play Store. For example, "org.qtproject.example.gallery". + +The package name set by this property is passed to the \c build.gradle file +as a \c namespace property, instead of \c AndroidManifest.xml, since the +latter is deprecated since Android Gradle Plugin 7.4. + +The package name considers some words or characters as illegal and the build +will clean such names if any is encountered. An underscore (\c _) either replaces +illegal characters or is appended to illegal words. + +\list + \li Allowed characters: alphanumeric, an underscore or a dot [a-zA-Z0-9_.]. + \li Illegal words: abstract, continue, for, new, switch, assert, default, + if, package, synchronized, boolean, do, goto, private, this, break, + double, implements, protected, throw, byte, else, import, public, + throws, case, enum, instanceof, return, transient, catch, extends, + int, short, try, char, final, interface, static, void, class, finally, + long, strictfp, volatile, const, float, native, super, while. +\endlist + +The default package name for Qt for Android apps is \c org.qtproject.example.<target_name>. + +\note Setting the package name manually in \c build.gradle (via +\c namespace property) takes precedence over \c AndroidManifest.xml +(via \c package attribute), and the latter also takes precedence over +this property. + +For more information, see Android's +\l{Android: Configure the app module}{configure the app module}. + +\sa{qt6_android_generate_deployment_settings}{qt_android_generate_deployment_settings()} +*/ + +/*! \page cmake-target-property-qt-android-version-code.html \ingroup cmake-properties-qtcore \ingroup cmake-target-properties-qtcore diff --git a/src/corelib/doc/src/cmake/qt_android_generate_deployment_settings.qdoc b/src/corelib/doc/src/cmake/qt_android_generate_deployment_settings.qdoc index 5a7bbdc33f..daa3680070 100644 --- a/src/corelib/doc/src/cmake/qt_android_generate_deployment_settings.qdoc +++ b/src/corelib/doc/src/cmake/qt_android_generate_deployment_settings.qdoc @@ -63,6 +63,7 @@ how to accomplish this. \li \l{cmake-target-property-QT_ANDROID_MIN_SDK_VERSION}{QT_ANDROID_MIN_SDK_VERSION} \li \l{cmake-target-property-QT_ANDROID_PACKAGE_SOURCE_DIR}{QT_ANDROID_PACKAGE_SOURCE_DIR} \li \l{cmake-target-property-QT_ANDROID_TARGET_SDK_VERSION}{QT_ANDROID_TARGET_SDK_VERSION} +\li \l{cmake-target-property-QT_ANDROID_PACKAGE_NAME}{QT_ANDROID_PACKAGE_NAME} \li \l{cmake-target-property-QT_ANDROID_VERSION_NAME}{QT_ANDROID_VERSION_NAME} \li \l{cmake-target-property-QT_ANDROID_VERSION_CODE}{QT_ANDROID_VERSION_CODE} \li \l{cmake-target-property-QT_QML_IMPORT_PATH}{QT_QML_IMPORT_PATH} diff --git a/src/corelib/doc/src/foreach-keyword.qdoc b/src/corelib/doc/src/foreach-keyword.qdoc index b3a4482528..6aa21d5880 100644 --- a/src/corelib/doc/src/foreach-keyword.qdoc +++ b/src/corelib/doc/src/foreach-keyword.qdoc @@ -81,7 +81,10 @@ /*! \macro QT_NO_FOREACH \since 6.0 + \relates <QtGlobal> Defining this macro removes the availability of Qt's \c foreach loop. + + \sa QT_NO_KEYWORDS */ diff --git a/src/corelib/doc/src/jni.qdoc b/src/corelib/doc/src/jni.qdoc new file mode 100644 index 0000000000..d05dd44ff6 --- /dev/null +++ b/src/corelib/doc/src/jni.qdoc @@ -0,0 +1,230 @@ +// Copyright (C) 2024 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only + +/*! + \namespace QtJniTypes + \inmodule QtCore + \ingroup frameworks-technologies + \keyword JNI + \since 6.8 + + \brief The QtJniTypes namespace declares C++ types that correspond to Java types. + + The \l{Java Native Interface Specification}{Java Native Interface} + framework enables native C or C++ code to call Java APIs, and to register + native C or C++ functions that Java code should be able to call with the + JVM. In Qt, the QJniObject and QJniEnvironment types provide convenient + wrappers for using JNI. + + Since the Java language, similar to C++, supports overloading, functions + need to be specified including their entire signature string. This is + complex, repetitive, and error prone, especially when functions take + several parameters. QJniObject provides variadic template APIs that can + deduce the signature string for a function call at compile time, based on + the C++ types passed into the template. For this to work, the mapping of + those C++ types to their corresponding JNI string needs to be known at + compile time. + + Qt implements this mapping for the standard \l {JNI types}. + By using the Q_DECLARE_JNI_CLASS macro, the mapping can be extended for + arbitrary Java types. + + \sa Q_DECLARE_JNI_CLASS, Q_DECLARE_JNI_NATIVE_METHOD, Q_JNI_NATIVE_METHOD +*/ + +/*! + \macro Q_DECLARE_JNI_TYPE(Type, JavaSignature) + \internal + \relates QtJniTypes + \since 6.8 + + Declares a C++ type \a Type in the QtJniTypes namespace that wraps the Java + type \a JavaSignature. The signature needs to start with \c{[L} to indicate + an array of a class, or with \c{L} for classes, and end with a semicolon + \c{;}. + + \code + Q_DECLARE_JNI_TYPE(StringArray, "[Ljava/lang/String;") + \endcode + + \sa Q_DECLARE_JNI_CLASS +*/ + +/*! + \macro Q_DECLARE_JNI_CLASS(Type, JavaSignature) + \relates QtJniTypes + \since 6.8 + + Declares a C++ type \a Type in the QtJniTypes namespace that wraps the Java + class \a JavaSignature. The Java class name in \a JavaSignature needs to be + fully qualified, using \c{/} as the separator. + + \code + Q_DECLARE_JNI_CLASS(File, "java/io/File") + Q_DECLARE_JNI_CLASS(FileWriter, "java/io/FileWriter") + \endcode + + The C++ classes \c{QtJniTypes::File} and \c{QtJniTypes::FileWriter} are + then QJniObject-like types that can be used to instantiate the + corresponding Java class, to call methods, and to pass such instances + through QJniObject variadic template methods with automatic, compile-time + signature deduction. + + \code + using namespace QtJniTypes; + + File file("path/to/file"); // instantiates the java.io.File type in Java + if (file.callMethod<bool>("createNewFile")) { + FileWriter writer(file); // instantiates a java.io.FileWriter that operates on file + writer.callMethod("write", 42); + } + \endcode + + In addition to the QJniObject API, those C++ classes also have a static + \c{registerNativeMethods} member function that can be used like this: + + \code + QtJniTypes::File::registerNativeMethods({ + Q_JNI_NATIVE_METHOD(freeFunction) + }); + \endcode + + \sa Q_DECLARE_JNI_NATIVE_METHOD, Q_JNI_NATIVE_METHOD +*/ + +/*! + \macro Q_DECLARE_JNI_NATIVE_METHOD(Method) + \relates QtJniTypes + \since 6.8 + + Declares the free C or C++ function \a Method as a native method. The + method can later be registered with the JNI framework using + QJniEnvironment::registerNativeMethod() with the help of the + Q_JNI_NATIVE_METHOD macro. + +//! [register-free-function] + \code + // C++ side + + Q_DECLARE_JNI_CLASS(MyJavaType, "my/java/Type") + + static void nativeFunction(JNIEnv *env, jobject thiz, jlong id) + { + // ... + } + Q_DECLARE_JNI_NATIVE_METHOD(nativeFunction) + + Q_DECL_EXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) + { + QJniEnvironment env; + env.registerNativeMethods<QtJniTypes::MyJavaType>({ + Q_JNI_NATIVE_METHOD(nativeFunction) + }); + } + + // Java side + public class MyJavaType + { + native public nativeFunction(long id); + } + \endcode +//! [register-free-function] + + \sa Q_JNI_NATIVE_METHOD, Q_DECLARE_JNI_NATIVE_METHOD_IN_CURRENT_SCOPE +*/ + +/*! + \macro Q_DECLARE_JNI_NATIVE_METHOD(Method, JavaName) + \relates QtJniTypes + \overload + \since 6.8 + + Declares the free C or C++ function \a Method as a native method that's + available in Java as \a JavaName. The method can later be registered with + the JNI framework using QJniEnvironment::registerNativeMethod() with the + help of the Q_JNI_NATIVE_METHOD macro. + + \sa Q_JNI_NATIVE_METHOD, Q_DECLARE_JNI_NATIVE_METHOD_IN_CURRENT_SCOPE +*/ + +/*! + \macro Q_DECLARE_JNI_NATIVE_METHOD_IN_CURRENT_SCOPE(Method) + \relates QtJniTypes + \since 6.8 + + Declares the C++ static class member function \a Method as a native method. + The method can later be registered with the JNI framework using + QJniEnvironment::registerNativeMethod() with the help of the + Q_JNI_NATIVE_SCOPED_METHOD macro. + +//! [register-scoped-function] + \code + class NativeHandler + { + // ... + private: + static void handleChange(JNIEnv*, jobject, jlong id); + Q_DECLARE_JNI_NATIVE_METHOD_IN_CURRENT_SCOPE(handleChange) + }; + + \dots + QJniEnvironment env; + env.registerNativeMethods<QtJniTypes::MyJavaType>({ + Q_JNI_NATIVE_SCOPED_METHOD(handleChange, NativeHandler) + }); + \endcode +//! [register-scoped-function] + + \sa Q_DECLARE_JNI_NATIVE_METHOD, Q_JNI_NATIVE_SCOPED_METHOD +*/ + +/*! + \macro Q_DECLARE_JNI_NATIVE_METHOD_IN_CURRENT_SCOPE(Method, JavaName) + \relates QtJniTypes + \overload + \since 6.8 + + Declares the C++ static class member function \a Method as a native method + that's available in Java as \a JavaName. The method can later be registered + with the JNI framework using QJniEnvironment::registerNativeMethod() with + the help of the Q_JNI_NATIVE_METHOD macro. + + \sa Q_DECLARE_JNI_NATIVE_METHOD, Q_JNI_NATIVE_SCOPED_METHOD +*/ + +/*! + \macro Q_JNI_NATIVE_METHOD(Method) + \relates QtJniTypes + \since 6.8 + + Makes the previously \l{Q_DECLARE_JNI_NATIVE_METHOD}{declared} native + method \a Method available for registration with the JNI framework. Use + this macro when registering the method with JNI using + QJniEnvironment::registerNativeMethod(). + + \code + Q_DECL_EXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) + { + QJniEnvironment env; + env.registerNativeMethods<QtJniTypes::MyJavaType>({ + Q_JNI_NATIVE_METHOD(nativeFunction) + }); + } + \endcode + + \sa Q_DECLARE_JNI_NATIVE_METHOD +*/ + +/*! + \macro Q_JNI_NATIVE_SCOPED_METHOD(Method, Scope) + \relates QtJniTypes + \since 6.8 + + Makes the previously + \l{Q_DECLARE_JNI_NATIVE_METHOD_IN_CURRENT_SCOPE}{declared} native method + \a Method in scope \a Scope available for registration with the JNI framework. + Use this macro when registering the method with JNI using + QJniEnvironment::registerNativeMethod(). + + \sa Q_JNI_NATIVE_METHOD, Q_DECLARE_JNI_NATIVE_METHOD_IN_CURRENT_SCOPE +*/ diff --git a/src/corelib/doc/src/objectmodel/metaobjects.qdoc b/src/corelib/doc/src/objectmodel/metaobjects.qdoc index 3d7685447f..44f574816e 100644 --- a/src/corelib/doc/src/objectmodel/metaobjects.qdoc +++ b/src/corelib/doc/src/objectmodel/metaobjects.qdoc @@ -19,8 +19,7 @@ \list 1 \li The \l QObject class provides a base class for objects that can take advantage of the meta-object system. - \li The Q_OBJECT macro inside the private section of the class - declaration is used to enable meta-object features, such as + \li The Q_OBJECT macro is used to enable meta-object features, such as dynamic properties, signals, and slots. \li The \l{moc}{Meta-Object Compiler} (\c moc) supplies each QObject subclass with the necessary code to implement diff --git a/src/corelib/doc/src/objectmodel/properties.qdoc b/src/corelib/doc/src/objectmodel/properties.qdoc index 99a3e60d88..0e66c8445c 100644 --- a/src/corelib/doc/src/objectmodel/properties.qdoc +++ b/src/corelib/doc/src/objectmodel/properties.qdoc @@ -186,12 +186,11 @@ \section1 A Simple Example - Suppose we have a class MyClass, which is derived from QObject and - which uses the Q_OBJECT macro in its private section. We want to - declare a property in MyClass to keep track of a priority - value. The name of the property will be \e priority, and its type - will be an enumeration type named \e Priority, which is defined in - MyClass. + Suppose we have a class \c MyClass, which is derived from QObject and which + uses the Q_OBJECT macro. We want to declare a property in \c MyClass to keep + track of a priority value. The name of the property will be \c priority, and + its type will be an enumeration type named \c Priority, which is defined in + \c MyClass. We declare the property with the Q_PROPERTY() macro in the private section of the class. The required \c READ function is named \c @@ -200,7 +199,7 @@ System} using the Q_ENUM() macro. Registering an enumeration type makes the enumerator names available for use in calls to QObject::setProperty(). We must also provide our own declarations - for the \c READ and \c WRITE functions. The declaration of MyClass + for the \c READ and \c WRITE functions. The declaration of \c MyClass then might look like this: \snippet code/doc_src_properties.cpp 5 @@ -213,24 +212,24 @@ potentially forcing re-evaluation in other places if nothing has changed. - Given a pointer to an instance of MyClass or a pointer to a - QObject that is an instance of MyClass, we have two ways to set + Given a pointer to an instance of \c MyClass or a pointer to a + QObject that is an instance of \c MyClass, we have two ways to set its priority property: \snippet code/doc_src_properties.cpp 6 In the example, the enumeration type that is the property type is - declared in MyClass and registered with the \l{Meta-Object System} + declared in \c MyClass and registered with the \l{Meta-Object System} using the Q_ENUM() macro. This makes the enumeration values - available as strings for use as in the call to \l{QObject::}{setProperty()}. Had - the enumeration type been declared in another class, its fully + available as strings for use as in the call to \l{QObject::}{setProperty()}. + Had the enumeration type been declared in another class, its fully qualified name (i.e., OtherClass::Priority) would be required, and that other class would also have to inherit QObject and register the enumeration type there using the Q_ENUM() macro. A similar macro, Q_FLAG(), is also available. Like Q_ENUM(), it registers an enumeration type, but it marks the type as being a - set of \e flags, i.e. values that can be OR'd together. An I/O + set of \e flags, i.e., values that can be OR'd together. An I/O class might have enumeration values \c Read and \c Write and then QObject::setProperty() could accept \c{Read | Write}. Q_FLAG() should be used to register this enumeration type. diff --git a/src/corelib/global/qassert.cpp b/src/corelib/global/qassert.cpp index 6a29cbfa21..7c0064ac2f 100644 --- a/src/corelib/global/qassert.cpp +++ b/src/corelib/global/qassert.cpp @@ -195,36 +195,6 @@ void qBadAlloc() */ /*! - \macro QT_TERMINATE_ON_EXCEPTION(expr) - \relates <QtGlobal> - \internal - - In general, use of the Q_DECL_NOEXCEPT macro is preferred over - Q_DECL_NOTHROW, because it exhibits well-defined behavior and - supports the more powerful Q_DECL_NOEXCEPT_EXPR variant. However, - use of Q_DECL_NOTHROW has the advantage that Windows builds - benefit on a wide range or compiler versions that do not yet - support the C++11 noexcept feature. - - It may therefore be beneficial to use Q_DECL_NOTHROW and emulate - the C++11 behavior manually with an embedded try/catch. - - Qt provides the QT_TERMINATE_ON_EXCEPTION(expr) macro for this - purpose. It either expands to \c expr (if Qt is compiled without - exception support or the compiler supports C++11 noexcept - semantics) or to - \snippet code/src_corelib_global_qglobal.cpp qterminate - otherwise. - - Since this macro expands to just \c expr if the compiler supports - C++11 noexcept, expecting the compiler to take over responsibility - of calling std::terminate() in that case, it should not be used - outside Q_DECL_NOTHROW functions. - - \sa Q_DECL_NOEXCEPT, Q_DECL_NOTHROW, qTerminate() -*/ - -/*! \macro void Q_UNREACHABLE() \relates <QtAssert> \since 5.0 diff --git a/src/corelib/global/qcompare.cpp b/src/corelib/global/qcompare.cpp index ac220b8434..81abf01984 100644 --- a/src/corelib/global/qcompare.cpp +++ b/src/corelib/global/qcompare.cpp @@ -149,6 +149,7 @@ CHECK(strong, equivalent); /*! \class Qt::strong_ordering \inmodule QtCore + \inheaderfile QtCompare \brief Qt::strong_ordering represents a comparison where equivalent values are indistinguishable. \sa Qt::weak_ordering, Qt::partial_ordering, {Comparison types overview} @@ -334,6 +335,7 @@ CHECK(strong, equivalent); /*! \class Qt::weak_ordering \inmodule QtCore + \inheaderfile QtCompare \brief Qt::weak_ordering represents a comparison where equivalent values are still distinguishable. \sa Qt::strong_ordering, Qt::partial_ordering, {Comparison types overview} @@ -484,6 +486,7 @@ CHECK(strong, equivalent); /*! \class Qt::partial_ordering \inmodule QtCore + \inheaderfile QtCompare \brief Qt::partial_ordering represents the result of a comparison that allows for unordered results. \sa Qt::strong_ordering, Qt::weak_ordering, {Comparison types overview} @@ -1354,4 +1357,57 @@ CHECK(strong, equivalent); \sa Qt::partial_ordering, Qt::weak_ordering, Qt::strong_ordering */ +/*! + \class Qt::totally_ordered_wrapper + \inmodule QtCore + \inheaderfile QtCompare + \brief Qt::totally_ordered_wrapper is a wrapper type that provides strict + total order for the wrapped types. + \since 6.8 + + One of its primary usecases is to prevent \e {Undefined Behavior} (UB) when + comparing pointers. + + Consider the following simple class: + + \code + template <typename T> + struct PointerWrapperBad { + int val; + T *ptr; + }; + \endcode + + Lexicographical comparison of the two instances of the \c PointerWrapperBad + type would result in UB, because it will call \c {operator<()} or + \c {operator<=>()} on the \c {ptr} members. + + To fix it, use the new wrapper type: + + \code + template <typename T> + struct PointerWrapperGood { + int val; + Qt::totally_ordered_wrapper<T *> ptr; + + friend bool + operator==(PointerWrapperGood lhs, PointerWrapperGood rhs) noexcept = default; + friend auto + operator<=>(PointerWrapperGood lhs, PointerWrapperGood rhs) noexecpt = default; + }; + \endcode + + The \c {operator<()} and (if available) \c {operator<=>()} operators for + the \c {Qt::totally_ordered_wrapper} type use the + \l {https://en.cppreference.com/w/cpp/utility/functional/less}{std::less} + and \l {https://en.cppreference.com/w/cpp/utility/compare/compare_three_way} + {std::compare_three_way} function objects respectively, providing + \l {https://en.cppreference.com/w/cpp/language/operator_comparison#Pointer_total_order} + {strict total order over pointers} when doing the comparison. + + As a result, the relational operators for \c {PointerWrapperGood::ptr} + member will be well-defined, and we can even \c {=default} the relational + operators for the \c {PointerWrapperGood} class, like it's shown above. +*/ + QT_END_NAMESPACE diff --git a/src/corelib/global/qcomparehelpers.h b/src/corelib/global/qcomparehelpers.h index 0e43ac296b..9a0f0f83a4 100644 --- a/src/corelib/global/qcomparehelpers.h +++ b/src/corelib/global/qcomparehelpers.h @@ -16,6 +16,7 @@ #include <QtCore/qoverload.h> #include <QtCore/qttypetraits.h> +#include <QtCore/qtypeinfo.h> #include <QtCore/qtypes.h> #ifdef __cpp_lib_three_way_comparison @@ -23,7 +24,7 @@ #endif #include <QtCore/q20type_traits.h> -#include <functional> // std::less +#include <functional> // std::less, std::hash QT_BEGIN_NAMESPACE @@ -145,8 +146,8 @@ template <typename In> constexpr auto to_Qt(In in) noexcept noexcept(noexcept(compareThreeWay(rhs, lhs))) \ { \ const auto r = compareThreeWay(rhs, lhs); \ - if (r > 0) return std::strong_ordering::less; \ - if (r < 0) return std::strong_ordering::greater; \ + if (is_gt(r)) return std::strong_ordering::less; \ + if (is_lt(r)) return std::strong_ordering::greater; \ return r; \ } @@ -157,8 +158,8 @@ template <typename In> constexpr auto to_Qt(In in) noexcept noexcept(noexcept(compareThreeWay(rhs, lhs))) \ { \ const auto r = compareThreeWay(rhs, lhs); \ - if (r > 0) return std::weak_ordering::less; \ - if (r < 0) return std::weak_ordering::greater; \ + if (is_gt(r)) return std::weak_ordering::less; \ + if (is_lt(r)) return std::weak_ordering::greater; \ return r; \ } @@ -169,8 +170,8 @@ template <typename In> constexpr auto to_Qt(In in) noexcept noexcept(noexcept(compareThreeWay(rhs, lhs))) \ { \ const auto r = compareThreeWay(rhs, lhs); \ - if (r > 0) return std::partial_ordering::less; \ - if (r < 0) return std::partial_ordering::greater; \ + if (is_gt(r)) return std::partial_ordering::less; \ + if (is_lt(r)) return std::partial_ordering::greater; \ return r; \ } @@ -218,19 +219,19 @@ template <typename In> constexpr auto to_Qt(In in) noexcept Attributes \ friend Constexpr bool operator<(LeftType const &lhs, RightType const &rhs) \ noexcept(noexcept(compareThreeWay(lhs, rhs))) \ - { return compareThreeWay(lhs, rhs) < 0; } \ + { return is_lt(compareThreeWay(lhs, rhs)); } \ Attributes \ friend Constexpr bool operator>(LeftType const &lhs, RightType const &rhs) \ noexcept(noexcept(compareThreeWay(lhs, rhs))) \ - { return compareThreeWay(lhs, rhs) > 0; } \ + { return is_gt(compareThreeWay(lhs, rhs)); } \ Attributes \ friend Constexpr bool operator<=(LeftType const &lhs, RightType const &rhs) \ noexcept(noexcept(compareThreeWay(lhs, rhs))) \ - { return compareThreeWay(lhs, rhs) <= 0; } \ + { return is_lteq(compareThreeWay(lhs, rhs)); } \ Attributes \ friend Constexpr bool operator>=(LeftType const &lhs, RightType const &rhs) \ noexcept(noexcept(compareThreeWay(lhs, rhs))) \ - { return compareThreeWay(lhs, rhs) >= 0; } + { return is_gteq(compareThreeWay(lhs, rhs)); } #define QT_DECLARE_ORDERING_HELPER_PARTIAL(LeftType, RightType, Constexpr, Attributes) \ QT_DECLARE_ORDERING_HELPER_TEMPLATE(Qt::partial_ordering, LeftType, RightType, Constexpr, \ @@ -255,19 +256,19 @@ template <typename In> constexpr auto to_Qt(In in) noexcept Attributes \ friend Constexpr bool operator<(RightType const &lhs, LeftType const &rhs) \ noexcept(noexcept(compareThreeWay(rhs, lhs))) \ - { return compareThreeWay(rhs, lhs) > 0; } \ + { return is_gt(compareThreeWay(rhs, lhs)); } \ Attributes \ friend Constexpr bool operator>(RightType const &lhs, LeftType const &rhs) \ noexcept(noexcept(compareThreeWay(rhs, lhs))) \ - { return compareThreeWay(rhs, lhs) < 0; } \ + { return is_lt(compareThreeWay(rhs, lhs)); } \ Attributes \ friend Constexpr bool operator<=(RightType const &lhs, LeftType const &rhs) \ noexcept(noexcept(compareThreeWay(rhs, lhs))) \ - { return compareThreeWay(rhs, lhs) >= 0; } \ + { return is_gteq(compareThreeWay(rhs, lhs)); } \ Attributes \ friend Constexpr bool operator>=(RightType const &lhs, LeftType const &rhs) \ noexcept(noexcept(compareThreeWay(rhs, lhs))) \ - { return compareThreeWay(rhs, lhs) <= 0; } + { return is_lteq(compareThreeWay(rhs, lhs)); } #define QT_DECLARE_REVERSED_ORDERING_HELPER_PARTIAL(LeftType, RightType, Constexpr, Attributes) \ QT_DECLARE_REVERSED_ORDERING_HELPER_TEMPLATE(Qt::partial_ordering, LeftType, RightType, \ @@ -559,9 +560,124 @@ constexpr Qt::strong_ordering compareThreeWay(Enum lhs, Enum rhs) noexcept { return compareThreeWay(qToUnderlying(lhs), qToUnderlying(rhs)); } - } // namespace Qt +namespace QtOrderingPrivate { + +template <typename Head, typename...Tail, std::size_t...Is> +constexpr std::tuple<Tail...> qt_tuple_pop_front_impl(const std::tuple<Head, Tail...> &t, + std::index_sequence<Is...>) noexcept +{ + return std::tuple<Tail...>(std::get<Is + 1>(t)...); +} + +template <typename Head, typename...Tail> +constexpr std::tuple<Tail...> qt_tuple_pop_front(const std::tuple<Head, Tail...> &t) noexcept +{ + return qt_tuple_pop_front_impl(t, std::index_sequence_for<Tail...>{}); +} + +template <typename LhsHead, typename...LhsTail, typename RhsHead, typename...RhsTail> +constexpr auto compareThreeWayMulti(const std::tuple<LhsHead, LhsTail...> &lhs, // ie. not empty + const std::tuple<RhsHead, RhsTail...> &rhs) noexcept +{ + static_assert(sizeof...(LhsTail) == sizeof...(RhsTail), + // expanded together below, but provide a nicer error message: + "The tuple arguments have to have the same size."); + + using Qt::compareThreeWay; + using R = std::common_type_t< + decltype(compareThreeWay(std::declval<LhsHead>(), std::declval<RhsHead>())), + decltype(compareThreeWay(std::declval<LhsTail>(), std::declval<RhsTail>()))... + >; + + const auto &l = std::get<0>(lhs); + const auto &r = std::get<0>(rhs); + static_assert(noexcept(compareThreeWay(l, r)), + "This function requires all relational operators to be noexcept."); + const auto res = compareThreeWay(l, r); + if constexpr (sizeof...(LhsTail) > 0) { + if (is_eq(res)) + return R{compareThreeWayMulti(qt_tuple_pop_front(lhs), qt_tuple_pop_front(rhs))}; + } + return R{res}; +} + +} //QtOrderingPrivate + +namespace Qt { +// A wrapper class that adapts the wrappee to use the strongly-ordered +// <functional> function objects for implementing the relational operators. +// Mostly useful to avoid UB on pointers (which it currently mandates P to be), +// because all the comparison helpers (incl. std::compare_three_way on +// std::tuple<T*>!) will use the language-level operators. +// +template <typename P> +class totally_ordered_wrapper +{ + static_assert(std::is_pointer_v<P>); + using T = std::remove_pointer_t<P>; + + P ptr; +public: + totally_ordered_wrapper() noexcept = default; + explicit constexpr totally_ordered_wrapper(P p) noexcept : ptr(p) {} + + constexpr P get() const noexcept { return ptr; } + constexpr P operator->() const noexcept { return get(); } + constexpr T& operator*() const noexcept { return *get(); } + + explicit constexpr operator bool() const noexcept { return get(); } + +private: + friend constexpr auto compareThreeWay(const totally_ordered_wrapper &lhs, const totally_ordered_wrapper &rhs) noexcept + { return Qt::compareThreeWay(lhs.ptr, rhs.ptr); } +#define MAKE_RELOP(Ret, op, Op) \ + friend constexpr Ret operator op (const totally_ordered_wrapper &lhs, const totally_ordered_wrapper &rhs) noexcept \ + { return std:: Op {}(lhs.ptr, rhs.ptr); } \ + friend constexpr Ret operator op (const totally_ordered_wrapper &lhs, const P &rhs) noexcept \ + { return std:: Op {}(lhs.ptr, rhs ); } \ + friend constexpr Ret operator op (const P &lhs, const totally_ordered_wrapper &rhs) noexcept \ + { return std:: Op {}(lhs, rhs.ptr); } \ + friend constexpr Ret operator op (const totally_ordered_wrapper &lhs, std::nullptr_t) noexcept \ + { return std:: Op {}(lhs.ptr, nullptr); } \ + friend constexpr Ret operator op (std::nullptr_t, const totally_ordered_wrapper &rhs) noexcept \ + { return std:: Op {}(nullptr, rhs.ptr); } \ + /* end */ + MAKE_RELOP(bool, ==, equal_to<P>) + MAKE_RELOP(bool, !=, not_equal_to<P>) + MAKE_RELOP(bool, < , less<P>) + MAKE_RELOP(bool, <=, less_equal<P>) + MAKE_RELOP(bool, > , greater<P>) + MAKE_RELOP(bool, >=, greater_equal<P>) +#ifdef __cpp_lib_three_way_comparison + MAKE_RELOP(auto, <=>, compare_three_way) +#endif +#undef MAKE_RELOP + friend void qt_ptr_swap(totally_ordered_wrapper &lhs, totally_ordered_wrapper &rhs) noexcept + { qt_ptr_swap(lhs.ptr, rhs.ptr); } + friend void swap(totally_ordered_wrapper &lhs, totally_ordered_wrapper &rhs) noexcept + { qt_ptr_swap(lhs, rhs); } + friend size_t qHash(totally_ordered_wrapper key, size_t seed = 0) noexcept + { return qHash(key.ptr, seed); } +}; + +} //Qt + +template <typename P> +class QTypeInfo<Qt::totally_ordered_wrapper<P>> : public QTypeInfo<P> {}; + QT_END_NAMESPACE +namespace std { + template <typename P> + struct hash<QT_PREPEND_NAMESPACE(Qt::totally_ordered_wrapper)<P>> + { + using argument_type = QT_PREPEND_NAMESPACE(Qt::totally_ordered_wrapper)<P>; + using result_type = size_t; + constexpr result_type operator()(argument_type w) const noexcept + { return std::hash<P>{}(w.get()); } + }; +} + #endif // QCOMPAREHELPERS_H diff --git a/src/corelib/global/qconfig-bootstrapped.h b/src/corelib/global/qconfig-bootstrapped.h index 4d80f23786..c2fe4661f6 100644 --- a/src/corelib/global/qconfig-bootstrapped.h +++ b/src/corelib/global/qconfig-bootstrapped.h @@ -72,6 +72,8 @@ # define QT_FEATURE_linkat -1 #endif #define QT_FEATURE_lttng -1 +#define QT_FEATURE_memmem -1 +#define QT_FEATURE_memrchr -1 #define QT_NO_QOBJECT #define QT_FEATURE_process -1 #define QT_FEATURE_regularexpression 1 diff --git a/src/corelib/global/qexceptionhandling.h b/src/corelib/global/qexceptionhandling.h index 76c6185c3e..7ffd0798f6 100644 --- a/src/corelib/global/qexceptionhandling.h +++ b/src/corelib/global/qexceptionhandling.h @@ -28,17 +28,11 @@ Q_NORETURN Q_DECL_COLD_FUNCTION Q_CORE_EXPORT void qTerminate() noexcept; # define QT_CATCH(A) else # define QT_THROW(A) qt_noop() # define QT_RETHROW qt_noop() -# define QT_TERMINATE_ON_EXCEPTION(expr) do { expr; } while (false) #else # define QT_TRY try # define QT_CATCH(A) catch (A) # define QT_THROW(A) throw A # define QT_RETHROW throw -# ifdef Q_COMPILER_NOEXCEPT -# define QT_TERMINATE_ON_EXCEPTION(expr) do { expr; } while (false) -# else -# define QT_TERMINATE_ON_EXCEPTION(expr) do { try { expr; } catch (...) { qTerminate(); } } while (false) -# endif #endif QT_END_NAMESPACE diff --git a/src/corelib/global/qglobal.cpp b/src/corelib/global/qglobal.cpp index 222c008f8a..6ce7f97580 100644 --- a/src/corelib/global/qglobal.cpp +++ b/src/corelib/global/qglobal.cpp @@ -63,6 +63,7 @@ using namespace Qt::StringLiterals; \row \li <QFlags> \li Type-safe way of combining enum values \row \li \l <QForeach> \li Qt's implementation of foreach and forever loops \row \li \l <QFunctionPointer> \li Typedef for a pointer-to-function type + \row \li \l <QApplicationStatic> \li For Q_APPLICATION_STATIC \row \li <QGlobalStatic> \li Thread-safe initialization of global static objects \row \li \l <QOverload> \li Helpers for resolving member function overloads \row \li <QSysInfo> \li A helper class to get system information @@ -170,6 +171,19 @@ bool QInternal::activateCallbacks(Callback cb, void **parameters) } /*! + \macro QT_NO_KEYWORDS + \relates <QtGlobal> + + Define this macro to disable the Qt-specific keywords that are usually enabled, + such as \c signals and \c slots. Use \c Q_SIGNALS and \c Q_SLOTS instead. + + Libraries should define this macro to make sure that they don't use the generic + keywords without the \c Q_ prefix in their public headers. + + \sa QT_NO_FOREACH +*/ + +/*! \macro QT_NAMESPACE \internal diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h index 1009057bad..2d70e82370 100644 --- a/src/corelib/global/qglobal.h +++ b/src/corelib/global/qglobal.h @@ -67,8 +67,9 @@ #include <QtCore/qtresource.h> #include <QtCore/qttranslation.h> #include <QtCore/qttypetraits.h> +#if QT_CONFIG(version_tagging) #include <QtCore/qversiontagging.h> - +#endif #endif /* __cplusplus */ #endif /* QGLOBAL_H */ diff --git a/src/corelib/global/qlibraryinfo.cpp b/src/corelib/global/qlibraryinfo.cpp index 92729b06f1..e09d2c72e1 100644 --- a/src/corelib/global/qlibraryinfo.cpp +++ b/src/corelib/global/qlibraryinfo.cpp @@ -516,75 +516,122 @@ QLibraryInfoPrivate::LocationInfo QLibraryInfoPrivate::locationInfo(QLibraryInfo /*! \since 6.0 Returns the path specified by \a p. + + If there is more than one path listed in qt.conf, it will + only return the first one. + \sa paths */ QString QLibraryInfo::path(LibraryPath p) { return QLibraryInfoPrivate::path(p); } +/*! + \since 6.8 + Returns all paths specificied by \a p. -/* - Returns the path specified by \a p. - - The usage mode can be set to UsedFromQtBinDir to enable special handling for executables that - live in <install-prefix>/bin. + \sa path */ -QString QLibraryInfoPrivate::path(QLibraryInfo::LibraryPath p, UsageMode usageMode) +QStringList QLibraryInfo::paths(LibraryPath p) +{ + return QLibraryInfoPrivate::paths(p); +} + +static bool keepQtBuildDefaults() +{ +#if QT_CONFIG(settings) + QSettings *config = QLibraryInfoPrivate::configuration(); + Q_ASSERT(config != nullptr); + return config->value("Config/MergeQtConf", false).toBool(); +#else + return false; +#endif +} + +#if QT_CONFIG(settings) +static QString normalizePath(QString ret) +{ + qsizetype startIndex = 0; + /* We support placeholders of the form $(<ENV_VAR>) in qt.conf. + The loop below tries to find all such placeholders, and replaces + them with the actual value of the ENV_VAR environment variable + */ + while (true) { + startIndex = ret.indexOf(u'$', startIndex); + if (startIndex < 0) + break; + if (ret.size() < startIndex + 3) + break; + if (ret.at(startIndex + 1) != u'(') { + startIndex++; + continue; + } + qsizetype endIndex = ret.indexOf(u')', startIndex + 2); + if (endIndex < 0) + break; + auto envVarName = QStringView{ret}.sliced(startIndex + 2, endIndex - startIndex - 2); + QString value = qEnvironmentVariable(envVarName.toLocal8Bit().constData()); + ret.replace(startIndex, endIndex - startIndex + 1, value); + startIndex += value.size(); + } + return QDir::fromNativeSeparators(ret); +}; + +static QVariant libraryPathToValue(QLibraryInfo::LibraryPath loc) +{ + QVariant value; + auto li = QLibraryInfoPrivate::locationInfo(loc); + if (li.key.isNull()) + return value; + QSettings *config = QLibraryInfoPrivate::configuration(); + Q_ASSERT(config != nullptr); + // if keepQtBuildDefaults returns true, + // we only consider explicit values listed in qt.conf + QVariant defaultValue = keepQtBuildDefaults() + ? QVariant() + : QVariant(li.defaultValue); + config->beginGroup("Paths"_L1); + auto cleanup = qScopeGuard([&]() { config->endGroup(); }); + if (li.fallbackKey.isNull()) { + value = config->value(li.key, defaultValue); + } else { + value = config->value(li.key); + if (!value.isValid()) + value = config->value(li.fallbackKey, defaultValue); + } + return value; +} +#endif // settings + +QStringList QLibraryInfoPrivate::paths(QLibraryInfo::LibraryPath p, + UsageMode usageMode) { const QLibraryInfo::LibraryPath loc = p; - QString ret; + QList<QString> ret; bool fromConf = false; #if QT_CONFIG(settings) if (havePaths()) { fromConf = true; - auto li = QLibraryInfoPrivate::locationInfo(loc); - if (!li.key.isNull()) { - QSettings *config = QLibraryInfoPrivate::configuration(); - Q_ASSERT(config != nullptr); - config->beginGroup("Paths"_L1); - - if (li.fallbackKey.isNull()) { - ret = config->value(li.key, li.defaultValue).toString(); - } else { - QVariant v = config->value(li.key); - if (!v.isValid()) - v = config->value(li.fallbackKey, li.defaultValue); - ret = v.toString(); - } - - qsizetype startIndex = 0; - while (true) { - startIndex = ret.indexOf(u'$', startIndex); - if (startIndex < 0) - break; - if (ret.size() < startIndex + 3) - break; - if (ret.at(startIndex + 1) != u'(') { - startIndex++; - continue; - } - qsizetype endIndex = ret.indexOf(u')', startIndex + 2); - if (endIndex < 0) - break; - auto envVarName = QStringView{ret}.mid(startIndex + 2, endIndex - startIndex - 2); - QString value = QString::fromLocal8Bit(qgetenv(envVarName.toLocal8Bit().constData())); - ret.replace(startIndex, endIndex - startIndex + 1, value); - startIndex += value.size(); - } - - config->endGroup(); + QVariant value = libraryPathToValue(loc); + if (value.isValid()) { - ret = QDir::fromNativeSeparators(ret); + if (auto *asList = get_if<QList<QString>>(&value)) + ret = std::move(*asList); + else + ret = QList<QString>({ std::move(value).toString()}); + for (qsizetype i = 0, end = ret.size(); i < end; ++i) + ret[i] = normalizePath(ret[i]); } } #endif // settings - if (!fromConf) { + if (!fromConf || keepQtBuildDefaults()) { + QString noConfResult; if (loc == QLibraryInfo::PrefixPath) { - ret = getPrefix(usageMode); + noConfResult = getPrefix(usageMode); } else if (int(loc) <= qt_configure_strs.count()) { - ret = QString::fromLocal8Bit(qt_configure_strs.viewAt(loc - 1)); + noConfResult = QString::fromLocal8Bit(qt_configure_strs.viewAt(loc - 1)); #ifndef Q_OS_WIN // On Windows we use the registry } else if (loc == QLibraryInfo::SettingsPath) { // Use of volatile is a hack to discourage compilers from calling @@ -592,24 +639,39 @@ QString QLibraryInfoPrivate::path(QLibraryInfo::LibraryPath p, UsageMode usageMo // compile-time, as Qt installers binary-patch the path, replacing // the dummy path seen at compile-time, typically changing length. const char *volatile path = QT_CONFIGURE_SETTINGS_PATH; - ret = QString::fromLocal8Bit(path); + noConfResult = QString::fromLocal8Bit(path); #endif } + if (!noConfResult.isEmpty()) + ret.push_back(std::move(noConfResult)); } + if (ret.isEmpty()) + return ret; - if (!ret.isEmpty() && QDir::isRelativePath(ret)) { - QString baseDir; - if (loc == QLibraryInfo::PrefixPath) { - baseDir = prefixFromAppDirHelper(); - } else { - // we make any other path absolute to the prefix directory - baseDir = path(QLibraryInfo::PrefixPath, usageMode); - } - ret = QDir::cleanPath(baseDir + u'/' + ret); + QString baseDir; + if (loc == QLibraryInfo::PrefixPath) { + baseDir = prefixFromAppDirHelper(); + } else { + // we make any other path absolute to the prefix directory + baseDir = QLibraryInfoPrivate::path(QLibraryInfo::PrefixPath, usageMode); } + for (qsizetype i = 0, end = ret.size(); i < end; ++i) + if (QDir::isRelativePath(ret[i])) + ret[i] = QDir::cleanPath(baseDir + u'/' + std::move(ret[i])); return ret; } +/* + Returns the path specified by \a p. + + The usage mode can be set to UsedFromQtBinDir to enable special handling for executables that + live in <install-prefix>/bin. + */ +QString QLibraryInfoPrivate::path(QLibraryInfo::LibraryPath p, UsageMode usageMode) +{ + return paths(p, usageMode).value(0, QString()); +} + /*! Returns additional arguments to the platform plugin matching \a platformName which can be specified as a string list using diff --git a/src/corelib/global/qlibraryinfo.h b/src/corelib/global/qlibraryinfo.h index d4e8f8b050..6cac6c83b0 100644 --- a/src/corelib/global/qlibraryinfo.h +++ b/src/corelib/global/qlibraryinfo.h @@ -42,6 +42,7 @@ public: SettingsPath = 100 }; static QString path(LibraryPath p); + static QStringList paths(LibraryPath p); #if QT_DEPRECATED_SINCE(6, 0) using LibraryLocation = LibraryPath; QT_DEPRECATED_VERSION_X_6_0("Use path()") diff --git a/src/corelib/global/qlibraryinfo_p.h b/src/corelib/global/qlibraryinfo_p.h index 4b471b932e..b9ca6b4d18 100644 --- a/src/corelib/global/qlibraryinfo_p.h +++ b/src/corelib/global/qlibraryinfo_p.h @@ -50,6 +50,7 @@ public: }; static QString path(QLibraryInfo::LibraryPath p, UsageMode usageMode = RegularUsage); + static QList<QString> paths(QLibraryInfo::LibraryPath p, UsageMode usageMode = RegularUsage); }; QT_END_NAMESPACE diff --git a/src/corelib/global/qlogging.cpp b/src/corelib/global/qlogging.cpp index dec16e4a77..efeec37094 100644 --- a/src/corelib/global/qlogging.cpp +++ b/src/corelib/global/qlogging.cpp @@ -834,7 +834,7 @@ void QMessageLogger::fatal(const QLoggingCategory &cat, const char *msg, ...) co va_list ap; va_start(ap, msg); // use variable arg list - QT_TERMINATE_ON_EXCEPTION(qt_message(QtFatalMsg, ctxt, msg, ap)); + qt_message(QtFatalMsg, ctxt, msg, ap); va_end(ap); #ifndef Q_CC_MSVC_ONLY @@ -858,7 +858,7 @@ void QMessageLogger::fatal(QMessageLogger::CategoryFunction catFunc, va_list ap; va_start(ap, msg); // use variable arg list - QT_TERMINATE_ON_EXCEPTION(qt_message(QtFatalMsg, ctxt, msg, ap)); + qt_message(QtFatalMsg, ctxt, msg, ap); va_end(ap); #ifndef Q_CC_MSVC_ONLY @@ -877,7 +877,7 @@ void QMessageLogger::fatal(const char *msg, ...) const noexcept QInternalMessageLogContext ctxt(context); va_list ap; va_start(ap, msg); // use variable arg list - QT_TERMINATE_ON_EXCEPTION(qt_message(QtFatalMsg, ctxt, msg, ap)); + qt_message(QtFatalMsg, ctxt, msg, ap); va_end(ap); #ifndef Q_CC_MSVC_ONLY @@ -2621,7 +2621,7 @@ QMessageLogContext &QMessageLogContext::copyContextFrom(const QMessageLogContext This enum describes the messages that can be sent to a message handler (QtMessageHandler). You can use the enum to identify and associate the various message types with the appropriate - actions. + actions. Its values are, in order of increasing severity: \value QtDebugMsg A message generated by the qDebug() function. @@ -2635,8 +2635,6 @@ QMessageLogContext &QMessageLogContext::copyContextFrom(const QMessageLogContext A message generated by the qFatal() function. \omitvalue QtSystemMsg - \c QtInfoMsg was added in Qt 5.5. - \sa QtMessageHandler, qInstallMessageHandler() */ diff --git a/src/corelib/global/qlogging.h b/src/corelib/global/qlogging.h index aa0ab93a2d..b4ec1a1235 100644 --- a/src/corelib/global/qlogging.h +++ b/src/corelib/global/qlogging.h @@ -28,10 +28,11 @@ class QNoDebug; enum QtMsgType { QtDebugMsg, + QT7_ONLY(QtInfoMsg,) QtWarningMsg, QtCriticalMsg, QtFatalMsg, - QtInfoMsg, + QT6_ONLY(QtInfoMsg,) #if QT_DEPRECATED_SINCE(6, 7) QtSystemMsg Q_DECL_ENUMERATOR_DEPRECATED_X("Use QtCriticalMsg instead.") = QtCriticalMsg #endif diff --git a/src/corelib/global/qminmax.h b/src/corelib/global/qminmax.h index e6fb62bf9d..fca13e047e 100644 --- a/src/corelib/global/qminmax.h +++ b/src/corelib/global/qminmax.h @@ -11,31 +11,10 @@ #include <QtCore/qassert.h> #include <QtCore/qtconfigmacros.h> - -#include <type_traits> +#include <QtCore/qttypetraits.h> QT_BEGIN_NAMESPACE -namespace QTypeTraits { - -namespace detail { -template<typename T, typename U, - typename = std::enable_if_t<std::is_arithmetic_v<T> && std::is_arithmetic_v<U> && - std::is_floating_point_v<T> == std::is_floating_point_v<U> && - std::is_signed_v<T> == std::is_signed_v<U> && - !std::is_same_v<T, bool> && !std::is_same_v<U, bool> && - !std::is_same_v<T, char> && !std::is_same_v<U, char>>> -struct Promoted -{ - using type = decltype(T() + U()); -}; -} - -template <typename T, typename U> -using Promoted = typename detail::Promoted<T, U>::type; - -} - template <typename T> constexpr inline const T &qMin(const T &a, const T &b) { return (a < b) ? a : b; } template <typename T> diff --git a/src/corelib/global/qnamespace.h b/src/corelib/global/qnamespace.h index 2398c0a1a4..9a0aa72bb5 100644 --- a/src/corelib/global/qnamespace.h +++ b/src/corelib/global/qnamespace.h @@ -462,7 +462,7 @@ namespace Qt { AA_DisableShaderDiskCache = 27, AA_DontShowShortcutsInContextMenus = 28, AA_CompressTabletEvents = 29, - AA_DontUsePopupWindows = 30, + // AA_DisableWindowContextHelpButton = 30, (in Qt 5) AA_DisableSessionManager = 31, // Add new attributes before this line @@ -1356,6 +1356,11 @@ namespace Qt { PreventContextMenu }; + enum class ContextMenuTrigger { + Press, + Release, + }; + enum InputMethodQuery { ImEnabled = 0x1, ImCursorRectangle = 0x2, @@ -1731,6 +1736,7 @@ namespace Qt { Q_ENUM_NS(ScrollBarPolicy) Q_ENUM_NS(FocusPolicy) Q_ENUM_NS(ContextMenuPolicy) + Q_ENUM_NS(ContextMenuTrigger) Q_ENUM_NS(ArrowType) Q_ENUM_NS(ToolButtonStyle) Q_ENUM_NS(PenStyle) diff --git a/src/corelib/global/qnamespace.qdoc b/src/corelib/global/qnamespace.qdoc index ddfade675a..6644ae8e13 100644 --- a/src/corelib/global/qnamespace.qdoc +++ b/src/corelib/global/qnamespace.qdoc @@ -279,11 +279,6 @@ level windows, unless required by the implementation. This value was added in Qt 6.8. - \value AA_DontUsePopupWindows When this attribute is set, popups will always appear - as items in the scene, rather than having their own dedicated windows. - Setting this attribute will only affect Qt Quick applications. - This value was added in Qt 6.8. - \omitvalue AA_AttributeCount \omitvalue AA_EnableHighDpiScaling \omitvalue AA_UseHighDpiPixmaps @@ -2087,6 +2082,18 @@ */ /*! + \enum Qt::ContextMenuTrigger + \since 6.8 + + This enum type defines the mouse event used to trigger a context menu event. + + \value Press context menu on mouse press event, default on UNIX systems. + \value Release context menu on mouse release event, default on Windows. + + \sa QStyleHints::contextMenuTrigger +*/ + +/*! \enum Qt::FocusPolicy This enum type defines the various policies a widget can have with @@ -3251,7 +3258,7 @@ The underlying type is \c int. You can use \l qToUnderlying() to convert Qt::TimerId to \c int. - \value Invalid Represents a no-op timer ID; it's usage depends on the + \value Invalid Represents a no-op timer ID; its usage depends on the context, for example, this is the value returned by QObject::startTimer() to indicate it failed to start a timer; whereas QChronoTimer::id() returns this value when the timer is inactive, that is, \c timer.isActive() diff --git a/src/corelib/global/qtconfigmacros.h b/src/corelib/global/qtconfigmacros.h index 018161eac4..b643122d5c 100644 --- a/src/corelib/global/qtconfigmacros.h +++ b/src/corelib/global/qtconfigmacros.h @@ -9,6 +9,8 @@ #endif #include <QtCore/qtconfiginclude.h> +#include <QtCore/qtdeprecationdefinitions.h> +#include <QtCore/qtversionchecks.h> #include <assert.h> diff --git a/src/corelib/global/qtdeprecationdefinitions.h.in b/src/corelib/global/qtdeprecationdefinitions.h.in new file mode 100644 index 0000000000..0570f63a5a --- /dev/null +++ b/src/corelib/global/qtdeprecationdefinitions.h.in @@ -0,0 +1,28 @@ +// 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 + +#ifndef QTDEPRECATIONDEFINITIONS_H +#define QTDEPRECATIONDEFINITIONS_H + +#ifndef QT_DISABLE_DEPRECATED_UP_TO +# ifdef QT_DISABLE_DEPRECATED_BEFORE // If the deprecated macro is defined, use its value +# define QT_DISABLE_DEPRECATED_UP_TO QT_DISABLE_DEPRECATED_BEFORE +# else +# define QT_DISABLE_DEPRECATED_UP_TO @QT_DISABLE_DEPRECATED_UP_TO@ +# endif +#endif + +#if QT_DISABLE_DEPRECATED_UP_TO < @QT_DISABLE_DEPRECATED_UP_TO@ +# warning QT_DISABLE_DEPRECATED_UP_TO is set to the version that is lower than the version that \ + Qt was built with. This may lead to linking issues. +#endif + +#ifndef QT_WARN_DEPRECATED_UP_TO +# ifdef QT_DEPRECATED_WARNINGS_SINCE // If the deprecated macro is defined, use its value +# define QT_WARN_DEPRECATED_UP_TO QT_DEPRECATED_WARNINGS_SINCE +# else +# define QT_WARN_DEPRECATED_UP_TO @QT_WARN_DEPRECATED_UP_TO@ +# endif +#endif + +#endif // QTDEPRECATIONDEFINITIONS_H diff --git a/src/corelib/global/qtdeprecationmarkers.h b/src/corelib/global/qtdeprecationmarkers.h index 6df5ebce6d..68f4fda186 100644 --- a/src/corelib/global/qtdeprecationmarkers.h +++ b/src/corelib/global/qtdeprecationmarkers.h @@ -5,6 +5,7 @@ #define QTDEPRECATIONMARKERS_H #include <QtCore/qtconfigmacros.h> +#include <QtCore/qtdeprecationdefinitions.h> #include <QtCore/qtversionchecks.h> #include <QtCore/qcompilerdetection.h> // for Q_DECL_DEPRECATED @@ -44,28 +45,6 @@ QT_BEGIN_NAMESPACE # define Q_DECL_ENUMERATOR_DEPRECATED_X(ignored) #endif -// If the deprecated macro is defined, use its value -#if !defined(QT_DISABLE_DEPRECATED_UP_TO) && defined(QT_DISABLE_DEPRECATED_BEFORE) -# define QT_DISABLE_DEPRECATED_UP_TO QT_DISABLE_DEPRECATED_BEFORE -#endif - -// If the deprecated macro is defined, use its value -#if !defined(QT_WARN_DEPRECATED_UP_TO) && defined(QT_DEPRECATED_WARNINGS_SINCE) -# define QT_WARN_DEPRECATED_UP_TO QT_DEPRECATED_WARNINGS_SINCE -#endif - -#ifndef QT_WARN_DEPRECATED_UP_TO -# ifdef QT_DISABLE_DEPRECATED_UP_TO -# define QT_WARN_DEPRECATED_UP_TO QT_DISABLE_DEPRECATED_UP_TO -# else -# define QT_WARN_DEPRECATED_UP_TO QT_VERSION -# endif -#endif - -#ifndef QT_DISABLE_DEPRECATED_UP_TO -#define QT_DISABLE_DEPRECATED_UP_TO QT_VERSION_CHECK(5, 0, 0) -#endif - /* QT_DEPRECATED_SINCE(major, minor) evaluates as true if the Qt version is greater than the deprecation point specified. diff --git a/src/corelib/global/qttypetraits.h b/src/corelib/global/qttypetraits.h index 1efb24bf70..2cd68c73cb 100644 --- a/src/corelib/global/qttypetraits.h +++ b/src/corelib/global/qttypetraits.h @@ -7,8 +7,11 @@ #include <QtCore/qtconfigmacros.h> #include <QtCore/qtdeprecationmarkers.h> +#include <optional> +#include <tuple> #include <type_traits> #include <utility> +#include <variant> #if 0 #pragma qt_class(QtTypeTraits) @@ -60,6 +63,212 @@ template <typename T> struct type_dependent_false : std::false_type {}; template <auto T> struct value_dependent_false : std::false_type {}; } +namespace QTypeTraits { + +namespace detail { +template<typename T, typename U, + typename = std::enable_if_t<std::is_arithmetic_v<T> && std::is_arithmetic_v<U> && + std::is_floating_point_v<T> == std::is_floating_point_v<U> && + std::is_signed_v<T> == std::is_signed_v<U> && + !std::is_same_v<T, bool> && !std::is_same_v<U, bool> && + !std::is_same_v<T, char> && !std::is_same_v<U, char>>> +struct Promoted +{ + using type = decltype(T() + U()); +}; +} + +template <typename T, typename U> +using Promoted = typename detail::Promoted<T, U>::type; + +/* + The templates below aim to find out whether one can safely instantiate an operator==() or + operator<() for a type. + + This is tricky for containers, as most containers have unconstrained comparison operators, even though they + rely on the corresponding operators for its content. + This is especially true for all of the STL template classes that have a comparison operator defined, and + leads to the situation, that the compiler would try to instantiate the operator, and fail if any + of its template arguments does not have the operator implemented. + + The code tries to cover the relevant cases for Qt and the STL, by checking (recusrsively) the value_type + of a container (if it exists), and checking the template arguments of pair, tuple and variant. +*/ +namespace detail { + +// find out whether T is a conteiner +// this is required to check the value type of containers for the existence of the comparison operator +template <typename, typename = void> +struct is_container : std::false_type {}; +template <typename T> +struct is_container<T, std::void_t< + typename T::value_type, + std::is_convertible<decltype(std::declval<T>().begin() != std::declval<T>().end()), bool> +>> : std::true_type {}; + + +// Checks the existence of the comparison operator for the class itself +QT_WARNING_PUSH +QT_WARNING_DISABLE_FLOAT_COMPARE +template <typename, typename = void> +struct has_operator_equal : std::false_type {}; +template <typename T> +struct has_operator_equal<T, std::void_t<decltype(bool(std::declval<const T&>() == std::declval<const T&>()))>> + : std::true_type {}; +QT_WARNING_POP + +// Two forward declarations +template<typename T, bool = is_container<T>::value> +struct expand_operator_equal_container; +template<typename T> +struct expand_operator_equal_tuple; + +// the entry point for the public method +template<typename T> +using expand_operator_equal = expand_operator_equal_container<T>; + +// if T isn't a container check if it's a tuple like object +template<typename T, bool> +struct expand_operator_equal_container : expand_operator_equal_tuple<T> {}; +// if T::value_type exists, check first T::value_type, then T itself +template<typename T> +struct expand_operator_equal_container<T, true> : + std::conjunction< + std::disjunction< + std::is_same<T, typename T::value_type>, // avoid endless recursion + expand_operator_equal<typename T::value_type> + >, expand_operator_equal_tuple<T>> {}; + +// recursively check the template arguments of a tuple like object +template<typename ...T> +using expand_operator_equal_recursive = std::conjunction<expand_operator_equal<T>...>; + +template<typename T> +struct expand_operator_equal_tuple : has_operator_equal<T> {}; +template<typename T> +struct expand_operator_equal_tuple<std::optional<T>> : expand_operator_equal_recursive<T> {}; +template<typename T1, typename T2> +struct expand_operator_equal_tuple<std::pair<T1, T2>> : expand_operator_equal_recursive<T1, T2> {}; +template<typename ...T> +struct expand_operator_equal_tuple<std::tuple<T...>> : expand_operator_equal_recursive<T...> {}; +template<typename ...T> +struct expand_operator_equal_tuple<std::variant<T...>> : expand_operator_equal_recursive<T...> {}; + +// the same for operator<(), see above for explanations +template <typename, typename = void> +struct has_operator_less_than : std::false_type{}; +template <typename T> +struct has_operator_less_than<T, std::void_t<decltype(bool(std::declval<const T&>() < std::declval<const T&>()))>> + : std::true_type{}; + +template<typename T, bool = is_container<T>::value> +struct expand_operator_less_than_container; +template<typename T> +struct expand_operator_less_than_tuple; + +template<typename T> +using expand_operator_less_than = expand_operator_less_than_container<T>; + +template<typename T, bool> +struct expand_operator_less_than_container : expand_operator_less_than_tuple<T> {}; +template<typename T> +struct expand_operator_less_than_container<T, true> : + std::conjunction< + std::disjunction< + std::is_same<T, typename T::value_type>, + expand_operator_less_than<typename T::value_type> + >, expand_operator_less_than_tuple<T> + > {}; + +template<typename ...T> +using expand_operator_less_than_recursive = std::conjunction<expand_operator_less_than<T>...>; + +template<typename T> +struct expand_operator_less_than_tuple : has_operator_less_than<T> {}; +template<typename T> +struct expand_operator_less_than_tuple<std::optional<T>> : expand_operator_less_than_recursive<T> {}; +template<typename T1, typename T2> +struct expand_operator_less_than_tuple<std::pair<T1, T2>> : expand_operator_less_than_recursive<T1, T2> {}; +template<typename ...T> +struct expand_operator_less_than_tuple<std::tuple<T...>> : expand_operator_less_than_recursive<T...> {}; +template<typename ...T> +struct expand_operator_less_than_tuple<std::variant<T...>> : expand_operator_less_than_recursive<T...> {}; + +} + +template<typename T, typename = void> +struct is_dereferenceable : std::false_type {}; + +template<typename T> +struct is_dereferenceable<T, std::void_t<decltype(std::declval<T>().operator->())> > + : std::true_type {}; + +template <typename T> +inline constexpr bool is_dereferenceable_v = is_dereferenceable<T>::value; + +template<typename T> +struct has_operator_equal : detail::expand_operator_equal<T> {}; +template<typename T> +inline constexpr bool has_operator_equal_v = has_operator_equal<T>::value; + +template <typename Container, typename T> +using has_operator_equal_container = std::disjunction<std::is_base_of<Container, T>, QTypeTraits::has_operator_equal<T>>; + +template<typename T> +struct has_operator_less_than : detail::expand_operator_less_than<T> {}; +template<typename T> +inline constexpr bool has_operator_less_than_v = has_operator_less_than<T>::value; + +template <typename Container, typename T> +using has_operator_less_than_container = std::disjunction<std::is_base_of<Container, T>, QTypeTraits::has_operator_less_than<T>>; + +template <typename ...T> +using compare_eq_result = std::enable_if_t<std::conjunction_v<QTypeTraits::has_operator_equal<T>...>, bool>; + +template <typename Container, typename ...T> +using compare_eq_result_container = std::enable_if_t<std::conjunction_v<QTypeTraits::has_operator_equal_container<Container, T>...>, bool>; + +template <typename ...T> +using compare_lt_result = std::enable_if_t<std::conjunction_v<QTypeTraits::has_operator_less_than<T>...>, bool>; + +template <typename Container, typename ...T> +using compare_lt_result_container = std::enable_if_t<std::conjunction_v<QTypeTraits::has_operator_less_than_container<Container, T>...>, bool>; + +namespace detail { + +template<typename T> +const T &const_reference(); +template<typename T> +T &reference(); + +} + +template <typename Stream, typename, typename = void> +struct has_ostream_operator : std::false_type {}; +template <typename Stream, typename T> +struct has_ostream_operator<Stream, T, std::void_t<decltype(detail::reference<Stream>() << detail::const_reference<T>())>> + : std::true_type {}; +template <typename Stream, typename T> +inline constexpr bool has_ostream_operator_v = has_ostream_operator<Stream, T>::value; + +template <typename Stream, typename Container, typename T> +using has_ostream_operator_container = std::disjunction<std::is_base_of<Container, T>, QTypeTraits::has_ostream_operator<Stream, T>>; + +template <typename Stream, typename, typename = void> +struct has_istream_operator : std::false_type {}; +template <typename Stream, typename T> +struct has_istream_operator<Stream, T, std::void_t<decltype(detail::reference<Stream>() >> detail::reference<T>())>> + : std::true_type {}; +template <typename Stream, typename T> +inline constexpr bool has_istream_operator_v = has_istream_operator<Stream, T>::value; +template <typename Stream, typename Container, typename T> +using has_istream_operator_container = std::disjunction<std::is_base_of<Container, T>, QTypeTraits::has_istream_operator<Stream, T>>; + +template <typename Stream, typename T> +inline constexpr bool has_stream_operator_v = has_ostream_operator_v<Stream, T> && has_istream_operator_v<Stream, T>; + +} // namespace QTypeTraits + QT_END_NAMESPACE #endif // QTTYPETRAITS_H diff --git a/src/corelib/global/qtypeinfo.h b/src/corelib/global/qtypeinfo.h index 255a2b33c6..e9dfbc34a4 100644 --- a/src/corelib/global/qtypeinfo.h +++ b/src/corelib/global/qtypeinfo.h @@ -8,9 +8,6 @@ #include <QtCore/qcompilerdetection.h> #include <QtCore/qcontainerfwd.h> -#include <variant> -#include <optional> -#include <tuple> #include <type_traits> QT_BEGIN_NAMESPACE @@ -186,197 +183,5 @@ template<typename T> class QFlags; template<typename T> Q_DECLARE_TYPEINFO_BODY(QFlags<T>, Q_PRIMITIVE_TYPE); -namespace QTypeTraits -{ - -/* - The templates below aim to find out whether one can safely instantiate an operator==() or - operator<() for a type. - - This is tricky for containers, as most containers have unconstrained comparison operators, even though they - rely on the corresponding operators for its content. - This is especially true for all of the STL template classes that have a comparison operator defined, and - leads to the situation, that the compiler would try to instantiate the operator, and fail if any - of its template arguments does not have the operator implemented. - - The code tries to cover the relevant cases for Qt and the STL, by checking (recusrsively) the value_type - of a container (if it exists), and checking the template arguments of pair, tuple and variant. -*/ -namespace detail { - -// find out whether T is a conteiner -// this is required to check the value type of containers for the existence of the comparison operator -template <typename, typename = void> -struct is_container : std::false_type {}; -template <typename T> -struct is_container<T, std::void_t< - typename T::value_type, - std::is_convertible<decltype(std::declval<T>().begin() != std::declval<T>().end()), bool> ->> : std::true_type {}; - - -// Checks the existence of the comparison operator for the class itself -QT_WARNING_PUSH -QT_WARNING_DISABLE_FLOAT_COMPARE -template <typename, typename = void> -struct has_operator_equal : std::false_type {}; -template <typename T> -struct has_operator_equal<T, std::void_t<decltype(bool(std::declval<const T&>() == std::declval<const T&>()))>> - : std::true_type {}; -QT_WARNING_POP - -// Two forward declarations -template<typename T, bool = is_container<T>::value> -struct expand_operator_equal_container; -template<typename T> -struct expand_operator_equal_tuple; - -// the entry point for the public method -template<typename T> -using expand_operator_equal = expand_operator_equal_container<T>; - -// if T isn't a container check if it's a tuple like object -template<typename T, bool> -struct expand_operator_equal_container : expand_operator_equal_tuple<T> {}; -// if T::value_type exists, check first T::value_type, then T itself -template<typename T> -struct expand_operator_equal_container<T, true> : - std::conjunction< - std::disjunction< - std::is_same<T, typename T::value_type>, // avoid endless recursion - expand_operator_equal<typename T::value_type> - >, expand_operator_equal_tuple<T>> {}; - -// recursively check the template arguments of a tuple like object -template<typename ...T> -using expand_operator_equal_recursive = std::conjunction<expand_operator_equal<T>...>; - -template<typename T> -struct expand_operator_equal_tuple : has_operator_equal<T> {}; -template<typename T> -struct expand_operator_equal_tuple<std::optional<T>> : expand_operator_equal_recursive<T> {}; -template<typename T1, typename T2> -struct expand_operator_equal_tuple<std::pair<T1, T2>> : expand_operator_equal_recursive<T1, T2> {}; -template<typename ...T> -struct expand_operator_equal_tuple<std::tuple<T...>> : expand_operator_equal_recursive<T...> {}; -template<typename ...T> -struct expand_operator_equal_tuple<std::variant<T...>> : expand_operator_equal_recursive<T...> {}; - -// the same for operator<(), see above for explanations -template <typename, typename = void> -struct has_operator_less_than : std::false_type{}; -template <typename T> -struct has_operator_less_than<T, std::void_t<decltype(bool(std::declval<const T&>() < std::declval<const T&>()))>> - : std::true_type{}; - -template<typename T, bool = is_container<T>::value> -struct expand_operator_less_than_container; -template<typename T> -struct expand_operator_less_than_tuple; - -template<typename T> -using expand_operator_less_than = expand_operator_less_than_container<T>; - -template<typename T, bool> -struct expand_operator_less_than_container : expand_operator_less_than_tuple<T> {}; -template<typename T> -struct expand_operator_less_than_container<T, true> : - std::conjunction< - std::disjunction< - std::is_same<T, typename T::value_type>, - expand_operator_less_than<typename T::value_type> - >, expand_operator_less_than_tuple<T> - > {}; - -template<typename ...T> -using expand_operator_less_than_recursive = std::conjunction<expand_operator_less_than<T>...>; - -template<typename T> -struct expand_operator_less_than_tuple : has_operator_less_than<T> {}; -template<typename T> -struct expand_operator_less_than_tuple<std::optional<T>> : expand_operator_less_than_recursive<T> {}; -template<typename T1, typename T2> -struct expand_operator_less_than_tuple<std::pair<T1, T2>> : expand_operator_less_than_recursive<T1, T2> {}; -template<typename ...T> -struct expand_operator_less_than_tuple<std::tuple<T...>> : expand_operator_less_than_recursive<T...> {}; -template<typename ...T> -struct expand_operator_less_than_tuple<std::variant<T...>> : expand_operator_less_than_recursive<T...> {}; - -} - -template<typename T, typename = void> -struct is_dereferenceable : std::false_type {}; - -template<typename T> -struct is_dereferenceable<T, std::void_t<decltype(std::declval<T>().operator->())> > - : std::true_type {}; - -template <typename T> -inline constexpr bool is_dereferenceable_v = is_dereferenceable<T>::value; - -template<typename T> -struct has_operator_equal : detail::expand_operator_equal<T> {}; -template<typename T> -inline constexpr bool has_operator_equal_v = has_operator_equal<T>::value; - -template <typename Container, typename T> -using has_operator_equal_container = std::disjunction<std::is_base_of<Container, T>, QTypeTraits::has_operator_equal<T>>; - -template<typename T> -struct has_operator_less_than : detail::expand_operator_less_than<T> {}; -template<typename T> -inline constexpr bool has_operator_less_than_v = has_operator_less_than<T>::value; - -template <typename Container, typename T> -using has_operator_less_than_container = std::disjunction<std::is_base_of<Container, T>, QTypeTraits::has_operator_less_than<T>>; - -template <typename ...T> -using compare_eq_result = std::enable_if_t<std::conjunction_v<QTypeTraits::has_operator_equal<T>...>, bool>; - -template <typename Container, typename ...T> -using compare_eq_result_container = std::enable_if_t<std::conjunction_v<QTypeTraits::has_operator_equal_container<Container, T>...>, bool>; - -template <typename ...T> -using compare_lt_result = std::enable_if_t<std::conjunction_v<QTypeTraits::has_operator_less_than<T>...>, bool>; - -template <typename Container, typename ...T> -using compare_lt_result_container = std::enable_if_t<std::conjunction_v<QTypeTraits::has_operator_less_than_container<Container, T>...>, bool>; - -namespace detail { - -template<typename T> -const T &const_reference(); -template<typename T> -T &reference(); - -} - -template <typename Stream, typename, typename = void> -struct has_ostream_operator : std::false_type {}; -template <typename Stream, typename T> -struct has_ostream_operator<Stream, T, std::void_t<decltype(detail::reference<Stream>() << detail::const_reference<T>())>> - : std::true_type {}; -template <typename Stream, typename T> -inline constexpr bool has_ostream_operator_v = has_ostream_operator<Stream, T>::value; - -template <typename Stream, typename Container, typename T> -using has_ostream_operator_container = std::disjunction<std::is_base_of<Container, T>, QTypeTraits::has_ostream_operator<Stream, T>>; - -template <typename Stream, typename, typename = void> -struct has_istream_operator : std::false_type {}; -template <typename Stream, typename T> -struct has_istream_operator<Stream, T, std::void_t<decltype(detail::reference<Stream>() >> detail::reference<T>())>> - : std::true_type {}; -template <typename Stream, typename T> -inline constexpr bool has_istream_operator_v = has_istream_operator<Stream, T>::value; -template <typename Stream, typename Container, typename T> -using has_istream_operator_container = std::disjunction<std::is_base_of<Container, T>, QTypeTraits::has_istream_operator<Stream, T>>; - -template <typename Stream, typename T> -inline constexpr bool has_stream_operator_v = has_ostream_operator_v<Stream, T> && has_istream_operator_v<Stream, T>; - -} - - QT_END_NAMESPACE #endif // QTYPEINFO_H diff --git a/src/corelib/global/qversiontagging.h b/src/corelib/global/qversiontagging.h index 965d53e88f..fa2dd23728 100644 --- a/src/corelib/global/qversiontagging.h +++ b/src/corelib/global/qversiontagging.h @@ -13,6 +13,8 @@ #include <QtCore/qtversionchecks.h> #include <QtCore/qtypes.h> +QT_REQUIRE_CONFIG(version_tagging); + QT_BEGIN_NAMESPACE /* diff --git a/src/corelib/io/qbuffer.cpp b/src/corelib/io/qbuffer.cpp index 763620692c..4e513bc7cf 100644 --- a/src/corelib/io/qbuffer.cpp +++ b/src/corelib/io/qbuffer.cpp @@ -282,8 +282,7 @@ void QBuffer::setData(const char *data, qsizetype size) qWarning("QBuffer::setData: Buffer is open"); return; } - d->buf->replace(qsizetype(0), d->buf->size(), // ### QByteArray lacks assign(ptr, n) - data, size); + d->buf->assign(data, data + size); } /*! diff --git a/src/corelib/io/qdebug.h b/src/corelib/io/qdebug.h index 4797bcd169..44c3dea804 100644 --- a/src/corelib/io/qdebug.h +++ b/src/corelib/io/qdebug.h @@ -11,6 +11,7 @@ #include <QtCore/qcontainerfwd.h> #include <QtCore/qtextstream.h> +#include <QtCore/qttypetraits.h> #include <QtCore/qtypes.h> #include <QtCore/qstring.h> #include <QtCore/qcontiguouscache.h> diff --git a/src/corelib/io/qdir.cpp b/src/corelib/io/qdir.cpp index 9291201d88..05947f3380 100644 --- a/src/corelib/io/qdir.cpp +++ b/src/corelib/io/qdir.cpp @@ -313,9 +313,10 @@ inline void QDirPrivate::sortFileList(QDir::SortFlags sort, const QFileInfoList names->append(fi.fileName()); } } else { - QScopedArrayPointer<QDirSortItem> si(new QDirSortItem[n]); + QVarLengthArray<QDirSortItem, 64> si; + si.reserve(n); for (qsizetype i = 0; i < n; ++i) - si[i] = QDirSortItem{l.at(i), sort}; + si.emplace_back(l.at(i), sort); #ifndef QT_BOOTSTRAPPED if (sort.testAnyFlag(QDir::LocaleAware)) { diff --git a/src/corelib/io/qdirlisting.cpp b/src/corelib/io/qdirlisting.cpp index 008003e856..bc4d7c98e9 100644 --- a/src/corelib/io/qdirlisting.cpp +++ b/src/corelib/io/qdirlisting.cpp @@ -25,12 +25,11 @@ \snippet code/src_corelib_io_qdirlisting.cpp 1 Iterators constructed by QDirListing (QDirListing::const_iterator) are - forward-only (you cannot iterate directories in reverse order) and don't - allow random access. They can be used in ranged-for loops (or with STL - alogrithms that don't require random access iterators). Dereferencing - a valid iterator returns a QDirListing::DirEntry object. The (c)end() - iterator marks the end of the iteration. Dereferencing the end iterator - is undefiend behavior. + forward-only, single-pass iterators, that don't allow random access. They + can be used in ranged-for loops (or with STL alogrithms that don't + require random access iterators). Dereferencing a valid iterator returns + a QDirListing::DirEntry object. The (c)end() iterator marks the end of + the iteration. Dereferencing the end iterator is undefined behavior. QDirListing::DirEntry offers a subset of QFileInfo's API (for example, fileName(), filePath(), exists()). Internally, DirEntry only constructs @@ -80,7 +79,6 @@ #include <QtCore/private/qduplicatetracker_p.h> #include <memory> -#include <stack> #include <vector> QT_BEGIN_NAMESPACE @@ -92,6 +90,7 @@ class QDirListingPrivate public: void init(bool resolveEngine); void advance(); + void beginIterating(); bool entryMatches(QDirEntryInfo &info); void pushDirectory(QDirEntryInfo &info); @@ -113,10 +112,10 @@ public: #endif using FEngineIteratorPtr = std::unique_ptr<QAbstractFileEngineIterator>; - std::stack<FEngineIteratorPtr, std::vector<FEngineIteratorPtr>> fileEngineIterators; + std::vector<FEngineIteratorPtr> fileEngineIterators; #ifndef QT_NO_FILESYSTEMITERATOR using FsIteratorPtr = std::unique_ptr<QFileSystemIterator>; - std::stack<FsIteratorPtr, std::vector<FsIteratorPtr>> nativeIterators; + std::vector<FsIteratorPtr> nativeIterators; #endif // Loop protection @@ -143,7 +142,21 @@ void QDirListingPrivate::init(bool resolveEngine = true) engine = QFileSystemEngine::createLegacyEngine(initialEntryInfo.entry, initialEntryInfo.metaData); } +} + +/*! + \internal + Resets the iteration state (if any), so that calling begin()/cbegin() + always starts iterating anew. +*/ +void QDirListingPrivate::beginIterating() +{ +#ifndef QT_NO_FILESYSTEMITERATOR + nativeIterators.clear(); +#endif + fileEngineIterators.clear(); + visitedLinks.clear(); pushDirectory(initialEntryInfo); } @@ -167,7 +180,7 @@ void QDirListingPrivate::pushDirectory(QDirEntryInfo &entryInfo) if (engine) { engine->setFileName(path); if (auto it = engine->beginEntryList(path, filters, nameFilters)) { - fileEngineIterators.emplace(std::move(it)); + fileEngineIterators.emplace_back(std::move(it)); } else { // No iterator; no entry list. } @@ -178,7 +191,7 @@ void QDirListingPrivate::pushDirectory(QDirEntryInfo &entryInfo) fentry = &entryInfo.fileInfoOpt->d_ptr->fileEntry; else fentry = &entryInfo.entry; - nativeIterators.emplace(std::make_unique<QFileSystemIterator>(*fentry, filters)); + nativeIterators.emplace_back(std::make_unique<QFileSystemIterator>(*fentry, filters)); #else qWarning("Qt was built with -no-feature-filesystemiterator: no files/plugins will be found!"); #endif @@ -196,19 +209,18 @@ bool QDirListingPrivate::entryMatches(QDirEntryInfo &entryInfo) Advances the internal iterator, either a QAbstractFileEngineIterator (e.g. QResourceFileEngineIterator) or a QFileSystemIterator (which uses low-level - system methods, e.g. readdir() on Unix). - - An iterator stack is used for holding the iterators. + system methods, e.g. readdir() on Unix). The iterators are stored in a + vector. A typical example of doing recursive iteration: - while iterating directory A we find a sub-dir B - - an iterator for B is added to the iterator stack - - B's iterator is processed (the top() of the stack) first; then loop + - an iterator for B is added to the vector + - B's iterator is processed (vector.back()) first; then the loop goes back to processing A's iterator */ void QDirListingPrivate::advance() { - // Use get() in both code paths below because the iterator returned by top() + // Use get() in both code paths below because the iterator returned by back() // may be invalidated due to reallocation when appending new iterators in // pushDirectory(). @@ -216,7 +228,7 @@ void QDirListingPrivate::advance() while (!fileEngineIterators.empty()) { // Find the next valid iterator that matches the filters. QAbstractFileEngineIterator *it; - while (it = fileEngineIterators.top().get(), it->advance()) { + while (it = fileEngineIterators.back().get(), it->advance()) { QDirEntryInfo entryInfo; entryInfo.fileInfoOpt = it->currentFileInfo(); if (entryMatches(entryInfo)) { @@ -225,7 +237,7 @@ void QDirListingPrivate::advance() } } - fileEngineIterators.pop(); + fileEngineIterators.pop_back(); } } else { #ifndef QT_NO_FILESYSTEMITERATOR @@ -233,7 +245,8 @@ void QDirListingPrivate::advance() while (!nativeIterators.empty()) { // Find the next valid iterator that matches the filters. QFileSystemIterator *it; - while (it = nativeIterators.top().get(), it->advance(entryInfo.entry, entryInfo.metaData)) { + while (it = nativeIterators.back().get(), + it->advance(entryInfo.entry, entryInfo.metaData)) { if (entryMatches(entryInfo)) { currentEntryInfo = std::move(entryInfo); return; @@ -241,7 +254,7 @@ void QDirListingPrivate::advance() entryInfo = {}; } - nativeIterators.pop(); + nativeIterators.pop_back(); } #endif } @@ -383,7 +396,7 @@ bool QDirListingPrivate::hasIterators() const \note To list symlinks that point to non existing files, QDir::System must be set in \a dir's QDir::Filters. - \sa hasNext(), next(), IteratorFlags + \sa IteratorFlags */ QDirListing::QDirListing(const QDir &dir, IteratorFlags flags) : d(new QDirListingPrivate) @@ -408,7 +421,7 @@ QDirListing::QDirListing(const QDir &dir, IteratorFlags flags) \note To list symlinks that point to non existing files, QDir::System must be set in \a filters. - \sa hasNext(), next(), IteratorFlags + \sa IteratorFlags */ QDirListing::QDirListing(const QString &path, QDir::Filters filters, IteratorFlags flags) : d(new QDirListingPrivate) @@ -426,7 +439,7 @@ QDirListing::QDirListing(const QString &path, QDir::Filters filters, IteratorFla By default, \a flags is NoIteratorFlags, which provides the same behavior as in QDir::entryList(). - \sa hasNext(), next(), IteratorFlags + \sa IteratorFlags */ QDirListing::QDirListing(const QString &path, IteratorFlags flags) : d(new QDirListingPrivate) @@ -453,7 +466,7 @@ QDirListing::QDirListing(const QString &path, IteratorFlags flags) \note To list symlinks that point to non existing files, QDir::System must be set in \a flags. - \sa hasNext(), next(), IteratorFlags, QDir::setNameFilters() + \sa IteratorFlags, QDir::setNameFilters() */ QDirListing::QDirListing(const QString &path, const QStringList &nameFilters, QDir::Filters filters, IteratorFlags flags) @@ -485,12 +498,25 @@ QString QDirListing::iteratorPath() const \fn QDirListing::const_iterator QDirListing::end() const \fn QDirListing::const_iterator QDirListing::cend() const - begin()/cbegin() returns a QDirListing::const_iterator that enables - iterating over directory entries using a ranged-for loop; dereferencing - this iterator returns a \c{const QFileInfo &}. - - end()/cend() return a sentinel const_iterator that signals the end of - the iteration. Dereferencing this iterator is undefined behavior. + (c)begin() returns a QDirListing::const_iterator that can be used to + iterate over directory entries. + + \list + \li This is a forward-only, single-pass iterator (you cannot iterate + directory entries in reverse order) + \li Doesn't allow random access + \li Can be used in ranged-for loops; or with STL algorithms that don't + require random access iterators + \li Dereferencing a valid iterator returns a \c{const DirEntry &} + \li (c)end() returns a sentinel-like const_iterator that signals the + end of the iteration. Dereferencing the end() iterator is undefined + behavior + \li Each time (c)begin() is called on the same QDirListing object, + the internal state is reset and the iteration starts anew + \endlist + + (Some of the above restrictions are dictated by the underlying system + library functions' implementation). For example: \snippet code/src_corelib_io_qdirlisting.cpp 0 @@ -498,14 +524,11 @@ QString QDirListing::iteratorPath() const Here's how to find and read all files filtered by name, recursively: \snippet code/src_corelib_io_qdirlisting.cpp 1 - \note As this is a unidirectional (forward-only) iterator, calling - begin()/cbegin() more than once on the same QDirListing object could - result in unexpected behavior (for example, some entries being skipped). - - \sa fileInfo(), fileName(), filePath() + \sa QDirListing::DirEntry */ QDirListing::const_iterator QDirListing::begin() const { + d->beginIterating(); const_iterator it{d.get()}; return ++it; } diff --git a/src/corelib/io/qfile.cpp b/src/corelib/io/qfile.cpp index 52188dde51..ea594470ea 100644 --- a/src/corelib/io/qfile.cpp +++ b/src/corelib/io/qfile.cpp @@ -510,7 +510,7 @@ QFile::moveToTrash() \since 5.15 \overload - Moves the file specified by fileName() to the trash. Returns \c true if successful, + Moves the file specified by \a fileName to the trash. Returns \c true if successful, and sets \a pathInTrash (if provided) to the path at which the file can be found within the trash; otherwise returns \c false. diff --git a/src/corelib/io/qfilesystemengine_unix.cpp b/src/corelib/io/qfilesystemengine_unix.cpp index bda2962f8d..fb48f22bc6 100644 --- a/src/corelib/io/qfilesystemengine_unix.cpp +++ b/src/corelib/io/qfilesystemengine_unix.cpp @@ -641,30 +641,17 @@ QFileSystemEntry QFileSystemEngine::getRawLinkPath(const QFileSystemEntry &link, QFileSystemEntry QFileSystemEngine::canonicalName(const QFileSystemEntry &entry, QFileSystemMetaData &data) { Q_CHECK_FILE_NAME(entry, entry); + char *resolved_name = nullptr; -#if !defined(Q_OS_DARWIN) && !defined(Q_OS_QNX) && !defined(Q_OS_ANDROID) && !defined(Q_OS_HAIKU) && _POSIX_VERSION < 200809L - // realpath(X,0) is not supported - Q_UNUSED(data); - return QFileSystemEntry(slowCanonicalized(absoluteName(entry).filePath())); -#else -# if defined(Q_OS_DARWIN) || defined(Q_OS_ANDROID) || _POSIX_VERSION < 200801L - // used to store the result of realpath in case where realpath cannot allocate itself +#ifdef PATH_MAX + // use the stack to avoid the overhead of memory allocation char stack_result[PATH_MAX + 1]; #else - // enables unconditionally passing stack_result below + // system with unlimited file paths -> must use heap std::nullptr_t stack_result = nullptr; -# endif - auto resolved_path_deleter = [&](char *ptr) { - // frees resolved_name if it was allocated by realpath -# if defined(Q_OS_DARWIN) || defined(Q_OS_ANDROID) || _POSIX_VERSION < 200801L - // ptr is either null, or points to stack_result - Q_ASSERT(!ptr || ptr == stack_result); - return; -#else - free(ptr); -# endif - }; - std::unique_ptr<char, decltype (resolved_path_deleter)> resolved_name {nullptr, resolved_path_deleter}; + auto freer = qScopeGuard([&] { free(resolved_name); }); +#endif + # if defined(Q_OS_DARWIN) || defined(Q_OS_ANDROID) // On some Android and macOS versions, realpath() will return a path even if // it does not exist. To work around this, we check existence in advance. @@ -674,14 +661,14 @@ QFileSystemEntry QFileSystemEngine::canonicalName(const QFileSystemEntry &entry, if (!data.exists()) errno = ENOENT; else - resolved_name.reset(realpath(entry.nativeFilePath().constData(), stack_result)); + resolved_name = realpath(entry.nativeFilePath().constData(), stack_result); # else - resolved_name.reset(realpath(entry.nativeFilePath().constData(), stack_result)); + resolved_name = realpath(entry.nativeFilePath().constData(), stack_result); # endif if (resolved_name) { data.knownFlagsMask |= QFileSystemMetaData::ExistsAttribute; data.entryFlags |= QFileSystemMetaData::ExistsAttribute; - QString canonicalPath = QDir::cleanPath(QFile::decodeName(resolved_name.get())); + QString canonicalPath = QDir::cleanPath(QFile::decodeName(resolved_name)); return QFileSystemEntry(canonicalPath); } else if (errno == ENOENT || errno == ENOTDIR) { // file doesn't exist data.knownFlagsMask |= QFileSystemMetaData::ExistsAttribute; @@ -689,7 +676,6 @@ QFileSystemEntry QFileSystemEngine::canonicalName(const QFileSystemEntry &entry, return QFileSystemEntry(); } return entry; -#endif } //static diff --git a/src/corelib/io/qfloat16format.h b/src/corelib/io/qfloat16format.h new file mode 100644 index 0000000000..2d507800b6 --- /dev/null +++ b/src/corelib/io/qfloat16format.h @@ -0,0 +1,62 @@ +// 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 + +#ifndef QFLOAT16FORMAT_H +#define QFLOAT16FORMAT_H + +#if 0 +#pragma qt_class(QFloat16Format) +#pragma qt_sync_skip_header_check +#endif + +#include <QtCore/qglobal.h> +#include <QtCore/qtformat_impl.h> + +#ifdef QT_SUPPORTS_STD_FORMAT + +#include <QtCore/qfloat16.h> + +#include <type_traits> + +QT_BEGIN_NAMESPACE + +namespace QtPrivate { + +// [format.formatter.spec] / 5 +template <typename T, typename CharT> +constexpr bool FormatterDoesNotExist = + std::negation_v< + std::disjunction< + std::is_default_constructible<std::formatter<T, CharT>>, + std::is_copy_constructible<std::formatter<T, CharT>>, + std::is_move_constructible<std::formatter<T, CharT>>, + std::is_copy_assignable<std::formatter<T, CharT>>, + std::is_move_assignable<std::formatter<T, CharT>> + > + >; + +template <typename CharT> +using QFloat16FormatterBaseType = + std::conditional_t<FormatterDoesNotExist<qfloat16::NearestFloat, CharT>, + float, + qfloat16::NearestFloat>; + +} // namespace QtPrivate + +QT_END_NAMESPACE + +template <typename CharT> +struct std::formatter<QT_PREPEND_NAMESPACE(qfloat16), CharT> + : std::formatter<QT_PREPEND_NAMESPACE(QtPrivate::QFloat16FormatterBaseType<CharT>), CharT> +{ + template <typename FormatContext> + auto format(QT_PREPEND_NAMESPACE(qfloat16) val, FormatContext &ctx) const + { + using FloatType = QT_PREPEND_NAMESPACE(QtPrivate::QFloat16FormatterBaseType<CharT>); + return std::formatter<FloatType, CharT>::format(FloatType(val), ctx); + } +}; + +#endif // QT_SUPPORTS_STD_FORMAT + +#endif // QFLOAT16FORMAT_H diff --git a/src/corelib/io/qloggingcategory.cpp b/src/corelib/io/qloggingcategory.cpp index 10763dd65a..4e28c44e7b 100644 --- a/src/corelib/io/qloggingcategory.cpp +++ b/src/corelib/io/qloggingcategory.cpp @@ -665,4 +665,43 @@ void QLoggingCategory::setFilterRules(const QString &rules) This macro must be used outside of a class or method. */ +/*! + \macro Q_STATIC_LOGGING_CATEGORY(name, string) + \sa Q_LOGGING_CATEGORY() + \relates QLoggingCategory + \since 6.9 + + Defines a static logging category \a name, and makes it configurable under + the \a string identifier. By default, all message types are enabled. + + The logging category is created using the \c static qualifier so that you + can only access it in the same translation unit. This avoids accidental + symbol clashes. + + The implicitly-defined QLoggingCategory object is created on first use, + in a thread-safe manner. + + This macro must be used outside of a class or method. +*/ + +/*! + \macro Q_STATIC_LOGGING_CATEGORY(name, string, msgType) + \sa Q_LOGGING_CATEGORY() + \relates QLoggingCategory + \since 6.9 + + Defines a static logging category \a name, and makes it configurable under + the \a string identifier. By default, messages of QtMsgType \a msgType and + more severe are enabled, types with a lower severity are disabled. + + The logging category is created using the \c static qualifier so that you + can only access it in the same translation unit. This avoids accidental + symbol clashes. + + The implicitly-defined QLoggingCategory object is created on first use, in + a thread-safe manner. + + This macro must be used outside of a class or method. +*/ + QT_END_NAMESPACE diff --git a/src/corelib/io/qloggingcategory.h b/src/corelib/io/qloggingcategory.h index 7c32beea1a..b8be7f6037 100644 --- a/src/corelib/io/qloggingcategory.h +++ b/src/corelib/io/qloggingcategory.h @@ -116,6 +116,9 @@ template <> const bool QLoggingCategoryMacroHolder<QtWarningMsg>::IsOutputEnable return category; \ } +#define Q_STATIC_LOGGING_CATEGORY(name, ...) \ + static Q_LOGGING_CATEGORY(name, __VA_ARGS__) + #define QT_MESSAGE_LOGGER_COMMON(category, level) \ for (QLoggingCategoryMacroHolder<level> qt_category((category)()); qt_category; qt_category.control = false) \ QMessageLogger(QT_MESSAGELOG_FILE, QT_MESSAGELOG_LINE, QT_MESSAGELOG_FUNC, qt_category.name()) diff --git a/src/corelib/io/qloggingregistry_p.h b/src/corelib/io/qloggingregistry_p.h index 92b96f0ba4..42738891f7 100644 --- a/src/corelib/io/qloggingregistry_p.h +++ b/src/corelib/io/qloggingregistry_p.h @@ -39,6 +39,9 @@ QT_BEGIN_NAMESPACE return category; \ } +#define Q_STATIC_LOGGING_CATEGORY_WITH_ENV_OVERRIDE(name, env, categoryName) \ + static Q_LOGGING_CATEGORY_WITH_ENV_OVERRIDE(name, env, categoryName) + class Q_AUTOTEST_EXPORT QLoggingRule { public: diff --git a/src/corelib/io/qresource.cpp b/src/corelib/io/qresource.cpp index 005380720b..581e1e75ef 100644 --- a/src/corelib/io/qresource.cpp +++ b/src/corelib/io/qresource.cpp @@ -36,6 +36,16 @@ #if defined(Q_OS_UNIX) && !defined(Q_OS_INTEGRITY) # define QT_USE_MMAP # include <sys/mman.h> +# ifdef Q_OS_LINUX +// since 5.7, so define in case we're being compiled with older kernel headers +# define MREMAP_DONTUNMAP 4 +# elif defined(Q_OS_DARWIN) +# include <mach/mach.h> +# include <mach/vm_map.h> +# endif +#endif +#ifdef Q_OS_WIN +# include <qt_windows.h> #endif //#define DEBUG_RESOURCE_MATCH @@ -65,6 +75,7 @@ RCC_FEATURE_SYMBOL(Zstd) #undef RCC_FEATURE_SYMBOL +namespace { class QStringSplitter { public: @@ -159,15 +170,18 @@ static QString cleanPath(const QString &_path) path.remove(0, 1); return path; } +} // unnamed namespace Q_DECLARE_TYPEINFO(QResourceRoot, Q_RELOCATABLE_TYPE); typedef QList<QResourceRoot*> ResourceList; +namespace { struct QResourceGlobalData { QRecursiveMutex resourceMutex; ResourceList resourceList; }; +} Q_GLOBAL_STATIC(QResourceGlobalData, resourceGlobalData) static inline QRecursiveMutex &resourceMutex() @@ -279,6 +293,8 @@ public: bool load(const QString &file); void clear(); + static bool mayRemapData(const QResource &resource); + QLocale locale; QString fileName, absoluteFilePath; QList<QResourceRoot *> related; @@ -1031,8 +1047,8 @@ Q_CORE_EXPORT bool qUnregisterResourceData(int version, const unsigned char *tre return false; } +namespace { // run time resource creation - class QDynamicBufferResourceRoot : public QResourceRoot { QString root; @@ -1105,6 +1121,11 @@ public: class QDynamicFileResourceRoot : public QDynamicBufferResourceRoot { +public: + static uchar *map_sys(QFile &file, qint64 base, qsizetype size); + static void unmap_sys(void *base, qsizetype size); + +private: QString fileName; // for mmap'ed files, this is what needs to be unmapped. uchar *unmapPointer; @@ -1115,22 +1136,18 @@ public: : QDynamicBufferResourceRoot(_root), unmapPointer(nullptr), unmapLength(0) { } ~QDynamicFileResourceRoot() { -#if defined(QT_USE_MMAP) - if (unmapPointer) { - munmap(reinterpret_cast<char *>(unmapPointer), unmapLength); - unmapPointer = nullptr; - unmapLength = 0; - } else -#endif - { + if (wasMemoryMapped()) + unmap_sys(unmapPointer, unmapLength); + else delete[] mappingBuffer(); - } } QString mappingFile() const { return fileName; } ResourceRootType type() const override { return Resource_File; } + bool wasMemoryMapped() const { return unmapPointer; } bool registerSelf(const QString &f); }; +} // unnamed namespace #ifndef MAP_FILE # define MAP_FILE 0 @@ -1139,49 +1156,69 @@ public: # define MAP_FAILED reinterpret_cast<void *>(-1) #endif -bool QDynamicFileResourceRoot::registerSelf(const QString &f) +void QDynamicFileResourceRoot::unmap_sys(void *base, qsizetype size) +{ +#if defined(QT_USE_MMAP) + munmap(base, size); +#elif defined(Q_OS_WIN) + Q_UNUSED(size) + UnmapViewOfFile(reinterpret_cast<void *>(base)); +#endif +} + +// Note: caller must ensure \a offset and \a size are acceptable to the OS. +uchar *QDynamicFileResourceRoot::map_sys(QFile &file, qint64 offset, qsizetype size) { - bool fromMM = false; - uchar *data = nullptr; - qsizetype data_len = 0; + Q_ASSERT(file.isOpen()); + void *ptr = nullptr; + if (size < 0) + size = qMin(file.size() - offset, (std::numeric_limits<qsizetype>::max)()); + // We don't use QFile::map() here because we want to dispose of the QFile object #if defined(QT_USE_MMAP) - int fd = QT_OPEN(QFile::encodeName(f), O_RDONLY); - if (fd >= 0) { - QT_STATBUF st; - if (!QT_FSTAT(fd, &st) && st.st_size <= std::numeric_limits<qsizetype>::max()) { - int protection = PROT_READ; // read-only memory - int flags = MAP_FILE | MAP_PRIVATE; // swap-backed map from file - void *ptr = QT_MMAP(nullptr, st.st_size, // any address, whole file - protection, flags, - fd, 0); // from offset 0 of fd - if (ptr != MAP_FAILED) { - data = static_cast<uchar *>(ptr); - data_len = st.st_size; - fromMM = true; - } + int fd = file.handle(); + int protection = PROT_READ; // read-only memory + int flags = MAP_FILE | MAP_PRIVATE; // swap-backed map from file + ptr = QT_MMAP(nullptr, size, protection, flags, fd, offset); + if (ptr == MAP_FAILED) + ptr = nullptr; +#elif defined(Q_OS_WIN) + int fd = file.handle(); + HANDLE fileHandle = reinterpret_cast<HANDLE>(_get_osfhandle(fd)); + if (fileHandle != INVALID_HANDLE_VALUE) { + HANDLE mapHandle = CreateFileMapping(fileHandle, 0, PAGE_WRITECOPY, 0, 0, 0); + if (mapHandle) { + ptr = MapViewOfFile(mapHandle, FILE_MAP_COPY, DWORD(offset >> 32), DWORD(offset), size); + CloseHandle(mapHandle); } - QT_CLOSE(fd); } #endif // QT_USE_MMAP - if (!data) { - QFile file(f); + return static_cast<uchar *>(ptr); +} + +bool QDynamicFileResourceRoot::registerSelf(const QString &f) +{ + QFile file(f); + if (!file.open(QIODevice::ReadOnly)) + return false; + + qint64 data_len = file.size(); + if (data_len > std::numeric_limits<qsizetype>::max()) + return false; + + uchar *data = map_sys(file, 0, data_len); + bool fromMM = !!data; + + if (!fromMM) { bool ok = false; - if (file.open(QIODevice::ReadOnly)) { - qint64 fsize = file.size(); - if (fsize <= std::numeric_limits<qsizetype>::max()) { - data_len = file.size(); - data = new uchar[data_len]; - ok = (data_len == file.read(reinterpret_cast<char *>(data), data_len)); - } - } + data = new uchar[data_len]; + ok = (data_len == file.read(reinterpret_cast<char *>(data), data_len)); if (!ok) { delete[] data; data = nullptr; data_len = 0; return false; } - fromMM = false; } if (data && QDynamicBufferResourceRoot::registerSelf(data, data_len)) { if (fromMM) { @@ -1349,11 +1386,22 @@ private: uchar *map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags); bool unmap(uchar *ptr); void uncompress() const; - qint64 offset; + void mapUncompressed(); + bool mapUncompressed_sys(); + void unmapUncompressed_sys(); + qint64 offset = 0; QResource resource; mutable QByteArray uncompressed; + bool mustUnmap = false; + + // minimum size for which we'll try to re-open ourselves in mapUncompressed() + static constexpr qsizetype RemapCompressedThreshold = 16384; protected: - QResourceFileEnginePrivate() : offset(0) { } + ~QResourceFileEnginePrivate() + { + if (mustUnmap) + unmapUncompressed_sys(); + } }; bool QResourceFileEngine::caseSensitive() const @@ -1565,7 +1613,9 @@ bool QResourceFileEngine::supportsExtension(Extension extension) const uchar *QResourceFileEnginePrivate::map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags) { Q_Q(QResourceFileEngine); - Q_UNUSED(flags); + Q_ASSERT_X(resource.compressionAlgorithm() == QResource::NoCompression + || !uncompressed.isNull(), "QFile::map()", + "open() should have uncompressed compressed resources"); qint64 max = resource.uncompressedSize(); qint64 end; @@ -1575,11 +1625,15 @@ uchar *QResourceFileEnginePrivate::map(qint64 offset, qint64 size, QFile::Memory return nullptr; } - const uchar *address = resource.data(); - if (resource.compressionAlgorithm() != QResource::NoCompression) { - uncompress(); - if (uncompressed.isNull()) - return nullptr; + const uchar *address = reinterpret_cast<const uchar *>(uncompressed.constBegin()); + if (!uncompressed.isNull()) + return const_cast<uchar *>(address) + offset; + + // resource was not compressed + address = resource.data(); + if (flags & QFile::MapPrivateOption) { + // We need to provide read-write memory + mapUncompressed(); address = reinterpret_cast<const uchar *>(uncompressed.constData()); } @@ -1600,6 +1654,131 @@ void QResourceFileEnginePrivate::uncompress() const uncompressed = resource.uncompressedData(); } +void QResourceFileEnginePrivate::mapUncompressed() +{ + Q_ASSERT(resource.compressionAlgorithm() == QResource::NoCompression); + if (!uncompressed.isNull()) + return; // nothing to do + + if (resource.uncompressedSize() >= RemapCompressedThreshold) { + if (mapUncompressed_sys()) + return; + } + + uncompressed = resource.uncompressedData(); + uncompressed.detach(); +} + +#if defined(MREMAP_MAYMOVE) && defined(MREMAP_DONTUNMAP) +inline bool QResourcePrivate::mayRemapData(const QResource &resource) +{ + auto d = resource.d_func(); + + // assumptions from load(): + // - d->related is not empty + // - the first item in d->related is the one with our data + // by current construction, it's also the only item + const QResourceRoot *root = d->related.at(0); + + switch (root->type()) { + case QResourceRoot::Resource_Builtin: + return true; // always acceptable, memory is read-only + case QResourceRoot::Resource_Buffer: + return false; // never acceptable, memory is heap + case QResourceRoot::Resource_File: + break; + } + + auto df = static_cast<const QDynamicFileResourceRoot *>(root); + return df->wasMemoryMapped(); +} +#endif + +// Returns the page boundaries of where \a location is located in memory. +static auto mappingBoundaries(const void *location, qsizetype size) +{ +#ifdef Q_OS_WIN + auto getpagesize = [] { + SYSTEM_INFO sysinfo; + ::GetSystemInfo(&sysinfo); + return sysinfo.dwAllocationGranularity; + }; +#endif + struct R { + void *begin; + qsizetype size; + qptrdiff offset; + } r; + + const quintptr pageMask = getpagesize() - 1; + quintptr data = quintptr(location); + quintptr begin = data & ~pageMask; + quintptr end = (data + size + pageMask) & ~pageMask; + r.begin = reinterpret_cast<void *>(begin); + r.size = end - begin; + r.offset = data & pageMask; + return r; +} + +bool QResourceFileEnginePrivate::mapUncompressed_sys() +{ + auto r = mappingBoundaries(resource.data(), resource.uncompressedSize()); + void *ptr = nullptr; + +#if defined(MREMAP_MAYMOVE) && defined(MREMAP_DONTUNMAP) + // Use MREMAP_MAYMOVE to tell the kernel to give us a new address and use + // MREMAP_DONTUNMAP (supported since kernel 5.7) to request that it create + // a new mapping of the same pages, instead of moving. We can only do that + // for pages that are read-only, otherwise the kernel replaces the source + // with pages full of nulls. + if (!QResourcePrivate::mayRemapData(resource)) + return false; + + ptr = mremap(r.begin, r.size, r.size, MREMAP_MAYMOVE | MREMAP_DONTUNMAP); + if (ptr == MAP_FAILED) + return false; + + // Allow writing, which the documentation says we allow. This is safe + // because MREMAP_DONTUNMAP only works for private mappings. + if (mprotect(ptr, r.size, PROT_READ | PROT_WRITE) != 0) { + munmap(ptr, r.size); + return false; + } +#elif defined(Q_OS_DARWIN) + mach_port_t self = mach_task_self(); + vm_address_t addr = 0; + vm_address_t mask = 0; + bool anywhere = true; + bool copy = true; + vm_prot_t cur_prot = VM_PROT_READ | VM_PROT_WRITE; + vm_prot_t max_prot = VM_PROT_ALL; + kern_return_t res = vm_remap(self, &addr, r.size, mask, anywhere, + self, vm_address_t(r.begin), copy, &cur_prot, + &max_prot, VM_INHERIT_DEFAULT); + if (res != KERN_SUCCESS) + return false; + + ptr = reinterpret_cast<void *>(addr); + if ((max_prot & VM_PROT_WRITE) == 0 || mprotect(ptr, r.size, PROT_READ | PROT_WRITE) != 0) { + munmap(ptr, r.size); + return false; + } +#endif + + if (!ptr) + return false; + const char *newdata = static_cast<char *>(ptr) + r.offset; + uncompressed = QByteArray::fromRawData(newdata, resource.uncompressedSize()); + mustUnmap = true; + return true; +} + +void QResourceFileEnginePrivate::unmapUncompressed_sys() +{ + auto r = mappingBoundaries(uncompressed.constBegin(), uncompressed.size()); + QDynamicFileResourceRoot::unmap_sys(r.begin, r.size); +} + #endif // !defined(QT_BOOTSTRAPPED) QT_END_NAMESPACE diff --git a/src/corelib/io/qstorageinfo_linux.cpp b/src/corelib/io/qstorageinfo_linux.cpp index a9d46e7395..b4360f9164 100644 --- a/src/corelib/io/qstorageinfo_linux.cpp +++ b/src/corelib/io/qstorageinfo_linux.cpp @@ -13,6 +13,7 @@ #include <q20memory.h> #include <sys/ioctl.h> +#include <sys/stat.h> #include <sys/statfs.h> // so we don't have to #include <linux/fs.h>, which is known to cause conflicts @@ -28,10 +29,29 @@ # define ST_RDONLY 0x0001 /* mount read-only */ #endif +#if defined(Q_OS_ANDROID) +// statx() is disabled on Android because quite a few systems +// come with sandboxes that kill applications that make system calls outside a +// whitelist and several Android vendors can't be bothered to update the list. +# undef STATX_BASIC_STATS +#endif + QT_BEGIN_NAMESPACE using namespace Qt::StringLiterals; +namespace { +struct AutoFileDescriptor +{ + int fd = -1; + AutoFileDescriptor(const QString &path, int mode = QT_OPEN_RDONLY) + : fd(qt_safe_open(QFile::encodeName(path), mode)) + {} + ~AutoFileDescriptor() { if (fd >= 0) qt_safe_close(fd); } + operator int() const noexcept { return fd; } +}; +} + // udev encodes the labels with ID_LABEL_FS_ENC which is done with // blkid_encode_string(). Within this function some 1-byte utf-8 // characters not considered safe (e.g. '\' or ' ') are encoded as hex @@ -79,6 +99,20 @@ static inline dev_t deviceIdForPath(const QString &device) return st.st_dev; } +static inline quint64 mountIdForPath(int fd) +{ + if (fd < 0) + return 0; +#if defined(STATX_BASIC_STATS) && defined(STATX_MNT_ID) + // STATX_MNT_ID was added in kernel v5.8 + struct statx st; + int r = statx(fd, "", AT_EMPTY_PATH | AT_NO_AUTOMOUNT, STATX_MNT_ID, &st); + if (r == 0 && (st.stx_mask & STATX_MNT_ID)) + return st.stx_mnt_id; +#endif + return 0; +} + static inline quint64 retrieveDeviceId(const QByteArray &device, quint64 deviceId = 0) { // major = 0 implies an anonymous block device, so we need to stat() the @@ -129,10 +163,9 @@ static inline auto retrieveLabels() return result; } -static std::optional<QString> retrieveLabelViaIoctl(const QString &path) +static std::optional<QString> retrieveLabelViaIoctl(int fd) { // FS_IOC_GETFSLABEL was introduced in v4.18; previously it was btrfs-specific. - int fd = qt_safe_open(QFile::encodeName(path).constData(), QT_OPEN_RDONLY); if (fd < 0) return std::nullopt; @@ -140,15 +173,14 @@ static std::optional<QString> retrieveLabelViaIoctl(const QString &path) // says) and the return code on success (0) does not indicate the length. char label[FSLABEL_MAX] = {}; int r = ioctl(fd, FS_IOC_GETFSLABEL, &label); - close(fd); if (r < 0) return std::nullopt; return QString::fromUtf8(label); } -static inline QString retrieveLabel(const QStorageInfoPrivate &d, quint64 deviceId) +static inline QString retrieveLabel(const QStorageInfoPrivate &d, int fd, quint64 deviceId) { - if (auto label = retrieveLabelViaIoctl(d.rootPath)) + if (auto label = retrieveLabelViaIoctl(fd)) return *label; deviceId = retrieveDeviceId(d.device, deviceId); @@ -207,39 +239,51 @@ void QStorageInfoPrivate::doStat() return; } - // We iterate over the /proc/self/mountinfo list backwards because then any - // matching isParentOf must be the actual mount point because it's the most - // recent mount on that path. Linux does allow mounting over non-empty - // directories, such as in: - // # mount | tail -2 - // tmpfs on /tmp/foo/bar type tmpfs (rw,relatime,inode64) - // tmpfs on /tmp/foo type tmpfs (rw,relatime,inode64) - // - // We try to match the device ID in case there's a mount --move. - // We can't *rely* on it because some filesystems like btrfs will assign - // device IDs to subvolumes that aren't listed in /proc/self/mountinfo. - - const QString oldRootPath = std::exchange(rootPath, QString()); - const dev_t rootPathDevId = deviceIdForPath(oldRootPath); MountInfo *best = nullptr; - for (auto it = infos.rbegin(); it != infos.rend(); ++it) { - if (!isParentOf(it->mountPoint, oldRootPath)) - continue; - if (rootPathDevId == it->stDev) { - // device ID matches; this is definitely the best option - best = q20::to_address(it); - break; - } - if (!best) { - // if we can't find a device ID match, this parent path is probably - // the correct one + AutoFileDescriptor fd(rootPath); + if (quint64 mntid = mountIdForPath(fd)) { + // We have the mount ID for this path, so find the matching line. + auto it = std::find_if(infos.begin(), infos.end(), + [mntid](const MountInfo &info) { return info.mntid == mntid; }); + if (it != infos.end()) best = q20::to_address(it); + } else { + // We have failed to get the mount ID for this path, usually because + // the path cannot be open()ed by this user (e.g., /root), so we fall + // back to a string search. + // We iterate over the /proc/self/mountinfo list backwards because then any + // matching isParentOf must be the actual mount point because it's the most + // recent mount on that path. Linux does allow mounting over non-empty + // directories, such as in: + // # mount | tail -2 + // tmpfs on /tmp/foo/bar type tmpfs (rw,relatime,inode64) + // tmpfs on /tmp/foo type tmpfs (rw,relatime,inode64) + // + // We try to match the device ID in case there's a mount --move. + // We can't *rely* on it because some filesystems like btrfs will assign + // device IDs to subvolumes that aren't listed in /proc/self/mountinfo. + + const QString oldRootPath = std::exchange(rootPath, QString()); + const dev_t rootPathDevId = deviceIdForPath(oldRootPath); + for (auto it = infos.rbegin(); it != infos.rend(); ++it) { + if (!isParentOf(it->mountPoint, oldRootPath)) + continue; + if (rootPathDevId == it->stDev) { + // device ID matches; this is definitely the best option + best = q20::to_address(it); + break; + } + if (!best) { + // if we can't find a device ID match, this parent path is probably + // the correct one + best = q20::to_address(it); + } } } if (best) { auto stDev = best->stDev; setFromMountInfo(std::move(*best)); - name = retrieveLabel(*this, stDev); + name = retrieveLabel(*this, fd, stDev); } } @@ -250,11 +294,11 @@ QList<QStorageInfo> QStorageInfoPrivate::mountedVolumes() return QList{root()}; std::optional<decltype(retrieveLabels())> labelMap; - auto labelForDevice = [&labelMap](const QStorageInfoPrivate &d, quint64 devid) { + auto labelForDevice = [&labelMap](const QStorageInfoPrivate &d, int fd, quint64 devid) { if (d.fileSystemType == "tmpfs") return QString(); - if (auto label = retrieveLabelViaIoctl(d.rootPath)) + if (auto label = retrieveLabelViaIoctl(fd)) return *label; devid = retrieveDeviceId(d.device, devid); @@ -271,15 +315,31 @@ QList<QStorageInfo> QStorageInfoPrivate::mountedVolumes() }; QList<QStorageInfo> volumes; - for (MountInfo &info : infos) { + volumes.reserve(infos.size()); + for (auto it = infos.begin(); it != infos.end(); ++it) { + MountInfo &info = *it; + AutoFileDescriptor fd(info.mountPoint); + + // find out if the path as we see it matches this line from mountinfo + quint64 mntid = mountIdForPath(fd); + if (mntid == 0) { + // statx failed, so scan the later lines to see if any is a parent + // to this + auto isParent = [&info](const MountInfo &maybeParent) { + return isParentOf(maybeParent.mountPoint, info.mountPoint); + }; + if (std::find_if(it + 1, infos.end(), isParent) != infos.end()) + continue; + } else if (mntid != info.mntid) { + continue; + } + const auto infoStDev = info.stDev; QStorageInfoPrivate d(std::move(info)); d.retrieveVolumeInfo(); if (d.bytesTotal <= 0 && d.rootPath != u'/') continue; - if (infoStDev != deviceIdForPath(d.rootPath)) - continue; // probably something mounted over this mountpoint - d.name = labelForDevice(d, infoStDev); + d.name = labelForDevice(d, fd, infoStDev); volumes.emplace_back(QStorageInfo(*new QStorageInfoPrivate(std::move(d)))); } return volumes; diff --git a/src/corelib/io/qstorageinfo_linux_p.h b/src/corelib/io/qstorageinfo_linux_p.h index 6f5e107ec6..ae6c1a3859 100644 --- a/src/corelib/io/qstorageinfo_linux_p.h +++ b/src/corelib/io/qstorageinfo_linux_p.h @@ -93,7 +93,7 @@ static QByteArray parseMangledPath(QByteArrayView path) } // Indexes into the "fields" std::array in parseMountInfo() -// static constexpr short MountId = 0; +static constexpr short MountId = 0; // static constexpr short ParentId = 1; static constexpr short DevNo = 2; static constexpr short FsRoot = 3; @@ -199,6 +199,13 @@ doParseMountInfo(const QByteArray &mountinfo, FilterMountInfo filter = FilterMou tokenizeLine(fields, line); MountInfo info; + if (auto r = qstrntoll(fields[MountId].data(), fields[MountId].size(), 10); r.ok()) { + info.mntid = r.result; + } else { + checkField({}); + continue; + } + QByteArray mountP = parseMangledPath(fields[MountPoint]); if (!checkField(mountP)) continue; diff --git a/src/corelib/io/qstorageinfo_p.h b/src/corelib/io/qstorageinfo_p.h index 3af4b81ca4..3b049cdfd4 100644 --- a/src/corelib/io/qstorageinfo_p.h +++ b/src/corelib/io/qstorageinfo_p.h @@ -69,6 +69,7 @@ public: QByteArray device; QByteArray fsRoot; dev_t stDev = 0; + quint64 mntid = 0; }; void setFromMountInfo(MountInfo &&info) diff --git a/src/corelib/io/qtformat_impl.h b/src/corelib/io/qtformat_impl.h new file mode 100644 index 0000000000..7c7029d779 --- /dev/null +++ b/src/corelib/io/qtformat_impl.h @@ -0,0 +1,25 @@ +// 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 + +#ifndef QTFORMAT_IMPL_H +#define QTFORMAT_IMPL_H + +#if 0 +#pragma qt_no_master_include +#pragma qt_sync_skip_header_check +#endif + +#include <QtCore/qsystemdetection.h> +#include <QtCore/qtconfigmacros.h> + +#if __has_include(<format>) +# include <format> +#endif + +#if (defined(__cpp_lib_format) && (__cpp_lib_format >= 202106L)) + +#define QT_SUPPORTS_STD_FORMAT 1 + +#endif // __cpp_lib_format + +#endif // QTFORMAT_IMPL_H diff --git a/src/corelib/io/qurl.cpp b/src/corelib/io/qurl.cpp index 4360b5b076..1e285bb36b 100644 --- a/src/corelib/io/qurl.cpp +++ b/src/corelib/io/qurl.cpp @@ -1014,8 +1014,9 @@ inline bool QUrlPrivate::setScheme(const QString &value, qsizetype len, bool doS inline void QUrlPrivate::setAuthority(const QString &auth, qsizetype from, qsizetype end, QUrl::ParsingMode mode) { sectionIsPresent &= ~Authority; - sectionIsPresent |= Host; port = -1; + if (from == end && !auth.isNull()) + sectionIsPresent |= Host; // empty but not null authority implies host // we never actually _loop_ while (from != end) { @@ -1155,8 +1156,11 @@ inline void QUrlPrivate::setQuery(const QString &value, qsizetype from, qsizetyp inline void QUrlPrivate::appendHost(QString &appendTo, QUrl::FormattingOptions options) const { - if (host.isEmpty()) + if (host.isEmpty()) { + if ((sectionIsPresent & Host) && appendTo.isNull()) + appendTo.detach(); return; + } if (host.at(0).unicode() == '[') { // IPv6 addresses might contain a zone-id which needs to be recoded if (options != 0) @@ -1274,7 +1278,9 @@ QUrlPrivate::setHost(const QString &value, qsizetype from, qsizetype iend, QUrl: const qsizetype len = end - begin; host.clear(); - sectionIsPresent |= Host; + sectionIsPresent &= ~Host; + if (!value.isNull() || (sectionIsPresent & Authority)) + sectionIsPresent |= Host; if (len == 0) return true; @@ -2029,11 +2035,6 @@ void QUrl::setAuthority(const QString &authority, ParsingMode mode) } d->setAuthority(authority, 0, authority.size(), mode); - if (authority.isNull()) { - // QUrlPrivate::setAuthority cleared almost everything - // but it leaves the Host bit set - d->sectionIsPresent &= ~QUrlPrivate::Authority; - } } /*! @@ -2297,8 +2298,7 @@ void QUrl::setHost(const QString &host, ParsingMode mode) } if (d->setHost(data, 0, data.size(), mode)) { - if (host.isNull()) - d->sectionIsPresent &= ~QUrlPrivate::Host; + return; } else if (!data.startsWith(u'[')) { // setHost failed, it might be IPv6 or IPvFuture in need of bracketing Q_ASSERT(d->error); @@ -2311,6 +2311,7 @@ void QUrl::setHost(const QString &host, ParsingMode mode) // source data contains ':', so it's an IPv6 error d->error->code = QUrlPrivate::InvalidIPv6AddressError; } + d->sectionIsPresent &= ~QUrlPrivate::Host; } else { // succeeded d->clearError(); diff --git a/src/corelib/itemmodels/qabstractitemmodel.cpp b/src/corelib/itemmodels/qabstractitemmodel.cpp index cd29f2fcc2..216db3b42a 100644 --- a/src/corelib/itemmodels/qabstractitemmodel.cpp +++ b/src/corelib/itemmodels/qabstractitemmodel.cpp @@ -288,6 +288,9 @@ void QPersistentModelIndexData::destroy(QPersistentModelIndexData *data) \brief The QPersistentModelIndex class is used to locate data in a data model. \ingroup model-view + \compares strong + \compareswith strong QModelIndex + \endcompareswith A QPersistentModelIndex is a model index that can be stored by an application, and later used to access information in a model. @@ -375,45 +378,53 @@ QPersistentModelIndex::~QPersistentModelIndex() } /*! - Returns \c{true} if this persistent model index is equal to the \a other - persistent model index; otherwise returns \c{false}. + \fn bool QPersistentModelIndex::operator==(const QPersistentModelIndex &lhs, const QPersistentModelIndex &rhs) + Returns \c{true} if \a lhs persistent model index is equal to the \a rhs + persistent model index; otherwise returns \c{false}. - The internal data pointer, row, column, and model values in the persistent - model index are used when comparing with another persistent model index. + The internal data pointer, row, column, and model values in the persistent + model index are used when comparing with another persistent model index. */ -bool QPersistentModelIndex::operator==(const QPersistentModelIndex &other) const noexcept +/*! + \fn bool QPersistentModelIndex::operator!=(const QPersistentModelIndex &lhs, const QPersistentModelIndex &rhs) + \since 4.2 + + Returns \c{true} if \a lhs persistent model index is not equal to the \a rhs + persistent model index; otherwise returns \c{false}. +*/ +bool comparesEqual(const QPersistentModelIndex &lhs, const QPersistentModelIndex &rhs) noexcept { - if (d && other.d) - return d->index == other.d->index; - return d == other.d; + if (lhs.d && rhs.d) + return lhs.d->index == rhs.d->index; + return lhs.d == rhs.d; } /*! + \fn bool QPersistentModelIndex::operator<(const QPersistentModelIndex &lhs, const QPersistentModelIndex &rhs) \since 4.1 - Returns \c{true} if this persistent model index is smaller than the \a other + Returns \c{true} if \a lhs persistent model index is smaller than the \a rhs persistent model index; otherwise returns \c{false}. The internal data pointer, row, column, and model values in the persistent model index are used when comparing with another persistent model index. */ - -bool QPersistentModelIndex::operator<(const QPersistentModelIndex &other) const noexcept +Qt::strong_ordering compareThreeWay(const QPersistentModelIndex &lhs, + const QPersistentModelIndex &rhs) noexcept { - if (d && other.d) - return d->index < other.d->index; + if (lhs.d && rhs.d) + return compareThreeWay(lhs.d->index, rhs.d->index); - return std::less<>{}(d, other.d); + using Qt::totally_ordered_wrapper; + return compareThreeWay(totally_ordered_wrapper{lhs.d}, totally_ordered_wrapper{rhs.d}); } -/*! - \fn bool QPersistentModelIndex::operator!=(const QPersistentModelIndex &other) const - \since 4.2 - - Returns \c{true} if this persistent model index is not equal to the \a - other persistent model index; otherwise returns \c{false}. -*/ +Qt::strong_ordering compareThreeWay(const QPersistentModelIndex &lhs, + const QModelIndex &rhs) noexcept +{ + return compareThreeWay(lhs.d ? lhs.d->index : QModelIndex{}, rhs); +} /*! Sets the persistent model index to refer to the same item in a model @@ -470,32 +481,26 @@ QPersistentModelIndex::operator QModelIndex() const } /*! - Returns \c{true} if this persistent model index refers to the same location as - the \a other model index; otherwise returns \c{false}. + \fn bool QPersistentModelIndex::operator==(const QPersistentModelIndex &lhs, const QModelIndex &rhs) + Returns \c{true} if \a lhs persistent model index refers to the same location as + the \a rhs model index; otherwise returns \c{false}. The internal data pointer, row, column, and model values in the persistent model index are used when comparing with another model index. -*/ - -bool QPersistentModelIndex::operator==(const QModelIndex &other) const noexcept -{ - if (d) - return d->index == other; - return !other.isValid(); -} + */ /*! - \fn bool QPersistentModelIndex::operator!=(const QModelIndex &other) const + \fn bool QPersistentModelIndex::operator!=(const QPersistentModelIndex &lhs, const QModelIndex &rhs) - Returns \c{true} if this persistent model index does not refer to the same - location as the \a other model index; otherwise returns \c{false}. + Returns \c{true} if \a lhs persistent model index does not refer to the same + location as the \a rhs model index; otherwise returns \c{false}. */ -bool QPersistentModelIndex::operator!=(const QModelIndex &other) const noexcept +bool comparesEqual(const QPersistentModelIndex &lhs, const QModelIndex &rhs) noexcept { - if (d) - return d->index != other; - return other.isValid(); + if (lhs.d) + return lhs.d->index == rhs; + return !rhs.isValid(); } /*! @@ -1158,6 +1163,7 @@ void QAbstractItemModel::resetInternalData() \ingroup model-view + \compares strong This class is used as an index into item models derived from QAbstractItemModel. The index is used by item views, delegates, and @@ -1328,24 +1334,22 @@ void QAbstractItemModel::resetInternalData() */ /*! - \fn bool QModelIndex::operator==(const QModelIndex &other) const + \fn bool QModelIndex::operator==(const QModelIndex &lhs, const QModelIndex &rhs) - Returns \c{true} if this model index refers to the same location as the - \a other model index; otherwise returns \c{false}. + Returns \c{true} if \a lhs model index refers to the same location as the + \a rhs model index; otherwise returns \c{false}. The internal data pointer, row, column, and model values are used when comparing with another model index. */ - /*! - \fn bool QModelIndex::operator!=(const QModelIndex &other) const + \fn bool QModelIndex::operator!=(const QModelIndex &lhs, const QModelIndex &rhs) - Returns \c{true} if this model index does not refer to the same location as - the \a other model index; otherwise returns \c{false}. + Returns \c{true} if \a lhs model index does not refer to the same location as + the \a rhs model index; otherwise returns \c{false}. */ - /*! \fn QModelIndex QModelIndex::parent() const @@ -4124,10 +4128,10 @@ bool QAbstractListModel::dropMimeData(const QMimeData *data, Qt::DropAction acti */ /*! - \fn bool QModelIndex::operator<(const QModelIndex &other) const + \fn bool QModelIndex::operator<(const QModelIndex &lhs, const QModelIndex &rhs) \since 4.1 - Returns \c{true} if this model index is smaller than the \a other + Returns \c{true} if \a lhs model index is smaller than the \a rhs model index; otherwise returns \c{false}. The less than calculation is not directly useful to developers - the way that indexes diff --git a/src/corelib/itemmodels/qabstractitemmodel.h b/src/corelib/itemmodels/qabstractitemmodel.h index 8f22f14989..418fc6b864 100644 --- a/src/corelib/itemmodels/qabstractitemmodel.h +++ b/src/corelib/itemmodels/qabstractitemmodel.h @@ -5,11 +5,14 @@ #ifndef QABSTRACTITEMMODEL_H #define QABSTRACTITEMMODEL_H +#include <QtCore/qcompare.h> #include <QtCore/qhash.h> #include <QtCore/qlist.h> #include <QtCore/qobject.h> #include <QtCore/qvariant.h> +#include <tuple> + QT_REQUIRE_CONFIG(itemmodel); QT_BEGIN_NAMESPACE @@ -138,19 +141,16 @@ public: inline QVariant data(int role = Qt::DisplayRole) const; inline void multiData(QModelRoleDataSpan roleDataSpan) const; inline Qt::ItemFlags flags() const; - constexpr inline const QAbstractItemModel *model() const noexcept { return m; } + constexpr inline const QAbstractItemModel *model() const noexcept { return m.get(); } constexpr inline bool isValid() const noexcept { return (r >= 0) && (c >= 0) && (m != nullptr); } - constexpr inline bool operator==(const QModelIndex &other) const noexcept - { return (other.r == r) && (other.i == i) && (other.c == c) && (other.m == m); } - constexpr inline bool operator!=(const QModelIndex &other) const noexcept - { return !(*this == other); } - constexpr inline bool operator<(const QModelIndex &other) const noexcept - { - return r < other.r - || (r == other.r && (c < other.c - || (c == other.c && (i < other.i - || (i == other.i && std::less<const QAbstractItemModel *>()(m, other.m)))))); - } + +private: + constexpr auto asTuple() const noexcept { return std::tie(r, c, i, m); } + friend constexpr bool comparesEqual(const QModelIndex &lhs, const QModelIndex &rhs) noexcept + { return lhs.asTuple() == rhs.asTuple(); } + friend constexpr Qt::strong_ordering compareThreeWay(const QModelIndex &lhs, const QModelIndex &rhs) noexcept + { return QtOrderingPrivate::compareThreeWayMulti(lhs.asTuple(), rhs.asTuple()); } + Q_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE(QModelIndex) private: inline QModelIndex(int arow, int acolumn, const void *ptr, const QAbstractItemModel *amodel) noexcept : r(arow), c(acolumn), i(reinterpret_cast<quintptr>(ptr)), m(amodel) {} @@ -158,7 +158,7 @@ private: : r(arow), c(acolumn), i(id), m(amodel) {} int r, c; quintptr i; - const QAbstractItemModel *m; + Qt::totally_ordered_wrapper<const QAbstractItemModel *> m; }; Q_DECLARE_TYPEINFO(QModelIndex, Q_RELOCATABLE_TYPE); @@ -178,17 +178,21 @@ public: QPersistentModelIndex(const QModelIndex &index); QPersistentModelIndex(const QPersistentModelIndex &other); ~QPersistentModelIndex(); +#if QT_CORE_REMOVED_SINCE(6, 8) bool operator<(const QPersistentModelIndex &other) const noexcept; bool operator==(const QPersistentModelIndex &other) const noexcept; inline bool operator!=(const QPersistentModelIndex &other) const noexcept { return !operator==(other); } +#endif QPersistentModelIndex &operator=(const QPersistentModelIndex &other); inline QPersistentModelIndex(QPersistentModelIndex &&other) noexcept : d(std::exchange(other.d, nullptr)) {} QT_MOVE_ASSIGNMENT_OPERATOR_IMPL_VIA_PURE_SWAP(QPersistentModelIndex) void swap(QPersistentModelIndex &other) noexcept { qt_ptr_swap(d, other.d); } +#if QT_CORE_REMOVED_SINCE(6, 8) bool operator==(const QModelIndex &other) const noexcept; bool operator!=(const QModelIndex &other) const noexcept; +#endif QPersistentModelIndex &operator=(const QModelIndex &other); operator QModelIndex() const; int row() const; @@ -208,6 +212,18 @@ private: friend size_t qHash(const QPersistentModelIndex &, size_t seed) noexcept; friend bool qHashEquals(const QPersistentModelIndex &a, const QPersistentModelIndex &b) noexcept { return a.d == b.d; } + friend Q_CORE_EXPORT bool + comparesEqual(const QPersistentModelIndex &lhs, const QPersistentModelIndex &rhs) noexcept; + friend Q_CORE_EXPORT bool + comparesEqual(const QPersistentModelIndex &lhs, const QModelIndex &rhs) noexcept; + friend Q_CORE_EXPORT Qt::strong_ordering // ### Qt 7: partial_ordering? + compareThreeWay(const QPersistentModelIndex &lhs, const QPersistentModelIndex &rhs) noexcept; + friend Q_CORE_EXPORT Qt::strong_ordering // ### Qt 7: partial_ordering? + compareThreeWay(const QPersistentModelIndex &lhs, const QModelIndex &rhs) noexcept; +#if !QT_CORE_REMOVED_SINCE(6, 8) + Q_DECLARE_STRONGLY_ORDERED(QPersistentModelIndex) + Q_DECLARE_STRONGLY_ORDERED(QPersistentModelIndex, QModelIndex) +#endif #ifndef QT_NO_DEBUG_STREAM friend Q_CORE_EXPORT QDebug operator<<(QDebug, const QPersistentModelIndex &); #endif diff --git a/src/corelib/itemmodels/qitemselectionmodel.h b/src/corelib/itemmodels/qitemselectionmodel.h index c4b8dadc97..aaf32e68ef 100644 --- a/src/corelib/itemmodels/qitemselectionmodel.h +++ b/src/corelib/itemmodels/qitemselectionmodel.h @@ -77,7 +77,7 @@ private: friend bool comparesEqual(const QItemSelectionRange &lhs, const QItemSelectionRange &rhs) noexcept { - return (lhs.tl == rhs.tl && lhs.br == rhs.br); + return comparesEqual(lhs.tl, rhs.tl) && comparesEqual(lhs.br, rhs.br); } Q_DECLARE_EQUALITY_COMPARABLE(QItemSelectionRange) QPersistentModelIndex tl, br; diff --git a/src/corelib/kernel/qapplicationstatic.h b/src/corelib/kernel/qapplicationstatic.h index bf5e79b8bf..345a880748 100644 --- a/src/corelib/kernel/qapplicationstatic.h +++ b/src/corelib/kernel/qapplicationstatic.h @@ -11,6 +11,10 @@ #include <new> +#if 0 +#pragma qt_class(QApplicationStatic) +#endif + QT_BEGIN_NAMESPACE namespace QtGlobalStatic { diff --git a/src/corelib/kernel/qapplicationstatic.qdoc b/src/corelib/kernel/qapplicationstatic.qdoc index 5cbac65df9..1d13fbd84a 100644 --- a/src/corelib/kernel/qapplicationstatic.qdoc +++ b/src/corelib/kernel/qapplicationstatic.qdoc @@ -2,9 +2,14 @@ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only /*! + \headerfile <QApplicationStatic> + \inmodule QtCore +*/ + +/*! \macro Q_APPLICATION_STATIC(Type, VariableName, ...) \since 6.3 - \relates QGlobalStatic + \relates <QApplicationStatic> This macro extends Q_GLOBAL_STATIC and creates a global and static object of type \l QGlobalStatic, of name \a VariableName, initialized by the diff --git a/src/corelib/kernel/qcore_foundation.mm b/src/corelib/kernel/qcore_foundation.mm index a31040944f..6d2451e078 100644 --- a/src/corelib/kernel/qcore_foundation.mm +++ b/src/corelib/kernel/qcore_foundation.mm @@ -300,8 +300,8 @@ QUuid QUuid::fromCFUUID(CFUUIDRef uuid) */ CFUUIDRef QUuid::toCFUUID() const { - const QByteArray bytes = toRfc4122(); - return CFUUIDCreateFromUUIDBytes(0, *reinterpret_cast<const CFUUIDBytes *>(bytes.constData())); + const auto bytes = toBytes(); + return CFUUIDCreateFromUUIDBytes(0, *reinterpret_cast<const CFUUIDBytes *>(&bytes)); } /*! @@ -333,8 +333,11 @@ QUuid QUuid::fromNSUUID(const NSUUID *uuid) */ NSUUID *QUuid::toNSUUID() const { - const QByteArray bytes = toRfc4122(); - return [[[NSUUID alloc] initWithUUIDBytes:*reinterpret_cast<const uuid_t *>(bytes.constData())] autorelease]; + const auto bytes = toBytes(); + static_assert(sizeof bytes == sizeof(uuid_t)); + uuid_t u; + memcpy(&u, &bytes, sizeof(uuid_t)); + return [[[NSUUID alloc] initWithUUIDBytes:u] autorelease]; } // ---------------------------------------------------------------------------- diff --git a/src/corelib/kernel/qcore_mac.mm b/src/corelib/kernel/qcore_mac.mm index 54c4373aed..00b0d078d7 100644 --- a/src/corelib/kernel/qcore_mac.mm +++ b/src/corelib/kernel/qcore_mac.mm @@ -541,7 +541,7 @@ QMacRootLevelAutoReleasePool::QMacRootLevelAutoReleasePool() if (qEnvironmentVariableIsSet(ROOT_LEVEL_POOL_DISABLE_SWITCH)) return; - pool.reset(new QMacAutoReleasePool); + pool.emplace(); [[[ROOT_LEVEL_POOL_MARKER alloc] init] autorelease]; diff --git a/src/corelib/kernel/qcore_mac_p.h b/src/corelib/kernel/qcore_mac_p.h index e63c320805..5ecf8072f4 100644 --- a/src/corelib/kernel/qcore_mac_p.h +++ b/src/corelib/kernel/qcore_mac_p.h @@ -19,6 +19,8 @@ #include <QtCore/qoperatingsystemversion.h> +#include <optional> + #ifdef Q_OS_MACOS #include <mach/port.h> struct mach_header; @@ -48,7 +50,6 @@ kern_return_t IOObjectRelease(io_object_t object); #endif #include "qstring.h" -#include "qscopedpointer.h" #include "qpair.h" #if defined( __OBJC__) && defined(QT_NAMESPACE) @@ -129,7 +130,7 @@ public: Q_NODISCARD_CTOR QMacRootLevelAutoReleasePool(); ~QMacRootLevelAutoReleasePool(); private: - QScopedPointer<QMacAutoReleasePool> pool; + std::optional<QMacAutoReleasePool> pool = std::nullopt; }; #endif diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp index bd00f69c1c..4262c14405 100644 --- a/src/corelib/kernel/qcoreapplication.cpp +++ b/src/corelib/kernel/qcoreapplication.cpp @@ -1825,6 +1825,8 @@ void QCoreApplicationPrivate::sendPostedEvents(QObject *receiver, int event_type // Exception-safe cleaning up without the need for a try/catch block struct CleanUp { + Q_DISABLE_COPY_MOVE(CleanUp) + QObject *receiver; int event_type; QThreadData *data; @@ -3251,7 +3253,7 @@ void QCoreApplication::installNativeEventFilter(QAbstractNativeEventFilter *filt */ void QCoreApplication::removeNativeEventFilter(QAbstractNativeEventFilter *filterObject) { - QAbstractEventDispatcher *eventDispatcher = QAbstractEventDispatcher::instance(); + QAbstractEventDispatcher *eventDispatcher = QAbstractEventDispatcher::instance(QCoreApplicationPrivate::theMainThread.loadAcquire()); if (!filterObject || !eventDispatcher) return; eventDispatcher->removeNativeEventFilter(filterObject); diff --git a/src/corelib/kernel/qelapsedtimer.cpp b/src/corelib/kernel/qelapsedtimer.cpp index 511b81a04e..c4308a0b8f 100644 --- a/src/corelib/kernel/qelapsedtimer.cpp +++ b/src/corelib/kernel/qelapsedtimer.cpp @@ -14,6 +14,8 @@ QT_BEGIN_NAMESPACE \reentrant \ingroup tools + \compares strong + The QElapsedTimer class is usually used to quickly calculate how much time has elapsed between two events. Its API is similar to that of QTime, so code that was using that can be ported quickly to the new class. @@ -155,8 +157,7 @@ QT_BEGIN_NAMESPACE Returns \c true if \a lhs and \a rhs contain different times, false otherwise. */ /*! - \fn bool operator<(const QElapsedTimer &lhs, const QElapsedTimer &rhs) noexcept - \relates QElapsedTimer + \fn bool QElapsedTimer::operator<(const QElapsedTimer &lhs, const QElapsedTimer &rhs) noexcept Returns \c true if \a lhs was started before \a rhs, false otherwise. diff --git a/src/corelib/kernel/qelapsedtimer.h b/src/corelib/kernel/qelapsedtimer.h index 7d8b889f61..e71573456d 100644 --- a/src/corelib/kernel/qelapsedtimer.h +++ b/src/corelib/kernel/qelapsedtimer.h @@ -4,6 +4,7 @@ #ifndef QELAPSEDTIMER_H #define QELAPSEDTIMER_H +#include <QtCore/qcompare.h> #include <QtCore/qglobal.h> #include <chrono> @@ -45,15 +46,41 @@ public: Duration durationTo(const QElapsedTimer &other) const noexcept; qint64 msecsTo(const QElapsedTimer &other) const noexcept; qint64 secsTo(const QElapsedTimer &other) const noexcept; - - friend bool operator==(const QElapsedTimer &lhs, const QElapsedTimer &rhs) noexcept - { return lhs.t1 == rhs.t1 && lhs.t2 == rhs.t2; } - friend bool operator!=(const QElapsedTimer &lhs, const QElapsedTimer &rhs) noexcept - { return !(lhs == rhs); } - friend bool Q_CORE_EXPORT operator<(const QElapsedTimer &lhs, const QElapsedTimer &rhs) noexcept; private: + friend bool comparesEqual(const QElapsedTimer &lhs, const QElapsedTimer &rhs) noexcept + { + return lhs.t1 == rhs.t1 && lhs.t2 == rhs.t2; + } + Q_DECLARE_EQUALITY_COMPARABLE(QElapsedTimer) + + friend Qt::strong_ordering compareThreeWay(const QElapsedTimer &lhs, + const QElapsedTimer &rhs) noexcept + { + return Qt::compareThreeWay(lhs.t1, rhs.t1); + } + +#if defined(__cpp_lib_three_way_comparison) + friend std::strong_ordering + operator<=>(const QElapsedTimer &lhs, const QElapsedTimer &rhs) noexcept + { + return compareThreeWay(lhs, rhs); + } +#else + friend bool operator>(const QElapsedTimer &lhs, const QElapsedTimer &rhs) noexcept + { + return is_gt(compareThreeWay(lhs, rhs)); + } + friend bool operator<=(const QElapsedTimer &lhs, const QElapsedTimer &rhs) noexcept + { + return is_lteq(compareThreeWay(lhs, rhs)); + } + friend bool operator>=(const QElapsedTimer &lhs, const QElapsedTimer &rhs) noexcept + { + return is_gteq(compareThreeWay(lhs, rhs)); + } +#endif // defined(__cpp_lib_three_way_comparison) qint64 t1 = Q_INT64_C(0x8000000000000000); qint64 t2 = Q_INT64_C(0x8000000000000000); }; diff --git a/src/corelib/kernel/qjniarray.h b/src/corelib/kernel/qjniarray.h index 976b4e92e3..2ea82e39db 100644 --- a/src/corelib/kernel/qjniarray.h +++ b/src/corelib/kernel/qjniarray.h @@ -18,7 +18,7 @@ QT_BEGIN_NAMESPACE template <typename T> class QJniArray; template <typename T> -struct QJniArrayIterator +struct QT_TECH_PREVIEW_API QJniArrayIterator { QJniArrayIterator() = default; @@ -86,7 +86,7 @@ private: {} }; -class QJniArrayBase +class QT_TECH_PREVIEW_API QJniArrayBase { // for SFINAE'ing out the fromContainer named constructor template <typename Container, typename = void> struct CanConvertHelper : std::false_type {}; @@ -193,7 +193,7 @@ private: }; template <typename T> -class QJniArray : public QJniArrayBase +class QT_TECH_PREVIEW_API QJniArray : public QJniArrayBase { friend struct QJniArrayIterator<T>; public: diff --git a/src/corelib/kernel/qjnienvironment.cpp b/src/corelib/kernel/qjnienvironment.cpp index 1e2826e76b..b4f8497ddd 100644 --- a/src/corelib/kernel/qjnienvironment.cpp +++ b/src/corelib/kernel/qjnienvironment.cpp @@ -320,6 +320,30 @@ JavaVM *QJniEnvironment::javaVM() } /*! + \fn template <typename Class> bool QJniEnvironment::registerNativeMethods(std::initializer_list<JNINativeMethod> methods) + \overload + + Registers the Java methods in \a methods with the Java class represented by + \c Class, and returns whether the registration was successful. + + The \c Class type has to be declared within the QtJniTypes namespace using + the Q_DECLARE_JNI_CLASS macro. Functions that are implemented as free C or + C++ functions have to be declared using one of the + Q_DECLARE_JNI_NATIVE_METHOD macros, and passed into the registration using + the Q_JNI_NATIVE_METHOD macro. + + \include jni.qdoc register-free-function + + For functions that are implemented as static class member functions, use + the \l{Q_DECLARE_JNI_NATIVE_METHOD_IN_CURRENT_SCOPE}{macros for scoped + functions} instead. + + \include jni.qdoc register-scoped-function +*/ + +/*! + \overload + Registers the Java methods in the array \a methods of size \a size, each of which can call native C++ functions from class \a className. These methods must be registered before any attempt to call them. diff --git a/src/corelib/kernel/qjnihelpers.cpp b/src/corelib/kernel/qjnihelpers.cpp index d900b74d37..4d5ccd7d9b 100644 --- a/src/corelib/kernel/qjnihelpers.cpp +++ b/src/corelib/kernel/qjnihelpers.cpp @@ -18,6 +18,10 @@ QT_BEGIN_NAMESPACE +Q_DECLARE_JNI_CLASS(QtInputDelegate, "org/qtproject/qt/android/QtInputDelegate"); +Q_DECLARE_JNI_CLASS(MotionEvent, "android/view/MotionEvent"); +Q_DECLARE_JNI_CLASS(KeyEvent, "android/view/KeyEvent"); + namespace QtAndroidPrivate { // *Listener virtual function implementations. // Defined out-of-line to pin the vtable/type_info. @@ -141,6 +145,68 @@ void QtAndroidPrivate::handleNewIntent(JNIEnv *env, jobject intent) } } +QtAndroidPrivate::GenericMotionEventListener::~GenericMotionEventListener() {} +namespace { +struct GenericMotionEventListeners { + QMutex mutex; + QList<QtAndroidPrivate::GenericMotionEventListener *> listeners; +}; +} +Q_GLOBAL_STATIC(GenericMotionEventListeners, g_genericMotionEventListeners) + +static jboolean dispatchGenericMotionEvent(JNIEnv *, jclass, QtJniTypes::MotionEvent event) +{ + jboolean ret = JNI_FALSE; + QMutexLocker locker(&g_genericMotionEventListeners()->mutex); + for (auto *listener : std::as_const(g_genericMotionEventListeners()->listeners)) + ret |= listener->handleGenericMotionEvent(event.object()); + return ret; +} +Q_DECLARE_JNI_NATIVE_METHOD(dispatchGenericMotionEvent); + +QtAndroidPrivate::KeyEventListener::~KeyEventListener() {} +namespace { +struct KeyEventListeners { + QMutex mutex; + QList<QtAndroidPrivate::KeyEventListener *> listeners; +}; +} +Q_GLOBAL_STATIC(KeyEventListeners, g_keyEventListeners) + +static jboolean dispatchKeyEvent(JNIEnv *, jclass, QtJniTypes::KeyEvent event) +{ + jboolean ret = JNI_FALSE; + QMutexLocker locker(&g_keyEventListeners()->mutex); + for (auto *listener : std::as_const(g_keyEventListeners()->listeners)) + ret |= listener->handleKeyEvent(event.object()); + return ret; +} +Q_DECLARE_JNI_NATIVE_METHOD(dispatchKeyEvent); + +void QtAndroidPrivate::registerGenericMotionEventListener(QtAndroidPrivate::GenericMotionEventListener *listener) +{ + QMutexLocker locker(&g_genericMotionEventListeners()->mutex); + g_genericMotionEventListeners()->listeners.push_back(listener); +} + +void QtAndroidPrivate::unregisterGenericMotionEventListener(QtAndroidPrivate::GenericMotionEventListener *listener) +{ + QMutexLocker locker(&g_genericMotionEventListeners()->mutex); + g_genericMotionEventListeners()->listeners.removeOne(listener); +} + +void QtAndroidPrivate::registerKeyEventListener(QtAndroidPrivate::KeyEventListener *listener) +{ + QMutexLocker locker(&g_keyEventListeners()->mutex); + g_keyEventListeners()->listeners.push_back(listener); +} + +void QtAndroidPrivate::unregisterKeyEventListener(QtAndroidPrivate::KeyEventListener *listener) +{ + QMutexLocker locker(&g_keyEventListeners()->mutex); + g_keyEventListeners()->listeners.removeOne(listener); +} + namespace { class ResumePauseListeners { @@ -245,6 +311,15 @@ jint QtAndroidPrivate::initJNI(JavaVM *vm, JNIEnv *env) return JNI_ERR; QJniEnvironment qJniEnv; + using namespace QtJniTypes; + if (!QtInputDelegate::registerNativeMethods( + { Q_JNI_NATIVE_METHOD(dispatchGenericMotionEvent), + Q_JNI_NATIVE_METHOD(dispatchKeyEvent) })) { + qCritical() << "Failed to register natives methods for" + << Traits<QtInputDelegate>::className(); + return JNI_ERR; + } + if (!registerPermissionNatives(qJniEnv)) return JNI_ERR; diff --git a/src/corelib/kernel/qjnihelpers_p.h b/src/corelib/kernel/qjnihelpers_p.h index b5e05fcaf1..a7b879d9e1 100644 --- a/src/corelib/kernel/qjnihelpers_p.h +++ b/src/corelib/kernel/qjnihelpers_p.h @@ -56,6 +56,20 @@ namespace QtAndroidPrivate virtual jobject onBind(jobject intent) = 0; }; + class Q_CORE_EXPORT GenericMotionEventListener + { + public: + virtual ~GenericMotionEventListener(); + virtual bool handleGenericMotionEvent(jobject event) = 0; + }; + + class Q_CORE_EXPORT KeyEventListener + { + public: + virtual ~KeyEventListener(); + virtual bool handleKeyEvent(jobject event) = 0; + }; + Q_CORE_EXPORT QtJniTypes::Activity activity(); Q_CORE_EXPORT QtJniTypes::Service service(); Q_CORE_EXPORT QtJniTypes::Context context(); @@ -77,6 +91,12 @@ namespace QtAndroidPrivate Q_CORE_EXPORT void registerNewIntentListener(NewIntentListener *listener); Q_CORE_EXPORT void unregisterNewIntentListener(NewIntentListener *listener); + Q_CORE_EXPORT void registerGenericMotionEventListener(GenericMotionEventListener *listener); + Q_CORE_EXPORT void unregisterGenericMotionEventListener(GenericMotionEventListener *listener); + + Q_CORE_EXPORT void registerKeyEventListener(KeyEventListener *listener); + Q_CORE_EXPORT void unregisterKeyEventListener(KeyEventListener *listener); + Q_CORE_EXPORT void handlePause(); Q_CORE_EXPORT void handleResume(); Q_CORE_EXPORT void registerResumePauseListener(ResumePauseListener *listener); diff --git a/src/corelib/kernel/qjniobject.cpp b/src/corelib/kernel/qjniobject.cpp index 8244a4390f..d5b0cd5663 100644 --- a/src/corelib/kernel/qjniobject.cpp +++ b/src/corelib/kernel/qjniobject.cpp @@ -34,19 +34,10 @@ using namespace Qt::StringLiterals; \sa QJniEnvironment - \section1 General Notes - - \list - \li Class names need to be fully-qualified, for example: \c "java/lang/String". - \li Method signatures are written as \c "(ArgumentsTypes)ReturnType", see \l {JNI Types}. - \li All object types are returned as a QJniObject. - \endlist - \section1 Method Signatures QJniObject provides convenience functions that will use the correct signature based on the - provided template types. For functions that only return and take \l {JNI types}, the - signature can be generate at compile time: + provided or deduced template arguments. \code jint x = QJniObject::callMethod<jint>("getSize"); @@ -54,13 +45,11 @@ using namespace Qt::StringLiterals; jint ret = jString1.callMethod<jint>("compareToIgnoreCase", jString2.object<jstring>()); \endcode - These functions are variadic templates, and the compiler will deduce the template arguments - from the actual argument types. In many situations, only the return type needs to be provided - explicitly. - - For functions that take other argument types, you need to supply the signature yourself. It is - important that the signature matches the function you want to call. The example below - demonstrates how to call different static functions: + These functions are variadic templates, and the compiler will deduce the + signature from the actual argument types. Only the return type needs to be + provided explicitly. QJniObject can deduce the signature string for + functions that take \l {JNI types}, and for types that have been declared + with the QtJniTypes type mapping. \code // Java class @@ -73,6 +62,31 @@ using namespace Qt::StringLiterals; } \endcode + \code + // C++ code + Q_DECLARE_JNI_CLASS(TestClass, "org/qtproject/qt/TestClass") + + // ... + using namespace QtJniTypes; + TestClass testClass = TestClass::callStaticMethod<TestClass>("create"); + \endcode + + This allows working with arbitrary Java and Android types in C++ code, without having to + create JNI signature strings explicitly. + + \section2 Explicit JNI Signatures + + It is possible to supply the signature yourself. In that case, it is important + that the signature matches the function you want to call. + + \list + \li Class names need to be fully-qualified, for example: \c "java/lang/String". + \li Method signatures are written as \c "(ArgumentsTypes)ReturnType", see \l {JNI Types}. + \li All object types are returned as a QJniObject. + \endlist + + The example below demonstrates how to call different static functions: + The signature structure is \c "(ArgumentsTypes)ReturnType". Array types in the signature must have the \c {[} prefix, and the fully-qualified \c Object type names must have the \c L prefix and the \c ; suffix. The signature for the \c create function is @@ -105,9 +119,9 @@ using namespace Qt::StringLiterals; // C++ code QJniObject string1 = QJniObject::fromString("String1"); QJniObject string2 = QJniObject::fromString("String2"); - QJniObject stringArray = QJniObject::callStaticObjectMethod<jstringArray>( + QJniObject stringArray = QJniObject::callStaticObjectMethod<jobjectArray>( "org/qtproject/qt/TestClass", - "stringArray" + "stringArray", string1.object<jstring>(), string2.object<jstring>()); \endcode diff --git a/src/corelib/kernel/qjniobject.h b/src/corelib/kernel/qjniobject.h index 589f6489f7..707d1ae28a 100644 --- a/src/corelib/kernel/qjniobject.h +++ b/src/corelib/kernel/qjniobject.h @@ -670,7 +670,7 @@ inline bool operator!=(const QJniObject &obj1, const QJniObject &obj2) } namespace QtJniTypes { -struct JObjectBase +struct QT_TECH_PREVIEW_API JObjectBase { operator QJniObject() const { return m_object; } @@ -695,7 +695,7 @@ protected: }; template<typename Type> -class JObject : public JObjectBase +class QT_TECH_PREVIEW_API JObject : public JObjectBase { public: using Class = Type; diff --git a/src/corelib/kernel/qjnitypes.h b/src/corelib/kernel/qjnitypes.h index 1eaae6312b..033445be6a 100644 --- a/src/corelib/kernel/qjnitypes.h +++ b/src/corelib/kernel/qjnitypes.h @@ -11,6 +11,7 @@ QT_BEGIN_NAMESPACE +// QT_TECH_PREVIEW_API #define Q_DECLARE_JNI_TYPE_HELPER(Type) \ namespace QtJniTypes { \ struct Type : JObject<Type> \ @@ -19,19 +20,19 @@ struct Type : JObject<Type> \ }; \ } \ - +// QT_TECH_PREVIEW_API #define Q_DECLARE_JNI_TYPE(Type, Signature) \ Q_DECLARE_JNI_TYPE_HELPER(Type) \ template<> \ struct QtJniTypes::Traits<QtJniTypes::Type> { \ static constexpr auto signature() \ { \ - static_assert((Signature[0] == 'L' \ - || Signature[0] == '[') \ - && Signature[sizeof(Signature) - 2] == ';', \ + constexpr QtJniTypes::CTString sig(Signature); \ + static_assert((sig.startsWith('L') || sig.startsWith("[L")) \ + && sig.endsWith(';'), \ "Type signature needs to start with 'L' or" \ - " '[' and end with ';'"); \ - return QtJniTypes::CTString(Signature); \ + " '[L', and end with ';'"); \ + return sig; \ } \ }; \ @@ -176,7 +177,6 @@ va_##Method(JNIEnv *env, jclass thiz, ...) }, argTuple); \ } \ - #define Q_DECLARE_JNI_NATIVE_METHOD(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_JNI_NATIVE_METHOD, __VA_ARGS__) \ diff --git a/src/corelib/kernel/qmetaobject.cpp b/src/corelib/kernel/qmetaobject.cpp index 148983f126..05662b385a 100644 --- a/src/corelib/kernel/qmetaobject.cpp +++ b/src/corelib/kernel/qmetaobject.cpp @@ -3656,8 +3656,8 @@ QMetaProperty::QMetaProperty(const QMetaObject *mobj, int index) data(getMetaPropertyData(mobj, index)) { Q_ASSERT(index >= 0 && index < priv(mobj->d.data)->propertyCount); - - if (!(data.flags() & EnumOrFlag)) + // The code below here just resolves menum if the property is an enum type: + if (!(data.flags() & EnumOrFlag) || !metaType().flags().testFlag(QMetaType::IsEnumeration)) return; QByteArrayView enum_name = typeNameFromTypeInfo(mobj, data.type()); menum = mobj->enumerator(QMetaObjectPrivate::indexOfEnumerator(mobj, enum_name)); diff --git a/src/corelib/kernel/qmetaobject_p.h b/src/corelib/kernel/qmetaobject_p.h index d2c36fceb4..d5dc9a356a 100644 --- a/src/corelib/kernel/qmetaobject_p.h +++ b/src/corelib/kernel/qmetaobject_p.h @@ -111,22 +111,18 @@ public: const_cast<QArgumentType *>(this)->_name = QMetaType(_type).name(); return _name; } - bool operator==(const QArgumentType &other) const - { - if (_type && other._type) - return _type == other._type; - else - return name() == other.name(); - } - bool operator!=(const QArgumentType &other) const + +private: + friend bool comparesEqual(const QArgumentType &lhs, + const QArgumentType &rhs) noexcept { - if (_type && other._type) - return _type != other._type; + if (lhs._type && rhs._type) + return lhs._type == rhs._type; else - return name() != other.name(); + return lhs.name() == rhs.name(); } + Q_DECLARE_EQUALITY_COMPARABLE(QArgumentType) -private: int _type; QByteArray _name; }; diff --git a/src/corelib/kernel/qmetatype.cpp b/src/corelib/kernel/qmetatype.cpp index 387c0f49ab..1c2665e53c 100644 --- a/src/corelib/kernel/qmetatype.cpp +++ b/src/corelib/kernel/qmetatype.cpp @@ -474,6 +474,7 @@ const char *QtMetaTypePrivate::typedefNameForType(const QtPrivate::QMetaTypeInte \ingroup objectmodel \threadsafe + \compares equality The class is used as a helper to marshall types in QVariant and in queued signals and slots connections. It associates a type @@ -925,20 +926,20 @@ void QMetaType::unregisterMetaType(QMetaType type) Returns the QMetaType corresponding to the type in the template parameter. */ -/*! \fn bool QMetaType::operator==(QMetaType a, QMetaType b) +/*! \fn bool QMetaType::operator==(const QMetaType &lhs, const QMetaType &rhs) \since 5.15 \overload - Returns \c true if the QMetaType \a a represents the same type - as the QMetaType \a b, otherwise returns \c false. + Returns \c true if the QMetaType \a lhs represents the same type + as the QMetaType \a rhs, otherwise returns \c false. */ -/*! \fn bool QMetaType::operator!=(QMetaType a, QMetaType b) +/*! \fn bool QMetaType::operator!=(const QMetaType &lhs, const QMetaType &rhs) \since 5.15 \overload - Returns \c true if the QMetaType \a a represents a different type - than the QMetaType \a b, otherwise returns \c false. + Returns \c true if the QMetaType \a lhs represents a different type + than the QMetaType \a rhs, otherwise returns \c false. */ /*! \internal */ @@ -2659,6 +2660,36 @@ bool QMetaType::hasRegisteredConverterFunction(QMetaType fromType, QMetaType toT } /*! + \internal + Non-template helper ("SCARY") for IsMetaTypePair::registerConverter(). +*/ +bool QtPrivate::hasRegisteredConverterFunctionToPairVariantInterface(QMetaType m) +{ + const QMetaType to = QMetaType::fromType<QtMetaTypePrivate::QPairVariantInterfaceImpl>(); + return QMetaType::hasRegisteredConverterFunction(m, to); +} + +/*! + \internal + Non-template helper ("SCARY") for SequentialValueTypeIsMetaType::registerConverter(). +*/ +bool QtPrivate::hasRegisteredConverterFunctionToIterableMetaSequence(QMetaType m) +{ + const QMetaType to = QMetaType::fromType<QIterable<QMetaSequence>>(); + return QMetaType::hasRegisteredConverterFunction(m, to); +} + +/*! + \internal + Non-template helper ("SCARY") for AssociativeKeyTypeIsMetaType::registerConverter(). +*/ +bool QtPrivate::hasRegisteredConverterFunctionToIterableMetaAssociation(QMetaType m) +{ + const QMetaType to = QMetaType::fromType<QIterable<QMetaAssociation>>(); + return QMetaType::hasRegisteredConverterFunction(m, to); +} + +/*! \fn template<typename From, typename To> bool QMetaType::hasRegisteredMutableViewFunction() Returns \c true, if the meta type system has a registered mutable view on type From of type To. \since 6.0 @@ -2676,6 +2707,26 @@ bool QMetaType::hasRegisteredMutableViewFunction(QMetaType fromType, QMetaType t } /*! + \internal + Non-template helper ("SCARY") for SequentialValueTypeIsMetaType::registerMutableView(). +*/ +bool QtPrivate::hasRegisteredMutableViewFunctionToIterableMetaSequence(QMetaType m) +{ + const QMetaType to = QMetaType::fromType<QIterable<QMetaSequence>>(); + return QMetaType::hasRegisteredMutableViewFunction(m, to); +} + +/*! + \internal + Non-template helper ("SCARY") for AssociativeKeyTypeIsMetaType::registerMutableView(). +*/ +bool QtPrivate::hasRegisteredMutableViewFunctionToIterableMetaAssociation(QMetaType m) +{ + const QMetaType to = QMetaType::fromType<QIterable<QMetaAssociation>>(); + return QMetaType::hasRegisteredMutableViewFunction(m, to); +} + +/*! \fn const char *QMetaType::typeName(int typeId) \deprecated diff --git a/src/corelib/kernel/qmetatype.h b/src/corelib/kernel/qmetatype.h index e3ef1474da..1e944660c6 100644 --- a/src/corelib/kernel/qmetatype.h +++ b/src/corelib/kernel/qmetatype.h @@ -18,6 +18,7 @@ #include <QtCore/qobjectdefs.h> #endif #include <QtCore/qscopeguard.h> +#include <QtCore/qttypetraits.h> #include <array> #include <new> @@ -518,20 +519,20 @@ public: template<typename T> constexpr static QMetaType fromType(); static QMetaType fromName(QByteArrayView name); - - friend bool operator==(QMetaType a, QMetaType b) +private: + friend bool comparesEqual(const QMetaType &lhs, + const QMetaType &rhs) noexcept { - if (a.d_ptr == b.d_ptr) + if (lhs.d_ptr == rhs.d_ptr) return true; - if (!a.d_ptr || !b.d_ptr) + if (!lhs.d_ptr || !rhs.d_ptr) return false; // one type is undefined, the other is defined // avoid id call if we already have the id - const int aId = a.id(); - const int bId = b.id(); + const int aId = lhs.id(); + const int bId = rhs.id(); return aId == bId; } - friend bool operator!=(QMetaType a, QMetaType b) { return !(a == b); } - + Q_DECLARE_EQUALITY_COMPARABLE(QMetaType) #ifndef QT_NO_DEBUG_STREAM private: friend Q_CORE_EXPORT QDebug operator<<(QDebug d, QMetaType m); @@ -1750,11 +1751,19 @@ QT_FOR_EACH_STATIC_TYPE(Q_DECLARE_BUILTIN_METATYPE) QT_BEGIN_NAMESPACE +namespace QtPrivate { +// out-of-line helpers to reduce template code bloat ("SCARY") and improve compile times: +Q_CORE_EXPORT bool hasRegisteredConverterFunctionToPairVariantInterface(QMetaType m); +Q_CORE_EXPORT bool hasRegisteredConverterFunctionToIterableMetaSequence(QMetaType m); +Q_CORE_EXPORT bool hasRegisteredMutableViewFunctionToIterableMetaSequence(QMetaType m); +Q_CORE_EXPORT bool hasRegisteredConverterFunctionToIterableMetaAssociation(QMetaType m); +Q_CORE_EXPORT bool hasRegisteredMutableViewFunctionToIterableMetaAssociation(QMetaType m); +} + template <typename T> inline bool QtPrivate::IsMetaTypePair<T, true>::registerConverter() { - const QMetaType to = QMetaType::fromType<QtMetaTypePrivate::QPairVariantInterfaceImpl>(); - if (!QMetaType::hasRegisteredConverterFunction(QMetaType::fromType<T>(), to)) { + if (!QtPrivate::hasRegisteredConverterFunctionToPairVariantInterface(QMetaType::fromType<T>())) { QtMetaTypePrivate::QPairVariantInterfaceConvertFunctor<T> o; return QMetaType::registerConverter<T, QtMetaTypePrivate::QPairVariantInterfaceImpl>(o); } @@ -1786,8 +1795,7 @@ struct SequentialValueTypeIsMetaType<T, true> { static bool registerConverter() { - const QMetaType to = QMetaType::fromType<QIterable<QMetaSequence>>(); - if (!QMetaType::hasRegisteredConverterFunction(QMetaType::fromType<T>(), to)) { + if (!QtPrivate::hasRegisteredConverterFunctionToIterableMetaSequence(QMetaType::fromType<T>())) { QSequentialIterableConvertFunctor<T> o; return QMetaType::registerConverter<T, QIterable<QMetaSequence>>(o); } @@ -1796,8 +1804,7 @@ struct SequentialValueTypeIsMetaType<T, true> static bool registerMutableView() { - const QMetaType to = QMetaType::fromType<QIterable<QMetaSequence>>(); - if (!QMetaType::hasRegisteredMutableViewFunction(QMetaType::fromType<T>(), to)) { + if (!QtPrivate::hasRegisteredMutableViewFunctionToIterableMetaSequence(QMetaType::fromType<T>())) { QSequentialIterableMutableViewFunctor<T> o; return QMetaType::registerMutableView<T, QIterable<QMetaSequence>>(o); } @@ -1830,8 +1837,7 @@ struct AssociativeKeyTypeIsMetaType<T, true> : AssociativeMappedTypeIsMetaType<T { static bool registerConverter() { - const QMetaType to = QMetaType::fromType<QIterable<QMetaAssociation>>(); - if (!QMetaType::hasRegisteredConverterFunction(QMetaType::fromType<T>(), to)) { + if (!QtPrivate::hasRegisteredConverterFunctionToIterableMetaAssociation(QMetaType::fromType<T>())) { QAssociativeIterableConvertFunctor<T> o; return QMetaType::registerConverter<T, QIterable<QMetaAssociation>>(o); } @@ -1840,8 +1846,7 @@ struct AssociativeKeyTypeIsMetaType<T, true> : AssociativeMappedTypeIsMetaType<T static bool registerMutableView() { - const QMetaType to = QMetaType::fromType<QIterable<QMetaAssociation>>(); - if (!QMetaType::hasRegisteredMutableViewFunction(QMetaType::fromType<T>(), to)) { + if (!QtPrivate::hasRegisteredMutableViewFunctionToIterableMetaAssociation(QMetaType::fromType<T>())) { QAssociativeIterableMutableViewFunctor<T> o; return QMetaType::registerMutableView<T, QIterable<QMetaAssociation>>(o); } diff --git a/src/corelib/kernel/qobject.cpp b/src/corelib/kernel/qobject.cpp index e1129c5d25..31b779dc9b 100644 --- a/src/corelib/kernel/qobject.cpp +++ b/src/corelib/kernel/qobject.cpp @@ -4698,16 +4698,25 @@ QDebug operator<<(QDebug dbg, const QObject *o) \sa {Qt's Property System} */ - /*! \macro Q_OBJECT \relates QObject - The Q_OBJECT macro must appear in the private section of a class - definition that declares its own signals and slots or that uses - other services provided by Qt's meta-object system. + The Q_OBJECT macro is used to enable meta-object features, such as dynamic + properties, signals, and slots. - For example: + You can add the Q_OBJECT macro to any section of a class definition that + declares its own signals and slots or that uses other services provided by + Qt's meta-object system. + +//! [qobject-macros-private-access-specifier] + \note This macro expansion ends with a \c private: access specifier. If you + declare members immediately after this macro, those members will also be + private. To add public (or protected) members right after the macro, use a + \c {public:} (or \c {protected:}) access specifier. +//! [qobject-macros-private-access-specifier] + + Example: \snippet signalsandslots/signalsandslots.h 1 \codeline @@ -4715,15 +4724,8 @@ QDebug operator<<(QDebug dbg, const QObject *o) \snippet signalsandslots/signalsandslots.h 3 \note This macro requires the class to be a subclass of QObject. Use - Q_GADGET or Q_GADGET_EXPORT instead of Q_OBJECT to enable the meta object system's support - for enums in a class that is not a QObject subclass. - -//! [qobject-macros-private-access-specifier] - \note This macro expansion ends with a \c private: access specifier, which makes member - declarations immediately after the macro private, too. If you want add public (or protected) - members immediately after the macro, you need to use a \c public: (or \c protected:) - access specifier. -//! [qobject-macros-private-access-specifier] + Q_GADGET or Q_GADGET_EXPORT instead of Q_OBJECT to enable the meta object + system's support for enums in a class that is not a QObject subclass. \sa {Meta-Object System}, {Signals and Slots}, {Qt's Property System} */ @@ -4734,8 +4736,9 @@ QDebug operator<<(QDebug dbg, const QObject *o) The Q_GADGET macro is a lighter version of the Q_OBJECT macro for classes that do not inherit from QObject but still want to use some of the - reflection capabilities offered by QMetaObject. Just like the Q_OBJECT - macro, it must appear in the private section of a class definition. + reflection capabilities offered by QMetaObject. + + \include qobject.cpp qobject-macros-private-access-specifier Q_GADGETs can have Q_ENUM, Q_PROPERTY and Q_INVOKABLE, but they cannot have signals or slots. @@ -4744,8 +4747,6 @@ QDebug operator<<(QDebug dbg, const QObject *o) \c{staticMetaObject} is of type QMetaObject and provides access to the enums declared with Q_ENUM. - \include qobject.cpp qobject-macros-private-access-specifier - \sa Q_GADGET_EXPORT */ @@ -4761,6 +4762,8 @@ QDebug operator<<(QDebug dbg, const QObject *o) enclosing class as a whole should not be (e.g. because it consists of mostly inline functions). + \include qobject.cpp qobject-macros-private-access-specifier + For example: \code @@ -4771,8 +4774,6 @@ QDebug operator<<(QDebug dbg, const QObject *o) ~~~ \endcode - \include qobject.cpp qobject-macros-private-access-specifier - \sa Q_GADGET, {Creating Shared Libraries} */ diff --git a/src/corelib/kernel/qpermissions_wasm.cpp b/src/corelib/kernel/qpermissions_wasm.cpp index 846e62ccf7..11bd4e864f 100644 --- a/src/corelib/kernel/qpermissions_wasm.cpp +++ b/src/corelib/kernel/qpermissions_wasm.cpp @@ -51,9 +51,13 @@ namespace { updatePermission(permissionName, permissionState["state"].as<std::string>(), {}); }; - callbacks.catchFunc = [permissionName](val) + callbacks.catchFunc = [permissionName](val err) { - updatePermission(permissionName, wapiDenied, {}); + if (err["name"].as<std::string>() == "NotAllowedError") + return updatePermission(permissionName, wapiDenied, {}); + + qCInfo(lcPermissions, "'%s' '%s'", err["name"].as<std::string>().c_str(), + err["message"].as<std::string>().c_str()); }; val query = val::object(); diff --git a/src/corelib/kernel/qpointer.h b/src/corelib/kernel/qpointer.h index 39e4ba3e0f..8875eef5c3 100644 --- a/src/corelib/kernel/qpointer.h +++ b/src/corelib/kernel/qpointer.h @@ -4,6 +4,7 @@ #ifndef QPOINTER_H #define QPOINTER_H +#include <QtCore/qcompare.h> #include <QtCore/qsharedpointer.h> #include <QtCore/qtypeinfo.h> @@ -90,27 +91,21 @@ public: friend void swap(QPointer &lhs, QPointer &rhs) noexcept { lhs.swap(rhs); } -#define DECLARE_COMPARE_SET(T1, A1, T2, A2) \ - friend bool operator==(T1, T2) noexcept \ - { return A1 == A2; } \ - friend bool operator!=(T1, T2) noexcept \ - { return A1 != A2; } - -#define DECLARE_TEMPLATE_COMPARE_SET(T1, A1, T2, A2) \ - template <typename X> \ - friend bool operator==(T1, T2) noexcept \ - { return A1 == A2; } \ - template <typename X> \ - friend bool operator!=(T1, T2) noexcept \ - { return A1 != A2; } - - DECLARE_TEMPLATE_COMPARE_SET(const QPointer &p1, p1.data(), const QPointer<X> &p2, p2.data()) - DECLARE_TEMPLATE_COMPARE_SET(const QPointer &p1, p1.data(), X *ptr, ptr) - DECLARE_TEMPLATE_COMPARE_SET(X *ptr, ptr, const QPointer &p2, p2.data()) - DECLARE_COMPARE_SET(const QPointer &p1, p1.data(), std::nullptr_t, nullptr) - DECLARE_COMPARE_SET(std::nullptr_t, nullptr, const QPointer &p2, p2.data()) -#undef DECLARE_COMPARE_SET -#undef DECLARE_TEMPLATE_COMPARE_SET +private: + template <typename X> + friend bool comparesEqual(const QPointer &lhs, const QPointer<X> &rhs) noexcept + { return lhs.data() == rhs.data(); } + QT_DECLARE_EQUALITY_OPERATORS_HELPER(QPointer, QPointer<X>, /* non-constexpr */, + template <typename X>) + + template <typename X> + friend bool comparesEqual(const QPointer &lhs, X *rhs) noexcept + { return lhs.data() == rhs; } + Q_DECLARE_EQUALITY_COMPARABLE(QPointer, X*, template <typename X>) + + friend bool comparesEqual(const QPointer &lhs, std::nullptr_t) noexcept + { return lhs.data() == nullptr; } + Q_DECLARE_EQUALITY_COMPARABLE(QPointer, std::nullptr_t) }; template <class T> Q_DECLARE_TYPEINFO_BODY(QPointer<T>, Q_RELOCATABLE_TYPE); diff --git a/src/corelib/kernel/qpointer.qdoc b/src/corelib/kernel/qpointer.qdoc index 9e4c9b2658..63a2a72e6f 100644 --- a/src/corelib/kernel/qpointer.qdoc +++ b/src/corelib/kernel/qpointer.qdoc @@ -8,6 +8,12 @@ \ingroup objectmodel + \compares equality + \compareswith equality QPointer<X> X* std::nullptr_t + Where X and T are compatible types, which means that they are either the same (except + for their cv-qualifiers), or one is a base type of the other. + \endcompareswith + A guarded pointer, QPointer<T>, behaves like a normal C++ pointer \c{T *}, except that it is automatically cleared when the referenced object is destroyed (unlike normal C++ pointers, which @@ -202,38 +208,38 @@ */ /*! - \fn template <typename T> template<typename X> bool QPointer<T>::operator==(X *o, const QPointer<T> &p) + \fn template <typename T> template<typename X> bool QPointer<T>::operator==(X* const &lhs, const QPointer<T> &rhs) - Equality operator. Returns \c true if \a o and the guarded - pointer \a p are pointing to the same object, otherwise + Equality operator. Returns \c true if \a lhs and the guarded + pointer \a rhs are pointing to the same object, otherwise returns \c false. */ /*! - \fn template <typename T> template<typename X> bool QPointer<T>::operator==(const QPointer<T> &p, X *o) + \fn template <typename T> template<typename X> bool QPointer<T>::operator==(const QPointer<T> &lhs, X* const &rhs) - Equality operator. Returns \c true if \a o and the guarded - pointer \a p are pointing to the same object, otherwise + Equality operator. Returns \c true if \a rhs and the guarded + pointer \a lhs are pointing to the same object, otherwise returns \c false. */ /*! - \fn template <typename T> template<typename X> bool QPointer<T>::operator==(const QPointer<T> &p1, const QPointer<X> &p2) + \fn template <typename T> template<typename X> bool QPointer<T>::operator==(const QPointer<T> &lhs, const QPointer<X> &rhs) - Equality operator. Returns \c true if the guarded pointers \a p1 and \a p2 + Equality operator. Returns \c true if the guarded pointers \a lhs and \a rhs are pointing to the same object, otherwise returns \c false. */ /*! - \fn template <typename T> bool QPointer<T>::operator==(std::nullptr_t, const QPointer<T> &rhs) + \fn template <typename T> bool QPointer<T>::operator==(std::nullptr_t const &lhs, const QPointer<T> &rhs) Equality operator. Returns \c true if the pointer guarded by \a rhs is \nullptr, otherwise returns \c false. */ /*! - \fn template <typename T> bool QPointer<T>::operator==(const QPointer<T> &lhs, std::nullptr_t) + \fn template <typename T> bool QPointer<T>::operator==(const QPointer<T> &lhs, std::nullptr_t const &rhs) Equality operator. Returns \c true if the pointer guarded by \a lhs is \nullptr, otherwise @@ -241,35 +247,35 @@ */ /*! - \fn template <typename T> template<typename X> bool QPointer<T>::operator!=(const QPointer<T> &p, X *o) + \fn template <typename T> template<typename X> bool QPointer<T>::operator!=(const QPointer<T> &lhs, X* const &rhs) - Inequality operator. Returns \c true if \a o and the guarded - pointer \a p are not pointing to the same object, otherwise + Inequality operator. Returns \c true if \a rhs and the guarded + pointer \a lhs are not pointing to the same object, otherwise returns \c false. */ /*! - \fn template <typename T> template<typename X> bool QPointer<T>::operator!=(X *o, const QPointer<T> &p) + \fn template <typename T> template<typename X> bool QPointer<T>::operator!=(X* const &lhs, const QPointer<T> &rhs) - Inequality operator. Returns \c true if \a o and the guarded - pointer \a p are not pointing to the same object, otherwise + Inequality operator. Returns \c true if \a lhs and the guarded + pointer \a rhs are not pointing to the same object, otherwise returns \c false. */ /*! - \fn template <typename T> template<typename X> bool QPointer<T>::operator!=(const QPointer<T> &p1, const QPointer<X> &p2) + \fn template <typename T> template<typename X> bool QPointer<T>::operator!=(const QPointer<T> &lhs, const QPointer<X> &rhs) - Inequality operator. Returns \c true if the guarded pointers \a p1 and - \a p2 are not pointing to the same object, otherwise + Inequality operator. Returns \c true if the guarded pointers \a lhs and + \a rhs are not pointing to the same object, otherwise returns \c false. */ /*! - \fn template <typename T> bool QPointer<T>::operator!=(std::nullptr_t, const QPointer<T> &rhs) + \fn template <typename T> bool QPointer<T>::operator!=(std::nullptr_t const &lhs, const QPointer<T> &rhs) Inequality operator. Returns \c true if the pointer guarded by \a rhs is a valid (ie not \nullptr) pointer, otherwise returns \c false. */ /*! - \fn template <typename T> bool QPointer<T>::operator!=(const QPointer<T> &lhs, std::nullptr_t) + \fn template <typename T> bool QPointer<T>::operator!=(const QPointer<T> &lhs, std::nullptr_t const &rhs) Inequality operator. Returns \c true if the pointer guarded by \a lhs is a valid (ie not \nullptr) pointer, otherwise diff --git a/src/corelib/kernel/qproperty.h b/src/corelib/kernel/qproperty.h index 0373867a66..8c4b13cf5e 100644 --- a/src/corelib/kernel/qproperty.h +++ b/src/corelib/kernel/qproperty.h @@ -7,6 +7,7 @@ #include <QtCore/qglobal.h> #include <QtCore/qshareddata.h> #include <QtCore/qstring.h> +#include <QtCore/qttypetraits.h> #include <QtCore/qbindingstorage.h> #include <type_traits> diff --git a/src/corelib/kernel/qproperty_p.h b/src/corelib/kernel/qproperty_p.h index 8ae6664a2b..376482a6af 100644 --- a/src/corelib/kernel/qproperty_p.h +++ b/src/corelib/kernel/qproperty_p.h @@ -19,12 +19,13 @@ #include <qproperty.h> #include <qmetaobject.h> -#include <qscopedpointer.h> #include <qscopedvaluerollback.h> #include <qvariant.h> #include <vector> #include <QtCore/QVarLengthArray> +#include <memory> + QT_BEGIN_NAMESPACE namespace QtPrivate { @@ -292,7 +293,7 @@ private: ObserverArray inlineDependencyObservers; // for things we are observing QPropertyObserverPointer firstObserver; // list of observers observing us - QScopedPointer<std::vector<QPropertyObserver>> heapObservers; // for things we are observing + std::unique_ptr<std::vector<QPropertyObserver>> heapObservers; // for things we are observing protected: QUntypedPropertyData *propertyDataPtr = nullptr; diff --git a/src/corelib/kernel/qpropertyprivate.h b/src/corelib/kernel/qpropertyprivate.h index 86dc08a6bc..c4a73f2c91 100644 --- a/src/corelib/kernel/qpropertyprivate.h +++ b/src/corelib/kernel/qpropertyprivate.h @@ -19,6 +19,7 @@ #include <QtCore/qtaggedpointer.h> #include <QtCore/qmetatype.h> #include <QtCore/qcontainerfwd.h> +#include <QtCore/qttypetraits.h> #include <functional> @@ -95,28 +96,20 @@ public: void swap(QPropertyBindingPrivatePtr &other) noexcept { qt_ptr_swap(d, other.d); } - friend bool operator==(const QPropertyBindingPrivatePtr &p1, const QPropertyBindingPrivatePtr &p2) noexcept - { return p1.d == p2.d; } - friend bool operator!=(const QPropertyBindingPrivatePtr &p1, const QPropertyBindingPrivatePtr &p2) noexcept - { return p1.d != p2.d; } - friend bool operator==(const QPropertyBindingPrivatePtr &p1, const T *ptr) noexcept - { return p1.d == ptr; } - friend bool operator!=(const QPropertyBindingPrivatePtr &p1, const T *ptr) noexcept - { return p1.d != ptr; } - friend bool operator==(const T *ptr, const QPropertyBindingPrivatePtr &p2) noexcept - { return ptr == p2.d; } - friend bool operator!=(const T *ptr, const QPropertyBindingPrivatePtr &p2) noexcept - { return ptr != p2.d; } - friend bool operator==(const QPropertyBindingPrivatePtr &p1, std::nullptr_t) noexcept - { return !p1; } - friend bool operator!=(const QPropertyBindingPrivatePtr &p1, std::nullptr_t) noexcept - { return p1; } - friend bool operator==(std::nullptr_t, const QPropertyBindingPrivatePtr &p2) noexcept - { return !p2; } - friend bool operator!=(std::nullptr_t, const QPropertyBindingPrivatePtr &p2) noexcept - { return p2; } - private: + friend bool comparesEqual(const QPropertyBindingPrivatePtr &lhs, + const QPropertyBindingPrivatePtr &rhs) noexcept + { return lhs.d == rhs.d; } + Q_DECLARE_EQUALITY_COMPARABLE(QPropertyBindingPrivatePtr) + friend bool comparesEqual(const QPropertyBindingPrivatePtr &lhs, + const T *rhs) noexcept + { return lhs.d == rhs; } + Q_DECLARE_EQUALITY_COMPARABLE(QPropertyBindingPrivatePtr, T*) + friend bool comparesEqual(const QPropertyBindingPrivatePtr &lhs, + std::nullptr_t) noexcept + { return !lhs; } + Q_DECLARE_EQUALITY_COMPARABLE(QPropertyBindingPrivatePtr, std::nullptr_t) + QtPrivate::RefCounted *d; }; diff --git a/src/corelib/kernel/qsocketnotifier.h b/src/corelib/kernel/qsocketnotifier.h index 8288a6b2b5..ac9e577ebc 100644 --- a/src/corelib/kernel/qsocketnotifier.h +++ b/src/corelib/kernel/qsocketnotifier.h @@ -83,20 +83,20 @@ public: Q_DECL_CONSTEXPR_NOT_WIN bool isValid() const noexcept { return *this != QSocketDescriptor(); } - friend Q_DECL_CONSTEXPR_NOT_WIN bool operator==(QSocketDescriptor lhs, - QSocketDescriptor rhs) noexcept +private: + friend Q_DECL_CONSTEXPR_NOT_WIN bool comparesEqual(const QSocketDescriptor &lhs, + const QSocketDescriptor &rhs) noexcept { return lhs.sockfd == rhs.sockfd; } - friend Q_DECL_CONSTEXPR_NOT_WIN bool operator!=(QSocketDescriptor lhs, - QSocketDescriptor rhs) noexcept - { - return lhs.sockfd != rhs.sockfd; - } +#if defined(Q_OS_WIN) || defined(Q_QDOC) + Q_DECLARE_EQUALITY_COMPARABLE(QSocketDescriptor) +#else + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QSocketDescriptor) +#endif #undef Q_DECL_CONSTEXPR_NOT_WIN -private: DescriptorType sockfd; }; diff --git a/src/corelib/kernel/qvariant.h b/src/corelib/kernel/qvariant.h index d567bcbb7c..306e5b3a38 100644 --- a/src/corelib/kernel/qvariant.h +++ b/src/corelib/kernel/qvariant.h @@ -497,6 +497,7 @@ public: // If possible we reuse the current QVariant private. if (isDetached() && d.type() == metaType) { *reinterpret_cast<VT *>(const_cast<void *>(constData())) = std::forward<T>(avalue); + d.is_null = false; } else { *this = QVariant::fromValue<VT>(std::forward<T>(avalue)); } diff --git a/src/corelib/mimetypes/mime/packages/freedesktop.org.xml b/src/corelib/mimetypes/mime/packages/freedesktop.org.xml index b7aa6a1995..e77349a12e 100644 --- a/src/corelib/mimetypes/mime/packages/freedesktop.org.xml +++ b/src/corelib/mimetypes/mime/packages/freedesktop.org.xml @@ -10699,39 +10699,39 @@ command to generate the output files. <glob pattern="*.udeb"/> </mime-type> <mime-type type="application/x-designer"> - <comment>Qt Designer interface document</comment> - <comment xml:lang="zh_TW">Qt Designer 介面文件</comment> - <comment xml:lang="zh_CN">Qt Designer 界面文档</comment> - <comment xml:lang="uk">документ інтерфейсу Qt Designer</comment> - <comment xml:lang="tr">Qt Designer arayüz belgesi</comment> - <comment xml:lang="sv">Qt Designer-gränssnittsdokument</comment> - <comment xml:lang="sq">dokument ndërfaqesh Qt Designer</comment> - <comment xml:lang="sl">Dokument vmesnika Qt Designer</comment> - <comment xml:lang="si">Qt Designer අතුරුමුහුණත් ලේඛනය</comment> - <comment xml:lang="ru">Документ интерфейса Qt Designer</comment> - <comment xml:lang="pt_BR">Documento de interface do Qt Designer</comment> - <comment xml:lang="pt">documento de interface Qt Designer</comment> - <comment xml:lang="pl">Dokument interfejsu Qt Designer</comment> - <comment xml:lang="nl">Qt Designer-interfacedocument</comment> + <comment>Qt Widgets Designer interface document</comment> + <comment xml:lang="zh_TW">Qt Widgets Designer 介面文件</comment> + <comment xml:lang="zh_CN">Qt Widgets Designer 界面文档</comment> + <comment xml:lang="uk">документ інтерфейсу Qt Widgets Designer</comment> + <comment xml:lang="tr">Qt Widgets Designer arayüz belgesi</comment> + <comment xml:lang="sv">Qt Widgets Designer-gränssnittsdokument</comment> + <comment xml:lang="sq">dokument ndërfaqesh Qt Widgets Designer</comment> + <comment xml:lang="sl">Dokument vmesnika Qt Widgets Designer</comment> + <comment xml:lang="si">Qt Widgets Designer අතුරුමුහුණත් ලේඛනය</comment> + <comment xml:lang="ru">Документ интерфейса Qt Widgets Designer</comment> + <comment xml:lang="pt_BR">Documento de interface do Qt Widgets Designer</comment> + <comment xml:lang="pt">documento de interface Qt Widgets Designer</comment> + <comment xml:lang="pl">Dokument interfejsu Qt Widgets Designer</comment> + <comment xml:lang="nl">Qt Widgets Designer-interfacedocument</comment> <comment xml:lang="ko">Qt 디자이너 인터페이스 문서</comment> - <comment xml:lang="kk">Qt Designer интерфейс құжаты</comment> - <comment xml:lang="ja">Qt Designer インターフェイスドキュメント</comment> - <comment xml:lang="it">Documento interfaccia Qt Designer</comment> - <comment xml:lang="is">Qt Designer viðmótsskjal</comment> - <comment xml:lang="id">Dokumen antarmuka Qt Designer</comment> - <comment xml:lang="hu">Qt Designer felületleíró dokumentum</comment> - <comment xml:lang="hr">Qt Designer dokument sučelja</comment> - <comment xml:lang="he">מסמך מנשק של Qt Designer</comment> - <comment xml:lang="fr">document d'interface Qt Designer</comment> - <comment xml:lang="fi">Qt Designer -käyttöliittymän asiakirja</comment> - <comment xml:lang="eu">Qt Designer interfaze dokumentua</comment> - <comment xml:lang="es">documento de interfaz de Qt Designer</comment> - <comment xml:lang="en_GB">Qt Designer interface document</comment> + <comment xml:lang="kk">Qt Widgets Designer интерфейс құжаты</comment> + <comment xml:lang="ja">Qt Widgets Designer インターフェイスドキュメント</comment> + <comment xml:lang="it">Documento interfaccia Qt Widgets Designer</comment> + <comment xml:lang="is">Qt Widgets Designer viðmótsskjal</comment> + <comment xml:lang="id">Dokumen antarmuka Qt Widgets Designer</comment> + <comment xml:lang="hu">Qt Widgets Designer felületleíró dokumentum</comment> + <comment xml:lang="hr">Qt Widgets Designer dokument sučelja</comment> + <comment xml:lang="he">מסמך מנשק של Qt Widgets Designer</comment> + <comment xml:lang="fr">document d'interface Qt Widgets Designer</comment> + <comment xml:lang="fi">Qt Widgets Designer -käyttöliittymän asiakirja</comment> + <comment xml:lang="eu">Qt Widgets Designer interfaze dokumentua</comment> + <comment xml:lang="es">documento de interfaz de Qt Widgets Designer</comment> + <comment xml:lang="en_GB">Qt Widgets Designer interface document</comment> <comment xml:lang="de">Qt-Designer-Oberflächendokument</comment> - <comment xml:lang="da">Qt Designer-brugerflade-dokument</comment> - <comment xml:lang="ca">document d'interfície Qt Designer</comment> - <comment xml:lang="bg">Документ — интерфейс, Qt Designer</comment> - <comment xml:lang="be">дакумент інтэрфейсу Qt Designer</comment> + <comment xml:lang="da">Qt Widgets Designer-brugerflade-dokument</comment> + <comment xml:lang="ca">document d'interfície Qt Widgets Designer</comment> + <comment xml:lang="bg">Документ — интерфейс, Qt Widgets Designer</comment> + <comment xml:lang="be">дакумент інтэрфейсу Qt Widgets Designer</comment> <comment xml:lang="ar">مستند واجهة مصمم كيوت</comment> <generic-icon name="x-office-document"/> <sub-class-of type="application/xml"/> diff --git a/src/corelib/mimetypes/qmimetype.cpp b/src/corelib/mimetypes/qmimetype.cpp index ad3c484f30..e26c8b898d 100644 --- a/src/corelib/mimetypes/qmimetype.cpp +++ b/src/corelib/mimetypes/qmimetype.cpp @@ -24,6 +24,7 @@ using namespace Qt::StringLiterals; \brief The QMimeType class describes types of file or data, represented by a MIME type string. \since 5.0 + \compares equality For instance a file named "readme.txt" has the MIME type "text/plain". The MIME type can be determined from the file name, or from the file @@ -111,14 +112,15 @@ QMimeType::~QMimeType() } /*! - \fn bool QMimeType::operator==(const QMimeType &other) const; - Returns \c true if \a other equals this QMimeType object, otherwise returns \c false. + \fn bool QMimeType::operator==(const QMimeType &lhs, const QMimeType &rhs); + Returns \c true if \a lhs equals to the \a rhs QMimeType object, otherwise + returns \c false. The name is the unique identifier for a mimetype, so two mimetypes with the same name, are equal. */ -bool QMimeType::operator==(const QMimeType &other) const +bool comparesEqual(const QMimeType &lhs, const QMimeType &rhs) noexcept { - return d == other.d || d->name == other.d->name; + return lhs.d == rhs.d || lhs.d->name == rhs.d->name; } /*! @@ -134,8 +136,9 @@ size_t qHash(const QMimeType &key, size_t seed) noexcept } /*! - \fn bool QMimeType::operator!=(const QMimeType &other) const; - Returns \c true if \a other does not equal this QMimeType object, otherwise returns \c false. + \fn bool QMimeType::operator!=(const QMimeType &lhs, const QMimeType &rhs); + Returns \c true if QMimeType \a lhs is not equal to QMimeType \a rhs, + otherwise returns \c false. */ /*! diff --git a/src/corelib/mimetypes/qmimetype.h b/src/corelib/mimetypes/qmimetype.h index 3421638f5b..508a5cfb53 100644 --- a/src/corelib/mimetypes/qmimetype.h +++ b/src/corelib/mimetypes/qmimetype.h @@ -49,14 +49,14 @@ public: } explicit QMimeType(const QMimeTypePrivate &dd); ~QMimeType(); - +#if QT_CORE_REMOVED_SINCE(6, 8) bool operator==(const QMimeType &other) const; inline bool operator!=(const QMimeType &other) const { return !operator==(other); } - +#endif bool isValid() const; bool isDefault() const; @@ -86,6 +86,10 @@ protected: friend Q_CORE_EXPORT size_t qHash(const QMimeType &key, size_t seed) noexcept; QExplicitlySharedDataPointer<QMimeTypePrivate> d; + +private: + friend Q_CORE_EXPORT bool comparesEqual(const QMimeType &lhs, const QMimeType &rhs) noexcept; + Q_DECLARE_EQUALITY_COMPARABLE(QMimeType) }; Q_DECLARE_SHARED(QMimeType) diff --git a/src/corelib/platform/android/qandroidnativeinterface.cpp b/src/corelib/platform/android/qandroidnativeinterface.cpp index fc3a09c78b..351893eb81 100644 --- a/src/corelib/platform/android/qandroidnativeinterface.cpp +++ b/src/corelib/platform/android/qandroidnativeinterface.cpp @@ -49,7 +49,7 @@ QT_DEFINE_NATIVE_INTERFACE(QAndroidApplication); \fn QJniObject QNativeInterface::QAndroidApplication::context() Returns the Android context as a \c QJniObject. The context is an \c Activity - if the main activity object is valid. Otherwise, the context is a \c Service. + if the most recently started activity object is valid. Otherwise, the context is a \c Service. \since 6.2 */ diff --git a/src/corelib/plugin/qelfparser_p.cpp b/src/corelib/plugin/qelfparser_p.cpp index 7f6271cde4..78c9be0e56 100644 --- a/src/corelib/plugin/qelfparser_p.cpp +++ b/src/corelib/plugin/qelfparser_p.cpp @@ -35,7 +35,7 @@ static constexpr bool IncludeValidityChecks = true; # define QELFPARSER_DEBUG #endif #if defined(QELFPARSER_DEBUG) -static Q_LOGGING_CATEGORY(lcElfParser, "qt.core.plugin.elfparser") +Q_STATIC_LOGGING_CATEGORY(lcElfParser, "qt.core.plugin.elfparser") # define qEDebug qCDebug(lcElfParser) << reinterpret_cast<const char16_t *>(error.errMsg->constData()) << ':' #else # define qEDebug if (false) {} else QNoDebug() diff --git a/src/corelib/plugin/qfactoryloader.cpp b/src/corelib/plugin/qfactoryloader.cpp index e2d9a40cb4..6486414d8c 100644 --- a/src/corelib/plugin/qfactoryloader.cpp +++ b/src/corelib/plugin/qfactoryloader.cpp @@ -272,7 +272,7 @@ public: #if QT_CONFIG(library) -static Q_LOGGING_CATEGORY_WITH_ENV_OVERRIDE(lcFactoryLoader, "QT_DEBUG_PLUGINS", +Q_STATIC_LOGGING_CATEGORY_WITH_ENV_OVERRIDE(lcFactoryLoader, "QT_DEBUG_PLUGINS", "qt.core.plugin.factoryloader") namespace { diff --git a/src/corelib/plugin/qlibrary.cpp b/src/corelib/plugin/qlibrary.cpp index a3ef8e3c52..8f1db7e4d4 100644 --- a/src/corelib/plugin/qlibrary.cpp +++ b/src/corelib/plugin/qlibrary.cpp @@ -55,7 +55,7 @@ static constexpr bool QtBuildIsDebug = true; #endif Q_LOGGING_CATEGORY_WITH_ENV_OVERRIDE(qt_lcDebugPlugins, "QT_DEBUG_PLUGINS", "qt.core.plugin.loader") -static Q_LOGGING_CATEGORY_WITH_ENV_OVERRIDE(lcDebugLibrary, "QT_DEBUG_PLUGINS", "qt.core.library") +Q_STATIC_LOGGING_CATEGORY_WITH_ENV_OVERRIDE(lcDebugLibrary, "QT_DEBUG_PLUGINS", "qt.core.library") /*! \class QLibrary diff --git a/src/corelib/plugin/quuid.cpp b/src/corelib/plugin/quuid.cpp index 9c7216c3c5..b3fad47ee6 100644 --- a/src/corelib/plugin/quuid.cpp +++ b/src/corelib/plugin/quuid.cpp @@ -116,12 +116,12 @@ static QUuid _q_uuidFromHex(const char *src) return QUuid(); } -static QUuid createFromName(const QUuid &ns, const QByteArray &baseData, QCryptographicHash::Algorithm algorithm, int version) +static QUuid createFromName(QUuid ns, QByteArrayView baseData, QCryptographicHash::Algorithm algorithm, int version) noexcept { - QCryptographicHash hash(algorithm); - hash.addData(ns.toRfc4122()); - hash.addData(baseData); - QByteArrayView hashResult = hash.resultView(); + std::byte buffer[20]; + Q_ASSERT(sizeof buffer >= size_t(QCryptographicHash::hashLength(algorithm))); + QByteArrayView hashResult + = QCryptographicHash::hashInto(buffer, {QByteArrayView{ns.toBytes()}, baseData}, algorithm); Q_ASSERT(hashResult.size() >= 16); hashResult.truncate(16); // Sha1 will be too long @@ -142,6 +142,11 @@ static QUuid createFromName(const QUuid &ns, const QByteArray &baseData, QCrypto \reentrant + \compares strong + \compareswith strong GUID + \note Comparison with GUID is Windows-only. + \endcompareswith + Using \e{U}niversally \e{U}nique \e{ID}entifiers (UUID) is a standard way to uniquely identify entities in a distributed computing environment. A UUID is a 16-byte (128-bit) number @@ -527,11 +532,14 @@ QUuid QUuid::fromString(QAnyStringView text) noexcept /*! \since 5.0 - \fn QUuid QUuid::createUuidV3(const QUuid &ns, const QByteArray &baseData); + \fn QUuid QUuid::createUuidV3(QUuid ns, QByteArrayView baseData); This function returns a new UUID with variant QUuid::DCE and version QUuid::Md5. \a ns is the namespace and \a baseData is the basic data as described by RFC 4122. + \note In Qt versions prior to 6.8, this function took QByteArray, not + QByteArrayView. + \sa variant(), version(), createUuidV5() */ @@ -547,11 +555,14 @@ QUuid QUuid::fromString(QAnyStringView text) noexcept /*! \since 5.0 - \fn QUuid QUuid::createUuidV5(const QUuid &ns, const QByteArray &baseData); + \fn QUuid QUuid::createUuidV5(QUuid ns, QByteArrayView baseData); This function returns a new UUID with variant QUuid::DCE and version QUuid::Sha1. \a ns is the namespace and \a baseData is the basic data as described by RFC 4122. + \note In Qt versions prior to 6.8, this function took QByteArray, not + QByteArrayView. + \sa variant(), version(), createUuidV3() */ @@ -565,13 +576,13 @@ QUuid QUuid::fromString(QAnyStringView text) noexcept \sa variant(), version(), createUuidV3() */ #ifndef QT_BOOTSTRAPPED -QUuid QUuid::createUuidV3(const QUuid &ns, const QByteArray &baseData) +QUuid QUuid::createUuidV3(QUuid ns, QByteArrayView baseData) noexcept { return createFromName(ns, baseData, QCryptographicHash::Md5, 3); } #endif -QUuid QUuid::createUuidV5(const QUuid &ns, const QByteArray &baseData) +QUuid QUuid::createUuidV5(QUuid ns, QByteArrayView baseData) noexcept { return createFromName(ns, baseData, QCryptographicHash::Sha1, 5); } @@ -600,16 +611,16 @@ QUuid QUuid::fromRfc4122(QByteArrayView bytes) noexcept } /*! - \fn bool QUuid::operator==(const QUuid &other) const + \fn bool QUuid::operator==(const QUuid &lhs, const QUuid &rhs) - Returns \c true if this QUuid and the \a other QUuid are identical; + Returns \c true if \a lhs QUuid and the \a rhs QUuid are identical; otherwise returns \c false. */ /*! - \fn bool QUuid::operator!=(const QUuid &other) const + \fn bool QUuid::operator!=(const QUuid &lhs, const QUuid &rhs) - Returns \c true if this QUuid and the \a other QUuid are different; + Returns \c true if \a lhs QUuid and the \a rhs QUuid are different; otherwise returns \c false. */ @@ -898,51 +909,31 @@ QUuid::Version QUuid::version() const noexcept } /*! - \fn bool QUuid::operator<(const QUuid &other) const + \fn bool QUuid::operator<(const QUuid &lhs, const QUuid &rhs) - Returns \c true if this QUuid has the same \l{Variant field} - {variant field} as the \a other QUuid and is lexicographically - \e{before} the \a other QUuid. If the \a other QUuid has a + Returns \c true if \a lhs QUuid has the same \l{Variant field} + {variant field} as the \a rhs QUuid and is lexicographically + \e{before} the \a rhs QUuid. If the \a rhs QUuid has a different variant field, the return value is determined by comparing the two \l{QUuid::Variant} {variants}. \sa variant() */ -bool QUuid::operator<(const QUuid &other) const noexcept -{ - if (variant() != other.variant()) - return variant() < other.variant(); - -#define ISLESS(f1, f2) if (f1!=f2) return (f1<f2); - ISLESS(data1, other.data1); - ISLESS(data2, other.data2); - ISLESS(data3, other.data3); - for (int n = 0; n < 8; n++) { - ISLESS(data4[n], other.data4[n]); - } -#undef ISLESS - return false; -} /*! - \fn bool QUuid::operator>(const QUuid &other) const + \fn bool QUuid::operator>(const QUuid &lhs, const QUuid &rhs) - Returns \c true if this QUuid has the same \l{Variant field} - {variant field} as the \a other QUuid and is lexicographically - \e{after} the \a other QUuid. If the \a other QUuid has a + Returns \c true if \a lhs QUuid has the same \l{Variant field} + {variant field} as the \a rhs QUuid and is lexicographically + \e{after} the \a rhs QUuid. If the \a rhs QUuid has a different variant field, the return value is determined by comparing the two \l{QUuid::Variant} {variants}. \sa variant() */ -bool QUuid::operator>(const QUuid &other) const noexcept -{ - return other < *this; -} /*! - \fn bool operator<=(const QUuid &lhs, const QUuid &rhs) - \relates QUuid + \fn bool QUuid::operator<=(const QUuid &lhs, const QUuid &rhs) \since 5.5 Returns \c true if \a lhs has the same \l{Variant field} @@ -955,8 +946,7 @@ bool QUuid::operator>(const QUuid &other) const noexcept */ /*! - \fn bool operator>=(const QUuid &lhs, const QUuid &rhs) - \relates QUuid + \fn bool QUuid::operator>=(const QUuid &lhs, const QUuid &rhs) \since 5.5 Returns \c true if \a lhs has the same \l{Variant field} @@ -1009,17 +999,17 @@ QUuid QUuid::createUuid() #endif // !Q_OS_WIN && !QT_BOOTSTRAPPED /*! - \fn bool QUuid::operator==(const GUID &guid) const + \fn bool QUuid::operator==(const QUuid &lhs, const GUID &rhs) - Returns \c true if this UUID is equal to the Windows GUID \a guid; + Returns \c true if \a lhs UUID is equal to the Windows GUID \a rhs; otherwise returns \c false. */ /*! - \fn bool QUuid::operator!=(const GUID &guid) const + \fn bool QUuid::operator!=(const QUuid &lhs, const GUID &rhs) - Returns \c true if this UUID is not equal to the Windows GUID \a - guid; otherwise returns \c false. + Returns \c true if \a lhs UUID is not equal to the Windows GUID \a rhs; + otherwise returns \c false. */ #ifndef QT_NO_DEBUG_STREAM diff --git a/src/corelib/plugin/quuid.h b/src/corelib/plugin/quuid.h index 7125e8e2cc..591d9b27c4 100644 --- a/src/corelib/plugin/quuid.h +++ b/src/corelib/plugin/quuid.h @@ -4,6 +4,7 @@ #ifndef QUUID_H #define QUUID_H +#include <QtCore/qcompare.h> #include <QtCore/qendian.h> #include <QtCore/qstring.h> @@ -122,27 +123,60 @@ QT_WARNING_POP constexpr quint128 toUInt128(QSysInfo::Endian order = QSysInfo::BigEndian) const noexcept; #endif - constexpr bool operator==(const QUuid &orig) const noexcept +private: + friend constexpr bool comparesEqual(const QUuid &lhs, const QUuid &rhs) noexcept { - if (data1 != orig.data1 || data2 != orig.data2 || - data3 != orig.data3) + if (lhs.data1 != rhs.data1 || lhs.data2 != rhs.data2 || lhs.data3 != rhs.data3) return false; - for (uint i = 0; i < 8; i++) - if (data4[i] != orig.data4[i]) + for (uint i = 0; i < 8; i++) { + if (lhs.data4[i] != rhs.data4[i]) return false; + } return true; } + friend Qt::strong_ordering compareThreeWay(const QUuid &lhs, const QUuid &rhs) noexcept + { + if (lhs.variant() != rhs.variant()) + return Qt::compareThreeWay(lhs.variant(), rhs.variant()); + if (lhs.data1 != rhs.data1) + return Qt::compareThreeWay(lhs.data1, rhs.data1); + if (lhs.data2 != rhs.data2) + return Qt::compareThreeWay(lhs.data2, rhs.data2); + if (lhs.data3 != rhs.data3) + return Qt::compareThreeWay(lhs.data3, rhs.data3); + + int c = std::memcmp(lhs.data4, rhs.data4, sizeof(lhs.data4)); + return Qt::compareThreeWay(c, 0); + } + +public: +/* To prevent a meta-type creation ambiguity on Windows, we put comparison + macros under NOT QT_CORE_REMOVED_SINCE(6, 8) part. */ +#if QT_CORE_REMOVED_SINCE(6, 8) + constexpr bool operator==(const QUuid &orig) const noexcept + { + return comparesEqual(*this, orig); + } constexpr bool operator!=(const QUuid &orig) const noexcept { - return !(*this == orig); + return !operator==(orig); } bool operator<(const QUuid &other) const noexcept; bool operator>(const QUuid &other) const noexcept; - +#else +private: +#if defined(__cpp_lib_three_way_comparison) && !defined(Q_QDOC) + QT_DECLARE_3WAY_HELPER_STRONG(QUuid, QUuid, /* non-constexpr */, /* no attributes */) +#else + QT_DECLARE_ORDERING_HELPER_STRONG(QUuid, QUuid, /* non-constexpr */, /* no attributes */) +#endif // defined(__cpp_lib_three_way_comparison) && !defined(Q_QDOC) + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QUuid) +#endif // QT_CORE_REMOVED_SINCE(6, 8) +public: #if defined(Q_OS_WIN) || defined(Q_QDOC) // On Windows we have a type GUID that is used by the platform API, so we // provide convenience operators to cast from and to this type. @@ -162,32 +196,51 @@ QT_WARNING_POP GUID guid = { data1, data2, data3, { data4[0], data4[1], data4[2], data4[3], data4[4], data4[5], data4[6], data4[7] } }; return guid; } - +private: + friend constexpr bool comparesEqual(const QUuid &lhs, const GUID &rhs) noexcept + { + return comparesEqual(lhs, QUuid(rhs)); + } +public: +/* To prevent a meta-type creation ambiguity on Windows, we put comparison + macros under NOT QT_CORE_REMOVED_SINCE(6, 8) part. */ +#if QT_CORE_REMOVED_SINCE(6, 8) constexpr bool operator==(const GUID &guid) const noexcept { - return *this == QUuid(guid); + return comparesEqual(*this, QUuid(guid)); } constexpr bool operator!=(const GUID &guid) const noexcept { - return !(*this == guid); + return !operator==(guid); } +#else + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QUuid, GUID) +#endif // !QT_CORE_REMOVED_SINCE(6, 8) #endif +public: static QUuid createUuid(); -#ifndef QT_BOOTSTRAPPED - static QUuid createUuidV3(const QUuid &ns, const QByteArray &baseData); +#if QT_CORE_REMOVED_SINCE(6, 8) + static QUuid createUuidV3(const QUuid &ns, const QByteArray &baseData) noexcept; + static QUuid createUuidV5(const QUuid &ns, const QByteArray &baseData) noexcept; #endif - static QUuid createUuidV5(const QUuid &ns, const QByteArray &baseData); + static QUuid createUuidV5(QUuid ns, QByteArrayView baseData) noexcept; #ifndef QT_BOOTSTRAPPED + static QUuid createUuidV3(QUuid ns, QByteArrayView baseData) noexcept; +#if !QT_CORE_REMOVED_SINCE(6, 8) + Q_WEAK_OVERLOAD +#endif static inline QUuid createUuidV3(const QUuid &ns, const QString &baseData) { - return QUuid::createUuidV3(ns, baseData.toUtf8()); + return QUuid::createUuidV3(ns, qToByteArrayViewIgnoringNull(baseData.toUtf8())); } #endif - +#if !QT_CORE_REMOVED_SINCE(6, 8) + Q_WEAK_OVERLOAD +#endif static inline QUuid createUuidV5(const QUuid &ns, const QString &baseData) { - return QUuid::createUuidV5(ns, baseData.toUtf8()); + return QUuid::createUuidV5(ns, qToByteArrayViewIgnoringNull(baseData.toUtf8())); } QUuid::Variant variant() const noexcept; @@ -291,11 +344,6 @@ constexpr quint128 QUuid::toUInt128(QSysInfo::Endian order) const noexcept } #endif -inline bool operator<=(const QUuid &lhs, const QUuid &rhs) noexcept -{ return !(rhs < lhs); } -inline bool operator>=(const QUuid &lhs, const QUuid &rhs) noexcept -{ return !(lhs < rhs); } - #if defined(Q_QDOC) // provide fake declarations of qXXXEndian() functions, so that qDoc could // distinguish them from the general template diff --git a/src/corelib/serialization/qdatastream.cpp b/src/corelib/serialization/qdatastream.cpp index d35e871de0..3d6d1d8e92 100644 --- a/src/corelib/serialization/qdatastream.cpp +++ b/src/corelib/serialization/qdatastream.cpp @@ -547,6 +547,7 @@ void QDataStream::setByteOrder(ByteOrder bo) \value Qt_6_6 Version 21 (Qt 6.6) \value Qt_6_7 Version 22 (Qt 6.7) \value Qt_6_8 Same as Qt_6_7 + \value Qt_6_9 Same as Qt_6_7 \omitvalue Qt_DefaultCompiledVersion \sa setVersion(), version() @@ -1088,26 +1089,22 @@ QDataStream &QDataStream::readBytes(char *&s, qint64 &l) qsizetype step = (dev->bytesAvailable() >= len) ? len : 1024 * 1024; qsizetype allocated = 0; - char *prevBuf = nullptr; - char *curBuf = nullptr; + std::unique_ptr<char[]> curBuf = nullptr; + constexpr qsizetype StepIncreaseThreshold = std::numeric_limits<qsizetype>::max() / 2; do { qsizetype blockSize = qMin(step, len - allocated); - prevBuf = curBuf; - curBuf = new char[allocated + blockSize + 1]; - if (prevBuf) { - memcpy(curBuf, prevBuf, allocated); - delete [] prevBuf; - } - if (readBlock(curBuf + allocated, blockSize) != blockSize) { - delete [] curBuf; + const qsizetype n = allocated + blockSize + 1; + if (const auto prevBuf = std::exchange(curBuf, std::make_unique<char[]>(n))) + memcpy(curBuf.get(), prevBuf.get(), allocated); + if (readBlock(curBuf.get() + allocated, blockSize) != blockSize) return *this; - } allocated += blockSize; - step *= 2; + if (step <= StepIncreaseThreshold) + step *= 2; } while (allocated < len); - s = curBuf; + s = curBuf.release(); s[len] = '\0'; l = len; return *this; diff --git a/src/corelib/serialization/qdatastream.h b/src/corelib/serialization/qdatastream.h index cf37df71d7..32b0f96ab8 100644 --- a/src/corelib/serialization/qdatastream.h +++ b/src/corelib/serialization/qdatastream.h @@ -8,6 +8,7 @@ #include <QtCore/qiodevicebase.h> #include <QtCore/qcontainerfwd.h> #include <QtCore/qnamespace.h> +#include <QtCore/qttypetraits.h> #include <iterator> // std::distance(), std::next() @@ -87,8 +88,9 @@ public: Qt_6_6 = 21, Qt_6_7 = 22, Qt_6_8 = Qt_6_7, - Qt_DefaultCompiledVersion = Qt_6_8 -#if QT_VERSION >= QT_VERSION_CHECK(6, 9, 0) + Qt_6_9 = Qt_6_7, + Qt_DefaultCompiledVersion = Qt_6_9 +#if QT_VERSION >= QT_VERSION_CHECK(6, 10, 0) #error Add the datastream version for this Qt version and update Qt_DefaultCompiledVersion #endif }; diff --git a/src/corelib/text/qanystringview.h b/src/corelib/text/qanystringview.h index 01efd83743..843fa7e5c9 100644 --- a/src/corelib/text/qanystringview.h +++ b/src/corelib/text/qanystringview.h @@ -62,10 +62,13 @@ private: }; template <typename Char> - using if_compatible_char = std::enable_if_t<std::disjunction_v< + using is_compatible_char = std::disjunction< QtPrivate::IsCompatibleCharType<Char>, QtPrivate::IsCompatibleChar8Type<Char> - >, bool>; + >; + + template <typename Char> + using if_compatible_char = std::enable_if_t<is_compatible_char<Char>::value, bool>; template <typename Pointer> using if_compatible_pointer = std::enable_if_t<std::disjunction_v< @@ -87,6 +90,7 @@ private: std::is_same<q20::remove_cvref_t<T>, QAnyStringView::Tag>, std::is_same<q20::remove_cvref_t<T>, QAnyStringView>, // don't make a copy/move ctor std::is_pointer<std::decay_t<T>>, // const char*, etc + is_compatible_char<T>, // don't create a QString/QByteArray, we have a ctor std::is_same<q20::remove_cvref_t<T>, QByteArray>, std::is_same<q20::remove_cvref_t<T>, QString> >>, @@ -144,6 +148,11 @@ private: static QChar toQChar(QChar ch) noexcept { return ch; } static QChar toQChar(QLatin1Char ch) noexcept { return ch; } + struct QCharContainer { // private, so users can't pass their own + explicit QCharContainer() = default; + QChar ch; + }; + explicit constexpr QAnyStringView(const void *d, qsizetype n, std::size_t sizeAndType) noexcept : m_data{d}, m_size{std::size_t(n) | (sizeAndType & TypeMask)} {} public: @@ -193,16 +202,16 @@ public: constexpr QAnyStringView(Container &&c, QtPrivate::wrapped_t<Container, QByteArray> &&capacity = {}) //noexcept(std::is_nothrow_constructible_v<QByteArray, Container>) : QAnyStringView(capacity = std::forward<Container>(c)) {} - template <typename Char, if_compatible_char<Char> = true> constexpr QAnyStringView(const Char &c) noexcept : QAnyStringView{&c, 1} {} - constexpr QAnyStringView(const QChar &c) noexcept - : QAnyStringView{&c, 1} {} + template <typename Char, if_convertible_to<QChar, Char> = true> + constexpr QAnyStringView(Char ch, QCharContainer &&capacity = QCharContainer()) noexcept + : QAnyStringView{&(capacity.ch = ch), 1} {} template <typename Char, typename Container = decltype(QChar::fromUcs4(U'x')), std::enable_if_t<std::is_same_v<Char, char32_t>, bool> = true> - constexpr QAnyStringView(Char c, Container &&capacity = {}) + constexpr QAnyStringView(Char c, Container &&capacity = {}) noexcept : QAnyStringView(capacity = QChar::fromUcs4(c)) {} constexpr QAnyStringView(QStringView v) noexcept diff --git a/src/corelib/text/qbytearray.cpp b/src/corelib/text/qbytearray.cpp index e6387e4bed..d9f0ee405a 100644 --- a/src/corelib/text/qbytearray.cpp +++ b/src/corelib/text/qbytearray.cpp @@ -56,15 +56,35 @@ static constexpr inline uchar asciiLower(uchar c) return c >= 'A' && c <= 'Z' ? c | 0x20 : c; } -qsizetype qFindByteArray( - const char *haystack0, qsizetype haystackLen, qsizetype from, - const char *needle0, qsizetype needleLen); - /***************************************************************************** Safe and portable C string functions; extensions to standard string.h *****************************************************************************/ /*! \relates QByteArray + \internal + + Wrapper around memrchr() for systems that don't have it. It's provided in + every system because, as a GNU extension, memrchr() may not be declared in + string.h depending on how strict the compiler was asked to be. + + Used in QByteArrayView::lastIndexOf() overload for a single char. +*/ +const void *qmemrchr(const void *s, int needle, size_t size) noexcept +{ +#if QT_CONFIG(memrchr) + return memrchr(s, needle, size); +#endif + auto b = static_cast<const char *>(s); + const char *n = b + size; + while (n-- != b) { + if (*n == needle) + return n; + } + return nullptr; +} + + +/*! \relates QByteArray Returns a duplicate string. @@ -2680,31 +2700,6 @@ QByteArray QByteArray::repeated(qsizetype times) const return result; } -#define REHASH(a) \ - if (ol_minus_1 < sizeof(std::size_t) * CHAR_BIT) \ - hashHaystack -= std::size_t(a) << ol_minus_1; \ - hashHaystack <<= 1 - -qsizetype QtPrivate::findByteArray(QByteArrayView haystack, qsizetype from, QByteArrayView needle) noexcept -{ - const auto ol = needle.size(); - const auto l = haystack.size(); - if (ol == 0) { - if (from < 0) - return qMax(from + l, 0); - else - return from > l ? -1 : from; - } - - if (ol == 1) - return findByteArray(haystack, from, needle.front()); - - if (from > l || ol + from > l) - return -1; - - return qFindByteArray(haystack.data(), haystack.size(), from, needle.data(), ol); -} - /*! \fn qsizetype QByteArray::indexOf(QByteArrayView bv, qsizetype from) const \since 6.0 @@ -2745,10 +2740,10 @@ static qsizetype lastIndexOfHelper(const char *haystack, qsizetype l, const char const char *end = haystack; haystack += from; - const auto ol_minus_1 = std::size_t(ol - 1); + const qregisteruint ol_minus_1 = ol - 1; const char *n = needle + ol_minus_1; const char *h = haystack + ol_minus_1; - std::size_t hashNeedle = 0, hashHaystack = 0; + qregisteruint hashNeedle = 0, hashHaystack = 0; qsizetype idx; for (idx = 0; idx < ol; ++idx) { hashNeedle = ((hashNeedle<<1) + *(n-idx)); @@ -2760,34 +2755,11 @@ static qsizetype lastIndexOfHelper(const char *haystack, qsizetype l, const char if (hashHaystack == hashNeedle && memcmp(needle, haystack, ol) == 0) return haystack - end; --haystack; - REHASH(*(haystack + ol)); + if (ol_minus_1 < sizeof(ol_minus_1) * CHAR_BIT) + hashHaystack -= qregisteruint(*(haystack + ol)) << ol_minus_1; + hashHaystack <<= 1; } return -1; - -} - -static inline qsizetype lastIndexOfCharHelper(QByteArrayView haystack, qsizetype from, char needle) noexcept -{ - if (haystack.size() == 0) - return -1; - if (from < 0) - from += haystack.size(); - else if (from > haystack.size()) - from = haystack.size() - 1; - if (from >= 0) { - const char *b = haystack.data(); - const char *n = b + from + 1; - while (n-- != b) { - if (*n == needle) - return n - b; - } - } - return -1; -} - -qsizetype QtPrivate::lastIndexOf(QByteArrayView haystack, qsizetype from, char needle) noexcept -{ - return lastIndexOfCharHelper(haystack, from, needle); } qsizetype QtPrivate::lastIndexOf(QByteArrayView haystack, qsizetype from, QByteArrayView needle) noexcept @@ -2799,7 +2771,7 @@ qsizetype QtPrivate::lastIndexOf(QByteArrayView haystack, qsizetype from, QByteA } const auto ol = needle.size(); if (ol == 1) - return lastIndexOfCharHelper(haystack, from, needle.front()); + return QtPrivate::lastIndexOf(haystack, from, needle.front()); return lastIndexOfHelper(haystack.data(), haystack.size(), needle.data(), ol, from); } @@ -4218,24 +4190,6 @@ QByteArray QByteArray::toBase64(Base64Options options) const \sa toUShort() */ -static char *qulltoa2(char *p, qulonglong n, int base) -{ -#if defined(QT_CHECK_RANGE) - if (base < 2 || base > 36) { - qWarning("QByteArray::setNum: Invalid base %d", base); - base = 10; - } -#endif - constexpr char b = 'a' - 10; - do { - const int c = n % base; - n /= base; - *--p = c + (c < 10 ? '0' : b); - } while (n); - - return p; -} - /*! \overload @@ -4255,9 +4209,7 @@ QByteArray &QByteArray::setNum(qlonglong n, int base) p = qulltoa2(buff + buffsize, qulonglong(n), base); } - clear(); - append(p, buffsize - (p - buff)); - return *this; + return assign(QByteArrayView{p, buff + buffsize}); } /*! @@ -4272,9 +4224,7 @@ QByteArray &QByteArray::setNum(qulonglong n, int base) char buff[buffsize]; char *p = qulltoa2(buff + buffsize, n, base); - clear(); - append(p, buffsize - (p - buff)); - return *this; + return assign(QByteArrayView{p, buff + buffsize}); } /*! @@ -5206,5 +5156,3 @@ size_t qHash(const QByteArray::FromBase64Result &key, size_t seed) noexcept */ QT_END_NAMESPACE - -#undef REHASH diff --git a/src/corelib/text/qbytearrayalgorithms.h b/src/corelib/text/qbytearrayalgorithms.h index 7060161bb4..649ec2e39b 100644 --- a/src/corelib/text/qbytearrayalgorithms.h +++ b/src/corelib/text/qbytearrayalgorithms.h @@ -31,8 +31,8 @@ qsizetype findByteArray(QByteArrayView haystack, qsizetype from, char needle) no [[nodiscard]] Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype findByteArray(QByteArrayView haystack, qsizetype from, QByteArrayView needle) noexcept; -[[nodiscard]] Q_CORE_EXPORT Q_DECL_PURE_FUNCTION -qsizetype lastIndexOf(QByteArrayView haystack, qsizetype from, char needle) noexcept; +[[nodiscard]] inline Q_DECL_PURE_FUNCTION +qsizetype lastIndexOf(QByteArrayView haystack, qsizetype from, uchar needle) noexcept; [[nodiscard]] Q_CORE_EXPORT Q_DECL_PURE_FUNCTION qsizetype lastIndexOf(QByteArrayView haystack, qsizetype from, QByteArrayView needle) noexcept; @@ -99,6 +99,8 @@ static inline T toIntegral(ByteArrayView data, bool *ok, int base) Safe and portable C string functions; extensions to standard string.h *****************************************************************************/ +[[nodiscard]] Q_DECL_PURE_FUNCTION Q_CORE_EXPORT +const void *qmemrchr(const void *s, int needle, size_t n) noexcept; Q_CORE_EXPORT char *qstrdup(const char *); inline size_t qstrlen(const char *str) diff --git a/src/corelib/text/qbytearraymatcher.cpp b/src/corelib/text/qbytearraymatcher.cpp index ae38fb584b..9f27e10f3d 100644 --- a/src/corelib/text/qbytearraymatcher.cpp +++ b/src/corelib/text/qbytearraymatcher.cpp @@ -3,6 +3,11 @@ #include "qbytearraymatcher.h" +#include <qtconfiginclude.h> +#ifndef QT_BOOTSTRAPPED +# include <private/qtcore-config_p.h> +#endif + #include <limits.h> QT_BEGIN_NAMESPACE @@ -212,26 +217,10 @@ qsizetype QByteArrayMatcher::indexIn(QByteArrayView data, qsizetype from) const \sa setPattern() */ - -static qsizetype findChar(const char *str, qsizetype len, char ch, qsizetype from) -{ - const uchar *s = (const uchar *)str; - uchar c = (uchar)ch; - if (from < 0) - from = qMax(from + len, qsizetype(0)); - if (from < len) { - const uchar *n = s + from - 1; - const uchar *e = s + len; - while (++n != e) - if (*n == c) - return n - s; - } - return -1; -} - /*! \internal */ +Q_NEVER_INLINE static qsizetype qFindByteArrayBoyerMoore( const char *haystack, qsizetype haystackLen, qsizetype haystackOffset, const char *needle, qsizetype needleLen) @@ -244,20 +233,21 @@ static qsizetype qFindByteArrayBoyerMoore( (const uchar *)needle, needleLen, skiptable); } -#define REHASH(a) \ - if (sl_minus_1 < sizeof(std::size_t) * CHAR_BIT) \ - hashHaystack -= std::size_t(a) << sl_minus_1; \ - hashHaystack <<= 1 - /*! \internal */ -qsizetype qFindByteArray( - const char *haystack0, qsizetype haystackLen, qsizetype from, - const char *needle, qsizetype needleLen) +static qsizetype qFindByteArray(const char *haystack0, qsizetype l, qsizetype from, + const char *needle, qsizetype sl); +qsizetype QtPrivate::findByteArray(QByteArrayView haystack, qsizetype from, QByteArrayView needle) noexcept { - const auto l = haystackLen; - const auto sl = needleLen; + const auto haystack0 = haystack.data(); + const auto l = haystack.size(); + const auto sl = needle.size(); +#if !QT_CONFIG(memmem) + if (sl == 1) + return findByteArray(haystack, from, needle.front()); +#endif + if (from < 0) from += l; if (std::size_t(sl + from) > std::size_t(l)) @@ -267,8 +257,10 @@ qsizetype qFindByteArray( if (!l) return -1; - if (sl == 1) - return findChar(haystack0, haystackLen, needle[0], from); +#if QT_CONFIG(memmem) + auto where = memmem(haystack0 + from, l - from, needle.data(), sl); + return where ? static_cast<const char *>(where) - haystack0 : -1; +#endif /* We use the Boyer-Moore algorithm in cases where the overhead @@ -276,18 +268,22 @@ qsizetype qFindByteArray( hash function. */ if (l > 500 && sl > 5) - return qFindByteArrayBoyerMoore(haystack0, haystackLen, from, - needle, needleLen); + return qFindByteArrayBoyerMoore(haystack0, l, from, needle.data(), sl); + return qFindByteArray(haystack0, l, from, needle.data(), sl); +} +qsizetype qFindByteArray(const char *haystack0, qsizetype l, qsizetype from, + const char *needle, qsizetype sl) +{ /* We use some hashing for efficiency's sake. Instead of comparing strings, we compare the hash value of str with that - of a part of this QString. Only if that matches, we call memcmp(). + of a part of this QByteArray. Only if that matches, we call memcmp(). */ const char *haystack = haystack0 + from; const char *end = haystack0 + (l - sl); - const auto sl_minus_1 = std::size_t(sl - 1); - std::size_t hashNeedle = 0, hashHaystack = 0; + const qregisteruint sl_minus_1 = sl - 1; + qregisteruint hashNeedle = 0, hashHaystack = 0; qsizetype idx; for (idx = 0; idx < sl; ++idx) { hashNeedle = ((hashNeedle<<1) + needle[idx]); @@ -301,7 +297,9 @@ qsizetype qFindByteArray( && memcmp(needle, haystack, sl) == 0) return haystack - haystack0; - REHASH(*haystack); + if (sl_minus_1 < sizeof(sl_minus_1) * CHAR_BIT) + hashHaystack -= qregisteruint(*haystack) << sl_minus_1; + hashHaystack <<= 1; ++haystack; } return -1; @@ -409,7 +407,4 @@ qsizetype QStaticByteArrayMatcherBase::indexOfIn(const char *needle, size_t nlen \snippet code/src_corelib_text_qbytearraymatcher.cpp 1 */ - QT_END_NAMESPACE - -#undef REHASH diff --git a/src/corelib/text/qbytearrayview.h b/src/corelib/text/qbytearrayview.h index 45ebc812cd..9f7d854a9a 100644 --- a/src/corelib/text/qbytearrayview.h +++ b/src/corelib/text/qbytearrayview.h @@ -401,6 +401,18 @@ qsizetype QtPrivate::findByteArray(QByteArrayView haystack, qsizetype from, char return -1; } +qsizetype QtPrivate::lastIndexOf(QByteArrayView haystack, qsizetype from, uchar needle) noexcept +{ + if (from < 0) + from = qMax(from + haystack.size(), qsizetype(0)); + else + from = qMin(from, haystack.size() - 1); + + const char *const b = haystack.data(); + const void *n = b ? qmemrchr(b, needle, from + 1) : nullptr; + return n ? static_cast<const char *>(n) - b : -1; +} + QT_END_NAMESPACE #endif // QBYTEARRAYVIEW_H diff --git a/src/corelib/text/qchar.cpp b/src/corelib/text/qchar.cpp index 63296a92de..7b114e9723 100644 --- a/src/corelib/text/qchar.cpp +++ b/src/corelib/text/qchar.cpp @@ -123,9 +123,7 @@ QT_BEGIN_NAMESPACE Starting with Qt 6.0, most QChar constructors are \c explicit. This is done to avoid dangerous mistakes when accidentally mixing - integral types and strings. You can opt-out (and make these - constructors implicit) by defining the macro \c - QT_IMPLICIT_QCHAR_CONSTRUCTION. + integral types and strings. For more information see \l{https://www.unicode.org/ucd/}{"About the Unicode Character Database"}. @@ -2110,51 +2108,4 @@ static bool normalizationQuickCheckHelper(QString *str, QString::NormalizationFo return true; } -/*! - \macro QT_IMPLICIT_QCHAR_CONSTRUCTION - \since 6.0 - \relates QChar - - Defining this macro makes certain QChar constructors implicit - rather than explicit. This is done to enforce safe conversions: - - \badcode - - QString str = getString(); - if (str == 123) { - // Oops, meant str == "123". By default does not compile, - // *unless* this macro is defined, in which case, it's interpreted - // as `if (str == QChar(123))`, that is, `if (str == '{')`. - // Likely, not what we meant. - } - - \endcode - - This macro is provided to keep existing code working; it is - recommended to instead use explicit conversions and/or QLatin1Char. - For instance: - - \code - - QChar c1 = 'x'; // OK, unless QT_NO_CAST_FROM_ASCII is defined - QChar c2 = u'x'; // always OK, recommended - QChar c3 = QLatin1Char('x'); // always OK, recommended - - // from int to 1 UTF-16 code unit: must guarantee that the input is <= 0xFFFF - QChar c4 = 120; // compile error, unless QT_IMPLICIT_QCHAR_CONSTRUCTION is defined - QChar c5(120); // OK (direct initialization) - auto c6 = QChar(120); // ditto - - // from int/char32_t to 1/2 UTF-16 code units: - // 𝄞 'MUSICAL SYMBOL G CLEF' (U+1D11E) - auto c7 = QChar(0x1D11E); // compiles, but undefined behavior at runtime - auto c8 = QChar::fromUcs4(0x1D11E); // always OK - auto c9 = QChar::fromUcs4(U'\U0001D11E'); // always OK - // => use c8/c9 as QStringView objects - - \endcode - - \sa QLatin1Char, QChar::fromUcs4, QT_NO_CAST_FROM_ASCII -*/ - QT_END_NAMESPACE diff --git a/src/corelib/text/qchar.h b/src/corelib/text/qchar.h index c0c53664c2..b3fd794726 100644 --- a/src/corelib/text/qchar.h +++ b/src/corelib/text/qchar.h @@ -63,17 +63,15 @@ public: }; #ifdef QT_IMPLICIT_QCHAR_CONSTRUCTION -#define QCHAR_MAYBE_IMPLICIT Q_IMPLICIT -#else -#define QCHAR_MAYBE_IMPLICIT explicit +#error This macro has been removed in Qt 6.8. #endif constexpr Q_IMPLICIT QChar() noexcept : ucs(0) {} constexpr Q_IMPLICIT QChar(ushort rc) noexcept : ucs(rc) {} - constexpr QCHAR_MAYBE_IMPLICIT QChar(uchar c, uchar r) noexcept : ucs(char16_t((r << 8) | c)) {} + constexpr explicit QChar(uchar c, uchar r) noexcept : ucs(char16_t((r << 8) | c)) {} constexpr Q_IMPLICIT QChar(short rc) noexcept : ucs(char16_t(rc)) {} - constexpr QCHAR_MAYBE_IMPLICIT QChar(uint rc) noexcept : ucs((Q_ASSERT(rc <= 0xffff), char16_t(rc))) {} - constexpr QCHAR_MAYBE_IMPLICIT QChar(int rc) noexcept : QChar(uint(rc)) {} + constexpr explicit QChar(uint rc) noexcept : ucs((Q_ASSERT(rc <= 0xffff), char16_t(rc))) {} + constexpr explicit QChar(int rc) noexcept : QChar(uint(rc)) {} constexpr Q_IMPLICIT QChar(SpecialCharacter s) noexcept : ucs(char16_t(s)) {} constexpr Q_IMPLICIT QChar(QLatin1Char ch) noexcept : ucs(ch.unicode()) {} constexpr Q_IMPLICIT QChar(char16_t ch) noexcept : ucs(ch) {} @@ -85,12 +83,10 @@ public: // Always implicit -- allow for 'x' => QChar conversions QT_ASCII_CAST_WARN constexpr Q_IMPLICIT QChar(char c) noexcept : ucs(uchar(c)) { } #ifndef QT_RESTRICTED_CAST_FROM_ASCII - QT_ASCII_CAST_WARN constexpr QCHAR_MAYBE_IMPLICIT QChar(uchar c) noexcept : ucs(c) { } + QT_ASCII_CAST_WARN constexpr explicit QChar(uchar c) noexcept : ucs(c) { } #endif #endif -#undef QCHAR_MAYBE_IMPLICIT - static constexpr QChar fromUcs2(char16_t c) noexcept { return QChar{c}; } static constexpr inline auto fromUcs4(char32_t c) noexcept; diff --git a/src/corelib/text/qlatin1stringmatcher.cpp b/src/corelib/text/qlatin1stringmatcher.cpp index 68bf97db5c..9036048fff 100644 --- a/src/corelib/text/qlatin1stringmatcher.cpp +++ b/src/corelib/text/qlatin1stringmatcher.cpp @@ -160,6 +160,31 @@ Qt::CaseSensitivity QLatin1StringMatcher::caseSensitivity() const noexcept */ qsizetype QLatin1StringMatcher::indexIn(QLatin1StringView haystack, qsizetype from) const noexcept { + return indexIn_helper(haystack, from); +} + +/*! + \since 6.8 + \overload + + Searches for the pattern in the given \a haystack starting from index + position \a from. + + \sa caseSensitivity(), pattern() +*/ +qsizetype QLatin1StringMatcher::indexIn(QStringView haystack, qsizetype from) const noexcept +{ + return indexIn_helper(haystack, from); +} + +/*! + \internal +*/ +template <typename String> +qsizetype QLatin1StringMatcher::indexIn_helper(String haystack, qsizetype from) const noexcept +{ + static_assert(QtPrivate::isLatin1OrUtf16View<String>); + if (m_pattern.isEmpty() && from == haystack.size()) return from; if (from < 0) // Historical behavior (see QString::indexOf and co.) @@ -167,8 +192,15 @@ qsizetype QLatin1StringMatcher::indexIn(QLatin1StringView haystack, qsizetype fr if (from >= haystack.size()) return -1; - auto begin = haystack.begin() + from; - auto end = haystack.end(); + const auto start = [haystack] { + if constexpr (std::is_same_v<String, QStringView>) + return haystack.utf16(); + else + return haystack.begin(); + }(); + + auto begin = start + from; + auto end = start + haystack.size(); auto found = begin; if (m_cs == Qt::CaseSensitive) { found = m_caseSensitiveSearcher(begin, end, m_pattern.begin(), m_pattern.end()).begin; @@ -178,7 +210,7 @@ qsizetype QLatin1StringMatcher::indexIn(QLatin1StringView haystack, qsizetype fr const qsizetype bufferSize = std::min(m_pattern.size(), qsizetype(sizeof m_foldBuffer)); const QLatin1StringView restNeedle = m_pattern.sliced(bufferSize); const bool needleLongerThanBuffer = restNeedle.size() > 0; - QLatin1StringView restHaystack = haystack; + String restHaystack = haystack; do { found = m_caseInsensitiveSearcher(found, end, m_foldBuffer, &m_foldBuffer[bufferSize]) .begin; @@ -189,13 +221,13 @@ qsizetype QLatin1StringMatcher::indexIn(QLatin1StringView haystack, qsizetype fr } restHaystack = haystack.sliced( qMin(haystack.size(), - bufferSize + qsizetype(std::distance(haystack.begin(), found)))); + bufferSize + qsizetype(std::distance(start, found)))); if (restHaystack.startsWith(restNeedle, Qt::CaseInsensitive)) break; ++found; } while (true); } - return std::distance(haystack.begin(), found); + return std::distance(start, found); } QT_END_NAMESPACE diff --git a/src/corelib/text/qlatin1stringmatcher.h b/src/corelib/text/qlatin1stringmatcher.h index 3b8c24fc92..dd3414fc6d 100644 --- a/src/corelib/text/qlatin1stringmatcher.h +++ b/src/corelib/text/qlatin1stringmatcher.h @@ -14,6 +14,10 @@ QT_BEGIN_NAMESPACE namespace QtPrivate { +template <typename T> +constexpr inline bool isLatin1OrUtf16View = + std::disjunction_v<std::is_same<T, QLatin1StringView>, std::is_same<T, QStringView>>; + template<class RandomIt1, class Hash = std::hash<typename std::iterator_traits<RandomIt1>::value_type>, class BinaryPredicate = std::equal_to<>> @@ -147,6 +151,7 @@ public: Q_CORE_EXPORT Qt::CaseSensitivity caseSensitivity() const noexcept; Q_CORE_EXPORT qsizetype indexIn(QLatin1StringView haystack, qsizetype from = 0) const noexcept; + Q_CORE_EXPORT qsizetype indexIn(QStringView haystack, qsizetype from = 0) const noexcept; private: void setSearcher() noexcept; @@ -164,6 +169,10 @@ private: CaseSensitiveSearcher m_caseSensitiveSearcher; CaseInsensitiveSearcher m_caseInsensitiveSearcher; }; + + template <typename String> + qsizetype indexIn_helper(String haystack, qsizetype from) const noexcept; + char m_foldBuffer[256]; }; diff --git a/src/corelib/text/qlocale.cpp b/src/corelib/text/qlocale.cpp index ab95b300eb..86ab072b73 100644 --- a/src/corelib/text/qlocale.cpp +++ b/src/corelib/text/qlocale.cpp @@ -4760,6 +4760,11 @@ QStringList QLocale::uiLanguages(TagSeparator separator) const const bool isSystem = d->m_data == &systemLocaleData; if (isSystem) { uiLanguages = systemLocale()->query(QSystemLocale::UILanguages).toStringList(); + if (separator != TagSeparator::Dash) { + // Map from default separator, Dash, used by backends: + const QChar join = QLatin1Char(sep); + uiLanguages = uiLanguages.replaceInStrings(u"-", QStringView(&join, 1)); + } // ... but we need to include likely-adjusted forms of each of those, too. // For now, collect up locale Ids representing the entries, for later processing: for (const auto &entry : std::as_const(uiLanguages)) diff --git a/src/corelib/text/qlocale.h b/src/corelib/text/qlocale.h index cb3eb64193..abef24ea0e 100644 --- a/src/corelib/text/qlocale.h +++ b/src/corelib/text/qlocale.h @@ -1173,8 +1173,11 @@ private: friend class QRomanCalendar; friend Q_CORE_EXPORT size_t qHash(const QLocale &key, size_t seed) noexcept; - friend bool operator==(const QLocale &lhs, const QLocale &rhs) { return lhs.equals(rhs); } - friend bool operator!=(const QLocale &lhs, const QLocale &rhs) { return !lhs.equals(rhs); } + friend bool comparesEqual(const QLocale &lhs, const QLocale &rhs) noexcept + { + return lhs.equals(rhs); + } + Q_DECLARE_EQUALITY_COMPARABLE(QLocale) QSharedDataPointer<QLocalePrivate> d; }; diff --git a/src/corelib/text/qlocale.qdoc b/src/corelib/text/qlocale.qdoc index f3f0a5cc2d..0cdacfd8e5 100644 --- a/src/corelib/text/qlocale.qdoc +++ b/src/corelib/text/qlocale.qdoc @@ -7,6 +7,7 @@ \brief The QLocale class converts between numbers and their string representations in various languages. + \compares equality \reentrant \ingroup i18n \ingroup string-processing diff --git a/src/corelib/text/qlocale_tools.cpp b/src/corelib/text/qlocale_tools.cpp index b6639bcb71..6b04bc92cd 100644 --- a/src/corelib/text/qlocale_tools.cpp +++ b/src/corelib/text/qlocale_tools.cpp @@ -552,6 +552,18 @@ QString qulltoa(qulonglong number, int base, const QStringView zero) return QString(reinterpret_cast<QChar *>(p), end - p); } +char *qulltoa2(char *p, qulonglong n, int base) +{ +#if defined(QT_CHECK_RANGE) + if (base < 2 || base > 36) { + qWarning("QByteArray::setNum: Invalid base %d", base); + base = 10; + } +#endif + qulltoString_helper(n, base, p); + return p; +} + /*! \internal @@ -795,4 +807,79 @@ QByteArray qdtoAscii(double d, QLocaleData::DoubleForm form, int precision, bool return dtoString<QByteArray>(d, form, precision, uppercase); } +#if defined(QT_SUPPORTS_INT128) || defined(QT_USE_MSVC_INT128) +static inline quint64 toUInt64(qinternaluint128 v) +{ +#if defined(QT_USE_MSVC_INT128) + return quint64(v._Word[0]); +#else + return quint64(v); +#endif +} + +QString quint128toBasicLatin(qinternaluint128 number, int base) +{ + // We divide our 128-bit number into parts that we can do text + // concatenation with. This list is the maximum power of the + // base that is less than 2^64. + static constexpr auto dividers = []() constexpr { + std::array<quint64, 35> bases {}; + for (int base = 2; base <= 36; ++base) { + quint64 v = base; + while (v * base > v) + v *= base; + bases[base - 2] = v; + } + return bases; + }(); + static constexpr auto digitCounts = []() constexpr { + std::array<quint8, 35> digits{}; + for (int base = 2; base <= 36; ++base) { + quint64 v = base; + int i = 0; + for (i = 0; v * base > v; ++i) + v *= base; + digits[base - 2] = i; + } + return digits; + }(); + + QString result; + + constexpr unsigned flags = QLocaleData::NoFlags; + const QLocaleData *dd = QLocaleData::c(); + + // special base cases: + constexpr int Width = -1; + if (base == 2 || base == 4 || base == 16) { + // 2^64 is a power of 2, 4 and 16 + result = dd->unsLongLongToString(quint64(number), 64, base, Width, flags); + result.prepend(dd->unsLongLongToString(quint64(number >> 64), -1, base, Width, flags)); + } else { + int digitCount = digitCounts[base - 2]; + quint64 divider = dividers[base - 2]; + quint64 lower = toUInt64(number % divider); + number /= divider; + while (number) { + result.prepend(dd->unsLongLongToString(lower, digitCount, base, Width, flags)); + lower = toUInt64(number % divider); + number /= divider; + } + result.prepend(dd->unsLongLongToString(lower, -1, base, Width, flags)); + } + return result; +} + +QString qint128toBasicLatin(qinternalint128 number, int base) +{ + const bool negative = number < 0; + if (negative) + number *= -1; + QString result = quint128toBasicLatin(qinternaluint128(number), base); + if (negative) + result.prepend(u'-'); + return result; +} +#endif // defined(QT_SUPPORTS_INT128) || defined(QT_USE_MSVC_INT128) + QT_END_NAMESPACE diff --git a/src/corelib/text/qlocale_tools_p.h b/src/corelib/text/qlocale_tools_p.h index 9b02403ea4..2cfe25d299 100644 --- a/src/corelib/text/qlocale_tools_p.h +++ b/src/corelib/text/qlocale_tools_p.h @@ -18,8 +18,21 @@ #include "qlocale_p.h" #include "qstring.h" +#if !defined(QT_SUPPORTS_INT128) && (defined(Q_CC_MSVC) && (_MSC_VER >= 1930) && __has_include(<__msvc_int128.hpp>)) +#include <__msvc_int128.hpp> +#define QT_USE_MSVC_INT128 +#endif + QT_BEGIN_NAMESPACE +#if defined(QT_SUPPORTS_INT128) +using qinternalint128 = qint128; +using qinternaluint128 = quint128; +#elif defined(QT_USE_MSVC_INT128) +using qinternalint128 = std::_Signed128; +using qinternaluint128 = std::_Unsigned128; +#endif + enum StrayCharacterMode { TrailingJunkProhibited, TrailingJunkAllowed, @@ -36,12 +49,20 @@ void qt_doubleToAscii(double d, QLocaleData::DoubleForm form, int precision, [[nodiscard]] QString qulltoBasicLatin(qulonglong l, int base, bool negative); [[nodiscard]] QString qulltoa(qulonglong l, int base, const QStringView zero); +[[nodiscard]] char *qulltoa2(char *p, qulonglong n, int base); [[nodiscard]] Q_CORE_EXPORT QString qdtoa(qreal d, int *decpt, int *sign); [[nodiscard]] QString qdtoBasicLatin(double d, QLocaleData::DoubleForm form, int precision, bool uppercase); [[nodiscard]] QByteArray qdtoAscii(double d, QLocaleData::DoubleForm form, int precision, bool uppercase); +#if defined(QT_SUPPORTS_INT128) || defined(QT_USE_MSVC_INT128) +[[nodiscard]] Q_CORE_EXPORT QString quint128toBasicLatin(qinternaluint128 number, + int base = 10); +[[nodiscard]] Q_CORE_EXPORT QString qint128toBasicLatin(qinternalint128 number, + int base = 10); +#endif + [[nodiscard]] constexpr inline bool isZero(double d) { return d == 0; // Amusingly, compilers do not grumble. diff --git a/src/corelib/text/qregularexpression.cpp b/src/corelib/text/qregularexpression.cpp index 67c422568b..78261e14cb 100644 --- a/src/corelib/text/qregularexpression.cpp +++ b/src/corelib/text/qregularexpression.cpp @@ -42,6 +42,7 @@ using namespace Qt::StringLiterals; \keyword regular expression + \compares equality Regular expressions, or \e{regexps}, are a very powerful tool to handle strings and texts. This is useful in many contexts, e.g., @@ -1734,18 +1735,20 @@ void QRegularExpression::optimize() const } /*! - Returns \c true if the regular expression is equal to \a re, or false + \fn bool QRegularExpression::operator==(const QRegularExpression &lhs, const QRegularExpression &rhs) noexcept + + Returns \c true if the \a lhs regular expression is equal to the \a rhs, or false otherwise. Two QRegularExpression objects are equal if they have the same pattern string and the same pattern options. \sa operator!=() */ -bool QRegularExpression::operator==(const QRegularExpression &re) const +bool comparesEqual(const QRegularExpression &lhs, + const QRegularExpression &rhs) noexcept { - return (d == re.d) || - (d->pattern == re.d->pattern && d->patternOptions == re.d->patternOptions); + return (lhs.d == rhs.d) || + (lhs.d->pattern == rhs.d->pattern && lhs.d->patternOptions == rhs.d->patternOptions); } - /*! \fn QRegularExpression & QRegularExpression::operator=(QRegularExpression && re) @@ -1758,9 +1761,9 @@ bool QRegularExpression::operator==(const QRegularExpression &re) const */ /*! - \fn bool QRegularExpression::operator!=(const QRegularExpression &re) const + \fn bool QRegularExpression::operator!=(const QRegularExpression &lhs, const QRegularExpression &rhs) noexcept - Returns \c true if the regular expression is different from \a re, or + Returns \c true if the \a lhs regular expression is different from the \a rhs, or false otherwise. \sa operator==() diff --git a/src/corelib/text/qregularexpression.h b/src/corelib/text/qregularexpression.h index 2b51b94b15..ab147b87d4 100644 --- a/src/corelib/text/qregularexpression.h +++ b/src/corelib/text/qregularexpression.h @@ -157,11 +157,15 @@ public: static QRegularExpression fromWildcard(QStringView pattern, Qt::CaseSensitivity cs = Qt::CaseInsensitive, WildcardConversionOptions options = DefaultWildcardConversion); - +#if QT_CORE_REMOVED_SINCE(6, 8) bool operator==(const QRegularExpression &re) const; inline bool operator!=(const QRegularExpression &re) const { return !operator==(re); } - +#endif private: + friend Q_CORE_EXPORT bool comparesEqual(const QRegularExpression &lhs, + const QRegularExpression &rhs) noexcept; + Q_DECLARE_EQUALITY_COMPARABLE(QRegularExpression) + friend struct QRegularExpressionPrivate; friend class QRegularExpressionMatch; friend struct QRegularExpressionMatchPrivate; @@ -365,30 +369,24 @@ private: // [input.iterators] imposes operator== on us. Unfortunately, it's not // trivial to implement, so just do the bare minimum to satifisfy // Cpp17EqualityComparable. - friend bool operator==(const QRegularExpressionMatchIteratorRangeBasedForIterator &lhs, - const QRegularExpressionMatchIteratorRangeBasedForIterator &rhs) noexcept + friend bool comparesEqual(const QRegularExpressionMatchIteratorRangeBasedForIterator &lhs, + const QRegularExpressionMatchIteratorRangeBasedForIterator &rhs) + noexcept { return (&lhs == &rhs); } - - friend bool operator!=(const QRegularExpressionMatchIteratorRangeBasedForIterator &lhs, - const QRegularExpressionMatchIteratorRangeBasedForIterator &rhs) noexcept - { - return !(lhs == rhs); - } + Q_DECLARE_EQUALITY_COMPARABLE(QRegularExpressionMatchIteratorRangeBasedForIterator) // This is what we really use in a range-based for. - friend bool operator==(const QRegularExpressionMatchIteratorRangeBasedForIterator &lhs, - QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel) noexcept + friend bool comparesEqual(const QRegularExpressionMatchIteratorRangeBasedForIterator &lhs, + const QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel &rhs) + noexcept { + Q_UNUSED(rhs); return lhs.m_atEnd; } - - friend bool operator!=(const QRegularExpressionMatchIteratorRangeBasedForIterator &lhs, - QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel) noexcept - { - return !lhs.m_atEnd; - } + Q_DECLARE_EQUALITY_COMPARABLE(QRegularExpressionMatchIteratorRangeBasedForIterator, + QRegularExpressionMatchIteratorRangeBasedForIteratorSentinel) QRegularExpressionMatchIterator m_matchIterator; QRegularExpressionMatch m_currentMatch; diff --git a/src/corelib/text/qstaticlatin1stringmatcher.h b/src/corelib/text/qstaticlatin1stringmatcher.h index d80ebd8547..bd6d9db08b 100644 --- a/src/corelib/text/qstaticlatin1stringmatcher.h +++ b/src/corelib/text/qstaticlatin1stringmatcher.h @@ -109,13 +109,30 @@ public: } constexpr qsizetype indexIn(QLatin1StringView haystack, qsizetype from = 0) const noexcept + { return indexIn_helper(haystack, from); } + + constexpr qsizetype indexIn(QStringView haystack, qsizetype from = 0) const noexcept + { return indexIn_helper(haystack, from); } + +private: + template <typename String> + constexpr qsizetype indexIn_helper(String haystack, qsizetype from = 0) const noexcept { + static_assert(QtPrivate::isLatin1OrUtf16View<String>); + if (from >= haystack.size()) return -1; - const char *begin = haystack.begin() + from; - const char *end = haystack.end(); + + const auto start = [haystack]() constexpr { + if constexpr (std::is_same_v<String, QStringView>) + return haystack.utf16(); + else + return haystack.begin(); + }(); + const auto begin = start + from; + const auto end = start + haystack.size(); const auto r = m_searcher(begin, end, m_pattern.begin(), m_pattern.end()); - return r.begin == end ? -1 : std::distance(haystack.begin(), r.begin); + return r.begin == end ? -1 : std::distance(start, r.begin); } }; diff --git a/src/corelib/text/qstaticlatin1stringmatcher.qdoc b/src/corelib/text/qstaticlatin1stringmatcher.qdoc index 6577f985b2..86edf69bc2 100644 --- a/src/corelib/text/qstaticlatin1stringmatcher.qdoc +++ b/src/corelib/text/qstaticlatin1stringmatcher.qdoc @@ -44,6 +44,7 @@ /*! \fn template<Qt::CaseSensitivity CS, size_t N> constexpr qsizetype QStaticLatin1StringMatcher<CS, N>::indexIn(QLatin1StringView haystack, qsizetype from) const + \fn template<Qt::CaseSensitivity CS, size_t N> constexpr qsizetype QStaticLatin1StringMatcher<CS, N>::indexIn(QStringView haystack, qsizetype from) const Searches the QLatin1StringView \a haystack, from byte position \a from (default 0, i.e. from the first byte), for QLatin1StringView pattern() diff --git a/src/corelib/text/qstring.cpp b/src/corelib/text/qstring.cpp index f0bf0c50a3..8adbfe3cbb 100644 --- a/src/corelib/text/qstring.cpp +++ b/src/corelib/text/qstring.cpp @@ -63,8 +63,8 @@ #endif #define REHASH(a) \ - if (sl_minus_1 < sizeof(std::size_t) * CHAR_BIT) \ - hashHaystack -= std::size_t(a) << sl_minus_1; \ + if (sl_minus_1 < sizeof(sl_minus_1) * CHAR_BIT) \ + hashHaystack -= decltype(hashHaystack)(a) << sl_minus_1; \ hashHaystack <<= 1 QT_BEGIN_NAMESPACE @@ -183,10 +183,10 @@ static qsizetype qLastIndexOf(Haystack haystack0, qsizetype from, const auto needle = needle0.data(); const auto *end = haystack; haystack += from; - const std::size_t sl_minus_1 = sl ? sl - 1 : 0; + const qregisteruint sl_minus_1 = sl ? sl - 1 : 0; const auto *n = needle + sl_minus_1; const auto *h = haystack + sl_minus_1; - std::size_t hashNeedle = 0, hashHaystack = 0; + qregisteruint hashNeedle = 0, hashHaystack = 0; if (cs == Qt::CaseSensitive) { for (qsizetype idx = 0; idx < sl; ++idx) { @@ -1543,6 +1543,8 @@ int QtPrivate::compareStrings(QLatin1StringView lhs, QLatin1StringView rhs, Qt:: { if (lhs.isEmpty()) return qt_lencmp(qsizetype(0), rhs.size()); + if (rhs.isEmpty()) + return qt_lencmp(lhs.size(), qsizetype(0)); if (cs == Qt::CaseInsensitive) return latin1nicmp(lhs.data(), lhs.size(), rhs.data(), rhs.size()); const auto l = std::min(lhs.size(), rhs.size()); @@ -9140,18 +9142,13 @@ namespace { struct Part { Part() = default; // for QVarLengthArray; do not use - constexpr Part(QStringView s, int num = -1) - : tag{QtPrivate::ArgBase::U16}, number{num}, data{s.utf16()}, size{s.size()} {} - constexpr Part(QLatin1StringView s, int num = -1) - : tag{QtPrivate::ArgBase::L1}, number{num}, data{s.data()}, size{s.size()} {} + constexpr Part(QAnyStringView s, int num = -1) + : string{s}, number{num} {} - void reset(QStringView s) noexcept { *this = {s, number}; } - void reset(QLatin1StringView s) noexcept { *this = {s, number}; } + void reset(QAnyStringView s) noexcept { *this = {s, number}; } - QtPrivate::ArgBase::Tag tag; + QAnyStringView string; int number; - const void *data; - qsizetype size; }; } // unnamed namespace @@ -9234,16 +9231,13 @@ static qsizetype resolveStringRefsAndReturnTotalSize(ParseResult &parts, const A } } } - totalSize += part.size; + totalSize += part.string.size(); } return totalSize; } } // unnamed namespace -Q_ALWAYS_INLINE QString to_string(QLatin1StringView s) noexcept { return s; } -Q_ALWAYS_INLINE QString to_string(QStringView s) noexcept { return s.toString(); } - template <typename StringView> static QString argToQStringImpl(StringView pattern, size_t numArgs, const QtPrivate::ArgBase **args) { @@ -9257,7 +9251,7 @@ static QString argToQStringImpl(StringView pattern, size_t numArgs, const QtPriv argIndexToPlaceholderMap.resize(qsizetype(numArgs)); else if (Q_UNLIKELY(static_cast<size_t>(argIndexToPlaceholderMap.size()) < numArgs)) // 3b qWarning("QString::arg: %d argument(s) missing in %ls", - int(numArgs - argIndexToPlaceholderMap.size()), qUtf16Printable(to_string(pattern))); + int(numArgs - argIndexToPlaceholderMap.size()), qUtf16Printable(pattern.toString())); // 5 const qsizetype totalSize = resolveStringRefsAndReturnTotalSize(parts, argIndexToPlaceholderMap, args); @@ -9266,24 +9260,33 @@ static QString argToQStringImpl(StringView pattern, size_t numArgs, const QtPriv QString result(totalSize, Qt::Uninitialized); auto out = const_cast<QChar*>(result.constData()); - for (const Part &part : parts) { - switch (part.tag) { - case QtPrivate::ArgBase::L1: - if (part.size) { + struct Concatenate { + QChar *out; + QChar *operator()(QLatin1String part) noexcept + { + if (part.size()) { qt_from_latin1(reinterpret_cast<char16_t*>(out), - reinterpret_cast<const char*>(part.data), part.size); + part.data(), part.size()); } - break; - case QtPrivate::ArgBase::U8: - Q_UNREACHABLE(); // waiting for QUtf8String - break; - case QtPrivate::ArgBase::U16: - if (part.size) - memcpy(out, part.data, part.size * sizeof(QChar)); - break; + return out + part.size(); } - out += part.size; - } + QChar *operator()(QUtf8StringView part) noexcept + { + return QUtf8::convertToUnicode(out, part); + } + QChar *operator()(QStringView part) noexcept + { + if (part.size()) + memcpy(out, part.data(), part.size() * sizeof(QChar)); + return out + part.size(); + } + }; + + for (const Part &part : parts) + out = part.string.visit(Concatenate{out}); + + // UTF-8 decoding may have caused an overestimate of totalSize - correct it: + result.truncate(out - result.cbegin()); return result; } @@ -9905,8 +9908,8 @@ qsizetype QtPrivate::findString(QStringView haystack0, qsizetype from, QStringVi const char16_t *needle = needle0.utf16(); const char16_t *haystack = haystack0.utf16() + from; const char16_t *end = haystack0.utf16() + (l - sl); - const std::size_t sl_minus_1 = sl - 1; - std::size_t hashNeedle = 0, hashHaystack = 0; + const qregisteruint sl_minus_1 = sl - 1; + qregisteruint hashNeedle = 0, hashHaystack = 0; qsizetype idx; if (cs == Qt::CaseSensitive) { diff --git a/src/corelib/text/qstringconverter.cpp b/src/corelib/text/qstringconverter.cpp index 67c75d708e..a960899e59 100644 --- a/src/corelib/text/qstringconverter.cpp +++ b/src/corelib/text/qstringconverter.cpp @@ -2247,7 +2247,7 @@ std::optional<QStringConverter::Encoding> QStringConverter::encodingForName(cons if (nameMatch(encodingInterfaces[i].name, name)) return QStringConverter::Encoding(i); } - if (nameMatch(name, "latin1")) + if (nameMatch("latin1", name)) return QStringConverter::Latin1; return std::nullopt; } diff --git a/src/corelib/text/qstringconverter_p.h b/src/corelib/text/qstringconverter_p.h index e68ffb2bb0..5c530cf1bd 100644 --- a/src/corelib/text/qstringconverter_p.h +++ b/src/corelib/text/qstringconverter_p.h @@ -52,6 +52,7 @@ struct QLatin1 static char *convertFromUnicode(char *out, QStringView in, QStringConverter::State *state) noexcept; // Defined in qstring.cpp + Q_CORE_EXPORT static char *convertFromUnicode(char *out, QStringView in) noexcept; }; diff --git a/src/corelib/thread/qfuture.h b/src/corelib/thread/qfuture.h index 5939a93780..3945df066a 100644 --- a/src/corelib/thread/qfuture.h +++ b/src/corelib/thread/qfuture.h @@ -183,8 +183,6 @@ QT_WARNING_POP { future = o.future; index = o.index; return *this; } inline const T &operator*() const { return future->d.resultReference(index); } inline const T *operator->() const { return future->d.resultPointer(index); } - inline bool operator!=(const const_iterator &other) const { return index != other.index; } - inline bool operator==(const const_iterator &o) const { return !operator!=(o); } inline const_iterator &operator++() { index = advanceIndex(index, 1); return *this; } inline const_iterator &operator--() @@ -213,6 +211,12 @@ QT_WARNING_POP { return const_iterator(k.future, k.advanceIndex(k.index, j)); } private: + friend bool comparesEqual(const const_iterator &lhs, const const_iterator &rhs) noexcept + { + return lhs.index == rhs.index; + } + Q_DECLARE_EQUALITY_COMPARABLE(const_iterator) + /*! \internal Advances the iterator index \a idx \a n steps, waits for the diff --git a/src/corelib/thread/qfuture.qdoc b/src/corelib/thread/qfuture.qdoc index 9eda766968..b278d39882 100644 --- a/src/corelib/thread/qfuture.qdoc +++ b/src/corelib/thread/qfuture.qdoc @@ -613,17 +613,17 @@ Returns a pointer to the current result. */ -/*! \fn template <typename T> bool QFuture<T>::const_iterator::operator!=(const const_iterator &other) const +/*! \fn template <typename T> bool QFuture<T>::const_iterator::operator!=(const const_iterator &lhs, const const_iterator &rhs) - Returns \c true if \a other points to a different result than this iterator; + Returns \c true if \a lhs points to a different result than \a rhs iterator; otherwise returns \c false. \sa operator==() */ -/*! \fn template <typename T> bool QFuture<T>::const_iterator::operator==(const const_iterator &other) const +/*! \fn template <typename T> bool QFuture<T>::const_iterator::operator==(const const_iterator &lhs, const const_iterator &rhs) - Returns \c true if \a other points to the same result as this iterator; + Returns \c true if \a lhs points to the same result as \a rhs iterator; otherwise returns \c false. \sa operator!=() diff --git a/src/corelib/thread/qfuture_impl.h b/src/corelib/thread/qfuture_impl.h index 79fc6d9a01..351093adc7 100644 --- a/src/corelib/thread/qfuture_impl.h +++ b/src/corelib/thread/qfuture_impl.h @@ -287,6 +287,7 @@ using IsForwardIterable = template<typename Function, typename ResultType, typename ParentResultType> class Continuation { + Q_DISABLE_COPY_MOVE(Continuation) public: template<typename F = Function> Continuation(F &&func, const QFuture<ParentResultType> &f, QPromise<ResultType> &&p) @@ -588,9 +589,6 @@ void Continuation<Function, ResultType, ParentResultType>::create(F &&func, f->d.setContinuation(ContinuationWrapper(std::move(continuation)), fi.d); } -// defined in qfutureinterface.cpp: -Q_CORE_EXPORT void watchContinuationImpl(const QObject *context, QSlotObjectBase *slotObj, - QFutureInterfaceBase &fi); template <typename Continuation> void watchContinuation(const QObject *context, Continuation &&c, QFutureInterfaceBase &fi) { diff --git a/src/corelib/thread/qfutureinterface.h b/src/corelib/thread/qfutureinterface.h index 180a59a94e..ea7d40ad90 100644 --- a/src/corelib/thread/qfutureinterface.h +++ b/src/corelib/thread/qfutureinterface.h @@ -465,6 +465,9 @@ std::vector<T> QFutureInterface<T>::takeResults() } #endif +QT_WARNING_PUSH +QT_WARNING_DISABLE_CLANG("-Wweak-vtables") // QTBUG-125115 + template <> class QFutureInterface<void> : public QFutureInterfaceBase { @@ -495,6 +498,8 @@ public: } }; +QT_WARNING_POP // Clang -Wweak-vtables + template<typename T> inline void swap(QFutureInterface<T> &a, QFutureInterface<T> &b) noexcept { diff --git a/src/corelib/thread/qresultstore.cpp b/src/corelib/thread/qresultstore.cpp index 14ed7c6b87..8b7601f5b0 100644 --- a/src/corelib/thread/qresultstore.cpp +++ b/src/corelib/thread/qresultstore.cpp @@ -88,16 +88,6 @@ void ResultIteratorBase::batchedAdvance() m_vectorIndex = 0; } -bool ResultIteratorBase::operator==(const ResultIteratorBase &other) const -{ - return (mapIterator == other.mapIterator && m_vectorIndex == other.m_vectorIndex); -} - -bool ResultIteratorBase::operator!=(const ResultIteratorBase &other) const -{ - return !operator==(other); -} - bool ResultIteratorBase::isVector() const { return mapIterator.value().isVector(); diff --git a/src/corelib/thread/qresultstore.h b/src/corelib/thread/qresultstore.h index 30ce1fe904..f21068206f 100644 --- a/src/corelib/thread/qresultstore.h +++ b/src/corelib/thread/qresultstore.h @@ -46,12 +46,21 @@ public: ResultIteratorBase operator++(); int batchSize() const; void batchedAdvance(); +#if QT_CORE_REMOVED_SINCE(6, 8) bool operator==(const ResultIteratorBase &other) const; bool operator!=(const ResultIteratorBase &other) const; +#endif bool isVector() const; bool canIncrementVectorIndex() const; bool isValid() const; +private: + friend bool comparesEqual(const ResultIteratorBase &lhs, + const ResultIteratorBase &rhs) noexcept + { + return (lhs.mapIterator == rhs.mapIterator && lhs.m_vectorIndex == rhs.m_vectorIndex); + } + Q_DECLARE_EQUALITY_COMPARABLE(ResultIteratorBase) protected: QMap<int, ResultItem>::const_iterator mapIterator; int m_vectorIndex; diff --git a/src/corelib/thread/qthread.cpp b/src/corelib/thread/qthread.cpp index 8d8f353aaa..ea76a2ccad 100644 --- a/src/corelib/thread/qthread.cpp +++ b/src/corelib/thread/qthread.cpp @@ -531,10 +531,18 @@ bool QThread::isRunning() const } /*! - Sets the maximum stack size for the thread to \a stackSize. If \a - stackSize is greater than zero, the maximum stack size is set to - \a stackSize bytes, otherwise the maximum stack size is - automatically determined by the operating system. + Sets the stack size for the thread to \a stackSize. If \a stackSize is + zero, the operating system or runtime will choose a default value. + Otherwise, the thread's stack size will be the value provided (which may be + rounded up or down). + + On most operating systems, the amount of memory allocated to serve the + stack will initially be smaller than \a stackSize and will grow as the + thread uses the stack. This parameter sets the maximum size it will be + allowed to grow to (that is, it sets the size of the virtual memory space + the stack is allowed to occupy). + + This function can only be called before the thread is started. \warning Most operating systems place minimum and maximum limits on thread stack sizes. The thread will fail to start if the stack diff --git a/src/corelib/thread/qthread_unix.cpp b/src/corelib/thread/qthread_unix.cpp index 23a79074d6..44487a2cc2 100644 --- a/src/corelib/thread/qthread_unix.cpp +++ b/src/corelib/thread/qthread_unix.cpp @@ -282,8 +282,16 @@ void *QThreadPrivate::start(void *arg) #ifdef PTHREAD_CANCEL_DISABLE pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, nullptr); #endif - pthread_cleanup_push(QThreadPrivate::finish, arg); - +#if !defined(Q_OS_QNX) && !defined(Q_OS_VXWORKS) + // On QNX, calling finish() from a thread_local destructor causes the C + // library to hang. + // On VxWorks, its pthread implementation fails on call to `pthead_setspecific` which is made + // by first QObject constructor during `finish()`. This causes call to QThread::current, since + // QObject doesn't have parent, and since the pthread is already removed, it tries to set + // QThreadData for current pthread key, which crashes. + static thread_local +#endif + auto cleanup = qScopeGuard([=] { finish(arg); }); terminate_on_exception([&] { QThread *thr = reinterpret_cast<QThread *>(arg); QThreadData *data = QThreadData::get2(thr); @@ -328,11 +336,7 @@ void *QThreadPrivate::start(void *arg) thr->run(); }); - // This pop runs finish() below. It's outside the try/catch (and has its - // own try/catch) to prevent finish() to be run in case an exception is - // thrown. - pthread_cleanup_pop(1); - + // The qScopeGuard above call runs finish() below. return nullptr; } @@ -365,7 +369,7 @@ void QThreadPrivate::finish(void *arg) d->running = false; d->finished = true; - d->interruptionRequested = false; + d->interruptionRequested.store(false, std::memory_order_relaxed); d->isInFinish = false; d->data->threadId.storeRelaxed(nullptr); @@ -642,7 +646,7 @@ void QThread::start(Priority priority) d->finished = false; d->returnCode = 0; d->exited = false; - d->interruptionRequested = false; + d->interruptionRequested.store(false, std::memory_order_relaxed); pthread_attr_t attr; pthread_attr_init(&attr); diff --git a/src/corelib/thread/qthread_win.cpp b/src/corelib/thread/qthread_win.cpp index 3e0eef411a..74bc1d2650 100644 --- a/src/corelib/thread/qthread_win.cpp +++ b/src/corelib/thread/qthread_win.cpp @@ -314,7 +314,7 @@ void QThreadPrivate::finish(void *arg, bool lockAnyway) noexcept d->running = false; d->finished = true; d->isInFinish = false; - d->interruptionRequested = false; + d->interruptionRequested.store(false, std::memory_order_relaxed); if (!d->waiters) { CloseHandle(d->handle); @@ -391,7 +391,7 @@ void QThread::start(Priority priority) d->finished = false; d->exited = false; d->returnCode = 0; - d->interruptionRequested = false; + d->interruptionRequested.store(false, std::memory_order_relaxed); /* NOTE: we create the thread in the suspended state, set the diff --git a/src/corelib/thread/qthreadpool.cpp b/src/corelib/thread/qthreadpool.cpp index ae584656fe..c7531111da 100644 --- a/src/corelib/thread/qthreadpool.cpp +++ b/src/corelib/thread/qthreadpool.cpp @@ -258,7 +258,7 @@ void QThreadPoolPrivate::startThread(QRunnable *runnable) /*! \internal - Helper function only to be called from waitForDone(int) + Helper function only to be called from waitForDone() Deletes all current threads. */ @@ -285,22 +285,17 @@ void QThreadPoolPrivate::reset() /*! \internal - Helper function only to be called from waitForDone(int) + Helper function only to be called from the public waitForDone() */ bool QThreadPoolPrivate::waitForDone(const QDeadlineTimer &timer) { + QMutexLocker locker(&mutex); while (!(queue.isEmpty() && activeThreads == 0) && !timer.hasExpired()) noActiveThreads.wait(&mutex, timer); - return queue.isEmpty() && activeThreads == 0; -} - -bool QThreadPoolPrivate::waitForDone(int msecs) -{ - QMutexLocker locker(&mutex); - QDeadlineTimer timer(msecs); - if (!waitForDone(timer)) + if (!queue.isEmpty() || activeThreads) return false; + reset(); // New jobs might have started during reset, but return anyway // as the active thread and task count did reach 0 once, and @@ -598,18 +593,17 @@ bool QThreadPool::tryStart(QRunnable *runnable) int QThreadPool::expiryTimeout() const { + using namespace std::chrono; Q_D(const QThreadPool); QMutexLocker locker(&d->mutex); - return d->expiryTimeout; + return duration_cast<milliseconds>(d->expiryTimeout).count(); } void QThreadPool::setExpiryTimeout(int expiryTimeout) { Q_D(QThreadPool); QMutexLocker locker(&d->mutex); - if (d->expiryTimeout == expiryTimeout) - return; - d->expiryTimeout = expiryTimeout; + d->expiryTimeout = std::chrono::milliseconds(expiryTimeout); } /*! \property QThreadPool::maxThreadCount @@ -808,15 +802,24 @@ void QThreadPool::startOnReservedThread(QRunnable *runnable) */ /*! + \fn bool QThreadPool::waitForDone(int msecs) Waits up to \a msecs milliseconds for all threads to exit and removes all threads from the thread pool. Returns \c true if all threads were removed; - otherwise it returns \c false. If \a msecs is -1 (the default), the timeout - is ignored (waits for the last thread to exit). + otherwise it returns \c false. If \a msecs is -1, this function waits for + the last thread to exit. +*/ + +/*! + \since 6.8 + + Waits until \a deadline expires for all threads to exit and removes all + threads from the thread pool. Returns \c true if all threads were removed; + otherwise it returns \c false. */ -bool QThreadPool::waitForDone(int msecs) +bool QThreadPool::waitForDone(QDeadlineTimer deadline) { Q_D(QThreadPool); - return d->waitForDone(msecs); + return d->waitForDone(deadline); } /*! diff --git a/src/corelib/thread/qthreadpool.h b/src/corelib/thread/qthreadpool.h index a097ace14b..0640f41587 100644 --- a/src/corelib/thread/qthreadpool.h +++ b/src/corelib/thread/qthreadpool.h @@ -9,7 +9,9 @@ #include <QtCore/qthread.h> #include <QtCore/qrunnable.h> +#if QT_CORE_REMOVED_SINCE(6, 6) #include <functional> +#endif QT_REQUIRE_CONFIG(thread); @@ -70,7 +72,9 @@ public: void reserveThread(); void releaseThread(); - bool waitForDone(int msecs = -1); + QT_CORE_INLINE_SINCE(6, 8) + bool waitForDone(int msecs); + bool waitForDone(QDeadlineTimer deadline = QDeadlineTimer::Forever); void clear(); @@ -101,6 +105,13 @@ void QThreadPool::startOnReservedThread(Callable &&functionToRun) startOnReservedThread(QRunnable::create(std::forward<Callable>(functionToRun))); } +#if QT_CORE_INLINE_IMPL_SINCE(6, 8) +bool QThreadPool::waitForDone(int msecs) +{ + return waitForDone(QDeadlineTimer(msecs)); +} +#endif + QT_END_NAMESPACE #endif diff --git a/src/corelib/thread/qthreadpool_p.h b/src/corelib/thread/qthreadpool_p.h index 67c703fabd..7910592f70 100644 --- a/src/corelib/thread/qthreadpool_p.h +++ b/src/corelib/thread/qthreadpool_p.h @@ -128,7 +128,6 @@ public: { return qMax(requestedMaxThreadCount, 1); } // documentation says we start at least one void startThread(QRunnable *runnable = nullptr); void reset(); - bool waitForDone(int msecs); bool waitForDone(const QDeadlineTimer &timer); void clear(); void stealAndRunRunnable(QRunnable *runnable); @@ -144,7 +143,7 @@ public: QWaitCondition noActiveThreads; QString objectName; - int expiryTimeout = 30000; + std::chrono::duration<int, std::milli> expiryTimeout = std::chrono::seconds(30); int requestedMaxThreadCount = QThread::idealThreadCount(); // don't use this directly int reservedThreads = 0; int activeThreads = 0; diff --git a/src/corelib/time/qdatetime.cpp b/src/corelib/time/qdatetime.cpp index 687f174c07..c3e9b49b25 100644 --- a/src/corelib/time/qdatetime.cpp +++ b/src/corelib/time/qdatetime.cpp @@ -5350,10 +5350,19 @@ QDateTime QDateTime::currentDateTimeUtc() \since 6.4 Constructs a datetime representing the same point in time as \a time, - using Qt::UTC as its specification. + using Qt::UTC as its time representation. - The clock of \a time must be compatible with \c{std::chrono::system_clock}, - and the duration type must be convertible to \c{std::chrono::milliseconds}. + The clock of \a time must be compatible with + \c{std::chrono::system_clock}; in particular, a conversion + supported by \c{std::chrono::clock_cast} must exist. After the + conversion, the duration type of the result must be convertible to + \c{std::chrono::milliseconds}. + + If this is not the case, the caller must perform the necessary + clock conversion towards \c{std::chrono::system_clock} and the + necessary conversion of the duration type + (cast/round/floor/ceil/...) so that the input to this function + satisfies the constraints above. \note This function requires C++20. @@ -5361,6 +5370,22 @@ QDateTime QDateTime::currentDateTimeUtc() */ /*! + \since 6.4 + \overload + + Constructs a datetime representing the same point in time as \a time, + using Qt::UTC as its time representation. +*/ +QDateTime QDateTime::fromStdTimePoint( + std::chrono::time_point< + std::chrono::system_clock, + std::chrono::milliseconds + > time) +{ + return fromMSecsSinceEpoch(time.time_since_epoch().count(), QTimeZone::UTC); +} + +/*! \fn QDateTime QDateTime::fromStdTimePoint(const std::chrono::local_time<std::chrono::milliseconds> &time) \since 6.4 diff --git a/src/corelib/time/qdatetime.h b/src/corelib/time/qdatetime.h index e1c0d29e2a..77247dcd07 100644 --- a/src/corelib/time/qdatetime.h +++ b/src/corelib/time/qdatetime.h @@ -35,28 +35,28 @@ public: #if __cpp_lib_chrono >= 201907L || defined(Q_QDOC) QT_POST_CXX17_API_IN_EXPORTED_CLASS Q_IMPLICIT constexpr QDate(std::chrono::year_month_day date) noexcept - : jd(date.ok() ? stdSysDaysToJulianDay(date) : nullJd()) + : jd(date.ok() ? stdSysDaysToJulianDay(date QT6_CALL_NEW_OVERLOAD_TAIL) : nullJd()) {} QT_POST_CXX17_API_IN_EXPORTED_CLASS Q_IMPLICIT constexpr QDate(std::chrono::year_month_day_last date) noexcept - : jd(date.ok() ? stdSysDaysToJulianDay(date) : nullJd()) + : jd(date.ok() ? stdSysDaysToJulianDay(date QT6_CALL_NEW_OVERLOAD_TAIL) : nullJd()) {} QT_POST_CXX17_API_IN_EXPORTED_CLASS Q_IMPLICIT constexpr QDate(std::chrono::year_month_weekday date) noexcept - : jd(date.ok() ? stdSysDaysToJulianDay(date) : nullJd()) + : jd(date.ok() ? stdSysDaysToJulianDay(date QT6_CALL_NEW_OVERLOAD_TAIL) : nullJd()) {} QT_POST_CXX17_API_IN_EXPORTED_CLASS Q_IMPLICIT constexpr QDate(std::chrono::year_month_weekday_last date) noexcept - : jd(date.ok() ? stdSysDaysToJulianDay(date) : nullJd()) + : jd(date.ok() ? stdSysDaysToJulianDay(date QT6_CALL_NEW_OVERLOAD_TAIL) : nullJd()) {} QT_POST_CXX17_API_IN_EXPORTED_CLASS static constexpr QDate fromStdSysDays(const std::chrono::sys_days &days) noexcept { - return QDate(stdSysDaysToJulianDay(days)); + return QDate(stdSysDaysToJulianDay(days QT6_CALL_NEW_OVERLOAD_TAIL)); } QT_POST_CXX17_API_IN_EXPORTED_CLASS @@ -177,7 +177,9 @@ private: static constexpr inline qint64 unixEpochJd() { return Q_INT64_C(2440588); } #if __cpp_lib_chrono >= 201907L - static constexpr qint64 stdSysDaysToJulianDay(const std::chrono::sys_days &days) noexcept + QT_POST_CXX17_API_IN_EXPORTED_CLASS + static constexpr qint64 + stdSysDaysToJulianDay(const std::chrono::sys_days &days QT6_DECL_NEW_OVERLOAD_TAIL) noexcept { const auto epochDays = days.time_since_epoch().count(); // minJd() and maxJd() fit into 40 bits. @@ -189,6 +191,13 @@ private: } return unixEpochJd() + epochDays; } + +#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0) + static constexpr qint64 stdSysDaysToJulianDay(const std::chrono::sys_days &days) noexcept + { + return stdSysDaysToJulianDay(days QT6_CALL_NEW_OVERLOAD_TAIL); + } +#endif // QT_VERSION < QT_VERSION_CHECK(7, 0, 0) #endif // __cpp_lib_chrono >= 201907L qint64 jd; @@ -499,8 +508,26 @@ public: NSDate *toNSDate() const Q_DECL_NS_RETURNS_AUTORELEASED; #endif + static QDateTime fromStdTimePoint( + std::chrono::time_point< + std::chrono::system_clock, + std::chrono::milliseconds + > time + ); + #if __cpp_lib_chrono >= 201907L || defined(Q_QDOC) #if __cpp_concepts >= 201907L || defined(Q_QDOC) +private: + // The duration type of the result of a clock_cast<system_clock>. + // This duration may differ from the duration of the input. + template <typename Clock, typename Duration> + using system_clock_cast_duration = decltype( + std::chrono::clock_cast<std::chrono::system_clock>( + std::declval<const std::chrono::time_point<Clock, Duration> &>() + ).time_since_epoch() + ); + +public: // Generic clock, as long as it's compatible with us (= system_clock) template <typename Clock, typename Duration> static QDateTime fromStdTimePoint(const std::chrono::time_point<Clock, Duration> &time) @@ -508,14 +535,17 @@ public: requires(const std::chrono::time_point<Clock, Duration> &t) { // the clock can be converted to system_clock std::chrono::clock_cast<std::chrono::system_clock>(t); - // the duration can be converted to milliseconds - requires std::is_convertible_v<Duration, std::chrono::milliseconds>; + // after the conversion to system_clock, the duration type + // we get is convertible to milliseconds + requires std::is_convertible_v< + system_clock_cast_duration<Clock, Duration>, + std::chrono::milliseconds + >; } { - const auto sysTime = std::chrono::clock_cast<std::chrono::system_clock>(time); - // clock_cast can change the duration, so convert it again to milliseconds - const auto timeInMSec = std::chrono::time_point_cast<std::chrono::milliseconds>(sysTime); - return fromMSecsSinceEpoch(timeInMSec.time_since_epoch().count(), Qt::UTC); + using namespace std::chrono; + const sys_time<milliseconds> sysTime = clock_cast<system_clock>(time); + return fromStdTimePoint(sysTime); } #endif // __cpp_concepts @@ -529,7 +559,7 @@ public: QT_POST_CXX17_API_IN_EXPORTED_CLASS static QDateTime fromStdLocalTime(const std::chrono::local_time<std::chrono::milliseconds> &time) { - QDateTime result(QDate(1970, 1, 1), QTime(0, 0, 0)); + QDateTime result(QDate(1970, 1, 1), QTime(0, 0, 0), TransitionResolution::LegacyBehavior); return result.addMSecs(time.time_since_epoch().count()); } diff --git a/src/corelib/time/qdatetimeparser.cpp b/src/corelib/time/qdatetimeparser.cpp index 78520a51aa..cce32e7ad2 100644 --- a/src/corelib/time/qdatetimeparser.cpp +++ b/src/corelib/time/qdatetimeparser.cpp @@ -334,7 +334,7 @@ int QDateTimeParser::sectionPos(int sectionIndex) const return sectionPos(sectionNode(sectionIndex)); } -int QDateTimeParser::sectionPos(const SectionNode &sn) const +int QDateTimeParser::sectionPos(SectionNode sn) const { switch (sn.type) { case FirstSection: return 0; @@ -2314,11 +2314,9 @@ QString QDateTimeParser::getAmPmText(AmPm ap, Case cs) const /* \internal - - I give arg2 preference because arg1 is always a QDateTime. */ -bool operator==(const QDateTimeParser::SectionNode &s1, const QDateTimeParser::SectionNode &s2) +bool operator==(QDateTimeParser::SectionNode s1, QDateTimeParser::SectionNode s2) { return (s1.type == s2.type) && (s1.pos == s2.pos) && (s1.count == s2.count); } diff --git a/src/corelib/time/qdatetimeparser_p.h b/src/corelib/time/qdatetimeparser_p.h index faf383f3d7..30e9e4d524 100644 --- a/src/corelib/time/qdatetimeparser_p.h +++ b/src/corelib/time/qdatetimeparser_p.h @@ -212,7 +212,7 @@ protected: // for the benefit of QDateTimeEditPrivate int sectionSize(int index) const; int sectionMaxSize(int index) const; int sectionPos(int index) const; - int sectionPos(const SectionNode &sn) const; + int sectionPos(SectionNode sn) const; const SectionNode §ionNode(int index) const; Section sectionType(int index) const; @@ -265,7 +265,7 @@ protected: // for the benefit of QDateTimeEditPrivate }; Q_DECLARE_TYPEINFO(QDateTimeParser::SectionNode, Q_PRIMITIVE_TYPE); -Q_CORE_EXPORT bool operator==(const QDateTimeParser::SectionNode &s1, const QDateTimeParser::SectionNode &s2); +Q_CORE_EXPORT bool operator==(QDateTimeParser::SectionNode s1, QDateTimeParser::SectionNode s2); Q_DECLARE_OPERATORS_FOR_FLAGS(QDateTimeParser::Sections) Q_DECLARE_OPERATORS_FOR_FLAGS(QDateTimeParser::FieldInfo) diff --git a/src/corelib/time/qtimezone.cpp b/src/corelib/time/qtimezone.cpp index 3a68277a6c..8ce967cf9f 100644 --- a/src/corelib/time/qtimezone.cpp +++ b/src/corelib/time/qtimezone.cpp @@ -455,10 +455,17 @@ QTimeZone::QTimeZone(const QByteArray &ianaId) d = new QUtcTimeZonePrivate(ianaId); // If not recognized, try creating it with the system backend. if (!d->isValid()) { - if (ianaId.isEmpty()) + if (ianaId.isEmpty()) { d = newBackendTimeZone(); - else // Constructor MUST produce invalid for unsupported ID. + } else { // Constructor MUST produce invalid for unsupported ID. d = newBackendTimeZone(ianaId); + if (!d->isValid()) { + // We may have a legacy alias for a supported IANA ID: + const QByteArray name = QTimeZonePrivate::aliasToIana(ianaId); + if (!name.isEmpty() && name != ianaId) + d = newBackendTimeZone(name); + } + } } // Can also handle UTC with arbitrary (valid) offset, but only do so as // fall-back, since either of the above may handle it more informatively. @@ -823,6 +830,34 @@ QByteArray QTimeZone::id() const } /*! + \since 6.8 + Returns \c true if \a alias is an alternative name for this timezone. + + The IANA (formerly Olson) database has renamed some zones during its + history. There are also some zones that only differed prior to 1970 but are + now treated as synonymous. Some backends may have data reaching to before + 1970 and produce distinct zones in the latter case. Others may produce zones + indistinguishable except by id(). This method determines whether an ID + refers (at least since 1970) to the same zone that this timezone object + describes. + + This method is only available when feature \c timezone is enabled. +*/ +bool QTimeZone::aliasMatches(QByteArrayView alias) const +{ + if (alias == id()) + return true; + QByteArray mine = QTimeZonePrivate::aliasToIana(id()); + // Empty if id() aliases to itself, which we've already checked: + if (!mine.isEmpty() && alias == mine) + return true; + QByteArray its = QTimeZonePrivate::aliasToIana(alias); + // Empty if alias aliases to itself, which we've already compared to id() + // and, where relevant, mine. + return !its.isEmpty() && its == (mine.isEmpty() ? id() : mine); +} + +/*! \since 6.2 Returns the territory for the time zone. diff --git a/src/corelib/time/qtimezone.h b/src/corelib/time/qtimezone.h index 46c7d6312b..6c490c4e25 100644 --- a/src/corelib/time/qtimezone.h +++ b/src/corelib/time/qtimezone.h @@ -166,6 +166,7 @@ public: }; typedef QList<OffsetData> OffsetDataList; + bool aliasMatches(QByteArrayView alias) const; QByteArray id() const; QLocale::Territory territory() const; # if QT_DEPRECATED_SINCE(6, 6) diff --git a/src/corelib/time/qtimezonelocale.cpp b/src/corelib/time/qtimezonelocale.cpp index 5757e55d28..cf3a84b317 100644 --- a/src/corelib/time/qtimezonelocale.cpp +++ b/src/corelib/time/qtimezonelocale.cpp @@ -4,7 +4,9 @@ #include <private/qtimezonelocale_p.h> #include <private/qtimezoneprivate_p.h> -#if !QT_CONFIG(icu) // Use data generated from CLDR: +#if !QT_CONFIG(icu) +# include <private/qdatetime_p.h> +// Use data generated from CLDR: # include <private/qtimezonelocale_data_p.h> # include <private/qtimezoneprivate_data_p.h> #endif @@ -12,9 +14,90 @@ QT_BEGIN_NAMESPACE #if QT_CONFIG(icu) // Get data from ICU: +namespace { + +// Convert TimeType and NameType into ICU UCalendarDisplayNameType +constexpr UCalendarDisplayNameType ucalDisplayNameType(QTimeZone::TimeType timeType, + QTimeZone::NameType nameType) +{ + // TODO ICU C UCalendarDisplayNameType does not support full set of C++ TimeZone::EDisplayType + // For now, treat Generic as Standard + switch (nameType) { + case QTimeZone::OffsetName: + Q_UNREACHABLE(); // Callers of ucalTimeZoneDisplayName() should take care of OffsetName. + case QTimeZone::ShortName: + return timeType == QTimeZone::DaylightTime ? UCAL_SHORT_DST : UCAL_SHORT_STANDARD; + case QTimeZone::DefaultName: + case QTimeZone::LongName: + return timeType == QTimeZone::DaylightTime ? UCAL_DST : UCAL_STANDARD; + } + Q_UNREACHABLE_RETURN(UCAL_STANDARD); +} + +} // nameless namespace + namespace QtTimeZoneLocale { +// Qt wrapper around ucal_getTimeZoneDisplayName() +// Used directly by ICU backend; indirectly by TZ (see below). +QString ucalTimeZoneDisplayName(UCalendar *ucal, + QTimeZone::TimeType timeType, + QTimeZone::NameType nameType, + const QByteArray &localeCode) +{ + constexpr int32_t BigNameLength = 50; + int32_t size = BigNameLength; + QString result(size, Qt::Uninitialized); + auto dst = [&result]() { return reinterpret_cast<UChar *>(result.data()); }; + UErrorCode status = U_ZERO_ERROR; + const UCalendarDisplayNameType utype = ucalDisplayNameType(timeType, nameType); + + // size = ucal_getTimeZoneDisplayName(cal, type, locale, result, resultLength, status) + size = ucal_getTimeZoneDisplayName(ucal, utype, localeCode.constData(), + dst(), size, &status); + + // If overflow, then resize and retry + if (size > BigNameLength || status == U_BUFFER_OVERFLOW_ERROR) { + result.resize(size); + status = U_ZERO_ERROR; + size = ucal_getTimeZoneDisplayName(ucal, utype, localeCode.constData(), + dst(), size, &status); + } + + if (!U_SUCCESS(status)) + return QString(); + + // Resize and return: + result.resize(size); + return result; +} + } // QtTimeZoneLocale + +// Used by TZ backends when ICU is available: +QString QTimeZonePrivate::localeName(qint64 atMSecsSinceEpoch, int offsetFromUtc, + QTimeZone::TimeType timeType, + QTimeZone::NameType nameType, + const QLocale &locale) const +{ + Q_UNUSED(atMSecsSinceEpoch); + // TODO: use CLDR data for the offset name. + // No ICU API for offset formats, so fall back to our ISO one, even if + // locale isn't C: + if (nameType == QTimeZone::OffsetName) + return isoOffsetFormat(offsetFromUtc); + + const QString id = QString::fromUtf8(m_id); + const QByteArray loc = locale.name().toUtf8(); + UErrorCode status = U_ZERO_ERROR; + UCalendar *ucal = ucal_open(reinterpret_cast<const UChar *>(id.data()), id.size(), + loc.constData(), UCAL_DEFAULT, &status); + if (ucal && U_SUCCESS(status)) { + auto tidier = qScopeGuard([ucal]() { ucal_close(ucal); }); + return QtTimeZoneLocale::ucalTimeZoneDisplayName(ucal, timeType, nameType, loc); + } + return QString(); +} #else // No ICU, use QTZ[LP}_data_p.h data for feature timezone_locale. namespace { using namespace QtTimeZoneLocale; // QTZL_data_p.h @@ -24,6 +107,20 @@ using namespace QtTimeZoneCldr; // QTZP_data_p.h // Accessors for the QTZP_data_p.h } // nameless namespace + +QString QTimeZonePrivate::localeName(qint64 atMSecsSinceEpoch, int offsetFromUtc, + QTimeZone::TimeType timeType, + QTimeZone::NameType nameType, + const QLocale &locale) const +{ + Q_ASSERT(nameType != QTimeZone::OffsetName || locale.language() != QLocale::C); + // Get data from QTZ[LP]_data_p.h + + Q_UNUSED(atMSecsSinceEpoch); + Q_UNUSED(offsetFromUtc); + Q_UNUSED(timeType); + return QString(); +} #endif // ICU QT_END_NAMESPACE diff --git a/src/corelib/time/qtimezonelocale_p.h b/src/corelib/time/qtimezonelocale_p.h index adc8e83b35..6e6c6b51fd 100644 --- a/src/corelib/time/qtimezonelocale_p.h +++ b/src/corelib/time/qtimezonelocale_p.h @@ -14,18 +14,31 @@ // // We mean it. // +#include <private/qglobal_p.h> +#include <QtCore/qstring.h> #include <QtCore/qtimezone.h> +#if QT_CONFIG(icu) +#include <unicode/ucal.h> +#endif + QT_REQUIRE_CONFIG(timezone); QT_REQUIRE_CONFIG(timezone_locale); +QT_BEGIN_NAMESPACE + namespace QtTimeZoneLocale { #if QT_CONFIG(icu) +QString ucalTimeZoneDisplayName(UCalendar *ucal, QTimeZone::TimeType timeType, + QTimeZone::NameType nameType, + const QString &localeCode); #else // Define data types for QTZL_data_p.h #endif } +QT_END_NAMESPACE + #endif // QTIMEZONELOCALE_P_H diff --git a/src/corelib/time/qtimezoneprivate.cpp b/src/corelib/time/qtimezoneprivate.cpp index 2ad0d874b6..b18b7e8758 100644 --- a/src/corelib/time/qtimezoneprivate.cpp +++ b/src/corelib/time/qtimezoneprivate.cpp @@ -5,6 +5,9 @@ #include "qtimezone.h" #include "qtimezoneprivate_p.h" +#if QT_CONFIG(timezone_locale) +# include "qtimezonelocale_p.h" +#endif #include "qtimezoneprivate_data_p.h" #include <qdatastream.h> @@ -51,6 +54,11 @@ constexpr bool atLowerWindowsKey(const WindowsData &entry, qint16 winIdKey) noex return entry.windowsIdKey < winIdKey; } +static bool earlierAliasId(const AliasData &entry, QByteArrayView aliasId) noexcept +{ + return entry.aliasId().compare(aliasId, Qt::CaseInsensitive) < 0; +} + static bool earlierWindowsId(const WindowsData &entry, QByteArrayView winId) noexcept { return entry.windowsId().compare(winId, Qt::CaseInsensitive) < 0; @@ -172,22 +180,37 @@ QString QTimeZonePrivate::displayName(qint64 atMSecsSinceEpoch, QTimeZone::NameType nameType, const QLocale &locale) const { - if (nameType == QTimeZone::OffsetName) - return isoOffsetFormat(offsetFromUtc(atMSecsSinceEpoch)); - - if (isDaylightTime(atMSecsSinceEpoch)) - return displayName(QTimeZone::DaylightTime, nameType, locale); - else - return displayName(QTimeZone::StandardTime, nameType, locale); + const Data tran = data(atMSecsSinceEpoch); + if (tran.atMSecsSinceEpoch != invalidMSecs()) { + if (nameType == QTimeZone::OffsetName && locale.language() == QLocale::C) + return isoOffsetFormat(tran.offsetFromUtc); + if (nameType == QTimeZone::ShortName && isDataLocale(locale)) + return tran.abbreviation; + + QTimeZone::TimeType timeType + = tran.daylightTimeOffset != 0 ? QTimeZone::DaylightTime : QTimeZone::StandardTime; +#if QT_CONFIG(timezone_locale) + return localeName(atMSecsSinceEpoch, tran.offsetFromUtc, timeType, nameType, locale); +#else + return displayName(timeType, nameType, locale); +#endif + } + return QString(); } QString QTimeZonePrivate::displayName(QTimeZone::TimeType timeType, QTimeZone::NameType nameType, const QLocale &locale) const { - Q_UNUSED(timeType); - Q_UNUSED(nameType); - Q_UNUSED(locale); + const Data tran = data(timeType); + if (tran.atMSecsSinceEpoch != invalidMSecs()) { + if (nameType == QTimeZone::OffsetName && isDataLocale(locale)) + return isoOffsetFormat(tran.offsetFromUtc); + +#if QT_CONFIG(timezone_locale) + return localeName(tran.atMSecsSinceEpoch, tran.offsetFromUtc, timeType, nameType, locale); +#endif + } return QString(); } @@ -227,6 +250,56 @@ bool QTimeZonePrivate::isDaylightTime(qint64 atMSecsSinceEpoch) const return false; } +QTimeZonePrivate::Data QTimeZonePrivate::data(QTimeZone::TimeType timeType) const +{ + // True if tran is valid and has the DST-ness to match timeType: + const auto validMatch = [timeType](const QTimeZonePrivate::Data &tran) { + return tran.atMSecsSinceEpoch != invalidMSecs() + && ((timeType == QTimeZone::DaylightTime) != (tran.daylightTimeOffset == 0)); + }; + + // Get current tran, use if suitable: + const qint64 currentMSecs = QDateTime::currentMSecsSinceEpoch(); + QTimeZonePrivate::Data tran = data(currentMSecs); + if (validMatch(tran)) + return tran; + + if (hasTransitions()) { + // Otherwise, next tran probably flips DST-ness: + tran = nextTransition(currentMSecs); + if (validMatch(tran)) + return tran; + + // Failing that, prev (or present, if current MSecs is exactly a + // transition moment) tran defines what data() got us and the one before + // that probably flips DST-ness; failing that, keep marching backwards + // in search of a DST interval: + tran = previousTransition(currentMSecs + 1); + while (tran.atMSecsSinceEpoch != invalidMSecs()) { + tran = previousTransition(tran.atMSecsSinceEpoch); + if (validMatch(tran)) + return tran; + } + } + return {}; +} + +/*! + \internal + + Returns true if the abbreviation given in data()'s returns is appropriate + for use in the given \a locale. + + Base implementation assumes data() corresponds to the system locale; derived + classes should override if their data() is something else (such as + C/English). +*/ +bool QTimeZonePrivate::isDataLocale(const QLocale &locale) const +{ + // Guess data is for the system locale unless backend overrides that. + return locale == QLocale::system(); +} + QTimeZonePrivate::Data QTimeZonePrivate::data(qint64 forMSecsSinceEpoch) const { Q_UNUSED(forMSecsSinceEpoch); @@ -532,7 +605,8 @@ QList<QByteArray> QTimeZonePrivate::availableTimeZoneIds() const return QList<QByteArray>(); } -static QList<QByteArray> selectAvailable(QList<QByteArray>&& desired, const QList<QByteArray>& all) +static QList<QByteArray> selectAvailable(QList<QByteArrayView> &&desired, + const QList<QByteArray> &all) { std::sort(desired.begin(), desired.end()); const auto newEnd = std::unique(desired.begin(), desired.end()); @@ -547,13 +621,13 @@ static QList<QByteArray> selectAvailable(QList<QByteArray>&& desired, const QLis QList<QByteArray> QTimeZonePrivate::availableTimeZoneIds(QLocale::Territory territory) const { // Default fall-back mode, use the zoneTable to find Region of know Zones - QList<QByteArray> regions; + QList<QByteArrayView> regions; // First get all Zones in the Zones table belonging to the Region for (const ZoneData &data : zoneDataTable) { if (data.territory == territory) { for (auto l1 : data.ids()) - regions << QByteArray(l1.data(), l1.size()); + regions << QByteArrayView(l1.data(), l1.size()); } } return selectAvailable(std::move(regions), availableTimeZoneIds()); @@ -561,16 +635,16 @@ QList<QByteArray> QTimeZonePrivate::availableTimeZoneIds(QLocale::Territory terr QList<QByteArray> QTimeZonePrivate::availableTimeZoneIds(int offsetFromUtc) const { - // Default fall-back mode, use the zoneTable to find Offset of know Zones - QList<QByteArray> offsets; - // First get all Zones in the table using the Offset + // Default fall-back mode: use the zoneTable to find offsets of know zones. + QList<QByteArrayView> offsets; + // First get all Zones in the table using the given offset: for (const WindowsData &winData : windowsDataTable) { if (winData.offsetFromUtc == offsetFromUtc) { for (auto data = zoneStartForWindowsId(winData.windowsIdKey); data != std::end(zoneDataTable) && data->windowsIdKey == winData.windowsIdKey; ++data) { for (auto l1 : data->ids()) - offsets << QByteArray(l1.data(), l1.size()); + offsets << QByteArrayView(l1.data(), l1.size()); } } } @@ -701,6 +775,18 @@ QString QTimeZonePrivate::isoOffsetFormat(int offsetFromUtc, QTimeZone::NameType return result; } +QByteArray QTimeZonePrivate::aliasToIana(QByteArrayView alias) +{ + const auto data = std::lower_bound(std::begin(aliasMappingTable), std::end(aliasMappingTable), + alias, earlierAliasId); + if (data != std::end(aliasMappingTable) && data->aliasId() == alias) + return data->ianaId().toByteArray(); + // Note: empty return means not an alias, which is true of an ID that others + // are aliases to, as the table omits self-alias entries. Let caller sort + // that out, rather than allocating to return alias.toByteArray(). + return {}; +} + QByteArray QTimeZonePrivate::ianaIdToWindowsId(const QByteArray &id) { const auto idUtf8 = QUtf8StringView(id); @@ -906,6 +992,19 @@ QTimeZonePrivate::Data QUtcTimeZonePrivate::data(qint64 forMSecsSinceEpoch) cons return d; } +// Override to shortcut past base's complications: +QTimeZonePrivate::Data QUtcTimeZonePrivate::data(QTimeZone::TimeType timeType) const +{ + Q_UNUSED(timeType); + return data(QDateTime::currentMSecsSinceEpoch()); +} + +bool QUtcTimeZonePrivate::isDataLocale(const QLocale &locale) const +{ + // Officially only supports C locale names; these are surely also viable for English. + return locale.language() == QLocale::C || locale.language() == QLocale::English; +} + void QUtcTimeZonePrivate::init(const QByteArray &zoneId) { m_id = zoneId; @@ -933,6 +1032,15 @@ QString QUtcTimeZonePrivate::comment() const return m_comment; } +// Override to bypass complications in base-class: +QString QUtcTimeZonePrivate::displayName(qint64 atMSecsSinceEpoch, + QTimeZone::NameType nameType, + const QLocale &locale) const +{ + Q_UNUSED(atMSecsSinceEpoch); + return displayName(QTimeZone::StandardTime, nameType, locale); +} + QString QUtcTimeZonePrivate::displayName(QTimeZone::TimeType timeType, QTimeZone::NameType nameType, const QLocale &locale) const diff --git a/src/corelib/time/qtimezoneprivate_data_p.h b/src/corelib/time/qtimezoneprivate_data_p.h index 659605b224..50d1ed80c1 100644 --- a/src/corelib/time/qtimezoneprivate_data_p.h +++ b/src/corelib/time/qtimezoneprivate_data_p.h @@ -25,7 +25,7 @@ QT_BEGIN_NAMESPACE namespace QtTimeZoneCldr { /* - Recognized UTC-offset zones and CLDR-derived data on Windows IDs. + Recognized UTC-offset zones and CLDR-derived data on timezone IDs. The UTC-offset zone table is provided for generic UTC±HH:mm format time zones. The UTC backend can support arbitrary offsets in seconds, but only @@ -38,12 +38,26 @@ namespace QtTimeZoneCldr { look up Region Codes and UTC Offsets on platforms whose backends don't directly support them. For example, Darwin does not support availableTimeZones() filtering by region or offset. This table is - auto-generated from the CLDR supplemental/windowsZones.xml data file. + auto-generated from the CLDR supplemental/windowsZones.xml data file, with + IDs converted from CLDR-stable to IANA-current using bcp47/timezone.xml + data. Please do not edit this data directly. See the generated section for details of its last update and how to update it. */ +struct AliasData +{ + // Table is sorted on aliasId(), then on ianaId(). + // Indices in alias table, not IANA (group) table + quint16 aliasIdIndex; + quint16 ianaIdIndex; + // Values for the actual IDs: + constexpr QByteArrayView aliasId() const; + constexpr QByteArrayView ianaId() const; +}; + +// FIXME: rename ianaIdData[] to ianaListData[], aliasIdData[] to ianaIdData[] struct ZoneData { // Keys (table is sorted in Windows ID, then on territory enum value): @@ -63,6 +77,7 @@ struct WindowsData // Values for this Windows zone: quint16 ianaIdIndex; // Index in ianaIdData of space-joined IANA IDs qint32 offsetFromUtc; // Standard Time Offset from UTC, used for quick look-ups + // FIXME: ianaIdIndex is actually always a single IANA ID, so re-route to alias table constexpr QByteArrayView windowsId() const; constexpr QByteArrayView ianaId() const; // Space-joined list of IANA IDs }; @@ -74,39 +89,167 @@ struct UtcData constexpr QByteArrayView id() const; // Space-joined list of IANA IDs }; -/* - COPYRIGHT AND PERMISSION NOTICE - - Copyright © 1991-2012 Unicode, Inc. All rights reserved. Distributed under - the Terms of Use in http://www.unicode.org/copyright.html. - - Permission is hereby granted, free of charge, to any person obtaining a - copy of the Unicode data files and any associated documentation (the "Data - Files") or Unicode software and any associated documentation (the "Software") - to deal in the Data Files or Software without restriction, including without - limitation the rights to use, copy, modify, merge, publish, distribute, and/or - sell copies of the Data Files or Software, and to permit persons to whom the - Data Files or Software are furnished to do so, provided that (a) the above - copyright notice(s) and this permission notice appear with all copies of the - Data Files or Software, (b) both the above copyright notice(s) and this - permission notice appear in associated documentation, and (c) there is clear - notice in each modified Data File or in the Software as well as in the - documentation associated with the Data File(s) or Software that the data or - software has been modified. -*/ - // GENERATED PART STARTS HERE /* - This part of the file was generated on 2024-01-29 from the - Common Locale Data Repository v43 file supplemental/windowsZones.xml + This part of the file was generated on 2024-04-30 from the + Common Locale Data Repository v44.1 http://www.unicode.org/cldr/ - Do not edit this code: run cldr2qtimezone.py on updated (or + Do not edit this section: instead regenerate it using + cldr2qlocalexml.py and qlocalexml2cpp.py on updated (or edited) CLDR data; see qtbase/util/locale_database/. */ +// Alias ID Index, Alias ID Index +static constexpr AliasData aliasMappingTable[] = { + { 0, 14 }, // Africa/Asmera -> Africa/Asmara + { 28, 44 }, // Africa/Timbuktu -> Africa/Bamako + { 58, 91 }, // America/Argentina/ComodRivadavia -> America/Argentina/Catamarca + { 119, 132 }, // America/Atka -> America/Adak + { 145, 166 }, // America/Buenos_Aires -> America/Argentina/Buenos_Aires + { 197, 91 }, // America/Catamarca -> America/Argentina/Catamarca + { 215, 237 }, // America/Coral_Harbour -> America/Atikokan + { 254, 270 }, // America/Cordoba -> America/Argentina/Cordoba + { 296, 313 }, // America/Ensenada -> America/Tijuana + { 329, 348 }, // America/Fort_Wayne -> America/Indiana/Indianapolis + { 377, 393 }, // America/Godthab -> America/Nuuk + { 406, 348 }, // America/Indianapolis -> America/Indiana/Indianapolis + { 427, 441 }, // America/Jujuy -> America/Argentina/Jujuy + { 465, 481 }, // America/Knox_IN -> America/Indiana/Knox + { 502, 521 }, // America/Louisville -> America/Kentucky/Louisville + { 549, 565 }, // America/Mendoza -> America/Argentina/Mendoza + { 591, 608 }, // America/Montreal -> America/Toronto + { 624, 608 }, // America/Nipigon -> America/Toronto + { 640, 660 }, // America/Pangnirtung -> America/Iqaluit + { 676, 695 }, // America/Porto_Acre -> America/Rio_Branco + { 714, 734 }, // America/Rainy_River -> America/Winnipeg + { 751, 270 }, // America/Rosario -> America/Argentina/Cordoba + { 767, 313 }, // America/Santa_Isabel -> America/Tijuana + { 788, 805 }, // America/Shiprock -> America/Denver + { 820, 608 }, // America/Thunder_Bay -> America/Toronto + { 840, 855 }, // America/Virgin -> America/St_Thomas + { 873, 893 }, // America/Yellowknife -> America/Edmonton + { 910, 932 }, // Antarctica/South_Pole -> Pacific/Auckland + { 949, 964 }, // Asia/Ashkhabad -> Asia/Ashgabat + { 978, 992 }, // Asia/Calcutta -> Asia/Kolkata + { 1005, 1020 }, // Asia/Chongqing -> Asia/Shanghai + { 1034, 1020 }, // Asia/Chungking -> Asia/Shanghai + { 1049, 1060 }, // Asia/Dacca -> Asia/Dhaka + { 1071, 1020 }, // Asia/Harbin -> Asia/Shanghai + { 1083, 1097 }, // Asia/Istanbul -> Europe/Istanbul + { 1113, 1126 }, // Asia/Kashgar -> Asia/Urumqi + { 1138, 1152 }, // Asia/Katmandu -> Asia/Kathmandu + { 1167, 1178 }, // Asia/Macao -> Asia/Macau + { 1189, 1202 }, // Asia/Rangoon -> Asia/Yangon + { 1214, 1226 }, // Asia/Saigon -> Asia/Ho_Chi_Minh + { 1243, 1257 }, // Asia/Tel_Aviv -> Asia/Jerusalem + { 1272, 1284 }, // Asia/Thimbu -> Asia/Thimphu + { 1297, 1316 }, // Asia/Ujung_Pandang -> Asia/Makassar + { 1330, 1346 }, // Asia/Ulan_Bator -> Asia/Ulaanbaatar + { 1363, 1379 }, // Atlantic/Faeroe -> Atlantic/Faroe + { 1394, 1413 }, // Atlantic/Jan_Mayen -> Arctic/Longyearbyen + { 1433, 1447 }, // Australia/ACT -> Australia/Sydney + { 1464, 1447 }, // Australia/Canberra -> Australia/Sydney + { 1483, 1500 }, // Australia/Currie -> Australia/Hobart + { 1517, 1531 }, // Australia/LHI -> Australia/Lord_Howe + { 1551, 1447 }, // Australia/NSW -> Australia/Sydney + { 1565, 1581 }, // Australia/North -> Australia/Darwin + { 1598, 1619 }, // Australia/Queensland -> Australia/Brisbane + { 1638, 1654 }, // Australia/South -> Australia/Adelaide + { 1673, 1500 }, // Australia/Tasmania -> Australia/Hobart + { 1692, 1711 }, // Australia/Victoria -> Australia/Melbourne + { 1731, 1746 }, // Australia/West -> Australia/Perth + { 1762, 1783 }, // Australia/Yancowinna -> Australia/Broken_Hill + { 1805, 695 }, // Brazil/Acre -> America/Rio_Branco + { 1817, 1834 }, // Brazil/DeNoronha -> America/Noronha + { 1850, 1862 }, // Brazil/East -> America/Sao_Paulo + { 1880, 1892 }, // Brazil/West -> America/Manaus + { 1907, 1923 }, // Canada/Atlantic -> America/Halifax + { 1939, 734 }, // Canada/Central -> America/Winnipeg + { 1954, 1979 }, // Canada/East-Saskatchewan -> America/Regina + { 1994, 608 }, // Canada/Eastern -> America/Toronto + { 2009, 893 }, // Canada/Mountain -> America/Edmonton + { 2025, 2045 }, // Canada/Newfoundland -> America/St_Johns + { 2062, 2077 }, // Canada/Pacific -> America/Vancouver + { 2095, 1979 }, // Canada/Saskatchewan -> America/Regina + { 2115, 2128 }, // Canada/Yukon -> America/Whitehorse + { 2147, 2165 }, // Chile/Continental -> America/Santiago + { 2182, 2201 }, // Chile/EasterIsland -> Pacific/Easter + { 2216, 2221 }, // Cuba -> America/Havana + { 2236, 2240 }, // EST -> Etc/GMT+5 + { 2250, 2256 }, // Egypt -> Africa/Cairo + { 2269, 2274 }, // Eire -> Europe/Dublin + { 2288, 2298 }, // Etc/GMT+0 -> Etc/GMT + { 2306, 2298 }, // Etc/GMT-0 -> Etc/GMT + { 2316, 2298 }, // Etc/GMT0 -> Etc/GMT + { 2325, 2298 }, // Etc/Greenwich -> Etc/GMT + { 2339, 2347 }, // Etc/UCT -> Etc/UTC + { 2355, 2347 }, // Etc/Universal -> Etc/UTC + { 2369, 2347 }, // Etc/Zulu -> Etc/UTC + { 2378, 2393 }, // Europe/Belfast -> Europe/London + { 2407, 2419 }, // Europe/Kiev -> Europe/Kyiv + { 2431, 2446 }, // Europe/Nicosia -> Asia/Nicosia + { 2459, 2475 }, // Europe/Tiraspol -> Europe/Chisinau + { 2491, 2419 }, // Europe/Uzhgorod -> Europe/Kyiv + { 2507, 2419 }, // Europe/Zaporozhye -> Europe/Kyiv + { 2525, 2393 }, // GB -> Europe/London + { 2528, 2393 }, // GB-Eire -> Europe/London + { 2536, 2298 }, // GMT -> Etc/GMT + { 2540, 2298 }, // GMT+0 -> Etc/GMT + { 2546, 2298 }, // GMT-0 -> Etc/GMT + { 2552, 2298 }, // GMT0 -> Etc/GMT + { 2557, 2298 }, // Greenwich -> Etc/GMT + { 2567, 2571 }, // HST -> Etc/GMT+10 + { 2582, 2591 }, // Hongkong -> Asia/Hong_Kong + { 2606, 2614 }, // Iceland -> Atlantic/Reykjavik + { 2633, 2638 }, // Iran -> Asia/Tehran + { 2650, 1257 }, // Israel -> Asia/Jerusalem + { 2657, 2665 }, // Jamaica -> America/Jamaica + { 2681, 2687 }, // Japan -> Asia/Tokyo + { 2698, 2708 }, // Kwajalein -> Pacific/Kwajalein + { 2726, 2732 }, // Libya -> Africa/Tripoli + { 2747, 2751 }, // MST -> Etc/GMT+7 + { 2761, 313 }, // Mexico/BajaNorte -> America/Tijuana + { 2778, 2793 }, // Mexico/BajaSur -> America/Mazatlan + { 2810, 2825 }, // Mexico/General -> America/Mexico_City + { 2845, 932 }, // NZ -> Pacific/Auckland + { 2848, 2856 }, // NZ-CHAT -> Pacific/Chatham + { 2872, 805 }, // Navajo -> America/Denver + { 2879, 1020 }, // PRC -> Asia/Shanghai + { 2883, 2901 }, // Pacific/Enderbury -> Pacific/Kanton + { 2916, 2933 }, // Pacific/Johnston -> Pacific/Honolulu + { 2950, 2965 }, // Pacific/Ponape -> Pacific/Pohnpei + { 2981, 2995 }, // Pacific/Samoa -> Pacific/Pago_Pago + { 3013, 3026 }, // Pacific/Truk -> Pacific/Chuuk + { 3040, 3026 }, // Pacific/Yap -> Pacific/Chuuk + { 3052, 3059 }, // Poland -> Europe/Warsaw + { 3073, 3082 }, // Portugal -> Europe/Lisbon + { 3096, 3100 }, // ROC -> Asia/Taipei + { 3112, 3116 }, // ROK -> Asia/Seoul + { 3127, 3137 }, // Singapore -> Asia/Singapore + { 3152, 1097 }, // Turkey -> Europe/Istanbul + { 3159, 2347 }, // UCT -> Etc/UTC + { 3163, 3173 }, // US/Alaska -> America/Anchorage + { 3191, 132 }, // US/Aleutian -> America/Adak + { 3203, 3214 }, // US/Arizona -> America/Phoenix + { 3230, 3241 }, // US/Central -> America/Chicago + { 3257, 348 }, // US/East-Indiana -> America/Indiana/Indianapolis + { 3273, 3284 }, // US/Eastern -> America/New_York + { 3301, 2933 }, // US/Hawaii -> Pacific/Honolulu + { 3311, 481 }, // US/Indiana-Starke -> America/Indiana/Knox + { 3329, 3341 }, // US/Michigan -> America/Detroit + { 3357, 805 }, // US/Mountain -> America/Denver + { 3369, 3380 }, // US/Pacific -> America/Los_Angeles + { 3400, 3380 }, // US/Pacific-New -> America/Los_Angeles + { 3415, 2995 }, // US/Samoa -> Pacific/Pago_Pago + { 3424, 2347 }, // UTC -> Etc/UTC + { 3428, 2347 }, // Universal -> Etc/UTC + { 3438, 3443 }, // W-SU -> Europe/Moscow + { 3457, 2347 }, // Zulu -> Etc/UTC +}; + // Windows ID Key, Territory Enum, IANA ID Index static constexpr ZoneData zoneDataTable[] = { { 1, 1, 0 }, // Afghanistan Standard Time / Afghanistan @@ -123,544 +266,548 @@ static constexpr ZoneData zoneDataTable[] = { { 6, 245, 212 }, // Arabian Standard Time / United Arab Emirates { 7, 113, 223 }, // Arabic Standard Time / Iraq { 8, 11, 236 }, // Argentina Standard Time / Argentina - { 9, 193, 509 }, // Astrakhan Standard Time / Russia - { 10, 26, 543 }, // Atlantic Standard Time / Bermuda - { 10, 41, 560 }, // Atlantic Standard Time / Canada - { 10, 95, 628 }, // Atlantic Standard Time / Greenland - { 11, 15, 642 }, // AUS Central Standard Time / Australia - { 12, 15, 659 }, // Aus Central W. Standard Time / Australia - { 13, 15, 675 }, // AUS Eastern Standard Time / Australia - { 14, 17, 712 }, // Azerbaijan Standard Time / Azerbaijan - { 15, 95, 722 }, // Azores Standard Time / Greenland - { 15, 188, 743 }, // Azores Standard Time / Portugal - { 16, 32, 759 }, // Bahia Standard Time / Brazil - { 17, 20, 773 }, // Bangladesh Standard Time / Bangladesh - { 17, 27, 784 }, // Bangladesh Standard Time / Bhutan - { 18, 22, 797 }, // Belarus Standard Time / Belarus - { 19, 182, 810 }, // Bougainville Standard Time / Papua New Guinea - { 20, 41, 831 }, // Canada Central Standard Time / Canada - { 21, 0, 868 }, // Cape Verde Standard Time / AnyTerritory - { 21, 43, 878 }, // Cape Verde Standard Time / Cape Verde - { 22, 12, 898 }, // Caucasus Standard Time / Armenia - { 23, 15, 911 }, // Cen. Australia Standard Time / Australia - { 24, 0, 952 }, // Central America Standard Time / AnyTerritory - { 24, 24, 962 }, // Central America Standard Time / Belize - { 24, 59, 977 }, // Central America Standard Time / Costa Rica - { 24, 70, 996 }, // Central America Standard Time / Ecuador - { 24, 72, 1014 }, // Central America Standard Time / El Salvador - { 24, 99, 1034 }, // Central America Standard Time / Guatemala - { 24, 106, 1052 }, // Central America Standard Time / Honduras - { 24, 168, 1072 }, // Central America Standard Time / Nicaragua - { 25, 0, 1088 }, // Central Asia Standard Time / AnyTerritory - { 25, 9, 1098 }, // Central Asia Standard Time / Antarctica - { 25, 33, 1116 }, // Central Asia Standard Time / British Indian Ocean Territory - { 25, 50, 1130 }, // Central Asia Standard Time / China - { 25, 123, 1142 }, // Central Asia Standard Time / Kazakhstan - { 25, 128, 1168 }, // Central Asia Standard Time / Kyrgyzstan - { 26, 32, 1181 }, // Central Brazilian Standard Time / Brazil - { 27, 3, 1217 }, // Central Europe Standard Time / Albania - { 27, 64, 1231 }, // Central Europe Standard Time / Czechia - { 27, 108, 1245 }, // Central Europe Standard Time / Hungary - { 27, 157, 1261 }, // Central Europe Standard Time / Montenegro - { 27, 207, 1278 }, // Central Europe Standard Time / Serbia - { 27, 212, 1294 }, // Central Europe Standard Time / Slovakia - { 27, 213, 1312 }, // Central Europe Standard Time / Slovenia - { 28, 29, 1329 }, // Central European Standard Time / Bosnia and Herzegovina - { 28, 60, 1345 }, // Central European Standard Time / Croatia - { 28, 140, 1359 }, // Central European Standard Time / Macedonia - { 28, 187, 1373 }, // Central European Standard Time / Poland - { 29, 0, 1387 }, // Central Pacific Standard Time / AnyTerritory - { 29, 9, 1398 }, // Central Pacific Standard Time / Antarctica - { 29, 153, 1415 }, // Central Pacific Standard Time / Micronesia - { 29, 166, 1445 }, // Central Pacific Standard Time / New Caledonia - { 29, 214, 1460 }, // Central Pacific Standard Time / Solomon Islands - { 29, 252, 1480 }, // Central Pacific Standard Time / Vanuatu - { 30, 0, 1494 }, // Central Standard Time / AnyTerritory - { 30, 41, 1502 }, // Central Standard Time / Canada - { 30, 152, 1577 }, // Central Standard Time / Mexico - { 30, 248, 1611 }, // Central Standard Time / United States - { 31, 152, 1779 }, // Central Standard Time (Mexico) / Mexico - { 32, 167, 1873 }, // Chatham Islands Standard Time / New Zealand - { 33, 50, 1889 }, // China Standard Time / China - { 33, 107, 1903 }, // China Standard Time / Hong Kong - { 33, 139, 1918 }, // China Standard Time / Macao - { 34, 61, 1929 }, // Cuba Standard Time / Cuba - { 35, 0, 1944 }, // Dateline Standard Time / AnyTerritory - { 36, 0, 1955 }, // E. Africa Standard Time / AnyTerritory - { 36, 9, 1965 }, // E. Africa Standard Time / Antarctica - { 36, 55, 1982 }, // E. Africa Standard Time / Comoros - { 36, 67, 1996 }, // E. Africa Standard Time / Djibouti - { 36, 74, 2012 }, // E. Africa Standard Time / Eritrea - { 36, 77, 2026 }, // E. Africa Standard Time / Ethiopia - { 36, 124, 2045 }, // E. Africa Standard Time / Kenya - { 36, 141, 2060 }, // E. Africa Standard Time / Madagascar - { 36, 151, 2080 }, // E. Africa Standard Time / Mayotte - { 36, 215, 2095 }, // E. Africa Standard Time / Somalia - { 36, 230, 2112 }, // E. Africa Standard Time / Tanzania - { 36, 243, 2133 }, // E. Africa Standard Time / Uganda - { 37, 15, 2148 }, // E. Australia Standard Time / Australia - { 38, 154, 2186 }, // E. Europe Standard Time / Moldova - { 39, 32, 2202 }, // E. South America Standard Time / Brazil - { 40, 49, 2220 }, // Easter Island Standard Time / Chile - { 41, 0, 2235 }, // Eastern Standard Time / AnyTerritory - { 41, 18, 2243 }, // Eastern Standard Time / Bahamas - { 41, 41, 2258 }, // Eastern Standard Time / Canada - { 41, 248, 2363 }, // Eastern Standard Time / United States - { 42, 152, 2520 }, // Eastern Standard Time (Mexico) / Mexico - { 43, 71, 2535 }, // Egypt Standard Time / Egypt - { 44, 193, 2548 }, // Ekaterinburg Standard Time / Russia - { 45, 82, 2567 }, // Fiji Standard Time / Fiji - { 46, 2, 2580 }, // FLE Standard Time / Aland Islands - { 46, 36, 2597 }, // FLE Standard Time / Bulgaria - { 46, 75, 2610 }, // FLE Standard Time / Estonia - { 46, 83, 2625 }, // FLE Standard Time / Finland - { 46, 131, 2641 }, // FLE Standard Time / Latvia - { 46, 137, 2653 }, // FLE Standard Time / Lithuania - { 46, 244, 2668 }, // FLE Standard Time / Ukraine - { 47, 90, 2714 }, // Georgian Standard Time / Georgia - { 48, 81, 2727 }, // GMT Standard Time / Faroe Islands - { 48, 100, 2743 }, // GMT Standard Time / Guernsey - { 48, 114, 2759 }, // GMT Standard Time / Ireland - { 48, 115, 2773 }, // GMT Standard Time / Isle of Man - { 48, 121, 2792 }, // GMT Standard Time / Jersey - { 48, 188, 2806 }, // GMT Standard Time / Portugal - { 48, 220, 2837 }, // GMT Standard Time / Spain - { 48, 246, 2853 }, // GMT Standard Time / United Kingdom - { 49, 95, 2867 }, // Greenland Standard Time / Greenland - { 50, 37, 2883 }, // Greenwich Standard Time / Burkina Faso - { 50, 89, 2902 }, // Greenwich Standard Time / Gambia - { 50, 92, 2916 }, // Greenwich Standard Time / Ghana - { 50, 95, 2929 }, // Greenwich Standard Time / Greenland - { 50, 101, 2950 }, // Greenwich Standard Time / Guinea-Bissau - { 50, 102, 2964 }, // Greenwich Standard Time / Guinea - { 50, 109, 2979 }, // Greenwich Standard Time / Iceland - { 50, 118, 2998 }, // Greenwich Standard Time / Ivory Coast - { 50, 134, 3013 }, // Greenwich Standard Time / Liberia - { 50, 145, 3029 }, // Greenwich Standard Time / Mali - { 50, 149, 3043 }, // Greenwich Standard Time / Mauritania - { 50, 196, 3061 }, // Greenwich Standard Time / Saint Helena - { 50, 206, 3080 }, // Greenwich Standard Time / Senegal - { 50, 209, 3093 }, // Greenwich Standard Time / Sierra Leone - { 50, 233, 3109 }, // Greenwich Standard Time / Togo - { 51, 63, 3121 }, // GTB Standard Time / Cyprus - { 51, 94, 3149 }, // GTB Standard Time / Greece - { 51, 192, 3163 }, // GTB Standard Time / Romania - { 52, 104, 3180 }, // Haiti Standard Time / Haiti - { 53, 0, 3203 }, // Hawaiian Standard Time / AnyTerritory - { 53, 58, 3214 }, // Hawaiian Standard Time / Cook Islands - { 53, 86, 3232 }, // Hawaiian Standard Time / French Polynesia - { 53, 247, 3247 }, // Hawaiian Standard Time / United States Outlying Islands - { 53, 248, 3264 }, // Hawaiian Standard Time / United States - { 54, 110, 3281 }, // India Standard Time / India - { 55, 112, 3295 }, // Iran Standard Time / Iran - { 56, 116, 3307 }, // Israel Standard Time / Israel - { 57, 122, 3322 }, // Jordan Standard Time / Jordan - { 58, 193, 3333 }, // Kaliningrad Standard Time / Russia - { 59, 218, 3352 }, // Korea Standard Time / South Korea - { 60, 135, 3363 }, // Libya Standard Time / Libya - { 61, 0, 3378 }, // Line Islands Standard Time / AnyTerritory - { 61, 125, 3389 }, // Line Islands Standard Time / Kiribati - { 62, 15, 3408 }, // Lord Howe Standard Time / Australia - { 63, 193, 3428 }, // Magadan Standard Time / Russia - { 64, 49, 3441 }, // Magallanes Standard Time / Chile - { 65, 86, 3462 }, // Marquesas Standard Time / French Polynesia - { 66, 150, 3480 }, // Mauritius Standard Time / Mauritius - { 66, 191, 3497 }, // Mauritius Standard Time / Reunion - { 66, 208, 3512 }, // Mauritius Standard Time / Seychelles - { 67, 132, 3524 }, // Middle East Standard Time / Lebanon - { 68, 250, 3536 }, // Montevideo Standard Time / Uruguay - { 69, 159, 3555 }, // Morocco Standard Time / Morocco - { 69, 257, 3573 }, // Morocco Standard Time / Western Sahara - { 70, 0, 3589 }, // Mountain Standard Time / AnyTerritory - { 70, 41, 3597 }, // Mountain Standard Time / Canada - { 70, 152, 3671 }, // Mountain Standard Time / Mexico - { 70, 248, 3693 }, // Mountain Standard Time / United States - { 71, 152, 3722 }, // Mountain Standard Time (Mexico) / Mexico - { 72, 53, 3739 }, // Myanmar Standard Time / Cocos Islands - { 72, 161, 3752 }, // Myanmar Standard Time / Myanmar - { 73, 193, 3765 }, // N. Central Asia Standard Time / Russia - { 74, 162, 3782 }, // Namibia Standard Time / Namibia - { 75, 164, 3798 }, // Nepal Standard Time / Nepal - { 76, 9, 3812 }, // New Zealand Standard Time / Antarctica - { 76, 167, 3831 }, // New Zealand Standard Time / New Zealand - { 77, 41, 3848 }, // Newfoundland Standard Time / Canada - { 78, 172, 3865 }, // Norfolk Standard Time / Norfolk Island - { 79, 193, 3881 }, // North Asia East Standard Time / Russia - { 80, 193, 3894 }, // North Asia Standard Time / Russia - { 81, 174, 3929 }, // North Korea Standard Time / North Korea - { 82, 193, 3944 }, // Omsk Standard Time / Russia - { 83, 49, 3954 }, // Pacific SA Standard Time / Chile - { 84, 0, 3971 }, // Pacific Standard Time / AnyTerritory - { 84, 41, 3979 }, // Pacific Standard Time / Canada - { 84, 248, 3997 }, // Pacific Standard Time / United States - { 85, 152, 4017 }, // Pacific Standard Time (Mexico) / Mexico - { 86, 178, 4054 }, // Pakistan Standard Time / Pakistan - { 87, 183, 4067 }, // Paraguay Standard Time / Paraguay - { 88, 123, 4084 }, // Qyzylorda Standard Time / Kazakhstan - { 89, 23, 4099 }, // Romance Standard Time / Belgium - { 89, 65, 4115 }, // Romance Standard Time / Denmark - { 89, 84, 4133 }, // Romance Standard Time / France - { 89, 220, 4146 }, // Romance Standard Time / Spain - { 90, 193, 4173 }, // Russia Time Zone 10 / Russia - { 91, 193, 4192 }, // Russia Time Zone 11 / Russia - { 92, 193, 4219 }, // Russia Time Zone 3 / Russia - { 93, 193, 4233 }, // Russian Standard Time / Russia - { 93, 244, 4260 }, // Russian Standard Time / Ukraine - { 94, 0, 4278 }, // SA Eastern Standard Time / AnyTerritory - { 94, 9, 4288 }, // SA Eastern Standard Time / Antarctica - { 94, 32, 4325 }, // SA Eastern Standard Time / Brazil - { 94, 80, 4404 }, // SA Eastern Standard Time / Falkland Islands - { 94, 85, 4421 }, // SA Eastern Standard Time / French Guiana - { 94, 223, 4437 }, // SA Eastern Standard Time / Suriname - { 95, 0, 4456 }, // SA Pacific Standard Time / AnyTerritory - { 95, 32, 4466 }, // SA Pacific Standard Time / Brazil - { 95, 41, 4502 }, // SA Pacific Standard Time / Canada - { 95, 45, 4524 }, // SA Pacific Standard Time / Cayman Islands - { 95, 54, 4539 }, // SA Pacific Standard Time / Colombia - { 95, 70, 4554 }, // SA Pacific Standard Time / Ecuador - { 95, 119, 4572 }, // SA Pacific Standard Time / Jamaica - { 95, 181, 4588 }, // SA Pacific Standard Time / Panama - { 95, 184, 4603 }, // SA Pacific Standard Time / Peru - { 96, 0, 4616 }, // SA Western Standard Time / AnyTerritory - { 96, 8, 4626 }, // SA Western Standard Time / Anguilla - { 96, 10, 4643 }, // SA Western Standard Time / Antigua and Barbuda - { 96, 13, 4659 }, // SA Western Standard Time / Aruba - { 96, 21, 4673 }, // SA Western Standard Time / Barbados - { 96, 28, 4690 }, // SA Western Standard Time / Bolivia - { 96, 32, 4705 }, // SA Western Standard Time / Brazil - { 96, 34, 4758 }, // SA Western Standard Time / British Virgin Islands - { 96, 41, 4774 }, // SA Western Standard Time / Canada - { 96, 44, 4795 }, // SA Western Standard Time / Caribbean Netherlands - { 96, 62, 4814 }, // SA Western Standard Time / Curacao - { 96, 68, 4830 }, // SA Western Standard Time / Dominica - { 96, 69, 4847 }, // SA Western Standard Time / Dominican Republic - { 96, 96, 4869 }, // SA Western Standard Time / Grenada - { 96, 97, 4885 }, // SA Western Standard Time / Guadeloupe - { 96, 103, 4904 }, // SA Western Standard Time / Guyana - { 96, 148, 4919 }, // SA Western Standard Time / Martinique - { 96, 158, 4938 }, // SA Western Standard Time / Montserrat - { 96, 189, 4957 }, // SA Western Standard Time / Puerto Rico - { 96, 195, 4977 }, // SA Western Standard Time / Saint Barthelemy - { 96, 197, 4999 }, // SA Western Standard Time / Saint Kitts and Nevis - { 96, 198, 5016 }, // SA Western Standard Time / Saint Lucia - { 96, 199, 5033 }, // SA Western Standard Time / Saint Martin - { 96, 201, 5049 }, // SA Western Standard Time / Saint Vincent and Grenadines - { 96, 211, 5068 }, // SA Western Standard Time / Sint Maarten - { 96, 236, 5090 }, // SA Western Standard Time / Trinidad and Tobago - { 96, 249, 5112 }, // SA Western Standard Time / United States Virgin Islands - { 97, 200, 5130 }, // Saint Pierre Standard Time / Saint Pierre and Miquelon - { 98, 193, 5147 }, // Sakhalin Standard Time / Russia - { 99, 202, 5161 }, // Samoa Standard Time / Samoa - { 100, 204, 5174 }, // Sao Tome Standard Time / Sao Tome and Principe - { 101, 193, 5190 }, // Saratov Standard Time / Russia - { 102, 0, 5205 }, // SE Asia Standard Time / AnyTerritory - { 102, 9, 5215 }, // SE Asia Standard Time / Antarctica - { 102, 39, 5232 }, // SE Asia Standard Time / Cambodia - { 102, 51, 5248 }, // SE Asia Standard Time / Christmas Island - { 102, 111, 5265 }, // SE Asia Standard Time / Indonesia - { 102, 129, 5293 }, // SE Asia Standard Time / Laos - { 102, 231, 5308 }, // SE Asia Standard Time / Thailand - { 102, 255, 5321 }, // SE Asia Standard Time / Vietnam - { 103, 0, 5333 }, // Singapore Standard Time / AnyTerritory - { 103, 35, 5343 }, // Singapore Standard Time / Brunei - { 103, 111, 5355 }, // Singapore Standard Time / Indonesia - { 103, 143, 5369 }, // Singapore Standard Time / Malaysia - { 103, 185, 5400 }, // Singapore Standard Time / Philippines - { 103, 210, 5412 }, // Singapore Standard Time / Singapore - { 104, 0, 5427 }, // South Africa Standard Time / AnyTerritory - { 104, 30, 5437 }, // South Africa Standard Time / Botswana - { 104, 38, 5453 }, // South Africa Standard Time / Burundi - { 104, 57, 5470 }, // South Africa Standard Time / Congo - Kinshasa - { 104, 76, 5488 }, // South Africa Standard Time / Eswatini - { 104, 133, 5503 }, // South Africa Standard Time / Lesotho - { 104, 142, 5517 }, // South Africa Standard Time / Malawi - { 104, 160, 5533 }, // South Africa Standard Time / Mozambique - { 104, 194, 5547 }, // South Africa Standard Time / Rwanda - { 104, 216, 5561 }, // South Africa Standard Time / South Africa - { 104, 260, 5581 }, // South Africa Standard Time / Zambia - { 104, 261, 5595 }, // South Africa Standard Time / Zimbabwe - { 105, 219, 5609 }, // South Sudan Standard Time / South Sudan - { 106, 221, 5621 }, // Sri Lanka Standard Time / Sri Lanka - { 107, 222, 5634 }, // Sudan Standard Time / Sudan - { 108, 227, 5650 }, // Syria Standard Time / Syria - { 109, 228, 5664 }, // Taipei Standard Time / Taiwan - { 110, 15, 5676 }, // Tasmania Standard Time / Australia - { 111, 32, 5731 }, // Tocantins Standard Time / Brazil - { 112, 0, 5749 }, // Tokyo Standard Time / AnyTerritory - { 112, 111, 5759 }, // Tokyo Standard Time / Indonesia - { 112, 120, 5773 }, // Tokyo Standard Time / Japan - { 112, 179, 5784 }, // Tokyo Standard Time / Palau - { 112, 232, 5798 }, // Tokyo Standard Time / Timor-Leste - { 113, 193, 5808 }, // Tomsk Standard Time / Russia - { 114, 235, 5819 }, // Tonga Standard Time / Tonga - { 115, 193, 5837 }, // Transbaikal Standard Time / Russia - { 116, 239, 5848 }, // Turkey Standard Time / Turkey - { 117, 241, 5864 }, // Turks And Caicos Standard Time / Turks and Caicos Islands - { 118, 156, 5883 }, // Ulaanbaatar Standard Time / Mongolia - { 119, 248, 5916 }, // US Eastern Standard Time / United States - { 120, 0, 5983 }, // US Mountain Standard Time / AnyTerritory - { 120, 41, 5993 }, // US Mountain Standard Time / Canada - { 120, 152, 6050 }, // US Mountain Standard Time / Mexico - { 120, 248, 6069 }, // US Mountain Standard Time / United States - { 121, 0, 6085 }, // UTC / AnyTerritory - { 122, 0, 6101 }, // UTC+12 / AnyTerritory - { 122, 125, 6112 }, // UTC+12 / Kiribati - { 122, 147, 6127 }, // UTC+12 / Marshall Islands - { 122, 163, 6160 }, // UTC+12 / Nauru - { 122, 242, 6174 }, // UTC+12 / Tuvalu - { 122, 247, 6191 }, // UTC+12 / United States Outlying Islands - { 122, 256, 6204 }, // UTC+12 / Wallis and Futuna - { 123, 0, 6219 }, // UTC+13 / AnyTerritory - { 123, 125, 6230 }, // UTC+13 / Kiribati - { 123, 234, 6248 }, // UTC+13 / Tokelau - { 124, 0, 6264 }, // UTC-02 / AnyTerritory - { 124, 32, 6274 }, // UTC-02 / Brazil - { 124, 217, 6290 }, // UTC-02 / South Georgia and South Sandwich Islands - { 125, 0, 6313 }, // UTC-08 / AnyTerritory - { 125, 186, 6323 }, // UTC-08 / Pitcairn - { 126, 0, 6340 }, // UTC-09 / AnyTerritory - { 126, 86, 6350 }, // UTC-09 / French Polynesia - { 127, 0, 6366 }, // UTC-11 / AnyTerritory - { 127, 5, 6377 }, // UTC-11 / American Samoa - { 127, 171, 6395 }, // UTC-11 / Niue - { 127, 247, 6408 }, // UTC-11 / United States Outlying Islands - { 128, 254, 6423 }, // Venezuela Standard Time / Venezuela - { 129, 193, 6439 }, // Vladivostok Standard Time / Russia - { 130, 193, 6470 }, // Volgograd Standard Time / Russia - { 131, 15, 6487 }, // W. Australia Standard Time / Australia - { 132, 0, 6503 }, // W. Central Africa Standard Time / AnyTerritory - { 132, 4, 6513 }, // W. Central Africa Standard Time / Algeria - { 132, 7, 6528 }, // W. Central Africa Standard Time / Angola - { 132, 25, 6542 }, // W. Central Africa Standard Time / Benin - { 132, 40, 6560 }, // W. Central Africa Standard Time / Cameroon - { 132, 46, 6574 }, // W. Central Africa Standard Time / Central African Republic - { 132, 48, 6588 }, // W. Central Africa Standard Time / Chad - { 132, 56, 6604 }, // W. Central Africa Standard Time / Congo - Brazzaville - { 132, 57, 6623 }, // W. Central Africa Standard Time / Congo - Kinshasa - { 132, 73, 6639 }, // W. Central Africa Standard Time / Equatorial Guinea - { 132, 88, 6653 }, // W. Central Africa Standard Time / Gabon - { 132, 169, 6671 }, // W. Central Africa Standard Time / Nigeria - { 132, 170, 6684 }, // W. Central Africa Standard Time / Niger - { 132, 238, 6698 }, // W. Central Africa Standard Time / Tunisia - { 133, 6, 6711 }, // W. Europe Standard Time / Andorra - { 133, 16, 6726 }, // W. Europe Standard Time / Austria - { 133, 91, 6740 }, // W. Europe Standard Time / Germany - { 133, 93, 6770 }, // W. Europe Standard Time / Gibraltar - { 133, 117, 6787 }, // W. Europe Standard Time / Italy - { 133, 136, 6799 }, // W. Europe Standard Time / Liechtenstein - { 133, 138, 6812 }, // W. Europe Standard Time / Luxembourg - { 133, 146, 6830 }, // W. Europe Standard Time / Malta - { 133, 155, 6843 }, // W. Europe Standard Time / Monaco - { 133, 165, 6857 }, // W. Europe Standard Time / Netherlands - { 133, 175, 6874 }, // W. Europe Standard Time / Norway - { 133, 203, 6886 }, // W. Europe Standard Time / San Marino - { 133, 224, 6904 }, // W. Europe Standard Time / Svalbard and Jan Mayen - { 133, 225, 6924 }, // W. Europe Standard Time / Sweden - { 133, 226, 6941 }, // W. Europe Standard Time / Switzerland - { 133, 253, 6955 }, // W. Europe Standard Time / Vatican City - { 134, 156, 6970 }, // W. Mongolia Standard Time / Mongolia - { 135, 0, 6980 }, // West Asia Standard Time / AnyTerritory - { 135, 9, 6990 }, // West Asia Standard Time / Antarctica - { 135, 87, 7008 }, // West Asia Standard Time / French Southern Territories - { 135, 123, 7025 }, // West Asia Standard Time / Kazakhstan - { 135, 144, 7070 }, // West Asia Standard Time / Maldives - { 135, 229, 7086 }, // West Asia Standard Time / Tajikistan - { 135, 240, 7100 }, // West Asia Standard Time / Turkmenistan - { 135, 251, 7114 }, // West Asia Standard Time / Uzbekistan - { 136, 180, 7143 }, // West Bank Standard Time / Palestinian Territories - { 137, 0, 7165 }, // West Pacific Standard Time / AnyTerritory - { 137, 9, 7176 }, // West Pacific Standard Time / Antarctica - { 137, 98, 7202 }, // West Pacific Standard Time / Guam - { 137, 153, 7215 }, // West Pacific Standard Time / Micronesia - { 137, 173, 7228 }, // West Pacific Standard Time / Northern Mariana Islands - { 137, 182, 7243 }, // West Pacific Standard Time / Papua New Guinea - { 138, 193, 7264 }, // Yakutsk Standard Time / Russia - { 139, 41, 7291 }, // Yukon Standard Time / Canada + { 9, 193, 559 }, // Astrakhan Standard Time / Russia + { 10, 26, 593 }, // Atlantic Standard Time / Bermuda + { 10, 41, 610 }, // Atlantic Standard Time / Canada + { 10, 95, 678 }, // Atlantic Standard Time / Greenland + { 11, 15, 692 }, // AUS Central Standard Time / Australia + { 12, 15, 709 }, // Aus Central W. Standard Time / Australia + { 13, 15, 725 }, // AUS Eastern Standard Time / Australia + { 14, 17, 762 }, // Azerbaijan Standard Time / Azerbaijan + { 15, 95, 772 }, // Azores Standard Time / Greenland + { 15, 188, 793 }, // Azores Standard Time / Portugal + { 16, 32, 809 }, // Bahia Standard Time / Brazil + { 17, 20, 823 }, // Bangladesh Standard Time / Bangladesh + { 17, 27, 834 }, // Bangladesh Standard Time / Bhutan + { 18, 22, 847 }, // Belarus Standard Time / Belarus + { 19, 182, 860 }, // Bougainville Standard Time / Papua New Guinea + { 20, 41, 881 }, // Canada Central Standard Time / Canada + { 21, 0, 918 }, // Cape Verde Standard Time / AnyTerritory + { 21, 43, 928 }, // Cape Verde Standard Time / Cape Verde + { 22, 12, 948 }, // Caucasus Standard Time / Armenia + { 23, 15, 961 }, // Cen. Australia Standard Time / Australia + { 24, 0, 1002 }, // Central America Standard Time / AnyTerritory + { 24, 24, 1012 }, // Central America Standard Time / Belize + { 24, 59, 1027 }, // Central America Standard Time / Costa Rica + { 24, 70, 1046 }, // Central America Standard Time / Ecuador + { 24, 72, 1064 }, // Central America Standard Time / El Salvador + { 24, 99, 1084 }, // Central America Standard Time / Guatemala + { 24, 106, 1102 }, // Central America Standard Time / Honduras + { 24, 168, 1122 }, // Central America Standard Time / Nicaragua + { 25, 0, 1138 }, // Central Asia Standard Time / AnyTerritory + { 25, 9, 1148 }, // Central Asia Standard Time / Antarctica + { 25, 33, 1166 }, // Central Asia Standard Time / British Indian Ocean Territory + { 25, 50, 1180 }, // Central Asia Standard Time / China + { 25, 123, 1192 }, // Central Asia Standard Time / Kazakhstan + { 25, 128, 1218 }, // Central Asia Standard Time / Kyrgyzstan + { 26, 32, 1231 }, // Central Brazilian Standard Time / Brazil + { 27, 3, 1267 }, // Central Europe Standard Time / Albania + { 27, 64, 1281 }, // Central Europe Standard Time / Czechia + { 27, 108, 1295 }, // Central Europe Standard Time / Hungary + { 27, 157, 1311 }, // Central Europe Standard Time / Montenegro + { 27, 207, 1328 }, // Central Europe Standard Time / Serbia + { 27, 212, 1344 }, // Central Europe Standard Time / Slovakia + { 27, 213, 1362 }, // Central Europe Standard Time / Slovenia + { 28, 29, 1379 }, // Central European Standard Time / Bosnia and Herzegovina + { 28, 60, 1395 }, // Central European Standard Time / Croatia + { 28, 140, 1409 }, // Central European Standard Time / Macedonia + { 28, 187, 1423 }, // Central European Standard Time / Poland + { 29, 0, 1437 }, // Central Pacific Standard Time / AnyTerritory + { 29, 9, 1448 }, // Central Pacific Standard Time / Antarctica + { 29, 153, 1465 }, // Central Pacific Standard Time / Micronesia + { 29, 166, 1496 }, // Central Pacific Standard Time / New Caledonia + { 29, 214, 1511 }, // Central Pacific Standard Time / Solomon Islands + { 29, 252, 1531 }, // Central Pacific Standard Time / Vanuatu + { 30, 0, 1545 }, // Central Standard Time / AnyTerritory + { 30, 41, 1553 }, // Central Standard Time / Canada + { 30, 152, 1608 }, // Central Standard Time / Mexico + { 30, 248, 1642 }, // Central Standard Time / United States + { 31, 152, 1810 }, // Central Standard Time (Mexico) / Mexico + { 32, 167, 1904 }, // Chatham Islands Standard Time / New Zealand + { 33, 50, 1920 }, // China Standard Time / China + { 33, 107, 1934 }, // China Standard Time / Hong Kong + { 33, 139, 1949 }, // China Standard Time / Macao + { 34, 61, 1960 }, // Cuba Standard Time / Cuba + { 35, 0, 1975 }, // Dateline Standard Time / AnyTerritory + { 36, 0, 1986 }, // E. Africa Standard Time / AnyTerritory + { 36, 9, 1996 }, // E. Africa Standard Time / Antarctica + { 36, 55, 2013 }, // E. Africa Standard Time / Comoros + { 36, 67, 2027 }, // E. Africa Standard Time / Djibouti + { 36, 74, 2043 }, // E. Africa Standard Time / Eritrea + { 36, 77, 2057 }, // E. Africa Standard Time / Ethiopia + { 36, 124, 2076 }, // E. Africa Standard Time / Kenya + { 36, 141, 2091 }, // E. Africa Standard Time / Madagascar + { 36, 151, 2111 }, // E. Africa Standard Time / Mayotte + { 36, 215, 2126 }, // E. Africa Standard Time / Somalia + { 36, 230, 2143 }, // E. Africa Standard Time / Tanzania + { 36, 243, 2164 }, // E. Africa Standard Time / Uganda + { 37, 15, 2179 }, // E. Australia Standard Time / Australia + { 38, 154, 2217 }, // E. Europe Standard Time / Moldova + { 39, 32, 2233 }, // E. South America Standard Time / Brazil + { 40, 49, 2251 }, // Easter Island Standard Time / Chile + { 41, 0, 2266 }, // Eastern Standard Time / AnyTerritory + { 41, 18, 2274 }, // Eastern Standard Time / Bahamas + { 41, 41, 2289 }, // Eastern Standard Time / Canada + { 41, 248, 2321 }, // Eastern Standard Time / United States + { 42, 152, 2487 }, // Eastern Standard Time (Mexico) / Mexico + { 43, 71, 2502 }, // Egypt Standard Time / Egypt + { 44, 193, 2515 }, // Ekaterinburg Standard Time / Russia + { 45, 82, 2534 }, // Fiji Standard Time / Fiji + { 46, 2, 2547 }, // FLE Standard Time / Aland Islands + { 46, 36, 2564 }, // FLE Standard Time / Bulgaria + { 46, 75, 2577 }, // FLE Standard Time / Estonia + { 46, 83, 2592 }, // FLE Standard Time / Finland + { 46, 131, 2608 }, // FLE Standard Time / Latvia + { 46, 137, 2620 }, // FLE Standard Time / Lithuania + { 46, 244, 2635 }, // FLE Standard Time / Ukraine + { 47, 90, 2647 }, // Georgian Standard Time / Georgia + { 48, 81, 2660 }, // GMT Standard Time / Faroe Islands + { 48, 100, 2675 }, // GMT Standard Time / Guernsey + { 48, 114, 2691 }, // GMT Standard Time / Ireland + { 48, 115, 2705 }, // GMT Standard Time / Isle of Man + { 48, 121, 2724 }, // GMT Standard Time / Jersey + { 48, 188, 2738 }, // GMT Standard Time / Portugal + { 48, 220, 2769 }, // GMT Standard Time / Spain + { 48, 246, 2785 }, // GMT Standard Time / United Kingdom + { 49, 95, 2799 }, // Greenland Standard Time / Greenland + { 50, 37, 2812 }, // Greenwich Standard Time / Burkina Faso + { 50, 89, 2831 }, // Greenwich Standard Time / Gambia + { 50, 92, 2845 }, // Greenwich Standard Time / Ghana + { 50, 95, 2858 }, // Greenwich Standard Time / Greenland + { 50, 101, 2879 }, // Greenwich Standard Time / Guinea-Bissau + { 50, 102, 2893 }, // Greenwich Standard Time / Guinea + { 50, 109, 2908 }, // Greenwich Standard Time / Iceland + { 50, 118, 2927 }, // Greenwich Standard Time / Ivory Coast + { 50, 134, 2942 }, // Greenwich Standard Time / Liberia + { 50, 145, 2958 }, // Greenwich Standard Time / Mali + { 50, 149, 2972 }, // Greenwich Standard Time / Mauritania + { 50, 196, 2990 }, // Greenwich Standard Time / Saint Helena + { 50, 206, 3009 }, // Greenwich Standard Time / Senegal + { 50, 209, 3022 }, // Greenwich Standard Time / Sierra Leone + { 50, 233, 3038 }, // Greenwich Standard Time / Togo + { 51, 63, 3050 }, // GTB Standard Time / Cyprus + { 51, 94, 3078 }, // GTB Standard Time / Greece + { 51, 192, 3092 }, // GTB Standard Time / Romania + { 52, 104, 3109 }, // Haiti Standard Time / Haiti + { 53, 0, 3132 }, // Hawaiian Standard Time / AnyTerritory + { 53, 58, 3143 }, // Hawaiian Standard Time / Cook Islands + { 53, 86, 3161 }, // Hawaiian Standard Time / French Polynesia + { 53, 247, 3176 }, // Hawaiian Standard Time / United States Outlying Islands + { 53, 248, 3176 }, // Hawaiian Standard Time / United States + { 54, 110, 3193 }, // India Standard Time / India + { 55, 112, 3206 }, // Iran Standard Time / Iran + { 56, 116, 3218 }, // Israel Standard Time / Israel + { 57, 122, 3233 }, // Jordan Standard Time / Jordan + { 58, 193, 3244 }, // Kaliningrad Standard Time / Russia + { 59, 218, 3263 }, // Korea Standard Time / South Korea + { 60, 135, 3274 }, // Libya Standard Time / Libya + { 61, 0, 3289 }, // Line Islands Standard Time / AnyTerritory + { 61, 125, 3300 }, // Line Islands Standard Time / Kiribati + { 62, 15, 3319 }, // Lord Howe Standard Time / Australia + { 63, 193, 3339 }, // Magadan Standard Time / Russia + { 64, 49, 3352 }, // Magallanes Standard Time / Chile + { 65, 86, 3373 }, // Marquesas Standard Time / French Polynesia + { 66, 150, 3391 }, // Mauritius Standard Time / Mauritius + { 66, 191, 3408 }, // Mauritius Standard Time / Reunion + { 66, 208, 3423 }, // Mauritius Standard Time / Seychelles + { 67, 132, 3435 }, // Middle East Standard Time / Lebanon + { 68, 250, 3447 }, // Montevideo Standard Time / Uruguay + { 69, 159, 3466 }, // Morocco Standard Time / Morocco + { 69, 257, 3484 }, // Morocco Standard Time / Western Sahara + { 70, 0, 3500 }, // Mountain Standard Time / AnyTerritory + { 70, 41, 3508 }, // Mountain Standard Time / Canada + { 70, 152, 3562 }, // Mountain Standard Time / Mexico + { 70, 248, 3584 }, // Mountain Standard Time / United States + { 71, 152, 3613 }, // Mountain Standard Time (Mexico) / Mexico + { 72, 53, 3630 }, // Myanmar Standard Time / Cocos Islands + { 72, 161, 3643 }, // Myanmar Standard Time / Myanmar + { 73, 193, 3655 }, // N. Central Asia Standard Time / Russia + { 74, 162, 3672 }, // Namibia Standard Time / Namibia + { 75, 164, 3688 }, // Nepal Standard Time / Nepal + { 76, 9, 3703 }, // New Zealand Standard Time / Antarctica + { 76, 167, 3722 }, // New Zealand Standard Time / New Zealand + { 77, 41, 3739 }, // Newfoundland Standard Time / Canada + { 78, 172, 3756 }, // Norfolk Standard Time / Norfolk Island + { 79, 193, 3772 }, // North Asia East Standard Time / Russia + { 80, 193, 3785 }, // North Asia Standard Time / Russia + { 81, 174, 3820 }, // North Korea Standard Time / North Korea + { 82, 193, 3835 }, // Omsk Standard Time / Russia + { 83, 49, 3845 }, // Pacific SA Standard Time / Chile + { 84, 0, 3862 }, // Pacific Standard Time / AnyTerritory + { 84, 41, 3870 }, // Pacific Standard Time / Canada + { 84, 248, 3888 }, // Pacific Standard Time / United States + { 85, 152, 3908 }, // Pacific Standard Time (Mexico) / Mexico + { 86, 178, 3924 }, // Pakistan Standard Time / Pakistan + { 87, 183, 3937 }, // Paraguay Standard Time / Paraguay + { 88, 123, 3954 }, // Qyzylorda Standard Time / Kazakhstan + { 89, 23, 3969 }, // Romance Standard Time / Belgium + { 89, 65, 3985 }, // Romance Standard Time / Denmark + { 89, 84, 4003 }, // Romance Standard Time / France + { 89, 220, 4016 }, // Romance Standard Time / Spain + { 90, 193, 4043 }, // Russia Time Zone 10 / Russia + { 91, 193, 4062 }, // Russia Time Zone 11 / Russia + { 92, 193, 4089 }, // Russia Time Zone 3 / Russia + { 93, 193, 4103 }, // Russian Standard Time / Russia + { 93, 244, 4130 }, // Russian Standard Time / Ukraine + { 94, 0, 4148 }, // SA Eastern Standard Time / AnyTerritory + { 94, 9, 4158 }, // SA Eastern Standard Time / Antarctica + { 94, 32, 4195 }, // SA Eastern Standard Time / Brazil + { 94, 80, 4274 }, // SA Eastern Standard Time / Falkland Islands + { 94, 85, 4291 }, // SA Eastern Standard Time / French Guiana + { 94, 223, 4307 }, // SA Eastern Standard Time / Suriname + { 95, 0, 4326 }, // SA Pacific Standard Time / AnyTerritory + { 95, 32, 4336 }, // SA Pacific Standard Time / Brazil + { 95, 41, 4372 }, // SA Pacific Standard Time / Canada + { 95, 45, 4389 }, // SA Pacific Standard Time / Cayman Islands + { 95, 54, 4404 }, // SA Pacific Standard Time / Colombia + { 95, 70, 4419 }, // SA Pacific Standard Time / Ecuador + { 95, 119, 4437 }, // SA Pacific Standard Time / Jamaica + { 95, 181, 4453 }, // SA Pacific Standard Time / Panama + { 95, 184, 4468 }, // SA Pacific Standard Time / Peru + { 96, 0, 4481 }, // SA Western Standard Time / AnyTerritory + { 96, 8, 4491 }, // SA Western Standard Time / Anguilla + { 96, 10, 4508 }, // SA Western Standard Time / Antigua and Barbuda + { 96, 13, 4524 }, // SA Western Standard Time / Aruba + { 96, 21, 4538 }, // SA Western Standard Time / Barbados + { 96, 28, 4555 }, // SA Western Standard Time / Bolivia + { 96, 32, 4570 }, // SA Western Standard Time / Brazil + { 96, 34, 4623 }, // SA Western Standard Time / British Virgin Islands + { 96, 41, 4639 }, // SA Western Standard Time / Canada + { 96, 44, 4660 }, // SA Western Standard Time / Caribbean Netherlands + { 96, 62, 4679 }, // SA Western Standard Time / Curacao + { 96, 68, 4695 }, // SA Western Standard Time / Dominica + { 96, 69, 4712 }, // SA Western Standard Time / Dominican Republic + { 96, 96, 4734 }, // SA Western Standard Time / Grenada + { 96, 97, 4750 }, // SA Western Standard Time / Guadeloupe + { 96, 103, 4769 }, // SA Western Standard Time / Guyana + { 96, 148, 4784 }, // SA Western Standard Time / Martinique + { 96, 158, 4803 }, // SA Western Standard Time / Montserrat + { 96, 189, 4822 }, // SA Western Standard Time / Puerto Rico + { 96, 195, 4842 }, // SA Western Standard Time / Saint Barthelemy + { 96, 197, 4864 }, // SA Western Standard Time / Saint Kitts and Nevis + { 96, 198, 4881 }, // SA Western Standard Time / Saint Lucia + { 96, 199, 4898 }, // SA Western Standard Time / Saint Martin + { 96, 201, 4914 }, // SA Western Standard Time / Saint Vincent and Grenadines + { 96, 211, 4933 }, // SA Western Standard Time / Sint Maarten + { 96, 236, 4955 }, // SA Western Standard Time / Trinidad and Tobago + { 96, 249, 4977 }, // SA Western Standard Time / United States Virgin Islands + { 97, 200, 4995 }, // Saint Pierre Standard Time / Saint Pierre and Miquelon + { 98, 193, 5012 }, // Sakhalin Standard Time / Russia + { 99, 202, 5026 }, // Samoa Standard Time / Samoa + { 100, 204, 5039 }, // Sao Tome Standard Time / Sao Tome and Principe + { 101, 193, 5055 }, // Saratov Standard Time / Russia + { 102, 0, 5070 }, // SE Asia Standard Time / AnyTerritory + { 102, 9, 5080 }, // SE Asia Standard Time / Antarctica + { 102, 39, 5097 }, // SE Asia Standard Time / Cambodia + { 102, 51, 5113 }, // SE Asia Standard Time / Christmas Island + { 102, 111, 5130 }, // SE Asia Standard Time / Indonesia + { 102, 129, 5158 }, // SE Asia Standard Time / Laos + { 102, 231, 5173 }, // SE Asia Standard Time / Thailand + { 102, 255, 5186 }, // SE Asia Standard Time / Vietnam + { 103, 0, 5203 }, // Singapore Standard Time / AnyTerritory + { 103, 35, 5213 }, // Singapore Standard Time / Brunei + { 103, 111, 5225 }, // Singapore Standard Time / Indonesia + { 103, 143, 5239 }, // Singapore Standard Time / Malaysia + { 103, 185, 5270 }, // Singapore Standard Time / Philippines + { 103, 210, 5282 }, // Singapore Standard Time / Singapore + { 104, 0, 5297 }, // South Africa Standard Time / AnyTerritory + { 104, 30, 5307 }, // South Africa Standard Time / Botswana + { 104, 38, 5323 }, // South Africa Standard Time / Burundi + { 104, 57, 5340 }, // South Africa Standard Time / Congo - Kinshasa + { 104, 76, 5358 }, // South Africa Standard Time / Eswatini + { 104, 133, 5373 }, // South Africa Standard Time / Lesotho + { 104, 142, 5387 }, // South Africa Standard Time / Malawi + { 104, 160, 5403 }, // South Africa Standard Time / Mozambique + { 104, 194, 5417 }, // South Africa Standard Time / Rwanda + { 104, 216, 5431 }, // South Africa Standard Time / South Africa + { 104, 260, 5451 }, // South Africa Standard Time / Zambia + { 104, 261, 5465 }, // South Africa Standard Time / Zimbabwe + { 105, 219, 5479 }, // South Sudan Standard Time / South Sudan + { 106, 221, 5491 }, // Sri Lanka Standard Time / Sri Lanka + { 107, 222, 5504 }, // Sudan Standard Time / Sudan + { 108, 227, 5520 }, // Syria Standard Time / Syria + { 109, 228, 5534 }, // Taipei Standard Time / Taiwan + { 110, 15, 5546 }, // Tasmania Standard Time / Australia + { 111, 32, 5584 }, // Tocantins Standard Time / Brazil + { 112, 0, 5602 }, // Tokyo Standard Time / AnyTerritory + { 112, 111, 5612 }, // Tokyo Standard Time / Indonesia + { 112, 120, 5626 }, // Tokyo Standard Time / Japan + { 112, 179, 5637 }, // Tokyo Standard Time / Palau + { 112, 232, 5651 }, // Tokyo Standard Time / Timor-Leste + { 113, 193, 5661 }, // Tomsk Standard Time / Russia + { 114, 235, 5672 }, // Tonga Standard Time / Tonga + { 115, 193, 5690 }, // Transbaikal Standard Time / Russia + { 116, 239, 5701 }, // Turkey Standard Time / Turkey + { 117, 241, 5717 }, // Turks And Caicos Standard Time / Turks and Caicos Islands + { 118, 156, 5736 }, // Ulaanbaatar Standard Time / Mongolia + { 119, 248, 5769 }, // US Eastern Standard Time / United States + { 120, 0, 5844 }, // US Mountain Standard Time / AnyTerritory + { 120, 41, 5854 }, // US Mountain Standard Time / Canada + { 120, 152, 5911 }, // US Mountain Standard Time / Mexico + { 120, 248, 5930 }, // US Mountain Standard Time / United States + { 121, 0, 5946 }, // UTC / AnyTerritory + { 122, 0, 5962 }, // UTC+12 / AnyTerritory + { 122, 125, 5973 }, // UTC+12 / Kiribati + { 122, 147, 5988 }, // UTC+12 / Marshall Islands + { 122, 163, 6021 }, // UTC+12 / Nauru + { 122, 242, 6035 }, // UTC+12 / Tuvalu + { 122, 247, 6052 }, // UTC+12 / United States Outlying Islands + { 122, 256, 6065 }, // UTC+12 / Wallis and Futuna + { 123, 0, 6080 }, // UTC+13 / AnyTerritory + { 123, 125, 6091 }, // UTC+13 / Kiribati + { 123, 234, 6106 }, // UTC+13 / Tokelau + { 124, 0, 6122 }, // UTC-02 / AnyTerritory + { 124, 32, 6132 }, // UTC-02 / Brazil + { 124, 217, 6148 }, // UTC-02 / South Georgia and South Sandwich Islands + { 125, 0, 6171 }, // UTC-08 / AnyTerritory + { 125, 186, 6181 }, // UTC-08 / Pitcairn + { 126, 0, 6198 }, // UTC-09 / AnyTerritory + { 126, 86, 6208 }, // UTC-09 / French Polynesia + { 127, 0, 6224 }, // UTC-11 / AnyTerritory + { 127, 5, 6235 }, // UTC-11 / American Samoa + { 127, 171, 6253 }, // UTC-11 / Niue + { 127, 247, 6266 }, // UTC-11 / United States Outlying Islands + { 128, 254, 6281 }, // Venezuela Standard Time / Venezuela + { 129, 193, 6297 }, // Vladivostok Standard Time / Russia + { 130, 193, 6328 }, // Volgograd Standard Time / Russia + { 131, 15, 6345 }, // W. Australia Standard Time / Australia + { 132, 0, 6361 }, // W. Central Africa Standard Time / AnyTerritory + { 132, 4, 6371 }, // W. Central Africa Standard Time / Algeria + { 132, 7, 6386 }, // W. Central Africa Standard Time / Angola + { 132, 25, 6400 }, // W. Central Africa Standard Time / Benin + { 132, 40, 6418 }, // W. Central Africa Standard Time / Cameroon + { 132, 46, 6432 }, // W. Central Africa Standard Time / Central African Republic + { 132, 48, 6446 }, // W. Central Africa Standard Time / Chad + { 132, 56, 6462 }, // W. Central Africa Standard Time / Congo - Brazzaville + { 132, 57, 6481 }, // W. Central Africa Standard Time / Congo - Kinshasa + { 132, 73, 6497 }, // W. Central Africa Standard Time / Equatorial Guinea + { 132, 88, 6511 }, // W. Central Africa Standard Time / Gabon + { 132, 169, 6529 }, // W. Central Africa Standard Time / Nigeria + { 132, 170, 6542 }, // W. Central Africa Standard Time / Niger + { 132, 238, 6556 }, // W. Central Africa Standard Time / Tunisia + { 133, 6, 6569 }, // W. Europe Standard Time / Andorra + { 133, 16, 6584 }, // W. Europe Standard Time / Austria + { 133, 91, 6598 }, // W. Europe Standard Time / Germany + { 133, 93, 6628 }, // W. Europe Standard Time / Gibraltar + { 133, 117, 6645 }, // W. Europe Standard Time / Italy + { 133, 136, 6657 }, // W. Europe Standard Time / Liechtenstein + { 133, 138, 6670 }, // W. Europe Standard Time / Luxembourg + { 133, 146, 6688 }, // W. Europe Standard Time / Malta + { 133, 155, 6701 }, // W. Europe Standard Time / Monaco + { 133, 165, 6715 }, // W. Europe Standard Time / Netherlands + { 133, 175, 6732 }, // W. Europe Standard Time / Norway + { 133, 203, 6744 }, // W. Europe Standard Time / San Marino + { 133, 224, 6762 }, // W. Europe Standard Time / Svalbard and Jan Mayen + { 133, 225, 6782 }, // W. Europe Standard Time / Sweden + { 133, 226, 6799 }, // W. Europe Standard Time / Switzerland + { 133, 253, 6813 }, // W. Europe Standard Time / Vatican City + { 134, 156, 6828 }, // W. Mongolia Standard Time / Mongolia + { 135, 0, 6838 }, // West Asia Standard Time / AnyTerritory + { 135, 9, 6848 }, // West Asia Standard Time / Antarctica + { 135, 87, 6866 }, // West Asia Standard Time / French Southern Territories + { 135, 123, 6883 }, // West Asia Standard Time / Kazakhstan + { 135, 144, 6928 }, // West Asia Standard Time / Maldives + { 135, 229, 6944 }, // West Asia Standard Time / Tajikistan + { 135, 240, 6958 }, // West Asia Standard Time / Turkmenistan + { 135, 251, 6972 }, // West Asia Standard Time / Uzbekistan + { 136, 180, 7001 }, // West Bank Standard Time / Palestinian Territories + { 137, 0, 7023 }, // West Pacific Standard Time / AnyTerritory + { 137, 9, 7034 }, // West Pacific Standard Time / Antarctica + { 137, 98, 7060 }, // West Pacific Standard Time / Guam + { 137, 153, 7073 }, // West Pacific Standard Time / Micronesia + { 137, 173, 7087 }, // West Pacific Standard Time / Northern Mariana Islands + { 137, 182, 7102 }, // West Pacific Standard Time / Papua New Guinea + { 138, 193, 7123 }, // Yakutsk Standard Time / Russia + { 139, 41, 7150 }, // Yukon Standard Time / Canada }; // Windows ID Key, Windows ID Index, IANA ID Index, UTC Offset static constexpr WindowsData windowsDataTable[] = { { 1, 0, 0, 16200 }, // Afghanistan Standard Time - { 2, 26, 7325,-32400 }, // Alaskan Standard Time + { 2, 26, 7184,-32400 }, // Alaskan Standard Time { 3, 48, 106,-36000 }, // Aleutian Standard Time { 4, 71, 119, 25200 }, // Altai Standard Time { 5, 91, 168, 10800 }, // Arab Standard Time { 6, 110, 212, 14400 }, // Arabian Standard Time { 7, 132, 223, 10800 }, // Arabic Standard Time - { 8, 153, 7343,-10800 }, // Argentina Standard Time - { 9, 177, 7364, 14400 }, // Astrakhan Standard Time - { 10, 201, 7381,-14400 }, // Atlantic Standard Time - { 11, 224, 642, 34200 }, // AUS Central Standard Time - { 12, 250, 659, 31500 }, // Aus Central W. Standard Time - { 13, 279, 7397, 36000 }, // AUS Eastern Standard Time - { 14, 305, 712, 14400 }, // Azerbaijan Standard Time - { 15, 330, 743, -3600 }, // Azores Standard Time - { 16, 351, 759,-10800 }, // Bahia Standard Time - { 17, 371, 773, 21600 }, // Bangladesh Standard Time - { 18, 396, 797, 10800 }, // Belarus Standard Time - { 19, 418, 810, 39600 }, // Bougainville Standard Time - { 20, 445, 7414,-21600 }, // Canada Central Standard Time - { 21, 474, 878, -3600 }, // Cape Verde Standard Time - { 22, 499, 898, 14400 }, // Caucasus Standard Time - { 23, 522, 7429, 34200 }, // Cen. Australia Standard Time - { 24, 551, 1034,-21600 }, // Central America Standard Time - { 25, 581, 7448, 21600 }, // Central Asia Standard Time - { 26, 608, 7460,-14400 }, // Central Brazilian Standard Time - { 27, 640, 1245, 3600 }, // Central Europe Standard Time - { 28, 669, 1373, 3600 }, // Central European Standard Time - { 29, 700, 1460, 39600 }, // Central Pacific Standard Time - { 30, 730, 7475,-21600 }, // Central Standard Time - { 31, 752, 7491,-21600 }, // Central Standard Time (Mexico) - { 32, 783, 1873, 45900 }, // Chatham Islands Standard Time - { 33, 813, 1889, 28800 }, // China Standard Time - { 34, 833, 1929,-18000 }, // Cuba Standard Time - { 35, 852, 1944,-43200 }, // Dateline Standard Time - { 36, 875, 2045, 10800 }, // E. Africa Standard Time - { 37, 899, 7511, 36000 }, // E. Australia Standard Time - { 38, 926, 2186, 7200 }, // E. Europe Standard Time - { 39, 950, 2202,-10800 }, // E. South America Standard Time - { 40, 981, 2220,-21600 }, // Easter Island Standard Time - { 41, 1009, 7530,-18000 }, // Eastern Standard Time - { 42, 1031, 2520,-18000 }, // Eastern Standard Time (Mexico) - { 43, 1062, 2535, 7200 }, // Egypt Standard Time - { 44, 1082, 2548, 18000 }, // Ekaterinburg Standard Time - { 45, 1109, 2567, 43200 }, // Fiji Standard Time - { 46, 1128, 7547, 7200 }, // FLE Standard Time - { 47, 1146, 2714, 14400 }, // Georgian Standard Time - { 48, 1169, 2853, 0 }, // GMT Standard Time - { 49, 1187, 2867,-10800 }, // Greenland Standard Time - { 50, 1211, 2979, 0 }, // Greenwich Standard Time - { 51, 1235, 3163, 7200 }, // GTB Standard Time - { 52, 1253, 3180,-18000 }, // Haiti Standard Time - { 53, 1273, 3264,-36000 }, // Hawaiian Standard Time - { 54, 1296, 3281, 19800 }, // India Standard Time - { 55, 1316, 3295, 12600 }, // Iran Standard Time - { 56, 1335, 3307, 7200 }, // Israel Standard Time - { 57, 1356, 3322, 7200 }, // Jordan Standard Time - { 58, 1377, 3333, 7200 }, // Kaliningrad Standard Time - { 59, 1403, 3352, 32400 }, // Korea Standard Time - { 60, 1423, 3363, 7200 }, // Libya Standard Time - { 61, 1443, 3389, 50400 }, // Line Islands Standard Time - { 62, 1470, 3408, 37800 }, // Lord Howe Standard Time - { 63, 1494, 3428, 36000 }, // Magadan Standard Time - { 64, 1516, 3441,-10800 }, // Magallanes Standard Time - { 65, 1541, 3462,-34200 }, // Marquesas Standard Time - { 66, 1565, 3480, 14400 }, // Mauritius Standard Time - { 67, 1589, 3524, 7200 }, // Middle East Standard Time - { 68, 1615, 3536,-10800 }, // Montevideo Standard Time - { 69, 1640, 3555, 0 }, // Morocco Standard Time - { 70, 1662, 7559,-25200 }, // Mountain Standard Time - { 71, 1685, 3722,-25200 }, // Mountain Standard Time (Mexico) - { 72, 1717, 3752, 23400 }, // Myanmar Standard Time - { 73, 1739, 3765, 21600 }, // N. Central Asia Standard Time - { 74, 1769, 3782, 3600 }, // Namibia Standard Time - { 75, 1791, 3798, 20700 }, // Nepal Standard Time - { 76, 1811, 3831, 43200 }, // New Zealand Standard Time - { 77, 1837, 3848,-12600 }, // Newfoundland Standard Time - { 78, 1864, 3865, 39600 }, // Norfolk Standard Time - { 79, 1886, 3881, 28800 }, // North Asia East Standard Time - { 80, 1916, 7574, 25200 }, // North Asia Standard Time - { 81, 1941, 3929, 30600 }, // North Korea Standard Time - { 82, 1967, 3944, 21600 }, // Omsk Standard Time - { 83, 1986, 3954,-10800 }, // Pacific SA Standard Time - { 84, 2011, 3997,-28800 }, // Pacific Standard Time - { 85, 2033, 7591,-28800 }, // Pacific Standard Time (Mexico) - { 86, 2064, 4054, 18000 }, // Pakistan Standard Time - { 87, 2087, 4067,-14400 }, // Paraguay Standard Time - { 88, 2110, 4084, 18000 }, // Qyzylorda Standard Time - { 89, 2134, 4133, 3600 }, // Romance Standard Time - { 90, 2156, 4173, 39600 }, // Russia Time Zone 10 - { 91, 2176, 7607, 43200 }, // Russia Time Zone 11 - { 92, 2196, 4219, 14400 }, // Russia Time Zone 3 - { 93, 2215, 7622, 10800 }, // Russian Standard Time - { 94, 2237, 4421,-10800 }, // SA Eastern Standard Time - { 95, 2262, 4539,-18000 }, // SA Pacific Standard Time - { 96, 2287, 4690,-14400 }, // SA Western Standard Time - { 97, 2312, 5130,-10800 }, // Saint Pierre Standard Time - { 98, 2339, 5147, 39600 }, // Sakhalin Standard Time - { 99, 2362, 5161, 46800 }, // Samoa Standard Time - { 100, 2382, 5174, 0 }, // Sao Tome Standard Time - { 101, 2405, 5190, 14400 }, // Saratov Standard Time - { 102, 2427, 5308, 25200 }, // SE Asia Standard Time - { 103, 2449, 5412, 28800 }, // Singapore Standard Time - { 104, 2473, 5561, 7200 }, // South Africa Standard Time - { 105, 2500, 5609, 7200 }, // South Sudan Standard Time - { 106, 2526, 5621, 19800 }, // Sri Lanka Standard Time - { 107, 2550, 5634, 7200 }, // Sudan Standard Time - { 108, 2570, 5650, 7200 }, // Syria Standard Time - { 109, 2590, 5664, 28800 }, // Taipei Standard Time - { 110, 2611, 7636, 36000 }, // Tasmania Standard Time - { 111, 2634, 5731,-10800 }, // Tocantins Standard Time - { 112, 2658, 5773, 32400 }, // Tokyo Standard Time - { 113, 2678, 5808, 25200 }, // Tomsk Standard Time - { 114, 2698, 5819, 46800 }, // Tonga Standard Time - { 115, 2718, 5837, 32400 }, // Transbaikal Standard Time - { 116, 2744, 5848, 7200 }, // Turkey Standard Time - { 117, 2765, 5864,-14400 }, // Turks And Caicos Standard Time - { 118, 2796, 7653, 28800 }, // Ulaanbaatar Standard Time - { 119, 2822, 7670,-18000 }, // US Eastern Standard Time - { 120, 2847, 6069,-25200 }, // US Mountain Standard Time - { 121, 2873, 7691, 0 }, // UTC - { 122, 2877, 6101, 43200 }, // UTC+12 - { 123, 2884, 6219, 46800 }, // UTC+13 - { 124, 2891, 6264, -7200 }, // UTC-02 - { 125, 2898, 6313,-28800 }, // UTC-08 - { 126, 2905, 6340,-32400 }, // UTC-09 - { 127, 2912, 6366,-39600 }, // UTC-11 - { 128, 2919, 6423,-16200 }, // Venezuela Standard Time - { 129, 2943, 7699, 36000 }, // Vladivostok Standard Time - { 130, 2969, 6470, 14400 }, // Volgograd Standard Time - { 131, 2993, 6487, 28800 }, // W. Australia Standard Time - { 132, 3020, 6671, 3600 }, // W. Central Africa Standard Time - { 133, 3052, 7716, 3600 }, // W. Europe Standard Time - { 134, 3076, 6970, 25200 }, // W. Mongolia Standard Time - { 135, 3102, 7730, 18000 }, // West Asia Standard Time - { 136, 3126, 7744, 7200 }, // West Bank Standard Time - { 137, 3150, 7243, 36000 }, // West Pacific Standard Time - { 138, 3177, 7756, 32400 }, // Yakutsk Standard Time - { 139, 3199, 7769,-25200 }, // Yukon Standard Time + { 8, 153, 7202,-10800 }, // Argentina Standard Time + { 9, 177, 7233, 14400 }, // Astrakhan Standard Time + { 10, 201, 7250,-14400 }, // Atlantic Standard Time + { 11, 224, 692, 34200 }, // AUS Central Standard Time + { 12, 250, 709, 31500 }, // Aus Central W. Standard Time + { 13, 279, 7266, 36000 }, // AUS Eastern Standard Time + { 14, 305, 762, 14400 }, // Azerbaijan Standard Time + { 15, 330, 793, -3600 }, // Azores Standard Time + { 16, 351, 809,-10800 }, // Bahia Standard Time + { 17, 371, 823, 21600 }, // Bangladesh Standard Time + { 18, 396, 847, 10800 }, // Belarus Standard Time + { 19, 418, 860, 39600 }, // Bougainville Standard Time + { 20, 445, 7283,-21600 }, // Canada Central Standard Time + { 21, 474, 928, -3600 }, // Cape Verde Standard Time + { 22, 499, 948, 14400 }, // Caucasus Standard Time + { 23, 522, 7298, 34200 }, // Cen. Australia Standard Time + { 24, 551, 1084,-21600 }, // Central America Standard Time + { 25, 581, 7317, 21600 }, // Central Asia Standard Time + { 26, 608, 7329,-14400 }, // Central Brazilian Standard Time + { 27, 640, 1295, 3600 }, // Central Europe Standard Time + { 28, 669, 1423, 3600 }, // Central European Standard Time + { 29, 700, 1511, 39600 }, // Central Pacific Standard Time + { 30, 730, 7344,-21600 }, // Central Standard Time + { 31, 752, 7360,-21600 }, // Central Standard Time (Mexico) + { 32, 783, 1904, 45900 }, // Chatham Islands Standard Time + { 33, 813, 1920, 28800 }, // China Standard Time + { 34, 833, 1960,-18000 }, // Cuba Standard Time + { 35, 852, 1975,-43200 }, // Dateline Standard Time + { 36, 875, 2076, 10800 }, // E. Africa Standard Time + { 37, 899, 7380, 36000 }, // E. Australia Standard Time + { 38, 926, 2217, 7200 }, // E. Europe Standard Time + { 39, 950, 2233,-10800 }, // E. South America Standard Time + { 40, 981, 2251,-21600 }, // Easter Island Standard Time + { 41, 1009, 7399,-18000 }, // Eastern Standard Time + { 42, 1031, 2487,-18000 }, // Eastern Standard Time (Mexico) + { 43, 1062, 2502, 7200 }, // Egypt Standard Time + { 44, 1082, 2515, 18000 }, // Ekaterinburg Standard Time + { 45, 1109, 2534, 43200 }, // Fiji Standard Time + { 46, 1128, 2635, 7200 }, // FLE Standard Time + { 47, 1146, 2647, 14400 }, // Georgian Standard Time + { 48, 1169, 2785, 0 }, // GMT Standard Time + { 49, 1187, 2799,-10800 }, // Greenland Standard Time + { 50, 1211, 2908, 0 }, // Greenwich Standard Time + { 51, 1235, 3092, 7200 }, // GTB Standard Time + { 52, 1253, 3109,-18000 }, // Haiti Standard Time + { 53, 1273, 3176,-36000 }, // Hawaiian Standard Time + { 54, 1296, 3193, 19800 }, // India Standard Time + { 55, 1316, 3206, 12600 }, // Iran Standard Time + { 56, 1335, 3218, 7200 }, // Israel Standard Time + { 57, 1356, 3233, 7200 }, // Jordan Standard Time + { 58, 1377, 3244, 7200 }, // Kaliningrad Standard Time + { 59, 1403, 3263, 32400 }, // Korea Standard Time + { 60, 1423, 3274, 7200 }, // Libya Standard Time + { 61, 1443, 3300, 50400 }, // Line Islands Standard Time + { 62, 1470, 3319, 37800 }, // Lord Howe Standard Time + { 63, 1494, 3339, 36000 }, // Magadan Standard Time + { 64, 1516, 3352,-10800 }, // Magallanes Standard Time + { 65, 1541, 3373,-34200 }, // Marquesas Standard Time + { 66, 1565, 3391, 14400 }, // Mauritius Standard Time + { 67, 1589, 3435, 7200 }, // Middle East Standard Time + { 68, 1615, 3447,-10800 }, // Montevideo Standard Time + { 69, 1640, 3466, 0 }, // Morocco Standard Time + { 70, 1662, 7416,-25200 }, // Mountain Standard Time + { 71, 1685, 3613,-25200 }, // Mountain Standard Time (Mexico) + { 72, 1717, 3643, 23400 }, // Myanmar Standard Time + { 73, 1739, 3655, 21600 }, // N. Central Asia Standard Time + { 74, 1769, 3672, 3600 }, // Namibia Standard Time + { 75, 1791, 3688, 20700 }, // Nepal Standard Time + { 76, 1811, 3722, 43200 }, // New Zealand Standard Time + { 77, 1837, 3739,-12600 }, // Newfoundland Standard Time + { 78, 1864, 3756, 39600 }, // Norfolk Standard Time + { 79, 1886, 3772, 28800 }, // North Asia East Standard Time + { 80, 1916, 7431, 25200 }, // North Asia Standard Time + { 81, 1941, 3820, 30600 }, // North Korea Standard Time + { 82, 1967, 3835, 21600 }, // Omsk Standard Time + { 83, 1986, 3845,-10800 }, // Pacific SA Standard Time + { 84, 2011, 3888,-28800 }, // Pacific Standard Time + { 85, 2033, 3908,-28800 }, // Pacific Standard Time (Mexico) + { 86, 2064, 3924, 18000 }, // Pakistan Standard Time + { 87, 2087, 3937,-14400 }, // Paraguay Standard Time + { 88, 2110, 3954, 18000 }, // Qyzylorda Standard Time + { 89, 2134, 4003, 3600 }, // Romance Standard Time + { 90, 2156, 4043, 39600 }, // Russia Time Zone 10 + { 91, 2176, 7448, 43200 }, // Russia Time Zone 11 + { 92, 2196, 4089, 14400 }, // Russia Time Zone 3 + { 93, 2215, 7463, 10800 }, // Russian Standard Time + { 94, 2237, 4291,-10800 }, // SA Eastern Standard Time + { 95, 2262, 4404,-18000 }, // SA Pacific Standard Time + { 96, 2287, 4555,-14400 }, // SA Western Standard Time + { 97, 2312, 4995,-10800 }, // Saint Pierre Standard Time + { 98, 2339, 5012, 39600 }, // Sakhalin Standard Time + { 99, 2362, 5026, 46800 }, // Samoa Standard Time + { 100, 2382, 5039, 0 }, // Sao Tome Standard Time + { 101, 2405, 5055, 14400 }, // Saratov Standard Time + { 102, 2427, 5173, 25200 }, // SE Asia Standard Time + { 103, 2449, 5282, 28800 }, // Singapore Standard Time + { 104, 2473, 5431, 7200 }, // South Africa Standard Time + { 105, 2500, 5479, 7200 }, // South Sudan Standard Time + { 106, 2526, 5491, 19800 }, // Sri Lanka Standard Time + { 107, 2550, 5504, 7200 }, // Sudan Standard Time + { 108, 2570, 5520, 7200 }, // Syria Standard Time + { 109, 2590, 5534, 28800 }, // Taipei Standard Time + { 110, 2611, 7477, 36000 }, // Tasmania Standard Time + { 111, 2634, 5584,-10800 }, // Tocantins Standard Time + { 112, 2658, 5626, 32400 }, // Tokyo Standard Time + { 113, 2678, 5661, 25200 }, // Tomsk Standard Time + { 114, 2698, 5672, 46800 }, // Tonga Standard Time + { 115, 2718, 5690, 32400 }, // Transbaikal Standard Time + { 116, 2744, 5701, 7200 }, // Turkey Standard Time + { 117, 2765, 5717,-14400 }, // Turks And Caicos Standard Time + { 118, 2796, 7494, 28800 }, // Ulaanbaatar Standard Time + { 119, 2822, 7511,-18000 }, // US Eastern Standard Time + { 120, 2847, 5930,-25200 }, // US Mountain Standard Time + { 121, 2873, 7540, 0 }, // UTC + { 122, 2877, 5962, 43200 }, // UTC+12 + { 123, 2884, 6080, 46800 }, // UTC+13 + { 124, 2891, 6122, -7200 }, // UTC-02 + { 125, 2898, 6171,-28800 }, // UTC-08 + { 126, 2905, 6198,-32400 }, // UTC-09 + { 127, 2912, 6224,-39600 }, // UTC-11 + { 128, 2919, 6281,-16200 }, // Venezuela Standard Time + { 129, 2943, 7548, 36000 }, // Vladivostok Standard Time + { 130, 2969, 6328, 14400 }, // Volgograd Standard Time + { 131, 2993, 6345, 28800 }, // W. Australia Standard Time + { 132, 3020, 6529, 3600 }, // W. Central Africa Standard Time + { 133, 3052, 7565, 3600 }, // W. Europe Standard Time + { 134, 3076, 6828, 25200 }, // W. Mongolia Standard Time + { 135, 3102, 7579, 18000 }, // West Asia Standard Time + { 136, 3126, 7593, 7200 }, // West Bank Standard Time + { 137, 3150, 7102, 36000 }, // West Pacific Standard Time + { 138, 3177, 7605, 32400 }, // Yakutsk Standard Time + { 139, 3199, 7618,-25200 }, // Yukon Standard Time }; // IANA ID Index, UTC Offset static constexpr UtcData utcDataTable[] = { - { 7788,-50400 }, // UTC-14:00 - { 7798,-46800 }, // UTC-13:00 - { 7808,-43200 }, // UTC-12:00 - { 7818,-39600 }, // UTC-11:00 - { 7828,-36000 }, // UTC-10:00 - { 7838,-32400 }, // UTC-09:00 - { 7848,-28800 }, // UTC-08:00 - { 7858,-25200 }, // UTC-07:00 - { 7868,-21600 }, // UTC-06:00 - { 7878,-18000 }, // UTC-05:00 - { 7888,-16200 }, // UTC-04:30 - { 7898,-14400 }, // UTC-04:00 - { 7908,-12600 }, // UTC-03:30 - { 7918,-10800 }, // UTC-03:00 - { 7928, -7200 }, // UTC-02:00 - { 7938, -3600 }, // UTC-01:00 - { 7948, 0 }, // UTC - { 7972, 3600 }, // UTC+01:00 - { 7982, 7200 }, // UTC+02:00 - { 7992, 10800 }, // UTC+03:00 - { 8002, 12600 }, // UTC+03:30 - { 8012, 14400 }, // UTC+04:00 - { 8022, 16200 }, // UTC+04:30 - { 8032, 18000 }, // UTC+05:00 - { 8042, 19800 }, // UTC+05:30 - { 8052, 20700 }, // UTC+05:45 - { 8062, 21600 }, // UTC+06:00 - { 8072, 23400 }, // UTC+06:30 - { 8082, 25200 }, // UTC+07:00 - { 8092, 28800 }, // UTC+08:00 - { 8102, 30600 }, // UTC+08:30 - { 8112, 32400 }, // UTC+09:00 - { 8122, 34200 }, // UTC+09:30 - { 8132, 36000 }, // UTC+10:00 - { 8142, 39600 }, // UTC+11:00 - { 8152, 43200 }, // UTC+12:00 - { 8162, 46800 }, // UTC+13:00 - { 8172, 50400 }, // UTC+14:00 + { 7637,-50400 }, // UTC-14:00 + { 7647,-46800 }, // UTC-13:00 + { 7657,-43200 }, // UTC-12:00 + { 7667,-39600 }, // UTC-11:00 + { 7677,-36000 }, // UTC-10:00 + { 7687,-34200 }, // UTC-09:30 + { 7697,-32400 }, // UTC-09:00 + { 7707,-28800 }, // UTC-08:00 + { 7717,-25200 }, // UTC-07:00 + { 7727,-21600 }, // UTC-06:00 + { 7737,-18000 }, // UTC-05:00 + { 7747,-16200 }, // UTC-04:30 + { 7757,-14400 }, // UTC-04:00 + { 7767,-12600 }, // UTC-03:30 + { 7777,-10800 }, // UTC-03:00 + { 7787, -7200 }, // UTC-02:00 + { 7797, -3600 }, // UTC-01:00 + { 7807, 0 }, // UTC + { 7831, 3600 }, // UTC+01:00 + { 7841, 7200 }, // UTC+02:00 + { 7851, 10800 }, // UTC+03:00 + { 7861, 12600 }, // UTC+03:30 + { 7871, 14400 }, // UTC+04:00 + { 7881, 16200 }, // UTC+04:30 + { 7891, 18000 }, // UTC+05:00 + { 7901, 19800 }, // UTC+05:30 + { 7911, 20700 }, // UTC+05:45 + { 7921, 21600 }, // UTC+06:00 + { 7931, 23400 }, // UTC+06:30 + { 7941, 25200 }, // UTC+07:00 + { 7951, 28800 }, // UTC+08:00 + { 7961, 30600 }, // UTC+08:30 + { 7971, 31500 }, // UTC+08:45 + { 7981, 32400 }, // UTC+09:00 + { 7991, 34200 }, // UTC+09:30 + { 8001, 36000 }, // UTC+10:00 + { 8011, 37800 }, // UTC+10:30 + { 8021, 39600 }, // UTC+11:00 + { 8031, 43200 }, // UTC+12:00 + { 8041, 45900 }, // UTC+12:45 + { 8051, 46800 }, // UTC+13:00 + { 8061, 50400 }, // UTC+14:00 }; static constexpr char windowsIdData[] = { @@ -884,506 +1031,721 @@ static constexpr char ianaIdData[] = { 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x34, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4d, 0x75, 0x73, 0x63, 0x61, 0x74, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x44, 0x75, 0x62, 0x61, 0x69, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x42, 0x61, 0x67, 0x68, 0x64, 0x61, 0x64, 0x0, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x42, 0x75, 0x65, 0x6e, 0x6f, 0x73, 0x5f, 0x41, 0x69, 0x72, 0x65, 0x73, -0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, -0x6e, 0x61, 0x2f, 0x4c, 0x61, 0x5f, 0x52, 0x69, 0x6f, 0x6a, 0x61, 0x20, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x52, 0x69, -0x6f, 0x5f, 0x47, 0x61, 0x6c, 0x6c, 0x65, 0x67, 0x6f, 0x73, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x53, 0x61, 0x6c, -0x74, 0x61, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, -0x74, 0x69, 0x6e, 0x61, 0x2f, 0x53, 0x61, 0x6e, 0x5f, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x41, 0x6d, +0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x42, 0x75, +0x65, 0x6e, 0x6f, 0x73, 0x5f, 0x41, 0x69, 0x72, 0x65, 0x73, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x4c, 0x61, 0x5f, +0x52, 0x69, 0x6f, 0x6a, 0x61, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, +0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x52, 0x69, 0x6f, 0x5f, 0x47, 0x61, 0x6c, 0x6c, +0x65, 0x67, 0x6f, 0x73, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, +0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x53, 0x61, 0x6c, 0x74, 0x61, 0x20, 0x41, 0x6d, 0x65, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x53, +0x61, 0x6e, 0x5f, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, +0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x53, 0x61, 0x6e, 0x5f, 0x4c, 0x75, +0x69, 0x73, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, +0x74, 0x69, 0x6e, 0x61, 0x2f, 0x54, 0x75, 0x63, 0x75, 0x6d, 0x61, 0x6e, 0x20, 0x41, 0x6d, 0x65, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x55, +0x73, 0x68, 0x75, 0x61, 0x69, 0x61, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, +0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x43, 0x61, 0x74, 0x61, 0x6d, 0x61, 0x72, +0x63, 0x61, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, +0x74, 0x69, 0x6e, 0x61, 0x2f, 0x43, 0x6f, 0x72, 0x64, 0x6f, 0x62, 0x61, 0x20, 0x41, 0x6d, 0x65, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x4a, +0x75, 0x6a, 0x75, 0x79, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, +0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x4d, 0x65, 0x6e, 0x64, 0x6f, 0x7a, 0x61, 0x0, 0x45, +0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x41, 0x73, 0x74, 0x72, 0x61, 0x6b, 0x68, 0x61, 0x6e, 0x20, +0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x55, 0x6c, 0x79, 0x61, 0x6e, 0x6f, 0x76, 0x73, 0x6b, +0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x42, 0x65, 0x72, 0x6d, 0x75, 0x64, +0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x48, 0x61, 0x6c, 0x69, 0x66, 0x61, +0x78, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x47, 0x6c, 0x61, 0x63, 0x65, 0x5f, +0x42, 0x61, 0x79, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x47, 0x6f, 0x6f, 0x73, +0x65, 0x5f, 0x42, 0x61, 0x79, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x6f, +0x6e, 0x63, 0x74, 0x6f, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, 0x68, +0x75, 0x6c, 0x65, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x44, 0x61, +0x72, 0x77, 0x69, 0x6e, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x45, +0x75, 0x63, 0x6c, 0x61, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x53, +0x79, 0x64, 0x6e, 0x65, 0x79, 0x20, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, +0x4d, 0x65, 0x6c, 0x62, 0x6f, 0x75, 0x72, 0x6e, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x42, +0x61, 0x6b, 0x75, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x63, 0x6f, 0x72, +0x65, 0x73, 0x62, 0x79, 0x73, 0x75, 0x6e, 0x64, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, +0x63, 0x2f, 0x41, 0x7a, 0x6f, 0x72, 0x65, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x42, 0x61, 0x68, 0x69, 0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x44, 0x68, 0x61, 0x6b, +0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x54, 0x68, 0x69, 0x6d, 0x70, 0x68, 0x75, 0x0, 0x45, +0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x69, 0x6e, 0x73, 0x6b, 0x0, 0x50, 0x61, 0x63, 0x69, +0x66, 0x69, 0x63, 0x2f, 0x42, 0x6f, 0x75, 0x67, 0x61, 0x69, 0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65, +0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x65, 0x67, 0x69, 0x6e, 0x61, 0x20, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x43, 0x75, +0x72, 0x72, 0x65, 0x6e, 0x74, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x31, 0x0, +0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x43, 0x61, 0x70, 0x65, 0x5f, 0x56, 0x65, +0x72, 0x64, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x59, 0x65, 0x72, 0x65, 0x76, 0x61, 0x6e, +0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x41, 0x64, 0x65, 0x6c, 0x61, +0x69, 0x64, 0x65, 0x20, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x42, 0x72, +0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x48, 0x69, 0x6c, 0x6c, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, +0x54, 0x2b, 0x36, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x65, 0x6c, 0x69, +0x7a, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x6f, 0x73, 0x74, 0x61, +0x5f, 0x52, 0x69, 0x63, 0x61, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x47, 0x61, +0x6c, 0x61, 0x70, 0x61, 0x67, 0x6f, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, +0x45, 0x6c, 0x5f, 0x53, 0x61, 0x6c, 0x76, 0x61, 0x64, 0x6f, 0x72, 0x0, 0x41, 0x6d, 0x65, 0x72, +0x69, 0x63, 0x61, 0x2f, 0x47, 0x75, 0x61, 0x74, 0x65, 0x6d, 0x61, 0x6c, 0x61, 0x0, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, 0x65, 0x67, 0x75, 0x63, 0x69, 0x67, 0x61, 0x6c, 0x70, +0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x75, +0x61, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x36, 0x0, 0x41, 0x6e, 0x74, 0x61, +0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x56, 0x6f, 0x73, 0x74, 0x6f, 0x6b, 0x0, 0x49, 0x6e, +0x64, 0x69, 0x61, 0x6e, 0x2f, 0x43, 0x68, 0x61, 0x67, 0x6f, 0x73, 0x0, 0x41, 0x73, 0x69, 0x61, +0x2f, 0x55, 0x72, 0x75, 0x6d, 0x71, 0x69, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x41, 0x6c, 0x6d, +0x61, 0x74, 0x79, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x51, 0x6f, 0x73, 0x74, 0x61, 0x6e, 0x61, +0x79, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x42, 0x69, 0x73, 0x68, 0x6b, 0x65, 0x6b, 0x0, 0x41, +0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x75, 0x69, 0x61, 0x62, 0x61, 0x20, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x6d, 0x70, 0x6f, 0x5f, 0x47, 0x72, 0x61, 0x6e, +0x64, 0x65, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x54, 0x69, 0x72, 0x61, 0x6e, 0x65, +0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x50, 0x72, 0x61, 0x67, 0x75, 0x65, 0x0, 0x45, +0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x75, 0x64, 0x61, 0x70, 0x65, 0x73, 0x74, 0x0, 0x45, +0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x50, 0x6f, 0x64, 0x67, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x0, +0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x65, 0x6c, 0x67, 0x72, 0x61, 0x64, 0x65, 0x0, +0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x72, 0x61, 0x74, 0x69, 0x73, 0x6c, 0x61, 0x76, +0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4c, 0x6a, 0x75, 0x62, 0x6c, 0x6a, 0x61, +0x6e, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, 0x61, 0x72, 0x61, 0x6a, 0x65, +0x76, 0x6f, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x5a, 0x61, 0x67, 0x72, 0x65, 0x62, +0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, 0x6b, 0x6f, 0x70, 0x6a, 0x65, 0x0, 0x45, +0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x57, 0x61, 0x72, 0x73, 0x61, 0x77, 0x0, 0x45, 0x74, 0x63, +0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x31, 0x31, 0x0, 0x41, 0x6e, 0x74, 0x61, 0x72, 0x63, 0x74, 0x69, +0x63, 0x61, 0x2f, 0x43, 0x61, 0x73, 0x65, 0x79, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, +0x2f, 0x50, 0x6f, 0x68, 0x6e, 0x70, 0x65, 0x69, 0x20, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, +0x2f, 0x4b, 0x6f, 0x73, 0x72, 0x61, 0x65, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, +0x4e, 0x6f, 0x75, 0x6d, 0x65, 0x61, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x47, +0x75, 0x61, 0x64, 0x61, 0x6c, 0x63, 0x61, 0x6e, 0x61, 0x6c, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, +0x69, 0x63, 0x2f, 0x45, 0x66, 0x61, 0x74, 0x65, 0x0, 0x43, 0x53, 0x54, 0x36, 0x43, 0x44, 0x54, +0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x57, 0x69, 0x6e, 0x6e, 0x69, 0x70, 0x65, +0x67, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x61, 0x6e, 0x6b, 0x69, 0x6e, +0x5f, 0x49, 0x6e, 0x6c, 0x65, 0x74, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, +0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, +0x4d, 0x61, 0x74, 0x61, 0x6d, 0x6f, 0x72, 0x6f, 0x73, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x4f, 0x6a, 0x69, 0x6e, 0x61, 0x67, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x43, 0x68, 0x69, 0x63, 0x61, 0x67, 0x6f, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x4b, 0x6e, 0x6f, 0x78, 0x20, 0x41, +0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x54, +0x65, 0x6c, 0x6c, 0x5f, 0x43, 0x69, 0x74, 0x79, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x4d, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x65, 0x65, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x5f, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x2f, +0x42, 0x65, 0x75, 0x6c, 0x61, 0x68, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, +0x6f, 0x72, 0x74, 0x68, 0x5f, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x2f, 0x43, 0x65, 0x6e, 0x74, +0x65, 0x72, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x6f, 0x72, 0x74, 0x68, +0x5f, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x2f, 0x4e, 0x65, 0x77, 0x5f, 0x53, 0x61, 0x6c, 0x65, +0x6d, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, +0x5f, 0x43, 0x69, 0x74, 0x79, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x61, +0x68, 0x69, 0x61, 0x5f, 0x42, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x61, 0x73, 0x20, 0x41, 0x6d, 0x65, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x65, 0x72, 0x69, 0x64, 0x61, 0x20, 0x41, 0x6d, 0x65, 0x72, +0x69, 0x63, 0x61, 0x2f, 0x4d, 0x6f, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x65, 0x79, 0x20, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x68, 0x69, 0x68, 0x75, 0x61, 0x68, 0x75, 0x61, 0x0, +0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x43, 0x68, 0x61, 0x74, 0x68, 0x61, 0x6d, 0x0, +0x41, 0x73, 0x69, 0x61, 0x2f, 0x53, 0x68, 0x61, 0x6e, 0x67, 0x68, 0x61, 0x69, 0x0, 0x41, 0x73, +0x69, 0x61, 0x2f, 0x48, 0x6f, 0x6e, 0x67, 0x5f, 0x4b, 0x6f, 0x6e, 0x67, 0x0, 0x41, 0x73, 0x69, +0x61, 0x2f, 0x4d, 0x61, 0x63, 0x61, 0x75, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, +0x48, 0x61, 0x76, 0x61, 0x6e, 0x61, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x31, +0x32, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x33, 0x0, 0x41, 0x6e, 0x74, 0x61, +0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x79, 0x6f, 0x77, 0x61, 0x0, 0x49, 0x6e, 0x64, +0x69, 0x61, 0x6e, 0x2f, 0x43, 0x6f, 0x6d, 0x6f, 0x72, 0x6f, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x44, 0x6a, 0x69, 0x62, 0x6f, 0x75, 0x74, 0x69, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x41, 0x73, 0x6d, 0x61, 0x72, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, +0x41, 0x64, 0x64, 0x69, 0x73, 0x5f, 0x41, 0x62, 0x61, 0x62, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x4e, 0x61, 0x69, 0x72, 0x6f, 0x62, 0x69, 0x0, 0x49, 0x6e, 0x64, 0x69, 0x61, +0x6e, 0x2f, 0x41, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x6e, 0x61, 0x72, 0x69, 0x76, 0x6f, 0x0, 0x49, +0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, 0x4d, 0x61, 0x79, 0x6f, 0x74, 0x74, 0x65, 0x0, 0x41, 0x66, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x6f, 0x67, 0x61, 0x64, 0x69, 0x73, 0x68, 0x75, 0x0, 0x41, +0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x61, 0x72, 0x5f, 0x65, 0x73, 0x5f, 0x53, 0x61, 0x6c, +0x61, 0x61, 0x6d, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4b, 0x61, 0x6d, 0x70, 0x61, +0x6c, 0x61, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x42, 0x72, 0x69, +0x73, 0x62, 0x61, 0x6e, 0x65, 0x20, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, +0x4c, 0x69, 0x6e, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, +0x43, 0x68, 0x69, 0x73, 0x69, 0x6e, 0x61, 0x75, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x53, 0x61, 0x6f, 0x5f, 0x50, 0x61, 0x75, 0x6c, 0x6f, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, +0x69, 0x63, 0x2f, 0x45, 0x61, 0x73, 0x74, 0x65, 0x72, 0x0, 0x45, 0x53, 0x54, 0x35, 0x45, 0x44, +0x54, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x61, 0x73, 0x73, 0x61, 0x75, +0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, 0x6f, 0x72, 0x6f, 0x6e, 0x74, 0x6f, +0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x71, 0x61, 0x6c, 0x75, 0x69, 0x74, +0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x65, 0x77, 0x5f, 0x59, 0x6f, 0x72, +0x6b, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x65, 0x74, 0x72, 0x6f, 0x69, +0x74, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, +0x61, 0x2f, 0x50, 0x65, 0x74, 0x65, 0x72, 0x73, 0x62, 0x75, 0x72, 0x67, 0x20, 0x41, 0x6d, 0x65, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x56, 0x69, 0x6e, +0x63, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, +0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x57, 0x69, 0x6e, 0x61, 0x6d, 0x61, 0x63, 0x20, 0x41, +0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x2f, +0x4d, 0x6f, 0x6e, 0x74, 0x69, 0x63, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x2f, 0x4c, 0x6f, 0x75, 0x69, +0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, +0x61, 0x6e, 0x63, 0x75, 0x6e, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x69, +0x72, 0x6f, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x59, 0x65, 0x6b, 0x61, 0x74, 0x65, 0x72, 0x69, +0x6e, 0x62, 0x75, 0x72, 0x67, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x46, 0x69, +0x6a, 0x69, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x61, 0x72, 0x69, 0x65, 0x68, +0x61, 0x6d, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, 0x6f, 0x66, 0x69, 0x61, +0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x54, 0x61, 0x6c, 0x6c, 0x69, 0x6e, 0x6e, 0x0, +0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x48, 0x65, 0x6c, 0x73, 0x69, 0x6e, 0x6b, 0x69, 0x0, +0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x52, 0x69, 0x67, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, +0x70, 0x65, 0x2f, 0x56, 0x69, 0x6c, 0x6e, 0x69, 0x75, 0x73, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, +0x65, 0x2f, 0x4b, 0x79, 0x69, 0x76, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x54, 0x62, 0x69, 0x6c, +0x69, 0x73, 0x69, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x46, 0x61, 0x72, +0x6f, 0x65, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x47, 0x75, 0x65, 0x72, 0x6e, 0x73, +0x65, 0x79, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x44, 0x75, 0x62, 0x6c, 0x69, 0x6e, +0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x49, 0x73, 0x6c, 0x65, 0x5f, 0x6f, 0x66, 0x5f, +0x4d, 0x61, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4a, 0x65, 0x72, 0x73, 0x65, +0x79, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4c, 0x69, 0x73, 0x62, 0x6f, 0x6e, 0x20, +0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x4d, 0x61, 0x64, 0x65, 0x69, 0x72, 0x61, +0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x43, 0x61, 0x6e, 0x61, 0x72, 0x79, +0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4c, 0x6f, 0x6e, 0x64, 0x6f, 0x6e, 0x0, 0x41, +0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x75, 0x75, 0x6b, 0x0, 0x41, 0x66, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x4f, 0x75, 0x61, 0x67, 0x61, 0x64, 0x6f, 0x75, 0x67, 0x6f, 0x75, 0x0, 0x41, +0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x61, 0x6e, 0x6a, 0x75, 0x6c, 0x0, 0x41, 0x66, 0x72, +0x69, 0x63, 0x61, 0x2f, 0x41, 0x63, 0x63, 0x72, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x44, 0x61, 0x6e, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x68, 0x61, 0x76, 0x6e, 0x0, 0x41, +0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x69, 0x73, 0x73, 0x61, 0x75, 0x0, 0x41, 0x66, 0x72, +0x69, 0x63, 0x61, 0x2f, 0x43, 0x6f, 0x6e, 0x61, 0x6b, 0x72, 0x79, 0x0, 0x41, 0x74, 0x6c, 0x61, +0x6e, 0x74, 0x69, 0x63, 0x2f, 0x52, 0x65, 0x79, 0x6b, 0x6a, 0x61, 0x76, 0x69, 0x6b, 0x0, 0x41, +0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x62, 0x69, 0x64, 0x6a, 0x61, 0x6e, 0x0, 0x41, 0x66, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x76, 0x69, 0x61, 0x0, 0x41, 0x66, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x61, 0x6d, 0x61, 0x6b, 0x6f, 0x0, 0x41, 0x66, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x4e, 0x6f, 0x75, 0x61, 0x6b, 0x63, 0x68, 0x6f, 0x74, 0x74, 0x0, 0x41, 0x74, +0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x53, 0x74, 0x5f, 0x48, 0x65, 0x6c, 0x65, 0x6e, 0x61, +0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x61, 0x6b, 0x61, 0x72, 0x0, 0x41, 0x66, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x46, 0x72, 0x65, 0x65, 0x74, 0x6f, 0x77, 0x6e, 0x0, 0x41, 0x66, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x6f, 0x6d, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4e, +0x69, 0x63, 0x6f, 0x73, 0x69, 0x61, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x46, 0x61, 0x6d, 0x61, +0x67, 0x75, 0x73, 0x74, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x41, 0x74, 0x68, +0x65, 0x6e, 0x73, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x75, 0x63, 0x68, 0x61, +0x72, 0x65, 0x73, 0x74, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x6f, 0x72, +0x74, 0x2d, 0x61, 0x75, 0x2d, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x65, 0x0, 0x45, 0x74, 0x63, 0x2f, +0x47, 0x4d, 0x54, 0x2b, 0x31, 0x30, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x52, +0x61, 0x72, 0x6f, 0x74, 0x6f, 0x6e, 0x67, 0x61, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, +0x2f, 0x54, 0x61, 0x68, 0x69, 0x74, 0x69, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, +0x48, 0x6f, 0x6e, 0x6f, 0x6c, 0x75, 0x6c, 0x75, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x6f, +0x6c, 0x6b, 0x61, 0x74, 0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x54, 0x65, 0x68, 0x72, 0x61, +0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4a, 0x65, 0x72, 0x75, 0x73, 0x61, 0x6c, 0x65, 0x6d, +0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x41, 0x6d, 0x6d, 0x61, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, +0x70, 0x65, 0x2f, 0x4b, 0x61, 0x6c, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x72, 0x61, 0x64, 0x0, 0x41, +0x73, 0x69, 0x61, 0x2f, 0x53, 0x65, 0x6f, 0x75, 0x6c, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x54, 0x72, 0x69, 0x70, 0x6f, 0x6c, 0x69, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, +0x2d, 0x31, 0x34, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4b, 0x69, 0x72, 0x69, +0x74, 0x69, 0x6d, 0x61, 0x74, 0x69, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, +0x2f, 0x4c, 0x6f, 0x72, 0x64, 0x5f, 0x48, 0x6f, 0x77, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, +0x4d, 0x61, 0x67, 0x61, 0x64, 0x61, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, +0x50, 0x75, 0x6e, 0x74, 0x61, 0x5f, 0x41, 0x72, 0x65, 0x6e, 0x61, 0x73, 0x0, 0x50, 0x61, 0x63, +0x69, 0x66, 0x69, 0x63, 0x2f, 0x4d, 0x61, 0x72, 0x71, 0x75, 0x65, 0x73, 0x61, 0x73, 0x0, 0x49, +0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, 0x4d, 0x61, 0x75, 0x72, 0x69, 0x74, 0x69, 0x75, 0x73, 0x0, +0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, 0x52, 0x65, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x0, 0x49, +0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, 0x4d, 0x61, 0x68, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, +0x42, 0x65, 0x69, 0x72, 0x75, 0x74, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, +0x6f, 0x6e, 0x74, 0x65, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x43, 0x61, 0x73, 0x61, 0x62, 0x6c, 0x61, 0x6e, 0x63, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x45, 0x6c, 0x5f, 0x41, 0x61, 0x69, 0x75, 0x6e, 0x0, 0x4d, 0x53, 0x54, 0x37, +0x4d, 0x44, 0x54, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x45, 0x64, 0x6d, 0x6f, +0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x6d, +0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x5f, 0x42, 0x61, 0x79, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x49, 0x6e, 0x75, 0x76, 0x69, 0x6b, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x43, 0x69, 0x75, 0x64, 0x61, 0x64, 0x5f, 0x4a, 0x75, 0x61, 0x72, 0x65, 0x7a, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x65, 0x6e, 0x76, 0x65, 0x72, 0x20, 0x41, +0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x6f, 0x69, 0x73, 0x65, 0x0, 0x41, 0x6d, 0x65, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x7a, 0x61, 0x74, 0x6c, 0x61, 0x6e, 0x0, 0x49, 0x6e, +0x64, 0x69, 0x61, 0x6e, 0x2f, 0x43, 0x6f, 0x63, 0x6f, 0x73, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, +0x59, 0x61, 0x6e, 0x67, 0x6f, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4e, 0x6f, 0x76, 0x6f, +0x73, 0x69, 0x62, 0x69, 0x72, 0x73, 0x6b, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x57, +0x69, 0x6e, 0x64, 0x68, 0x6f, 0x65, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x61, 0x74, +0x68, 0x6d, 0x61, 0x6e, 0x64, 0x75, 0x0, 0x41, 0x6e, 0x74, 0x61, 0x72, 0x63, 0x74, 0x69, 0x63, +0x61, 0x2f, 0x4d, 0x63, 0x4d, 0x75, 0x72, 0x64, 0x6f, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, +0x63, 0x2f, 0x41, 0x75, 0x63, 0x6b, 0x6c, 0x61, 0x6e, 0x64, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x53, 0x74, 0x5f, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x0, 0x50, 0x61, 0x63, 0x69, +0x66, 0x69, 0x63, 0x2f, 0x4e, 0x6f, 0x72, 0x66, 0x6f, 0x6c, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, +0x2f, 0x49, 0x72, 0x6b, 0x75, 0x74, 0x73, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x72, +0x61, 0x73, 0x6e, 0x6f, 0x79, 0x61, 0x72, 0x73, 0x6b, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4e, +0x6f, 0x76, 0x6f, 0x6b, 0x75, 0x7a, 0x6e, 0x65, 0x74, 0x73, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, +0x2f, 0x50, 0x79, 0x6f, 0x6e, 0x67, 0x79, 0x61, 0x6e, 0x67, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, +0x4f, 0x6d, 0x73, 0x6b, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x61, 0x6e, +0x74, 0x69, 0x61, 0x67, 0x6f, 0x0, 0x50, 0x53, 0x54, 0x38, 0x50, 0x44, 0x54, 0x0, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x56, 0x61, 0x6e, 0x63, 0x6f, 0x75, 0x76, 0x65, 0x72, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x6f, 0x73, 0x5f, 0x41, 0x6e, 0x67, 0x65, +0x6c, 0x65, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, 0x69, 0x6a, 0x75, +0x61, 0x6e, 0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x61, 0x72, 0x61, 0x63, 0x68, 0x69, +0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x73, 0x75, 0x6e, 0x63, 0x69, 0x6f, +0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x51, 0x79, 0x7a, 0x79, 0x6c, 0x6f, 0x72, 0x64, 0x61, +0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x72, 0x75, 0x73, 0x73, 0x65, 0x6c, 0x73, +0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x43, 0x6f, 0x70, 0x65, 0x6e, 0x68, 0x61, 0x67, +0x65, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x50, 0x61, 0x72, 0x69, 0x73, 0x0, +0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x61, 0x64, 0x72, 0x69, 0x64, 0x20, 0x41, 0x66, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x65, 0x75, 0x74, 0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, +0x53, 0x72, 0x65, 0x64, 0x6e, 0x65, 0x6b, 0x6f, 0x6c, 0x79, 0x6d, 0x73, 0x6b, 0x0, 0x41, 0x73, +0x69, 0x61, 0x2f, 0x4b, 0x61, 0x6d, 0x63, 0x68, 0x61, 0x74, 0x6b, 0x61, 0x20, 0x41, 0x73, 0x69, +0x61, 0x2f, 0x41, 0x6e, 0x61, 0x64, 0x79, 0x72, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, +0x53, 0x61, 0x6d, 0x61, 0x72, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x6f, +0x73, 0x63, 0x6f, 0x77, 0x20, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4b, 0x69, 0x72, 0x6f, +0x76, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, 0x69, 0x6d, 0x66, 0x65, 0x72, 0x6f, +0x70, 0x6f, 0x6c, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x33, 0x0, 0x41, 0x6e, +0x74, 0x61, 0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x61, +0x20, 0x41, 0x6e, 0x74, 0x61, 0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x61, 0x6c, 0x6d, +0x65, 0x72, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x46, 0x6f, 0x72, 0x74, 0x61, +0x6c, 0x65, 0x7a, 0x61, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x65, 0x6c, +0x65, 0x6d, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x63, 0x65, 0x69, +0x6f, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x65, 0x63, 0x69, 0x66, 0x65, +0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x61, 0x6e, 0x74, 0x61, 0x72, 0x65, +0x6d, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x53, 0x74, 0x61, 0x6e, 0x6c, +0x65, 0x79, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x79, 0x65, 0x6e, +0x6e, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x61, 0x72, 0x61, 0x6d, +0x61, 0x72, 0x69, 0x62, 0x6f, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x35, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x69, 0x6f, 0x5f, 0x42, 0x72, 0x61, 0x6e, +0x63, 0x6f, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x45, 0x69, 0x72, 0x75, 0x6e, +0x65, 0x70, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x74, 0x69, 0x6b, +0x6f, 0x6b, 0x61, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x79, +0x6d, 0x61, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x6f, 0x67, 0x6f, +0x74, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x47, 0x75, 0x61, 0x79, 0x61, +0x71, 0x75, 0x69, 0x6c, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4a, 0x61, 0x6d, +0x61, 0x69, 0x63, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x61, 0x6e, +0x61, 0x6d, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x69, 0x6d, 0x61, +0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x34, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x41, 0x6e, 0x67, 0x75, 0x69, 0x6c, 0x6c, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, +0x69, 0x63, 0x61, 0x2f, 0x41, 0x6e, 0x74, 0x69, 0x67, 0x75, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, +0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x75, 0x62, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x42, 0x61, 0x72, 0x62, 0x61, 0x64, 0x6f, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x4c, 0x61, 0x5f, 0x50, 0x61, 0x7a, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x4d, 0x61, 0x6e, 0x61, 0x75, 0x73, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x42, 0x6f, 0x61, 0x5f, 0x56, 0x69, 0x73, 0x74, 0x61, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x50, 0x6f, 0x72, 0x74, 0x6f, 0x5f, 0x56, 0x65, 0x6c, 0x68, 0x6f, 0x0, 0x41, +0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, 0x6f, 0x72, 0x74, 0x6f, 0x6c, 0x61, 0x0, 0x41, +0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x6c, 0x61, 0x6e, 0x63, 0x2d, 0x53, 0x61, 0x62, +0x6c, 0x6f, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4b, 0x72, 0x61, 0x6c, +0x65, 0x6e, 0x64, 0x69, 0x6a, 0x6b, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, +0x75, 0x72, 0x61, 0x63, 0x61, 0x6f, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, +0x6f, 0x6d, 0x69, 0x6e, 0x69, 0x63, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, +0x53, 0x61, 0x6e, 0x74, 0x6f, 0x5f, 0x44, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x6f, 0x0, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x47, 0x72, 0x65, 0x6e, 0x61, 0x64, 0x61, 0x0, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x47, 0x75, 0x61, 0x64, 0x65, 0x6c, 0x6f, 0x75, 0x70, 0x65, +0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x47, 0x75, 0x79, 0x61, 0x6e, 0x61, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x69, 0x71, +0x75, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x6f, 0x6e, 0x74, 0x73, +0x65, 0x72, 0x72, 0x61, 0x74, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x75, +0x65, 0x72, 0x74, 0x6f, 0x5f, 0x52, 0x69, 0x63, 0x6f, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x53, 0x74, 0x5f, 0x42, 0x61, 0x72, 0x74, 0x68, 0x65, 0x6c, 0x65, 0x6d, 0x79, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x74, 0x5f, 0x4b, 0x69, 0x74, 0x74, 0x73, +0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x74, 0x5f, 0x4c, 0x75, 0x63, 0x69, +0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x72, 0x69, 0x67, 0x6f, +0x74, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x74, 0x5f, 0x56, 0x69, 0x6e, +0x63, 0x65, 0x6e, 0x74, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x6f, 0x77, +0x65, 0x72, 0x5f, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x65, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x50, 0x6f, 0x72, 0x74, 0x5f, 0x6f, 0x66, 0x5f, 0x53, 0x70, 0x61, 0x69, 0x6e, +0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x74, 0x5f, 0x54, 0x68, 0x6f, 0x6d, +0x61, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x69, 0x71, 0x75, 0x65, +0x6c, 0x6f, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x53, 0x61, 0x6b, 0x68, 0x61, 0x6c, 0x69, +0x6e, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x41, 0x70, 0x69, 0x61, 0x0, 0x41, +0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x61, 0x6f, 0x5f, 0x54, 0x6f, 0x6d, 0x65, 0x0, 0x45, +0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, 0x61, 0x72, 0x61, 0x74, 0x6f, 0x76, 0x0, 0x45, 0x74, +0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x37, 0x0, 0x41, 0x6e, 0x74, 0x61, 0x72, 0x63, 0x74, 0x69, +0x63, 0x61, 0x2f, 0x44, 0x61, 0x76, 0x69, 0x73, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x50, 0x68, +0x6e, 0x6f, 0x6d, 0x5f, 0x50, 0x65, 0x6e, 0x68, 0x0, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, +0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4a, +0x61, 0x6b, 0x61, 0x72, 0x74, 0x61, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x50, 0x6f, 0x6e, 0x74, +0x69, 0x61, 0x6e, 0x61, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x56, 0x69, 0x65, 0x6e, 0x74, +0x69, 0x61, 0x6e, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x42, 0x61, 0x6e, 0x67, 0x6b, 0x6f, +0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x48, 0x6f, 0x5f, 0x43, 0x68, 0x69, 0x5f, 0x4d, 0x69, +0x6e, 0x68, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x38, 0x0, 0x41, 0x73, 0x69, +0x61, 0x2f, 0x42, 0x72, 0x75, 0x6e, 0x65, 0x69, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4d, 0x61, +0x6b, 0x61, 0x73, 0x73, 0x61, 0x72, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x75, 0x61, 0x6c, +0x61, 0x5f, 0x4c, 0x75, 0x6d, 0x70, 0x75, 0x72, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x75, +0x63, 0x68, 0x69, 0x6e, 0x67, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4d, 0x61, 0x6e, 0x69, 0x6c, +0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x53, 0x69, 0x6e, 0x67, 0x61, 0x70, 0x6f, 0x72, 0x65, +0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x32, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x47, 0x61, 0x62, 0x6f, 0x72, 0x6f, 0x6e, 0x65, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x42, 0x75, 0x6a, 0x75, 0x6d, 0x62, 0x75, 0x72, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x4c, 0x75, 0x62, 0x75, 0x6d, 0x62, 0x61, 0x73, 0x68, 0x69, 0x0, 0x41, 0x66, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x62, 0x61, 0x62, 0x61, 0x6e, 0x65, 0x0, 0x41, 0x66, 0x72, +0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x73, 0x65, 0x72, 0x75, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x42, 0x6c, 0x61, 0x6e, 0x74, 0x79, 0x72, 0x65, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x4d, 0x61, 0x70, 0x75, 0x74, 0x6f, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, +0x4b, 0x69, 0x67, 0x61, 0x6c, 0x69, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4a, 0x6f, +0x68, 0x61, 0x6e, 0x6e, 0x65, 0x73, 0x62, 0x75, 0x72, 0x67, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x4c, 0x75, 0x73, 0x61, 0x6b, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, +0x48, 0x61, 0x72, 0x61, 0x72, 0x65, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4a, 0x75, +0x62, 0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x43, 0x6f, 0x6c, 0x6f, 0x6d, 0x62, 0x6f, 0x0, +0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4b, 0x68, 0x61, 0x72, 0x74, 0x6f, 0x75, 0x6d, 0x0, +0x41, 0x73, 0x69, 0x61, 0x2f, 0x44, 0x61, 0x6d, 0x61, 0x73, 0x63, 0x75, 0x73, 0x0, 0x41, 0x73, +0x69, 0x61, 0x2f, 0x54, 0x61, 0x69, 0x70, 0x65, 0x69, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, +0x6c, 0x69, 0x61, 0x2f, 0x48, 0x6f, 0x62, 0x61, 0x72, 0x74, 0x20, 0x41, 0x6e, 0x74, 0x61, 0x72, +0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x63, 0x71, 0x75, 0x61, 0x72, 0x69, 0x65, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x61, 0x67, 0x75, 0x61, 0x69, 0x6e, +0x61, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x39, 0x0, 0x41, 0x73, 0x69, 0x61, +0x2f, 0x4a, 0x61, 0x79, 0x61, 0x70, 0x75, 0x72, 0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x54, +0x6f, 0x6b, 0x79, 0x6f, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x50, 0x61, 0x6c, +0x61, 0x75, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x44, 0x69, 0x6c, 0x69, 0x0, 0x41, 0x73, 0x69, +0x61, 0x2f, 0x54, 0x6f, 0x6d, 0x73, 0x6b, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, +0x54, 0x6f, 0x6e, 0x67, 0x61, 0x74, 0x61, 0x70, 0x75, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x43, +0x68, 0x69, 0x74, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x49, 0x73, 0x74, 0x61, +0x6e, 0x62, 0x75, 0x6c, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x47, 0x72, 0x61, +0x6e, 0x64, 0x5f, 0x54, 0x75, 0x72, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x55, 0x6c, 0x61, +0x61, 0x6e, 0x62, 0x61, 0x61, 0x74, 0x61, 0x72, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x43, 0x68, +0x6f, 0x69, 0x62, 0x61, 0x6c, 0x73, 0x61, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, +0x70, 0x6f, 0x6c, 0x69, 0x73, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, +0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x4d, 0x61, 0x72, 0x65, 0x6e, 0x67, 0x6f, 0x20, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x56, 0x65, +0x76, 0x61, 0x79, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x37, 0x0, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x61, 0x77, 0x73, 0x6f, 0x6e, 0x5f, 0x43, 0x72, 0x65, +0x65, 0x6b, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x46, 0x6f, 0x72, 0x74, 0x5f, +0x4e, 0x65, 0x6c, 0x73, 0x6f, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x48, +0x65, 0x72, 0x6d, 0x6f, 0x73, 0x69, 0x6c, 0x6c, 0x6f, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x50, 0x68, 0x6f, 0x65, 0x6e, 0x69, 0x78, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x55, 0x54, +0x43, 0x20, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, +0x54, 0x2d, 0x31, 0x32, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x54, 0x61, 0x72, +0x61, 0x77, 0x61, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4d, 0x61, 0x6a, 0x75, +0x72, 0x6f, 0x20, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4b, 0x77, 0x61, 0x6a, 0x61, +0x6c, 0x65, 0x69, 0x6e, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4e, 0x61, 0x75, +0x72, 0x75, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x46, 0x75, 0x6e, 0x61, 0x66, +0x75, 0x74, 0x69, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x57, 0x61, 0x6b, 0x65, +0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x57, 0x61, 0x6c, 0x6c, 0x69, 0x73, 0x0, +0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x31, 0x33, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, +0x69, 0x63, 0x2f, 0x4b, 0x61, 0x6e, 0x74, 0x6f, 0x6e, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, +0x63, 0x2f, 0x46, 0x61, 0x6b, 0x61, 0x6f, 0x66, 0x6f, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, +0x54, 0x2b, 0x32, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x6f, 0x72, 0x6f, +0x6e, 0x68, 0x61, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x53, 0x6f, 0x75, +0x74, 0x68, 0x5f, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, +0x4d, 0x54, 0x2b, 0x38, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x50, 0x69, 0x74, +0x63, 0x61, 0x69, 0x72, 0x6e, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x39, 0x0, +0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x47, 0x61, 0x6d, 0x62, 0x69, 0x65, 0x72, 0x0, +0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x31, 0x31, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, +0x69, 0x63, 0x2f, 0x50, 0x61, 0x67, 0x6f, 0x5f, 0x50, 0x61, 0x67, 0x6f, 0x0, 0x50, 0x61, 0x63, +0x69, 0x66, 0x69, 0x63, 0x2f, 0x4e, 0x69, 0x75, 0x65, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, +0x63, 0x2f, 0x4d, 0x69, 0x64, 0x77, 0x61, 0x79, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x43, 0x61, 0x72, 0x61, 0x63, 0x61, 0x73, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x56, 0x6c, +0x61, 0x64, 0x69, 0x76, 0x6f, 0x73, 0x74, 0x6f, 0x6b, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x55, +0x73, 0x74, 0x2d, 0x4e, 0x65, 0x72, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x56, +0x6f, 0x6c, 0x67, 0x6f, 0x67, 0x72, 0x61, 0x64, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, +0x69, 0x61, 0x2f, 0x50, 0x65, 0x72, 0x74, 0x68, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, +0x2d, 0x31, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x6c, 0x67, 0x69, 0x65, 0x72, +0x73, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x75, 0x61, 0x6e, 0x64, 0x61, 0x0, +0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x6f, 0x72, 0x74, 0x6f, 0x2d, 0x4e, 0x6f, 0x76, +0x6f, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x6f, 0x75, 0x61, 0x6c, 0x61, 0x0, +0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x61, 0x6e, 0x67, 0x75, 0x69, 0x0, 0x41, 0x66, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x64, 0x6a, 0x61, 0x6d, 0x65, 0x6e, 0x61, 0x0, 0x41, 0x66, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x72, 0x61, 0x7a, 0x7a, 0x61, 0x76, 0x69, 0x6c, 0x6c, 0x65, +0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4b, 0x69, 0x6e, 0x73, 0x68, 0x61, 0x73, 0x61, +0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x6c, 0x61, 0x62, 0x6f, 0x0, 0x41, +0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x69, 0x62, 0x72, 0x65, 0x76, 0x69, 0x6c, 0x6c, 0x65, +0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x61, 0x67, 0x6f, 0x73, 0x0, 0x41, 0x66, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x69, 0x61, 0x6d, 0x65, 0x79, 0x0, 0x41, 0x66, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x54, 0x75, 0x6e, 0x69, 0x73, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, +0x41, 0x6e, 0x64, 0x6f, 0x72, 0x72, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x56, +0x69, 0x65, 0x6e, 0x6e, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x65, 0x72, +0x6c, 0x69, 0x6e, 0x20, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x75, 0x73, 0x69, 0x6e, +0x67, 0x65, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x47, 0x69, 0x62, 0x72, 0x61, +0x6c, 0x74, 0x61, 0x72, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x52, 0x6f, 0x6d, 0x65, +0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x56, 0x61, 0x64, 0x75, 0x7a, 0x0, 0x45, 0x75, +0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4c, 0x75, 0x78, 0x65, 0x6d, 0x62, 0x6f, 0x75, 0x72, 0x67, 0x0, +0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x61, 0x6c, 0x74, 0x61, 0x0, 0x45, 0x75, 0x72, +0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x6f, 0x6e, 0x61, 0x63, 0x6f, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, +0x65, 0x2f, 0x41, 0x6d, 0x73, 0x74, 0x65, 0x72, 0x64, 0x61, 0x6d, 0x0, 0x45, 0x75, 0x72, 0x6f, +0x70, 0x65, 0x2f, 0x4f, 0x73, 0x6c, 0x6f, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, +0x61, 0x6e, 0x5f, 0x4d, 0x61, 0x72, 0x69, 0x6e, 0x6f, 0x0, 0x41, 0x72, 0x63, 0x74, 0x69, 0x63, +0x2f, 0x4c, 0x6f, 0x6e, 0x67, 0x79, 0x65, 0x61, 0x72, 0x62, 0x79, 0x65, 0x6e, 0x0, 0x45, 0x75, +0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, 0x74, 0x6f, 0x63, 0x6b, 0x68, 0x6f, 0x6c, 0x6d, 0x0, 0x45, +0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x5a, 0x75, 0x72, 0x69, 0x63, 0x68, 0x0, 0x45, 0x75, 0x72, +0x6f, 0x70, 0x65, 0x2f, 0x56, 0x61, 0x74, 0x69, 0x63, 0x61, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, +0x2f, 0x48, 0x6f, 0x76, 0x64, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x35, 0x0, +0x41, 0x6e, 0x74, 0x61, 0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x77, 0x73, 0x6f, +0x6e, 0x0, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, 0x4b, 0x65, 0x72, 0x67, 0x75, 0x65, 0x6c, +0x65, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4f, 0x72, 0x61, 0x6c, 0x20, 0x41, 0x73, 0x69, +0x61, 0x2f, 0x41, 0x71, 0x74, 0x61, 0x75, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x41, 0x71, 0x74, +0x6f, 0x62, 0x65, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x41, 0x74, 0x79, 0x72, 0x61, 0x75, 0x0, +0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, 0x4d, 0x61, 0x6c, 0x64, 0x69, 0x76, 0x65, 0x73, 0x0, +0x41, 0x73, 0x69, 0x61, 0x2f, 0x44, 0x75, 0x73, 0x68, 0x61, 0x6e, 0x62, 0x65, 0x0, 0x41, 0x73, +0x69, 0x61, 0x2f, 0x41, 0x73, 0x68, 0x67, 0x61, 0x62, 0x61, 0x74, 0x0, 0x41, 0x73, 0x69, 0x61, +0x2f, 0x54, 0x61, 0x73, 0x68, 0x6b, 0x65, 0x6e, 0x74, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x53, +0x61, 0x6d, 0x61, 0x72, 0x6b, 0x61, 0x6e, 0x64, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x48, 0x65, +0x62, 0x72, 0x6f, 0x6e, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x47, 0x61, 0x7a, 0x61, 0x0, 0x45, +0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x31, 0x30, 0x0, 0x41, 0x6e, 0x74, 0x61, 0x72, 0x63, +0x74, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x75, 0x6d, 0x6f, 0x6e, 0x74, 0x44, 0x55, 0x72, 0x76, 0x69, +0x6c, 0x6c, 0x65, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x47, 0x75, 0x61, 0x6d, +0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x43, 0x68, 0x75, 0x75, 0x6b, 0x0, 0x50, +0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x53, 0x61, 0x69, 0x70, 0x61, 0x6e, 0x0, 0x50, 0x61, +0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x50, 0x6f, 0x72, 0x74, 0x5f, 0x4d, 0x6f, 0x72, 0x65, 0x73, +0x62, 0x79, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x59, 0x61, 0x6b, 0x75, 0x74, 0x73, 0x6b, 0x20, +0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x68, 0x61, 0x6e, 0x64, 0x79, 0x67, 0x61, 0x0, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x57, 0x68, 0x69, 0x74, 0x65, 0x68, 0x6f, 0x72, 0x73, 0x65, +0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x61, 0x77, 0x73, 0x6f, 0x6e, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x61, 0x67, +0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, +0x69, 0x6e, 0x61, 0x2f, 0x42, 0x75, 0x65, 0x6e, 0x6f, 0x73, 0x5f, 0x41, 0x69, 0x72, 0x65, 0x73, +0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x41, 0x73, 0x74, 0x72, 0x61, 0x6b, 0x68, 0x61, +0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x48, 0x61, 0x6c, 0x69, 0x66, 0x61, +0x78, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x53, 0x79, 0x64, 0x6e, +0x65, 0x79, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x65, 0x67, 0x69, 0x6e, +0x61, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x41, 0x64, 0x65, 0x6c, +0x61, 0x69, 0x64, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x41, 0x6c, 0x6d, 0x61, 0x74, 0x79, +0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x75, 0x69, 0x61, 0x62, 0x61, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x68, 0x69, 0x63, 0x61, 0x67, 0x6f, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x5f, 0x43, +0x69, 0x74, 0x79, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x42, 0x72, +0x69, 0x73, 0x62, 0x61, 0x6e, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, +0x65, 0x77, 0x5f, 0x59, 0x6f, 0x72, 0x6b, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, +0x44, 0x65, 0x6e, 0x76, 0x65, 0x72, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x72, 0x61, 0x73, +0x6e, 0x6f, 0x79, 0x61, 0x72, 0x73, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x61, 0x6d, +0x63, 0x68, 0x61, 0x74, 0x6b, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x6f, +0x73, 0x63, 0x6f, 0x77, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x48, +0x6f, 0x62, 0x61, 0x72, 0x74, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x55, 0x6c, 0x61, 0x61, 0x6e, +0x62, 0x61, 0x61, 0x74, 0x61, 0x72, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, +0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x70, 0x6f, +0x6c, 0x69, 0x73, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x55, 0x54, 0x43, 0x0, 0x41, 0x73, 0x69, 0x61, +0x2f, 0x56, 0x6c, 0x61, 0x64, 0x69, 0x76, 0x6f, 0x73, 0x74, 0x6f, 0x6b, 0x0, 0x45, 0x75, 0x72, +0x6f, 0x70, 0x65, 0x2f, 0x42, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, +0x54, 0x61, 0x73, 0x68, 0x6b, 0x65, 0x6e, 0x74, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x48, 0x65, +0x62, 0x72, 0x6f, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x59, 0x61, 0x6b, 0x75, 0x74, 0x73, +0x6b, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x57, 0x68, 0x69, 0x74, 0x65, 0x68, +0x6f, 0x72, 0x73, 0x65, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x31, 0x34, 0x3a, 0x30, 0x30, 0x0, 0x55, +0x54, 0x43, 0x2d, 0x31, 0x33, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x31, 0x32, 0x3a, +0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x31, 0x31, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, +0x2d, 0x31, 0x30, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x39, 0x3a, 0x33, 0x30, +0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x39, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, +0x38, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x37, 0x3a, 0x30, 0x30, 0x0, 0x55, +0x54, 0x43, 0x2d, 0x30, 0x36, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x35, 0x3a, +0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x34, 0x3a, 0x33, 0x30, 0x0, 0x55, 0x54, 0x43, +0x2d, 0x30, 0x34, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x33, 0x3a, 0x33, 0x30, +0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x33, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, +0x32, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x31, 0x3a, 0x30, 0x30, 0x0, 0x55, +0x54, 0x43, 0x20, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x30, 0x3a, 0x30, 0x30, 0x20, 0x55, 0x54, 0x43, +0x2d, 0x30, 0x30, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x31, 0x3a, 0x30, 0x30, +0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x32, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, +0x33, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x33, 0x3a, 0x33, 0x30, 0x0, 0x55, +0x54, 0x43, 0x2b, 0x30, 0x34, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x34, 0x3a, +0x33, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x35, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, +0x2b, 0x30, 0x35, 0x3a, 0x33, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x35, 0x3a, 0x34, 0x35, +0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x36, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, +0x36, 0x3a, 0x33, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x37, 0x3a, 0x30, 0x30, 0x0, 0x55, +0x54, 0x43, 0x2b, 0x30, 0x38, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x38, 0x3a, +0x33, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x38, 0x3a, 0x34, 0x35, 0x0, 0x55, 0x54, 0x43, +0x2b, 0x30, 0x39, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x39, 0x3a, 0x33, 0x30, +0x0, 0x55, 0x54, 0x43, 0x2b, 0x31, 0x30, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x31, +0x30, 0x3a, 0x33, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x31, 0x31, 0x3a, 0x30, 0x30, 0x0, 0x55, +0x54, 0x43, 0x2b, 0x31, 0x32, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x31, 0x32, 0x3a, +0x34, 0x35, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x31, 0x33, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, +0x2b, 0x31, 0x34, 0x3a, 0x30, 0x30, 0x0 +}; + +static constexpr char aliasIdData[] = { +0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x73, 0x6d, 0x65, 0x72, 0x61, 0x0, 0x41, 0x66, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x73, 0x6d, 0x61, 0x72, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x54, 0x69, 0x6d, 0x62, 0x75, 0x6b, 0x74, 0x75, 0x0, 0x41, 0x66, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x42, 0x61, 0x6d, 0x61, 0x6b, 0x6f, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x43, 0x6f, 0x6d, 0x6f, +0x64, 0x52, 0x69, 0x76, 0x61, 0x64, 0x61, 0x76, 0x69, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x43, 0x61, 0x74, +0x61, 0x6d, 0x61, 0x72, 0x63, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, +0x74, 0x6b, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x64, 0x61, 0x6b, +0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x75, 0x65, 0x6e, 0x6f, 0x73, 0x5f, +0x41, 0x69, 0x72, 0x65, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, +0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x42, 0x75, 0x65, 0x6e, 0x6f, 0x73, 0x5f, 0x41, +0x69, 0x72, 0x65, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x74, +0x61, 0x6d, 0x61, 0x72, 0x63, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, +0x6f, 0x72, 0x61, 0x6c, 0x5f, 0x48, 0x61, 0x72, 0x62, 0x6f, 0x75, 0x72, 0x0, 0x41, 0x6d, 0x65, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x74, 0x69, 0x6b, 0x6f, 0x6b, 0x61, 0x6e, 0x0, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x6f, 0x72, 0x64, 0x6f, 0x62, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, -0x53, 0x61, 0x6e, 0x5f, 0x4c, 0x75, 0x69, 0x73, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, -0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x54, 0x75, 0x63, 0x75, 0x6d, -0x61, 0x6e, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, -0x74, 0x69, 0x6e, 0x61, 0x2f, 0x55, 0x73, 0x68, 0x75, 0x61, 0x69, 0x61, 0x20, 0x41, 0x6d, 0x65, -0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x74, 0x61, 0x6d, 0x61, 0x72, 0x63, 0x61, 0x20, 0x41, -0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x6f, 0x72, 0x64, 0x6f, 0x62, 0x61, 0x20, 0x41, -0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4a, 0x75, 0x6a, 0x75, 0x79, 0x20, 0x41, 0x6d, 0x65, -0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x65, 0x6e, 0x64, 0x6f, 0x7a, 0x61, 0x0, 0x45, 0x75, 0x72, -0x6f, 0x70, 0x65, 0x2f, 0x41, 0x73, 0x74, 0x72, 0x61, 0x6b, 0x68, 0x61, 0x6e, 0x20, 0x45, 0x75, -0x72, 0x6f, 0x70, 0x65, 0x2f, 0x55, 0x6c, 0x79, 0x61, 0x6e, 0x6f, 0x76, 0x73, 0x6b, 0x0, 0x41, -0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x42, 0x65, 0x72, 0x6d, 0x75, 0x64, 0x61, 0x0, -0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x48, 0x61, 0x6c, 0x69, 0x66, 0x61, 0x78, 0x20, -0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x47, 0x6c, 0x61, 0x63, 0x65, 0x5f, 0x42, 0x61, -0x79, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x47, 0x6f, 0x6f, 0x73, 0x65, 0x5f, -0x42, 0x61, 0x79, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x6f, 0x6e, 0x63, -0x74, 0x6f, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, 0x68, 0x75, 0x6c, -0x65, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x44, 0x61, 0x72, 0x77, -0x69, 0x6e, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x45, 0x75, 0x63, -0x6c, 0x61, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x53, 0x79, 0x64, -0x6e, 0x65, 0x79, 0x20, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x4d, 0x65, -0x6c, 0x62, 0x6f, 0x75, 0x72, 0x6e, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x42, 0x61, 0x6b, -0x75, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x73, -0x62, 0x79, 0x73, 0x75, 0x6e, 0x64, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, -0x41, 0x7a, 0x6f, 0x72, 0x65, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, -0x61, 0x68, 0x69, 0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x44, 0x68, 0x61, 0x6b, 0x61, 0x0, -0x41, 0x73, 0x69, 0x61, 0x2f, 0x54, 0x68, 0x69, 0x6d, 0x70, 0x68, 0x75, 0x0, 0x45, 0x75, 0x72, -0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x69, 0x6e, 0x73, 0x6b, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, -0x63, 0x2f, 0x42, 0x6f, 0x75, 0x67, 0x61, 0x69, 0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x0, 0x41, -0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x65, 0x67, 0x69, 0x6e, 0x61, 0x20, 0x41, 0x6d, -0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x43, 0x75, 0x72, 0x72, -0x65, 0x6e, 0x74, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x31, 0x0, 0x41, 0x74, -0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x43, 0x61, 0x70, 0x65, 0x5f, 0x56, 0x65, 0x72, 0x64, -0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x59, 0x65, 0x72, 0x65, 0x76, 0x61, 0x6e, 0x0, 0x41, -0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x41, 0x64, 0x65, 0x6c, 0x61, 0x69, 0x64, -0x65, 0x20, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x42, 0x72, 0x6f, 0x6b, -0x65, 0x6e, 0x5f, 0x48, 0x69, 0x6c, 0x6c, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, -0x36, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x65, 0x6c, 0x69, 0x7a, 0x65, -0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x6f, 0x73, 0x74, 0x61, 0x5f, 0x52, -0x69, 0x63, 0x61, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x47, 0x61, 0x6c, 0x61, -0x70, 0x61, 0x67, 0x6f, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x45, 0x6c, -0x5f, 0x53, 0x61, 0x6c, 0x76, 0x61, 0x64, 0x6f, 0x72, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, -0x61, 0x2f, 0x47, 0x75, 0x61, 0x74, 0x65, 0x6d, 0x61, 0x6c, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x54, 0x65, 0x67, 0x75, 0x63, 0x69, 0x67, 0x61, 0x6c, 0x70, 0x61, 0x0, -0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x6e, 0x61, 0x67, 0x75, 0x61, 0x0, -0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x36, 0x0, 0x41, 0x6e, 0x74, 0x61, 0x72, 0x63, -0x74, 0x69, 0x63, 0x61, 0x2f, 0x56, 0x6f, 0x73, 0x74, 0x6f, 0x6b, 0x0, 0x49, 0x6e, 0x64, 0x69, -0x61, 0x6e, 0x2f, 0x43, 0x68, 0x61, 0x67, 0x6f, 0x73, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x55, -0x72, 0x75, 0x6d, 0x71, 0x69, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x41, 0x6c, 0x6d, 0x61, 0x74, -0x79, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x51, 0x6f, 0x73, 0x74, 0x61, 0x6e, 0x61, 0x79, 0x0, -0x41, 0x73, 0x69, 0x61, 0x2f, 0x42, 0x69, 0x73, 0x68, 0x6b, 0x65, 0x6b, 0x0, 0x41, 0x6d, 0x65, -0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x75, 0x69, 0x61, 0x62, 0x61, 0x20, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x6d, 0x70, 0x6f, 0x5f, 0x47, 0x72, 0x61, 0x6e, 0x64, 0x65, -0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x54, 0x69, 0x72, 0x61, 0x6e, 0x65, 0x0, 0x45, -0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x50, 0x72, 0x61, 0x67, 0x75, 0x65, 0x0, 0x45, 0x75, 0x72, -0x6f, 0x70, 0x65, 0x2f, 0x42, 0x75, 0x64, 0x61, 0x70, 0x65, 0x73, 0x74, 0x0, 0x45, 0x75, 0x72, -0x6f, 0x70, 0x65, 0x2f, 0x50, 0x6f, 0x64, 0x67, 0x6f, 0x72, 0x69, 0x63, 0x61, 0x0, 0x45, 0x75, -0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x65, 0x6c, 0x67, 0x72, 0x61, 0x64, 0x65, 0x0, 0x45, 0x75, -0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x72, 0x61, 0x74, 0x69, 0x73, 0x6c, 0x61, 0x76, 0x61, 0x0, -0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4c, 0x6a, 0x75, 0x62, 0x6c, 0x6a, 0x61, 0x6e, 0x61, -0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, 0x61, 0x72, 0x61, 0x6a, 0x65, 0x76, 0x6f, -0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x5a, 0x61, 0x67, 0x72, 0x65, 0x62, 0x0, 0x45, -0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, 0x6b, 0x6f, 0x70, 0x6a, 0x65, 0x0, 0x45, 0x75, 0x72, -0x6f, 0x70, 0x65, 0x2f, 0x57, 0x61, 0x72, 0x73, 0x61, 0x77, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, -0x4d, 0x54, 0x2d, 0x31, 0x31, 0x0, 0x41, 0x6e, 0x74, 0x61, 0x72, 0x63, 0x74, 0x69, 0x63, 0x61, -0x2f, 0x43, 0x61, 0x73, 0x65, 0x79, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x50, -0x6f, 0x6e, 0x61, 0x70, 0x65, 0x20, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4b, 0x6f, -0x73, 0x72, 0x61, 0x65, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4e, 0x6f, 0x75, -0x6d, 0x65, 0x61, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x47, 0x75, 0x61, 0x64, -0x61, 0x6c, 0x63, 0x61, 0x6e, 0x61, 0x6c, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, -0x45, 0x66, 0x61, 0x74, 0x65, 0x0, 0x43, 0x53, 0x54, 0x36, 0x43, 0x44, 0x54, 0x0, 0x41, 0x6d, -0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x57, 0x69, 0x6e, 0x6e, 0x69, 0x70, 0x65, 0x67, 0x20, 0x41, -0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x61, 0x69, 0x6e, 0x79, 0x5f, 0x52, 0x69, 0x76, -0x65, 0x72, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x61, 0x6e, 0x6b, 0x69, -0x6e, 0x5f, 0x49, 0x6e, 0x6c, 0x65, 0x74, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, -0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, -0x2f, 0x4d, 0x61, 0x74, 0x61, 0x6d, 0x6f, 0x72, 0x6f, 0x73, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x4f, 0x6a, 0x69, 0x6e, 0x61, 0x67, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x43, 0x68, 0x69, 0x63, 0x61, 0x67, 0x6f, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x4b, 0x6e, 0x6f, 0x78, 0x20, -0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, -0x54, 0x65, 0x6c, 0x6c, 0x5f, 0x43, 0x69, 0x74, 0x79, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, -0x61, 0x2f, 0x4d, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x65, 0x65, 0x20, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x5f, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, -0x2f, 0x42, 0x65, 0x75, 0x6c, 0x61, 0x68, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, -0x4e, 0x6f, 0x72, 0x74, 0x68, 0x5f, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x2f, 0x43, 0x65, 0x6e, -0x74, 0x65, 0x72, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x6f, 0x72, 0x74, -0x68, 0x5f, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x2f, 0x4e, 0x65, 0x77, 0x5f, 0x53, 0x61, 0x6c, -0x65, 0x6d, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x65, 0x78, 0x69, 0x63, -0x6f, 0x5f, 0x43, 0x69, 0x74, 0x79, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, -0x61, 0x68, 0x69, 0x61, 0x5f, 0x42, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x61, 0x73, 0x20, 0x41, 0x6d, -0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x65, 0x72, 0x69, 0x64, 0x61, 0x20, 0x41, 0x6d, 0x65, -0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x6f, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x65, 0x79, 0x20, 0x41, -0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x68, 0x69, 0x68, 0x75, 0x61, 0x68, 0x75, 0x61, -0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x43, 0x68, 0x61, 0x74, 0x68, 0x61, 0x6d, -0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x53, 0x68, 0x61, 0x6e, 0x67, 0x68, 0x61, 0x69, 0x0, 0x41, -0x73, 0x69, 0x61, 0x2f, 0x48, 0x6f, 0x6e, 0x67, 0x5f, 0x4b, 0x6f, 0x6e, 0x67, 0x0, 0x41, 0x73, -0x69, 0x61, 0x2f, 0x4d, 0x61, 0x63, 0x61, 0x75, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, -0x2f, 0x48, 0x61, 0x76, 0x61, 0x6e, 0x61, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, -0x31, 0x32, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x33, 0x0, 0x41, 0x6e, 0x74, -0x61, 0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x79, 0x6f, 0x77, 0x61, 0x0, 0x49, 0x6e, -0x64, 0x69, 0x61, 0x6e, 0x2f, 0x43, 0x6f, 0x6d, 0x6f, 0x72, 0x6f, 0x0, 0x41, 0x66, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x44, 0x6a, 0x69, 0x62, 0x6f, 0x75, 0x74, 0x69, 0x0, 0x41, 0x66, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x41, 0x73, 0x6d, 0x65, 0x72, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, -0x2f, 0x41, 0x64, 0x64, 0x69, 0x73, 0x5f, 0x41, 0x62, 0x61, 0x62, 0x61, 0x0, 0x41, 0x66, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x4e, 0x61, 0x69, 0x72, 0x6f, 0x62, 0x69, 0x0, 0x49, 0x6e, 0x64, 0x69, -0x61, 0x6e, 0x2f, 0x41, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x6e, 0x61, 0x72, 0x69, 0x76, 0x6f, 0x0, -0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, 0x4d, 0x61, 0x79, 0x6f, 0x74, 0x74, 0x65, 0x0, 0x41, -0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x6f, 0x67, 0x61, 0x64, 0x69, 0x73, 0x68, 0x75, 0x0, -0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x61, 0x72, 0x5f, 0x65, 0x73, 0x5f, 0x53, 0x61, -0x6c, 0x61, 0x61, 0x6d, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4b, 0x61, 0x6d, 0x70, -0x61, 0x6c, 0x61, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x42, 0x72, -0x69, 0x73, 0x62, 0x61, 0x6e, 0x65, 0x20, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, -0x2f, 0x4c, 0x69, 0x6e, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, -0x2f, 0x43, 0x68, 0x69, 0x73, 0x69, 0x6e, 0x61, 0x75, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, -0x61, 0x2f, 0x53, 0x61, 0x6f, 0x5f, 0x50, 0x61, 0x75, 0x6c, 0x6f, 0x0, 0x50, 0x61, 0x63, 0x69, -0x66, 0x69, 0x63, 0x2f, 0x45, 0x61, 0x73, 0x74, 0x65, 0x72, 0x0, 0x45, 0x53, 0x54, 0x35, 0x45, -0x44, 0x54, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x61, 0x73, 0x73, 0x61, -0x75, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, 0x6f, 0x72, 0x6f, 0x6e, 0x74, -0x6f, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x71, 0x61, 0x6c, 0x75, 0x69, -0x74, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x6f, 0x6e, 0x74, 0x72, 0x65, -0x61, 0x6c, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x69, 0x70, 0x69, 0x67, -0x6f, 0x6e, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x61, 0x6e, 0x67, 0x6e, -0x69, 0x72, 0x74, 0x75, 0x6e, 0x67, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, -0x68, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x5f, 0x42, 0x61, 0x79, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x4e, 0x65, 0x77, 0x5f, 0x59, 0x6f, 0x72, 0x6b, 0x20, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x44, 0x65, 0x74, 0x72, 0x6f, 0x69, 0x74, 0x20, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x50, 0x65, 0x74, 0x65, -0x72, 0x73, 0x62, 0x75, 0x72, 0x67, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, -0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x56, 0x69, 0x6e, 0x63, 0x65, 0x6e, 0x6e, 0x65, 0x73, -0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, -0x2f, 0x57, 0x69, 0x6e, 0x61, 0x6d, 0x61, 0x63, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, -0x2f, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x2f, 0x4d, 0x6f, 0x6e, 0x74, 0x69, 0x63, -0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x6f, 0x75, -0x69, 0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, -0x43, 0x61, 0x6e, 0x63, 0x75, 0x6e, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, -0x69, 0x72, 0x6f, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x59, 0x65, 0x6b, 0x61, 0x74, 0x65, 0x72, -0x69, 0x6e, 0x62, 0x75, 0x72, 0x67, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x46, -0x69, 0x6a, 0x69, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x61, 0x72, 0x69, 0x65, -0x68, 0x61, 0x6d, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, 0x6f, 0x66, 0x69, -0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x54, 0x61, 0x6c, 0x6c, 0x69, 0x6e, 0x6e, -0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x48, 0x65, 0x6c, 0x73, 0x69, 0x6e, 0x6b, 0x69, -0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x52, 0x69, 0x67, 0x61, 0x0, 0x45, 0x75, 0x72, -0x6f, 0x70, 0x65, 0x2f, 0x56, 0x69, 0x6c, 0x6e, 0x69, 0x75, 0x73, 0x0, 0x45, 0x75, 0x72, 0x6f, -0x70, 0x65, 0x2f, 0x4b, 0x69, 0x65, 0x76, 0x20, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x55, -0x7a, 0x68, 0x67, 0x6f, 0x72, 0x6f, 0x64, 0x20, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x5a, -0x61, 0x70, 0x6f, 0x72, 0x6f, 0x7a, 0x68, 0x79, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x54, -0x62, 0x69, 0x6c, 0x69, 0x73, 0x69, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, -0x46, 0x61, 0x65, 0x72, 0x6f, 0x65, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x47, 0x75, -0x65, 0x72, 0x6e, 0x73, 0x65, 0x79, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x44, 0x75, -0x62, 0x6c, 0x69, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x49, 0x73, 0x6c, 0x65, -0x5f, 0x6f, 0x66, 0x5f, 0x4d, 0x61, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4a, -0x65, 0x72, 0x73, 0x65, 0x79, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4c, 0x69, 0x73, -0x62, 0x6f, 0x6e, 0x20, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x4d, 0x61, 0x64, -0x65, 0x69, 0x72, 0x61, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x43, 0x61, -0x6e, 0x61, 0x72, 0x79, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4c, 0x6f, 0x6e, 0x64, -0x6f, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x47, 0x6f, 0x64, 0x74, 0x68, -0x61, 0x62, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4f, 0x75, 0x61, 0x67, 0x61, 0x64, -0x6f, 0x75, 0x67, 0x6f, 0x75, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x61, 0x6e, -0x6a, 0x75, 0x6c, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x63, 0x63, 0x72, 0x61, -0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x61, 0x6e, 0x6d, 0x61, 0x72, 0x6b, -0x73, 0x68, 0x61, 0x76, 0x6e, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x69, 0x73, -0x73, 0x61, 0x75, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x6f, 0x6e, 0x61, 0x6b, -0x72, 0x79, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x52, 0x65, 0x79, 0x6b, -0x6a, 0x61, 0x76, 0x69, 0x6b, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x62, 0x69, -0x64, 0x6a, 0x61, 0x6e, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x6f, 0x6e, 0x72, -0x6f, 0x76, 0x69, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x61, 0x6d, 0x61, -0x6b, 0x6f, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x6f, 0x75, 0x61, 0x6b, 0x63, -0x68, 0x6f, 0x74, 0x74, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x53, 0x74, -0x5f, 0x48, 0x65, 0x6c, 0x65, 0x6e, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, -0x61, 0x6b, 0x61, 0x72, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x46, 0x72, 0x65, 0x65, -0x74, 0x6f, 0x77, 0x6e, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x6f, 0x6d, 0x65, -0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4e, 0x69, 0x63, 0x6f, 0x73, 0x69, 0x61, 0x20, 0x41, 0x73, -0x69, 0x61, 0x2f, 0x46, 0x61, 0x6d, 0x61, 0x67, 0x75, 0x73, 0x74, 0x61, 0x0, 0x45, 0x75, 0x72, -0x6f, 0x70, 0x65, 0x2f, 0x41, 0x74, 0x68, 0x65, 0x6e, 0x73, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, -0x65, 0x2f, 0x42, 0x75, 0x63, 0x68, 0x61, 0x72, 0x65, 0x73, 0x74, 0x0, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x50, 0x6f, 0x72, 0x74, 0x2d, 0x61, 0x75, 0x2d, 0x50, 0x72, 0x69, 0x6e, -0x63, 0x65, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x31, 0x30, 0x0, 0x50, 0x61, -0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x52, 0x61, 0x72, 0x6f, 0x74, 0x6f, 0x6e, 0x67, 0x61, 0x0, -0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x54, 0x61, 0x68, 0x69, 0x74, 0x69, 0x0, 0x50, -0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x74, 0x6f, 0x6e, 0x0, -0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x48, 0x6f, 0x6e, 0x6f, 0x6c, 0x75, 0x6c, 0x75, -0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x43, 0x61, 0x6c, 0x63, 0x75, 0x74, 0x74, 0x61, 0x0, 0x41, -0x73, 0x69, 0x61, 0x2f, 0x54, 0x65, 0x68, 0x72, 0x61, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, -0x4a, 0x65, 0x72, 0x75, 0x73, 0x61, 0x6c, 0x65, 0x6d, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x41, -0x6d, 0x6d, 0x61, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4b, 0x61, 0x6c, 0x69, -0x6e, 0x69, 0x6e, 0x67, 0x72, 0x61, 0x64, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x53, 0x65, 0x6f, -0x75, 0x6c, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, 0x72, 0x69, 0x70, 0x6f, 0x6c, -0x69, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x31, 0x34, 0x0, 0x50, 0x61, 0x63, -0x69, 0x66, 0x69, 0x63, 0x2f, 0x4b, 0x69, 0x72, 0x69, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x69, 0x0, -0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x4c, 0x6f, 0x72, 0x64, 0x5f, 0x48, -0x6f, 0x77, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4d, 0x61, 0x67, 0x61, 0x64, 0x61, 0x6e, -0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x75, 0x6e, 0x74, 0x61, 0x5f, 0x41, -0x72, 0x65, 0x6e, 0x61, 0x73, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4d, 0x61, -0x72, 0x71, 0x75, 0x65, 0x73, 0x61, 0x73, 0x0, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, 0x4d, -0x61, 0x75, 0x72, 0x69, 0x74, 0x69, 0x75, 0x73, 0x0, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, -0x52, 0x65, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x0, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, 0x4d, -0x61, 0x68, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x42, 0x65, 0x69, 0x72, 0x75, 0x74, 0x0, -0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x6f, 0x6e, 0x74, 0x65, 0x76, 0x69, 0x64, -0x65, 0x6f, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x73, 0x61, 0x62, 0x6c, -0x61, 0x6e, 0x63, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x45, 0x6c, 0x5f, 0x41, -0x61, 0x69, 0x75, 0x6e, 0x0, 0x4d, 0x53, 0x54, 0x37, 0x4d, 0x44, 0x54, 0x0, 0x41, 0x6d, 0x65, -0x72, 0x69, 0x63, 0x61, 0x2f, 0x45, 0x64, 0x6d, 0x6f, 0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x41, 0x6d, -0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x6d, 0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x5f, -0x42, 0x61, 0x79, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, 0x75, 0x76, -0x69, 0x6b, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x59, 0x65, 0x6c, 0x6c, 0x6f, -0x77, 0x6b, 0x6e, 0x69, 0x66, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, -0x69, 0x75, 0x64, 0x61, 0x64, 0x5f, 0x4a, 0x75, 0x61, 0x72, 0x65, 0x7a, 0x0, 0x41, 0x6d, 0x65, -0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x65, 0x6e, 0x76, 0x65, 0x72, 0x20, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x42, 0x6f, 0x69, 0x73, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, -0x61, 0x2f, 0x4d, 0x61, 0x7a, 0x61, 0x74, 0x6c, 0x61, 0x6e, 0x0, 0x49, 0x6e, 0x64, 0x69, 0x61, -0x6e, 0x2f, 0x43, 0x6f, 0x63, 0x6f, 0x73, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x52, 0x61, 0x6e, -0x67, 0x6f, 0x6f, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4e, 0x6f, 0x76, 0x6f, 0x73, 0x69, -0x62, 0x69, 0x72, 0x73, 0x6b, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x57, 0x69, 0x6e, -0x64, 0x68, 0x6f, 0x65, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x61, 0x74, 0x6d, 0x61, -0x6e, 0x64, 0x75, 0x0, 0x41, 0x6e, 0x74, 0x61, 0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x4d, -0x63, 0x4d, 0x75, 0x72, 0x64, 0x6f, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x41, -0x75, 0x63, 0x6b, 0x6c, 0x61, 0x6e, 0x64, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, -0x53, 0x74, 0x5f, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, -0x2f, 0x4e, 0x6f, 0x72, 0x66, 0x6f, 0x6c, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x49, 0x72, -0x6b, 0x75, 0x74, 0x73, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x72, 0x61, 0x73, 0x6e, -0x6f, 0x79, 0x61, 0x72, 0x73, 0x6b, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4e, 0x6f, 0x76, 0x6f, -0x6b, 0x75, 0x7a, 0x6e, 0x65, 0x74, 0x73, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x50, 0x79, -0x6f, 0x6e, 0x67, 0x79, 0x61, 0x6e, 0x67, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4f, 0x6d, 0x73, -0x6b, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x61, 0x6e, 0x74, 0x69, 0x61, -0x67, 0x6f, 0x0, 0x50, 0x53, 0x54, 0x38, 0x50, 0x44, 0x54, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x56, 0x61, 0x6e, 0x63, 0x6f, 0x75, 0x76, 0x65, 0x72, 0x0, 0x41, 0x6d, 0x65, -0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x6f, 0x73, 0x5f, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x65, 0x73, -0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, 0x69, 0x6a, 0x75, 0x61, 0x6e, 0x61, -0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x61, 0x6e, 0x74, 0x61, 0x5f, 0x49, -0x73, 0x61, 0x62, 0x65, 0x6c, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x61, 0x72, 0x61, 0x63, -0x68, 0x69, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x73, 0x75, 0x6e, 0x63, -0x69, 0x6f, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x51, 0x79, 0x7a, 0x79, 0x6c, 0x6f, 0x72, -0x64, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x72, 0x75, 0x73, 0x73, 0x65, -0x6c, 0x73, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x43, 0x6f, 0x70, 0x65, 0x6e, 0x68, -0x61, 0x67, 0x65, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x50, 0x61, 0x72, 0x69, -0x73, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x61, 0x64, 0x72, 0x69, 0x64, 0x20, -0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x65, 0x75, 0x74, 0x61, 0x0, 0x41, 0x73, 0x69, -0x61, 0x2f, 0x53, 0x72, 0x65, 0x64, 0x6e, 0x65, 0x6b, 0x6f, 0x6c, 0x79, 0x6d, 0x73, 0x6b, 0x0, -0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x61, 0x6d, 0x63, 0x68, 0x61, 0x74, 0x6b, 0x61, 0x20, 0x41, -0x73, 0x69, 0x61, 0x2f, 0x41, 0x6e, 0x61, 0x64, 0x79, 0x72, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, -0x65, 0x2f, 0x53, 0x61, 0x6d, 0x61, 0x72, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, -0x4d, 0x6f, 0x73, 0x63, 0x6f, 0x77, 0x20, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4b, 0x69, -0x72, 0x6f, 0x76, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, 0x69, 0x6d, 0x66, 0x65, -0x72, 0x6f, 0x70, 0x6f, 0x6c, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x33, 0x0, -0x41, 0x6e, 0x74, 0x61, 0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x6f, 0x74, 0x68, 0x65, -0x72, 0x61, 0x20, 0x41, 0x6e, 0x74, 0x61, 0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x61, -0x6c, 0x6d, 0x65, 0x72, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x46, 0x6f, 0x72, -0x74, 0x61, 0x6c, 0x65, 0x7a, 0x61, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, -0x65, 0x6c, 0x65, 0x6d, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x63, -0x65, 0x69, 0x6f, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x65, 0x63, 0x69, -0x66, 0x65, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x61, 0x6e, 0x74, 0x61, -0x72, 0x65, 0x6d, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x53, 0x74, 0x61, -0x6e, 0x6c, 0x65, 0x79, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x79, -0x65, 0x6e, 0x6e, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x61, 0x72, -0x61, 0x6d, 0x61, 0x72, 0x69, 0x62, 0x6f, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, -0x35, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x69, 0x6f, 0x5f, 0x42, 0x72, -0x61, 0x6e, 0x63, 0x6f, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x45, 0x69, 0x72, -0x75, 0x6e, 0x65, 0x70, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x6f, -0x72, 0x61, 0x6c, 0x5f, 0x48, 0x61, 0x72, 0x62, 0x6f, 0x75, 0x72, 0x0, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x79, 0x6d, 0x61, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x42, 0x6f, 0x67, 0x6f, 0x74, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, -0x61, 0x2f, 0x47, 0x75, 0x61, 0x79, 0x61, 0x71, 0x75, 0x69, 0x6c, 0x0, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x4a, 0x61, 0x6d, 0x61, 0x69, 0x63, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x50, 0x61, 0x6e, 0x61, 0x6d, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x4c, 0x69, 0x6d, 0x61, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, -0x34, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x6e, 0x67, 0x75, 0x69, 0x6c, -0x6c, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x6e, 0x74, 0x69, 0x67, -0x75, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x75, 0x62, 0x61, -0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x61, 0x72, 0x62, 0x61, 0x64, 0x6f, -0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x61, 0x5f, 0x50, 0x61, 0x7a, -0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x6e, 0x61, 0x75, 0x73, 0x20, -0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x6f, 0x61, 0x5f, 0x56, 0x69, 0x73, 0x74, -0x61, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x6f, 0x72, 0x74, 0x6f, 0x5f, -0x56, 0x65, 0x6c, 0x68, 0x6f, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, 0x6f, -0x72, 0x74, 0x6f, 0x6c, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x6c, -0x61, 0x6e, 0x63, 0x2d, 0x53, 0x61, 0x62, 0x6c, 0x6f, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x4b, 0x72, 0x61, 0x6c, 0x65, 0x6e, 0x64, 0x69, 0x6a, 0x6b, 0x0, 0x41, 0x6d, -0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x75, 0x72, 0x61, 0x63, 0x61, 0x6f, 0x0, 0x41, 0x6d, -0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x6f, 0x6d, 0x69, 0x6e, 0x69, 0x63, 0x61, 0x0, 0x41, -0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x61, 0x6e, 0x74, 0x6f, 0x5f, 0x44, 0x6f, 0x6d, -0x69, 0x6e, 0x67, 0x6f, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x47, 0x72, 0x65, -0x6e, 0x61, 0x64, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x47, 0x75, 0x61, -0x64, 0x65, 0x6c, 0x6f, 0x75, 0x70, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, -0x47, 0x75, 0x79, 0x61, 0x6e, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, -0x61, 0x72, 0x74, 0x69, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, -0x61, 0x2f, 0x4d, 0x6f, 0x6e, 0x74, 0x73, 0x65, 0x72, 0x72, 0x61, 0x74, 0x0, 0x41, 0x6d, 0x65, -0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x75, 0x65, 0x72, 0x74, 0x6f, 0x5f, 0x52, 0x69, 0x63, 0x6f, -0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x74, 0x5f, 0x42, 0x61, 0x72, 0x74, -0x68, 0x65, 0x6c, 0x65, 0x6d, 0x79, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, -0x74, 0x5f, 0x4b, 0x69, 0x74, 0x74, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, -0x53, 0x74, 0x5f, 0x4c, 0x75, 0x63, 0x69, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, -0x2f, 0x4d, 0x61, 0x72, 0x69, 0x67, 0x6f, 0x74, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, -0x2f, 0x53, 0x74, 0x5f, 0x56, 0x69, 0x6e, 0x63, 0x65, 0x6e, 0x74, 0x0, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x4c, 0x6f, 0x77, 0x65, 0x72, 0x5f, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x65, -0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x6f, 0x72, 0x74, 0x5f, 0x6f, -0x66, 0x5f, 0x53, 0x70, 0x61, 0x69, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, -0x53, 0x74, 0x5f, 0x54, 0x68, 0x6f, 0x6d, 0x61, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, -0x61, 0x2f, 0x4d, 0x69, 0x71, 0x75, 0x65, 0x6c, 0x6f, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, -0x53, 0x61, 0x6b, 0x68, 0x61, 0x6c, 0x69, 0x6e, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, -0x2f, 0x41, 0x70, 0x69, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x61, 0x6f, -0x5f, 0x54, 0x6f, 0x6d, 0x65, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, 0x61, 0x72, -0x61, 0x74, 0x6f, 0x76, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x37, 0x0, 0x41, -0x6e, 0x74, 0x61, 0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x61, 0x76, 0x69, 0x73, 0x0, -0x41, 0x73, 0x69, 0x61, 0x2f, 0x50, 0x68, 0x6e, 0x6f, 0x6d, 0x5f, 0x50, 0x65, 0x6e, 0x68, 0x0, -0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x6d, 0x61, 0x73, -0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4a, 0x61, 0x6b, 0x61, 0x72, 0x74, 0x61, 0x20, 0x41, 0x73, -0x69, 0x61, 0x2f, 0x50, 0x6f, 0x6e, 0x74, 0x69, 0x61, 0x6e, 0x61, 0x6b, 0x0, 0x41, 0x73, 0x69, -0x61, 0x2f, 0x56, 0x69, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6e, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, -0x2f, 0x42, 0x61, 0x6e, 0x67, 0x6b, 0x6f, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x53, 0x61, -0x69, 0x67, 0x6f, 0x6e, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x38, 0x0, 0x41, -0x73, 0x69, 0x61, 0x2f, 0x42, 0x72, 0x75, 0x6e, 0x65, 0x69, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, -0x4d, 0x61, 0x6b, 0x61, 0x73, 0x73, 0x61, 0x72, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x75, -0x61, 0x6c, 0x61, 0x5f, 0x4c, 0x75, 0x6d, 0x70, 0x75, 0x72, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, -0x4b, 0x75, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4d, 0x61, 0x6e, -0x69, 0x6c, 0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x53, 0x69, 0x6e, 0x67, 0x61, 0x70, 0x6f, -0x72, 0x65, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x32, 0x0, 0x41, 0x66, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x47, 0x61, 0x62, 0x6f, 0x72, 0x6f, 0x6e, 0x65, 0x0, 0x41, 0x66, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x42, 0x75, 0x6a, 0x75, 0x6d, 0x62, 0x75, 0x72, 0x61, 0x0, 0x41, 0x66, -0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x75, 0x62, 0x75, 0x6d, 0x62, 0x61, 0x73, 0x68, 0x69, 0x0, -0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x62, 0x61, 0x62, 0x61, 0x6e, 0x65, 0x0, 0x41, -0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x73, 0x65, 0x72, 0x75, 0x0, 0x41, 0x66, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x42, 0x6c, 0x61, 0x6e, 0x74, 0x79, 0x72, 0x65, 0x0, 0x41, 0x66, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x70, 0x75, 0x74, 0x6f, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, -0x61, 0x2f, 0x4b, 0x69, 0x67, 0x61, 0x6c, 0x69, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, -0x4a, 0x6f, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x73, 0x62, 0x75, 0x72, 0x67, 0x0, 0x41, 0x66, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x4c, 0x75, 0x73, 0x61, 0x6b, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, -0x61, 0x2f, 0x48, 0x61, 0x72, 0x61, 0x72, 0x65, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, -0x4a, 0x75, 0x62, 0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x43, 0x6f, 0x6c, 0x6f, 0x6d, 0x62, -0x6f, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4b, 0x68, 0x61, 0x72, 0x74, 0x6f, 0x75, -0x6d, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x44, 0x61, 0x6d, 0x61, 0x73, 0x63, 0x75, 0x73, 0x0, -0x41, 0x73, 0x69, 0x61, 0x2f, 0x54, 0x61, 0x69, 0x70, 0x65, 0x69, 0x0, 0x41, 0x75, 0x73, 0x74, -0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x48, 0x6f, 0x62, 0x61, 0x72, 0x74, 0x20, 0x41, 0x75, 0x73, -0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x43, 0x75, 0x72, 0x72, 0x69, 0x65, 0x20, 0x41, 0x6e, -0x74, 0x61, 0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x63, 0x71, 0x75, 0x61, 0x72, -0x69, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x61, 0x67, 0x75, -0x61, 0x69, 0x6e, 0x61, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x39, 0x0, 0x41, -0x73, 0x69, 0x61, 0x2f, 0x4a, 0x61, 0x79, 0x61, 0x70, 0x75, 0x72, 0x61, 0x0, 0x41, 0x73, 0x69, -0x61, 0x2f, 0x54, 0x6f, 0x6b, 0x79, 0x6f, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, -0x50, 0x61, 0x6c, 0x61, 0x75, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x44, 0x69, 0x6c, 0x69, 0x0, -0x41, 0x73, 0x69, 0x61, 0x2f, 0x54, 0x6f, 0x6d, 0x73, 0x6b, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, -0x69, 0x63, 0x2f, 0x54, 0x6f, 0x6e, 0x67, 0x61, 0x74, 0x61, 0x70, 0x75, 0x0, 0x41, 0x73, 0x69, -0x61, 0x2f, 0x43, 0x68, 0x69, 0x74, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x49, -0x73, 0x74, 0x61, 0x6e, 0x62, 0x75, 0x6c, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, -0x47, 0x72, 0x61, 0x6e, 0x64, 0x5f, 0x54, 0x75, 0x72, 0x6b, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, -0x55, 0x6c, 0x61, 0x61, 0x6e, 0x62, 0x61, 0x61, 0x74, 0x61, 0x72, 0x20, 0x41, 0x73, 0x69, 0x61, -0x2f, 0x43, 0x68, 0x6f, 0x69, 0x62, 0x61, 0x6c, 0x73, 0x61, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x70, 0x6f, 0x6c, 0x69, 0x73, -0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, -0x2f, 0x4d, 0x61, 0x72, 0x65, 0x6e, 0x67, 0x6f, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, -0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x56, 0x65, 0x76, 0x61, 0x79, 0x0, 0x45, -0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x37, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, -0x2f, 0x43, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, -0x2f, 0x44, 0x61, 0x77, 0x73, 0x6f, 0x6e, 0x5f, 0x43, 0x72, 0x65, 0x65, 0x6b, 0x20, 0x41, 0x6d, -0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x46, 0x6f, 0x72, 0x74, 0x5f, 0x4e, 0x65, 0x6c, 0x73, 0x6f, -0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x48, 0x65, 0x72, 0x6d, 0x6f, 0x73, -0x69, 0x6c, 0x6c, 0x6f, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x68, 0x6f, -0x65, 0x6e, 0x69, 0x78, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x55, 0x54, 0x43, 0x20, 0x45, 0x74, 0x63, -0x2f, 0x47, 0x4d, 0x54, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x31, 0x32, 0x0, -0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x54, 0x61, 0x72, 0x61, 0x77, 0x61, 0x0, 0x50, -0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4d, 0x61, 0x6a, 0x75, 0x72, 0x6f, 0x20, 0x50, 0x61, -0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4b, 0x77, 0x61, 0x6a, 0x61, 0x6c, 0x65, 0x69, 0x6e, 0x0, -0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4e, 0x61, 0x75, 0x72, 0x75, 0x0, 0x50, 0x61, -0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x46, 0x75, 0x6e, 0x61, 0x66, 0x75, 0x74, 0x69, 0x0, 0x50, -0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x57, 0x61, 0x6b, 0x65, 0x0, 0x50, 0x61, 0x63, 0x69, -0x66, 0x69, 0x63, 0x2f, 0x57, 0x61, 0x6c, 0x6c, 0x69, 0x73, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, -0x4d, 0x54, 0x2d, 0x31, 0x33, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x45, 0x6e, -0x64, 0x65, 0x72, 0x62, 0x75, 0x72, 0x79, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, -0x46, 0x61, 0x6b, 0x61, 0x6f, 0x66, 0x6f, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, -0x32, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x6f, 0x72, 0x6f, 0x6e, 0x68, -0x61, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x53, 0x6f, 0x75, 0x74, 0x68, -0x5f, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, -0x2b, 0x38, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x50, 0x69, 0x74, 0x63, 0x61, -0x69, 0x72, 0x6e, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x39, 0x0, 0x50, 0x61, -0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x47, 0x61, 0x6d, 0x62, 0x69, 0x65, 0x72, 0x0, 0x45, 0x74, -0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x31, 0x31, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, -0x2f, 0x50, 0x61, 0x67, 0x6f, 0x5f, 0x50, 0x61, 0x67, 0x6f, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, -0x69, 0x63, 0x2f, 0x4e, 0x69, 0x75, 0x65, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, -0x4d, 0x69, 0x64, 0x77, 0x61, 0x79, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, -0x61, 0x72, 0x61, 0x63, 0x61, 0x73, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x56, 0x6c, 0x61, 0x64, -0x69, 0x76, 0x6f, 0x73, 0x74, 0x6f, 0x6b, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x55, 0x73, 0x74, -0x2d, 0x4e, 0x65, 0x72, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x56, 0x6f, 0x6c, -0x67, 0x6f, 0x67, 0x72, 0x61, 0x64, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, -0x2f, 0x50, 0x65, 0x72, 0x74, 0x68, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x31, -0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x6c, 0x67, 0x69, 0x65, 0x72, 0x73, 0x0, -0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x75, 0x61, 0x6e, 0x64, 0x61, 0x0, 0x41, 0x66, -0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x6f, 0x72, 0x74, 0x6f, 0x2d, 0x4e, 0x6f, 0x76, 0x6f, 0x0, -0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x6f, 0x75, 0x61, 0x6c, 0x61, 0x0, 0x41, 0x66, -0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x61, 0x6e, 0x67, 0x75, 0x69, 0x0, 0x41, 0x66, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x4e, 0x64, 0x6a, 0x61, 0x6d, 0x65, 0x6e, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x42, 0x72, 0x61, 0x7a, 0x7a, 0x61, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x0, 0x41, -0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4b, 0x69, 0x6e, 0x73, 0x68, 0x61, 0x73, 0x61, 0x0, 0x41, -0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x6c, 0x61, 0x62, 0x6f, 0x0, 0x41, 0x66, 0x72, -0x69, 0x63, 0x61, 0x2f, 0x4c, 0x69, 0x62, 0x72, 0x65, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x0, 0x41, -0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x61, 0x67, 0x6f, 0x73, 0x0, 0x41, 0x66, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x4e, 0x69, 0x61, 0x6d, 0x65, 0x79, 0x0, 0x41, 0x66, 0x72, 0x69, 0x63, 0x61, -0x2f, 0x54, 0x75, 0x6e, 0x69, 0x73, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x41, 0x6e, -0x64, 0x6f, 0x72, 0x72, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x56, 0x69, 0x65, -0x6e, 0x6e, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x65, 0x72, 0x6c, 0x69, -0x6e, 0x20, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x65, -0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x47, 0x69, 0x62, 0x72, 0x61, 0x6c, 0x74, -0x61, 0x72, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x52, 0x6f, 0x6d, 0x65, 0x0, 0x45, -0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x56, 0x61, 0x64, 0x75, 0x7a, 0x0, 0x45, 0x75, 0x72, 0x6f, -0x70, 0x65, 0x2f, 0x4c, 0x75, 0x78, 0x65, 0x6d, 0x62, 0x6f, 0x75, 0x72, 0x67, 0x0, 0x45, 0x75, -0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x61, 0x6c, 0x74, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, -0x65, 0x2f, 0x4d, 0x6f, 0x6e, 0x61, 0x63, 0x6f, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, -0x41, 0x6d, 0x73, 0x74, 0x65, 0x72, 0x64, 0x61, 0x6d, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, -0x2f, 0x4f, 0x73, 0x6c, 0x6f, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x53, 0x61, 0x6e, -0x5f, 0x4d, 0x61, 0x72, 0x69, 0x6e, 0x6f, 0x0, 0x41, 0x72, 0x63, 0x74, 0x69, 0x63, 0x2f, 0x4c, -0x6f, 0x6e, 0x67, 0x79, 0x65, 0x61, 0x72, 0x62, 0x79, 0x65, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, -0x70, 0x65, 0x2f, 0x53, 0x74, 0x6f, 0x63, 0x6b, 0x68, 0x6f, 0x6c, 0x6d, 0x0, 0x45, 0x75, 0x72, -0x6f, 0x70, 0x65, 0x2f, 0x5a, 0x75, 0x72, 0x69, 0x63, 0x68, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, -0x65, 0x2f, 0x56, 0x61, 0x74, 0x69, 0x63, 0x61, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x48, -0x6f, 0x76, 0x64, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x35, 0x0, 0x41, 0x6e, -0x74, 0x61, 0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x77, 0x73, 0x6f, 0x6e, 0x0, -0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2f, 0x4b, 0x65, 0x72, 0x67, 0x75, 0x65, 0x6c, 0x65, 0x6e, -0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4f, 0x72, 0x61, 0x6c, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, -0x41, 0x71, 0x74, 0x61, 0x75, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x41, 0x71, 0x74, 0x6f, 0x62, -0x65, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x41, 0x74, 0x79, 0x72, 0x61, 0x75, 0x0, 0x49, 0x6e, -0x64, 0x69, 0x61, 0x6e, 0x2f, 0x4d, 0x61, 0x6c, 0x64, 0x69, 0x76, 0x65, 0x73, 0x0, 0x41, 0x73, -0x69, 0x61, 0x2f, 0x44, 0x75, 0x73, 0x68, 0x61, 0x6e, 0x62, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, -0x2f, 0x41, 0x73, 0x68, 0x67, 0x61, 0x62, 0x61, 0x74, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x54, -0x61, 0x73, 0x68, 0x6b, 0x65, 0x6e, 0x74, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x53, 0x61, 0x6d, -0x61, 0x72, 0x6b, 0x61, 0x6e, 0x64, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x48, 0x65, 0x62, 0x72, -0x6f, 0x6e, 0x20, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x47, 0x61, 0x7a, 0x61, 0x0, 0x45, 0x74, 0x63, -0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x31, 0x30, 0x0, 0x41, 0x6e, 0x74, 0x61, 0x72, 0x63, 0x74, 0x69, -0x63, 0x61, 0x2f, 0x44, 0x75, 0x6d, 0x6f, 0x6e, 0x74, 0x44, 0x55, 0x72, 0x76, 0x69, 0x6c, 0x6c, -0x65, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x47, 0x75, 0x61, 0x6d, 0x0, 0x50, -0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x54, 0x72, 0x75, 0x6b, 0x0, 0x50, 0x61, 0x63, 0x69, -0x66, 0x69, 0x63, 0x2f, 0x53, 0x61, 0x69, 0x70, 0x61, 0x6e, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, -0x69, 0x63, 0x2f, 0x50, 0x6f, 0x72, 0x74, 0x5f, 0x4d, 0x6f, 0x72, 0x65, 0x73, 0x62, 0x79, 0x0, -0x41, 0x73, 0x69, 0x61, 0x2f, 0x59, 0x61, 0x6b, 0x75, 0x74, 0x73, 0x6b, 0x20, 0x41, 0x73, 0x69, -0x61, 0x2f, 0x4b, 0x68, 0x61, 0x6e, 0x64, 0x79, 0x67, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, -0x63, 0x61, 0x2f, 0x57, 0x68, 0x69, 0x74, 0x65, 0x68, 0x6f, 0x72, 0x73, 0x65, 0x20, 0x41, 0x6d, -0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x61, 0x77, 0x73, 0x6f, 0x6e, 0x0, 0x41, 0x6d, 0x65, -0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x0, 0x41, -0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x42, 0x75, 0x65, 0x6e, 0x6f, 0x73, 0x5f, 0x41, 0x69, -0x72, 0x65, 0x73, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x41, 0x73, 0x74, 0x72, 0x61, -0x6b, 0x68, 0x61, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x48, 0x61, 0x6c, -0x69, 0x66, 0x61, 0x78, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x53, -0x79, 0x64, 0x6e, 0x65, 0x79, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x65, -0x67, 0x69, 0x6e, 0x61, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x41, -0x64, 0x65, 0x6c, 0x61, 0x69, 0x64, 0x65, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x41, 0x6c, 0x6d, -0x61, 0x74, 0x79, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x75, 0x69, 0x61, -0x62, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x68, 0x69, 0x63, 0x61, -0x67, 0x6f, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x65, 0x78, 0x69, 0x63, -0x6f, 0x5f, 0x43, 0x69, 0x74, 0x79, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, -0x2f, 0x42, 0x72, 0x69, 0x73, 0x62, 0x61, 0x6e, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, -0x61, 0x2f, 0x4e, 0x65, 0x77, 0x5f, 0x59, 0x6f, 0x72, 0x6b, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, -0x65, 0x2f, 0x4b, 0x69, 0x65, 0x76, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, -0x65, 0x6e, 0x76, 0x65, 0x72, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x72, 0x61, 0x73, 0x6e, -0x6f, 0x79, 0x61, 0x72, 0x73, 0x6b, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, -0x69, 0x6a, 0x75, 0x61, 0x6e, 0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x61, 0x6d, 0x63, -0x68, 0x61, 0x74, 0x6b, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x6f, 0x73, -0x63, 0x6f, 0x77, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x48, 0x6f, -0x62, 0x61, 0x72, 0x74, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x55, 0x6c, 0x61, 0x61, 0x6e, 0x62, -0x61, 0x61, 0x74, 0x61, 0x72, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, -0x64, 0x69, 0x61, 0x6e, 0x61, 0x70, 0x6f, 0x6c, 0x69, 0x73, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x55, -0x54, 0x43, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x56, 0x6c, 0x61, 0x64, 0x69, 0x76, 0x6f, 0x73, -0x74, 0x6f, 0x6b, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x42, 0x65, 0x72, 0x6c, 0x69, -0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x54, 0x61, 0x73, 0x68, 0x6b, 0x65, 0x6e, 0x74, 0x0, -0x41, 0x73, 0x69, 0x61, 0x2f, 0x48, 0x65, 0x62, 0x72, 0x6f, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, -0x2f, 0x59, 0x61, 0x6b, 0x75, 0x74, 0x73, 0x6b, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, -0x2f, 0x57, 0x68, 0x69, 0x74, 0x65, 0x68, 0x6f, 0x72, 0x73, 0x65, 0x0, 0x55, 0x54, 0x43, 0x2d, -0x31, 0x34, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x31, 0x33, 0x3a, 0x30, 0x30, 0x0, -0x55, 0x54, 0x43, 0x2d, 0x31, 0x32, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x31, 0x31, -0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x31, 0x30, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, -0x43, 0x2d, 0x30, 0x39, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x38, 0x3a, 0x30, -0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x37, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, -0x30, 0x36, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x35, 0x3a, 0x30, 0x30, 0x0, -0x55, 0x54, 0x43, 0x2d, 0x30, 0x34, 0x3a, 0x33, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x34, -0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x33, 0x3a, 0x33, 0x30, 0x0, 0x55, 0x54, -0x43, 0x2d, 0x30, 0x33, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x32, 0x3a, 0x30, -0x30, 0x0, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x31, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x20, -0x55, 0x54, 0x43, 0x2b, 0x30, 0x30, 0x3a, 0x30, 0x30, 0x20, 0x55, 0x54, 0x43, 0x2d, 0x30, 0x30, -0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x31, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, -0x43, 0x2b, 0x30, 0x32, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x33, 0x3a, 0x30, -0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x33, 0x3a, 0x33, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, -0x30, 0x34, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x34, 0x3a, 0x33, 0x30, 0x0, -0x55, 0x54, 0x43, 0x2b, 0x30, 0x35, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x35, -0x3a, 0x33, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x35, 0x3a, 0x34, 0x35, 0x0, 0x55, 0x54, -0x43, 0x2b, 0x30, 0x36, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x36, 0x3a, 0x33, -0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x37, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, -0x30, 0x38, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x38, 0x3a, 0x33, 0x30, 0x0, -0x55, 0x54, 0x43, 0x2b, 0x30, 0x39, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x30, 0x39, -0x3a, 0x33, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x31, 0x30, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, -0x43, 0x2b, 0x31, 0x31, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x31, 0x32, 0x3a, 0x30, -0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, 0x31, 0x33, 0x3a, 0x30, 0x30, 0x0, 0x55, 0x54, 0x43, 0x2b, -0x31, 0x34, 0x3a, 0x30, 0x30, 0x0 +0x43, 0x6f, 0x72, 0x64, 0x6f, 0x62, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, +0x45, 0x6e, 0x73, 0x65, 0x6e, 0x61, 0x64, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x54, 0x69, 0x6a, 0x75, 0x61, 0x6e, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x46, 0x6f, 0x72, 0x74, 0x5f, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, +0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, +0x61, 0x6e, 0x61, 0x70, 0x6f, 0x6c, 0x69, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x47, 0x6f, 0x64, 0x74, 0x68, 0x61, 0x62, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x4e, 0x75, 0x75, 0x6b, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, +0x64, 0x69, 0x61, 0x6e, 0x61, 0x70, 0x6f, 0x6c, 0x69, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x4a, 0x75, 0x6a, 0x75, 0x79, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x4a, 0x75, 0x6a, 0x75, 0x79, +0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4b, 0x6e, 0x6f, 0x78, 0x5f, 0x49, 0x4e, +0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, +0x2f, 0x4b, 0x6e, 0x6f, 0x78, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x6f, +0x75, 0x69, 0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x2f, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x76, +0x69, 0x6c, 0x6c, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x65, 0x6e, +0x64, 0x6f, 0x7a, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x72, 0x67, +0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x4d, 0x65, 0x6e, 0x64, 0x6f, 0x7a, 0x61, 0x0, 0x41, +0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x6f, 0x6e, 0x74, 0x72, 0x65, 0x61, 0x6c, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, 0x6f, 0x72, 0x6f, 0x6e, 0x74, 0x6f, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x69, 0x70, 0x69, 0x67, 0x6f, 0x6e, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x61, 0x6e, 0x67, 0x6e, 0x69, 0x72, 0x74, +0x75, 0x6e, 0x67, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x49, 0x71, 0x61, 0x6c, +0x75, 0x69, 0x74, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x6f, 0x72, 0x74, +0x6f, 0x5f, 0x41, 0x63, 0x72, 0x65, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, +0x69, 0x6f, 0x5f, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x6f, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x52, 0x61, 0x69, 0x6e, 0x79, 0x5f, 0x52, 0x69, 0x76, 0x65, 0x72, 0x0, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x57, 0x69, 0x6e, 0x6e, 0x69, 0x70, 0x65, 0x67, 0x0, 0x41, +0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x52, 0x6f, 0x73, 0x61, 0x72, 0x69, 0x6f, 0x0, 0x41, +0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x61, 0x6e, 0x74, 0x61, 0x5f, 0x49, 0x73, 0x61, +0x62, 0x65, 0x6c, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x68, 0x69, 0x70, +0x72, 0x6f, 0x63, 0x6b, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x65, 0x6e, +0x76, 0x65, 0x72, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x54, 0x68, 0x75, 0x6e, +0x64, 0x65, 0x72, 0x5f, 0x42, 0x61, 0x79, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, +0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, +0x74, 0x5f, 0x54, 0x68, 0x6f, 0x6d, 0x61, 0x73, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x59, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6b, 0x6e, 0x69, 0x66, 0x65, 0x0, 0x41, 0x6d, 0x65, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x45, 0x64, 0x6d, 0x6f, 0x6e, 0x74, 0x6f, 0x6e, 0x0, 0x41, 0x6e, +0x74, 0x61, 0x72, 0x63, 0x74, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x5f, 0x50, +0x6f, 0x6c, 0x65, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x41, 0x75, 0x63, 0x6b, +0x6c, 0x61, 0x6e, 0x64, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x41, 0x73, 0x68, 0x6b, 0x68, 0x61, +0x62, 0x61, 0x64, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x41, 0x73, 0x68, 0x67, 0x61, 0x62, 0x61, +0x74, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x43, 0x61, 0x6c, 0x63, 0x75, 0x74, 0x74, 0x61, 0x0, +0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x6f, 0x6c, 0x6b, 0x61, 0x74, 0x61, 0x0, 0x41, 0x73, 0x69, +0x61, 0x2f, 0x43, 0x68, 0x6f, 0x6e, 0x67, 0x71, 0x69, 0x6e, 0x67, 0x0, 0x41, 0x73, 0x69, 0x61, +0x2f, 0x53, 0x68, 0x61, 0x6e, 0x67, 0x68, 0x61, 0x69, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x43, +0x68, 0x75, 0x6e, 0x67, 0x6b, 0x69, 0x6e, 0x67, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x44, 0x61, +0x63, 0x63, 0x61, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x44, 0x68, 0x61, 0x6b, 0x61, 0x0, 0x41, +0x73, 0x69, 0x61, 0x2f, 0x48, 0x61, 0x72, 0x62, 0x69, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, +0x49, 0x73, 0x74, 0x61, 0x6e, 0x62, 0x75, 0x6c, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, +0x49, 0x73, 0x74, 0x61, 0x6e, 0x62, 0x75, 0x6c, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x61, +0x73, 0x68, 0x67, 0x61, 0x72, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x55, 0x72, 0x75, 0x6d, 0x71, +0x69, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x61, 0x74, 0x6d, 0x61, 0x6e, 0x64, 0x75, 0x0, +0x41, 0x73, 0x69, 0x61, 0x2f, 0x4b, 0x61, 0x74, 0x68, 0x6d, 0x61, 0x6e, 0x64, 0x75, 0x0, 0x41, +0x73, 0x69, 0x61, 0x2f, 0x4d, 0x61, 0x63, 0x61, 0x6f, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4d, +0x61, 0x63, 0x61, 0x75, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x52, 0x61, 0x6e, 0x67, 0x6f, 0x6f, +0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x59, 0x61, 0x6e, 0x67, 0x6f, 0x6e, 0x0, 0x41, 0x73, +0x69, 0x61, 0x2f, 0x53, 0x61, 0x69, 0x67, 0x6f, 0x6e, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x48, +0x6f, 0x5f, 0x43, 0x68, 0x69, 0x5f, 0x4d, 0x69, 0x6e, 0x68, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, +0x54, 0x65, 0x6c, 0x5f, 0x41, 0x76, 0x69, 0x76, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4a, 0x65, +0x72, 0x75, 0x73, 0x61, 0x6c, 0x65, 0x6d, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x54, 0x68, 0x69, +0x6d, 0x62, 0x75, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x54, 0x68, 0x69, 0x6d, 0x70, 0x68, 0x75, +0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x55, 0x6a, 0x75, 0x6e, 0x67, 0x5f, 0x50, 0x61, 0x6e, 0x64, +0x61, 0x6e, 0x67, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x4d, 0x61, 0x6b, 0x61, 0x73, 0x73, 0x61, +0x72, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x55, 0x6c, 0x61, 0x6e, 0x5f, 0x42, 0x61, 0x74, 0x6f, +0x72, 0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x55, 0x6c, 0x61, 0x61, 0x6e, 0x62, 0x61, 0x61, 0x74, +0x61, 0x72, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x46, 0x61, 0x65, 0x72, +0x6f, 0x65, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x46, 0x61, 0x72, 0x6f, +0x65, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x4a, 0x61, 0x6e, 0x5f, 0x4d, +0x61, 0x79, 0x65, 0x6e, 0x0, 0x41, 0x72, 0x63, 0x74, 0x69, 0x63, 0x2f, 0x4c, 0x6f, 0x6e, 0x67, +0x79, 0x65, 0x61, 0x72, 0x62, 0x79, 0x65, 0x6e, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, +0x69, 0x61, 0x2f, 0x41, 0x43, 0x54, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, +0x2f, 0x53, 0x79, 0x64, 0x6e, 0x65, 0x79, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, +0x61, 0x2f, 0x43, 0x61, 0x6e, 0x62, 0x65, 0x72, 0x72, 0x61, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, +0x61, 0x6c, 0x69, 0x61, 0x2f, 0x43, 0x75, 0x72, 0x72, 0x69, 0x65, 0x0, 0x41, 0x75, 0x73, 0x74, +0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x48, 0x6f, 0x62, 0x61, 0x72, 0x74, 0x0, 0x41, 0x75, 0x73, +0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x4c, 0x48, 0x49, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, +0x61, 0x6c, 0x69, 0x61, 0x2f, 0x4c, 0x6f, 0x72, 0x64, 0x5f, 0x48, 0x6f, 0x77, 0x65, 0x0, 0x41, +0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x4e, 0x53, 0x57, 0x0, 0x41, 0x75, 0x73, +0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x0, 0x41, 0x75, 0x73, +0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x44, 0x61, 0x72, 0x77, 0x69, 0x6e, 0x0, 0x41, 0x75, +0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x51, 0x75, 0x65, 0x65, 0x6e, 0x73, 0x6c, 0x61, +0x6e, 0x64, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x42, 0x72, 0x69, +0x73, 0x62, 0x61, 0x6e, 0x65, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, +0x53, 0x6f, 0x75, 0x74, 0x68, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, +0x41, 0x64, 0x65, 0x6c, 0x61, 0x69, 0x64, 0x65, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, +0x69, 0x61, 0x2f, 0x54, 0x61, 0x73, 0x6d, 0x61, 0x6e, 0x69, 0x61, 0x0, 0x41, 0x75, 0x73, 0x74, +0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x56, 0x69, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x0, 0x41, +0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x4d, 0x65, 0x6c, 0x62, 0x6f, 0x75, 0x72, +0x6e, 0x65, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x57, 0x65, 0x73, +0x74, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x50, 0x65, 0x72, 0x74, +0x68, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x2f, 0x59, 0x61, 0x6e, 0x63, +0x6f, 0x77, 0x69, 0x6e, 0x6e, 0x61, 0x0, 0x41, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x61, +0x2f, 0x42, 0x72, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x48, 0x69, 0x6c, 0x6c, 0x0, 0x42, 0x72, 0x61, +0x7a, 0x69, 0x6c, 0x2f, 0x41, 0x63, 0x72, 0x65, 0x0, 0x42, 0x72, 0x61, 0x7a, 0x69, 0x6c, 0x2f, +0x44, 0x65, 0x4e, 0x6f, 0x72, 0x6f, 0x6e, 0x68, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, +0x61, 0x2f, 0x4e, 0x6f, 0x72, 0x6f, 0x6e, 0x68, 0x61, 0x0, 0x42, 0x72, 0x61, 0x7a, 0x69, 0x6c, +0x2f, 0x45, 0x61, 0x73, 0x74, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x61, +0x6f, 0x5f, 0x50, 0x61, 0x75, 0x6c, 0x6f, 0x0, 0x42, 0x72, 0x61, 0x7a, 0x69, 0x6c, 0x2f, 0x57, +0x65, 0x73, 0x74, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4d, 0x61, 0x6e, 0x61, +0x75, 0x73, 0x0, 0x43, 0x61, 0x6e, 0x61, 0x64, 0x61, 0x2f, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, +0x69, 0x63, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x48, 0x61, 0x6c, 0x69, 0x66, +0x61, 0x78, 0x0, 0x43, 0x61, 0x6e, 0x61, 0x64, 0x61, 0x2f, 0x43, 0x65, 0x6e, 0x74, 0x72, 0x61, +0x6c, 0x0, 0x43, 0x61, 0x6e, 0x61, 0x64, 0x61, 0x2f, 0x45, 0x61, 0x73, 0x74, 0x2d, 0x53, 0x61, +0x73, 0x6b, 0x61, 0x74, 0x63, 0x68, 0x65, 0x77, 0x61, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x52, 0x65, 0x67, 0x69, 0x6e, 0x61, 0x0, 0x43, 0x61, 0x6e, 0x61, 0x64, 0x61, +0x2f, 0x45, 0x61, 0x73, 0x74, 0x65, 0x72, 0x6e, 0x0, 0x43, 0x61, 0x6e, 0x61, 0x64, 0x61, 0x2f, +0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x0, 0x43, 0x61, 0x6e, 0x61, 0x64, 0x61, 0x2f, +0x4e, 0x65, 0x77, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x6c, 0x61, 0x6e, 0x64, 0x0, 0x41, 0x6d, 0x65, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x74, 0x5f, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x0, 0x43, 0x61, +0x6e, 0x61, 0x64, 0x61, 0x2f, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x0, 0x41, 0x6d, 0x65, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x56, 0x61, 0x6e, 0x63, 0x6f, 0x75, 0x76, 0x65, 0x72, 0x0, 0x43, +0x61, 0x6e, 0x61, 0x64, 0x61, 0x2f, 0x53, 0x61, 0x73, 0x6b, 0x61, 0x74, 0x63, 0x68, 0x65, 0x77, +0x61, 0x6e, 0x0, 0x43, 0x61, 0x6e, 0x61, 0x64, 0x61, 0x2f, 0x59, 0x75, 0x6b, 0x6f, 0x6e, 0x0, +0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x57, 0x68, 0x69, 0x74, 0x65, 0x68, 0x6f, 0x72, +0x73, 0x65, 0x0, 0x43, 0x68, 0x69, 0x6c, 0x65, 0x2f, 0x43, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x65, +0x6e, 0x74, 0x61, 0x6c, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x53, 0x61, 0x6e, +0x74, 0x69, 0x61, 0x67, 0x6f, 0x0, 0x43, 0x68, 0x69, 0x6c, 0x65, 0x2f, 0x45, 0x61, 0x73, 0x74, +0x65, 0x72, 0x49, 0x73, 0x6c, 0x61, 0x6e, 0x64, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, +0x2f, 0x45, 0x61, 0x73, 0x74, 0x65, 0x72, 0x0, 0x43, 0x75, 0x62, 0x61, 0x0, 0x41, 0x6d, 0x65, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x48, 0x61, 0x76, 0x61, 0x6e, 0x61, 0x0, 0x45, 0x53, 0x54, 0x0, +0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x35, 0x0, 0x45, 0x67, 0x79, 0x70, 0x74, 0x0, +0x41, 0x66, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x43, 0x61, 0x69, 0x72, 0x6f, 0x0, 0x45, 0x69, 0x72, +0x65, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x44, 0x75, 0x62, 0x6c, 0x69, 0x6e, 0x0, +0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x30, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, +0x54, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2d, 0x30, 0x0, 0x45, 0x74, 0x63, 0x2f, +0x47, 0x4d, 0x54, 0x30, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x77, 0x69, +0x63, 0x68, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x55, 0x43, 0x54, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x55, +0x54, 0x43, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x61, 0x6c, +0x0, 0x45, 0x74, 0x63, 0x2f, 0x5a, 0x75, 0x6c, 0x75, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, +0x2f, 0x42, 0x65, 0x6c, 0x66, 0x61, 0x73, 0x74, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, +0x4c, 0x6f, 0x6e, 0x64, 0x6f, 0x6e, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4b, 0x69, +0x65, 0x76, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4b, 0x79, 0x69, 0x76, 0x0, 0x45, +0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4e, 0x69, 0x63, 0x6f, 0x73, 0x69, 0x61, 0x0, 0x41, 0x73, +0x69, 0x61, 0x2f, 0x4e, 0x69, 0x63, 0x6f, 0x73, 0x69, 0x61, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, +0x65, 0x2f, 0x54, 0x69, 0x72, 0x61, 0x73, 0x70, 0x6f, 0x6c, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, +0x65, 0x2f, 0x43, 0x68, 0x69, 0x73, 0x69, 0x6e, 0x61, 0x75, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, +0x65, 0x2f, 0x55, 0x7a, 0x68, 0x67, 0x6f, 0x72, 0x6f, 0x64, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, +0x65, 0x2f, 0x5a, 0x61, 0x70, 0x6f, 0x72, 0x6f, 0x7a, 0x68, 0x79, 0x65, 0x0, 0x47, 0x42, 0x0, +0x47, 0x42, 0x2d, 0x45, 0x69, 0x72, 0x65, 0x0, 0x47, 0x4d, 0x54, 0x0, 0x47, 0x4d, 0x54, 0x2b, +0x30, 0x0, 0x47, 0x4d, 0x54, 0x2d, 0x30, 0x0, 0x47, 0x4d, 0x54, 0x30, 0x0, 0x47, 0x72, 0x65, +0x65, 0x6e, 0x77, 0x69, 0x63, 0x68, 0x0, 0x48, 0x53, 0x54, 0x0, 0x45, 0x74, 0x63, 0x2f, 0x47, +0x4d, 0x54, 0x2b, 0x31, 0x30, 0x0, 0x48, 0x6f, 0x6e, 0x67, 0x6b, 0x6f, 0x6e, 0x67, 0x0, 0x41, +0x73, 0x69, 0x61, 0x2f, 0x48, 0x6f, 0x6e, 0x67, 0x5f, 0x4b, 0x6f, 0x6e, 0x67, 0x0, 0x49, 0x63, +0x65, 0x6c, 0x61, 0x6e, 0x64, 0x0, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x2f, 0x52, +0x65, 0x79, 0x6b, 0x6a, 0x61, 0x76, 0x69, 0x6b, 0x0, 0x49, 0x72, 0x61, 0x6e, 0x0, 0x41, 0x73, +0x69, 0x61, 0x2f, 0x54, 0x65, 0x68, 0x72, 0x61, 0x6e, 0x0, 0x49, 0x73, 0x72, 0x61, 0x65, 0x6c, +0x0, 0x4a, 0x61, 0x6d, 0x61, 0x69, 0x63, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x4a, 0x61, 0x6d, 0x61, 0x69, 0x63, 0x61, 0x0, 0x4a, 0x61, 0x70, 0x61, 0x6e, 0x0, 0x41, +0x73, 0x69, 0x61, 0x2f, 0x54, 0x6f, 0x6b, 0x79, 0x6f, 0x0, 0x4b, 0x77, 0x61, 0x6a, 0x61, 0x6c, +0x65, 0x69, 0x6e, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4b, 0x77, 0x61, 0x6a, +0x61, 0x6c, 0x65, 0x69, 0x6e, 0x0, 0x4c, 0x69, 0x62, 0x79, 0x61, 0x0, 0x41, 0x66, 0x72, 0x69, +0x63, 0x61, 0x2f, 0x54, 0x72, 0x69, 0x70, 0x6f, 0x6c, 0x69, 0x0, 0x4d, 0x53, 0x54, 0x0, 0x45, +0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0x2b, 0x37, 0x0, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x2f, +0x42, 0x61, 0x6a, 0x61, 0x4e, 0x6f, 0x72, 0x74, 0x65, 0x0, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, +0x2f, 0x42, 0x61, 0x6a, 0x61, 0x53, 0x75, 0x72, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x4d, 0x61, 0x7a, 0x61, 0x74, 0x6c, 0x61, 0x6e, 0x0, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, +0x2f, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x5f, 0x43, 0x69, 0x74, 0x79, 0x0, 0x4e, 0x5a, 0x0, +0x4e, 0x5a, 0x2d, 0x43, 0x48, 0x41, 0x54, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, +0x43, 0x68, 0x61, 0x74, 0x68, 0x61, 0x6d, 0x0, 0x4e, 0x61, 0x76, 0x61, 0x6a, 0x6f, 0x0, 0x50, +0x52, 0x43, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x45, 0x6e, 0x64, 0x65, 0x72, +0x62, 0x75, 0x72, 0x79, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4b, 0x61, 0x6e, +0x74, 0x6f, 0x6e, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x4a, 0x6f, 0x68, 0x6e, +0x73, 0x74, 0x6f, 0x6e, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x48, 0x6f, 0x6e, +0x6f, 0x6c, 0x75, 0x6c, 0x75, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x50, 0x6f, +0x6e, 0x61, 0x70, 0x65, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x50, 0x6f, 0x68, +0x6e, 0x70, 0x65, 0x69, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x53, 0x61, 0x6d, +0x6f, 0x61, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x50, 0x61, 0x67, 0x6f, 0x5f, +0x50, 0x61, 0x67, 0x6f, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x54, 0x72, 0x75, +0x6b, 0x0, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x43, 0x68, 0x75, 0x75, 0x6b, 0x0, +0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x2f, 0x59, 0x61, 0x70, 0x0, 0x50, 0x6f, 0x6c, 0x61, +0x6e, 0x64, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x57, 0x61, 0x72, 0x73, 0x61, 0x77, +0x0, 0x50, 0x6f, 0x72, 0x74, 0x75, 0x67, 0x61, 0x6c, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, +0x2f, 0x4c, 0x69, 0x73, 0x62, 0x6f, 0x6e, 0x0, 0x52, 0x4f, 0x43, 0x0, 0x41, 0x73, 0x69, 0x61, +0x2f, 0x54, 0x61, 0x69, 0x70, 0x65, 0x69, 0x0, 0x52, 0x4f, 0x4b, 0x0, 0x41, 0x73, 0x69, 0x61, +0x2f, 0x53, 0x65, 0x6f, 0x75, 0x6c, 0x0, 0x53, 0x69, 0x6e, 0x67, 0x61, 0x70, 0x6f, 0x72, 0x65, +0x0, 0x41, 0x73, 0x69, 0x61, 0x2f, 0x53, 0x69, 0x6e, 0x67, 0x61, 0x70, 0x6f, 0x72, 0x65, 0x0, +0x54, 0x75, 0x72, 0x6b, 0x65, 0x79, 0x0, 0x55, 0x43, 0x54, 0x0, 0x55, 0x53, 0x2f, 0x41, 0x6c, +0x61, 0x73, 0x6b, 0x61, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x41, 0x6e, 0x63, +0x68, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x0, 0x55, 0x53, 0x2f, 0x41, 0x6c, 0x65, 0x75, 0x74, 0x69, +0x61, 0x6e, 0x0, 0x55, 0x53, 0x2f, 0x41, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61, 0x0, 0x41, 0x6d, +0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x50, 0x68, 0x6f, 0x65, 0x6e, 0x69, 0x78, 0x0, 0x55, 0x53, +0x2f, 0x43, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6c, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, +0x2f, 0x43, 0x68, 0x69, 0x63, 0x61, 0x67, 0x6f, 0x0, 0x55, 0x53, 0x2f, 0x45, 0x61, 0x73, 0x74, +0x2d, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x0, 0x55, 0x53, 0x2f, 0x45, 0x61, 0x73, 0x74, +0x65, 0x72, 0x6e, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4e, 0x65, 0x77, 0x5f, +0x59, 0x6f, 0x72, 0x6b, 0x0, 0x55, 0x53, 0x2f, 0x48, 0x61, 0x77, 0x61, 0x69, 0x69, 0x0, 0x55, +0x53, 0x2f, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x2d, 0x53, 0x74, 0x61, 0x72, 0x6b, 0x65, +0x0, 0x55, 0x53, 0x2f, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x0, 0x41, 0x6d, 0x65, +0x72, 0x69, 0x63, 0x61, 0x2f, 0x44, 0x65, 0x74, 0x72, 0x6f, 0x69, 0x74, 0x0, 0x55, 0x53, 0x2f, +0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x0, 0x55, 0x53, 0x2f, 0x50, 0x61, 0x63, 0x69, +0x66, 0x69, 0x63, 0x0, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2f, 0x4c, 0x6f, 0x73, 0x5f, +0x41, 0x6e, 0x67, 0x65, 0x6c, 0x65, 0x73, 0x0, 0x55, 0x53, 0x2f, 0x50, 0x61, 0x63, 0x69, 0x66, +0x69, 0x63, 0x2d, 0x4e, 0x65, 0x77, 0x0, 0x55, 0x53, 0x2f, 0x53, 0x61, 0x6d, 0x6f, 0x61, 0x0, +0x55, 0x54, 0x43, 0x0, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x61, 0x6c, 0x0, 0x57, 0x2d, +0x53, 0x55, 0x0, 0x45, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x2f, 0x4d, 0x6f, 0x73, 0x63, 0x6f, 0x77, +0x0, 0x5a, 0x75, 0x6c, 0x75, 0x0 }; // GENERATED PART ENDS HERE +constexpr QByteArrayView AliasData::aliasId() const { return aliasIdData + aliasIdIndex; } +constexpr QByteArrayView AliasData::ianaId() const { return aliasIdData + ianaIdIndex; } constexpr QByteArrayView WindowsData::windowsId() const { return windowsIdData + windowsIdIndex; } // Each of the following returns a space-joined sequence of IANA IDs: constexpr QByteArrayView WindowsData::ianaId() const { return ianaIdData + ianaIdIndex; } diff --git a/src/corelib/time/qtimezoneprivate_icu.cpp b/src/corelib/time/qtimezoneprivate_icu.cpp index 1a3baa70d0..a9fe68b83c 100644 --- a/src/corelib/time/qtimezoneprivate_icu.cpp +++ b/src/corelib/time/qtimezoneprivate_icu.cpp @@ -4,6 +4,7 @@ #include "qtimezone.h" #include "qtimezoneprivate_p.h" +#include "qtimezonelocale_p.h" #include <unicode/ucal.h> @@ -22,27 +23,6 @@ QT_BEGIN_NAMESPACE // ICU utilities -// Convert TimeType and NameType into ICU UCalendarDisplayNameType -static UCalendarDisplayNameType ucalDisplayNameType(QTimeZone::TimeType timeType, QTimeZone::NameType nameType) -{ - // TODO ICU C UCalendarDisplayNameType does not support full set of C++ TimeZone::EDisplayType - switch (nameType) { - case QTimeZone::ShortName : - case QTimeZone::OffsetName : - if (timeType == QTimeZone::DaylightTime) - return UCAL_SHORT_DST; - // Includes GenericTime - return UCAL_SHORT_STANDARD; - case QTimeZone::DefaultName : - case QTimeZone::LongName : - if (timeType == QTimeZone::DaylightTime) - return UCAL_DST; - // Includes GenericTime - return UCAL_STANDARD; - } - return UCAL_STANDARD; -} - // Qt wrapper around ucal_getDefaultTimeZone() static QByteArray ucalDefaultTimeZoneId() { @@ -69,44 +49,6 @@ static QByteArray ucalDefaultTimeZoneId() return QByteArray(); } -// Qt wrapper around ucal_getTimeZoneDisplayName() -static QString ucalTimeZoneDisplayName(UCalendar *ucal, QTimeZone::TimeType timeType, - QTimeZone::NameType nameType, - const QString &localeCode) -{ - int32_t size = 50; - QString result(size, Qt::Uninitialized); - UErrorCode status = U_ZERO_ERROR; - - // size = ucal_getTimeZoneDisplayName(cal, type, locale, result, resultLength, status) - size = ucal_getTimeZoneDisplayName(ucal, - ucalDisplayNameType(timeType, nameType), - localeCode.toUtf8(), - reinterpret_cast<UChar *>(result.data()), - size, - &status); - - // If overflow, then resize and retry - if (status == U_BUFFER_OVERFLOW_ERROR) { - result.resize(size); - status = U_ZERO_ERROR; - size = ucal_getTimeZoneDisplayName(ucal, - ucalDisplayNameType(timeType, nameType), - localeCode.toUtf8(), - reinterpret_cast<UChar *>(result.data()), - size, - &status); - } - - // If successful on first or second go, resize and return - if (U_SUCCESS(status)) { - result.resize(size); - return result; - } - - return QString(); -} - // Qt wrapper around ucal_get() for offsets static bool ucalOffsetsAtTime(UCalendar *m_ucal, qint64 atMSecsSinceEpoch, int *utcOffset, int *dstOffset) @@ -203,13 +145,11 @@ static QTimeZonePrivate::Data ucalTimeZoneTransition(UCalendar *m_ucal, tran.offsetFromUtc = utc + dst; tran.standardTimeOffset = utc; tran.daylightTimeOffset = dst; - // TODO No ICU API, use short name instead - if (dst == 0) - tran.abbreviation = ucalTimeZoneDisplayName(m_ucal, QTimeZone::StandardTime, - QTimeZone::ShortName, QLocale().name()); - else - tran.abbreviation = ucalTimeZoneDisplayName(m_ucal, QTimeZone::DaylightTime, - QTimeZone::ShortName, QLocale().name()); + // TODO No ICU API, use short name as abbreviation. + QTimeZone::TimeType timeType = dst == 0 ? QTimeZone::StandardTime : QTimeZone::DaylightTime; + using namespace QtTimeZoneLocale; + tran.abbreviation = ucalTimeZoneDisplayName(m_ucal, timeType, + QTimeZone::ShortName, QLocale().name()); return tran; } #endif // U_ICU_VERSION_SHORT @@ -317,6 +257,7 @@ QString QIcuTimeZonePrivate::displayName(QTimeZone::TimeType timeType, } // Technically this may be suspect, if locale isn't QLocale(), since that's // what we used when constructing m_ucal; does ICU cope with inconsistency ? + using namespace QtTimeZoneLocale; return ucalTimeZoneDisplayName(m_ucal, timeType, nameType, locale.name()); } diff --git a/src/corelib/time/qtimezoneprivate_p.h b/src/corelib/time/qtimezoneprivate_p.h index 506acaa1f7..7034a7285c 100644 --- a/src/corelib/time/qtimezoneprivate_p.h +++ b/src/corelib/time/qtimezoneprivate_p.h @@ -99,6 +99,8 @@ public: virtual bool isDaylightTime(qint64 atMSecsSinceEpoch) const; virtual Data data(qint64 forMSecsSinceEpoch) const; + virtual Data data(QTimeZone::TimeType timeType) const; + virtual bool isDataLocale(const QLocale &locale) const; QDateTimePrivate::ZoneState stateAtZoneTime(qint64 forLocalMSecs, QDateTimePrivate::TransitionOptions resolve) const; @@ -131,6 +133,7 @@ public: static QString isoOffsetFormat(int offsetFromUtc, QTimeZone::NameType mode = QTimeZone::OffsetName); + static QByteArray aliasToIana(QByteArrayView alias); static QByteArray ianaIdToWindowsId(const QByteArray &ianaId); static QByteArray windowsIdToDefaultIanaId(const QByteArray &windowsId); static QByteArray windowsIdToDefaultIanaId(const QByteArray &windowsId, @@ -150,6 +153,15 @@ public: return QByteArrayLiteral("UTC"); } +#if QT_CONFIG(timezone_locale) +private: + // Defined in qtimezonelocale.cpp + QString localeName(qint64 atMSecsSinceEpoch, int offsetFromUtc, + QTimeZone::TimeType timeType, + QTimeZone::NameType nameType, + const QLocale &locale) const; +#endif // L10n helpers. + protected: QByteArray m_id; }; @@ -179,11 +191,15 @@ public: QUtcTimeZonePrivate *clone() const override; Data data(qint64 forMSecsSinceEpoch) const override; + Data data(QTimeZone::TimeType timeType) const override; + bool isDataLocale(const QLocale &locale) const override; QLocale::Territory territory() const override; QString comment() const override; - using QTimeZonePrivate::displayName; + QString displayName(qint64 atMSecsSinceEpoch, + QTimeZone::NameType nameType, + const QLocale &locale) const override; QString displayName(QTimeZone::TimeType timeType, QTimeZone::NameType nameType, const QLocale &locale) const override; @@ -217,7 +233,7 @@ private: // TODO: shuffle (almost reverse) order of and rework #if-ery here to use #elif // and match the #if-ery in each of QTZ's newBackendTimeZone() cascades for // backend selection. -#if QT_CONFIG(icu) +#if QT_CONFIG(icu) && !defined(Q_OS_UNIX) class Q_AUTOTEST_EXPORT QIcuTimeZonePrivate final : public QTimeZonePrivate { public: @@ -241,6 +257,7 @@ public: bool hasDaylightTime() const override; bool isDaylightTime(qint64 atMSecsSinceEpoch) const override; + using QTimeZonePrivate::data; Data data(qint64 forMSecsSinceEpoch) const override; bool hasTransitions() const override; @@ -259,7 +276,7 @@ private: UCalendar *m_ucal; }; -#endif // ICU +#endif // ICU not on Unix. #if defined(Q_OS_UNIX) && !defined(Q_OS_DARWIN) && !defined(Q_OS_ANDROID) struct QTzTransitionTime @@ -321,6 +338,8 @@ public: bool isDaylightTime(qint64 atMSecsSinceEpoch) const override; Data data(qint64 forMSecsSinceEpoch) const override; + Data data(QTimeZone::TimeType timeType) const override; + bool isDataLocale(const QLocale &locale) const override; bool hasTransitions() const override; Data nextTransition(qint64 afterMSecsSinceEpoch) const override; @@ -338,14 +357,6 @@ private: Data dataForTzTransition(QTzTransitionTime tran) const; Data dataFromRule(QTzTransitionRule rule, qint64 msecsSinceEpoch) const; -#if QT_CONFIG(icu) -# ifdef __cpp_lib_is_final - static_assert(std::is_final<QIcuTimeZonePrivate>::value, - "if QIcuTimeZonePrivate isn't final, we may need to specialize " - "QExplicitlySharedDataPointer::clone() to call QTimeZonePrivate::clone()"); -# endif - mutable QExplicitlySharedDataPointer<const QIcuTimeZonePrivate> m_icu; -#endif QTzTimeZoneCacheEntry cached_data; const QList<QTzTransitionTime> &tranCache() const { return cached_data.m_tranTimes; } }; @@ -378,6 +389,7 @@ public: bool hasDaylightTime() const override; bool isDaylightTime(qint64 atMSecsSinceEpoch) const override; + using QTimeZonePrivate::data; Data data(qint64 forMSecsSinceEpoch) const override; bool hasTransitions() const override; @@ -432,6 +444,7 @@ public: bool hasDaylightTime() const override; bool isDaylightTime(qint64 atMSecsSinceEpoch) const override; + using QTimeZonePrivate::data; Data data(qint64 forMSecsSinceEpoch) const override; bool hasTransitions() const override; @@ -481,6 +494,7 @@ public: bool hasDaylightTime() const override; bool isDaylightTime(qint64 atMSecsSinceEpoch) const override; + using QTimeZonePrivate::data; Data data(qint64 forMSecsSinceEpoch) const override; QByteArray systemTimeZoneId() const override; diff --git a/src/corelib/time/qtimezoneprivate_tz.cpp b/src/corelib/time/qtimezoneprivate_tz.cpp index f6156fe93e..8d14e75193 100644 --- a/src/corelib/time/qtimezoneprivate_tz.cpp +++ b/src/corelib/time/qtimezoneprivate_tz.cpp @@ -33,10 +33,6 @@ QT_BEGIN_NAMESPACE using namespace Qt::StringLiterals; -#if QT_CONFIG(icu) -Q_CONSTINIT static QBasicMutex s_icu_mutex; -#endif - /* Private @@ -771,9 +767,6 @@ QTzTimeZonePrivate::~QTzTimeZonePrivate() QTzTimeZonePrivate *QTzTimeZonePrivate::clone() const { -#if QT_CONFIG(icu) - const auto lock = qt_scoped_lock(s_icu_mutex); -#endif return new QTzTimeZonePrivate(*this); } @@ -1007,15 +1000,7 @@ QTzTimeZonePrivate::QTzTimeZonePrivate(const QByteArray &ianaId) if (m_id.isEmpty()) { // This can only happen for the system zone, when we've read the // contents of /etc/localtime because it wasn't a symlink. -#if QT_CONFIG(icu) - // Use ICU's system zone, if only to avoid using the abbreviation as ID - // (ICU might mis-recognize it) in displayName(). - m_icu = new QIcuTimeZonePrivate(); - // Use its ID, as an alternate source of data: - m_id = m_icu->id(); - if (!m_id.isEmpty()) - return; -#endif + // TODO: use CLDR generic abbreviation for the zone. m_id = abbreviation(QDateTime::currentMSecsSinceEpoch()).toUtf8(); } } @@ -1034,70 +1019,19 @@ QString QTzTimeZonePrivate::displayName(QTimeZone::TimeType timeType, QTimeZone::NameType nameType, const QLocale &locale) const { - // TZ DB lacks localized names (it only has IANA IDs), so delegate to ICU - // for those, when available. -#if QT_CONFIG(icu) - { - auto lock = qt_scoped_lock(s_icu_mutex); - // TODO Some valid TZ names are not valid ICU names, use translation table? - if (!m_icu) - m_icu = new QIcuTimeZonePrivate(m_id); - if (m_icu->isValid()) - return m_icu->displayName(timeType, nameType, locale); - } -#else - Q_UNUSED(timeType); - Q_UNUSED(nameType); - Q_UNUSED(locale); -#endif - // If ICU is unavailable, fall back to abbreviations. - // Abbreviations don't have GenericTime - if (timeType == QTimeZone::GenericTime) - timeType = QTimeZone::StandardTime; - - // Get current tran, if valid and is what we want, then use it - const qint64 currentMSecs = QDateTime::currentMSecsSinceEpoch(); - QTimeZonePrivate::Data tran = data(currentMSecs); - if (tran.atMSecsSinceEpoch != invalidMSecs() - && ((timeType == QTimeZone::DaylightTime && tran.daylightTimeOffset != 0) - || (timeType == QTimeZone::StandardTime && tran.daylightTimeOffset == 0))) { - return tran.abbreviation; - } - - // Otherwise get next tran and if valid and is what we want, then use it - tran = nextTransition(currentMSecs); - if (tran.atMSecsSinceEpoch != invalidMSecs() - && ((timeType == QTimeZone::DaylightTime && tran.daylightTimeOffset != 0) - || (timeType == QTimeZone::StandardTime && tran.daylightTimeOffset == 0))) { - return tran.abbreviation; - } - - // Otherwise get prev tran and if valid and is what we want, then use it - tran = previousTransition(currentMSecs); - if (tran.atMSecsSinceEpoch != invalidMSecs()) - tran = previousTransition(tran.atMSecsSinceEpoch); - if (tran.atMSecsSinceEpoch != invalidMSecs() - && ((timeType == QTimeZone::DaylightTime && tran.daylightTimeOffset != 0) - || (timeType == QTimeZone::StandardTime && tran.daylightTimeOffset == 0))) { - return tran.abbreviation; - } - - // Otherwise is strange sequence, so work backwards through trans looking for first match, if any - auto it = std::partition_point(tranCache().cbegin(), tranCache().cend(), - [currentMSecs](const QTzTransitionTime &at) { - return at.atMSecsSinceEpoch <= currentMSecs; - }); - - while (it != tranCache().cbegin()) { - --it; - tran = dataForTzTransition(*it); - int offset = tran.daylightTimeOffset; - if ((timeType == QTimeZone::DaylightTime) != (offset == 0)) - return tran.abbreviation; + // TZ only provides C-locale abbreviations and offset: + if (nameType != QTimeZone::LongName && isDataLocale(locale)) { + QTimeZonePrivate::Data tran = data(timeType); + if (tran.atMSecsSinceEpoch != invalidMSecs()) { + if (nameType == QTimeZone::ShortName) + return tran.abbreviation; + // Save base class repeating the data(timeType) query: + if (locale.language() == QLocale::C) + return isoOffsetFormat(tran.offsetFromUtc); + } } - - // Otherwise if no match use current data - return data(currentMSecs).abbreviation; + // Otherwise, fall back to base class (and qtimezonelocale.cpp): + return QTimeZonePrivate::displayName(timeType, nameType, locale); } QString QTzTimeZonePrivate::abbreviation(qint64 atMSecsSinceEpoch) const @@ -1184,6 +1118,64 @@ QTimeZonePrivate::Data QTzTimeZonePrivate::data(qint64 forMSecsSinceEpoch) const return dataFromRule(cached_data.m_tranRules.at(last->ruleIndex), forMSecsSinceEpoch); } +// Overridden because the final iteration over transitions only needs to look +// forward and backwards one transition within the POSIX rule (when there is +// one, as is common) to settle the whole period it covers, so we can then skip +// all other transitions of the POSIX rule and iterate tranCache() backwards +// from its most recent transition. +QTimeZonePrivate::Data QTzTimeZonePrivate::data(QTimeZone::TimeType timeType) const +{ + // True if tran is valid and has the DST-ness to match timeType: + const auto validMatch = [timeType](const QTimeZonePrivate::Data &tran) { + return tran.atMSecsSinceEpoch != invalidMSecs() + && ((timeType == QTimeZone::DaylightTime) != (tran.daylightTimeOffset == 0)); + }; + + // Get current tran, use if suitable: + const qint64 currentMSecs = QDateTime::currentMSecsSinceEpoch(); + QTimeZonePrivate::Data tran = data(currentMSecs); + if (validMatch(tran)) + return tran; + + // Otherwise, next tran probably flips DST-ness: + tran = nextTransition(currentMSecs); + if (validMatch(tran)) + return tran; + + // Failing that, prev (or present, if current MSecs is eactly a transition + // moment) tran defines what data() got us and the one before that probably + // flips DST-ness: + tran = previousTransition(currentMSecs + 1); + if (tran.atMSecsSinceEpoch != invalidMSecs()) + tran = previousTransition(tran.atMSecsSinceEpoch); + if (validMatch(tran)) + return tran; + + // Otherwise, we can look backwards through transitions for a match; if we + // have a POSIX rule, it clearly doesn't do DST (or we'd have hit it by + // now), so we only need to look in the tranCache() up to now. + const auto untilNow = [currentMSecs](const QTzTransitionTime &at) { + return at.atMSecsSinceEpoch <= currentMSecs; + }; + auto it = std::partition_point(tranCache().cbegin(), tranCache().cend(), untilNow); + // That's the end or first future transition; we don't want to look at it, + // but at all those before it. + while (it != tranCache().cbegin()) { + --it; + tran = dataForTzTransition(*it); + if ((timeType == QTimeZone::DaylightTime) != (tran.daylightTimeOffset == 0)) + return tran; + } + + return {}; +} + +bool QTzTimeZonePrivate::isDataLocale(const QLocale &locale) const +{ + // TZ data uses English / C locale names: + return locale.language() == QLocale::C || locale.language() == QLocale::English; +} + bool QTzTimeZonePrivate::hasTransitions() const { return true; diff --git a/src/corelib/tools/qcontiguouscache.h b/src/corelib/tools/qcontiguouscache.h index c01dbb9390..e3f98c30de 100644 --- a/src/corelib/tools/qcontiguouscache.h +++ b/src/corelib/tools/qcontiguouscache.h @@ -8,6 +8,7 @@ #include <QtCore/qassert.h> #include <QtCore/qtclasshelpermacros.h> #include <QtCore/qtcoreexports.h> +#include <QtCore/qttypetraits.h> #include <QtCore/qtypeinfo.h> #include <climits> diff --git a/src/corelib/tools/qcryptographichash.cpp b/src/corelib/tools/qcryptographichash.cpp index 2e82a394ee..d0ed17eba2 100644 --- a/src/corelib/tools/qcryptographichash.cpp +++ b/src/corelib/tools/qcryptographichash.cpp @@ -1153,13 +1153,49 @@ void QCryptographicHashPrivate::State::finalizeUnchecked(QCryptographicHash::Alg \note In Qt versions prior to 6.3, this function took QByteArray, not QByteArrayView. + + \sa hashInto() */ QByteArray QCryptographicHash::hash(QByteArrayView data, Algorithm method) { + QByteArray ba(hashLengthInternal(method), Qt::Uninitialized); + [[maybe_unused]] const auto r = hashInto(ba, data, method); + Q_ASSERT(r.size() == ba.size()); + return ba; +} + +/*! + \since 6.8 + \fn QCryptographicHash::hashInto(QSpan<char> buffer, QSpan<const QByteArrayView> data, Algorithm method); + \fn QCryptographicHash::hashInto(QSpan<uchar> buffer, QSpan<const QByteArrayView> data, Algorithm method); + \fn QCryptographicHash::hashInto(QSpan<std::byte> buffer, QSpan<const QByteArrayView> data, Algorithm method); + \fn QCryptographicHash::hashInto(QSpan<char> buffer, QByteArrayView data, Algorithm method); + \fn QCryptographicHash::hashInto(QSpan<uchar> buffer, QByteArrayView data, Algorithm method); + \fn QCryptographicHash::hashInto(QSpan<std::byte> buffer, QByteArrayView data, Algorithm method); + + Returns the hash of \a data using \a method, using \a buffer to store the result. + + If \a data is a span, adds all the byte array views to the hash, in the order given. + + The return value will be a sub-span of \a buffer, unless \a buffer is of + insufficient size, in which case a null QByteArrayView is returned. + + \sa hash() +*/ +QByteArrayView QCryptographicHash::hashInto(QSpan<std::byte> buffer, + QSpan<const QByteArrayView> data, + Algorithm method) noexcept +{ QCryptographicHashPrivate hash(method); - hash.addData(data); + for (QByteArrayView part : data) + hash.addData(part); hash.finalizeUnchecked(); // no mutex needed: no-one but us has access to 'hash' - return hash.resultView().toByteArray(); + auto result = hash.resultView(); + if (buffer.size() < result.size()) + return {}; // buffer too small + // ### optimize: have the method directly write into `buffer` + memcpy(buffer.data(), result.data(), result.size()); + return buffer.first(result.size()); } /*! @@ -1338,7 +1374,7 @@ static HashBlock xored(const HashBlock &block, quint8 val) noexcept class QMessageAuthenticationCodePrivate { public: - QMessageAuthenticationCodePrivate(QCryptographicHash::Algorithm m) + explicit QMessageAuthenticationCodePrivate(QCryptographicHash::Algorithm m) noexcept : messageHash(m) { } @@ -1635,15 +1671,52 @@ void QMessageAuthenticationCodePrivate::finalizeUnchecked() noexcept the key \a key and the method \a method. \include qcryptographichash.cpp {qba-to-qbav-6.6} + + \sa hashInto() */ QByteArray QMessageAuthenticationCode::hash(QByteArrayView message, QByteArrayView key, QCryptographicHash::Algorithm method) { + QByteArray ba(hashLengthInternal(method), Qt::Uninitialized); + [[maybe_unused]] const auto r = hashInto(ba, message, key, method); + Q_ASSERT(r.size() == ba.size()); + return ba; +} + +/*! + \since 6.8 + \fn QMessageAuthenticationCode::hashInto(QSpan<char> buffer, QSpan<const QByteArrayView> messageParts, QByteArrayView key, QCryptographicHash::Algorithm method); + \fn QMessageAuthenticationCode::hashInto(QSpan<uchar> buffer, QSpan<const QByteArrayView> messageParts, QByteArrayView key, QCryptographicHash::Algorithm method); + \fn QMessageAuthenticationCode::hashInto(QSpan<std::byte> buffer, QSpan<const QByteArrayView> messageParts, QByteArrayView key, QCryptographicHash::Algorithm method); + \fn QMessageAuthenticationCode::hashInto(QSpan<char> buffer, QByteArrayView message, QByteArrayView key, QCryptographicHash::Algorithm method); + \fn QMessageAuthenticationCode::hashInto(QSpan<uchar> buffer, QByteArrayView message, QByteArrayView key, QCryptographicHash::Algorithm method); + \fn QMessageAuthenticationCode::hashInto(QSpan<std::byte> buffer, QByteArrayView message, QByteArrayView key, QCryptographicHash::Algorithm method); + + Returns the authentication code for the message (\a message or, for the + QSpan overloads, the concatenation of \a messageParts) using the key \a key + and the method \a method. + + The return value will be a sub-span of \a buffer, unless \a buffer is of + insufficient size, in which case a null QByteArrayView is returned. + + \sa hash() +*/ +QByteArrayView QMessageAuthenticationCode::hashInto(QSpan<std::byte> buffer, + QSpan<const QByteArrayView> messageParts, + QByteArrayView key, + QCryptographicHash::Algorithm method) noexcept +{ QMessageAuthenticationCodePrivate mac(method); mac.setKey(key); - mac.messageHash.addData(message); + for (QByteArrayView part : messageParts) + mac.messageHash.addData(part); mac.finalizeUnchecked(); - return mac.messageHash.resultView().toByteArray(); + auto result = mac.messageHash.resultView(); + if (buffer.size() < result.size()) + return {}; // buffer too small + // ### optimize: have the method directly write into `buffer` + memcpy(buffer.data(), result.data(), result.size()); + return buffer.first(result.size()); } QT_END_NAMESPACE diff --git a/src/corelib/tools/qcryptographichash.h b/src/corelib/tools/qcryptographichash.h index 294453adce..8c4f70457f 100644 --- a/src/corelib/tools/qcryptographichash.h +++ b/src/corelib/tools/qcryptographichash.h @@ -8,6 +8,7 @@ #include <QtCore/qbytearray.h> #include <QtCore/qobjectdefs.h> +#include <QtCore/qspan.h> QT_BEGIN_NAMESPACE @@ -91,6 +92,19 @@ public: static QByteArray hash(const QByteArray &data, Algorithm method); #endif static QByteArray hash(QByteArrayView data, Algorithm method); + + static QByteArrayView hashInto(QSpan<char> buffer, QByteArrayView data, Algorithm method) noexcept + { return hashInto(as_writable_bytes(buffer), {&data, 1}, method); } + static QByteArrayView hashInto(QSpan<uchar> buffer, QByteArrayView data, Algorithm method) noexcept + { return hashInto(as_writable_bytes(buffer), {&data, 1}, method); } + static QByteArrayView hashInto(QSpan<std::byte> buffer, QByteArrayView data, Algorithm method) noexcept + { return hashInto(buffer, {&data, 1}, method); } + static QByteArrayView hashInto(QSpan<char> buffer, QSpan<const QByteArrayView> data, Algorithm method) noexcept + { return hashInto(as_writable_bytes(buffer), data, method); } + static QByteArrayView hashInto(QSpan<uchar> buffer, QSpan<const QByteArrayView> data, Algorithm method) noexcept + { return hashInto(as_writable_bytes(buffer), data, method); } + static QByteArrayView hashInto(QSpan<std::byte> buffer, QSpan<const QByteArrayView> data, Algorithm method) noexcept; + static int hashLength(Algorithm method); static bool supportsAlgorithm(Algorithm method); private: diff --git a/src/corelib/tools/qeasingcurve.cpp b/src/corelib/tools/qeasingcurve.cpp index d8b3367de3..52602a0256 100644 --- a/src/corelib/tools/qeasingcurve.cpp +++ b/src/corelib/tools/qeasingcurve.cpp @@ -1153,32 +1153,37 @@ QEasingCurve::~QEasingCurve() */ /*! - Compare this easing curve with \a other and returns \c true if they are - equal. It will also compare the properties of a curve. + \fn bool QEasingCurve::operator==(const QEasingCurve &lhs, const QEasingCurve &rhs) + + Compares easing curve \a lhs with \a rhs and returns \c true if they are + equal; otherwise returns \c false. + It will also compare the properties of the curves. */ -bool QEasingCurve::operator==(const QEasingCurve &other) const +bool comparesEqual(const QEasingCurve &lhs, const QEasingCurve &rhs) noexcept { - bool res = d_ptr->func == other.d_ptr->func - && d_ptr->type == other.d_ptr->type; + bool res = lhs.d_ptr->func == rhs.d_ptr->func + && lhs.d_ptr->type == rhs.d_ptr->type; if (res) { - if (d_ptr->config && other.d_ptr->config) { + if (lhs.d_ptr->config && rhs.d_ptr->config) { // catch the config content - res = d_ptr->config->operator==(*(other.d_ptr->config)); + res = lhs.d_ptr->config->operator==(*(rhs.d_ptr->config)); - } else if (d_ptr->config || other.d_ptr->config) { + } else if (lhs.d_ptr->config || rhs.d_ptr->config) { // one one has a config object, which could contain default values - res = qFuzzyCompare(amplitude(), other.amplitude()) - && qFuzzyCompare(period(), other.period()) - && qFuzzyCompare(overshoot(), other.overshoot()); + res = qFuzzyCompare(lhs.amplitude(), rhs.amplitude()) + && qFuzzyCompare(lhs.period(), rhs.period()) + && qFuzzyCompare(lhs.overshoot(), rhs.overshoot()); } } return res; } /*! - \fn bool QEasingCurve::operator!=(const QEasingCurve &other) const - Compare this easing curve with \a other and returns \c true if they are not equal. - It will also compare the properties of a curve. + \fn bool QEasingCurve::operator!=(const QEasingCurve &lhs, const QEasingCurve &rhs) + + Compares easing curve \a lhs with \a rhs and returns \c true if they are + not equal; otherwise returns \c false. + It will also compare the properties of the curves. \sa operator==() */ diff --git a/src/corelib/tools/qeasingcurve.h b/src/corelib/tools/qeasingcurve.h index 5b112d7d7d..61e9aa247d 100644 --- a/src/corelib/tools/qeasingcurve.h +++ b/src/corelib/tools/qeasingcurve.h @@ -8,6 +8,7 @@ QT_REQUIRE_CONFIG(easingcurve); +#include <QtCore/qcompare.h> #include <QtCore/qlist.h> #include <QtCore/qobjectdefs.h> @@ -47,9 +48,11 @@ public: void swap(QEasingCurve &other) noexcept { qt_ptr_swap(d_ptr, other.d_ptr); } +#if QT_CORE_REMOVED_SINCE(6, 8) bool operator==(const QEasingCurve &other) const; inline bool operator!=(const QEasingCurve &other) const { return !(this->operator==(other)); } +#endif qreal amplitude() const; void setAmplitude(qreal amplitude); @@ -81,6 +84,11 @@ private: friend Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QEasingCurve &); friend Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QEasingCurve &); #endif + friend Q_CORE_EXPORT bool + comparesEqual(const QEasingCurve &lhs, const QEasingCurve &rhs) noexcept; +#if !QT_CORE_REMOVED_SINCE(6, 8) + Q_DECLARE_EQUALITY_COMPARABLE(QEasingCurve) +#endif }; Q_DECLARE_SHARED(QEasingCurve) diff --git a/src/corelib/tools/qhash.h b/src/corelib/tools/qhash.h index e7cd4123fb..9cc6fbf30b 100644 --- a/src/corelib/tools/qhash.h +++ b/src/corelib/tools/qhash.h @@ -11,6 +11,7 @@ #include <QtCore/qiterator.h> #include <QtCore/qlist.h> #include <QtCore/qrefcount.h> +#include <QtCore/qttypetraits.h> #include <initializer_list> #include <functional> // for std::hash diff --git a/src/corelib/tools/qline.cpp b/src/corelib/tools/qline.cpp index 9216b8875b..e313b06aa9 100644 --- a/src/corelib/tools/qline.cpp +++ b/src/corelib/tools/qline.cpp @@ -14,6 +14,9 @@ QT_BEGIN_NAMESPACE \class QLine \inmodule QtCore \ingroup painting + \compares equality + \compareswith equality QLineF + \endcompareswith \brief The QLine class provides a two-dimensional vector using integer precision. @@ -133,18 +136,18 @@ QT_BEGIN_NAMESPACE */ /*! - \fn bool QLine::operator!=(const QLine &line) const + \fn bool QLine::operator!=(const QLine &lhs, const QLine &rhs) - Returns \c true if the given \a line is not the same as \e this line. + Returns \c true if the line \a lhs is not the same as line \a rhs. A line is different from another line if any of their start or end points differ, or the internal order of the points is different. */ /*! - \fn bool QLine::operator==(const QLine &line) const + \fn bool QLine::operator==(const QLine &lhs, const QLine &rhs) - Returns \c true if the given \a line is the same as \e this line. + Returns \c true if the line \a lhs is the same as line \a rhs. A line is identical to another line if the start and end points are identical, and the internal order of the points is the same. @@ -288,6 +291,9 @@ QDataStream &operator>>(QDataStream &stream, QLine &line) \class QLineF \inmodule QtCore \ingroup painting + \compares equality + \compareswith equality QLine + \endcompareswith \brief The QLineF class provides a two-dimensional vector using floating point precision. @@ -508,18 +514,18 @@ QDataStream &operator>>(QDataStream &stream, QLine &line) */ /*! - \fn bool QLineF::operator!=(const QLineF &line) const + \fn bool QLineF::operator!=(const QLineF &lhs, const QLineF &rhs) - Returns \c true if the given \a line is not the same as \e this line. + Returns \c true if the line \a lhs is not the same as line \a rhs. A line is different from another line if their start or end points differ, or the internal order of the points is different. */ /*! - \fn bool QLineF::operator==(const QLineF &line) const + \fn bool QLineF::operator==(const QLineF &lhs, const QLineF &rhs) - Returns \c true if the given \a line is the same as this line. + Returns \c true if the line \a lhs is the same as line \a rhs. A line is identical to another line if the start and end points are identical, and the internal order of the points is the same. @@ -781,6 +787,25 @@ qreal QLineF::angleTo(const QLineF &l) const return delta_normalized; } +/*! + \fn bool QLineF::qFuzzyCompare(const QLineF &lhs, const QLineF &rhs) + \since 6.8 + + Returns \c true if line \a lhs is approximately equal to line \a rhs; + otherwise returns \c false. + + The lines are considered approximately equal if their start and end + points are approximately equal. +*/ + +/*! + \fn bool QLineF::qFuzzyIsNull(const QLineF &line) + \since 6.8 + + Returns \c true if the start point of line \a line is approximately + equal to its end point; otherwise returns \c false. +*/ + #ifndef QT_NO_DEBUG_STREAM QDebug operator<<(QDebug dbg, const QLineF &p) { diff --git a/src/corelib/tools/qline.h b/src/corelib/tools/qline.h index e23ffbe9d5..03dac30e16 100644 --- a/src/corelib/tools/qline.h +++ b/src/corelib/tools/qline.h @@ -48,12 +48,20 @@ public: inline void setPoints(const QPoint &p1, const QPoint &p2); inline void setLine(int x1, int y1, int x2, int y2); +#if QT_CORE_REMOVED_SINCE(6, 8) constexpr inline bool operator==(const QLine &d) const noexcept; - constexpr inline bool operator!=(const QLine &d) const noexcept { return !(*this == d); } + constexpr inline bool operator!=(const QLine &d) const noexcept { return !operator==(d); } +#endif [[nodiscard]] constexpr inline QLineF toLineF() const noexcept; private: + friend constexpr bool comparesEqual(const QLine &lhs, const QLine &rhs) noexcept + { return lhs.pt1 == rhs.pt1 && lhs.pt2 == rhs.pt2; } +#if !QT_CORE_REMOVED_SINCE(6, 8) + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QLine) +#endif + QPoint pt1, pt2; }; Q_DECLARE_TYPEINFO(QLine, Q_PRIMITIVE_TYPE); @@ -161,10 +169,12 @@ inline void QLine::setLine(int aX1, int aY1, int aX2, int aY2) pt2 = QPoint(aX2, aY2); } +#if QT_CORE_REMOVED_SINCE(6, 8) constexpr inline bool QLine::operator==(const QLine &d) const noexcept { - return pt1 == d.pt1 && pt2 == d.pt2; + return comparesEqual(*this, d); } +#endif #ifndef QT_NO_DEBUG_STREAM Q_CORE_EXPORT QDebug operator<<(QDebug d, const QLine &p); @@ -233,12 +243,30 @@ public: inline void setPoints(const QPointF &p1, const QPointF &p2); inline void setLine(qreal x1, qreal y1, qreal x2, qreal y2); +#if QT_CORE_REMOVED_SINCE(6, 8) constexpr inline bool operator==(const QLineF &d) const; - constexpr inline bool operator!=(const QLineF &d) const { return !(*this == d); } + constexpr inline bool operator!=(const QLineF &d) const { return !operator==(d); } +#endif constexpr QLine toLine() const; private: + friend constexpr bool comparesEqual(const QLineF &lhs, const QLineF &rhs) noexcept + { return lhs.pt1 == rhs.pt1 && lhs.pt2 == rhs.pt2; } +#if !QT_CORE_REMOVED_SINCE(6, 8) + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QLineF) +#endif + + friend constexpr bool comparesEqual(const QLineF &lhs, const QLine &rhs) noexcept + { return comparesEqual(lhs, rhs.toLineF()); } + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QLineF, QLine) + + friend constexpr bool qFuzzyCompare(const QLineF &lhs, const QLineF &rhs) noexcept + { return qFuzzyCompare(lhs.pt1, rhs.pt1) && qFuzzyCompare(lhs.pt2, rhs.pt2); } + + friend constexpr bool qFuzzyIsNull(const QLineF &line) noexcept + { return qFuzzyCompare(line.pt1, line.pt2); } + QPointF pt1, pt2; }; Q_DECLARE_TYPEINFO(QLineF, Q_PRIMITIVE_TYPE); @@ -283,7 +311,7 @@ constexpr inline qreal QLineF::y2() const constexpr inline bool QLineF::isNull() const { - return qFuzzyCompare(pt1.x(), pt2.x()) && qFuzzyCompare(pt1.y(), pt2.y()); + return qFuzzyCompare(pt1, pt2); } constexpr inline QPointF QLineF::p1() const @@ -383,12 +411,12 @@ inline void QLineF::setLine(qreal aX1, qreal aY1, qreal aX2, qreal aY2) pt2 = QPointF(aX2, aY2); } - +#if QT_CORE_REMOVED_SINCE(6, 8) constexpr inline bool QLineF::operator==(const QLineF &d) const { - return pt1 == d.pt1 && pt2 == d.pt2; + return comparesEqual(*this, d); } - +#endif #ifndef QT_NO_DEBUG_STREAM diff --git a/src/corelib/tools/qlist.h b/src/corelib/tools/qlist.h index 89e0e3f380..1cced5acc2 100644 --- a/src/corelib/tools/qlist.h +++ b/src/corelib/tools/qlist.h @@ -11,6 +11,7 @@ #include <QtCore/qiterator.h> #include <QtCore/qcontainertools_impl.h> #include <QtCore/qnamespace.h> +#include <QtCore/qttypetraits.h> #include <functional> #include <limits> diff --git a/src/corelib/tools/qmap.h b/src/corelib/tools/qmap.h index 7ee0be1e51..326ae7d8a5 100644 --- a/src/corelib/tools/qmap.h +++ b/src/corelib/tools/qmap.h @@ -12,6 +12,7 @@ #include <QtCore/qpair.h> #include <QtCore/qshareddata.h> #include <QtCore/qshareddata_impl.h> +#include <QtCore/qttypetraits.h> #include <functional> #include <initializer_list> diff --git a/src/corelib/tools/qmargins.cpp b/src/corelib/tools/qmargins.cpp index 1d2cb7d6e5..c4cd0da30d 100644 --- a/src/corelib/tools/qmargins.cpp +++ b/src/corelib/tools/qmargins.cpp @@ -14,6 +14,10 @@ QT_BEGIN_NAMESPACE \ingroup painting \since 4.6 + \compares equality + \compareswith equality QMarginsF + \endcompareswith + \brief The QMargins class defines the four margins of a rectangle. QMargin defines a set of four margins; left, top, right, and bottom, @@ -107,15 +111,15 @@ QT_BEGIN_NAMESPACE */ /*! - \fn bool QMargins::operator==(const QMargins &m1, const QMargins &m2) + \fn bool QMargins::operator==(const QMargins &lhs, const QMargins &rhs) - Returns \c true if \a m1 and \a m2 are equal; otherwise returns \c false. + Returns \c true if \a lhs and \a rhs are equal; otherwise returns \c false. */ /*! - \fn bool QMargins::operator!=(const QMargins &m1, const QMargins &m2) + \fn bool QMargins::operator!=(const QMargins &lhs, const QMargins &rhs) - Returns \c true if \a m1 and \a m2 are different; otherwise returns \c false. + Returns \c true if \a lhs and \a rhs are different; otherwise returns \c false. */ /*! @@ -438,6 +442,10 @@ QDebug operator<<(QDebug dbg, const QMargins &m) \ingroup painting \since 5.3 + \compares equality + \compareswith equality QMargins + \endcompareswith + \brief The QMarginsF class defines the four margins of a rectangle. QMarginsF defines a set of four margins; left, top, right, and bottom, @@ -746,6 +754,22 @@ QDebug operator<<(QDebug dbg, const QMargins &m) \sa QMarginsF(), QMargins::toMarginsF() */ +/*! + \fn bool QMarginsF::qFuzzyCompare(const QMarginsF &lhs, const QMarginsF &rhs) + \since 6.8 + + Returns \c true if \a lhs is approximately equal to \a rhs; + otherwise returns \c false. +*/ + +/*! + \fn bool QMarginsF::qFuzzyIsNull(const QMarginsF &margins) + \since 6.8 + + Returns \c true if all components of margsins \a margins are + approximately equal to zero; otherwise returns \c false. +*/ + /***************************************************************************** QMarginsF stream functions *****************************************************************************/ diff --git a/src/corelib/tools/qmargins.h b/src/corelib/tools/qmargins.h index f8d7150dfd..3b29860d66 100644 --- a/src/corelib/tools/qmargins.h +++ b/src/corelib/tools/qmargins.h @@ -4,6 +4,7 @@ #ifndef QMARGINS_H #define QMARGINS_H +#include <QtCore/qcompare.h> #include <QtCore/qnamespace.h> #include <QtCore/q20type_traits.h> @@ -54,19 +55,14 @@ private: int m_right; int m_bottom; - friend constexpr inline bool operator==(const QMargins &m1, const QMargins &m2) noexcept + friend constexpr bool comparesEqual(const QMargins &lhs, const QMargins &rhs) noexcept { - return - m1.m_left == m2.m_left && - m1.m_top == m2.m_top && - m1.m_right == m2.m_right && - m1.m_bottom == m2.m_bottom; - } - - friend constexpr inline bool operator!=(const QMargins &m1, const QMargins &m2) noexcept - { - return !(m1 == m2); + return lhs.m_left == rhs.m_left + && lhs.m_top == rhs.m_top + && lhs.m_right == rhs.m_right + && lhs.m_bottom == rhs.m_bottom; } + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QMargins) template <std::size_t I, typename M, @@ -304,18 +300,35 @@ private: qreal m_right; qreal m_bottom; - friend constexpr inline bool operator==(const QMarginsF &lhs, const QMarginsF &rhs) noexcept + QT_WARNING_PUSH + QT_WARNING_DISABLE_FLOAT_COMPARE + friend constexpr bool qFuzzyCompare(const QMarginsF &lhs, const QMarginsF &rhs) noexcept { - return qFuzzyCompare(lhs.left(), rhs.left()) - && qFuzzyCompare(lhs.top(), rhs.top()) - && qFuzzyCompare(lhs.right(), rhs.right()) - && qFuzzyCompare(lhs.bottom(), rhs.bottom()); + return ((!lhs.m_left || !rhs.m_left) ? qFuzzyIsNull(lhs.m_left - rhs.m_left) + : qFuzzyCompare(lhs.m_left, rhs.m_left)) + && ((!lhs.m_top || !rhs.m_top) ? qFuzzyIsNull(lhs.m_top - rhs.m_top) + : qFuzzyCompare(lhs.m_top, rhs.m_top)) + && ((!lhs.m_right || !rhs.m_right) ? qFuzzyIsNull(lhs.m_right - rhs.m_right) + : qFuzzyCompare(lhs.m_right, rhs.m_right)) + && ((!lhs.m_bottom || !rhs.m_bottom) ? qFuzzyIsNull(lhs.m_bottom - rhs.m_bottom) + : qFuzzyCompare(lhs.m_bottom, rhs.m_bottom)); + } + QT_WARNING_POP + friend constexpr bool qFuzzyIsNull(const QMarginsF &m) noexcept + { + return qFuzzyIsNull(m.m_left) && qFuzzyIsNull(m.m_top) + && qFuzzyIsNull(m.m_right) && qFuzzyIsNull(m.m_bottom); } - friend constexpr inline bool operator!=(const QMarginsF &lhs, const QMarginsF &rhs) noexcept + friend constexpr bool comparesEqual(const QMarginsF &lhs, const QMarginsF &rhs) noexcept { - return !(lhs == rhs); + return qFuzzyCompare(lhs, rhs); } + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QMarginsF) + + friend constexpr bool comparesEqual(const QMarginsF &lhs, const QMargins &rhs) noexcept + { return comparesEqual(lhs, rhs.toMarginsF()); } + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QMarginsF, QMargins) template <std::size_t I, typename M, diff --git a/src/corelib/tools/qmessageauthenticationcode.h b/src/corelib/tools/qmessageauthenticationcode.h index 4e88138763..7c5edfa7bf 100644 --- a/src/corelib/tools/qmessageauthenticationcode.h +++ b/src/corelib/tools/qmessageauthenticationcode.h @@ -55,6 +55,30 @@ public: static QByteArray hash(QByteArrayView message, QByteArrayView key, QCryptographicHash::Algorithm method); + static QByteArrayView + hashInto(QSpan<char> buffer, QByteArrayView message, QByteArrayView key, + QCryptographicHash::Algorithm method) noexcept + { return hashInto(as_writable_bytes(buffer), {&message, 1}, key, method); } + static QByteArrayView + hashInto(QSpan<uchar> buffer, QByteArrayView message, QByteArrayView key, + QCryptographicHash::Algorithm method) noexcept + { return hashInto(as_writable_bytes(buffer), {&message, 1}, key, method); } + static QByteArrayView + hashInto(QSpan<std::byte> buffer, QByteArrayView message, + QByteArrayView key, QCryptographicHash::Algorithm method) noexcept + { return hashInto(buffer, {&message, 1}, key, method); } + static QByteArrayView + hashInto(QSpan<char> buffer, QSpan<const QByteArrayView> messageParts, + QByteArrayView key, QCryptographicHash::Algorithm method) noexcept + { return hashInto(as_writable_bytes(buffer), messageParts, key, method); } + static QByteArrayView + hashInto(QSpan<uchar> buffer, QSpan<const QByteArrayView> messageParts, + QByteArrayView key, QCryptographicHash::Algorithm method) noexcept + { return hashInto(as_writable_bytes(buffer), messageParts, key, method); } + static QByteArrayView + hashInto(QSpan<std::byte> buffer, QSpan<const QByteArrayView> message, + QByteArrayView key, QCryptographicHash::Algorithm method) noexcept; + private: Q_DISABLE_COPY(QMessageAuthenticationCode) QMessageAuthenticationCodePrivate *d; diff --git a/src/corelib/tools/qpoint.cpp b/src/corelib/tools/qpoint.cpp index d1f3b12a68..775a354469 100644 --- a/src/corelib/tools/qpoint.cpp +++ b/src/corelib/tools/qpoint.cpp @@ -15,6 +15,10 @@ QT_BEGIN_NAMESPACE \ingroup painting \reentrant + \compares equality + \compareswith equality QPointF + \endcompareswith + \brief The QPoint class defines a point in the plane using integer precision. @@ -208,16 +212,17 @@ QT_BEGIN_NAMESPACE */ /*! - \fn bool QPoint::operator==(const QPoint &p1, const QPoint &p2) + \fn bool QPoint::operator==(const QPoint &lhs, const QPoint &rhs) - Returns \c true if \a p1 and \a p2 are equal; otherwise returns - false. + Returns \c true if \a lhs and \a rhs are equal; otherwise returns + \c false. */ /*! - \fn bool QPoint::operator!=(const QPoint &p1, const QPoint &p2) + \fn bool QPoint::operator!=(const QPoint &lhs, const QPoint &rhs) - Returns \c true if \a p1 and \a p2 are not equal; otherwise returns \c false. + Returns \c true if \a lhs and \a rhs are not equal; otherwise returns + \c false. */ /*! @@ -463,6 +468,10 @@ size_t qHash(QPoint key, size_t seed) noexcept \ingroup painting \reentrant + \compares equality + \compareswith equality QPoint + \endcompareswith + \brief The QPointF class defines a point in the plane using floating point precision. @@ -730,9 +739,9 @@ size_t qHash(QPoint key, size_t seed) noexcept */ /*! - \fn bool QPointF::operator==(const QPointF &p1, const QPointF &p2) + \fn bool QPointF::operator==(const QPointF &lhs, const QPointF &rhs) - Returns \c true if \a p1 is approximately equal to \a p2; otherwise + Returns \c true if \a lhs is approximately equal to \a rhs; otherwise returns \c false. \warning This function does not check for strict equality; instead, @@ -742,9 +751,9 @@ size_t qHash(QPoint key, size_t seed) noexcept */ /*! - \fn bool QPointF::operator!=(const QPointF &p1, const QPointF &p2); + \fn bool QPointF::operator!=(const QPointF &lhs, const QPointF &rhs) - Returns \c true if \a p1 is sufficiently different from \a p2; + Returns \c true if \a lhs is sufficiently different from \a rhs; otherwise returns \c false. \warning This function does not check for strict inequality; instead, @@ -753,6 +762,26 @@ size_t qHash(QPoint key, size_t seed) noexcept \sa qFuzzyCompare */ +/*! + \fn bool QPointF::qFuzzyCompare(const QPointF &p1, const QPointF &p2) + \since 6.8 + + Returns \c true if \a p1 is approximately equal to \a p2; otherwise + returns \c false. + + \sa qFuzzyIsNull +*/ + +/*! + \fn bool QPointF::qFuzzyIsNull(const QPointF &point) + \since 6.8 + + Returns \c true if \a point is approximately equal to a point + \c {(0.0, 0.0)}. + + \sa qFuzzyCompare +*/ + #ifndef QT_NO_DATASTREAM /*! \fn QDataStream &operator<<(QDataStream &stream, const QPointF &point) diff --git a/src/corelib/tools/qpoint.h b/src/corelib/tools/qpoint.h index 7df4d49005..50b4c864be 100644 --- a/src/corelib/tools/qpoint.h +++ b/src/corelib/tools/qpoint.h @@ -4,7 +4,9 @@ #ifndef QPOINT_H #define QPOINT_H +#include <QtCore/qcompare.h> #include <QtCore/qnamespace.h> +#include <QtCore/qnumeric.h> #include <QtCore/q20type_traits.h> #include <QtCore/q23utility.h> @@ -51,10 +53,10 @@ public: constexpr static inline int dotProduct(const QPoint &p1, const QPoint &p2) { return p1.xp * p2.xp + p1.yp * p2.yp; } - friend constexpr inline bool operator==(const QPoint &p1, const QPoint &p2) noexcept +private: + friend constexpr bool comparesEqual(const QPoint &p1, const QPoint &p2) noexcept { return p1.xp == p2.xp && p1.yp == p2.yp; } - friend constexpr inline bool operator!=(const QPoint &p1, const QPoint &p2) noexcept - { return p1.xp != p2.xp || p1.yp != p2.yp; } + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QPoint) friend constexpr inline QPoint operator+(const QPoint &p1, const QPoint &p2) noexcept { return QPoint(p1.xp + p2.xp, p1.yp + p2.yp); } friend constexpr inline QPoint operator-(const QPoint &p1, const QPoint &p2) noexcept @@ -78,6 +80,7 @@ public: friend constexpr inline QPoint operator/(const QPoint &p, qreal c) { return QPoint(qRound(p.xp / c), qRound(p.yp / c)); } +public: #if defined(Q_OS_DARWIN) || defined(Q_QDOC) [[nodiscard]] Q_CORE_EXPORT CGPoint toCGPoint() const noexcept; #endif @@ -241,19 +244,25 @@ public: return p1.xp * p2.xp + p1.yp * p2.yp; } +private: QT_WARNING_PUSH QT_WARNING_DISABLE_FLOAT_COMPARE - friend constexpr inline bool operator==(const QPointF &p1, const QPointF &p2) + friend constexpr bool qFuzzyCompare(const QPointF &p1, const QPointF &p2) noexcept { return ((!p1.xp || !p2.xp) ? qFuzzyIsNull(p1.xp - p2.xp) : qFuzzyCompare(p1.xp, p2.xp)) && ((!p1.yp || !p2.yp) ? qFuzzyIsNull(p1.yp - p2.yp) : qFuzzyCompare(p1.yp, p2.yp)); } - friend constexpr inline bool operator!=(const QPointF &p1, const QPointF &p2) + QT_WARNING_POP + friend constexpr bool qFuzzyIsNull(const QPointF &point) noexcept { - return !(p1 == p2); + return qFuzzyIsNull(point.xp) && qFuzzyIsNull(point.yp); } - QT_WARNING_POP - + friend constexpr bool comparesEqual(const QPointF &p1, const QPointF &p2) noexcept + { return qFuzzyCompare(p1, p2); } + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QPointF) + friend constexpr bool comparesEqual(const QPointF &p1, const QPoint &p2) noexcept + { return comparesEqual(p1, p2.toPointF()); } + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QPointF, QPoint) friend constexpr inline QPointF operator+(const QPointF &p1, const QPointF &p2) { return QPointF(p1.xp + p2.xp, p1.yp + p2.yp); } friend constexpr inline QPointF operator-(const QPointF &p1, const QPointF &p2) @@ -272,6 +281,7 @@ public: return QPointF(p.xp / divisor, p.yp / divisor); } +public: constexpr QPoint toPoint() const; #if defined(Q_OS_DARWIN) || defined(Q_QDOC) diff --git a/src/corelib/tools/qrect.cpp b/src/corelib/tools/qrect.cpp index 6d345ce543..ce28a6d887 100644 --- a/src/corelib/tools/qrect.cpp +++ b/src/corelib/tools/qrect.cpp @@ -15,6 +15,10 @@ QT_BEGIN_NAMESPACE \ingroup painting \reentrant + \compares equality + \compareswith equality QRectF + \endcompareswith + \brief The QRect class defines a rectangle in the plane using integer precision. @@ -1105,18 +1109,18 @@ bool QRect::intersects(const QRect &r) const noexcept } /*! - \fn bool QRect::operator==(const QRect &r1, const QRect &r2) + \fn bool QRect::operator==(const QRect &lhs, const QRect &rhs) - Returns \c true if the rectangles \a r1 and \a r2 are equal, + Returns \c true if the rectangles \a lhs and \a rhs are equal, otherwise returns \c false. */ /*! - \fn bool QRect::operator!=(const QRect &r1, const QRect &r2) + \fn bool QRect::operator!=(const QRect &lhs, const QRect &rhs) - Returns \c true if the rectangles \a r1 and \a r2 are different, otherwise - returns \c false. + Returns \c true if the rectangles \a lhs and \a rhs are different, + otherwise returns \c false. */ /*! @@ -1279,6 +1283,10 @@ QDebug operator<<(QDebug dbg, const QRect &r) \ingroup painting \reentrant + \compares equality + \compareswith equality QRect + \endcompareswith + \brief The QRectF class defines a finite rectangle in the plane using floating point precision. @@ -2346,10 +2354,10 @@ QRect QRectF::toAlignedRect() const noexcept */ /*! - \fn bool QRectF::operator==(const QRectF &r1, const QRectF &r2) + \fn bool QRectF::operator==(const QRectF &lhs, const QRectF &rhs) - Returns \c true if the rectangles \a r1 and \a r2 are \b approximately equal, - otherwise returns \c false. + Returns \c true if the rectangles \a lhs and \a rhs are \b approximately + equal, otherwise returns \c false. \warning This function does not check for strict equality; instead, it uses a fuzzy comparison to compare the rectangles' coordinates. @@ -2359,9 +2367,9 @@ QRect QRectF::toAlignedRect() const noexcept /*! - \fn bool QRectF::operator!=(const QRectF &r1, const QRectF &r2) + \fn bool QRectF::operator!=(const QRectF &lhs, const QRectF &rhs) - Returns \c true if the rectangles \a r1 and \a r2 are sufficiently + Returns \c true if the rectangles \a lhs and \a rhs are sufficiently different, otherwise returns \c false. \warning This function does not check for strict inequality; instead, @@ -2429,6 +2437,22 @@ QRect QRectF::toAlignedRect() const noexcept \sa marginsRemoved(), operator+=(), marginsAdded() */ +/*! + \fn bool QRectF::qFuzzyCompare(const QRectF &lhs, const QRectF &rhs) + \since 6.8 + + Returns \c true if the rectangle \a lhs is approximately equal to the + rectangle \a rhs; otherwise returns \c false. +*/ + +/*! + \fn bool QRectF::qFuzzyIsNull(const QRectF &rect) + \since 6.8 + + Returns \c true if both width and height of the rectangle \a rect are + approximately equal to zero; otherwise returns \c false. +*/ + /***************************************************************************** QRectF stream functions *****************************************************************************/ diff --git a/src/corelib/tools/qrect.h b/src/corelib/tools/qrect.h index e69a217f48..fb938b0056 100644 --- a/src/corelib/tools/qrect.h +++ b/src/corelib/tools/qrect.h @@ -119,12 +119,13 @@ public: [[nodiscard]] static constexpr inline QRect span(const QPoint &p1, const QPoint &p2) noexcept; - friend constexpr inline bool operator==(const QRect &r1, const QRect &r2) noexcept +private: + friend constexpr bool comparesEqual(const QRect &r1, const QRect &r2) noexcept { return r1.x1==r2.x1 && r1.x2==r2.x2 && r1.y1==r2.y1 && r1.y2==r2.y2; } - friend constexpr inline bool operator!=(const QRect &r1, const QRect &r2) noexcept - { return r1.x1!=r2.x1 || r1.x2!=r2.x2 || r1.y1!=r2.y1 || r1.y2!=r2.y2; } + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QRect) friend constexpr inline size_t qHash(const QRect &, size_t) noexcept; +public: #if defined(Q_OS_DARWIN) || defined(Q_QDOC) [[nodiscard]] CGRect toCGRect() const noexcept; #endif @@ -572,17 +573,30 @@ public: constexpr inline QRectF &operator+=(const QMarginsF &margins) noexcept; constexpr inline QRectF &operator-=(const QMarginsF &margins) noexcept; - friend constexpr inline bool operator==(const QRectF &r1, const QRectF &r2) noexcept +private: + friend constexpr bool comparesEqual(const QRectF &r1, const QRectF &r2) noexcept { return r1.topLeft() == r2.topLeft() && r1.size() == r2.size(); } - friend constexpr inline bool operator!=(const QRectF &r1, const QRectF &r2) noexcept + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QRectF) + + friend constexpr bool comparesEqual(const QRectF &r1, const QRect &r2) noexcept + { return r1.topLeft() == r2.topLeft() && r1.size() == r2.size(); } + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QRectF, QRect) + + friend constexpr bool qFuzzyCompare(const QRectF &lhs, const QRectF &rhs) noexcept { - return r1.topLeft() != r2.topLeft() - || r1.size() != r2.size(); + return qFuzzyCompare(lhs.topLeft(), rhs.topLeft()) + && qFuzzyCompare(lhs.bottomRight(), rhs.bottomRight()); } + friend constexpr bool qFuzzyIsNull(const QRectF &rect) noexcept + { + return qFuzzyIsNull(rect.w) && qFuzzyIsNull(rect.h); + } + +public: [[nodiscard]] constexpr inline QRect toRect() const noexcept; [[nodiscard]] QRect toAlignedRect() const noexcept; diff --git a/src/corelib/tools/qset.h b/src/corelib/tools/qset.h index 7330b5e91c..6eaeb8fc41 100644 --- a/src/corelib/tools/qset.h +++ b/src/corelib/tools/qset.h @@ -6,6 +6,7 @@ #include <QtCore/qhash.h> #include <QtCore/qcontainertools_impl.h> +#include <QtCore/qttypetraits.h> #include <initializer_list> #include <iterator> diff --git a/src/corelib/tools/qsize.cpp b/src/corelib/tools/qsize.cpp index d5e8e4c71b..27ff1d164d 100644 --- a/src/corelib/tools/qsize.cpp +++ b/src/corelib/tools/qsize.cpp @@ -266,15 +266,15 @@ QSize QSize::scaled(const QSize &s, Qt::AspectRatioMode mode) const noexcept */ /*! - \fn bool QSize::operator==(const QSize &s1, const QSize &s2) + \fn bool QSize::operator==(const QSize &lhs, const QSize &rhs) - Returns \c true if \a s1 and \a s2 are equal; otherwise returns \c false. + Returns \c true if \a lhs and \a rhs are equal; otherwise returns \c false. */ /*! - \fn bool QSize::operator!=(const QSize &s1, const QSize &s2) + \fn bool QSize::operator!=(const QSize &lhs, const QSize &rhs) - Returns \c true if \a s1 and \a s2 are different; otherwise returns \c false. + Returns \c true if \a lhs and \a rhs are different; otherwise returns \c false. */ /*! @@ -714,9 +714,9 @@ QSizeF QSizeF::scaled(const QSizeF &s, Qt::AspectRatioMode mode) const noexcept */ /*! - \fn bool QSizeF::operator==(const QSizeF &s1, const QSizeF &s2) + \fn bool QSizeF::operator==(const QSizeF &lhs, const QSizeF &rhs) - Returns \c true if \a s1 and \a s2 are approximately equal; otherwise + Returns \c true if \a lhs and \a rhs are approximately equal; otherwise returns false. \warning This function does not check for strict equality; instead, @@ -726,9 +726,9 @@ QSizeF QSizeF::scaled(const QSizeF &s, Qt::AspectRatioMode mode) const noexcept */ /*! - \fn bool QSizeF::operator!=(const QSizeF &s1, const QSizeF &s2) + \fn bool QSizeF::operator!=(const QSizeF &lhs, const QSizeF &rhs) - Returns \c true if \a s1 and \a s2 are sufficiently different; otherwise + Returns \c true if \a lhs and \a rhs are sufficiently different; otherwise returns \c false. \warning This function does not check for strict inequality; instead, @@ -808,7 +808,24 @@ QSizeF QSizeF::scaled(const QSizeF &s, Qt::AspectRatioMode mode) const noexcept \sa expandedTo(), scale() */ +/*! + \fn bool QSizeF::qFuzzyCompare(const QSizeF &lhs, const QSizeF &rhs) + \since 6.8 + + Returns \c true if the size \a lhs is approximately equal to the + size \a rhs; otherwise returns \c false. + + The sizes are considered approximately equal if their width and + height are approximately equal. +*/ +/*! + \fn bool QSizeF::qFuzzyIsNull(const QSizeF &size) + \since 6.8 + + Returns \c true if both width and height of the size \a size + are approximately equal to zero. +*/ /***************************************************************************** QSizeF stream functions diff --git a/src/corelib/tools/qsize.h b/src/corelib/tools/qsize.h index a5eaf34afe..67f7146201 100644 --- a/src/corelib/tools/qsize.h +++ b/src/corelib/tools/qsize.h @@ -59,10 +59,10 @@ public: constexpr inline QSize &operator*=(qreal c) noexcept; inline QSize &operator/=(qreal c); - friend inline constexpr bool operator==(const QSize &s1, const QSize &s2) noexcept +private: + friend constexpr bool comparesEqual(const QSize &s1, const QSize &s2) noexcept { return s1.wd == s2.wd && s1.ht == s2.ht; } - friend inline constexpr bool operator!=(const QSize &s1, const QSize &s2) noexcept - { return s1.wd != s2.wd || s1.ht != s2.ht; } + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QSize) friend inline constexpr QSize operator+(const QSize &s1, const QSize &s2) noexcept { return QSize(s1.wd + s2.wd, s1.ht + s2.ht); } friend inline constexpr QSize operator-(const QSize &s1, const QSize &s2) noexcept @@ -75,6 +75,7 @@ public: { Q_ASSERT(!qFuzzyIsNull(c)); return QSize(qRound(s.wd / c), qRound(s.ht / c)); } friend inline constexpr size_t qHash(const QSize &, size_t) noexcept; +public: #if defined(Q_OS_DARWIN) || defined(Q_QDOC) [[nodiscard]] CGSize toCGSize() const noexcept; #endif @@ -242,16 +243,25 @@ public: constexpr inline QSizeF &operator*=(qreal c) noexcept; inline QSizeF &operator/=(qreal c); +private: QT_WARNING_PUSH QT_WARNING_DISABLE_FLOAT_COMPARE - friend constexpr inline bool operator==(const QSizeF &s1, const QSizeF &s2) + friend constexpr bool qFuzzyCompare(const QSizeF &s1, const QSizeF &s2) noexcept { + // Cannot use qFuzzyCompare(), because it will give incorrect results + // if one of the arguments is 0.0. return ((!s1.wd || !s2.wd) ? qFuzzyIsNull(s1.wd - s2.wd) : qFuzzyCompare(s1.wd, s2.wd)) && ((!s1.ht || !s2.ht) ? qFuzzyIsNull(s1.ht - s2.ht) : qFuzzyCompare(s1.ht, s2.ht)); } QT_WARNING_POP - friend constexpr inline bool operator!=(const QSizeF &s1, const QSizeF &s2) - { return !(s1 == s2); } + 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 + { return qFuzzyCompare(lhs, rhs); } + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QSizeF) + friend constexpr bool comparesEqual(const QSizeF &lhs, const QSize &rhs) noexcept + { return comparesEqual(lhs, rhs.toSizeF()); } + Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(QSizeF, QSize) friend constexpr inline QSizeF operator+(const QSizeF &s1, const QSizeF &s2) noexcept { return QSizeF(s1.wd + s2.wd, s1.ht + s2.ht); } friend constexpr inline QSizeF operator-(const QSizeF &s1, const QSizeF &s2) noexcept @@ -263,6 +273,7 @@ public: friend inline QSizeF operator/(const QSizeF &s, qreal c) { Q_ASSERT(!qFuzzyIsNull(c)); return QSizeF(s.wd / c, s.ht / c); } +public: constexpr inline QSize toSize() const noexcept; #if defined(Q_OS_DARWIN) || defined(Q_QDOC) diff --git a/src/corelib/tools/qspan.h b/src/corelib/tools/qspan.h index d6ae2570ae..2671ba374f 100644 --- a/src/corelib/tools/qspan.h +++ b/src/corelib/tools/qspan.h @@ -433,6 +433,29 @@ public: [[nodiscard]] constexpr QSpan<T> sliced(size_type pos) const { return subspan(pos); } [[nodiscard]] constexpr QSpan<T> sliced(size_type pos, size_type n) const { return subspan(pos, n); } +private: + // [span.objectrep] + [[nodiscard]] friend + QSpan<const std::byte, E == q20::dynamic_extent ? q20::dynamic_extent : E * sizeof(T)> + as_bytes(QSpan s) noexcept + { + using R = QSpan<const std::byte, E == q20::dynamic_extent ? q20::dynamic_extent : E * sizeof(T)>; + return R{reinterpret_cast<const std::byte *>(s.data()), s.size_bytes()}; + } + + template <typename U> + using if_mutable = std::enable_if_t<!std::is_const_v<U>, bool>; + +#ifndef Q_QDOC + template <typename T2 = T, if_mutable<T2> = true> +#endif + [[nodiscard]] friend + QSpan<std::byte, E == q20::dynamic_extent ? q20::dynamic_extent : E * sizeof(T)> + as_writable_bytes(QSpan s) noexcept + { + using R = QSpan<std::byte, E == q20::dynamic_extent ? q20::dynamic_extent : E * sizeof(T)>; + return R{reinterpret_cast<std::byte *>(s.data()), s.size_bytes()}; + } }; // class QSpan // [span.deduct] diff --git a/src/corelib/tools/qspan.qdoc b/src/corelib/tools/qspan.qdoc index 472f122877..9b55b09bf7 100644 --- a/src/corelib/tools/qspan.qdoc +++ b/src/corelib/tools/qspan.qdoc @@ -556,7 +556,6 @@ \sa subspan(QSpan<T,E>::size_type), subspan(), first(), last() */ -#if 0 // needs fix for QTBUG-118080 integrated into qt5.git /*! \fn template <typename T, size_t E> template <std::size_t Offset, std::size_t Count> auto QSpan<T, E>::subspan() const \keyword subspan-t2 @@ -573,7 +572,6 @@ \sa subspan(QSpan<T,E>::size_type, QSpan<T,E>::size_type), subspan(), first(), last() */ -#endif // // runtime subspans: @@ -649,3 +647,37 @@ \sa subspan(), first(QSpan<T,E>::size_type), last(QSpan<T,E>::size_type) */ +/*! + \fn template <typename T, size_t E> auto QSpan<T, E>::as_bytes(QSpan s) + \since 6.8 + + Returns \a s as a \c{QSpan<const std::byte, E'>} whose size() is equal to + \c{s.size_bytes()}. + + If \c{E} is \c{std::dynamic_extent} then so is \c{E'}. + Otherwise, \c{E' = E * sizeof(T)}. + + \note \c{q20::dynamic_extent} is a C++17 backport of C++20's + \l{https://en.cppreference.com/w/cpp/container/span/dynamic_extent}{\c{std::dynamic_extent}}. + + \sa as_writable_bytes(), size_bytes() +*/ + +/*! + \fn template <typename T, size_t E> auto QSpan<T, E>::as_writable_bytes(QSpan s) + \since 6.8 + + Returns \a s as a \c{QSpan<std::byte, E'>} whose size() is equal to + \c{s.size_bytes()}. + + If \c{E} is \c{std::dynamic_extent} then so is \c{E'}. + Otherwise, \c{E' = E * sizeof(T)}. + + \note This function participates in overload resolution only if + \c{!std::is_const_v<T>}. + + \note \c{q20::dynamic_extent} is a C++17 backport of C++20's + \l{https://en.cppreference.com/w/cpp/container/span/dynamic_extent}{\c{std::dynamic_extent}}. + + \sa as_bytes(), size_bytes() +*/ diff --git a/src/corelib/tools/qvarlengtharray.h b/src/corelib/tools/qvarlengtharray.h index afc345d3be..78d5a27627 100644 --- a/src/corelib/tools/qvarlengtharray.h +++ b/src/corelib/tools/qvarlengtharray.h @@ -14,6 +14,7 @@ #include <QtCore/qalgorithms.h> #include <QtCore/qcontainertools_impl.h> #include <QtCore/qhashfunctions.h> +#include <QtCore/qttypetraits.h> #include <algorithm> #include <initializer_list> @@ -956,8 +957,8 @@ Q_OUTOFLINE_TEMPLATE auto QVLABase<T>::insert_impl(qsizetype prealloc, void *arr template <class T> Q_OUTOFLINE_TEMPLATE auto QVLABase<T>::erase(const_iterator abegin, const_iterator aend) -> iterator { - Q_ASSERT_X(isValidIterator(abegin), "QVarLengthArray::insert", "The specified const_iterator argument 'abegin' is invalid"); - Q_ASSERT_X(isValidIterator(aend), "QVarLengthArray::insert", "The specified const_iterator argument 'aend' is invalid"); + Q_ASSERT_X(isValidIterator(abegin), "QVarLengthArray::erase", "The specified const_iterator argument 'abegin' is invalid"); + Q_ASSERT_X(isValidIterator(aend), "QVarLengthArray::erase", "The specified const_iterator argument 'aend' is invalid"); qsizetype f = qsizetype(abegin - cbegin()); qsizetype l = qsizetype(aend - cbegin()); @@ -968,10 +969,11 @@ Q_OUTOFLINE_TEMPLATE auto QVLABase<T>::erase(const_iterator abegin, const_iterat Q_ASSERT(n > 0); // aend must be reachable from abegin - if constexpr (QTypeInfo<T>::isComplex) { + if constexpr (!QTypeInfo<T>::isRelocatable) { std::move(begin() + l, end(), QT_MAKE_CHECKED_ARRAY_ITERATOR(begin() + f, size() - f)); std::destroy(end() - n, end()); } else { + std::destroy(abegin, aend); memmove(static_cast<void *>(data() + f), static_cast<const void *>(data() + l), (size() - l) * sizeof(T)); } this->s -= n; diff --git a/src/corelib/tools/qversionnumber.cpp b/src/corelib/tools/qversionnumber.cpp index 4b8ace71cc..af95875b44 100644 --- a/src/corelib/tools/qversionnumber.cpp +++ b/src/corelib/tools/qversionnumber.cpp @@ -30,6 +30,7 @@ QT_IMPL_METATYPE_EXTERN(QVersionNumber) \brief The QVersionNumber class contains a version number with an arbitrary number of segments. + \compares strong \snippet qversionnumber/main.cpp 0 */ diff --git a/src/corelib/tools/qversionnumber.h b/src/corelib/tools/qversionnumber.h index 95217a6eff..e7ae107226 100644 --- a/src/corelib/tools/qversionnumber.h +++ b/src/corelib/tools/qversionnumber.h @@ -6,6 +6,7 @@ #ifndef QVERSIONNUMBER_H #define QVERSIONNUMBER_H +#include <QtCore/qcompare.h> #include <QtCore/qcontainertools_impl.h> #include <QtCore/qlist.h> #include <QtCore/qmetatype.h> @@ -355,25 +356,20 @@ public: [[nodiscard]] Q_CORE_EXPORT static QVersionNumber fromString(QStringView string, int *suffixIndex); #endif - [[nodiscard]] friend bool operator> (const QVersionNumber &lhs, const QVersionNumber &rhs) noexcept - { return compare(lhs, rhs) > 0; } - - [[nodiscard]] friend bool operator>=(const QVersionNumber &lhs, const QVersionNumber &rhs) noexcept - { return compare(lhs, rhs) >= 0; } - - [[nodiscard]] friend bool operator< (const QVersionNumber &lhs, const QVersionNumber &rhs) noexcept - { return compare(lhs, rhs) < 0; } - - [[nodiscard]] friend bool operator<=(const QVersionNumber &lhs, const QVersionNumber &rhs) noexcept - { return compare(lhs, rhs) <= 0; } - - [[nodiscard]] friend bool operator==(const QVersionNumber &lhs, const QVersionNumber &rhs) noexcept - { return compare(lhs, rhs) == 0; } - - [[nodiscard]] friend bool operator!=(const QVersionNumber &lhs, const QVersionNumber &rhs) noexcept - { return compare(lhs, rhs) != 0; } - private: + [[nodiscard]] friend bool comparesEqual(const QVersionNumber &lhs, + const QVersionNumber &rhs) noexcept + { + return compare(lhs, rhs) == 0; + } + [[nodiscard]] friend Qt::strong_ordering compareThreeWay(const QVersionNumber &lhs, + const QVersionNumber &rhs) noexcept + { + int c = compare(lhs, rhs); + return Qt::compareThreeWay(c, 0); + } + Q_DECLARE_STRONGLY_ORDERED(QVersionNumber) + #ifndef QT_NO_DATASTREAM friend Q_CORE_EXPORT QDataStream& operator>>(QDataStream &in, QVersionNumber &version); #endif |