From 91248811807ef62b3c06acd61855f5617a3afdf6 Mon Sep 17 00:00:00 2001 From: Matthias Koefferlein Date: Sun, 5 Dec 2021 13:38:26 +0100 Subject: [PATCH] Added missing file. --- src/gsiqt/qt5/QtCore/gsiDeclQMetaType.cc | 719 +++++++++++++++++++++++ 1 file changed, 719 insertions(+) create mode 100644 src/gsiqt/qt5/QtCore/gsiDeclQMetaType.cc diff --git a/src/gsiqt/qt5/QtCore/gsiDeclQMetaType.cc b/src/gsiqt/qt5/QtCore/gsiDeclQMetaType.cc new file mode 100644 index 000000000..c9c182e12 --- /dev/null +++ b/src/gsiqt/qt5/QtCore/gsiDeclQMetaType.cc @@ -0,0 +1,719 @@ + +/* + + 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 "gsiQt.h" +#include "gsiQtCoreCommon.h" +#include + +// ----------------------------------------------------------------------- +// class QMetaType + +// Constructor QMetaType::QMetaType(const int type) + + +static void _init_ctor_QMetaType_1462 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("type"); + decl->add_arg (argspec_0); + decl->set_return_new (); +} + +static void _call_ctor_QMetaType_1462 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) +{ + __SUPPRESS_UNUSED_WARNING(args); + tl::Heap heap; + const int arg1 = gsi::arg_reader() (args, heap); + ret.write (new QMetaType (arg1)); +} + + +// 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, "0"); + 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() (0, 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, "0"); + 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() (0, heap); + ret.write ((void *)((QMetaType *)cls)->create (arg1)); +} + + +// 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); +} + + +// 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::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 ()); +} + + +// int 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 ((int)((QMetaType *)cls)->sizeOf ()); +} + + +// 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(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, "0"); + 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() (0, 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 bool QMetaType::hasRegisteredComparators(int typeId) + + +static void _init_f_hasRegisteredComparators_767 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("typeId"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_hasRegisteredComparators_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::hasRegisteredComparators (arg1)); +} + + +// static bool QMetaType::hasRegisteredConverterFunction(int fromTypeId, int toTypeId) + + +static void _init_f_hasRegisteredConverterFunction_1426 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("fromTypeId"); + decl->add_arg (argspec_0); + static gsi::ArgSpecBase argspec_1 ("toTypeId"); + decl->add_arg (argspec_1); + decl->set_return (); +} + +static void _call_f_hasRegisteredConverterFunction_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 ((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::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 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 bool QMetaType::unregisterType(int type) + + +static void _init_f_unregisterType_767 (qt_gsi::GenericStaticMethod *decl) +{ + static gsi::ArgSpecBase argspec_0 ("type"); + decl->add_arg (argspec_0); + decl->set_return (); +} + +static void _call_f_unregisterType_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::unregisterType (arg1)); +} + + + +namespace gsi +{ + +static gsi::Methods methods_QMetaType () { + gsi::Methods methods; + methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QMetaType::QMetaType(const int type)\nThis method creates an object of class QMetaType.", &_init_ctor_QMetaType_1462, &_call_ctor_QMetaType_1462); + 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 ("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 ("flags", "@brief Method QFlags QMetaType::flags()\n", true, &_init_f_flags_c0, &_call_f_flags_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 ("sizeOf", "@brief Method int QMetaType::sizeOf()\n", true, &_init_f_sizeOf_c0, &_call_f_sizeOf_c0); + 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(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 ("hasRegisteredComparators", "@brief Static method bool QMetaType::hasRegisteredComparators(int typeId)\nThis method is static and can be called without an instance.", &_init_f_hasRegisteredComparators_767, &_call_f_hasRegisteredComparators_767); + methods += new qt_gsi::GenericStaticMethod ("hasRegisteredConverterFunction", "@brief Static method bool QMetaType::hasRegisteredConverterFunction(int fromTypeId, int toTypeId)\nThis method is static and can be called without an instance.", &_init_f_hasRegisteredConverterFunction_1426, &_call_f_hasRegisteredConverterFunction_1426); + 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 ("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 ("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 ("unregisterType", "@brief Static method bool QMetaType::unregisterType(int type)\nThis method is static and can be called without an instance.", &_init_f_unregisterType_767, &_call_f_unregisterType_767); + 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 ("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 ("WasDeclaredAsMetaType", QMetaType::WasDeclaredAsMetaType, "@brief Enum constant QMetaType::WasDeclaredAsMetaType") + + gsi::enum_const ("IsGadget", QMetaType::IsGadget, "@brief Enum constant QMetaType::IsGadget"), + "@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"); + +} +