diff options
Diffstat (limited to 'src/corelib/compat')
-rw-r--r-- | src/corelib/compat/removed_api.cpp | 924 |
1 files changed, 923 insertions, 1 deletions
diff --git a/src/corelib/compat/removed_api.cpp b/src/corelib/compat/removed_api.cpp index 7c3dbd3be2..2210cae848 100644 --- a/src/corelib/compat/removed_api.cpp +++ b/src/corelib/compat/removed_api.cpp @@ -139,6 +139,16 @@ QLocale::Language QLocale::codeToLanguage(QStringView languageCode) noexcept #include "qoperatingsystemversion.h" +QOperatingSystemVersion QOperatingSystemVersion::current() +{ + return QOperatingSystemVersionBase::current(); +} + +QString QOperatingSystemVersion::name() const +{ + return QOperatingSystemVersionBase::name(); +} + int QOperatingSystemVersion::compare(const QOperatingSystemVersion &v1, const QOperatingSystemVersion &v2) { @@ -161,6 +171,8 @@ QByteArray QUrl::toAce(const QString &domain) #if QT_CORE_REMOVED_SINCE(6, 4) +#include "qbytearray.h" // uses QT_CORE_INLINE_SINCE + #include "qcalendar.h" QCalendar::QCalendar(QStringView name) @@ -169,6 +181,19 @@ QCalendar::QCalendar(QStringView name) QCalendar::QCalendar(QLatin1StringView name) : QCalendar(QAnyStringView{name}) {} +#include "qcollator.h" // inline function compare(ptr, n, ptr, n) (for MSVC) + +#include "qhashfunctions.h" + +size_t qHash(const QByteArray &key, size_t seed) noexcept +{ + return qHashBits(key.constData(), size_t(key.size()), seed); +} + +size_t qHash(const QByteArrayView &key, size_t seed) noexcept +{ + return qHashBits(key.constData(), size_t(key.size()), seed); +} #include "qobject.h" @@ -177,12 +202,15 @@ void QObject::setObjectName(const QString &name) setObjectName<void>(name); } +#include "qlocale.h" // uses QT_CORE_INLINE_SINCE + +#if QT_CONFIG(settings) #include "qsettings.h" void QSettings::beginGroup(const QString &prefix) { - return beginGroup(qToAnyStringViewIgnoringNull(prefix)); + beginGroup(qToAnyStringViewIgnoringNull(prefix)); } int QSettings::beginReadArray(const QString &prefix) @@ -220,6 +248,7 @@ QVariant QSettings::value(const QString &key) const return value(qToAnyStringViewIgnoringNull(key)); } +#endif // QT_CONFIG(settings) #include "qversionnumber.h" @@ -248,3 +277,896 @@ QT_WARNING_POP // order sections alphabetically to reduce chances of merge conflicts #endif // QT_CORE_REMOVED_SINCE(6, 4) + +#if QT_CORE_REMOVED_SINCE(6, 5) + +#include "qbasictimer.h" // inlined API + +#include "qbuffer.h" // inline removed API + +#include "qdir.h" + +uint QDir::count() const +{ + return uint(count(QT6_CALL_NEW_OVERLOAD)); +} + +#if QT_POINTER_SIZE != 4 +QString QDir::operator[](int i) const +{ + return operator[](qsizetype{i}); +} +#endif + +#include "qtenvironmentvariables.h" + +bool qputenv(const char *varName, const QByteArray &value) +{ + return qputenv(varName, qToByteArrayViewIgnoringNull(value)); +} + +#include "qmetatype.h" + +int QMetaType::idHelper() const +{ + Q_ASSERT(d_ptr); + return registerHelper(d_ptr); +} + +#if QT_CONFIG(sharedmemory) +#include "qsharedmemory.h" + +void QSharedMemory::setNativeKey(const QString &key) +{ + setNativeKey(key, QNativeIpcKey::legacyDefaultTypeForOs()); +} +#endif + +#include "qvariant.h" + +// these implementations aren't as efficient as they used to be prior to +// replacement, but there's no way to call the ambiguous overload +QVariant::QVariant(const QUuid &uuid) : QVariant(QVariant::fromValue(uuid)) {} +#ifndef QT_NO_GEOM_VARIANT +#include "qline.h" +#include "qpoint.h" +#include "qrect.h" +#include "qsize.h" +QVariant::QVariant(const QPoint &pt) : QVariant(QVariant::fromValue(pt)) {} +QVariant::QVariant(const QPointF &pt) : QVariant(QVariant::fromValue(pt)) {} +QVariant::QVariant(const QRect &r) : QVariant(QVariant::fromValue(r)) {} +QVariant::QVariant(const QRectF &r) : QVariant(QVariant::fromValue(r)) {} +QVariant::QVariant(const QLine &l) : QVariant(QVariant::fromValue(l)) {} +QVariant::QVariant(const QLineF &l) : QVariant(QVariant::fromValue(l)) {} +QVariant::QVariant(const QSize &s) : QVariant(QVariant::fromValue(s)) {} +QVariant::QVariant(const QSizeF &s) : QVariant(QVariant::fromValue(s)) {} +#endif + +#if QT_CONFIG(xmlstreamreader) + +#include "qxmlstream.h" + +QXmlStreamReader::QXmlStreamReader(const QByteArray &data) + : QXmlStreamReader(data, PrivateConstructorTag{}) +{ +} + +QXmlStreamReader::QXmlStreamReader(const QString &data) + : QXmlStreamReader(qToAnyStringViewIgnoringNull(data)) +{ +} + +QXmlStreamReader::QXmlStreamReader(const char *data) + : QXmlStreamReader(QAnyStringView(data)) +{ +} + +void QXmlStreamReader::addData(const QByteArray &data) +{ + addData<>(data); +} +void QXmlStreamReader::addData(const QString &data) +{ + addData(qToAnyStringViewIgnoringNull(data)); +} + +void QXmlStreamReader::addData(const char *data) +{ + addData(QAnyStringView(data)); +} + +#endif // QT_CONFIG(xmlstreamreader) + +#if QT_CONFIG(xmlstreamwriter) + +#include "qxmlstream.h" + +void QXmlStreamWriter::writeAttribute(const QString &qualifiedName, const QString &value) +{ + writeAttribute(qToAnyStringViewIgnoringNull(qualifiedName), + qToAnyStringViewIgnoringNull(value)); +} + +void QXmlStreamWriter::writeAttribute(const QString &namespaceUri, const QString &name, const QString &value) +{ + writeAttribute(qToAnyStringViewIgnoringNull(namespaceUri), + qToAnyStringViewIgnoringNull(name), + qToAnyStringViewIgnoringNull(value)); +} + +void QXmlStreamWriter::writeCDATA(const QString &text) +{ + writeCDATA(qToAnyStringViewIgnoringNull(text)); +} + +void QXmlStreamWriter::writeCharacters(const QString &text) +{ + writeCharacters(qToAnyStringViewIgnoringNull(text)); +} + +void QXmlStreamWriter::writeComment(const QString &text) +{ + writeComment(qToAnyStringViewIgnoringNull(text)); +} + +void QXmlStreamWriter::writeDTD(const QString &dtd) +{ + writeDTD(qToAnyStringViewIgnoringNull(dtd)); +} + +void QXmlStreamWriter::writeEmptyElement(const QString &qualifiedName) +{ + writeEmptyElement(qToAnyStringViewIgnoringNull(qualifiedName)); +} + +void QXmlStreamWriter::writeEmptyElement(const QString &namespaceUri, const QString &name) +{ + writeEmptyElement(qToAnyStringViewIgnoringNull(namespaceUri), + qToAnyStringViewIgnoringNull(name)); +} + +void QXmlStreamWriter::writeTextElement(const QString &qualifiedName, const QString &text) +{ + writeTextElement(qToAnyStringViewIgnoringNull(qualifiedName), + qToAnyStringViewIgnoringNull(text)); +} + +void QXmlStreamWriter::writeTextElement(const QString &namespaceUri, const QString &name, const QString &text) +{ + writeTextElement(qToAnyStringViewIgnoringNull(namespaceUri), + qToAnyStringViewIgnoringNull(name), + qToAnyStringViewIgnoringNull(text)); +} + +void QXmlStreamWriter::writeEntityReference(const QString &name) +{ + writeEntityReference(qToAnyStringViewIgnoringNull(name)); +} + +void QXmlStreamWriter::writeNamespace(const QString &namespaceUri, const QString &prefix) +{ + writeNamespace(qToAnyStringViewIgnoringNull(namespaceUri), + qToAnyStringViewIgnoringNull(prefix)); +} + +void QXmlStreamWriter::writeDefaultNamespace(const QString &namespaceUri) +{ + writeDefaultNamespace(qToAnyStringViewIgnoringNull(namespaceUri)); +} + +void QXmlStreamWriter::writeProcessingInstruction(const QString &target, const QString &data) +{ + writeProcessingInstruction(qToAnyStringViewIgnoringNull(target), + qToAnyStringViewIgnoringNull(data)); +} + +void QXmlStreamWriter::writeStartDocument(const QString &version) +{ + writeStartDocument(qToAnyStringViewIgnoringNull(version)); +} + +void QXmlStreamWriter::writeStartDocument(const QString &version, bool standalone) +{ + writeStartDocument(qToAnyStringViewIgnoringNull(version), + standalone); +} + +void QXmlStreamWriter::writeStartElement(const QString &qualifiedName) +{ + writeStartElement(qToAnyStringViewIgnoringNull(qualifiedName)); +} + +void QXmlStreamWriter::writeStartElement(const QString &namespaceUri, const QString &name) +{ + writeStartElement(qToAnyStringViewIgnoringNull(namespaceUri), + qToAnyStringViewIgnoringNull(name)); +} + +#endif // QT_CONFIG(xmlstreamwriter) + +// inlined API +#include "qfloat16.h" +#include "qstring.h" + +// #include "qotherheader.h" +// // implement removed functions from qotherheader.h +// order sections alphabetically to reduce chances of merge conflicts + +#endif // QT_CORE_REMOVED_SINCE(6, 5) + +#if QT_CORE_REMOVED_SINCE(6, 6) + +#include "qmessageauthenticationcode.h" + +QMessageAuthenticationCode::QMessageAuthenticationCode(QCryptographicHash::Algorithm method, + const QByteArray &key) + : QMessageAuthenticationCode(method, qToByteArrayViewIgnoringNull(key)) {} + +void QMessageAuthenticationCode::setKey(const QByteArray &key) +{ + setKey(qToByteArrayViewIgnoringNull(key)); +} + +void QMessageAuthenticationCode::addData(const QByteArray &data) +{ + addData(qToByteArrayViewIgnoringNull(data)); +} + +QByteArray QMessageAuthenticationCode::hash(const QByteArray &msg, const QByteArray &key, + QCryptographicHash::Algorithm method) +{ + return hash(qToByteArrayViewIgnoringNull(msg), + qToByteArrayViewIgnoringNull(key), method); +} + +#include "qobject.h" // inlined API + +#include "qrunnable.h" + +QRunnable *QRunnable::create(std::function<void()> functionToRun) +{ + return QRunnable::create<std::function<void()>>(std::move(functionToRun)); +} + +#include "qstring.h" + +qsizetype QString::toUcs4_helper(const ushort *uc, qsizetype length, uint *out) +{ + return toUcs4_helper(reinterpret_cast<const char16_t *>(uc), length, + reinterpret_cast<char32_t *>(out)); +} + +#if QT_CONFIG(thread) +#include "qreadwritelock.h" + +bool QReadWriteLock::tryLockForRead() +{ + return tryLockForRead(0); +} + +bool QReadWriteLock::tryLockForWrite() +{ + return tryLockForWrite(0); +} + +#include "qthreadpool.h" +#include "private/qthreadpool_p.h" + +void QThreadPool::start(std::function<void()> functionToRun, int priority) +{ + if (!functionToRun) + return; + start(QRunnable::create(std::move(functionToRun)), priority); +} + +bool QThreadPool::tryStart(std::function<void()> functionToRun) +{ + if (!functionToRun) + return false; + + Q_D(QThreadPool); + QMutexLocker locker(&d->mutex); + if (!d->allThreads.isEmpty() && d->areAllThreadsActive()) + return false; + + QRunnable *runnable = QRunnable::create(std::move(functionToRun)); + if (d->tryStart(runnable)) + return true; + delete runnable; + return false; +} + +void QThreadPool::startOnReservedThread(std::function<void()> functionToRun) +{ + if (!functionToRun) + return releaseThread(); + + startOnReservedThread(QRunnable::create(std::move(functionToRun))); +} + +#endif // QT_CONFIG(thread) + +#include "qxmlstream.h" + +QStringView QXmlStreamAttributes::value(const QString &namespaceUri, const QString &name) const +{ + return value(qToAnyStringViewIgnoringNull(namespaceUri), qToAnyStringViewIgnoringNull(name)); +} + +QStringView QXmlStreamAttributes::value(const QString &namespaceUri, QLatin1StringView name) const +{ + return value(qToAnyStringViewIgnoringNull(namespaceUri), QAnyStringView(name)); +} + +QStringView QXmlStreamAttributes::value(QLatin1StringView namespaceUri, QLatin1StringView name) const +{ + return value(QAnyStringView(namespaceUri), QAnyStringView(name)); +} + +QStringView QXmlStreamAttributes::value(const QString &qualifiedName) const +{ + return value(qToAnyStringViewIgnoringNull(qualifiedName)); +} + +QStringView QXmlStreamAttributes::value(QLatin1StringView qualifiedName) const +{ + return value(QAnyStringView(qualifiedName)); +} + +// inlined API +#if QT_CONFIG(thread) +#include "qmutex.h" +#include "qreadwritelock.h" +#include "qsemaphore.h" +#endif + +// #include "qotherheader.h" +// // implement removed functions from qotherheader.h +// order sections alphabetically to reduce chances of merge conflicts + +#endif // QT_CORE_REMOVED_SINCE(6, 6) + +#if QT_CORE_REMOVED_SINCE(6, 7) + +#include "qbitarray.h" + +QBitArray QBitArray::operator~() const +{ + return QBitArray(*this).inverted_inplace(); +} + +#include "qbytearray.h" // also includes inlined API + +QByteArray QByteArray::left(qsizetype len) const +{ + if (len >= size()) + return *this; + if (len < 0) + len = 0; + return QByteArray(data(), len); +} + +QByteArray QByteArray::right(qsizetype len) const +{ + if (len >= size()) + return *this; + if (len < 0) + len = 0; + return QByteArray(end() - len, len); +} + +QByteArray QByteArray::mid(qsizetype pos, qsizetype len) const +{ + qsizetype p = pos; + qsizetype l = len; + using namespace QtPrivate; + switch (QContainerImplHelper::mid(size(), &p, &l)) { + case QContainerImplHelper::Null: + return QByteArray(); + case QContainerImplHelper::Empty: + { + return QByteArray(DataPointer::fromRawData(&_empty, 0)); + } + case QContainerImplHelper::Full: + return *this; + case QContainerImplHelper::Subset: + return QByteArray(d.data() + p, l); + } + Q_UNREACHABLE_RETURN(QByteArray()); +} + +#ifdef Q_CC_MSVC +// previously inline methods, only needed for MSVC compat +QByteArray QByteArray::first(qsizetype n) const +{ return sliced(0, n); } +QByteArray QByteArray::last(qsizetype n) const +{ return sliced(size() - n, n); } +QByteArray QByteArray::sliced(qsizetype pos) const +{ return sliced(pos, size() - pos); } +QByteArray QByteArray::sliced(qsizetype pos, qsizetype n) const +{ verify(pos, n); return QByteArray(d.data() + pos, n); } +QByteArray QByteArray::chopped(qsizetype n) const +{ return sliced(0, size() - n); } +#endif + +#include "qcborstreamreader.h" + +QCborError QCborStreamReader::lastError() +{ + return std::as_const(*this).lastError(); +} + +#include "qdatetime.h" + +QDateTime::QDateTime(QDate date, QTime time, const QTimeZone &timeZone) + : QDateTime(date, time, timeZone, TransitionResolution::LegacyBehavior) {} +QDateTime::QDateTime(QDate date, QTime time) + : QDateTime(date, time, TransitionResolution::LegacyBehavior) {} +void QDateTime::setDate(QDate date) { setDate(date, TransitionResolution::LegacyBehavior); } +void QDateTime::setTime(QTime time) { setTime(time, TransitionResolution::LegacyBehavior); } +void QDateTime::setTimeZone(const QTimeZone &toZone) +{ + setTimeZone(toZone, TransitionResolution::LegacyBehavior); +} + +bool QDateTime::precedes(const QDateTime &other) const +{ + return compareThreeWay(*this, other) < 0; +} + +#include "qdatastream.h" + +QDataStream &QDataStream::writeBytes(const char *s, uint len) +{ + return writeBytes(s, qint64(len)); +} + +int QDataStream::skipRawData(int len) +{ + return int(skipRawData(qint64(len))); +} + +int QDataStream::readBlock(char *data, int len) +{ + return int(readBlock(data, qint64(len))); +} + +int QDataStream::readRawData(char *s, int len) +{ + return int(readRawData(s, qint64(len))); +} + +int QDataStream::writeRawData(const char *s, int len) +{ + return writeRawData(s, qint64(len)); +} + +#if defined(Q_OS_ANDROID) + +#include "qjniobject.h" + +jclass QJniObject::loadClass(const QByteArray &className, JNIEnv *env, bool /*binEncoded*/) +{ + return QJniObject::loadClass(className, env); +} + +QByteArray QJniObject::toBinaryEncClassName(const QByteArray &className) +{ + return QByteArray(className).replace('/', '.'); +} + +void QJniObject::callVoidMethodV(JNIEnv *env, jmethodID id, va_list args) const +{ + env->CallVoidMethodV(javaObject(), id, args); +} + +#endif // Q_OS_ANDROID + +#include "qlocale.h" + +QStringList QLocale::uiLanguages() const +{ + return uiLanguages(TagSeparator::Dash); +} + +QString QLocale::name() const +{ + return name(TagSeparator::Underscore); +} + +QString QLocale::bcp47Name() const +{ + return bcp47Name(TagSeparator::Dash); +} + +QDate QLocale::toDate(const QString &string, FormatType format) const +{ + return toDate(string, dateFormat(format), DefaultTwoDigitBaseYear); +} + +QDate QLocale::toDate(const QString &string, FormatType format, QCalendar cal) const +{ + return toDate(string, dateFormat(format), cal, DefaultTwoDigitBaseYear); +} + +QDateTime QLocale::toDateTime(const QString &string, FormatType format) const +{ + return toDateTime(string, dateTimeFormat(format), DefaultTwoDigitBaseYear); +} + +QDateTime QLocale::toDateTime(const QString &string, FormatType format, QCalendar cal) const +{ + return toDateTime(string, dateTimeFormat(format), cal, DefaultTwoDigitBaseYear); +} + +QDate QLocale::toDate(const QString &string, const QString &format) const +{ + return toDate(string, format, QCalendar(), DefaultTwoDigitBaseYear); +} + +QDate QLocale::toDate(const QString &string, const QString &format, QCalendar cal) const +{ + return toDate(string, format, cal, DefaultTwoDigitBaseYear); +} + +QDateTime QLocale::toDateTime(const QString &string, const QString &format) const +{ + return toDateTime(string, format, QCalendar(), DefaultTwoDigitBaseYear); +} + +QDateTime QLocale::toDateTime(const QString &string, const QString &format, QCalendar cal) const +{ + return toDateTime(string, format, cal, DefaultTwoDigitBaseYear); +} + +#include "qobject.h" + +void qt_qFindChildren_helper(const QObject *parent, const QMetaObject &mo, + QList<void*> *list, Qt::FindChildOptions options) +{ + qt_qFindChildren_helper(parent, QAnyStringView(), mo, list, options); +} + +void qt_qFindChildren_helper(const QObject *parent, const QString &name, const QMetaObject &mo, + QList<void*> *list, Qt::FindChildOptions options) +{ + qt_qFindChildren_helper(parent, QAnyStringView{name}, mo, list, options); +} + +QObject *qt_qFindChild_helper(const QObject *parent, const QString &name, const QMetaObject &mo, + Qt::FindChildOptions options) +{ + return qt_qFindChild_helper(parent, QAnyStringView{name}, mo, options); +} + +void QObject::moveToThread(QThread *targetThread) +{ + moveToThread(targetThread, QT6_CALL_NEW_OVERLOAD); +} + +#include "qobjectdefs.h" + +bool QMetaObject::invokeMethodImpl(QObject *object, QtPrivate::QSlotObjectBase *slot, Qt::ConnectionType type, void *ret) +{ + return invokeMethodImpl(object, slot, type, 1, &ret, nullptr, nullptr); +} + +#include "qstring.h" + +QString QString::left(qsizetype n) const +{ + if (size_t(n) >= size_t(size())) + return *this; + return QString((const QChar*) d.data(), n); +} + +QString QString::right(qsizetype n) const +{ + if (size_t(n) >= size_t(size())) + return *this; + return QString(constData() + size() - n, n); +} + +QString QString::mid(qsizetype position, qsizetype n) const +{ + qsizetype p = position; + qsizetype l = n; + using namespace QtPrivate; + switch (QContainerImplHelper::mid(size(), &p, &l)) { + case QContainerImplHelper::Null: + return QString(); + case QContainerImplHelper::Empty: + return QString(DataPointer::fromRawData(&_empty, 0)); + case QContainerImplHelper::Full: + return *this; + case QContainerImplHelper::Subset: + return QString(constData() + p, l); + } + Q_UNREACHABLE_RETURN(QString()); +} + +#ifdef Q_CC_MSVC +// previously inline methods, only needed for MSVC compat +QString QString::first(qsizetype n) const +{ return sliced(0, n); } +QString QString::last(qsizetype n) const +{ return sliced(size() - n, n); } +QString QString::sliced(qsizetype pos) const +{ return sliced(pos, size() - pos); } +QString QString::sliced(qsizetype pos, qsizetype n) const +{ verify(pos, n); return QString(begin() + pos, n); } +QString QString::chopped(qsizetype n) const +{ return sliced(0, size() - n); } +#endif + +#include "qtimezone.h" + +bool QTimeZone::operator==(const QTimeZone &other) const +{ + return comparesEqual(*this, other); +} + +bool QTimeZone::operator!=(const QTimeZone &other) const +{ + return !comparesEqual(*this, other); +} + +#include "qurl.h" + +QUrl QUrl::fromEncoded(const QByteArray &input, ParsingMode mode) +{ + return QUrl::fromEncoded(QByteArrayView(input), mode); +} + +#include "qtimer.h" // inlined API + + +// #include "qotherheader.h" +// // implement removed functions from qotherheader.h +// order sections alphabetically to reduce chances of merge conflicts + +#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 + +#include "qcborarray.h" // inlined API + +#include "qcbormap.h" // inlined API + +#include "qcborvalue.h" // inlined API + +#include "qdatastream.h" // inlined API + +QDataStream &QDataStream::operator<<(bool i) +{ + return (*this << qint8(i)); +} + +#include "qdir.h" // inlined API + +bool QDir::operator==(const QDir &dir) const +{ + return comparesEqual(*this, dir); +} + +#include "qeasingcurve.h" + +bool QEasingCurve::operator==(const QEasingCurve &other) const +{ + return comparesEqual(*this, other); +} + +#include "qfileinfo.h" // inlined API + +bool QFileInfo::operator==(const QFileInfo &fileinfo) const +{ + return comparesEqual(*this, fileinfo); +} + +#include "qitemselectionmodel.h" // inlined API + +#include "qjsonarray.h" + +bool QJsonArray::operator==(const QJsonArray &other) const +{ + return comparesEqual(*this, other); +} + +bool QJsonArray::operator!=(const QJsonArray &other) const +{ + return !comparesEqual(*this, other); +} + +#include "qjsondocument.h" + +bool QJsonDocument::operator==(const QJsonDocument &other) const +{ + return comparesEqual(*this, other); +} + +#include "qjsonobject.h" + +bool QJsonObject::operator==(const QJsonObject &other) const +{ + return comparesEqual(*this, other); +} + + +bool QJsonObject::operator!=(const QJsonObject &other) const +{ + return !comparesEqual(*this, other); +} + +#include "qjsonvalue.h" + +bool QJsonValue::operator==(const QJsonValue &other) const +{ + return comparesEqual(*this, other); +} + +bool QJsonValue::operator!=(const QJsonValue &other) const +{ + return !comparesEqual(*this, other); +} + +#include "qline.h" // inlined API + +#include "qmimetype.h" + +bool QMimeType::operator==(const QMimeType &other) const +{ + return comparesEqual(*this, other); +} + +#include "qobject.h" +#include "qnumeric.h" + +int QObject::startTimer(std::chrono::milliseconds time, Qt::TimerType timerType) +{ + using namespace std::chrono; + using ratio = std::ratio_divide<std::milli, std::nano>; + nanoseconds::rep r; + if (qMulOverflow<ratio::num>(time.count(), &r)) { + qWarning("QObject::startTimer(std::chrono::milliseconds): " + "'time' arg overflowed when converted to nanoseconds."); + r = nanoseconds::max().count(); + } + return startTimer(nanoseconds{r}, timerType); +} + +#if QT_CONFIG(processenvironment) +#include "qprocess.h" // inlined API + +bool QProcessEnvironment::operator==(const QProcessEnvironment &other) const +{ + return comparesEqual(*this, other); +} +#endif // QT_CONFIG(processenvironment) + +#if QT_CONFIG(regularexpression) +#include "qregularexpression.h" + +bool QRegularExpressionMatch::hasCaptured(QStringView name) const +{ + return hasCaptured(QAnyStringView(name)); +} + +QString QRegularExpressionMatch::captured(QStringView name) const +{ + return captured(QAnyStringView(name)); +} + +QStringView QRegularExpressionMatch::capturedView(QStringView name) const +{ + return capturedView(QAnyStringView(name)); +} + +qsizetype QRegularExpressionMatch::capturedStart(QStringView name) const +{ + return capturedStart(QAnyStringView(name)); +} + +qsizetype QRegularExpressionMatch::capturedLength(QStringView name) const +{ + return capturedLength(QAnyStringView(name)); +} + +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 +{ + return is_lt(compareThreeWay(*this, url)); +} + +bool QUrl::operator==(const QUrl &url) const +{ + return comparesEqual(*this, url); +} + +bool QUrl::operator!=(const QUrl &url) const +{ + return !comparesEqual(*this, url); +} + +#include "qurlquery.h" + +bool QUrlQuery::operator==(const QUrlQuery &other) const +{ + return comparesEqual(*this, other); +} + +#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)); +} + +#include "qxmlstream.h" // inlined API + +// #include "qotherheader.h" +// // implement removed functions from qotherheader.h +// order sections alphabetically to reduce chances of merge conflicts + +#endif // QT_CORE_REMOVED_SINCE(6, 8) |