luke
/
klayout
mirror of https://github.com/KLayout/klayout.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Updating Qt binding files

This commit is contained in:
Matthias Koefferlein 2024-10-19 20:35:43 +02:00
parent c7ec242b8b
commit 0328c7e9bd
55 changed files with 1069 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
src/gsiqt/qt6/QtCore/gsiDeclQAnyStringView.cc
View File

@ -304,6 +304,36 @@ static void _call_f_equal_3602 (const qt_gsi::GenericStaticMethod * /*decl*/, gs
}
// bool ::operator==(QAnyStringView lhs, QAnyStringView rhs)
static bool op_QAnyStringView_operator_eq__eq__3602(QAnyStringView *_self, QAnyStringView rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(QAnyStringView lhs, QAnyStringView rhs)
static bool op_QAnyStringView_operator_excl__eq__3602(QAnyStringView *_self, QAnyStringView rhs) {
return operator!=(*_self, rhs);
}
// bool ::operator<=(QAnyStringView lhs, QAnyStringView rhs)
static bool op_QAnyStringView_operator_lt__eq__3602(QAnyStringView *_self, QAnyStringView rhs) {
return operator<=(*_self, rhs);
}
// bool ::operator>=(QAnyStringView lhs, QAnyStringView rhs)
static bool op_QAnyStringView_operator_gt__eq__3602(QAnyStringView *_self, QAnyStringView rhs) {
return operator>=(*_self, rhs);
}
// bool ::operator<(QAnyStringView lhs, QAnyStringView rhs)
static bool op_QAnyStringView_operator_lt__3602(QAnyStringView *_self, QAnyStringView rhs) {
return operator<(*_self, rhs);
}
// bool ::operator>(QAnyStringView lhs, QAnyStringView rhs)
static bool op_QAnyStringView_operator_gt__3602(QAnyStringView *_self, QAnyStringView rhs) {
return operator>(*_self, rhs);
}
namespace gsi
{
@ -326,6 +356,12 @@ static gsi::Methods methods_QAnyStringView () {
methods += new qt_gsi::GenericMethod ("toString", "@brief Method QString QAnyStringView::toString()\n", true, &_init_f_toString_c0, &_call_f_toString_c0);
methods += new qt_gsi::GenericStaticMethod ("compare", "@brief Static method int QAnyStringView::compare(QAnyStringView lhs, QAnyStringView rhs, Qt::CaseSensitivity cs)\nThis method is static and can be called without an instance.", &_init_f_compare_5818, &_call_f_compare_5818);
methods += new qt_gsi::GenericStaticMethod ("equal", "@brief Static method bool QAnyStringView::equal(QAnyStringView lhs, QAnyStringView rhs)\nThis method is static and can be called without an instance.", &_init_f_equal_3602, &_call_f_equal_3602);
methods += gsi::method_ext("==", &::op_QAnyStringView_operator_eq__eq__3602, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QAnyStringView lhs, QAnyStringView rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QAnyStringView_operator_excl__eq__3602, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QAnyStringView lhs, QAnyStringView rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<=", &::op_QAnyStringView_operator_lt__eq__3602, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(QAnyStringView lhs, QAnyStringView rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">=", &::op_QAnyStringView_operator_gt__eq__3602, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(QAnyStringView lhs, QAnyStringView rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<", &::op_QAnyStringView_operator_lt__3602, gsi::arg ("rhs"), "@brief Operator bool ::operator<(QAnyStringView lhs, QAnyStringView rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">", &::op_QAnyStringView_operator_gt__3602, gsi::arg ("rhs"), "@brief Operator bool ::operator>(QAnyStringView lhs, QAnyStringView rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

6
src/gsiqt/qt6/QtCore/gsiDeclQCollatorSortKey.cc
View File

@ -112,6 +112,11 @@ static void _call_f_swap_2252 (const qt_gsi::GenericMethod * /*decl*/, void *cls
}
// bool ::operator<(const QCollatorSortKey &lhs, const QCollatorSortKey &rhs)
static bool op_QCollatorSortKey_operator_lt__5786(const QCollatorSortKey *_self, const QCollatorSortKey &rhs) {
return operator<(*_self, rhs);
}
namespace gsi
{
@ -122,6 +127,7 @@ static gsi::Methods methods_QCollatorSortKey () {
methods += new qt_gsi::GenericMethod ("compare", "@brief Method int QCollatorSortKey::compare(const QCollatorSortKey &key)\n", true, &_init_f_compare_c2947, &_call_f_compare_c2947);
methods += new qt_gsi::GenericMethod ("assign", "@brief Method QCollatorSortKey &QCollatorSortKey::operator=(const QCollatorSortKey &other)\n", false, &_init_f_operator_eq__2947, &_call_f_operator_eq__2947);
methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QCollatorSortKey::swap(QCollatorSortKey &other)\n", false, &_init_f_swap_2252, &_call_f_swap_2252);
methods += gsi::method_ext("<", &::op_QCollatorSortKey_operator_lt__5786, gsi::arg ("rhs"), "@brief Operator bool ::operator<(const QCollatorSortKey &lhs, const QCollatorSortKey &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

36
src/gsiqt/qt6/QtCore/gsiDeclQDate.cc
View File

@ -855,6 +855,36 @@ static void _call_f_isValid_2085 (const qt_gsi::GenericStaticMethod * /*decl*/,
}
// bool ::operator==(QDate lhs, QDate rhs)
static bool op_QDate_operator_eq__eq__1690(QDate *_self, QDate rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(QDate lhs, QDate rhs)
static bool op_QDate_operator_excl__eq__1690(QDate *_self, QDate rhs) {
return operator!=(*_self, rhs);
}
// bool ::operator<(QDate lhs, QDate rhs)
static bool op_QDate_operator_lt__1690(QDate *_self, QDate rhs) {
return operator<(*_self, rhs);
}
// bool ::operator<=(QDate lhs, QDate rhs)
static bool op_QDate_operator_lt__eq__1690(QDate *_self, QDate rhs) {
return operator<=(*_self, rhs);
}
// bool ::operator>(QDate lhs, QDate rhs)
static bool op_QDate_operator_gt__1690(QDate *_self, QDate rhs) {
return operator>(*_self, rhs);
}
// bool ::operator>=(QDate lhs, QDate rhs)
static bool op_QDate_operator_gt__eq__1690(QDate *_self, QDate rhs) {
return operator>=(*_self, rhs);
}
namespace gsi
{
@ -903,6 +933,12 @@ static gsi::Methods methods_QDate () {
methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QDate QDate::fromString(const QString &string, const QString &format, QCalendar cal)\nThis method is static and can be called without an instance.", &_init_f_fromString_5145, &_call_f_fromString_5145);
methods += new qt_gsi::GenericStaticMethod ("isLeapYear?", "@brief Static method bool QDate::isLeapYear(int year)\nThis method is static and can be called without an instance.", &_init_f_isLeapYear_767, &_call_f_isLeapYear_767);
methods += new qt_gsi::GenericStaticMethod ("isValid?", "@brief Static method bool QDate::isValid(int y, int m, int d)\nThis method is static and can be called without an instance.", &_init_f_isValid_2085, &_call_f_isValid_2085);
methods += gsi::method_ext("==", &::op_QDate_operator_eq__eq__1690, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QDate lhs, QDate rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QDate_operator_excl__eq__1690, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QDate lhs, QDate rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<", &::op_QDate_operator_lt__1690, gsi::arg ("rhs"), "@brief Operator bool ::operator<(QDate lhs, QDate rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<=", &::op_QDate_operator_lt__eq__1690, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(QDate lhs, QDate rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">", &::op_QDate_operator_gt__1690, gsi::arg ("rhs"), "@brief Operator bool ::operator>(QDate lhs, QDate rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">=", &::op_QDate_operator_gt__eq__1690, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(QDate lhs, QDate rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

36
src/gsiqt/qt6/QtCore/gsiDeclQDateTime.cc
View File

@ -951,6 +951,36 @@ static void _call_f_fromString_5145 (const qt_gsi::GenericStaticMethod * /*decl*
}
// bool ::operator==(const QDateTime &lhs, const QDateTime &rhs)
static bool op_QDateTime_operator_eq__eq__4242(const QDateTime *_self, const QDateTime &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QDateTime &lhs, const QDateTime &rhs)
static bool op_QDateTime_operator_excl__eq__4242(const QDateTime *_self, const QDateTime &rhs) {
return operator!=(*_self, rhs);
}
// bool ::operator<(const QDateTime &lhs, const QDateTime &rhs)
static bool op_QDateTime_operator_lt__4242(const QDateTime *_self, const QDateTime &rhs) {
return operator<(*_self, rhs);
}
// bool ::operator<=(const QDateTime &lhs, const QDateTime &rhs)
static bool op_QDateTime_operator_lt__eq__4242(const QDateTime *_self, const QDateTime &rhs) {
return operator<=(*_self, rhs);
}
// bool ::operator>(const QDateTime &lhs, const QDateTime &rhs)
static bool op_QDateTime_operator_gt__4242(const QDateTime *_self, const QDateTime &rhs) {
return operator>(*_self, rhs);
}
// bool ::operator>=(const QDateTime &lhs, const QDateTime &rhs)
static bool op_QDateTime_operator_gt__eq__4242(const QDateTime *_self, const QDateTime &rhs) {
return operator>=(*_self, rhs);
}
namespace gsi
{
@ -1006,6 +1036,12 @@ static gsi::Methods methods_QDateTime () {
methods += new qt_gsi::GenericStaticMethod ("fromSecsSinceEpoch", "@brief Static method QDateTime QDateTime::fromSecsSinceEpoch(qint64 secs, const QTimeZone &timeZone)\nThis method is static and can be called without an instance.", &_init_f_fromSecsSinceEpoch_3083, &_call_f_fromSecsSinceEpoch_3083);
methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QDateTime QDateTime::fromString(const QString &string, Qt::DateFormat format)\nThis method is static and can be called without an instance.", &_init_f_fromString_3665, &_call_f_fromString_3665);
methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QDateTime QDateTime::fromString(const QString &string, const QString &format, QCalendar cal)\nThis method is static and can be called without an instance.", &_init_f_fromString_5145, &_call_f_fromString_5145);
methods += gsi::method_ext("==", &::op_QDateTime_operator_eq__eq__4242, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QDateTime &lhs, const QDateTime &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QDateTime_operator_excl__eq__4242, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QDateTime &lhs, const QDateTime &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<", &::op_QDateTime_operator_lt__4242, gsi::arg ("rhs"), "@brief Operator bool ::operator<(const QDateTime &lhs, const QDateTime &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<=", &::op_QDateTime_operator_lt__eq__4242, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(const QDateTime &lhs, const QDateTime &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">", &::op_QDateTime_operator_gt__4242, gsi::arg ("rhs"), "@brief Operator bool ::operator>(const QDateTime &lhs, const QDateTime &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">=", &::op_QDateTime_operator_gt__eq__4242, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(const QDateTime &lhs, const QDateTime &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

48
src/gsiqt/qt6/QtCore/gsiDeclQDeadlineTimer.cc
View File

@ -420,6 +420,46 @@ static void _call_f_current_1680 (const qt_gsi::GenericStaticMethod * /*decl*/,
}
// bool ::operator==(QDeadlineTimer d1, QDeadlineTimer d2)
static bool op_QDeadlineTimer_operator_eq__eq__3532(QDeadlineTimer *_self, QDeadlineTimer d2) {
return operator==(*_self, d2);
}
// bool ::operator!=(QDeadlineTimer d1, QDeadlineTimer d2)
static bool op_QDeadlineTimer_operator_excl__eq__3532(QDeadlineTimer *_self, QDeadlineTimer d2) {
return operator!=(*_self, d2);
}
// bool ::operator<(QDeadlineTimer d1, QDeadlineTimer d2)
static bool op_QDeadlineTimer_operator_lt__3532(QDeadlineTimer *_self, QDeadlineTimer d2) {
return operator<(*_self, d2);
}
// bool ::operator<=(QDeadlineTimer d1, QDeadlineTimer d2)
static bool op_QDeadlineTimer_operator_lt__eq__3532(QDeadlineTimer *_self, QDeadlineTimer d2) {
return operator<=(*_self, d2);
}
// bool ::operator>(QDeadlineTimer d1, QDeadlineTimer d2)
static bool op_QDeadlineTimer_operator_gt__3532(QDeadlineTimer *_self, QDeadlineTimer d2) {
return operator>(*_self, d2);
}
// bool ::operator>=(QDeadlineTimer d1, QDeadlineTimer d2)
static bool op_QDeadlineTimer_operator_gt__eq__3532(QDeadlineTimer *_self, QDeadlineTimer d2) {
return operator>=(*_self, d2);
}
// QDeadlineTimer ::operator-(QDeadlineTimer dt, qint64 msecs)
static QDeadlineTimer op_QDeadlineTimer_operator_minus__2698(QDeadlineTimer *_self, qint64 msecs) {
return operator-(*_self, msecs);
}
// qint64 ::operator-(QDeadlineTimer dt1, QDeadlineTimer dt2)
static qint64 op_QDeadlineTimer_operator_minus__3532(QDeadlineTimer *_self, QDeadlineTimer dt2) {
return operator-(*_self, dt2);
}
namespace gsi
{
@ -446,6 +486,14 @@ static gsi::Methods methods_QDeadlineTimer () {
methods += new qt_gsi::GenericMethod (":timerType", "@brief Method Qt::TimerType QDeadlineTimer::timerType()\n", true, &_init_f_timerType_c0, &_call_f_timerType_c0);
methods += new qt_gsi::GenericStaticMethod ("addNSecs", "@brief Static method QDeadlineTimer QDeadlineTimer::addNSecs(QDeadlineTimer dt, qint64 nsecs)\nThis method is static and can be called without an instance.", &_init_f_addNSecs_2698, &_call_f_addNSecs_2698);
methods += new qt_gsi::GenericStaticMethod ("current", "@brief Static method QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType)\nThis method is static and can be called without an instance.", &_init_f_current_1680, &_call_f_current_1680);
methods += gsi::method_ext("==", &::op_QDeadlineTimer_operator_eq__eq__3532, gsi::arg ("d2"), "@brief Operator bool ::operator==(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QDeadlineTimer_operator_excl__eq__3532, gsi::arg ("d2"), "@brief Operator bool ::operator!=(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<", &::op_QDeadlineTimer_operator_lt__3532, gsi::arg ("d2"), "@brief Operator bool ::operator<(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<=", &::op_QDeadlineTimer_operator_lt__eq__3532, gsi::arg ("d2"), "@brief Operator bool ::operator<=(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">", &::op_QDeadlineTimer_operator_gt__3532, gsi::arg ("d2"), "@brief Operator bool ::operator>(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">=", &::op_QDeadlineTimer_operator_gt__eq__3532, gsi::arg ("d2"), "@brief Operator bool ::operator>=(QDeadlineTimer d1, QDeadlineTimer d2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QDeadlineTimer_operator_minus__2698, gsi::arg ("msecs"), "@brief Operator QDeadlineTimer ::operator-(QDeadlineTimer dt, qint64 msecs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QDeadlineTimer_operator_minus__3532, gsi::arg ("dt2"), "@brief Operator qint64 ::operator-(QDeadlineTimer dt1, QDeadlineTimer dt2)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtCore/gsiDeclQElapsedTimer.cc
View File

@ -244,6 +244,16 @@ static void _call_f_isMonotonic_0 (const qt_gsi::GenericStaticMethod * /*decl*/,
}
// bool ::operator==(const QElapsedTimer &lhs, const QElapsedTimer &rhs)
static bool op_QElapsedTimer_operator_eq__eq__5110(const QElapsedTimer *_self, const QElapsedTimer &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QElapsedTimer &lhs, const QElapsedTimer &rhs)
static bool op_QElapsedTimer_operator_excl__eq__5110(const QElapsedTimer *_self, const QElapsedTimer &rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -263,6 +273,8 @@ static gsi::Methods methods_QElapsedTimer () {
methods += new qt_gsi::GenericMethod ("start", "@brief Method void QElapsedTimer::start()\n", false, &_init_f_start_0, &_call_f_start_0);
methods += new qt_gsi::GenericStaticMethod ("clockType", "@brief Static method QElapsedTimer::ClockType QElapsedTimer::clockType()\nThis method is static and can be called without an instance.", &_init_f_clockType_0, &_call_f_clockType_0);
methods += new qt_gsi::GenericStaticMethod ("isMonotonic?", "@brief Static method bool QElapsedTimer::isMonotonic()\nThis method is static and can be called without an instance.", &_init_f_isMonotonic_0, &_call_f_isMonotonic_0);
methods += gsi::method_ext("==", &::op_QElapsedTimer_operator_eq__eq__5110, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QElapsedTimer &lhs, const QElapsedTimer &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QElapsedTimer_operator_excl__eq__5110, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QElapsedTimer &lhs, const QElapsedTimer &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtCore/gsiDeclQKeyCombination.cc
View File

@ -162,6 +162,16 @@ static void _call_f_fromCombined_767 (const qt_gsi::GenericStaticMethod * /*decl
}
// bool ::operator==(QKeyCombination lhs, QKeyCombination rhs)
static bool op_QKeyCombination_operator_eq__eq__3798(QKeyCombination *_self, QKeyCombination rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(QKeyCombination lhs, QKeyCombination rhs)
static bool op_QKeyCombination_operator_excl__eq__3798(QKeyCombination *_self, QKeyCombination rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -175,6 +185,8 @@ static gsi::Methods methods_QKeyCombination () {
methods += new qt_gsi::GenericMethod ("keyboardModifiers", "@brief Method QFlags<Qt::KeyboardModifier> QKeyCombination::keyboardModifiers()\n", true, &_init_f_keyboardModifiers_c0, &_call_f_keyboardModifiers_c0);
methods += new qt_gsi::GenericMethod ("toCombined", "@brief Method int QKeyCombination::toCombined()\n", true, &_init_f_toCombined_c0, &_call_f_toCombined_c0);
methods += new qt_gsi::GenericStaticMethod ("fromCombined", "@brief Static method QKeyCombination QKeyCombination::fromCombined(int combined)\nThis method is static and can be called without an instance.", &_init_f_fromCombined_767, &_call_f_fromCombined_767);
methods += gsi::method_ext("==", &::op_QKeyCombination_operator_eq__eq__3798, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QKeyCombination lhs, QKeyCombination rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QKeyCombination_operator_excl__eq__3798, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QKeyCombination lhs, QKeyCombination rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtCore/gsiDeclQLocale.cc
View File

@ -2105,6 +2105,16 @@ static void _call_f_territoryToString_2205 (const qt_gsi::GenericStaticMethod *
}
// bool ::operator==(const QLocale &lhs, const QLocale &rhs)
static bool op_QLocale_operator_eq__eq__3864(const QLocale *_self, const QLocale &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QLocale &lhs, const QLocale &rhs)
static bool op_QLocale_operator_excl__eq__3864(const QLocale *_self, const QLocale &rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -2216,6 +2226,8 @@ static gsi::Methods methods_QLocale () {
methods += new qt_gsi::GenericStaticMethod ("system", "@brief Static method QLocale QLocale::system()\nThis method is static and can be called without an instance.", &_init_f_system_0, &_call_f_system_0);
methods += new qt_gsi::GenericStaticMethod ("territoryToCode", "@brief Static method QString QLocale::territoryToCode(QLocale::Territory territory)\nThis method is static and can be called without an instance.", &_init_f_territoryToCode_2205, &_call_f_territoryToCode_2205);
methods += new qt_gsi::GenericStaticMethod ("territoryToString", "@brief Static method QString QLocale::territoryToString(QLocale::Territory territory)\nThis method is static and can be called without an instance.", &_init_f_territoryToString_2205, &_call_f_territoryToString_2205);
methods += gsi::method_ext("==", &::op_QLocale_operator_eq__eq__3864, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QLocale &lhs, const QLocale &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QLocale_operator_excl__eq__3864, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QLocale &lhs, const QLocale &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

36
src/gsiqt/qt6/QtCore/gsiDeclQMargins.cc
View File

@ -387,62 +387,72 @@ static void _call_f_top_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, g
// QMargins ::operator+(const QMargins &m1, const QMargins &m2)
static QMargins op_QMargins_operator_plus__4122(const QMargins *_self, const QMargins &m2) {
return ::operator+(*_self, m2);
return operator+(*_self, m2);
}
// QMargins ::operator-(const QMargins &m1, const QMargins &m2)
static QMargins op_QMargins_operator_minus__4122(const QMargins *_self, const QMargins &m2) {
return ::operator-(*_self, m2);
return operator-(*_self, m2);
}
// QMargins ::operator+(const QMargins &lhs, int rhs)
static QMargins op_QMargins_operator_plus__2774(const QMargins *_self, int rhs) {
return ::operator+(*_self, rhs);
return operator+(*_self, rhs);
}
// QMargins ::operator-(const QMargins &lhs, int rhs)
static QMargins op_QMargins_operator_minus__2774(const QMargins *_self, int rhs) {
return ::operator-(*_self, rhs);
return operator-(*_self, rhs);
}
// QMargins ::operator*(const QMargins &margins, int factor)
static QMargins op_QMargins_operator_star__2774(const QMargins *_self, int factor) {
return ::operator*(*_self, factor);
return operator*(*_self, factor);
}
// QMargins ::operator*(const QMargins &margins, qreal factor)
static QMargins op_QMargins_operator_star__2976(const QMargins *_self, qreal factor) {
return ::operator*(*_self, factor);
return operator*(*_self, factor);
}
// QMargins ::operator/(const QMargins &margins, int divisor)
static QMargins op_QMargins_operator_slash__2774(const QMargins *_self, int divisor) {
return ::operator/(*_self, divisor);
return operator/(*_self, divisor);
}
// QMargins ::operator/(const QMargins &margins, qreal divisor)
static QMargins op_QMargins_operator_slash__2976(const QMargins *_self, qreal divisor) {
return ::operator/(*_self, divisor);
return operator/(*_self, divisor);
}
// QMargins ::operator|(const QMargins &m1, const QMargins &m2)
static QMargins op_QMargins_operator_pipe__4122(const QMargins *_self, const QMargins &m2) {
return ::operator|(*_self, m2);
return operator|(*_self, m2);
}
// QMargins ::operator+(const QMargins &margins)
static QMargins op_QMargins_operator_plus__2115(const QMargins *_self) {
return ::operator+(*_self);
return operator+(*_self);
}
// QMargins ::operator-(const QMargins &margins)
static QMargins op_QMargins_operator_minus__2115(const QMargins *_self) {
return ::operator-(*_self);
return operator-(*_self);
}
// QRect ::operator+(const QMargins &margins, const QRect &rectangle)
static QRect op_QMargins_operator_plus__3799(const QMargins *_self, const QRect &rectangle) {
return ::operator+(*_self, rectangle);
return operator+(*_self, rectangle);
}
// bool ::operator==(const QMargins &m1, const QMargins &m2)
static bool op_QMargins_operator_eq__eq__4122(const QMargins *_self, const QMargins &m2) {
return operator==(*_self, m2);
}
// bool ::operator!=(const QMargins &m1, const QMargins &m2)
static bool op_QMargins_operator_excl__eq__4122(const QMargins *_self, const QMargins &m2) {
return operator!=(*_self, m2);
}
@ -482,6 +492,8 @@ static gsi::Methods methods_QMargins () {
methods += gsi::method_ext("+", &::op_QMargins_operator_plus__2115, "@brief Operator QMargins ::operator+(const QMargins &margins)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QMargins_operator_minus__2115, "@brief Operator QMargins ::operator-(const QMargins &margins)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("+", &::op_QMargins_operator_plus__3799, gsi::arg ("rectangle"), "@brief Operator QRect ::operator+(const QMargins &margins, const QRect &rectangle)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("==", &::op_QMargins_operator_eq__eq__4122, gsi::arg ("m2"), "@brief Operator bool ::operator==(const QMargins &m1, const QMargins &m2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QMargins_operator_excl__eq__4122, gsi::arg ("m2"), "@brief Operator bool ::operator!=(const QMargins &m1, const QMargins &m2)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

32
src/gsiqt/qt6/QtCore/gsiDeclQMarginsF.cc
View File

@ -384,52 +384,62 @@ static void _call_f_top_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, g
// QMarginsF ::operator+(const QMarginsF &lhs, const QMarginsF &rhs)
static QMarginsF op_QMarginsF_operator_plus__4262(const QMarginsF *_self, const QMarginsF &rhs) {
return ::operator+(*_self, rhs);
return operator+(*_self, rhs);
}
// QMarginsF ::operator-(const QMarginsF &lhs, const QMarginsF &rhs)
static QMarginsF op_QMarginsF_operator_minus__4262(const QMarginsF *_self, const QMarginsF &rhs) {
return ::operator-(*_self, rhs);
return operator-(*_self, rhs);
}
// QMarginsF ::operator+(const QMarginsF &lhs, qreal rhs)
static QMarginsF op_QMarginsF_operator_plus__3046(const QMarginsF *_self, qreal rhs) {
return ::operator+(*_self, rhs);
return operator+(*_self, rhs);
}
// QMarginsF ::operator-(const QMarginsF &lhs, qreal rhs)
static QMarginsF op_QMarginsF_operator_minus__3046(const QMarginsF *_self, qreal rhs) {
return ::operator-(*_self, rhs);
return operator-(*_self, rhs);
}
// QMarginsF ::operator*(const QMarginsF &lhs, qreal rhs)
static QMarginsF op_QMarginsF_operator_star__3046(const QMarginsF *_self, qreal rhs) {
return ::operator*(*_self, rhs);
return operator*(*_self, rhs);
}
// QMarginsF ::operator/(const QMarginsF &lhs, qreal divisor)
static QMarginsF op_QMarginsF_operator_slash__3046(const QMarginsF *_self, qreal divisor) {
return ::operator/(*_self, divisor);
return operator/(*_self, divisor);
}
// QMarginsF ::operator|(const QMarginsF &m1, const QMarginsF &m2)
static QMarginsF op_QMarginsF_operator_pipe__4262(const QMarginsF *_self, const QMarginsF &m2) {
return ::operator|(*_self, m2);
return operator|(*_self, m2);
}
// QMarginsF ::operator+(const QMarginsF &margins)
static QMarginsF op_QMarginsF_operator_plus__2185(const QMarginsF *_self) {
return ::operator+(*_self);
return operator+(*_self);
}
// QMarginsF ::operator-(const QMarginsF &margins)
static QMarginsF op_QMarginsF_operator_minus__2185(const QMarginsF *_self) {
return ::operator-(*_self);
return operator-(*_self);
}
// QRectF ::operator+(const QMarginsF &lhs, const QRectF &rhs)
static QRectF op_QMarginsF_operator_plus__3939(const QMarginsF *_self, const QRectF &rhs) {
return ::operator+(*_self, rhs);
return operator+(*_self, rhs);
}
// bool ::operator==(const QMarginsF &lhs, const QMarginsF &rhs)
static bool op_QMarginsF_operator_eq__eq__4262(const QMarginsF *_self, const QMarginsF &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QMarginsF &lhs, const QMarginsF &rhs)
static bool op_QMarginsF_operator_excl__eq__4262(const QMarginsF *_self, const QMarginsF &rhs) {
return operator!=(*_self, rhs);
}
@ -467,6 +477,8 @@ static gsi::Methods methods_QMarginsF () {
methods += gsi::method_ext("+", &::op_QMarginsF_operator_plus__2185, "@brief Operator QMarginsF ::operator+(const QMarginsF &margins)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QMarginsF_operator_minus__2185, "@brief Operator QMarginsF ::operator-(const QMarginsF &margins)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("+", &::op_QMarginsF_operator_plus__3939, gsi::arg ("rhs"), "@brief Operator QRectF ::operator+(const QMarginsF &lhs, const QRectF &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("==", &::op_QMarginsF_operator_eq__eq__4262, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QMarginsF &lhs, const QMarginsF &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QMarginsF_operator_excl__eq__4262, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QMarginsF &lhs, const QMarginsF &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtCore/gsiDeclQMetaAssociation.cc
View File

@ -540,6 +540,16 @@ static void _call_f_setMappedAtKey_c4342 (const qt_gsi::GenericMethod * /*decl*/
}
// bool ::operator==(const QMetaAssociation &a, const QMetaAssociation &b)
static bool op_QMetaAssociation_operator_eq__eq__5760(const QMetaAssociation *_self, const QMetaAssociation &b) {
return operator==(*_self, b);
}
// bool ::operator!=(const QMetaAssociation &a, const QMetaAssociation &b)
static bool op_QMetaAssociation_operator_excl__eq__5760(const QMetaAssociation *_self, const QMetaAssociation &b) {
return operator!=(*_self, b);
}
namespace gsi
{
@ -573,6 +583,8 @@ static gsi::Methods methods_QMetaAssociation () {
methods += new qt_gsi::GenericMethod ("removeKey", "@brief Method void QMetaAssociation::removeKey(void *container, const void *key)\n", true, &_init_f_removeKey_c2699, &_call_f_removeKey_c2699);
methods += new qt_gsi::GenericMethod ("setMappedAtIterator", "@brief Method void QMetaAssociation::setMappedAtIterator(const void *iterator, const void *mapped)\n", true, &_init_f_setMappedAtIterator_c3394, &_call_f_setMappedAtIterator_c3394);
methods += new qt_gsi::GenericMethod ("setMappedAtKey", "@brief Method void QMetaAssociation::setMappedAtKey(void *container, const void *key, const void *mapped)\n", true, &_init_f_setMappedAtKey_c4342, &_call_f_setMappedAtKey_c4342);
methods += gsi::method_ext("==", &::op_QMetaAssociation_operator_eq__eq__5760, gsi::arg ("b"), "@brief Operator bool ::operator==(const QMetaAssociation &a, const QMetaAssociation &b)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QMetaAssociation_operator_excl__eq__5760, gsi::arg ("b"), "@brief Operator bool ::operator!=(const QMetaAssociation &a, const QMetaAssociation &b)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtCore/gsiDeclQMetaMethod.cc
View File

@ -399,6 +399,16 @@ static void _call_f_typeName_c0 (const qt_gsi::GenericMethod * /*decl*/, void *c
}
// bool ::operator==(const QMetaMethod &m1, const QMetaMethod &m2)
static bool op_QMetaMethod_operator_eq__eq__4680(const QMetaMethod *_self, const QMetaMethod &m2) {
return operator==(*_self, m2);
}
// bool ::operator!=(const QMetaMethod &m1, const QMetaMethod &m2)
static bool op_QMetaMethod_operator_excl__eq__4680(const QMetaMethod *_self, const QMetaMethod &m2) {
return operator!=(*_self, m2);
}
namespace gsi
{
@ -428,6 +438,8 @@ static gsi::Methods methods_QMetaMethod () {
methods += new qt_gsi::GenericMethod ("revision", "@brief Method int QMetaMethod::revision()\n", true, &_init_f_revision_c0, &_call_f_revision_c0);
methods += new qt_gsi::GenericMethod ("tag", "@brief Method const char *QMetaMethod::tag()\n", true, &_init_f_tag_c0, &_call_f_tag_c0);
methods += new qt_gsi::GenericMethod ("typeName", "@brief Method const char *QMetaMethod::typeName()\n", true, &_init_f_typeName_c0, &_call_f_typeName_c0);
methods += gsi::method_ext("==", &::op_QMetaMethod_operator_eq__eq__4680, gsi::arg ("m2"), "@brief Operator bool ::operator==(const QMetaMethod &m1, const QMetaMethod &m2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QMetaMethod_operator_excl__eq__4680, gsi::arg ("m2"), "@brief Operator bool ::operator!=(const QMetaMethod &m1, const QMetaMethod &m2)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtCore/gsiDeclQMetaSequence.cc
View File

@ -616,6 +616,16 @@ static void _call_f_valueMetaType_c0 (const qt_gsi::GenericMethod * /*decl*/, vo
}
// bool ::operator==(const QMetaSequence &a, const QMetaSequence &b)
static bool op_QMetaSequence_operator_eq__eq__5112(const QMetaSequence *_self, const QMetaSequence &b) {
return operator==(*_self, b);
}
// bool ::operator!=(const QMetaSequence &a, const QMetaSequence &b)
static bool op_QMetaSequence_operator_excl__eq__5112(const QMetaSequence *_self, const QMetaSequence &b) {
return operator!=(*_self, b);
}
namespace gsi
{
@ -653,6 +663,8 @@ static gsi::Methods methods_QMetaSequence () {
methods += new qt_gsi::GenericMethod ("valueAtIndex", "@brief Method void QMetaSequence::valueAtIndex(const void *container, qsizetype index, void *result)\n", true, &_init_f_valueAtIndex_c4033, &_call_f_valueAtIndex_c4033);
methods += new qt_gsi::GenericMethod ("valueAtIterator", "@brief Method void QMetaSequence::valueAtIterator(const void *iterator, void *result)\n", true, &_init_f_valueAtIterator_c2699, &_call_f_valueAtIterator_c2699);
methods += new qt_gsi::GenericMethod ("valueMetaType", "@brief Method QMetaType QMetaSequence::valueMetaType()\n", true, &_init_f_valueMetaType_c0, &_call_f_valueMetaType_c0);
methods += gsi::method_ext("==", &::op_QMetaSequence_operator_eq__eq__5112, gsi::arg ("b"), "@brief Operator bool ::operator==(const QMetaSequence &a, const QMetaSequence &b)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QMetaSequence_operator_excl__eq__5112, gsi::arg ("b"), "@brief Operator bool ::operator!=(const QMetaSequence &a, const QMetaSequence &b)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtCore/gsiDeclQMetaType.cc
View File

@ -1069,6 +1069,16 @@ static void _call_f_view_4440 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi
}
// bool ::operator==(QMetaType a, QMetaType b)
static bool op_QMetaType_operator_eq__eq__2544(QMetaType *_self, QMetaType b) {
return operator==(*_self, b);
}
// bool ::operator!=(QMetaType a, QMetaType b)
static bool op_QMetaType_operator_excl__eq__2544(QMetaType *_self, QMetaType b) {
return operator!=(*_self, b);
}
namespace gsi
{
@ -1125,6 +1135,8 @@ static gsi::Methods methods_QMetaType () {
methods += new qt_gsi::GenericStaticMethod ("unregisterMetaType", "@brief Static method void QMetaType::unregisterMetaType(QMetaType type)\nThis method is static and can be called without an instance.", &_init_f_unregisterMetaType_1326, &_call_f_unregisterMetaType_1326);
methods += new qt_gsi::GenericStaticMethod ("unregisterMutableViewFunction", "@brief Static method void QMetaType::unregisterMutableViewFunction(QMetaType from, QMetaType to)\nThis method is static and can be called without an instance.", &_init_f_unregisterMutableViewFunction_2544, &_call_f_unregisterMutableViewFunction_2544);
methods += new qt_gsi::GenericStaticMethod ("view", "@brief Static method bool QMetaType::view(QMetaType fromType, void *from, QMetaType toType, void *to)\nThis method is static and can be called without an instance.", &_init_f_view_4440, &_call_f_view_4440);
methods += gsi::method_ext("==", &::op_QMetaType_operator_eq__eq__2544, gsi::arg ("b"), "@brief Operator bool ::operator==(QMetaType a, QMetaType b)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QMetaType_operator_excl__eq__2544, gsi::arg ("b"), "@brief Operator bool ::operator!=(QMetaType a, QMetaType b)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

24
src/gsiqt/qt6/QtCore/gsiDeclQOperatingSystemVersion.cc
View File

@ -199,6 +199,26 @@ static void _call_f_currentType_0 (const qt_gsi::GenericStaticMethod * /*decl*/,
}
// bool ::operator>(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)
static bool op_QOperatingSystemVersion_operator_gt__7328(const QOperatingSystemVersion *_self, const QOperatingSystemVersion &rhs) {
return operator>(*_self, rhs);
}
// bool ::operator>=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)
static bool op_QOperatingSystemVersion_operator_gt__eq__7328(const QOperatingSystemVersion *_self, const QOperatingSystemVersion &rhs) {
return operator>=(*_self, rhs);
}
// bool ::operator<(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)
static bool op_QOperatingSystemVersion_operator_lt__7328(const QOperatingSystemVersion *_self, const QOperatingSystemVersion &rhs) {
return operator<(*_self, rhs);
}
// bool ::operator<=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)
static bool op_QOperatingSystemVersion_operator_lt__eq__7328(const QOperatingSystemVersion *_self, const QOperatingSystemVersion &rhs) {
return operator<=(*_self, rhs);
}
namespace gsi
{
@ -215,6 +235,10 @@ static gsi::Methods methods_QOperatingSystemVersion () {
methods += new qt_gsi::GenericMethod ("version", "@brief Method QVersionNumber QOperatingSystemVersion::version()\n", true, &_init_f_version_c0, &_call_f_version_c0);
methods += new qt_gsi::GenericStaticMethod ("current", "@brief Static method QOperatingSystemVersion QOperatingSystemVersion::current()\nThis method is static and can be called without an instance.", &_init_f_current_0, &_call_f_current_0);
methods += new qt_gsi::GenericStaticMethod ("currentType", "@brief Static method QOperatingSystemVersion::OSType QOperatingSystemVersion::currentType()\nThis method is static and can be called without an instance.", &_init_f_currentType_0, &_call_f_currentType_0);
methods += gsi::method_ext(">", &::op_QOperatingSystemVersion_operator_gt__7328, gsi::arg ("rhs"), "@brief Operator bool ::operator>(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">=", &::op_QOperatingSystemVersion_operator_gt__eq__7328, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<", &::op_QOperatingSystemVersion_operator_lt__7328, gsi::arg ("rhs"), "@brief Operator bool ::operator<(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<=", &::op_QOperatingSystemVersion_operator_lt__eq__7328, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(const QOperatingSystemVersion &lhs, const QOperatingSystemVersion &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtCore/gsiDeclQPartialOrdering.cc
View File

@ -35,12 +35,24 @@
// -----------------------------------------------------------------------
// class QPartialOrdering
// bool ::operator==(QPartialOrdering p1, QPartialOrdering p2)
static bool op_QPartialOrdering_operator_eq__eq__4012(QPartialOrdering *_self, QPartialOrdering p2) {
return operator==(*_self, p2);
}
// bool ::operator!=(QPartialOrdering p1, QPartialOrdering p2)
static bool op_QPartialOrdering_operator_excl__eq__4012(QPartialOrdering *_self, QPartialOrdering p2) {
return operator!=(*_self, p2);
}
namespace gsi
{
static gsi::Methods methods_QPartialOrdering () {
gsi::Methods methods;
methods += gsi::method_ext("==", &::op_QPartialOrdering_operator_eq__eq__4012, gsi::arg ("p2"), "@brief Operator bool ::operator==(QPartialOrdering p1, QPartialOrdering p2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QPartialOrdering_operator_excl__eq__4012, gsi::arg ("p2"), "@brief Operator bool ::operator!=(QPartialOrdering p1, QPartialOrdering p2)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

60
src/gsiqt/qt6/QtCore/gsiDeclQPoint.cc
View File

@ -354,6 +354,56 @@ static void _call_f_dotProduct_3724 (const qt_gsi::GenericStaticMethod * /*decl*
}
// bool ::operator==(const QPoint &p1, const QPoint &p2)
static bool op_QPoint_operator_eq__eq__3724(const QPoint *_self, const QPoint &p2) {
return operator==(*_self, p2);
}
// bool ::operator!=(const QPoint &p1, const QPoint &p2)
static bool op_QPoint_operator_excl__eq__3724(const QPoint *_self, const QPoint &p2) {
return operator!=(*_self, p2);
}
// QPoint ::operator+(const QPoint &p1, const QPoint &p2)
static QPoint op_QPoint_operator_plus__3724(const QPoint *_self, const QPoint &p2) {
return operator+(*_self, p2);
}
// QPoint ::operator-(const QPoint &p1, const QPoint &p2)
static QPoint op_QPoint_operator_minus__3724(const QPoint *_self, const QPoint &p2) {
return operator-(*_self, p2);
}
// QPoint ::operator*(const QPoint &p, float factor)
static QPoint op_QPoint_operator_star__2778(const QPoint *_self, float factor) {
return operator*(*_self, factor);
}
// QPoint ::operator*(const QPoint &p, double factor)
static QPoint op_QPoint_operator_star__2879(const QPoint *_self, double factor) {
return operator*(*_self, factor);
}
// QPoint ::operator*(const QPoint &p, int factor)
static QPoint op_QPoint_operator_star__2575(const QPoint *_self, int factor) {
return operator*(*_self, factor);
}
// QPoint ::operator+(const QPoint &p)
static QPoint op_QPoint_operator_plus__1916(const QPoint *_self) {
return operator+(*_self);
}
// QPoint ::operator-(const QPoint &p)
static QPoint op_QPoint_operator_minus__1916(const QPoint *_self) {
return operator-(*_self);
}
// QPoint ::operator/(const QPoint &p, qreal c)
static QPoint op_QPoint_operator_slash__2777(const QPoint *_self, qreal c) {
return operator/(*_self, c);
}
namespace gsi
{
@ -378,6 +428,16 @@ static gsi::Methods methods_QPoint () {
methods += new qt_gsi::GenericMethod (":x", "@brief Method int QPoint::x()\n", true, &_init_f_x_c0, &_call_f_x_c0);
methods += new qt_gsi::GenericMethod (":y", "@brief Method int QPoint::y()\n", true, &_init_f_y_c0, &_call_f_y_c0);
methods += new qt_gsi::GenericStaticMethod ("dotProduct", "@brief Static method int QPoint::dotProduct(const QPoint &p1, const QPoint &p2)\nThis method is static and can be called without an instance.", &_init_f_dotProduct_3724, &_call_f_dotProduct_3724);
methods += gsi::method_ext("==", &::op_QPoint_operator_eq__eq__3724, gsi::arg ("p2"), "@brief Operator bool ::operator==(const QPoint &p1, const QPoint &p2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QPoint_operator_excl__eq__3724, gsi::arg ("p2"), "@brief Operator bool ::operator!=(const QPoint &p1, const QPoint &p2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("+", &::op_QPoint_operator_plus__3724, gsi::arg ("p2"), "@brief Operator QPoint ::operator+(const QPoint &p1, const QPoint &p2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QPoint_operator_minus__3724, gsi::arg ("p2"), "@brief Operator QPoint ::operator-(const QPoint &p1, const QPoint &p2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QPoint_operator_star__2778, gsi::arg ("factor"), "@brief Operator QPoint ::operator*(const QPoint &p, float factor)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QPoint_operator_star__2879, gsi::arg ("factor"), "@brief Operator QPoint ::operator*(const QPoint &p, double factor)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QPoint_operator_star__2575, gsi::arg ("factor"), "@brief Operator QPoint ::operator*(const QPoint &p, int factor)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("+", &::op_QPoint_operator_plus__1916, "@brief Operator QPoint ::operator+(const QPoint &p)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QPoint_operator_minus__1916, "@brief Operator QPoint ::operator-(const QPoint &p)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QPoint_operator_slash__2777, gsi::arg ("c"), "@brief Operator QPoint ::operator/(const QPoint &p, qreal c)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

48
src/gsiqt/qt6/QtCore/gsiDeclQPointF.cc
View File

@ -350,6 +350,46 @@ static void _call_f_dotProduct_3864 (const qt_gsi::GenericStaticMethod * /*decl*
}
// bool ::operator==(const QPointF &p1, const QPointF &p2)
static bool op_QPointF_operator_eq__eq__3864u1(const QPointF *_self, const QPointF &p2) {
return operator==(*_self, p2);
}
// bool ::operator!=(const QPointF &p1, const QPointF &p2)
static bool op_QPointF_operator_excl__eq__3864u1(const QPointF *_self, const QPointF &p2) {
return operator!=(*_self, p2);
}
// QPointF ::operator+(const QPointF &p1, const QPointF &p2)
static QPointF op_QPointF_operator_plus__3864(const QPointF *_self, const QPointF &p2) {
return operator+(*_self, p2);
}
// QPointF ::operator-(const QPointF &p1, const QPointF &p2)
static QPointF op_QPointF_operator_minus__3864(const QPointF *_self, const QPointF &p2) {
return operator-(*_self, p2);
}
// QPointF ::operator*(const QPointF &p, qreal c)
static QPointF op_QPointF_operator_star__2847(const QPointF *_self, qreal c) {
return operator*(*_self, c);
}
// QPointF ::operator+(const QPointF &p)
static QPointF op_QPointF_operator_plus__1986(const QPointF *_self) {
return operator+(*_self);
}
// QPointF ::operator-(const QPointF &p)
static QPointF op_QPointF_operator_minus__1986(const QPointF *_self) {
return operator-(*_self);
}
// QPointF ::operator/(const QPointF &p, qreal divisor)
static QPointF op_QPointF_operator_slash__2847(const QPointF *_self, qreal divisor) {
return operator/(*_self, divisor);
}
namespace gsi
{
@ -374,6 +414,14 @@ static gsi::Methods methods_QPointF () {
methods += new qt_gsi::GenericMethod (":x", "@brief Method double QPointF::x()\n", true, &_init_f_x_c0, &_call_f_x_c0);
methods += new qt_gsi::GenericMethod (":y", "@brief Method double QPointF::y()\n", true, &_init_f_y_c0, &_call_f_y_c0);
methods += new qt_gsi::GenericStaticMethod ("dotProduct", "@brief Static method double QPointF::dotProduct(const QPointF &p1, const QPointF &p2)\nThis method is static and can be called without an instance.", &_init_f_dotProduct_3864, &_call_f_dotProduct_3864);
methods += gsi::method_ext("==", &::op_QPointF_operator_eq__eq__3864u1, gsi::arg ("p2"), "@brief Operator bool ::operator==(const QPointF &p1, const QPointF &p2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QPointF_operator_excl__eq__3864u1, gsi::arg ("p2"), "@brief Operator bool ::operator!=(const QPointF &p1, const QPointF &p2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("+", &::op_QPointF_operator_plus__3864, gsi::arg ("p2"), "@brief Operator QPointF ::operator+(const QPointF &p1, const QPointF &p2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QPointF_operator_minus__3864, gsi::arg ("p2"), "@brief Operator QPointF ::operator-(const QPointF &p1, const QPointF &p2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QPointF_operator_star__2847, gsi::arg ("c"), "@brief Operator QPointF ::operator*(const QPointF &p, qreal c)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("+", &::op_QPointF_operator_plus__1986, "@brief Operator QPointF ::operator+(const QPointF &p)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QPointF_operator_minus__1986, "@brief Operator QPointF ::operator-(const QPointF &p)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QPointF_operator_slash__2847, gsi::arg ("divisor"), "@brief Operator QPointF ::operator/(const QPointF &p, qreal divisor)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

6
src/gsiqt/qt6/QtCore/gsiDeclQRandomGenerator.cc
View File

@ -561,6 +561,11 @@ static void _call_f_system_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi:
}
// bool ::operator!=(const QRandomGenerator &rng1, const QRandomGenerator &rng2)
static bool op_QRandomGenerator_operator_excl__eq__5768(const QRandomGenerator *_self, const QRandomGenerator &rng2) {
return operator!=(*_self, rng2);
}
namespace gsi
{
@ -595,6 +600,7 @@ static gsi::Methods methods_QRandomGenerator () {
methods += new qt_gsi::GenericStaticMethod ("min", "@brief Static method quint32 QRandomGenerator::min()\nThis method is static and can be called without an instance.", &_init_f_min_0, &_call_f_min_0);
methods += new qt_gsi::GenericStaticMethod ("securelySeeded", "@brief Static method QRandomGenerator QRandomGenerator::securelySeeded()\nThis method is static and can be called without an instance.", &_init_f_securelySeeded_0, &_call_f_securelySeeded_0);
methods += new qt_gsi::GenericStaticMethod ("system", "@brief Static method QRandomGenerator *QRandomGenerator::system()\nThis method is static and can be called without an instance.", &_init_f_system_0, &_call_f_system_0);
methods += gsi::method_ext("!=", &::op_QRandomGenerator_operator_excl__eq__5768, gsi::arg ("rng2"), "@brief Operator bool ::operator!=(const QRandomGenerator &rng1, const QRandomGenerator &rng2)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

16
src/gsiqt/qt6/QtCore/gsiDeclQRect.cc
View File

@ -1474,12 +1474,22 @@ static void _call_f_span_3724 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi
// QRect ::operator+(const QRect &rectangle, const QMargins &margins)
static QRect op_QRect_operator_plus__3799u1(const QRect *_self, const QMargins &margins) {
return ::operator+(*_self, margins);
return operator+(*_self, margins);
}
// QRect ::operator-(const QRect &lhs, const QMargins &rhs)
static QRect op_QRect_operator_minus__3799(const QRect *_self, const QMargins &rhs) {
return ::operator-(*_self, rhs);
return operator-(*_self, rhs);
}
// bool ::operator==(const QRect &r1, const QRect &r2)
static bool op_QRect_operator_eq__eq__3476(const QRect *_self, const QRect &r2) {
return operator==(*_self, r2);
}
// bool ::operator!=(const QRect &r1, const QRect &r2)
static bool op_QRect_operator_excl__eq__3476(const QRect *_self, const QRect &r2) {
return operator!=(*_self, r2);
}
@ -1563,6 +1573,8 @@ static gsi::Methods methods_QRect () {
methods += new qt_gsi::GenericStaticMethod ("span", "@brief Static method QRect QRect::span(const QPoint &p1, const QPoint &p2)\nThis method is static and can be called without an instance.", &_init_f_span_3724, &_call_f_span_3724);
methods += gsi::method_ext("+", &::op_QRect_operator_plus__3799u1, gsi::arg ("margins"), "@brief Operator QRect ::operator+(const QRect &rectangle, const QMargins &margins)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QRect_operator_minus__3799, gsi::arg ("rhs"), "@brief Operator QRect ::operator-(const QRect &lhs, const QMargins &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("==", &::op_QRect_operator_eq__eq__3476, gsi::arg ("r2"), "@brief Operator bool ::operator==(const QRect &r1, const QRect &r2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QRect_operator_excl__eq__3476, gsi::arg ("r2"), "@brief Operator bool ::operator!=(const QRect &r1, const QRect &r2)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

16
src/gsiqt/qt6/QtCore/gsiDeclQRectF.cc
View File

@ -1471,12 +1471,22 @@ static void _call_f_y_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi
// QRectF ::operator+(const QRectF &lhs, const QMarginsF &rhs)
static QRectF op_QRectF_operator_plus__3939u1(const QRectF *_self, const QMarginsF &rhs) {
return ::operator+(*_self, rhs);
return operator+(*_self, rhs);
}
// QRectF ::operator-(const QRectF &lhs, const QMarginsF &rhs)
static QRectF op_QRectF_operator_minus__3939(const QRectF *_self, const QMarginsF &rhs) {
return ::operator-(*_self, rhs);
return operator-(*_self, rhs);
}
// bool ::operator==(const QRectF &r1, const QRectF &r2)
static bool op_QRectF_operator_eq__eq__3616(const QRectF *_self, const QRectF &r2) {
return operator==(*_self, r2);
}
// bool ::operator!=(const QRectF &r1, const QRectF &r2)
static bool op_QRectF_operator_excl__eq__3616(const QRectF *_self, const QRectF &r2) {
return operator!=(*_self, r2);
}
@ -1561,6 +1571,8 @@ static gsi::Methods methods_QRectF () {
methods += new qt_gsi::GenericMethod (":y", "@brief Method double QRectF::y()\n", true, &_init_f_y_c0, &_call_f_y_c0);
methods += gsi::method_ext("+", &::op_QRectF_operator_plus__3939u1, gsi::arg ("rhs"), "@brief Operator QRectF ::operator+(const QRectF &lhs, const QMarginsF &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QRectF_operator_minus__3939, gsi::arg ("rhs"), "@brief Operator QRectF ::operator-(const QRectF &lhs, const QMarginsF &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("==", &::op_QRectF_operator_eq__eq__3616, gsi::arg ("r2"), "@brief Operator bool ::operator==(const QRectF &r1, const QRectF &r2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QRectF_operator_excl__eq__3616, gsi::arg ("r2"), "@brief Operator bool ::operator!=(const QRectF &r1, const QRectF &r2)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

36
src/gsiqt/qt6/QtCore/gsiDeclQSize.cc
View File

@ -497,6 +497,36 @@ static void _call_f_width_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls,
}
// bool ::operator==(const QSize &s1, const QSize &s2)
static bool op_QSize_operator_eq__eq__3502(const QSize *_self, const QSize &s2) {
return operator==(*_self, s2);
}
// bool ::operator!=(const QSize &s1, const QSize &s2)
static bool op_QSize_operator_excl__eq__3502(const QSize *_self, const QSize &s2) {
return operator!=(*_self, s2);
}
// QSize ::operator+(const QSize &s1, const QSize &s2)
static QSize op_QSize_operator_plus__3502(const QSize *_self, const QSize &s2) {
return operator+(*_self, s2);
}
// QSize ::operator-(const QSize &s1, const QSize &s2)
static QSize op_QSize_operator_minus__3502(const QSize *_self, const QSize &s2) {
return operator-(*_self, s2);
}
// QSize ::operator*(const QSize &s, qreal c)
static QSize op_QSize_operator_star__2666(const QSize *_self, qreal c) {
return operator*(*_self, c);
}
// QSize ::operator/(const QSize &s, qreal c)
static QSize op_QSize_operator_slash__2666(const QSize *_self, qreal c) {
return operator/(*_self, c);
}
namespace gsi
{
@ -528,6 +558,12 @@ static gsi::Methods methods_QSize () {
methods += new qt_gsi::GenericMethod ("transpose", "@brief Method void QSize::transpose()\n", false, &_init_f_transpose_0, &_call_f_transpose_0);
methods += new qt_gsi::GenericMethod ("transposed", "@brief Method QSize QSize::transposed()\n", true, &_init_f_transposed_c0, &_call_f_transposed_c0);
methods += new qt_gsi::GenericMethod (":width", "@brief Method int QSize::width()\n", true, &_init_f_width_c0, &_call_f_width_c0);
methods += gsi::method_ext("==", &::op_QSize_operator_eq__eq__3502, gsi::arg ("s2"), "@brief Operator bool ::operator==(const QSize &s1, const QSize &s2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QSize_operator_excl__eq__3502, gsi::arg ("s2"), "@brief Operator bool ::operator!=(const QSize &s1, const QSize &s2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("+", &::op_QSize_operator_plus__3502, gsi::arg ("s2"), "@brief Operator QSize ::operator+(const QSize &s1, const QSize &s2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QSize_operator_minus__3502, gsi::arg ("s2"), "@brief Operator QSize ::operator-(const QSize &s1, const QSize &s2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QSize_operator_star__2666, gsi::arg ("c"), "@brief Operator QSize ::operator*(const QSize &s, qreal c)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QSize_operator_slash__2666, gsi::arg ("c"), "@brief Operator QSize ::operator/(const QSize &s, qreal c)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

36
src/gsiqt/qt6/QtCore/gsiDeclQSizeF.cc
View File

@ -532,6 +532,36 @@ static void _call_f_width_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls,
}
// bool ::operator==(const QSizeF &s1, const QSizeF &s2)
static bool op_QSizeF_operator_eq__eq__3642(const QSizeF *_self, const QSizeF &s2) {
return operator==(*_self, s2);
}
// bool ::operator!=(const QSizeF &s1, const QSizeF &s2)
static bool op_QSizeF_operator_excl__eq__3642(const QSizeF *_self, const QSizeF &s2) {
return operator!=(*_self, s2);
}
// QSizeF ::operator+(const QSizeF &s1, const QSizeF &s2)
static QSizeF op_QSizeF_operator_plus__3642(const QSizeF *_self, const QSizeF &s2) {
return operator+(*_self, s2);
}
// QSizeF ::operator-(const QSizeF &s1, const QSizeF &s2)
static QSizeF op_QSizeF_operator_minus__3642(const QSizeF *_self, const QSizeF &s2) {
return operator-(*_self, s2);
}
// QSizeF ::operator*(const QSizeF &s, qreal c)
static QSizeF op_QSizeF_operator_star__2736(const QSizeF *_self, qreal c) {
return operator*(*_self, c);
}
// QSizeF ::operator/(const QSizeF &s, qreal c)
static QSizeF op_QSizeF_operator_slash__2736(const QSizeF *_self, qreal c) {
return operator/(*_self, c);
}
namespace gsi
{
@ -565,6 +595,12 @@ static gsi::Methods methods_QSizeF () {
methods += new qt_gsi::GenericMethod ("transpose", "@brief Method void QSizeF::transpose()\n", false, &_init_f_transpose_0, &_call_f_transpose_0);
methods += new qt_gsi::GenericMethod ("transposed", "@brief Method QSizeF QSizeF::transposed()\n", true, &_init_f_transposed_c0, &_call_f_transposed_c0);
methods += new qt_gsi::GenericMethod (":width", "@brief Method double QSizeF::width()\n", true, &_init_f_width_c0, &_call_f_width_c0);
methods += gsi::method_ext("==", &::op_QSizeF_operator_eq__eq__3642, gsi::arg ("s2"), "@brief Operator bool ::operator==(const QSizeF &s1, const QSizeF &s2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QSizeF_operator_excl__eq__3642, gsi::arg ("s2"), "@brief Operator bool ::operator!=(const QSizeF &s1, const QSizeF &s2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("+", &::op_QSizeF_operator_plus__3642, gsi::arg ("s2"), "@brief Operator QSizeF ::operator+(const QSizeF &s1, const QSizeF &s2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QSizeF_operator_minus__3642, gsi::arg ("s2"), "@brief Operator QSizeF ::operator-(const QSizeF &s1, const QSizeF &s2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QSizeF_operator_star__2736, gsi::arg ("c"), "@brief Operator QSizeF ::operator*(const QSizeF &s, qreal c)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QSizeF_operator_slash__2736, gsi::arg ("c"), "@brief Operator QSizeF ::operator/(const QSizeF &s, qreal c)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtCore/gsiDeclQSocketDescriptor.cc
View File

@ -69,6 +69,16 @@ static void _call_f_isValid_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cl
}
// bool ::operator==(QSocketDescriptor lhs, QSocketDescriptor rhs)
static bool op_QSocketDescriptor_operator_eq__eq__4270(QSocketDescriptor *_self, QSocketDescriptor rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(QSocketDescriptor lhs, QSocketDescriptor rhs)
static bool op_QSocketDescriptor_operator_excl__eq__4270(QSocketDescriptor *_self, QSocketDescriptor rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -77,6 +87,8 @@ static gsi::Methods methods_QSocketDescriptor () {
gsi::Methods methods;
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QSocketDescriptor::QSocketDescriptor(QSocketDescriptor::DescriptorType descriptor)\nThis method creates an object of class QSocketDescriptor.", &_init_ctor_QSocketDescriptor_3778, &_call_ctor_QSocketDescriptor_3778);
methods += new qt_gsi::GenericMethod ("isValid?", "@brief Method bool QSocketDescriptor::isValid()\n", true, &_init_f_isValid_c0, &_call_f_isValid_c0);
methods += gsi::method_ext("==", &::op_QSocketDescriptor_operator_eq__eq__4270, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QSocketDescriptor lhs, QSocketDescriptor rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QSocketDescriptor_operator_excl__eq__4270, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QSocketDescriptor lhs, QSocketDescriptor rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtCore/gsiDeclQStorageInfo.cc
View File

@ -423,6 +423,16 @@ static void _call_f_root_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::S
}
// bool ::operator==(const QStorageInfo &first, const QStorageInfo &second)
static bool op_QStorageInfo_operator_eq__eq__4922(const QStorageInfo *_self, const QStorageInfo &second) {
return operator==(*_self, second);
}
// bool ::operator!=(const QStorageInfo &first, const QStorageInfo &second)
static bool op_QStorageInfo_operator_excl__eq__4922(const QStorageInfo *_self, const QStorageInfo &second) {
return operator!=(*_self, second);
}
namespace gsi
{
@ -453,6 +463,8 @@ static gsi::Methods methods_QStorageInfo () {
methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QStorageInfo::swap(QStorageInfo &other)\n", false, &_init_f_swap_1820, &_call_f_swap_1820);
methods += new qt_gsi::GenericStaticMethod ("mountedVolumes", "@brief Static method QList<QStorageInfo> QStorageInfo::mountedVolumes()\nThis method is static and can be called without an instance.", &_init_f_mountedVolumes_0, &_call_f_mountedVolumes_0);
methods += new qt_gsi::GenericStaticMethod ("root", "@brief Static method QStorageInfo QStorageInfo::root()\nThis method is static and can be called without an instance.", &_init_f_root_0, &_call_f_root_0);
methods += gsi::method_ext("==", &::op_QStorageInfo_operator_eq__eq__4922, gsi::arg ("second"), "@brief Operator bool ::operator==(const QStorageInfo &first, const QStorageInfo &second)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QStorageInfo_operator_excl__eq__4922, gsi::arg ("second"), "@brief Operator bool ::operator!=(const QStorageInfo &first, const QStorageInfo &second)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

36
src/gsiqt/qt6/QtCore/gsiDeclQTime.cc
View File

@ -431,6 +431,36 @@ static void _call_f_isValid_2744 (const qt_gsi::GenericStaticMethod * /*decl*/,
}
// bool ::operator==(QTime lhs, QTime rhs)
static bool op_QTime_operator_eq__eq__1724(QTime *_self, QTime rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(QTime lhs, QTime rhs)
static bool op_QTime_operator_excl__eq__1724(QTime *_self, QTime rhs) {
return operator!=(*_self, rhs);
}
// bool ::operator<(QTime lhs, QTime rhs)
static bool op_QTime_operator_lt__1724(QTime *_self, QTime rhs) {
return operator<(*_self, rhs);
}
// bool ::operator<=(QTime lhs, QTime rhs)
static bool op_QTime_operator_lt__eq__1724(QTime *_self, QTime rhs) {
return operator<=(*_self, rhs);
}
// bool ::operator>(QTime lhs, QTime rhs)
static bool op_QTime_operator_gt__1724(QTime *_self, QTime rhs) {
return operator>(*_self, rhs);
}
// bool ::operator>=(QTime lhs, QTime rhs)
static bool op_QTime_operator_gt__eq__1724(QTime *_self, QTime rhs) {
return operator>=(*_self, rhs);
}
namespace gsi
{
@ -458,6 +488,12 @@ static gsi::Methods methods_QTime () {
methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QTime QTime::fromString(const QString &string, Qt::DateFormat format)\nThis method is static and can be called without an instance.", &_init_f_fromString_3665, &_call_f_fromString_3665);
methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QTime QTime::fromString(const QString &string, const QString &format)\nThis method is static and can be called without an instance.", &_init_f_fromString_3942, &_call_f_fromString_3942);
methods += new qt_gsi::GenericStaticMethod ("isValid?", "@brief Static method bool QTime::isValid(int h, int m, int s, int ms)\nThis method is static and can be called without an instance.", &_init_f_isValid_2744, &_call_f_isValid_2744);
methods += gsi::method_ext("==", &::op_QTime_operator_eq__eq__1724, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QTime lhs, QTime rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QTime_operator_excl__eq__1724, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QTime lhs, QTime rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<", &::op_QTime_operator_lt__1724, gsi::arg ("rhs"), "@brief Operator bool ::operator<(QTime lhs, QTime rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<=", &::op_QTime_operator_lt__eq__1724, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(QTime lhs, QTime rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">", &::op_QTime_operator_gt__1724, gsi::arg ("rhs"), "@brief Operator bool ::operator>(QTime lhs, QTime rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">=", &::op_QTime_operator_gt__eq__1724, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(QTime lhs, QTime rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

36
src/gsiqt/qt6/QtCore/gsiDeclQTypeRevision.cc
View File

@ -140,6 +140,36 @@ static void _call_f_zero_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::S
}
// bool ::operator==(QTypeRevision lhs, QTypeRevision rhs)
static bool op_QTypeRevision_operator_eq__eq__3456(QTypeRevision *_self, QTypeRevision rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(QTypeRevision lhs, QTypeRevision rhs)
static bool op_QTypeRevision_operator_excl__eq__3456(QTypeRevision *_self, QTypeRevision rhs) {
return operator!=(*_self, rhs);
}
// bool ::operator<(QTypeRevision lhs, QTypeRevision rhs)
static bool op_QTypeRevision_operator_lt__3456(QTypeRevision *_self, QTypeRevision rhs) {
return operator<(*_self, rhs);
}
// bool ::operator>(QTypeRevision lhs, QTypeRevision rhs)
static bool op_QTypeRevision_operator_gt__3456(QTypeRevision *_self, QTypeRevision rhs) {
return operator>(*_self, rhs);
}
// bool ::operator<=(QTypeRevision lhs, QTypeRevision rhs)
static bool op_QTypeRevision_operator_lt__eq__3456(QTypeRevision *_self, QTypeRevision rhs) {
return operator<=(*_self, rhs);
}
// bool ::operator>=(QTypeRevision lhs, QTypeRevision rhs)
static bool op_QTypeRevision_operator_gt__eq__3456(QTypeRevision *_self, QTypeRevision rhs) {
return operator>=(*_self, rhs);
}
namespace gsi
{
@ -153,6 +183,12 @@ static gsi::Methods methods_QTypeRevision () {
methods += new qt_gsi::GenericMethod ("majorVersion", "@brief Method quint8 QTypeRevision::majorVersion()\n", true, &_init_f_majorVersion_c0, &_call_f_majorVersion_c0);
methods += new qt_gsi::GenericMethod ("minorVersion", "@brief Method quint8 QTypeRevision::minorVersion()\n", true, &_init_f_minorVersion_c0, &_call_f_minorVersion_c0);
methods += new qt_gsi::GenericStaticMethod ("zero", "@brief Static method QTypeRevision QTypeRevision::zero()\nThis method is static and can be called without an instance.", &_init_f_zero_0, &_call_f_zero_0);
methods += gsi::method_ext("==", &::op_QTypeRevision_operator_eq__eq__3456, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QTypeRevision lhs, QTypeRevision rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QTypeRevision_operator_excl__eq__3456, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QTypeRevision lhs, QTypeRevision rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<", &::op_QTypeRevision_operator_lt__3456, gsi::arg ("rhs"), "@brief Operator bool ::operator<(QTypeRevision lhs, QTypeRevision rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">", &::op_QTypeRevision_operator_gt__3456, gsi::arg ("rhs"), "@brief Operator bool ::operator>(QTypeRevision lhs, QTypeRevision rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<=", &::op_QTypeRevision_operator_lt__eq__3456, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(QTypeRevision lhs, QTypeRevision rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">=", &::op_QTypeRevision_operator_gt__eq__3456, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(QTypeRevision lhs, QTypeRevision rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

36
src/gsiqt/qt6/QtCore/gsiDeclQVersionNumber.cc
View File

@ -374,6 +374,36 @@ static void _call_f_fromString_2870 (const qt_gsi::GenericStaticMethod * /*decl*
}
// bool ::operator>(const QVersionNumber &lhs, const QVersionNumber &rhs)
static bool op_QVersionNumber_operator_gt__5398(const QVersionNumber *_self, const QVersionNumber &rhs) {
return operator>(*_self, rhs);
}
// bool ::operator>=(const QVersionNumber &lhs, const QVersionNumber &rhs)
static bool op_QVersionNumber_operator_gt__eq__5398(const QVersionNumber *_self, const QVersionNumber &rhs) {
return operator>=(*_self, rhs);
}
// bool ::operator<(const QVersionNumber &lhs, const QVersionNumber &rhs)
static bool op_QVersionNumber_operator_lt__5398(const QVersionNumber *_self, const QVersionNumber &rhs) {
return operator<(*_self, rhs);
}
// bool ::operator<=(const QVersionNumber &lhs, const QVersionNumber &rhs)
static bool op_QVersionNumber_operator_lt__eq__5398(const QVersionNumber *_self, const QVersionNumber &rhs) {
return operator<=(*_self, rhs);
}
// bool ::operator==(const QVersionNumber &lhs, const QVersionNumber &rhs)
static bool op_QVersionNumber_operator_eq__eq__5398(const QVersionNumber *_self, const QVersionNumber &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QVersionNumber &lhs, const QVersionNumber &rhs)
static bool op_QVersionNumber_operator_excl__eq__5398(const QVersionNumber *_self, const QVersionNumber &rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -399,6 +429,12 @@ static gsi::Methods methods_QVersionNumber () {
methods += new qt_gsi::GenericStaticMethod ("commonPrefix", "@brief Static method QVersionNumber QVersionNumber::commonPrefix(const QVersionNumber &v1, const QVersionNumber &v2)\nThis method is static and can be called without an instance.", &_init_f_commonPrefix_5398, &_call_f_commonPrefix_5398);
methods += new qt_gsi::GenericStaticMethod ("compare", "@brief Static method int QVersionNumber::compare(const QVersionNumber &v1, const QVersionNumber &v2)\nThis method is static and can be called without an instance.", &_init_f_compare_5398, &_call_f_compare_5398);
methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QVersionNumber QVersionNumber::fromString(const QString &string, int *suffixIndex)\nThis method is static and can be called without an instance.", &_init_f_fromString_2870, &_call_f_fromString_2870);
methods += gsi::method_ext(">", &::op_QVersionNumber_operator_gt__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator>(const QVersionNumber &lhs, const QVersionNumber &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext(">=", &::op_QVersionNumber_operator_gt__eq__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator>=(const QVersionNumber &lhs, const QVersionNumber &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<", &::op_QVersionNumber_operator_lt__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator<(const QVersionNumber &lhs, const QVersionNumber &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("<=", &::op_QVersionNumber_operator_lt__eq__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator<=(const QVersionNumber &lhs, const QVersionNumber &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("==", &::op_QVersionNumber_operator_eq__eq__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QVersionNumber &lhs, const QVersionNumber &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QVersionNumber_operator_excl__eq__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QVersionNumber &lhs, const QVersionNumber &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

6
src/gsiqt/qt6/QtGui/gsiDeclQAccessible_State.cc
View File

@ -50,6 +50,11 @@ static void _call_ctor_QAccessible_State_0 (const qt_gsi::GenericStaticMethod *
}
// bool ::operator==(const QAccessible::State &first, const QAccessible::State &second)
static bool op_QAccessible_State_operator_eq__eq__5950(const QAccessible::State *_self, const QAccessible::State &second) {
return operator==(*_self, second);
}
namespace gsi
{
@ -57,6 +62,7 @@ namespace gsi
static gsi::Methods methods_QAccessible_State () {
gsi::Methods methods;
methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QAccessible::State::State()\nThis method creates an object of class QAccessible::State.", &_init_ctor_QAccessible_State_0, &_call_ctor_QAccessible_State_0);
methods += gsi::method_ext("==", &::op_QAccessible_State_operator_eq__eq__5950, gsi::arg ("second"), "@brief Operator bool ::operator==(const QAccessible::State &first, const QAccessible::State &second)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtGui/gsiDeclQColorSpace.cc
View File

@ -648,6 +648,16 @@ static void _call_f_fromIccProfile_2309 (const qt_gsi::GenericStaticMethod * /*d
}
// bool ::operator==(const QColorSpace &colorSpace1, const QColorSpace &colorSpace2)
static bool op_QColorSpace_operator_eq__eq__4686(const QColorSpace *_self, const QColorSpace &colorSpace2) {
return operator==(*_self, colorSpace2);
}
// bool ::operator!=(const QColorSpace &colorSpace1, const QColorSpace &colorSpace2)
static bool op_QColorSpace_operator_excl__eq__4686(const QColorSpace *_self, const QColorSpace &colorSpace2) {
return operator!=(*_self, colorSpace2);
}
namespace gsi
{
@ -683,6 +693,8 @@ static gsi::Methods methods_QColorSpace () {
methods += new qt_gsi::GenericMethod ("withTransferFunction", "@brief Method QColorSpace QColorSpace::withTransferFunction(const QList<uint16_t> &transferFunctionTable)\n", true, &_init_f_withTransferFunction_c2690, &_call_f_withTransferFunction_c2690);
methods += new qt_gsi::GenericMethod ("withTransferFunctions", "@brief Method QColorSpace QColorSpace::withTransferFunctions(const QList<uint16_t> &redTransferFunctionTable, const QList<uint16_t> &greenTransferFunctionTable, const QList<uint16_t> &blueTransferFunctionTable)\n", true, &_init_f_withTransferFunctions_c7854, &_call_f_withTransferFunctions_c7854);
methods += new qt_gsi::GenericStaticMethod ("fromIccProfile", "@brief Static method QColorSpace QColorSpace::fromIccProfile(const QByteArray &iccProfile)\nThis method is static and can be called without an instance.", &_init_f_fromIccProfile_2309, &_call_f_fromIccProfile_2309);
methods += gsi::method_ext("==", &::op_QColorSpace_operator_eq__eq__4686, gsi::arg ("colorSpace2"), "@brief Operator bool ::operator==(const QColorSpace &colorSpace1, const QColorSpace &colorSpace2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QColorSpace_operator_excl__eq__4686, gsi::arg ("colorSpace2"), "@brief Operator bool ::operator!=(const QColorSpace &colorSpace1, const QColorSpace &colorSpace2)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

6
src/gsiqt/qt6/QtGui/gsiDeclQCursor.cc
View File

@ -441,6 +441,11 @@ static void _call_f_setPos_3119 (const qt_gsi::GenericStaticMethod * /*decl*/, g
}
// bool ::operator!=(const QCursor &lhs, const QCursor &rhs)
static bool op_QCursor_operator_excl__eq__3956(const QCursor *_self, const QCursor &rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -468,6 +473,7 @@ static gsi::Methods methods_QCursor () {
methods += new qt_gsi::GenericStaticMethod ("setPos", "@brief Static method void QCursor::setPos(QScreen *screen, int x, int y)\nThis method is static and can be called without an instance.", &_init_f_setPos_2629, &_call_f_setPos_2629);
methods += new qt_gsi::GenericStaticMethod ("setPos|pos=", "@brief Static method void QCursor::setPos(const QPoint &p)\nThis method is static and can be called without an instance.", &_init_f_setPos_1916, &_call_f_setPos_1916);
methods += new qt_gsi::GenericStaticMethod ("setPos", "@brief Static method void QCursor::setPos(QScreen *screen, const QPoint &p)\nThis method is static and can be called without an instance.", &_init_f_setPos_3119, &_call_f_setPos_3119);
methods += gsi::method_ext("!=", &::op_QCursor_operator_excl__eq__3956, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QCursor &lhs, const QCursor &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

20
src/gsiqt/qt6/QtGui/gsiDeclQMatrix4x4.cc
View File

@ -1321,52 +1321,52 @@ static void _call_f_viewport_5280 (const qt_gsi::GenericMethod * /*decl*/, void
// QMatrix4x4 ::operator/(const QMatrix4x4 &matrix, float divisor)
static QMatrix4x4 op_QMatrix4x4_operator_slash__3109(const QMatrix4x4 *_self, float divisor) {
return ::operator/(*_self, divisor);
return operator/(*_self, divisor);
}
// QMatrix4x4 ::operator+(const QMatrix4x4 &m1, const QMatrix4x4 &m2)
static QMatrix4x4 op_QMatrix4x4_operator_plus__4386(const QMatrix4x4 *_self, const QMatrix4x4 &m2) {
return ::operator+(*_self, m2);
return operator+(*_self, m2);
}
// QMatrix4x4 ::operator-(const QMatrix4x4 &m1, const QMatrix4x4 &m2)
static QMatrix4x4 op_QMatrix4x4_operator_minus__4386(const QMatrix4x4 *_self, const QMatrix4x4 &m2) {
return ::operator-(*_self, m2);
return operator-(*_self, m2);
}
// QMatrix4x4 ::operator*(const QMatrix4x4 &m1, const QMatrix4x4 &m2)
static QMatrix4x4 op_QMatrix4x4_operator_star__4386(const QMatrix4x4 *_self, const QMatrix4x4 &m2) {
return ::operator*(*_self, m2);
return operator*(*_self, m2);
}
// QVector3D ::operator*(const QMatrix4x4 &matrix, const QVector3D &vector)
static QVector3D op_QMatrix4x4_operator_star__4279(const QMatrix4x4 *_self, const QVector3D &vector) {
return ::operator*(*_self, vector);
return operator*(*_self, vector);
}
// QVector4D ::operator*(const QMatrix4x4 &matrix, const QVector4D &vector)
static QVector4D op_QMatrix4x4_operator_star__4280(const QMatrix4x4 *_self, const QVector4D &vector) {
return ::operator*(*_self, vector);
return operator*(*_self, vector);
}
// QPoint ::operator*(const QMatrix4x4 &matrix, const QPoint &point)
static QPoint op_QMatrix4x4_operator_star__4055(const QMatrix4x4 *_self, const QPoint &point) {
return ::operator*(*_self, point);
return operator*(*_self, point);
}
// QPointF ::operator*(const QMatrix4x4 &matrix, const QPointF &point)
static QPointF op_QMatrix4x4_operator_star__4125(const QMatrix4x4 *_self, const QPointF &point) {
return ::operator*(*_self, point);
return operator*(*_self, point);
}
// QMatrix4x4 ::operator-(const QMatrix4x4 &matrix)
static QMatrix4x4 op_QMatrix4x4_operator_minus__2247(const QMatrix4x4 *_self) {
return ::operator-(*_self);
return operator-(*_self);
}
// QMatrix4x4 ::operator*(const QMatrix4x4 &matrix, float factor)
static QMatrix4x4 op_QMatrix4x4_operator_star__3109(const QMatrix4x4 *_self, float factor) {
return ::operator*(*_self, factor);
return operator*(*_self, factor);
}

12
src/gsiqt/qt6/QtGui/gsiDeclQPageLayout.cc
View File

@ -670,6 +670,16 @@ static void _call_f_units_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls,
}
// bool ::operator==(const QPageLayout &lhs, const QPageLayout &rhs)
static bool op_QPageLayout_operator_eq__eq__4718(const QPageLayout *_self, const QPageLayout &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QPageLayout &lhs, const QPageLayout &rhs)
static bool op_QPageLayout_operator_excl__eq__4718(const QPageLayout *_self, const QPageLayout &rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -711,6 +721,8 @@ static gsi::Methods methods_QPageLayout () {
methods += new qt_gsi::GenericMethod ("setUnits|units=", "@brief Method void QPageLayout::setUnits(QPageLayout::Unit units)\n", false, &_init_f_setUnits_2068, &_call_f_setUnits_2068);
methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QPageLayout::swap(QPageLayout &other)\n", false, &_init_f_swap_1718, &_call_f_swap_1718);
methods += new qt_gsi::GenericMethod (":units", "@brief Method QPageLayout::Unit QPageLayout::units()\n", true, &_init_f_units_c0, &_call_f_units_c0);
methods += gsi::method_ext("==", &::op_QPageLayout_operator_eq__eq__4718, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QPageLayout &lhs, const QPageLayout &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QPageLayout_operator_excl__eq__4718, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QPageLayout &lhs, const QPageLayout &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtGui/gsiDeclQPageRanges.cc
View File

@ -296,6 +296,16 @@ static void _call_f_fromString_2025 (const qt_gsi::GenericStaticMethod * /*decl*
}
// bool ::operator==(const QPageRanges &lhs, const QPageRanges &rhs)
static bool op_QPageRanges_operator_eq__eq__4658(const QPageRanges *_self, const QPageRanges &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QPageRanges &lhs, const QPageRanges &rhs)
static bool op_QPageRanges_operator_excl__eq__4658(const QPageRanges *_self, const QPageRanges &rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -317,6 +327,8 @@ static gsi::Methods methods_QPageRanges () {
methods += new qt_gsi::GenericMethod ("toRangeList", "@brief Method QList<QPageRanges::Range> QPageRanges::toRangeList()\n", true, &_init_f_toRangeList_c0, &_call_f_toRangeList_c0);
methods += new qt_gsi::GenericMethod ("toString", "@brief Method QString QPageRanges::toString()\n", true, &_init_f_toString_c0, &_call_f_toString_c0);
methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QPageRanges QPageRanges::fromString(const QString &ranges)\nThis method is static and can be called without an instance.", &_init_f_fromString_2025, &_call_f_fromString_2025);
methods += gsi::method_ext("==", &::op_QPageRanges_operator_eq__eq__4658, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QPageRanges &lhs, const QPageRanges &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QPageRanges_operator_excl__eq__4658, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QPageRanges &lhs, const QPageRanges &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtGui/gsiDeclQPageSize.cc
View File

@ -638,6 +638,16 @@ static void _call_f_windowsId_2390 (const qt_gsi::GenericStaticMethod * /*decl*/
}
// bool ::operator==(const QPageSize &lhs, const QPageSize &rhs)
static bool op_QPageSize_operator_eq__eq__4264(const QPageSize *_self, const QPageSize &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QPageSize &lhs, const QPageSize &rhs)
static bool op_QPageSize_operator_excl__eq__4264(const QPageSize *_self, const QPageSize &rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -676,6 +686,8 @@ static gsi::Methods methods_QPageSize () {
methods += new qt_gsi::GenericStaticMethod ("sizePixels", "@brief Static method QSize QPageSize::sizePixels(QPageSize::PageSizeId pageSizeId, int resolution)\nThis method is static and can be called without an instance.", &_init_f_sizePixels_3049, &_call_f_sizePixels_3049);
methods += new qt_gsi::GenericStaticMethod ("sizePoints", "@brief Static method QSize QPageSize::sizePoints(QPageSize::PageSizeId pageSizeId)\nThis method is static and can be called without an instance.", &_init_f_sizePoints_2390, &_call_f_sizePoints_2390);
methods += new qt_gsi::GenericStaticMethod ("windowsId", "@brief Static method int QPageSize::windowsId(QPageSize::PageSizeId pageSizeId)\nThis method is static and can be called without an instance.", &_init_f_windowsId_2390, &_call_f_windowsId_2390);
methods += gsi::method_ext("==", &::op_QPageSize_operator_eq__eq__4264, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QPageSize &lhs, const QPageSize &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QPageSize_operator_excl__eq__4264, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QPageSize &lhs, const QPageSize &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

2
src/gsiqt/qt6/QtGui/gsiDeclQPainterPath.cc
View File

@ -1602,7 +1602,7 @@ static void _call_f_united_c2514 (const qt_gsi::GenericMethod * /*decl*/, void *
// QPainterPath ::operator *(const QPainterPath &p, const QTransform &m)
static QPainterPath op_QPainterPath_operator_star__4756(const QPainterPath *_self, const QTransform &m) {
return ::operator *(*_self, m);
return operator *(*_self, m);
}

12
src/gsiqt/qt6/QtGui/gsiDeclQPixelFormat.cc
View File

@ -435,6 +435,16 @@ static void _call_f_yuvLayout_c0 (const qt_gsi::GenericMethod * /*decl*/, void *
}
// bool ::operator==(QPixelFormat fmt1, QPixelFormat fmt2)
static bool op_QPixelFormat_operator_eq__eq__3188(QPixelFormat *_self, QPixelFormat fmt2) {
return operator==(*_self, fmt2);
}
// bool ::operator!=(QPixelFormat fmt1, QPixelFormat fmt2)
static bool op_QPixelFormat_operator_excl__eq__3188(QPixelFormat *_self, QPixelFormat fmt2) {
return operator!=(*_self, fmt2);
}
namespace gsi
{
@ -465,6 +475,8 @@ static gsi::Methods methods_QPixelFormat () {
methods += new qt_gsi::GenericMethod ("typeInterpretation", "@brief Method QPixelFormat::TypeInterpretation QPixelFormat::typeInterpretation()\n", true, &_init_f_typeInterpretation_c0, &_call_f_typeInterpretation_c0);
methods += new qt_gsi::GenericMethod ("yellowSize", "@brief Method unsigned char QPixelFormat::yellowSize()\n", true, &_init_f_yellowSize_c0, &_call_f_yellowSize_c0);
methods += new qt_gsi::GenericMethod ("yuvLayout", "@brief Method QPixelFormat::YUVLayout QPixelFormat::yuvLayout()\n", true, &_init_f_yuvLayout_c0, &_call_f_yuvLayout_c0);
methods += gsi::method_ext("==", &::op_QPixelFormat_operator_eq__eq__3188, gsi::arg ("fmt2"), "@brief Operator bool ::operator==(QPixelFormat fmt1, QPixelFormat fmt2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QPixelFormat_operator_excl__eq__3188, gsi::arg ("fmt2"), "@brief Operator bool ::operator!=(QPixelFormat fmt1, QPixelFormat fmt2)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtGui/gsiDeclQPointingDeviceUniqueId.cc
View File

@ -99,6 +99,16 @@ static void _call_f_fromNumericId_986 (const qt_gsi::GenericStaticMethod * /*dec
}
// bool ::operator==(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs)
static bool op_QPointingDeviceUniqueId_operator_eq__eq__5398(QPointingDeviceUniqueId *_self, QPointingDeviceUniqueId rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs)
static bool op_QPointingDeviceUniqueId_operator_excl__eq__5398(QPointingDeviceUniqueId *_self, QPointingDeviceUniqueId rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -109,6 +119,8 @@ static gsi::Methods methods_QPointingDeviceUniqueId () {
methods += new qt_gsi::GenericMethod ("isValid?", "@brief Method bool QPointingDeviceUniqueId::isValid()\n", true, &_init_f_isValid_c0, &_call_f_isValid_c0);
methods += new qt_gsi::GenericMethod ("numericId", "@brief Method qint64 QPointingDeviceUniqueId::numericId()\n", true, &_init_f_numericId_c0, &_call_f_numericId_c0);
methods += new qt_gsi::GenericStaticMethod ("fromNumericId", "@brief Static method QPointingDeviceUniqueId QPointingDeviceUniqueId::fromNumericId(qint64 id)\nThis method is static and can be called without an instance.", &_init_f_fromNumericId_986, &_call_f_fromNumericId_986);
methods += gsi::method_ext("==", &::op_QPointingDeviceUniqueId_operator_eq__eq__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QPointingDeviceUniqueId_operator_excl__eq__5398, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

2
src/gsiqt/qt6/QtGui/gsiDeclQPolygon.cc
View File

@ -597,7 +597,7 @@ static void _call_f_united_c2138 (const qt_gsi::GenericMethod * /*decl*/, void *
// QPolygon ::operator *(const QPolygon &a, const QTransform &m)
static QPolygon op_QPolygon_operator_star__4380(const QPolygon *_self, const QTransform &m) {
return ::operator *(*_self, m);
return operator *(*_self, m);
}

2
src/gsiqt/qt6/QtGui/gsiDeclQPolygonF.cc
View File

@ -466,7 +466,7 @@ static void _call_f_united_c2208 (const qt_gsi::GenericMethod * /*decl*/, void *
// QPolygonF ::operator *(const QPolygonF &a, const QTransform &m)
static QPolygonF op_QPolygonF_operator_star__4450(const QPolygonF *_self, const QTransform &m) {
return ::operator *(*_self, m);
return operator *(*_self, m);
}

26
src/gsiqt/qt6/QtGui/gsiDeclQQuaternion.cc
View File

@ -928,37 +928,47 @@ static void _call_f_slerp_5666 (const qt_gsi::GenericStaticMethod * /*decl*/, gs
// const QQuaternion ::operator*(const QQuaternion &q1, const QQuaternion &q2)
static const QQuaternion op_QQuaternion_operator_star__4804(const QQuaternion *_self, const QQuaternion &q2) {
return ::operator*(*_self, q2);
return operator*(*_self, q2);
}
// const QQuaternion ::operator+(const QQuaternion &q1, const QQuaternion &q2)
static const QQuaternion op_QQuaternion_operator_plus__4804(const QQuaternion *_self, const QQuaternion &q2) {
return ::operator+(*_self, q2);
return operator+(*_self, q2);
}
// const QQuaternion ::operator-(const QQuaternion &q1, const QQuaternion &q2)
static const QQuaternion op_QQuaternion_operator_minus__4804(const QQuaternion *_self, const QQuaternion &q2) {
return ::operator-(*_self, q2);
return operator-(*_self, q2);
}
// const QQuaternion ::operator*(const QQuaternion &quaternion, float factor)
static const QQuaternion op_QQuaternion_operator_star__3318(const QQuaternion *_self, float factor) {
return ::operator*(*_self, factor);
return operator*(*_self, factor);
}
// const QQuaternion ::operator-(const QQuaternion &quaternion)
static const QQuaternion op_QQuaternion_operator_minus__2456(const QQuaternion *_self) {
return ::operator-(*_self);
return operator-(*_self);
}
// const QQuaternion ::operator/(const QQuaternion &quaternion, float divisor)
static const QQuaternion op_QQuaternion_operator_slash__3318(const QQuaternion *_self, float divisor) {
return ::operator/(*_self, divisor);
return operator/(*_self, divisor);
}
// QVector3D ::operator*(const QQuaternion &quaternion, const QVector3D &vec)
static QVector3D op_QQuaternion_operator_star__4488(const QQuaternion *_self, const QVector3D &vec) {
return ::operator*(*_self, vec);
return operator*(*_self, vec);
}
// bool ::operator==(const QQuaternion &q1, const QQuaternion &q2)
static bool op_QQuaternion_operator_eq__eq__4804(const QQuaternion *_self, const QQuaternion &q2) {
return operator==(*_self, q2);
}
// bool ::operator!=(const QQuaternion &q1, const QQuaternion &q2)
static bool op_QQuaternion_operator_excl__eq__4804(const QQuaternion *_self, const QQuaternion &q2) {
return operator!=(*_self, q2);
}
@ -1019,6 +1029,8 @@ static gsi::Methods methods_QQuaternion () {
methods += gsi::method_ext("-", &::op_QQuaternion_operator_minus__2456, "@brief Operator const QQuaternion ::operator-(const QQuaternion &quaternion)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QQuaternion_operator_slash__3318, gsi::arg ("divisor"), "@brief Operator const QQuaternion ::operator/(const QQuaternion &quaternion, float divisor)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QQuaternion_operator_star__4488, gsi::arg ("vec"), "@brief Operator QVector3D ::operator*(const QQuaternion &quaternion, const QVector3D &vec)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("==", &::op_QQuaternion_operator_eq__eq__4804, gsi::arg ("q2"), "@brief Operator bool ::operator==(const QQuaternion &q1, const QQuaternion &q2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QQuaternion_operator_excl__eq__4804, gsi::arg ("q2"), "@brief Operator bool ::operator!=(const QQuaternion &q1, const QQuaternion &q2)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

2
src/gsiqt/qt6/QtGui/gsiDeclQRegion.cc
View File

@ -912,7 +912,7 @@ static void _call_f_xored_c2006 (const qt_gsi::GenericMethod * /*decl*/, void *c
// QRegion ::operator *(const QRegion &r, const QTransform &m)
static QRegion op_QRegion_operator_star__4248(const QRegion *_self, const QTransform &m) {
return ::operator *(*_self, m);
return operator *(*_self, m);
}

12
src/gsiqt/qt6/QtGui/gsiDeclQSurfaceFormat.cc
View File

@ -818,6 +818,16 @@ static void _call_f_setDefaultFormat_2724 (const qt_gsi::GenericStaticMethod * /
}
// bool ::operator==(const QSurfaceFormat &lhs, const QSurfaceFormat &rhs)
static bool op_QSurfaceFormat_operator_eq__eq__5340(const QSurfaceFormat *_self, const QSurfaceFormat &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QSurfaceFormat &lhs, const QSurfaceFormat &rhs)
static bool op_QSurfaceFormat_operator_excl__eq__5340(const QSurfaceFormat *_self, const QSurfaceFormat &rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -868,6 +878,8 @@ static gsi::Methods methods_QSurfaceFormat () {
methods += new qt_gsi::GenericMethod ("version", "@brief Method QPair<int, int> QSurfaceFormat::version()\n", true, &_init_f_version_c0, &_call_f_version_c0);
methods += new qt_gsi::GenericStaticMethod (":defaultFormat", "@brief Static method QSurfaceFormat QSurfaceFormat::defaultFormat()\nThis method is static and can be called without an instance.", &_init_f_defaultFormat_0, &_call_f_defaultFormat_0);
methods += new qt_gsi::GenericStaticMethod ("setDefaultFormat|defaultFormat=", "@brief Static method void QSurfaceFormat::setDefaultFormat(const QSurfaceFormat &format)\nThis method is static and can be called without an instance.", &_init_f_setDefaultFormat_2724, &_call_f_setDefaultFormat_2724);
methods += gsi::method_ext("==", &::op_QSurfaceFormat_operator_eq__eq__5340, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QSurfaceFormat &lhs, const QSurfaceFormat &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QSurfaceFormat_operator_excl__eq__5340, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QSurfaceFormat &lhs, const QSurfaceFormat &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

8
src/gsiqt/qt6/QtGui/gsiDeclQTransform.cc
View File

@ -1213,22 +1213,22 @@ static void _call_f_squareToQuad_3755 (const qt_gsi::GenericStaticMethod * /*dec
// QTransform ::operator *(const QTransform &a, qreal n)
static QTransform op_QTransform_operator_star__3211(const QTransform *_self, qreal n) {
return ::operator *(*_self, n);
return operator *(*_self, n);
}
// QTransform ::operator /(const QTransform &a, qreal n)
static QTransform op_QTransform_operator_slash__3211(const QTransform *_self, qreal n) {
return ::operator /(*_self, n);
return operator /(*_self, n);
}
// QTransform ::operator +(const QTransform &a, qreal n)
static QTransform op_QTransform_operator_plus__3211(const QTransform *_self, qreal n) {
return ::operator +(*_self, n);
return operator +(*_self, n);
}
// QTransform ::operator -(const QTransform &a, qreal n)
static QTransform op_QTransform_operator_minus__3211(const QTransform *_self, qreal n) {
return ::operator -(*_self, n);
return operator -(*_self, n);
}

54
src/gsiqt/qt6/QtGui/gsiDeclQVector2D.cc
View File

@ -573,6 +573,51 @@ static void _call_f_dotProduct_2416 (const qt_gsi::GenericStaticMethod * /*decl*
}
// bool ::operator==(QVector2D v1, QVector2D v2)
static bool op_QVector2D_operator_eq__eq__2416(QVector2D *_self, QVector2D v2) {
return operator==(*_self, v2);
}
// bool ::operator!=(QVector2D v1, QVector2D v2)
static bool op_QVector2D_operator_excl__eq__2416(QVector2D *_self, QVector2D v2) {
return operator!=(*_self, v2);
}
// QVector2D ::operator+(QVector2D v1, QVector2D v2)
static QVector2D op_QVector2D_operator_plus__2416(QVector2D *_self, QVector2D v2) {
return operator+(*_self, v2);
}
// QVector2D ::operator-(QVector2D v1, QVector2D v2)
static QVector2D op_QVector2D_operator_minus__2416(QVector2D *_self, QVector2D v2) {
return operator-(*_self, v2);
}
// QVector2D ::operator*(QVector2D vector, float factor)
static QVector2D op_QVector2D_operator_star__2124(QVector2D *_self, float factor) {
return operator*(*_self, factor);
}
// QVector2D ::operator*(QVector2D v1, QVector2D v2)
static QVector2D op_QVector2D_operator_star__2416(QVector2D *_self, QVector2D v2) {
return operator*(*_self, v2);
}
// QVector2D ::operator-(QVector2D vector)
static QVector2D op_QVector2D_operator_minus__1262(QVector2D *_self) {
return operator-(*_self);
}
// QVector2D ::operator/(QVector2D vector, float divisor)
static QVector2D op_QVector2D_operator_slash__2124(QVector2D *_self, float divisor) {
return operator/(*_self, divisor);
}
// QVector2D ::operator/(QVector2D vector, QVector2D divisor)
static QVector2D op_QVector2D_operator_slash__2416(QVector2D *_self, QVector2D divisor) {
return operator/(*_self, divisor);
}
namespace gsi
{
@ -609,6 +654,15 @@ static gsi::Methods methods_QVector2D () {
methods += new qt_gsi::GenericMethod (":x", "@brief Method float QVector2D::x()\n", true, &_init_f_x_c0, &_call_f_x_c0);
methods += new qt_gsi::GenericMethod (":y", "@brief Method float QVector2D::y()\n", true, &_init_f_y_c0, &_call_f_y_c0);
methods += new qt_gsi::GenericStaticMethod ("dotProduct", "@brief Static method float QVector2D::dotProduct(QVector2D v1, QVector2D v2)\nThis method is static and can be called without an instance.", &_init_f_dotProduct_2416, &_call_f_dotProduct_2416);
methods += gsi::method_ext("==", &::op_QVector2D_operator_eq__eq__2416, gsi::arg ("v2"), "@brief Operator bool ::operator==(QVector2D v1, QVector2D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QVector2D_operator_excl__eq__2416, gsi::arg ("v2"), "@brief Operator bool ::operator!=(QVector2D v1, QVector2D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("+", &::op_QVector2D_operator_plus__2416, gsi::arg ("v2"), "@brief Operator QVector2D ::operator+(QVector2D v1, QVector2D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QVector2D_operator_minus__2416, gsi::arg ("v2"), "@brief Operator QVector2D ::operator-(QVector2D v1, QVector2D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QVector2D_operator_star__2124, gsi::arg ("factor"), "@brief Operator QVector2D ::operator*(QVector2D vector, float factor)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QVector2D_operator_star__2416, gsi::arg ("v2"), "@brief Operator QVector2D ::operator*(QVector2D v1, QVector2D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QVector2D_operator_minus__1262, "@brief Operator QVector2D ::operator-(QVector2D vector)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QVector2D_operator_slash__2124, gsi::arg ("divisor"), "@brief Operator QVector2D ::operator/(QVector2D vector, float divisor)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QVector2D_operator_slash__2416, gsi::arg ("divisor"), "@brief Operator QVector2D ::operator/(QVector2D vector, QVector2D divisor)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

56
src/gsiqt/qt6/QtGui/gsiDeclQVector3D.cc
View File

@ -799,7 +799,52 @@ static void _call_f_normal_3573 (const qt_gsi::GenericStaticMethod * /*decl*/, g
// QVector3D ::operator*(const QVector3D &vector, const QMatrix4x4 &matrix)
static QVector3D op_QVector3D_operator_star__4279u1(const QVector3D *_self, const QMatrix4x4 &matrix) {
return ::operator*(*_self, matrix);
return operator*(*_self, matrix);
}
// bool ::operator==(QVector3D v1, QVector3D v2)
static bool op_QVector3D_operator_eq__eq__2418(QVector3D *_self, QVector3D v2) {
return operator==(*_self, v2);
}
// bool ::operator!=(QVector3D v1, QVector3D v2)
static bool op_QVector3D_operator_excl__eq__2418(QVector3D *_self, QVector3D v2) {
return operator!=(*_self, v2);
}
// QVector3D ::operator+(QVector3D v1, QVector3D v2)
static QVector3D op_QVector3D_operator_plus__2418(QVector3D *_self, QVector3D v2) {
return operator+(*_self, v2);
}
// QVector3D ::operator-(QVector3D v1, QVector3D v2)
static QVector3D op_QVector3D_operator_minus__2418(QVector3D *_self, QVector3D v2) {
return operator-(*_self, v2);
}
// QVector3D ::operator*(QVector3D vector, float factor)
static QVector3D op_QVector3D_operator_star__2125(QVector3D *_self, float factor) {
return operator*(*_self, factor);
}
// QVector3D ::operator*(QVector3D v1, QVector3D v2)
static QVector3D op_QVector3D_operator_star__2418(QVector3D *_self, QVector3D v2) {
return operator*(*_self, v2);
}
// QVector3D ::operator-(QVector3D vector)
static QVector3D op_QVector3D_operator_minus__1263(QVector3D *_self) {
return operator-(*_self);
}
// QVector3D ::operator/(QVector3D vector, float divisor)
static QVector3D op_QVector3D_operator_slash__2125(QVector3D *_self, float divisor) {
return operator/(*_self, divisor);
}
// QVector3D ::operator/(QVector3D vector, QVector3D divisor)
static QVector3D op_QVector3D_operator_slash__2418(QVector3D *_self, QVector3D divisor) {
return operator/(*_self, divisor);
}
@ -849,6 +894,15 @@ static gsi::Methods methods_QVector3D () {
methods += new qt_gsi::GenericStaticMethod ("normal", "@brief Static method QVector3D QVector3D::normal(QVector3D v1, QVector3D v2)\nThis method is static and can be called without an instance.", &_init_f_normal_2418, &_call_f_normal_2418);
methods += new qt_gsi::GenericStaticMethod ("normal", "@brief Static method QVector3D QVector3D::normal(QVector3D v1, QVector3D v2, QVector3D v3)\nThis method is static and can be called without an instance.", &_init_f_normal_3573, &_call_f_normal_3573);
methods += gsi::method_ext("*", &::op_QVector3D_operator_star__4279u1, gsi::arg ("matrix"), "@brief Operator QVector3D ::operator*(const QVector3D &vector, const QMatrix4x4 &matrix)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("==", &::op_QVector3D_operator_eq__eq__2418, gsi::arg ("v2"), "@brief Operator bool ::operator==(QVector3D v1, QVector3D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QVector3D_operator_excl__eq__2418, gsi::arg ("v2"), "@brief Operator bool ::operator!=(QVector3D v1, QVector3D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("+", &::op_QVector3D_operator_plus__2418, gsi::arg ("v2"), "@brief Operator QVector3D ::operator+(QVector3D v1, QVector3D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QVector3D_operator_minus__2418, gsi::arg ("v2"), "@brief Operator QVector3D ::operator-(QVector3D v1, QVector3D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QVector3D_operator_star__2125, gsi::arg ("factor"), "@brief Operator QVector3D ::operator*(QVector3D vector, float factor)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QVector3D_operator_star__2418, gsi::arg ("v2"), "@brief Operator QVector3D ::operator*(QVector3D v1, QVector3D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QVector3D_operator_minus__1263, "@brief Operator QVector3D ::operator-(QVector3D vector)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QVector3D_operator_slash__2125, gsi::arg ("divisor"), "@brief Operator QVector3D ::operator/(QVector3D vector, float divisor)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QVector3D_operator_slash__2418, gsi::arg ("divisor"), "@brief Operator QVector3D ::operator/(QVector3D vector, QVector3D divisor)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

56
src/gsiqt/qt6/QtGui/gsiDeclQVector4D.cc
View File

@ -685,7 +685,52 @@ static void _call_f_dotProduct_2420 (const qt_gsi::GenericStaticMethod * /*decl*
// QVector4D ::operator*(const QVector4D &vector, const QMatrix4x4 &matrix)
static QVector4D op_QVector4D_operator_star__4280u1(const QVector4D *_self, const QMatrix4x4 &matrix) {
return ::operator*(*_self, matrix);
return operator*(*_self, matrix);
}
// bool ::operator==(QVector4D v1, QVector4D v2)
static bool op_QVector4D_operator_eq__eq__2420(QVector4D *_self, QVector4D v2) {
return operator==(*_self, v2);
}
// bool ::operator!=(QVector4D v1, QVector4D v2)
static bool op_QVector4D_operator_excl__eq__2420(QVector4D *_self, QVector4D v2) {
return operator!=(*_self, v2);
}
// QVector4D ::operator+(QVector4D v1, QVector4D v2)
static QVector4D op_QVector4D_operator_plus__2420(QVector4D *_self, QVector4D v2) {
return operator+(*_self, v2);
}
// QVector4D ::operator-(QVector4D v1, QVector4D v2)
static QVector4D op_QVector4D_operator_minus__2420(QVector4D *_self, QVector4D v2) {
return operator-(*_self, v2);
}
// QVector4D ::operator*(QVector4D vector, float factor)
static QVector4D op_QVector4D_operator_star__2126(QVector4D *_self, float factor) {
return operator*(*_self, factor);
}
// QVector4D ::operator*(QVector4D v1, QVector4D v2)
static QVector4D op_QVector4D_operator_star__2420(QVector4D *_self, QVector4D v2) {
return operator*(*_self, v2);
}
// QVector4D ::operator-(QVector4D vector)
static QVector4D op_QVector4D_operator_minus__1264(QVector4D *_self) {
return operator-(*_self);
}
// QVector4D ::operator/(QVector4D vector, float divisor)
static QVector4D op_QVector4D_operator_slash__2126(QVector4D *_self, float divisor) {
return operator/(*_self, divisor);
}
// QVector4D ::operator/(QVector4D vector, QVector4D divisor)
static QVector4D op_QVector4D_operator_slash__2420(QVector4D *_self, QVector4D divisor) {
return operator/(*_self, divisor);
}
@ -731,6 +776,15 @@ static gsi::Methods methods_QVector4D () {
methods += new qt_gsi::GenericMethod (":z", "@brief Method float QVector4D::z()\n", true, &_init_f_z_c0, &_call_f_z_c0);
methods += new qt_gsi::GenericStaticMethod ("dotProduct", "@brief Static method float QVector4D::dotProduct(QVector4D v1, QVector4D v2)\nThis method is static and can be called without an instance.", &_init_f_dotProduct_2420, &_call_f_dotProduct_2420);
methods += gsi::method_ext("*", &::op_QVector4D_operator_star__4280u1, gsi::arg ("matrix"), "@brief Operator QVector4D ::operator*(const QVector4D &vector, const QMatrix4x4 &matrix)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("==", &::op_QVector4D_operator_eq__eq__2420, gsi::arg ("v2"), "@brief Operator bool ::operator==(QVector4D v1, QVector4D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QVector4D_operator_excl__eq__2420, gsi::arg ("v2"), "@brief Operator bool ::operator!=(QVector4D v1, QVector4D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("+", &::op_QVector4D_operator_plus__2420, gsi::arg ("v2"), "@brief Operator QVector4D ::operator+(QVector4D v1, QVector4D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QVector4D_operator_minus__2420, gsi::arg ("v2"), "@brief Operator QVector4D ::operator-(QVector4D v1, QVector4D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QVector4D_operator_star__2126, gsi::arg ("factor"), "@brief Operator QVector4D ::operator*(QVector4D vector, float factor)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("*", &::op_QVector4D_operator_star__2420, gsi::arg ("v2"), "@brief Operator QVector4D ::operator*(QVector4D v1, QVector4D v2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QVector4D_operator_minus__1264, "@brief Operator QVector4D ::operator-(QVector4D vector)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QVector4D_operator_slash__2126, gsi::arg ("divisor"), "@brief Operator QVector4D ::operator/(QVector4D vector, float divisor)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("/", &::op_QVector4D_operator_slash__2420, gsi::arg ("divisor"), "@brief Operator QVector4D ::operator/(QVector4D vector, QVector4D divisor)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtMultimedia/gsiDeclQAudioFormat.cc
View File

@ -387,6 +387,16 @@ static void _call_f_setSampleRate_767 (const qt_gsi::GenericMethod * /*decl*/, v
}
// bool ::operator==(const QAudioFormat &a, const QAudioFormat &b)
static bool op_QAudioFormat_operator_eq__eq__4910(const QAudioFormat *_self, const QAudioFormat &b) {
return operator==(*_self, b);
}
// bool ::operator!=(const QAudioFormat &a, const QAudioFormat &b)
static bool op_QAudioFormat_operator_excl__eq__4910(const QAudioFormat *_self, const QAudioFormat &b) {
return operator!=(*_self, b);
}
namespace gsi
{
@ -413,6 +423,8 @@ static gsi::Methods methods_QAudioFormat () {
methods += new qt_gsi::GenericMethod ("setChannelCount|channelCount=", "@brief Method void QAudioFormat::setChannelCount(int channelCount)\n", false, &_init_f_setChannelCount_767, &_call_f_setChannelCount_767);
methods += new qt_gsi::GenericMethod ("setSampleFormat|sampleFormat=", "@brief Method void QAudioFormat::setSampleFormat(QAudioFormat::SampleFormat f)\n", false, &_init_f_setSampleFormat_2975, &_call_f_setSampleFormat_2975);
methods += new qt_gsi::GenericMethod ("setSampleRate|sampleRate=", "@brief Method void QAudioFormat::setSampleRate(int sampleRate)\n", false, &_init_f_setSampleRate_767, &_call_f_setSampleRate_767);
methods += gsi::method_ext("==", &::op_QAudioFormat_operator_eq__eq__4910, gsi::arg ("b"), "@brief Operator bool ::operator==(const QAudioFormat &a, const QAudioFormat &b)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QAudioFormat_operator_excl__eq__4910, gsi::arg ("b"), "@brief Operator bool ::operator!=(const QAudioFormat &a, const QAudioFormat &b)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtMultimedia/gsiDeclQMediaMetaData.cc
View File

@ -215,6 +215,16 @@ static void _call_f_metaDataKeyToString_2179 (const qt_gsi::GenericStaticMethod
}
// bool ::operator==(const QMediaMetaData &a, const QMediaMetaData &b)
static bool op_QMediaMetaData_operator_eq__eq__5178(const QMediaMetaData *_self, const QMediaMetaData &b) {
return operator==(*_self, b);
}
// bool ::operator!=(const QMediaMetaData &a, const QMediaMetaData &b)
static bool op_QMediaMetaData_operator_excl__eq__5178(const QMediaMetaData *_self, const QMediaMetaData &b) {
return operator!=(*_self, b);
}
namespace gsi
{
@ -231,6 +241,8 @@ static gsi::Methods methods_QMediaMetaData () {
methods += new qt_gsi::GenericMethod ("stringValue", "@brief Method QString QMediaMetaData::stringValue(QMediaMetaData::Key k)\n", true, &_init_f_stringValue_c2179, &_call_f_stringValue_c2179);
methods += new qt_gsi::GenericMethod ("value", "@brief Method QVariant QMediaMetaData::value(QMediaMetaData::Key k)\n", true, &_init_f_value_c2179, &_call_f_value_c2179);
methods += new qt_gsi::GenericStaticMethod ("metaDataKeyToString", "@brief Static method QString QMediaMetaData::metaDataKeyToString(QMediaMetaData::Key k)\nThis method is static and can be called without an instance.", &_init_f_metaDataKeyToString_2179, &_call_f_metaDataKeyToString_2179);
methods += gsi::method_ext("==", &::op_QMediaMetaData_operator_eq__eq__5178, gsi::arg ("b"), "@brief Operator bool ::operator==(const QMediaMetaData &a, const QMediaMetaData &b)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QMediaMetaData_operator_excl__eq__5178, gsi::arg ("b"), "@brief Operator bool ::operator!=(const QMediaMetaData &a, const QMediaMetaData &b)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

16
src/gsiqt/qt6/QtMultimedia/gsiDeclQMediaTimeRange.cc
View File

@ -498,12 +498,22 @@ static void _call_f_swap_2071 (const qt_gsi::GenericMethod * /*decl*/, void *cls
// QMediaTimeRange ::operator+(const QMediaTimeRange &r1, const QMediaTimeRange &r2)
static QMediaTimeRange op_QMediaTimeRange_operator_plus__5424(const QMediaTimeRange *_self, const QMediaTimeRange &r2) {
return ::operator+(*_self, r2);
return operator+(*_self, r2);
}
// QMediaTimeRange ::operator-(const QMediaTimeRange &r1, const QMediaTimeRange &r2)
static QMediaTimeRange op_QMediaTimeRange_operator_minus__5424(const QMediaTimeRange *_self, const QMediaTimeRange &r2) {
return ::operator-(*_self, r2);
return operator-(*_self, r2);
}
// bool ::operator==(const QMediaTimeRange &lhs, const QMediaTimeRange &rhs)
static bool op_QMediaTimeRange_operator_eq__eq__5424(const QMediaTimeRange *_self, const QMediaTimeRange &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QMediaTimeRange &lhs, const QMediaTimeRange &rhs)
static bool op_QMediaTimeRange_operator_excl__eq__5424(const QMediaTimeRange *_self, const QMediaTimeRange &rhs) {
return operator!=(*_self, rhs);
}
@ -539,6 +549,8 @@ static gsi::Methods methods_QMediaTimeRange () {
methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QMediaTimeRange::swap(QMediaTimeRange &other)\n", false, &_init_f_swap_2071, &_call_f_swap_2071);
methods += gsi::method_ext("+", &::op_QMediaTimeRange_operator_plus__5424, gsi::arg ("r2"), "@brief Operator QMediaTimeRange ::operator+(const QMediaTimeRange &r1, const QMediaTimeRange &r2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("-", &::op_QMediaTimeRange_operator_minus__5424, gsi::arg ("r2"), "@brief Operator QMediaTimeRange ::operator-(const QMediaTimeRange &r1, const QMediaTimeRange &r2)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("==", &::op_QMediaTimeRange_operator_eq__eq__5424, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QMediaTimeRange &lhs, const QMediaTimeRange &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QMediaTimeRange_operator_excl__eq__5424, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QMediaTimeRange &lhs, const QMediaTimeRange &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtNetwork/gsiDeclQHstsPolicy.cc
View File

@ -264,6 +264,16 @@ static void _call_f_swap_1741 (const qt_gsi::GenericMethod * /*decl*/, void *cls
}
// bool ::operator==(const QHstsPolicy &lhs, const QHstsPolicy &rhs)
static bool op_QHstsPolicy_operator_eq__eq__4764(const QHstsPolicy *_self, const QHstsPolicy &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QHstsPolicy &lhs, const QHstsPolicy &rhs)
static bool op_QHstsPolicy_operator_excl__eq__4764(const QHstsPolicy *_self, const QHstsPolicy &rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -282,6 +292,8 @@ static gsi::Methods methods_QHstsPolicy () {
methods += new qt_gsi::GenericMethod ("setHost", "@brief Method void QHstsPolicy::setHost(const QString &host, QUrl::ParsingMode mode)\n", false, &_init_f_setHost_3970, &_call_f_setHost_3970);
methods += new qt_gsi::GenericMethod ("setIncludesSubDomains|includesSubDomains=", "@brief Method void QHstsPolicy::setIncludesSubDomains(bool include)\n", false, &_init_f_setIncludesSubDomains_864, &_call_f_setIncludesSubDomains_864);
methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QHstsPolicy::swap(QHstsPolicy &other)\n", false, &_init_f_swap_1741, &_call_f_swap_1741);
methods += gsi::method_ext("==", &::op_QHstsPolicy_operator_eq__eq__4764, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QHstsPolicy &lhs, const QHstsPolicy &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QHstsPolicy_operator_excl__eq__4764, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QHstsPolicy &lhs, const QHstsPolicy &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtNetwork/gsiDeclQHttp2Configuration.cc
View File

@ -280,6 +280,16 @@ static void _call_f_swap_2533 (const qt_gsi::GenericMethod * /*decl*/, void *cls
}
// bool ::operator==(const QHttp2Configuration &lhs, const QHttp2Configuration &rhs)
static bool op_QHttp2Configuration_operator_eq__eq__6348(const QHttp2Configuration *_self, const QHttp2Configuration &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QHttp2Configuration &lhs, const QHttp2Configuration &rhs)
static bool op_QHttp2Configuration_operator_excl__eq__6348(const QHttp2Configuration *_self, const QHttp2Configuration &rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -300,6 +310,8 @@ static gsi::Methods methods_QHttp2Configuration () {
methods += new qt_gsi::GenericMethod ("setStreamReceiveWindowSize", "@brief Method bool QHttp2Configuration::setStreamReceiveWindowSize(unsigned int size)\n", false, &_init_f_setStreamReceiveWindowSize_1772, &_call_f_setStreamReceiveWindowSize_1772);
methods += new qt_gsi::GenericMethod ("streamReceiveWindowSize", "@brief Method unsigned int QHttp2Configuration::streamReceiveWindowSize()\n", true, &_init_f_streamReceiveWindowSize_c0, &_call_f_streamReceiveWindowSize_c0);
methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QHttp2Configuration::swap(QHttp2Configuration &other)\n", false, &_init_f_swap_2533, &_call_f_swap_2533);
methods += gsi::method_ext("==", &::op_QHttp2Configuration_operator_eq__eq__6348, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QHttp2Configuration &lhs, const QHttp2Configuration &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QHttp2Configuration_operator_excl__eq__6348, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QHttp2Configuration &lhs, const QHttp2Configuration &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtNetwork/gsiDeclQSslDiffieHellmanParameters.cc
View File

@ -228,6 +228,16 @@ static void _call_f_fromEncoded_3702 (const qt_gsi::GenericStaticMethod * /*decl
}
// bool ::operator==(const QSslDiffieHellmanParameters &lhs, const QSslDiffieHellmanParameters &rhs)
static bool op_QSslDiffieHellmanParameters_operator_eq__eq__7956(const QSslDiffieHellmanParameters *_self, const QSslDiffieHellmanParameters &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QSslDiffieHellmanParameters &lhs, const QSslDiffieHellmanParameters &rhs)
static bool op_QSslDiffieHellmanParameters_operator_excl__eq__7956(const QSslDiffieHellmanParameters *_self, const QSslDiffieHellmanParameters &rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -245,6 +255,8 @@ static gsi::Methods methods_QSslDiffieHellmanParameters () {
methods += new qt_gsi::GenericStaticMethod ("defaultParameters", "@brief Static method QSslDiffieHellmanParameters QSslDiffieHellmanParameters::defaultParameters()\nThis method is static and can be called without an instance.", &_init_f_defaultParameters_0, &_call_f_defaultParameters_0);
methods += new qt_gsi::GenericStaticMethod ("fromEncoded", "@brief Static method QSslDiffieHellmanParameters QSslDiffieHellmanParameters::fromEncoded(const QByteArray &encoded, QSsl::EncodingFormat format)\nThis method is static and can be called without an instance.", &_init_f_fromEncoded_4564, &_call_f_fromEncoded_4564);
methods += new qt_gsi::GenericStaticMethod ("fromEncoded", "@brief Static method QSslDiffieHellmanParameters QSslDiffieHellmanParameters::fromEncoded(QIODevice *device, QSsl::EncodingFormat format)\nThis method is static and can be called without an instance.", &_init_f_fromEncoded_3702, &_call_f_fromEncoded_3702);
methods += gsi::method_ext("==", &::op_QSslDiffieHellmanParameters_operator_eq__eq__7956, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QSslDiffieHellmanParameters &lhs, const QSslDiffieHellmanParameters &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QSslDiffieHellmanParameters_operator_excl__eq__7956, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QSslDiffieHellmanParameters &lhs, const QSslDiffieHellmanParameters &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtNetwork/gsiDeclQSslEllipticCurve.cc
View File

@ -148,6 +148,16 @@ static void _call_f_fromShortName_2025 (const qt_gsi::GenericStaticMethod * /*de
}
// bool ::operator==(QSslEllipticCurve lhs, QSslEllipticCurve rhs)
static bool op_QSslEllipticCurve_operator_eq__eq__4216(QSslEllipticCurve *_self, QSslEllipticCurve rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(QSslEllipticCurve lhs, QSslEllipticCurve rhs)
static bool op_QSslEllipticCurve_operator_excl__eq__4216(QSslEllipticCurve *_self, QSslEllipticCurve rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -161,6 +171,8 @@ static gsi::Methods methods_QSslEllipticCurve () {
methods += new qt_gsi::GenericMethod ("shortName", "@brief Method QString QSslEllipticCurve::shortName()\n", true, &_init_f_shortName_c0, &_call_f_shortName_c0);
methods += new qt_gsi::GenericStaticMethod ("fromLongName", "@brief Static method QSslEllipticCurve QSslEllipticCurve::fromLongName(const QString &name)\nThis method is static and can be called without an instance.", &_init_f_fromLongName_2025, &_call_f_fromLongName_2025);
methods += new qt_gsi::GenericStaticMethod ("fromShortName", "@brief Static method QSslEllipticCurve QSslEllipticCurve::fromShortName(const QString &name)\nThis method is static and can be called without an instance.", &_init_f_fromShortName_2025, &_call_f_fromShortName_2025);
methods += gsi::method_ext("==", &::op_QSslEllipticCurve_operator_eq__eq__4216, gsi::arg ("rhs"), "@brief Operator bool ::operator==(QSslEllipticCurve lhs, QSslEllipticCurve rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QSslEllipticCurve_operator_excl__eq__4216, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(QSslEllipticCurve lhs, QSslEllipticCurve rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}

12
src/gsiqt/qt6/QtNetwork/gsiDeclQSslPreSharedKeyAuthenticator.cc
View File

@ -223,6 +223,16 @@ static void _call_f_swap_3567 (const qt_gsi::GenericMethod * /*decl*/, void *cls
}
// bool ::operator==(const QSslPreSharedKeyAuthenticator &lhs, const QSslPreSharedKeyAuthenticator &rhs)
static bool op_QSslPreSharedKeyAuthenticator_operator_eq__eq__8416(const QSslPreSharedKeyAuthenticator *_self, const QSslPreSharedKeyAuthenticator &rhs) {
return operator==(*_self, rhs);
}
// bool ::operator!=(const QSslPreSharedKeyAuthenticator &lhs, const QSslPreSharedKeyAuthenticator &rhs)
static bool op_QSslPreSharedKeyAuthenticator_operator_excl__eq__8416(const QSslPreSharedKeyAuthenticator *_self, const QSslPreSharedKeyAuthenticator &rhs) {
return operator!=(*_self, rhs);
}
namespace gsi
{
@ -240,6 +250,8 @@ static gsi::Methods methods_QSslPreSharedKeyAuthenticator () {
methods += new qt_gsi::GenericMethod ("setIdentity|identity=", "@brief Method void QSslPreSharedKeyAuthenticator::setIdentity(const QByteArray &identity)\n", false, &_init_f_setIdentity_2309, &_call_f_setIdentity_2309);
methods += new qt_gsi::GenericMethod ("setPreSharedKey|preSharedKey=", "@brief Method void QSslPreSharedKeyAuthenticator::setPreSharedKey(const QByteArray &preSharedKey)\n", false, &_init_f_setPreSharedKey_2309, &_call_f_setPreSharedKey_2309);
methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QSslPreSharedKeyAuthenticator::swap(QSslPreSharedKeyAuthenticator &other)\n", false, &_init_f_swap_3567, &_call_f_swap_3567);
methods += gsi::method_ext("==", &::op_QSslPreSharedKeyAuthenticator_operator_eq__eq__8416, gsi::arg ("rhs"), "@brief Operator bool ::operator==(const QSslPreSharedKeyAuthenticator &lhs, const QSslPreSharedKeyAuthenticator &rhs)\nThis is the mapping of the global operator to the instance method.");
methods += gsi::method_ext("!=", &::op_QSslPreSharedKeyAuthenticator_operator_excl__eq__8416, gsi::arg ("rhs"), "@brief Operator bool ::operator!=(const QSslPreSharedKeyAuthenticator &lhs, const QSslPreSharedKeyAuthenticator &rhs)\nThis is the mapping of the global operator to the instance method.");
return methods;
}