
/*

  KLayout Layout Viewer
  Copyright (C) 2006-2026 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 <QMetaType>
#include <QDataStream>
#include <QDebug>
#include "gsiQt.h"
#include "gsiQtCoreCommon.h"
#include <memory>

// -----------------------------------------------------------------------
// 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<const int > (argspec_0);
  decl->set_return_new<QMetaType> ();
}

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<const int >() (args, heap);
  ret.write<QMetaType *> (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<void * > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("copy", true, "nullptr");
  decl->add_arg<const void * > (argspec_1);
  decl->set_return<void * > ();
}

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<void * >() (args, heap);
  const void *arg2 = args ? gsi::arg_reader<const void * >() (args, heap) : gsi::arg_maker<const void * >() (nullptr, heap);
  ret.write<void * > ((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<const void * > (argspec_0);
  decl->set_return<void * > ();
}

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<const void * >() (args, heap) : gsi::arg_maker<const void * >() (nullptr, heap);
  ret.write<void * > ((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<void * > (argspec_0);
  decl->set_return<void > ();
}

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<void * >() (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<void * > (argspec_0);
  decl->set_return<void > ();
}

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<void * >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMetaType *)cls)->destruct (arg1);
}


// QFlags<QMetaType::TypeFlag> QMetaType::flags()


static void _init_f_flags_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QFlags<QMetaType::TypeFlag> > ();
}

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::TypeFlag> > ((QFlags<QMetaType::TypeFlag>)((QMetaType *)cls)->flags ());
}


// bool QMetaType::isRegistered()


static void _init_f_isRegistered_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

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 > ((bool)((QMetaType *)cls)->isRegistered ());
}


// bool QMetaType::isValid()


static void _init_f_isValid_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

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 > ((bool)((QMetaType *)cls)->isValid ());
}


// int QMetaType::sizeOf()


static void _init_f_sizeOf_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<int > ();
}

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 > ((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<const void * > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("rhs");
  decl->add_arg<const void * > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("typeId");
  decl->add_arg<int > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("result");
  decl->add_arg<int * > (argspec_3);
  decl->set_return<bool > ();
}

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<const void * >() (args, heap);
  const void *arg2 = gsi::arg_reader<const void * >() (args, heap);
  int arg3 = gsi::arg_reader<int >() (args, heap);
  int *arg4 = gsi::arg_reader<int * >() (args, heap);
  ret.write<bool > ((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<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("where");
  decl->add_arg<void * > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("copy");
  decl->add_arg<const void * > (argspec_2);
  decl->set_return<void * > ();
}

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<int >() (args, heap);
  void *arg2 = gsi::arg_reader<void * >() (args, heap);
  const void *arg3 = gsi::arg_reader<const void * >() (args, heap);
  ret.write<void * > ((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<const void * > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("fromTypeId");
  decl->add_arg<int > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("to");
  decl->add_arg<void * > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("toTypeId");
  decl->add_arg<int > (argspec_3);
  decl->set_return<bool > ();
}

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<const void * >() (args, heap);
  int arg2 = gsi::arg_reader<int >() (args, heap);
  void *arg3 = gsi::arg_reader<void * >() (args, heap);
  int arg4 = gsi::arg_reader<int >() (args, heap);
  ret.write<bool > ((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<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("copy", true, "nullptr");
  decl->add_arg<const void * > (argspec_1);
  decl->set_return<void * > ();
}

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<int >() (args, heap);
  const void *arg2 = args ? gsi::arg_reader<const void * >() (args, heap) : gsi::arg_maker<const void * >() (nullptr, heap);
  ret.write<void * > ((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<QDebug & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("rhs");
  decl->add_arg<const void * > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("typeId");
  decl->add_arg<int > (argspec_2);
  decl->set_return<bool > ();
}

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<QDebug & >() (args, heap);
  const void *arg2 = gsi::arg_reader<const void * >() (args, heap);
  int arg3 = gsi::arg_reader<int >() (args, heap);
  ret.write<bool > ((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<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("data");
  decl->add_arg<void * > (argspec_1);
  decl->set_return<void > ();
}

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<int >() (args, heap);
  void *arg2 = gsi::arg_reader<void * >() (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<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("where");
  decl->add_arg<void * > (argspec_1);
  decl->set_return<void > ();
}

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<int >() (args, heap);
  void *arg2 = gsi::arg_reader<void * >() (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<const void * > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("rhs");
  decl->add_arg<const void * > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("typeId");
  decl->add_arg<int > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("result");
  decl->add_arg<int * > (argspec_3);
  decl->set_return<bool > ();
}

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<const void * >() (args, heap);
  const void *arg2 = gsi::arg_reader<const void * >() (args, heap);
  int arg3 = gsi::arg_reader<int >() (args, heap);
  int *arg4 = gsi::arg_reader<int * >() (args, heap);
  ret.write<bool > ((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<int > (argspec_0);
  decl->set_return<bool > ();
}

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<int >() (args, heap);
  ret.write<bool > ((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<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("toTypeId");
  decl->add_arg<int > (argspec_1);
  decl->set_return<bool > ();
}

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<int >() (args, heap);
  int arg2 = gsi::arg_reader<int >() (args, heap);
  ret.write<bool > ((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<int > (argspec_0);
  decl->set_return<bool > ();
}

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<int >() (args, heap);
  ret.write<bool > ((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<int > (argspec_0);
  decl->set_return<bool > ();
}

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<int >() (args, heap);
  ret.write<bool > ((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<QDataStream & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("type");
  decl->add_arg<int > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("data");
  decl->add_arg<void * > (argspec_2);
  decl->set_return<bool > ();
}

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<QDataStream & >() (args, heap);
  int arg2 = gsi::arg_reader<int >() (args, heap);
  void *arg3 = gsi::arg_reader<void * >() (args, heap);
  ret.write<bool > ((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<QDataStream & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("type");
  decl->add_arg<int > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("data");
  decl->add_arg<const void * > (argspec_2);
  decl->set_return<bool > ();
}

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<QDataStream & >() (args, heap);
  int arg2 = gsi::arg_reader<int >() (args, heap);
  const void *arg3 = gsi::arg_reader<const void * >() (args, heap);
  ret.write<bool > ((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<int > (argspec_0);
  decl->set_return<int > ();
}

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<int >() (args, heap);
  ret.write<int > ((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<const char * > (argspec_0);
  decl->set_return<int > ();
}

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<const char * >() (args, heap);
  ret.write<int > ((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<const ::QByteArray & > (argspec_0);
  decl->set_return<int > ();
}

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<const ::QByteArray & >() (args, heap);
  ret.write<int > ((int)QMetaType::type (arg1));
}


// static QFlags<QMetaType::TypeFlag> QMetaType::typeFlags(int type)


static void _init_f_typeFlags_767 (qt_gsi::GenericStaticMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("type");
  decl->add_arg<int > (argspec_0);
  decl->set_return<QFlags<QMetaType::TypeFlag> > ();
}

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<int >() (args, heap);
  ret.write<QFlags<QMetaType::TypeFlag> > ((QFlags<QMetaType::TypeFlag>)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<int > (argspec_0);
  decl->set_return<const char * > ();
}

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<int >() (args, heap);
  ret.write<const char * > ((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<int > (argspec_0);
  decl->set_return<bool > ();
}

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<int >() (args, heap);
  ret.write<bool > ((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 ("create|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 ("destroy|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::TypeFlag> 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 ("create|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 ("destroy|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::TypeFlag> 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<QMetaType> decl_QMetaType ("QtCore", "QMetaType",
  methods_QMetaType (),
  "@qt\n@brief Binding of QMetaType");


GSI_QTCORE_PUBLIC gsi::Class<QMetaType> &qtdecl_QMetaType () { return decl_QMetaType; }

}


//  Implementation of the enum wrapper class for QMetaType::TypeFlag
namespace qt_gsi
{

static gsi::Enum<QMetaType::TypeFlag> 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") +
    gsi::enum_const ("PointerToGadget", QMetaType::PointerToGadget, "@brief Enum constant QMetaType::PointerToGadget"),
  "@qt\n@brief This class represents the QMetaType::TypeFlag enum");

static gsi::QFlagsClass<QMetaType::TypeFlag > decl_QMetaType_TypeFlag_Enums ("QtCore", "QMetaType_QFlags_TypeFlag",
  "@qt\n@brief This class represents the QFlags<QMetaType::TypeFlag> flag set");

//  Inject the declarations into the parent
static gsi::ClassExt<QMetaType> inject_QMetaType_TypeFlag_Enum_in_parent (decl_QMetaType_TypeFlag_Enum.defs ());
static gsi::ClassExt<QMetaType> decl_QMetaType_TypeFlag_Enum_as_child (decl_QMetaType_TypeFlag_Enum, "TypeFlag");
static gsi::ClassExt<QMetaType> decl_QMetaType_TypeFlag_Enums_as_child (decl_QMetaType_TypeFlag_Enums, "QFlags_TypeFlag");

}

