diff --git a/scripts/mkqtdecl6/mkqtdecl.conf b/scripts/mkqtdecl6/mkqtdecl.conf index 396216df9..c9ff1150e 100644 --- a/scripts/mkqtdecl6/mkqtdecl.conf +++ b/scripts/mkqtdecl6/mkqtdecl.conf @@ -42,6 +42,7 @@ drop_method :all_classes, /\(.*std::initializer_list.*\)/ # no brace initializat drop_method :all_classes, /\(.*std::function.*\)/ # std::function not bindable drop_method :all_classes, /^std::function p (*(AdaptorBase **)mp_read); + AdaptorBase *p = *(AdaptorBase **)mp_read; mp_read += item_size (); - tl_assert (p.get () != 0); + + tl_assert (p != 0); + // late-destroy the adaptor since the new X object may still need data from there (e.g. QLatin1String) + heap.push (p); X x = X (); copy_to (*p, x, heap); @@ -565,9 +568,12 @@ private: check_data (as); - std::unique_ptr p (*(AdaptorBase **)mp_read); + AdaptorBase *p = *(AdaptorBase **)mp_read; mp_read += item_size (); - tl_assert (p.get () != 0); + + tl_assert (p != 0); + // late-destroy the adaptor since the new X object may still need data from there (e.g. QLatin1String) + heap.push (p); x_type *x = new x_type (); heap.push (x); @@ -601,14 +607,19 @@ private: check_data (as); - std::unique_ptr p (*(AdaptorBase **)mp_read); + AdaptorBase *p = *(AdaptorBase **) mp_read; mp_read += item_size (); x_type *x = 0; - if (p.get () != 0) { + if (p != 0) { + + // late-destroy the adaptor since the new X object may still need data from there (e.g. QLatin1String) + heap.push (p); + x = new x_type (); heap.push (x); copy_to (*p, *x, heap); + } return x; @@ -1024,17 +1035,8 @@ public: virtual void set (const char *c_str, size_t s, tl::Heap &) { if (! m_is_const) { - *mp_s = QLatin1String (QString::fromUtf8 (c_str, int (s)).toLatin1 ()); - } - } - - virtual void copy_to (AdaptorBase *target, tl::Heap &heap) const - { - StringAdaptorImpl *s = dynamic_cast *>(target); - if (s) { - *s->mp_s = *mp_s; - } else { - StringAdaptor::copy_to (target, heap); + m_latin1_holder = QString::fromUtf8 (c_str, int (s)).toLatin1 (); + *mp_s = QLatin1String (m_latin1_holder.constData (), m_latin1_holder.size ()); } } @@ -1042,6 +1044,7 @@ private: QLatin1String *mp_s; bool m_is_const; QLatin1String m_s; + QByteArray m_latin1_holder; mutable QByteArray m_s_utf8; }; @@ -1835,7 +1838,7 @@ public: virtual tl::Variant var () const { - return tl::Variant (mp_v->value ()); + return *mp_v ? tl::Variant (mp_v->value ()) : tl::Variant (); } virtual void set (const tl::Variant &v, tl::Heap & /*heap*/) diff --git a/src/gsi/gsi/gsiTypes.h b/src/gsi/gsi/gsiTypes.h index 769b1c4ab..6e5a3bc02 100644 --- a/src/gsi/gsi/gsiTypes.h +++ b/src/gsi/gsi/gsiTypes.h @@ -1350,10 +1350,10 @@ private: */ template class ArgSpec - : public ArgSpecImpl::value && std::is_destructible::value> + : public ArgSpecImpl::value && std::is_default_constructible::value> { public: - typedef ArgSpecImpl::value && std::is_destructible::value> Base; + typedef ArgSpecImpl::value && std::is_default_constructible::value> Base; ArgSpec () : Base () @@ -1387,10 +1387,10 @@ public: */ template class ArgSpec - : public ArgSpecImpl::value && std::is_destructible::value> + : public ArgSpecImpl::value && std::is_default_constructible::value> { public: - typedef ArgSpecImpl::value && std::is_destructible::value> Base; + typedef ArgSpecImpl::value && std::is_default_constructible::value> Base; ArgSpec () : Base () @@ -1424,10 +1424,10 @@ public: */ template class ArgSpec - : public ArgSpecImpl::value && std::is_destructible::value> + : public ArgSpecImpl::value && std::is_default_constructible::value> { public: - typedef ArgSpecImpl::value && std::is_destructible::value> Base; + typedef ArgSpecImpl::value && std::is_default_constructible::value> Base; typedef T &init_type; ArgSpec () @@ -1454,7 +1454,7 @@ public: T &init () const { // this simplifies the implementation, but it's not really clean since the caller may modify the default. - return const_cast (ArgSpecImpl::value>::init ()); + return const_cast (Base::init ()); } virtual ArgSpecBase *clone () const diff --git a/src/gsi/gsi_test/gsiTest.cc b/src/gsi/gsi_test/gsiTest.cc index a4f183933..5c96c8744 100644 --- a/src/gsi/gsi_test/gsiTest.cc +++ b/src/gsi/gsi_test/gsiTest.cc @@ -220,6 +220,42 @@ A::ia_cref_to_qs_ref (const std::vector &ia) return s; } +std::vector +A::ql1s_cref_to_ia (const QLatin1String &ql1s) +{ + const char *cp = ql1s.data (); + size_t n = ql1s.size (); + std::vector ia; + for (size_t i = 0; i < n; ++i) { + ia.push_back (*cp++); + } + return ia; +} + +QLatin1String +A::ia_cref_to_ql1s (const std::vector &ia) +{ + static std::string str; + str.clear (); + for (std::vector::const_iterator i = ia.begin (); i != ia.end (); ++i) { + str += char (*i); + } + return QLatin1String (str.c_str (), str.size ()); +} + +QLatin1String & +A::ia_cref_to_ql1s_ref (const std::vector &ia) +{ + static std::string str; + str.clear (); + for (std::vector::const_iterator i = ia.begin (); i != ia.end (); ++i) { + str += char (*i); + } + static QLatin1String s; + s = QLatin1String (str.c_str (), str.size ()); + return s; +} + #if QT_VERSION >= 0x60000 std::vector @@ -238,6 +274,7 @@ QStringView A::ia_cref_to_qsv (const std::vector &ia) { static QString s; + s.clear (); for (std::vector::const_iterator i = ia.begin (); i != ia.end (); ++i) { s.push_back (char (*i)); } @@ -1016,6 +1053,17 @@ static gsi::Class decl_a ("", "A", gsi::method ("ia_cref_to_qs_cptr", &A::ia_cref_to_qs_cptr) + gsi::method ("ia_cref_to_qs_ptr", &A::ia_cref_to_qs_ptr) + + gsi::method ("ql1s_cref_to_ia", &A::ql1s_cref_to_ia) + + gsi::method ("ql1s_ref_to_ia", &A::ql1s_ref_to_ia) + + gsi::method ("ql1s_cptr_to_ia", &A::ql1s_cptr_to_ia) + + gsi::method ("ql1s_ptr_to_ia", &A::ql1s_ptr_to_ia) + + gsi::method ("ql1s_to_ia", &A::ql1s_to_ia) + + gsi::method ("ia_cref_to_ql1s", &A::ia_cref_to_ql1s) + + gsi::method ("ia_cref_to_ql1s_cref", &A::ia_cref_to_ql1s_cref) + + gsi::method ("ia_cref_to_ql1s_ref", &A::ia_cref_to_ql1s_ref) + + gsi::method ("ia_cref_to_ql1s_cptr", &A::ia_cref_to_ql1s_cptr) + + gsi::method ("ia_cref_to_ql1s_ptr", &A::ia_cref_to_ql1s_ptr) + + #if QT_VERSION >= 0x60000 gsi::method ("qbav_cref_to_ia", &A::qbav_cref_to_ia) + @@ -1180,6 +1228,18 @@ static gsi::Class decl_a ("", "A", static gsi::Class decl_a_nc (decl_a, "", "A_NC"); static gsi::Class decl_b ("", "B", + gsi::method ("int_to_optional", &B::int_to_optional) + + gsi::method ("int_to_optional_a", &B::int_to_optional_a) + + gsi::method ("optional_to_int", &B::optional_to_int) + + gsi::method ("optional_cref_to_int", &B::optional_cref_to_int) + + gsi::method ("optional_ref_to_int", &B::optional_ref_to_int) + + gsi::method ("optional_cptr_to_int", &B::optional_cptr_to_int) + + gsi::method ("optional_ptr_to_int", &B::optional_ptr_to_int) + + gsi::method ("optional_a_to_int", &B::optional_a_to_int) + + gsi::method ("optional_a_cref_to_int", &B::optional_a_cref_to_int) + + gsi::method ("optional_a_ref_to_int", &B::optional_a_ref_to_int) + + gsi::method ("optional_a_cptr_to_int", &B::optional_a_cptr_to_int) + + gsi::method ("optional_a_ptr_to_int", &B::optional_a_ptr_to_int) + gsi::method ("inst", &B::inst) + gsi::method ("has_inst", &B::has_inst) + gsi::method ("set_inst", &B::set_inst) + diff --git a/src/gsi/gsi_test/gsiTest.h b/src/gsi/gsi_test/gsiTest.h index 402ba693e..f39bdf15f 100644 --- a/src/gsi/gsi_test/gsiTest.h +++ b/src/gsi/gsi_test/gsiTest.h @@ -131,6 +131,15 @@ struct A static std::vector qs_ptr_to_ia (QString *qs) { return qs_cref_to_ia (*qs); } static std::vector qs_to_ia (QString qs) { return qs_cref_to_ia (qs); } + /** + * @brief Byte sequences: tests access to QLatin1String + */ + static std::vector ql1s_cref_to_ia (const QLatin1String &qs); + static std::vector ql1s_ref_to_ia (QLatin1String &qs) { return ql1s_cref_to_ia (qs); } + static std::vector ql1s_cptr_to_ia (const QLatin1String *qs) { return ql1s_cref_to_ia (*qs); } + static std::vector ql1s_ptr_to_ia (QLatin1String *qs) { return ql1s_cref_to_ia (*qs); } + static std::vector ql1s_to_ia (QLatin1String qs) { return ql1s_cref_to_ia (qs); } + #if QT_VERSION >= 0x60000 /** @@ -175,6 +184,15 @@ struct A static const QString *ia_cref_to_qs_cptr (const std::vector &ia) { return &ia_cref_to_qs_ref (ia); } static QString *ia_cref_to_qs_ptr (const std::vector &ia) { return &ia_cref_to_qs_ref (ia); } + /** + * @brief Byte sequences: tests return of QString + */ + static QLatin1String ia_cref_to_ql1s (const std::vector &ia); + static QLatin1String &ia_cref_to_ql1s_ref (const std::vector &ia); + static const QLatin1String &ia_cref_to_ql1s_cref (const std::vector &ia) { return ia_cref_to_ql1s_ref (ia); } + static const QLatin1String *ia_cref_to_ql1s_cptr (const std::vector &ia) { return &ia_cref_to_ql1s_ref (ia); } + static QLatin1String *ia_cref_to_ql1s_ptr (const std::vector &ia) { return &ia_cref_to_ql1s_ref (ia); } + #if QT_VERSION >= 0x60000 /** @@ -573,6 +591,26 @@ struct B */ static tl::Variant new_b_by_variant (); + /** + * @brief std::optional for simple and complex types + */ + + static std::optional int_to_optional (int value, bool exists) { return exists ? std::optional (value) : std::optional (); } + static std::optional int_to_optional_a (int value, bool exists) { return exists ? std::optional (A (value)) : std::optional (); } + + static int optional_to_int (std::optional optional, int def) { return optional ? optional.value () : def; } + static int optional_cref_to_int (const std::optional &optional, int def) { return optional_to_int (optional, def); } + static int optional_ref_to_int (std::optional &optional, int def) { return optional_to_int (optional, def); } + static int optional_cptr_to_int (const std::optional *optional, int def) { return optional_to_int (*optional, def); } + static int optional_ptr_to_int (std::optional optional, int def) { return optional_to_int (*optional, def); } + + static int optional_a_to_int (std::optional optional, int def) { return optional ? optional.value ().a1 () : def; } + static int optional_a_cref_to_int (const std::optional &optional, int def) { return optional_a_to_int (optional, def); } + static int optional_a_ref_to_int (std::optional &optional, int def) { return optional_a_to_int (optional, def); } + static int optional_a_cptr_to_int (const std::optional *optional, int def) { return optional_a_to_int (*optional, def); } + static int optional_a_ptr_to_int (std::optional optional, int def) { return optional_a_to_int (*optional, def); } + + std::string addr () const; int always_5 () const { diff --git a/src/gsiqt/qt6/QtCore/QtCore.pri b/src/gsiqt/qt6/QtCore/QtCore.pri index 2f419a93c..f39c47858 100644 --- a/src/gsiqt/qt6/QtCore/QtCore.pri +++ b/src/gsiqt/qt6/QtCore/QtCore.pri @@ -96,6 +96,7 @@ SOURCES += \ $$PWD/gsiDeclQMetaObject_Connection.cc \ $$PWD/gsiDeclQMetaProperty.cc \ $$PWD/gsiDeclQMetaSequence.cc \ + $$PWD/gsiDeclQMetaType.cc \ $$PWD/gsiDeclQMethodRawArguments.cc \ $$PWD/gsiDeclQMimeData.cc \ $$PWD/gsiDeclQMimeDatabase.cc \ @@ -178,6 +179,7 @@ SOURCES += \ $$PWD/gsiDeclQUrl.cc \ $$PWD/gsiDeclQUrlQuery.cc \ $$PWD/gsiDeclQVariantAnimation.cc \ + $$PWD/gsiDeclQVersionNumber.cc \ $$PWD/gsiDeclQWaitCondition.cc \ $$PWD/gsiDeclQWriteLocker.cc \ $$PWD/gsiDeclQXmlStreamAttribute.cc \ diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQMetaType.cc b/src/gsiqt/qt6/QtCore/gsiDeclQMetaType.cc new file mode 100644 index 000000000..c2dcdb700 --- /dev/null +++ b/src/gsiqt/qt6/QtCore/gsiDeclQMetaType.cc @@ -0,0 +1,1172 @@ + +/* + + KLayout Layout Viewer + Copyright (C) 2006-2021 Matthias Koefferlein + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +*/ + +/** +* @file gsiDeclQMetaType.cc +* +* DO NOT EDIT THIS FILE. +* This file has been created automatically +*/ + +#include +#include +#include +#include +#include "gsiQt.h" +#include "gsiQtCoreCommon.h" +#include + +// ----------------------------------------------------------------------- +// class QMetaType + +// Constructor QMetaType::QMetaType(int type) + + +static void _init_ctor_QMetaType_767 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("type"); + decl->add_arg (argspec_0); + decl->set_return_new (); +} + +static void _call_ctor_QMetaType_767 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + ret.write (new QMetaType (arg1)); +} + + +// Constructor QMetaType::QMetaType() + + +static void _init_ctor_QMetaType_0 (qt_gsi::GenericStaticMethod *decl) +{ + decl->set_return_new (); +} + +static void _call_ctor_QMetaType_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write (new QMetaType ()); +} + + +// qsizetype QMetaType::alignOf() + + +static void _init_f_alignOf_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_alignOf_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((qsizetype)((QMetaType *)cls)->alignOf ()); +} + + +// QPartialOrdering QMetaType::compare(const void *lhs, const void *rhs) + + +static void _init_f_compare_c3394 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("lhs"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("rhs"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_compare_c3394 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const void *arg1 = gsi::arg_reader() (args, heap); + const void *arg2 = gsi::arg_reader() (args, heap); + ret.write ((QPartialOrdering)((QMetaType *)cls)->compare (arg1, arg2)); +} + + +// void *QMetaType::construct(void *where, const void *copy) + + +static void _init_f_construct_c2699 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("where"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("copy", true, "nullptr"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_construct_c2699 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + void *arg1 = gsi::arg_reader() (args, heap); + const void *arg2 = args ? gsi::arg_reader() (args, heap) : gsi::arg_maker() (nullptr, heap); + ret.write ((void *)((QMetaType *)cls)->construct (arg1, arg2)); +} + + +// void *QMetaType::create(const void *copy) + + +static void _init_f_create_c1751 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("copy", true, "nullptr"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_create_c1751 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const void *arg1 = args ? gsi::arg_reader() (args, heap) : gsi::arg_maker() (nullptr, heap); + ret.write ((void *)((QMetaType *)cls)->create (arg1)); +} + + +// bool QMetaType::debugStream(QDebug &dbg, const void *rhs) + + +static void _init_f_debugStream_2829 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("dbg"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("rhs"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_debugStream_2829 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QDebug &arg1 = gsi::arg_reader() (args, heap); + const void *arg2 = gsi::arg_reader() (args, heap); + ret.write ((bool)((QMetaType *)cls)->debugStream (arg1, arg2)); +} + + +// void QMetaType::destroy(void *data) + + +static void _init_f_destroy_c1056 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("data"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_destroy_c1056 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + void *arg1 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + ((QMetaType *)cls)->destroy (arg1); +} + + +// void QMetaType::destruct(void *data) + + +static void _init_f_destruct_c1056 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("data"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_destruct_c1056 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + void *arg1 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + ((QMetaType *)cls)->destruct (arg1); +} + + +// bool QMetaType::equals(const void *lhs, const void *rhs) + + +static void _init_f_equals_c3394 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("lhs"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("rhs"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_equals_c3394 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const void *arg1 = gsi::arg_reader() (args, heap); + const void *arg2 = gsi::arg_reader() (args, heap); + ret.write ((bool)((QMetaType *)cls)->equals (arg1, arg2)); +} + + +// QFlags QMetaType::flags() + + +static void _init_f_flags_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return > (); +} + +static void _call_f_flags_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write > ((QFlags)((QMetaType *)cls)->flags ()); +} + + +// bool QMetaType::hasRegisteredDataStreamOperators() + + +static void _init_f_hasRegisteredDataStreamOperators_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_hasRegisteredDataStreamOperators_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((bool)((QMetaType *)cls)->hasRegisteredDataStreamOperators ()); +} + + +// bool QMetaType::hasRegisteredDebugStreamOperator() + + +static void _init_f_hasRegisteredDebugStreamOperator_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_hasRegisteredDebugStreamOperator_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((bool)((QMetaType *)cls)->hasRegisteredDebugStreamOperator ()); +} + + +// int QMetaType::id(int) + + +static void _init_f_id_c767 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("arg1", true, "0"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_id_c767 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = args ? gsi::arg_reader() (args, heap) : gsi::arg_maker() (0, heap); + ret.write ((int)((QMetaType *)cls)->id (arg1)); +} + + +// bool QMetaType::isEqualityComparable() + + +static void _init_f_isEqualityComparable_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_isEqualityComparable_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((bool)((QMetaType *)cls)->isEqualityComparable ()); +} + + +// bool QMetaType::isOrdered() + + +static void _init_f_isOrdered_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_isOrdered_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((bool)((QMetaType *)cls)->isOrdered ()); +} + + +// bool QMetaType::isRegistered() + + +static void _init_f_isRegistered_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_isRegistered_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((bool)((QMetaType *)cls)->isRegistered ()); +} + + +// bool QMetaType::isValid() + + +static void _init_f_isValid_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_isValid_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((bool)((QMetaType *)cls)->isValid ()); +} + + +// bool QMetaType::load(QDataStream &stream, void *data) + + +static void _init_f_load_c2645 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("stream"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("data"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_load_c2645 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QDataStream &arg1 = gsi::arg_reader() (args, heap); + void *arg2 = gsi::arg_reader() (args, heap); + ret.write ((bool)((QMetaType *)cls)->load (arg1, arg2)); +} + + +// const char *QMetaType::name() + + +static void _init_f_name_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_name_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((const char *)((QMetaType *)cls)->name ()); +} + + +// bool QMetaType::save(QDataStream &stream, const void *data) + + +static void _init_f_save_c3340 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("stream"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("data"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_save_c3340 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QDataStream &arg1 = gsi::arg_reader() (args, heap); + const void *arg2 = gsi::arg_reader() (args, heap); + ret.write ((bool)((QMetaType *)cls)->save (arg1, arg2)); +} + + +// qsizetype QMetaType::sizeOf() + + +static void _init_f_sizeOf_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_sizeOf_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((qsizetype)((QMetaType *)cls)->sizeOf ()); +} + + +// static bool QMetaType::canConvert(QMetaType fromType, QMetaType toType) + + +static void _init_f_canConvert_2544 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("fromType"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("toType"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_canConvert_2544 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QMetaType arg1 = gsi::arg_reader() (args, heap); + QMetaType arg2 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::canConvert (arg1, arg2)); +} + + +// static bool QMetaType::canView(QMetaType fromType, QMetaType toType) + + +static void _init_f_canView_2544 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("fromType"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("toType"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_canView_2544 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QMetaType arg1 = gsi::arg_reader() (args, heap); + QMetaType arg2 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::canView (arg1, arg2)); +} + + +// static bool QMetaType::compare(const void *lhs, const void *rhs, int typeId, int *result) + + +static void _init_f_compare_4898 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("lhs"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("rhs"); + decl->add_arg (argspec_1); + static gsi::ArgSpecBase argspec_2 ("typeId"); + decl->add_arg (argspec_2); + static gsi::ArgSpecBase argspec_3 ("result"); + decl->add_arg (argspec_3); + decl->set_return (); +} + +static void _call_f_compare_4898 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const void *arg1 = gsi::arg_reader() (args, heap); + const void *arg2 = gsi::arg_reader() (args, heap); + int arg3 = gsi::arg_reader() (args, heap); + int *arg4 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::compare (arg1, arg2, arg3, arg4)); +} + + +// static void *QMetaType::construct(int type, void *where, const void *copy) + + +static void _init_f_construct_3358 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("type"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("where"); + decl->add_arg (argspec_1); + static gsi::ArgSpecBase argspec_2 ("copy"); + decl->add_arg (argspec_2); + decl->set_return (); +} + +static void _call_f_construct_3358 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + void *arg2 = gsi::arg_reader() (args, heap); + const void *arg3 = gsi::arg_reader() (args, heap); + ret.write ((void *)QMetaType::construct (arg1, arg2, arg3)); +} + + +// static bool QMetaType::convert(QMetaType fromType, const void *from, QMetaType toType, void *to) + + +static void _init_f_convert_5135 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("fromType"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("from"); + decl->add_arg (argspec_1); + static gsi::ArgSpecBase argspec_2 ("toType"); + decl->add_arg (argspec_2); + static gsi::ArgSpecBase argspec_3 ("to"); + decl->add_arg (argspec_3); + decl->set_return (); +} + +static void _call_f_convert_5135 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QMetaType arg1 = gsi::arg_reader() (args, heap); + const void *arg2 = gsi::arg_reader() (args, heap); + QMetaType arg3 = gsi::arg_reader() (args, heap); + void *arg4 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::convert (arg1, arg2, arg3, arg4)); +} + + +// static bool QMetaType::convert(const void *from, int fromTypeId, void *to, int toTypeId) + + +static void _init_f_convert_4017 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("from"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("fromTypeId"); + decl->add_arg (argspec_1); + static gsi::ArgSpecBase argspec_2 ("to"); + decl->add_arg (argspec_2); + static gsi::ArgSpecBase argspec_3 ("toTypeId"); + decl->add_arg (argspec_3); + decl->set_return (); +} + +static void _call_f_convert_4017 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const void *arg1 = gsi::arg_reader() (args, heap); + int arg2 = gsi::arg_reader() (args, heap); + void *arg3 = gsi::arg_reader() (args, heap); + int arg4 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::convert (arg1, arg2, arg3, arg4)); +} + + +// static void *QMetaType::create(int type, const void *copy) + + +static void _init_f_create_2410 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("type"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("copy", true, "nullptr"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_create_2410 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + const void *arg2 = args ? gsi::arg_reader() (args, heap) : gsi::arg_maker() (nullptr, heap); + ret.write ((void *)QMetaType::create (arg1, arg2)); +} + + +// static bool QMetaType::debugStream(QDebug &dbg, const void *rhs, int typeId) + + +static void _init_f_debugStream_3488 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("dbg"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("rhs"); + decl->add_arg (argspec_1); + static gsi::ArgSpecBase argspec_2 ("typeId"); + decl->add_arg (argspec_2); + decl->set_return (); +} + +static void _call_f_debugStream_3488 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QDebug &arg1 = gsi::arg_reader() (args, heap); + const void *arg2 = gsi::arg_reader() (args, heap); + int arg3 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::debugStream (arg1, arg2, arg3)); +} + + +// static void QMetaType::destroy(int type, void *data) + + +static void _init_f_destroy_1715 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("type"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("data"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_destroy_1715 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + void *arg2 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + QMetaType::destroy (arg1, arg2); +} + + +// static void QMetaType::destruct(int type, void *where) + + +static void _init_f_destruct_1715 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("type"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("where"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_destruct_1715 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + void *arg2 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + QMetaType::destruct (arg1, arg2); +} + + +// static bool QMetaType::equals(const void *lhs, const void *rhs, int typeId, int *result) + + +static void _init_f_equals_4898 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("lhs"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("rhs"); + decl->add_arg (argspec_1); + static gsi::ArgSpecBase argspec_2 ("typeId"); + decl->add_arg (argspec_2); + static gsi::ArgSpecBase argspec_3 ("result"); + decl->add_arg (argspec_3); + decl->set_return (); +} + +static void _call_f_equals_4898 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const void *arg1 = gsi::arg_reader() (args, heap); + const void *arg2 = gsi::arg_reader() (args, heap); + int arg3 = gsi::arg_reader() (args, heap); + int *arg4 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::equals (arg1, arg2, arg3, arg4)); +} + + +// static QMetaType QMetaType::fromName(QByteArrayView name) + + +static void _init_f_fromName_1843 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("name"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_fromName_1843 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QByteArrayView arg1 = gsi::arg_reader() (args, heap); + ret.write ((QMetaType)QMetaType::fromName (arg1)); +} + + +// static bool QMetaType::hasRegisteredConverterFunction(QMetaType fromType, QMetaType toType) + + +static void _init_f_hasRegisteredConverterFunction_2544 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("fromType"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("toType"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_hasRegisteredConverterFunction_2544 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QMetaType arg1 = gsi::arg_reader() (args, heap); + QMetaType arg2 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::hasRegisteredConverterFunction (arg1, arg2)); +} + + +// static bool QMetaType::hasRegisteredDebugStreamOperator(int typeId) + + +static void _init_f_hasRegisteredDebugStreamOperator_767 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("typeId"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_hasRegisteredDebugStreamOperator_767 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::hasRegisteredDebugStreamOperator (arg1)); +} + + +// static bool QMetaType::hasRegisteredMutableViewFunction(QMetaType fromType, QMetaType toType) + + +static void _init_f_hasRegisteredMutableViewFunction_2544 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("fromType"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("toType"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_hasRegisteredMutableViewFunction_2544 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QMetaType arg1 = gsi::arg_reader() (args, heap); + QMetaType arg2 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::hasRegisteredMutableViewFunction (arg1, arg2)); +} + + +// static bool QMetaType::isRegistered(int type) + + +static void _init_f_isRegistered_767 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("type"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_isRegistered_767 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::isRegistered (arg1)); +} + + +// static bool QMetaType::load(QDataStream &stream, int type, void *data) + + +static void _init_f_load_3304 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("stream"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("type"); + decl->add_arg (argspec_1); + static gsi::ArgSpecBase argspec_2 ("data"); + decl->add_arg (argspec_2); + decl->set_return (); +} + +static void _call_f_load_3304 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QDataStream &arg1 = gsi::arg_reader() (args, heap); + int arg2 = gsi::arg_reader() (args, heap); + void *arg3 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::load (arg1, arg2, arg3)); +} + + +// static void QMetaType::registerNormalizedTypedef(const ::QByteArray &normalizedTypeName, QMetaType type) + + +static void _init_f_registerNormalizedTypedef_3643 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("normalizedTypeName"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("type"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_registerNormalizedTypedef_3643 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const ::QByteArray &arg1 = gsi::arg_reader() (args, heap); + QMetaType arg2 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + QMetaType::registerNormalizedTypedef (arg1, arg2); +} + + +// static bool QMetaType::save(QDataStream &stream, int type, const void *data) + + +static void _init_f_save_3999 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("stream"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("type"); + decl->add_arg (argspec_1); + static gsi::ArgSpecBase argspec_2 ("data"); + decl->add_arg (argspec_2); + decl->set_return (); +} + +static void _call_f_save_3999 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QDataStream &arg1 = gsi::arg_reader() (args, heap); + int arg2 = gsi::arg_reader() (args, heap); + const void *arg3 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::save (arg1, arg2, arg3)); +} + + +// static int QMetaType::sizeOf(int type) + + +static void _init_f_sizeOf_767 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("type"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_sizeOf_767 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + ret.write ((int)QMetaType::sizeOf (arg1)); +} + + +// static int QMetaType::type(const char *typeName) + + +static void _init_f_type_1731 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("typeName"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_type_1731 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const char *arg1 = gsi::arg_reader() (args, heap); + ret.write ((int)QMetaType::type (arg1)); +} + + +// static int QMetaType::type(const ::QByteArray &typeName) + + +static void _init_f_type_2425 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("typeName"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_type_2425 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const ::QByteArray &arg1 = gsi::arg_reader() (args, heap); + ret.write ((int)QMetaType::type (arg1)); +} + + +// static QFlags QMetaType::typeFlags(int type) + + +static void _init_f_typeFlags_767 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("type"); + decl->add_arg (argspec_0); + decl->set_return > (); +} + +static void _call_f_typeFlags_767 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + ret.write > ((QFlags)QMetaType::typeFlags (arg1)); +} + + +// static const char *QMetaType::typeName(int type) + + +static void _init_f_typeName_767 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("type"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_typeName_767 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + ret.write ((const char *)QMetaType::typeName (arg1)); +} + + +// static void QMetaType::unregisterConverterFunction(QMetaType from, QMetaType to) + + +static void _init_f_unregisterConverterFunction_2544 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("from"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("to"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_unregisterConverterFunction_2544 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QMetaType arg1 = gsi::arg_reader() (args, heap); + QMetaType arg2 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + QMetaType::unregisterConverterFunction (arg1, arg2); +} + + +// static void QMetaType::unregisterMetaType(QMetaType type) + + +static void _init_f_unregisterMetaType_1326 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("type"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_unregisterMetaType_1326 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QMetaType arg1 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + QMetaType::unregisterMetaType (arg1); +} + + +// static void QMetaType::unregisterMutableViewFunction(QMetaType from, QMetaType to) + + +static void _init_f_unregisterMutableViewFunction_2544 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("from"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("to"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_unregisterMutableViewFunction_2544 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QMetaType arg1 = gsi::arg_reader() (args, heap); + QMetaType arg2 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + QMetaType::unregisterMutableViewFunction (arg1, arg2); +} + + +// static bool QMetaType::view(QMetaType fromType, void *from, QMetaType toType, void *to) + + +static void _init_f_view_4440 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("fromType"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("from"); + decl->add_arg (argspec_1); + static gsi::ArgSpecBase argspec_2 ("toType"); + decl->add_arg (argspec_2); + static gsi::ArgSpecBase argspec_3 ("to"); + decl->add_arg (argspec_3); + decl->set_return (); +} + +static void _call_f_view_4440 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QMetaType arg1 = gsi::arg_reader() (args, heap); + void *arg2 = gsi::arg_reader() (args, heap); + QMetaType arg3 = gsi::arg_reader() (args, heap); + void *arg4 = gsi::arg_reader() (args, heap); + ret.write ((bool)QMetaType::view (arg1, arg2, arg3, arg4)); +} + + + +namespace gsi +{ + +static gsi::Methods methods_QMetaType () { + gsi::Methods methods; + methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QMetaType::QMetaType(int type)\nThis method creates an object of class QMetaType.", &_init_ctor_QMetaType_767, &_call_ctor_QMetaType_767); + methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QMetaType::QMetaType()\nThis method creates an object of class QMetaType.", &_init_ctor_QMetaType_0, &_call_ctor_QMetaType_0); + methods += new qt_gsi::GenericMethod ("alignOf", "@brief Method qsizetype QMetaType::alignOf()\n", true, &_init_f_alignOf_c0, &_call_f_alignOf_c0); + methods += new qt_gsi::GenericMethod ("compare", "@brief Method QPartialOrdering QMetaType::compare(const void *lhs, const void *rhs)\n", true, &_init_f_compare_c3394, &_call_f_compare_c3394); + methods += new qt_gsi::GenericMethod ("construct", "@brief Method void *QMetaType::construct(void *where, const void *copy)\n", true, &_init_f_construct_c2699, &_call_f_construct_c2699); + methods += new qt_gsi::GenericMethod ("qt_create", "@brief Method void *QMetaType::create(const void *copy)\n", true, &_init_f_create_c1751, &_call_f_create_c1751); + methods += new qt_gsi::GenericMethod ("debugStream", "@brief Method bool QMetaType::debugStream(QDebug &dbg, const void *rhs)\n", false, &_init_f_debugStream_2829, &_call_f_debugStream_2829); + methods += new qt_gsi::GenericMethod ("qt_destroy", "@brief Method void QMetaType::destroy(void *data)\n", true, &_init_f_destroy_c1056, &_call_f_destroy_c1056); + methods += new qt_gsi::GenericMethod ("destruct", "@brief Method void QMetaType::destruct(void *data)\n", true, &_init_f_destruct_c1056, &_call_f_destruct_c1056); + methods += new qt_gsi::GenericMethod ("equals", "@brief Method bool QMetaType::equals(const void *lhs, const void *rhs)\n", true, &_init_f_equals_c3394, &_call_f_equals_c3394); + methods += new qt_gsi::GenericMethod ("flags", "@brief Method QFlags QMetaType::flags()\n", true, &_init_f_flags_c0, &_call_f_flags_c0); + methods += new qt_gsi::GenericMethod ("hasRegisteredDataStreamOperators", "@brief Method bool QMetaType::hasRegisteredDataStreamOperators()\n", true, &_init_f_hasRegisteredDataStreamOperators_c0, &_call_f_hasRegisteredDataStreamOperators_c0); + methods += new qt_gsi::GenericMethod ("hasRegisteredDebugStreamOperator", "@brief Method bool QMetaType::hasRegisteredDebugStreamOperator()\n", true, &_init_f_hasRegisteredDebugStreamOperator_c0, &_call_f_hasRegisteredDebugStreamOperator_c0); + methods += new qt_gsi::GenericMethod ("id", "@brief Method int QMetaType::id(int)\n", true, &_init_f_id_c767, &_call_f_id_c767); + methods += new qt_gsi::GenericMethod ("isEqualityComparable?", "@brief Method bool QMetaType::isEqualityComparable()\n", true, &_init_f_isEqualityComparable_c0, &_call_f_isEqualityComparable_c0); + methods += new qt_gsi::GenericMethod ("isOrdered?", "@brief Method bool QMetaType::isOrdered()\n", true, &_init_f_isOrdered_c0, &_call_f_isOrdered_c0); + methods += new qt_gsi::GenericMethod ("isRegistered?", "@brief Method bool QMetaType::isRegistered()\n", true, &_init_f_isRegistered_c0, &_call_f_isRegistered_c0); + methods += new qt_gsi::GenericMethod ("isValid?", "@brief Method bool QMetaType::isValid()\n", true, &_init_f_isValid_c0, &_call_f_isValid_c0); + methods += new qt_gsi::GenericMethod ("load", "@brief Method bool QMetaType::load(QDataStream &stream, void *data)\n", true, &_init_f_load_c2645, &_call_f_load_c2645); + methods += new qt_gsi::GenericMethod ("name", "@brief Method const char *QMetaType::name()\n", true, &_init_f_name_c0, &_call_f_name_c0); + methods += new qt_gsi::GenericMethod ("save", "@brief Method bool QMetaType::save(QDataStream &stream, const void *data)\n", true, &_init_f_save_c3340, &_call_f_save_c3340); + methods += new qt_gsi::GenericMethod ("sizeOf", "@brief Method qsizetype QMetaType::sizeOf()\n", true, &_init_f_sizeOf_c0, &_call_f_sizeOf_c0); + methods += new qt_gsi::GenericStaticMethod ("canConvert", "@brief Static method bool QMetaType::canConvert(QMetaType fromType, QMetaType toType)\nThis method is static and can be called without an instance.", &_init_f_canConvert_2544, &_call_f_canConvert_2544); + methods += new qt_gsi::GenericStaticMethod ("canView", "@brief Static method bool QMetaType::canView(QMetaType fromType, QMetaType toType)\nThis method is static and can be called without an instance.", &_init_f_canView_2544, &_call_f_canView_2544); + methods += new qt_gsi::GenericStaticMethod ("compare", "@brief Static method bool QMetaType::compare(const void *lhs, const void *rhs, int typeId, int *result)\nThis method is static and can be called without an instance.", &_init_f_compare_4898, &_call_f_compare_4898); + methods += new qt_gsi::GenericStaticMethod ("construct", "@brief Static method void *QMetaType::construct(int type, void *where, const void *copy)\nThis method is static and can be called without an instance.", &_init_f_construct_3358, &_call_f_construct_3358); + methods += new qt_gsi::GenericStaticMethod ("convert", "@brief Static method bool QMetaType::convert(QMetaType fromType, const void *from, QMetaType toType, void *to)\nThis method is static and can be called without an instance.", &_init_f_convert_5135, &_call_f_convert_5135); + methods += new qt_gsi::GenericStaticMethod ("convert", "@brief Static method bool QMetaType::convert(const void *from, int fromTypeId, void *to, int toTypeId)\nThis method is static and can be called without an instance.", &_init_f_convert_4017, &_call_f_convert_4017); + methods += new qt_gsi::GenericStaticMethod ("qt_create", "@brief Static method void *QMetaType::create(int type, const void *copy)\nThis method is static and can be called without an instance.", &_init_f_create_2410, &_call_f_create_2410); + methods += new qt_gsi::GenericStaticMethod ("debugStream", "@brief Static method bool QMetaType::debugStream(QDebug &dbg, const void *rhs, int typeId)\nThis method is static and can be called without an instance.", &_init_f_debugStream_3488, &_call_f_debugStream_3488); + methods += new qt_gsi::GenericStaticMethod ("qt_destroy", "@brief Static method void QMetaType::destroy(int type, void *data)\nThis method is static and can be called without an instance.", &_init_f_destroy_1715, &_call_f_destroy_1715); + methods += new qt_gsi::GenericStaticMethod ("destruct", "@brief Static method void QMetaType::destruct(int type, void *where)\nThis method is static and can be called without an instance.", &_init_f_destruct_1715, &_call_f_destruct_1715); + methods += new qt_gsi::GenericStaticMethod ("equals", "@brief Static method bool QMetaType::equals(const void *lhs, const void *rhs, int typeId, int *result)\nThis method is static and can be called without an instance.", &_init_f_equals_4898, &_call_f_equals_4898); + methods += new qt_gsi::GenericStaticMethod ("fromName", "@brief Static method QMetaType QMetaType::fromName(QByteArrayView name)\nThis method is static and can be called without an instance.", &_init_f_fromName_1843, &_call_f_fromName_1843); + methods += new qt_gsi::GenericStaticMethod ("hasRegisteredConverterFunction", "@brief Static method bool QMetaType::hasRegisteredConverterFunction(QMetaType fromType, QMetaType toType)\nThis method is static and can be called without an instance.", &_init_f_hasRegisteredConverterFunction_2544, &_call_f_hasRegisteredConverterFunction_2544); + methods += new qt_gsi::GenericStaticMethod ("hasRegisteredDebugStreamOperator", "@brief Static method bool QMetaType::hasRegisteredDebugStreamOperator(int typeId)\nThis method is static and can be called without an instance.", &_init_f_hasRegisteredDebugStreamOperator_767, &_call_f_hasRegisteredDebugStreamOperator_767); + methods += new qt_gsi::GenericStaticMethod ("hasRegisteredMutableViewFunction", "@brief Static method bool QMetaType::hasRegisteredMutableViewFunction(QMetaType fromType, QMetaType toType)\nThis method is static and can be called without an instance.", &_init_f_hasRegisteredMutableViewFunction_2544, &_call_f_hasRegisteredMutableViewFunction_2544); + methods += new qt_gsi::GenericStaticMethod ("isRegistered?", "@brief Static method bool QMetaType::isRegistered(int type)\nThis method is static and can be called without an instance.", &_init_f_isRegistered_767, &_call_f_isRegistered_767); + methods += new qt_gsi::GenericStaticMethod ("load", "@brief Static method bool QMetaType::load(QDataStream &stream, int type, void *data)\nThis method is static and can be called without an instance.", &_init_f_load_3304, &_call_f_load_3304); + methods += new qt_gsi::GenericStaticMethod ("registerNormalizedTypedef", "@brief Static method void QMetaType::registerNormalizedTypedef(const ::QByteArray &normalizedTypeName, QMetaType type)\nThis method is static and can be called without an instance.", &_init_f_registerNormalizedTypedef_3643, &_call_f_registerNormalizedTypedef_3643); + methods += new qt_gsi::GenericStaticMethod ("save", "@brief Static method bool QMetaType::save(QDataStream &stream, int type, const void *data)\nThis method is static and can be called without an instance.", &_init_f_save_3999, &_call_f_save_3999); + methods += new qt_gsi::GenericStaticMethod ("sizeOf", "@brief Static method int QMetaType::sizeOf(int type)\nThis method is static and can be called without an instance.", &_init_f_sizeOf_767, &_call_f_sizeOf_767); + methods += new qt_gsi::GenericStaticMethod ("type", "@brief Static method int QMetaType::type(const char *typeName)\nThis method is static and can be called without an instance.", &_init_f_type_1731, &_call_f_type_1731); + methods += new qt_gsi::GenericStaticMethod ("type", "@brief Static method int QMetaType::type(const ::QByteArray &typeName)\nThis method is static and can be called without an instance.", &_init_f_type_2425, &_call_f_type_2425); + methods += new qt_gsi::GenericStaticMethod ("typeFlags", "@brief Static method QFlags QMetaType::typeFlags(int type)\nThis method is static and can be called without an instance.", &_init_f_typeFlags_767, &_call_f_typeFlags_767); + methods += new qt_gsi::GenericStaticMethod ("typeName", "@brief Static method const char *QMetaType::typeName(int type)\nThis method is static and can be called without an instance.", &_init_f_typeName_767, &_call_f_typeName_767); + methods += new qt_gsi::GenericStaticMethod ("unregisterConverterFunction", "@brief Static method void QMetaType::unregisterConverterFunction(QMetaType from, QMetaType to)\nThis method is static and can be called without an instance.", &_init_f_unregisterConverterFunction_2544, &_call_f_unregisterConverterFunction_2544); + 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); + return methods; +} + +gsi::Class decl_QMetaType ("QtCore", "QMetaType", + methods_QMetaType (), + "@qt\n@brief Binding of QMetaType"); + + +GSI_QTCORE_PUBLIC gsi::Class &qtdecl_QMetaType () { return decl_QMetaType; } + +} + + +// Implementation of the enum wrapper class for QMetaType::TypeFlag +namespace qt_gsi +{ + +static gsi::Enum decl_QMetaType_TypeFlag_Enum ("QtCore", "QMetaType_TypeFlag", + gsi::enum_const ("NeedsConstruction", QMetaType::NeedsConstruction, "@brief Enum constant QMetaType::NeedsConstruction") + + gsi::enum_const ("NeedsDestruction", QMetaType::NeedsDestruction, "@brief Enum constant QMetaType::NeedsDestruction") + + gsi::enum_const ("RelocatableType", QMetaType::RelocatableType, "@brief Enum constant QMetaType::RelocatableType") + + gsi::enum_const ("MovableType", QMetaType::MovableType, "@brief Enum constant QMetaType::MovableType") + + gsi::enum_const ("PointerToQObject", QMetaType::PointerToQObject, "@brief Enum constant QMetaType::PointerToQObject") + + gsi::enum_const ("IsEnumeration", QMetaType::IsEnumeration, "@brief Enum constant QMetaType::IsEnumeration") + + gsi::enum_const ("SharedPointerToQObject", QMetaType::SharedPointerToQObject, "@brief Enum constant QMetaType::SharedPointerToQObject") + + gsi::enum_const ("WeakPointerToQObject", QMetaType::WeakPointerToQObject, "@brief Enum constant QMetaType::WeakPointerToQObject") + + gsi::enum_const ("TrackingPointerToQObject", QMetaType::TrackingPointerToQObject, "@brief Enum constant QMetaType::TrackingPointerToQObject") + + gsi::enum_const ("IsUnsignedEnumeration", QMetaType::IsUnsignedEnumeration, "@brief Enum constant QMetaType::IsUnsignedEnumeration") + + gsi::enum_const ("IsGadget", QMetaType::IsGadget, "@brief Enum constant QMetaType::IsGadget") + + gsi::enum_const ("PointerToGadget", QMetaType::PointerToGadget, "@brief Enum constant QMetaType::PointerToGadget") + + gsi::enum_const ("IsPointer", QMetaType::IsPointer, "@brief Enum constant QMetaType::IsPointer") + + gsi::enum_const ("IsQmlList", QMetaType::IsQmlList, "@brief Enum constant QMetaType::IsQmlList") + + gsi::enum_const ("IsConst", QMetaType::IsConst, "@brief Enum constant QMetaType::IsConst"), + "@qt\n@brief This class represents the QMetaType::TypeFlag enum"); + +static gsi::QFlagsClass decl_QMetaType_TypeFlag_Enums ("QtCore", "QMetaType_QFlags_TypeFlag", + "@qt\n@brief This class represents the QFlags flag set"); + +// Inject the declarations into the parent +static gsi::ClassExt inject_QMetaType_TypeFlag_Enum_in_parent (decl_QMetaType_TypeFlag_Enum.defs ()); +static gsi::ClassExt decl_QMetaType_TypeFlag_Enum_as_child (decl_QMetaType_TypeFlag_Enum, "TypeFlag"); +static gsi::ClassExt decl_QMetaType_TypeFlag_Enums_as_child (decl_QMetaType_TypeFlag_Enums, "QFlags_TypeFlag"); + +} + diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQPromise.cc b/src/gsiqt/qt6/QtCore/gsiDeclQPromise.cc new file mode 100644 index 000000000..ddf674045 --- /dev/null +++ b/src/gsiqt/qt6/QtCore/gsiDeclQPromise.cc @@ -0,0 +1,346 @@ + +/* + + KLayout Layout Viewer + Copyright (C) 2006-2021 Matthias Koefferlein + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +*/ + +/** +* @file gsiDeclQPromise.cc +* +* DO NOT EDIT THIS FILE. +* This file has been created automatically +*/ + +#include +#include "gsiQt.h" +#include "gsiQtCoreCommon.h" +#include + +// ----------------------------------------------------------------------- +// class QPromise + +// Constructor QPromise::QPromise() + + +static void _init_ctor_QPromise_0 (qt_gsi::GenericStaticMethod *decl) +{ + decl->set_return_new (); +} + +static void _call_ctor_QPromise_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write (new QPromise ()); +} + + +// Constructor QPromise::QPromise(const QPromise &) + + +static void _init_ctor_QPromise_2129 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("arg1"); + decl->add_arg (argspec_0); + decl->set_return_new (); +} + +static void _call_ctor_QPromise_2129 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const QPromise &arg1 = gsi::arg_reader() (args, heap); + ret.write (new QPromise (arg1)); +} + + +// Constructor QPromise::QPromise(const QFutureInterface &other) + + +static void _init_ctor_QPromise_3148 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("other"); + decl->add_arg & > (argspec_0); + decl->set_return_new (); +} + +static void _call_ctor_QPromise_3148 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const QFutureInterface &arg1 = gsi::arg_reader & >() (args, heap); + ret.write (new QPromise (arg1)); +} + + +// void QPromise::finish() + + +static void _init_f_finish_0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_finish_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + __SUPPRESS_UNUSED_WARNING(ret); + ((QPromise *)cls)->finish (); +} + + +// QFuture QPromise::future() + + +static void _init_f_future_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return > (); +} + +static void _call_f_future_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write > ((QFuture)((QPromise *)cls)->future ()); +} + + +// bool QPromise::isCanceled() + + +static void _init_f_isCanceled_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_isCanceled_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((bool)((QPromise *)cls)->isCanceled ()); +} + + +// QPromise &QPromise::operator=(const QPromise &) + + +static void _init_f_operator_eq__2129 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("arg1"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_operator_eq__2129 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const QPromise &arg1 = gsi::arg_reader() (args, heap); + ret.write ((QPromise &)((QPromise *)cls)->operator= (arg1)); +} + + +// void QPromise::setException(const QException &e) + + +static void _init_f_setException_2337 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("e"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_setException_2337 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const QException &arg1 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + ((QPromise *)cls)->setException (arg1); +} + + +// void QPromise::setException(std::exception_ptr e) + + +static void _init_f_setException_2295 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("e"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_setException_2295 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + std::exception_ptr arg1 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + ((QPromise *)cls)->setException (arg1); +} + + +// void QPromise::setProgressRange(int minimum, int maximum) + + +static void _init_f_setProgressRange_1426 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("minimum"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("maximum"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_setProgressRange_1426 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + int arg2 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + ((QPromise *)cls)->setProgressRange (arg1, arg2); +} + + +// void QPromise::setProgressValue(int progressValue) + + +static void _init_f_setProgressValue_767 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("progressValue"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_setProgressValue_767 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + ((QPromise *)cls)->setProgressValue (arg1); +} + + +// void QPromise::setProgressValueAndText(int progressValue, const QString &progressText) + + +static void _init_f_setProgressValueAndText_2684 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("progressValue"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("progressText"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_setProgressValueAndText_2684 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + const QString &arg2 = gsi::arg_reader() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + ((QPromise *)cls)->setProgressValueAndText (arg1, arg2); +} + + +// void QPromise::start() + + +static void _init_f_start_0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_start_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + __SUPPRESS_UNUSED_WARNING(ret); + ((QPromise *)cls)->start (); +} + + +// void QPromise::suspendIfRequested() + + +static void _init_f_suspendIfRequested_0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_suspendIfRequested_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + __SUPPRESS_UNUSED_WARNING(ret); + ((QPromise *)cls)->suspendIfRequested (); +} + + +// void QPromise::swap(QPromise &other) + + +static void _init_f_swap_1640 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("other"); + decl->add_arg & > (argspec_0); + decl->set_return (); +} + +static void _call_f_swap_1640 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QPromise &arg1 = gsi::arg_reader & >() (args, heap); + __SUPPRESS_UNUSED_WARNING(ret); + ((QPromise *)cls)->swap (arg1); +} + + + +namespace gsi +{ + +static gsi::Methods methods_QPromise () { + gsi::Methods methods; + methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QPromise::QPromise()\nThis method creates an object of class QPromise.", &_init_ctor_QPromise_0, &_call_ctor_QPromise_0); + methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QPromise::QPromise(const QPromise &)\nThis method creates an object of class QPromise.", &_init_ctor_QPromise_2129, &_call_ctor_QPromise_2129); + methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QPromise::QPromise(const QFutureInterface &other)\nThis method creates an object of class QPromise.", &_init_ctor_QPromise_3148, &_call_ctor_QPromise_3148); + methods += new qt_gsi::GenericMethod ("finish", "@brief Method void QPromise::finish()\n", false, &_init_f_finish_0, &_call_f_finish_0); + methods += new qt_gsi::GenericMethod ("future", "@brief Method QFuture QPromise::future()\n", true, &_init_f_future_c0, &_call_f_future_c0); + methods += new qt_gsi::GenericMethod ("isCanceled?", "@brief Method bool QPromise::isCanceled()\n", true, &_init_f_isCanceled_c0, &_call_f_isCanceled_c0); + methods += new qt_gsi::GenericMethod ("assign", "@brief Method QPromise &QPromise::operator=(const QPromise &)\n", false, &_init_f_operator_eq__2129, &_call_f_operator_eq__2129); + methods += new qt_gsi::GenericMethod ("setException", "@brief Method void QPromise::setException(const QException &e)\n", false, &_init_f_setException_2337, &_call_f_setException_2337); + methods += new qt_gsi::GenericMethod ("setException", "@brief Method void QPromise::setException(std::exception_ptr e)\n", false, &_init_f_setException_2295, &_call_f_setException_2295); + methods += new qt_gsi::GenericMethod ("setProgressRange", "@brief Method void QPromise::setProgressRange(int minimum, int maximum)\n", false, &_init_f_setProgressRange_1426, &_call_f_setProgressRange_1426); + methods += new qt_gsi::GenericMethod ("setProgressValue", "@brief Method void QPromise::setProgressValue(int progressValue)\n", false, &_init_f_setProgressValue_767, &_call_f_setProgressValue_767); + methods += new qt_gsi::GenericMethod ("setProgressValueAndText", "@brief Method void QPromise::setProgressValueAndText(int progressValue, const QString &progressText)\n", false, &_init_f_setProgressValueAndText_2684, &_call_f_setProgressValueAndText_2684); + methods += new qt_gsi::GenericMethod ("start", "@brief Method void QPromise::start()\n", false, &_init_f_start_0, &_call_f_start_0); + methods += new qt_gsi::GenericMethod ("suspendIfRequested", "@brief Method void QPromise::suspendIfRequested()\n", false, &_init_f_suspendIfRequested_0, &_call_f_suspendIfRequested_0); + methods += new qt_gsi::GenericMethod ("swap", "@brief Method void QPromise::swap(QPromise &other)\n", false, &_init_f_swap_1640, &_call_f_swap_1640); + return methods; +} + +gsi::Class decl_QPromise ("QtCore", "QPromise", + methods_QPromise (), + "@qt\n@brief Binding of QPromise"); + + +GSI_QTCORE_PUBLIC gsi::Class &qtdecl_QPromise () { return decl_QPromise; } + +} + diff --git a/src/gsiqt/qt6/QtCore/gsiDeclQVersionNumber.cc b/src/gsiqt/qt6/QtCore/gsiDeclQVersionNumber.cc new file mode 100644 index 000000000..a3b5412ac --- /dev/null +++ b/src/gsiqt/qt6/QtCore/gsiDeclQVersionNumber.cc @@ -0,0 +1,459 @@ + +/* + + KLayout Layout Viewer + Copyright (C) 2006-2021 Matthias Koefferlein + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +*/ + +/** +* @file gsiDeclQVersionNumber.cc +* +* DO NOT EDIT THIS FILE. +* This file has been created automatically +*/ + +#include +#include "gsiQt.h" +#include "gsiQtCoreCommon.h" +#include + +// ----------------------------------------------------------------------- +// class QVersionNumber + +// Constructor QVersionNumber::QVersionNumber() + + +static void _init_ctor_QVersionNumber_0 (qt_gsi::GenericStaticMethod *decl) +{ + decl->set_return_new (); +} + +static void _call_ctor_QVersionNumber_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write (new QVersionNumber ()); +} + + +// Constructor QVersionNumber::QVersionNumber(const QList &seg) + + +static void _init_ctor_QVersionNumber_2259 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("seg"); + decl->add_arg & > (argspec_0); + decl->set_return_new (); +} + +static void _call_ctor_QVersionNumber_2259 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const QList &arg1 = gsi::arg_reader & >() (args, heap); + ret.write (new QVersionNumber (arg1)); +} + + +// Constructor QVersionNumber::QVersionNumber(int maj) + + +static void _init_ctor_QVersionNumber_767 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("maj"); + decl->add_arg (argspec_0); + decl->set_return_new (); +} + +static void _call_ctor_QVersionNumber_767 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + ret.write (new QVersionNumber (arg1)); +} + + +// Constructor QVersionNumber::QVersionNumber(int maj, int min) + + +static void _init_ctor_QVersionNumber_1426 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("maj"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("min"); + decl->add_arg (argspec_1); + decl->set_return_new (); +} + +static void _call_ctor_QVersionNumber_1426 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + int arg2 = gsi::arg_reader() (args, heap); + ret.write (new QVersionNumber (arg1, arg2)); +} + + +// Constructor QVersionNumber::QVersionNumber(int maj, int min, int mic) + + +static void _init_ctor_QVersionNumber_2085 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("maj"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("min"); + decl->add_arg (argspec_1); + static gsi::ArgSpecBase argspec_2 ("mic"); + decl->add_arg (argspec_2); + decl->set_return_new (); +} + +static void _call_ctor_QVersionNumber_2085 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + int arg2 = gsi::arg_reader() (args, heap); + int arg3 = gsi::arg_reader() (args, heap); + ret.write (new QVersionNumber (arg1, arg2, arg3)); +} + + +// bool QVersionNumber::isNormalized() + + +static void _init_f_isNormalized_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_isNormalized_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((bool)((QVersionNumber *)cls)->isNormalized ()); +} + + +// bool QVersionNumber::isNull() + + +static void _init_f_isNull_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_isNull_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((bool)((QVersionNumber *)cls)->isNull ()); +} + + +// bool QVersionNumber::isPrefixOf(const QVersionNumber &other) + + +static void _init_f_isPrefixOf_c2753 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("other"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_isPrefixOf_c2753 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const QVersionNumber &arg1 = gsi::arg_reader() (args, heap); + ret.write ((bool)((QVersionNumber *)cls)->isPrefixOf (arg1)); +} + + +// int QVersionNumber::majorVersion() + + +static void _init_f_majorVersion_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_majorVersion_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((int)((QVersionNumber *)cls)->majorVersion ()); +} + + +// int QVersionNumber::microVersion() + + +static void _init_f_microVersion_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_microVersion_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((int)((QVersionNumber *)cls)->microVersion ()); +} + + +// int QVersionNumber::minorVersion() + + +static void _init_f_minorVersion_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_minorVersion_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((int)((QVersionNumber *)cls)->minorVersion ()); +} + + +// QVersionNumber QVersionNumber::normalized() + + +static void _init_f_normalized_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_normalized_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((QVersionNumber)((QVersionNumber *)cls)->normalized ()); +} + + +// int QVersionNumber::segmentAt(int index) + + +static void _init_f_segmentAt_c767 (qt_gsi::GenericMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("index"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_segmentAt_c767 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + int arg1 = gsi::arg_reader() (args, heap); + ret.write ((int)((QVersionNumber *)cls)->segmentAt (arg1)); +} + + +// int QVersionNumber::segmentCount() + + +static void _init_f_segmentCount_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_segmentCount_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((int)((QVersionNumber *)cls)->segmentCount ()); +} + + +// QList QVersionNumber::segments() + + +static void _init_f_segments_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return > (); +} + +static void _call_f_segments_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write > ((QList)((QVersionNumber *)cls)->segments ()); +} + + +// QString QVersionNumber::toString() + + +static void _init_f_toString_c0 (qt_gsi::GenericMethod *decl) +{ + decl->set_return (); +} + +static void _call_f_toString_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + ret.write ((QString)((QVersionNumber *)cls)->toString ()); +} + + +// static QVersionNumber QVersionNumber::commonPrefix(const QVersionNumber &v1, const QVersionNumber &v2) + + +static void _init_f_commonPrefix_5398 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("v1"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("v2"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_commonPrefix_5398 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const QVersionNumber &arg1 = gsi::arg_reader() (args, heap); + const QVersionNumber &arg2 = gsi::arg_reader() (args, heap); + ret.write ((QVersionNumber)QVersionNumber::commonPrefix (arg1, arg2)); +} + + +// static int QVersionNumber::compare(const QVersionNumber &v1, const QVersionNumber &v2) + + +static void _init_f_compare_5398 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("v1"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("v2"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_compare_5398 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const QVersionNumber &arg1 = gsi::arg_reader() (args, heap); + const QVersionNumber &arg2 = gsi::arg_reader() (args, heap); + ret.write ((int)QVersionNumber::compare (arg1, arg2)); +} + + +// static QVersionNumber QVersionNumber::fromString(const QString &string, int *suffixIndex) + + +static void _init_f_fromString_2870 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("string"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("suffixIndex", true, "nullptr"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_fromString_2870 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const QString &arg1 = gsi::arg_reader() (args, heap); + int *arg2 = args ? gsi::arg_reader() (args, heap) : gsi::arg_maker() (nullptr, heap); + ret.write ((QVersionNumber)QVersionNumber::fromString (arg1, arg2)); +} + + +// static QVersionNumber QVersionNumber::fromString(QLatin1String string, int *suffixIndex) + + +static void _init_f_fromString_2546 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("string"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("suffixIndex", true, "nullptr"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_fromString_2546 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QLatin1String arg1 = gsi::arg_reader() (args, heap); + int *arg2 = args ? gsi::arg_reader() (args, heap) : gsi::arg_maker() (nullptr, heap); + ret.write ((QVersionNumber)QVersionNumber::fromString (arg1, arg2)); +} + + +// static QVersionNumber QVersionNumber::fromString(QStringView string, int *suffixIndex) + + +static void _init_f_fromString_2404 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("string"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("suffixIndex", true, "nullptr"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_fromString_2404 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + QStringView arg1 = gsi::arg_reader() (args, heap); + int *arg2 = args ? gsi::arg_reader() (args, heap) : gsi::arg_maker() (nullptr, heap); + ret.write ((QVersionNumber)QVersionNumber::fromString (arg1, arg2)); +} + + + +namespace gsi +{ + +static gsi::Methods methods_QVersionNumber () { + gsi::Methods methods; + methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QVersionNumber::QVersionNumber()\nThis method creates an object of class QVersionNumber.", &_init_ctor_QVersionNumber_0, &_call_ctor_QVersionNumber_0); + methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QVersionNumber::QVersionNumber(const QList &seg)\nThis method creates an object of class QVersionNumber.", &_init_ctor_QVersionNumber_2259, &_call_ctor_QVersionNumber_2259); + methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QVersionNumber::QVersionNumber(int maj)\nThis method creates an object of class QVersionNumber.", &_init_ctor_QVersionNumber_767, &_call_ctor_QVersionNumber_767); + methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QVersionNumber::QVersionNumber(int maj, int min)\nThis method creates an object of class QVersionNumber.", &_init_ctor_QVersionNumber_1426, &_call_ctor_QVersionNumber_1426); + methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QVersionNumber::QVersionNumber(int maj, int min, int mic)\nThis method creates an object of class QVersionNumber.", &_init_ctor_QVersionNumber_2085, &_call_ctor_QVersionNumber_2085); + methods += new qt_gsi::GenericMethod ("isNormalized?", "@brief Method bool QVersionNumber::isNormalized()\n", true, &_init_f_isNormalized_c0, &_call_f_isNormalized_c0); + methods += new qt_gsi::GenericMethod ("isNull?", "@brief Method bool QVersionNumber::isNull()\n", true, &_init_f_isNull_c0, &_call_f_isNull_c0); + methods += new qt_gsi::GenericMethod ("isPrefixOf?", "@brief Method bool QVersionNumber::isPrefixOf(const QVersionNumber &other)\n", true, &_init_f_isPrefixOf_c2753, &_call_f_isPrefixOf_c2753); + methods += new qt_gsi::GenericMethod ("majorVersion", "@brief Method int QVersionNumber::majorVersion()\n", true, &_init_f_majorVersion_c0, &_call_f_majorVersion_c0); + methods += new qt_gsi::GenericMethod ("microVersion", "@brief Method int QVersionNumber::microVersion()\n", true, &_init_f_microVersion_c0, &_call_f_microVersion_c0); + methods += new qt_gsi::GenericMethod ("minorVersion", "@brief Method int QVersionNumber::minorVersion()\n", true, &_init_f_minorVersion_c0, &_call_f_minorVersion_c0); + methods += new qt_gsi::GenericMethod ("normalized", "@brief Method QVersionNumber QVersionNumber::normalized()\n", true, &_init_f_normalized_c0, &_call_f_normalized_c0); + methods += new qt_gsi::GenericMethod ("segmentAt", "@brief Method int QVersionNumber::segmentAt(int index)\n", true, &_init_f_segmentAt_c767, &_call_f_segmentAt_c767); + methods += new qt_gsi::GenericMethod ("segmentCount", "@brief Method int QVersionNumber::segmentCount()\n", true, &_init_f_segmentCount_c0, &_call_f_segmentCount_c0); + methods += new qt_gsi::GenericMethod ("segments", "@brief Method QList QVersionNumber::segments()\n", true, &_init_f_segments_c0, &_call_f_segments_c0); + methods += new qt_gsi::GenericMethod ("toString", "@brief Method QString QVersionNumber::toString()\n", true, &_init_f_toString_c0, &_call_f_toString_c0); + 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 += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QVersionNumber QVersionNumber::fromString(QLatin1String string, int *suffixIndex)\nThis method is static and can be called without an instance.", &_init_f_fromString_2546, &_call_f_fromString_2546); + methods += new qt_gsi::GenericStaticMethod ("fromString", "@brief Static method QVersionNumber QVersionNumber::fromString(QStringView string, int *suffixIndex)\nThis method is static and can be called without an instance.", &_init_f_fromString_2404, &_call_f_fromString_2404); + return methods; +} + +gsi::Class decl_QVersionNumber ("QtCore", "QVersionNumber", + methods_QVersionNumber (), + "@qt\n@brief Binding of QVersionNumber"); + + +GSI_QTCORE_PUBLIC gsi::Class &qtdecl_QVersionNumber () { return decl_QVersionNumber; } + +} + diff --git a/src/gsiqt/qt6/QtCore/gsiQtExternals.h b/src/gsiqt/qt6/QtCore/gsiQtExternals.h index d8fcf9ef7..21a58e372 100644 --- a/src/gsiqt/qt6/QtCore/gsiQtExternals.h +++ b/src/gsiqt/qt6/QtCore/gsiQtExternals.h @@ -349,6 +349,10 @@ class QMetaSequence; namespace gsi { GSI_QTCORE_PUBLIC gsi::Class &qtdecl_QMetaSequence (); } +class QMetaType; + +namespace gsi { GSI_QTCORE_PUBLIC gsi::Class &qtdecl_QMetaType (); } + struct QMethodRawArguments; namespace gsi { GSI_QTCORE_PUBLIC gsi::Class &qtdecl_QMethodRawArguments (); } @@ -669,6 +673,10 @@ class QVariantAnimation; namespace gsi { GSI_QTCORE_PUBLIC gsi::Class &qtdecl_QVariantAnimation (); } +class QVersionNumber; + +namespace gsi { GSI_QTCORE_PUBLIC gsi::Class &qtdecl_QVersionNumber (); } + class QWaitCondition; namespace gsi { GSI_QTCORE_PUBLIC gsi::Class &qtdecl_QWaitCondition (); } diff --git a/src/gsiqt/qt6/QtGui/gsiDeclQFont.cc b/src/gsiqt/qt6/QtGui/gsiDeclQFont.cc index 6c4ced380..73e991d85 100644 --- a/src/gsiqt/qt6/QtGui/gsiDeclQFont.cc +++ b/src/gsiqt/qt6/QtGui/gsiDeclQFont.cc @@ -35,11 +35,6 @@ // ----------------------------------------------------------------------- // class QFont - static unsigned int font_const_light () { return (unsigned int) QFont::Light; } - static unsigned int font_const_normal () { return (unsigned int) QFont::Normal; } - static unsigned int font_const_demibold () { return (unsigned int) QFont::DemiBold; } - static unsigned int font_const_bold () { return (unsigned int) QFont::Bold; } - static unsigned int font_const_black () { return (unsigned int) QFont::Black; } // Constructor QFont::QFont() @@ -1462,12 +1457,6 @@ static gsi::Methods methods_QFont () { } gsi::Class decl_QFont ("QtGui", "QFont", - gsi::method("Light", &font_const_light, "@brief Font weight constant 'QFont::Light'.") + - gsi::method("Normal", &font_const_normal, "@brief Font weight constant 'QFont::Normal'.") + - gsi::method("DemiBold", &font_const_demibold, "@brief Font weight constant 'QFont::DemiBold'.") + - gsi::method("Bold", &font_const_bold, "@brief Font weight constant 'QFont::Bold'.") + - gsi::method("Black", &font_const_black, "@brief Font weight constant 'QFont::Black'.") -+ methods_QFont (), "@qt\n@brief Binding of QFont"); diff --git a/src/pya/pya/pyaConvert.cc b/src/pya/pya/pyaConvert.cc index 932c564cd..7babd2a62 100644 --- a/src/pya/pya/pyaConvert.cc +++ b/src/pya/pya/pyaConvert.cc @@ -445,7 +445,7 @@ object_to_python (void *obj, PYAObjectBase *self, const gsi::ClassBase *cls, boo } - if (! pass_obj && prefer_copy && ! clsact->adapted_type_info () && ! clsact->is_managed () && clsact->can_copy ()) { + if (! pass_obj && prefer_copy && ! clsact->adapted_type_info () && ! clsact->is_managed () && clsact->can_copy () && clsact->can_default_create ()) { // We copy objects passed by const reference if they are not managed // (derived from gsi::ObjectBase, in that case, client_data is not 0). diff --git a/src/rba/rba/rbaConvert.cc b/src/rba/rba/rbaConvert.cc index 17673a91a..da7304264 100644 --- a/src/rba/rba/rbaConvert.cc +++ b/src/rba/rba/rbaConvert.cc @@ -204,7 +204,7 @@ object_to_ruby (void *obj, Proxy *self, const gsi::ClassBase *cls, bool pass_obj } - if (! pass_obj && prefer_copy && ! clsact->adapted_type_info () && ! clsact->is_managed () && clsact->can_copy ()) { + if (! pass_obj && prefer_copy && ! clsact->adapted_type_info () && ! clsact->is_managed () && clsact->can_copy () && clsact->can_default_create ()) { // We copy objects passed by const reference if they are not managed. // Such objects are often exposed internals. First we can't diff --git a/testdata/python/basic.py b/testdata/python/basic.py index d949db945..5bd49cb16 100644 --- a/testdata/python/basic.py +++ b/testdata/python/basic.py @@ -2993,6 +2993,35 @@ class BasicTest(unittest.TestCase): self.assertEqual(pya.A.qsv_to_ia('\x00\x01\x02'), [ 0, 1, 2 ]) + def test_QLatin1String(self): + + # QLatin1String + + if "ia_cref_to_ql1s" in pya.A.__dict__: + + ql1s = pya.A.ia_cref_to_ql1s([ 16, 42, 0, 8 ]) + self.assertEqual(repr(ql1s), "'\\x10*\\x00\\x08'") + + self.assertEqual(pya.A.ql1s_to_ia(ql1s), [ 16, 42, 0, 8 ]) + self.assertEqual(pya.A.ql1s_cref_to_ia(ql1s), [ 16, 42, 0, 8 ]) + self.assertEqual(pya.A.ql1s_cptr_to_ia(ql1s), [ 16, 42, 0, 8 ]) + self.assertEqual(pya.A.ql1s_ref_to_ia(ql1s), [ 16, 42, 0, 8 ]) + self.assertEqual(pya.A.ql1s_ptr_to_ia(ql1s), [ 16, 42, 0, 8 ]) + + ql1s = pya.A.ia_cref_to_ql1s_cref([ 17, 42, 0, 8 ]) + self.assertEqual(repr(ql1s), "'\\x11*\\x00\\x08'") + + ql1s = pya.A.ia_cref_to_ql1s_ref([ 18, 42, 0, 8 ]) + self.assertEqual(repr(ql1s), "'\\x12*\\x00\\x08'") + + ql1s = pya.A.ia_cref_to_ql1s_cptr([ 19, 42, 0, 8 ]) + self.assertEqual(repr(ql1s), "'\\x13*\\x00\\x08'") + + ql1s = pya.A.ia_cref_to_ql1s_ptr([ 20, 42, 0, 8 ]) + self.assertEqual(repr(ql1s), "'\\x14*\\x00\\x08'") + + self.assertEqual(pya.A.ql1s_to_ia('\x00\x01\x02'), [ 0, 1, 2 ]) + def test_binaryStrings(self): # binary strings (non-Qt) diff --git a/testdata/ruby/basic_testcore.rb b/testdata/ruby/basic_testcore.rb index f77026ff2..5e696102f 100644 --- a/testdata/ruby/basic_testcore.rb +++ b/testdata/ruby/basic_testcore.rb @@ -2893,6 +2893,36 @@ class Basic_TestClass < TestBase end + def test_QLatin1String + + # QLatin1String + + if RBA::A.respond_to?(:ia_cref_to_ql1s) + + ql1s = RBA::A::ia_cref_to_ql1s([ 16, 42, 0, 8 ]) + assert_equal(ql1s.inspect, "\"\\x10*\\x00\\b\"") + + assert_equal(RBA::A::ql1s_to_ia(ql1s), [ 16, 42, 0, 8 ]) + assert_equal(RBA::A::ql1s_cref_to_ia(ql1s), [ 16, 42, 0, 8 ]) + assert_equal(RBA::A::ql1s_cptr_to_ia(ql1s), [ 16, 42, 0, 8 ]) + assert_equal(RBA::A::ql1s_ref_to_ia(ql1s), [ 16, 42, 0, 8 ]) + assert_equal(RBA::A::ql1s_ptr_to_ia(ql1s), [ 16, 42, 0, 8 ]) + + ql1s = RBA::A::ia_cref_to_ql1s_cref([ 17, 42, 0, 8 ]) + assert_equal(ql1s.inspect, "\"\\x11*\\x00\\b\"") + ql1s = RBA::A::ia_cref_to_ql1s_ref([ 18, 42, 0, 8 ]) + assert_equal(ql1s.inspect, "\"\\x12*\\x00\\b\"") + ql1s = RBA::A::ia_cref_to_ql1s_cptr([ 19, 42, 0, 8 ]) + assert_equal(ql1s.inspect, "\"\\x13*\\x00\\b\"") + ql1s = RBA::A::ia_cref_to_ql1s_ptr([ 20, 42, 0, 8 ]) + assert_equal(ql1s.inspect, "\"\\x14*\\x00\\b\"") + + assert_equal(RBA::A::ql1s_to_ia("\x00\x01\x02"), [ 0, 1, 2 ]) + + end + + end + def test_QStringView # QStringView @@ -2949,6 +2979,35 @@ class Basic_TestClass < TestBase end + def test_optional + + assert_equal(RBA::B::int_to_optional(1, true), 1) + assert_equal(RBA::B::int_to_optional(1, false), nil) + assert_equal(RBA::B::int_to_optional_a(1, true).a1, 1) + assert_equal(RBA::B::int_to_optional_a(1, false), nil) + + assert_equal(RBA::B::optional_to_int(1, -1), 1) + assert_equal(RBA::B::optional_to_int(nil, -1), -1) + assert_equal(RBA::B::optional_cref_to_int(2, -1), 2) + assert_equal(RBA::B::optional_cref_to_int(nil, -1), -1) + assert_equal(RBA::B::optional_ref_to_int(3, -1), 3) + assert_equal(RBA::B::optional_ref_to_int(nil, -1), -1) + + assert_equal(RBA::B::optional_cptr_to_int(4, -1), 4) + assert_equal(RBA::B::optional_ptr_to_int(5, -1), 5) + + assert_equal(RBA::B::optional_a_to_int(RBA::A::new(1), -1), 1) + assert_equal(RBA::B::optional_a_to_int(nil, -1), -1) + assert_equal(RBA::B::optional_a_cref_to_int(RBA::A::new(2), -1), 2) + assert_equal(RBA::B::optional_a_cref_to_int(nil, -1), -1) + assert_equal(RBA::B::optional_a_ref_to_int(RBA::A::new(3), -1), 3) + assert_equal(RBA::B::optional_a_ref_to_int(nil, -1), -1) + + assert_equal(RBA::B::optional_a_cptr_to_int(RBA::A::new(4), -1), 4) + assert_equal(RBA::B::optional_a_ptr_to_int(RBA::A::new(5), -1), 5) + + end + # Custom factory implemented in Ruby def test_80