diff options
Diffstat (limited to 'src/corelib/compat/removed_api.cpp')
| -rw-r--r-- | src/corelib/compat/removed_api.cpp | 612 |
1 files changed, 611 insertions, 1 deletions
diff --git a/src/corelib/compat/removed_api.cpp b/src/corelib/compat/removed_api.cpp index dde262e779..c5ec16a246 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) { @@ -200,7 +210,7 @@ void QObject::setObjectName(const QString &name) void QSettings::beginGroup(const QString &prefix) { - return beginGroup(qToAnyStringViewIgnoringNull(prefix)); + beginGroup(qToAnyStringViewIgnoringNull(prefix)); } int QSettings::beginReadArray(const QString &prefix) @@ -576,6 +586,8 @@ void QThreadPool::startOnReservedThread(std::function<void()> functionToRun) #endif // QT_CONFIG(thread) +#if QT_CONFIG(xmlstream) + #include "qxmlstream.h" QStringView QXmlStreamAttributes::value(const QString &namespaceUri, const QString &name) const @@ -603,6 +615,8 @@ QStringView QXmlStreamAttributes::value(QLatin1StringView qualifiedName) const return value(QAnyStringView(qualifiedName)); } +#endif // xmlstream + // inlined API #if QT_CONFIG(thread) #include "qmutex.h" @@ -615,3 +629,599 @@ QStringView QXmlStreamAttributes::value(QLatin1StringView qualifiedName) const // 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" + +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); +} + +#if QT_CONFIG(datestring) + +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); +} + +#endif // datestring + +#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 + +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 + +#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); +} + +#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 +{ + return comparesEqual(*this, fileinfo); +} + +#if QT_CONFIG(itemmodel) +#include "qitemselectionmodel.h" // inlined API +#endif // itemmodel + +#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 + +#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) +{ + 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 + +#include "qstringconverter.h" + +QStringConverter::QStringConverter(const char *name, Flags f) + : QStringConverter(QAnyStringView{name}, f) +{} + +auto QStringConverter::encodingForName(const char *name) noexcept -> std::optional<Encoding> +{ + return encodingForName(QAnyStringView{name}); +} + +#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)); +} + +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 +// order sections alphabetically to reduce chances of merge conflicts + +#endif // QT_CORE_REMOVED_SINCE(6, 8) + +#if QT_CORE_REMOVED_SINCE(6, 9) + + +// #include "qotherheader.h" +// // implement removed functions from qotherheader.h +// order sections alphabetically to reduce chances of merge conflicts + +#endif // QT_CORE_REMOVED_SINCE(6, 9) |