/*
 * Module code.
 *
 * Generated by SIP 4.16.7
 *
 * Copyright (c) 2014 Riverbank Computing Limited <info@riverbankcomputing.com>
 * 
 * This file is part of PyQt.
 * 
 * This file may be used under the terms of the GNU General Public
 * License versions 2.0 or 3.0 as published by the Free Software
 * Foundation and appearing in the files LICENSE.GPL2 and LICENSE.GPL3
 * included in the packaging of this file.  Alternatively you may (at
 * your option) use any later version of the GNU General Public
 * License if such license has been publicly approved by Riverbank
 * Computing Limited (or its successors, if any) and the KDE Free Qt
 * Foundation. In addition, as a special exception, Riverbank gives you
 * certain additional rights. These rights are described in the Riverbank
 * GPL Exception version 1.1, which can be found in the file
 * GPL_EXCEPTION.txt in this package.
 * 
 * If you are unsure which license is appropriate for your use, please
 * contact the sales department at sales@riverbankcomputing.com.
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#include "sipAPIQtXmlPatterns.h"

#line 34 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 34 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlname.sip"
#include <qxmlname.h>
#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 36 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 40 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 801 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 43 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvector.sip"
#include <qvector.h>
#line 46 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 49 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvector.sip"
#include <qvector.h>
#line 52 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 107 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qurl.sip"
#include <qurl.h>
#line 55 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 86 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 58 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 274 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 61 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qsourcelocation.sip"
#include <qsourcelocation.h>
#line 64 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 132 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 67 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlnamepool.sip"
#include <qxmlnamepool.h>
#line 70 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlquery.sip"
#include <qxmlquery.h>
#line 73 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

/* Define the strings used by this module. */
const char sipStrings_QtXmlPatterns[] = {
    'Q', 'A', 'b', 's', 't', 'r', 'a', 'c', 't', 'X', 'm', 'l', 'N', 'o', 'd', 'e', 'M', 'o', 'd', 'e', 'l', ':', ':', 'S', 'i', 'm', 'p', 'l', 'e', 'A', 'x', 'i', 's', 0,
    'Q', 'X', 'm', 'l', 'N', 'o', 'd', 'e', 'M', 'o', 'd', 'e', 'l', 'I', 'n', 'd', 'e', 'x', ':', ':', 'D', 'o', 'c', 'u', 'm', 'e', 'n', 't', 'O', 'r', 'd', 'e', 'r', 0,
    'Q', 'X', 'm', 'l', 'N', 'o', 'd', 'e', 'M', 'o', 'd', 'e', 'l', 'I', 'n', 'd', 'e', 'x', ':', ':', 'N', 'o', 'd', 'e', 'K', 'i', 'n', 'd', 0,
    'P', 'y', 'Q', 't', '4', '.', 'Q', 't', 'C', 'o', 'r', 'e', '.', 'p', 'y', 'q', 't', 'W', 'r', 'a', 'p', 'p', 'e', 'r', 'T', 'y', 'p', 'e', 0,
    'Q', 'V', 'e', 'c', 't', 'o', 'r', '<', 'Q', 'X', 'm', 'l', 'N', 'o', 'd', 'e', 'M', 'o', 'd', 'e', 'l', 'I', 'n', 'd', 'e', 'x', '>', 0,
    'Q', 'X', 'm', 'l', 'Q', 'u', 'e', 'r', 'y', ':', ':', 'Q', 'u', 'e', 'r', 'y', 'L', 'a', 'n', 'g', 'u', 'a', 'g', 'e', 0,
    's', 'e', 't', 'N', 'e', 't', 'w', 'o', 'r', 'k', 'A', 'c', 'c', 'e', 's', 's', 'M', 'a', 'n', 'a', 'g', 'e', 'r', 0,
    'Q', 'A', 'b', 's', 't', 'r', 'a', 'c', 't', 'M', 'e', 's', 's', 'a', 'g', 'e', 'H', 'a', 'n', 'd', 'l', 'e', 'r', 0,
    's', 'e', 't', 'I', 'n', 'i', 't', 'i', 'a', 'l', 'T', 'e', 'm', 'p', 'l', 'a', 't', 'e', 'N', 'a', 'm', 'e', 0,
    'p', 'r', 'o', 'c', 'e', 's', 's', 'i', 'n', 'g', 'I', 'n', 's', 't', 'r', 'u', 'c', 't', 'i', 'o', 'n', 0,
    'Q', 'A', 'b', 's', 't', 'r', 'a', 'c', 't', 'X', 'm', 'l', 'N', 'o', 'd', 'e', 'M', 'o', 'd', 'e', 'l', 0,
    'P', 'r', 'o', 'c', 'e', 's', 's', 'i', 'n', 'g', 'I', 'n', 's', 't', 'r', 'u', 'c', 't', 'i', 'o', 'n', 0,
    'n', 'e', 't', 'w', 'o', 'r', 'k', 'A', 'c', 'c', 'e', 's', 's', 'M', 'a', 'n', 'a', 'g', 'e', 'r', 0,
    'e', 'v', 'a', 'l', 'u', 'a', 't', 'e', 'T', 'o', 'S', 't', 'r', 'i', 'n', 'g', 'L', 'i', 's', 't', 0,
    'Q', 'A', 'b', 's', 't', 'r', 'a', 'c', 't', 'X', 'm', 'l', 'R', 'e', 'c', 'e', 'i', 'v', 'e', 'r', 0,
    'Q', 'A', 'b', 's', 't', 'r', 'a', 'c', 't', 'U', 'r', 'i', 'R', 'e', 's', 'o', 'l', 'v', 'e', 'r', 0,
    'Q', 'X', 'm', 'l', 'S', 'c', 'h', 'e', 'm', 'a', 'V', 'a', 'l', 'i', 'd', 'a', 't', 'o', 'r', 0,
    'i', 'n', 'i', 't', 'i', 'a', 'l', 'T', 'e', 'm', 'p', 'l', 'a', 't', 'e', 'N', 'a', 'm', 'e', 0,
    's', 'e', 't', 'I', 'n', 'd', 'e', 'n', 't', 'a', 't', 'i', 'o', 'n', 'D', 'e', 'p', 't', 'h', 0,
    'Q', 'S', 'i', 'm', 'p', 'l', 'e', 'X', 'm', 'l', 'N', 'o', 'd', 'e', 'M', 'o', 'd', 'e', 'l', 0,
    'P', 'y', 'Q', 't', '4', '.', 'Q', 't', 'X', 'm', 'l', 'P', 'a', 't', 't', 'e', 'r', 'n', 's', 0,
    'n', 'e', 'x', 't', 'F', 'r', 'o', 'm', 'S', 'i', 'm', 'p', 'l', 'e', 'A', 'x', 'i', 's', 0,
    'Q', 'X', 'm', 'l', 'N', 'o', 'd', 'e', 'M', 'o', 'd', 'e', 'l', 'I', 'n', 'd', 'e', 'x', 0,
    'Q', 'V', 'e', 'c', 't', 'o', 'r', '<', 'Q', 'X', 'm', 'l', 'N', 'a', 'm', 'e', '>', 0,
    's', 'e', 't', 'M', 'e', 's', 's', 'a', 'g', 'e', 'H', 'a', 'n', 'd', 'l', 'e', 'r', 0,
    'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', 'B', 'i', 'n', 'd', 'i', 'n', 'g', 's', 0,
    's', 'e', 'n', 'd', 'e', 'r', 'S', 'i', 'g', 'n', 'a', 'l', 'I', 'n', 'd', 'e', 'x', 0,
    's', 'i', 'p', '.', 's', 'i', 'm', 'p', 'l', 'e', 'w', 'r', 'a', 'p', 'p', 'e', 'r', 0,
    'e', 'v', 'a', 'l', 'u', 'a', 't', 'e', 'T', 'o', 'S', 't', 'r', 'i', 'n', 'g', 0,
    'i', 'n', 'd', 'e', 'n', 't', 'a', 't', 'i', 'o', 'n', 'D', 'e', 'p', 't', 'h', 0,
    'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', 'B', 'i', 'n', 'd', 'i', 'n', 'g', 0,
    't', 'o', 'N', 'o', 'd', 'e', 'M', 'o', 'd', 'e', 'l', 'I', 'n', 'd', 'e', 'x', 0,
    'd', 'i', 's', 'c', 'o', 'n', 'n', 'e', 'c', 't', 'N', 'o', 't', 'i', 'f', 'y', 0,
    'Q', 'X', 'm', 'l', 'R', 'e', 's', 'u', 'l', 't', 'I', 't', 'e', 'm', 's', 0,
    'Q', 'S', 'o', 'u', 'r', 'c', 'e', 'L', 'o', 'c', 'a', 't', 'i', 'o', 'n', 0,
    's', 't', 'a', 'r', 't', 'O', 'f', 'S', 'e', 'q', 'u', 'e', 'n', 'c', 'e', 0,
    'P', 'r', 'e', 'v', 'i', 'o', 'u', 's', 'S', 'i', 'b', 'l', 'i', 'n', 'g', 0,
    'i', 'n', 't', 'e', 'r', 'n', 'a', 'l', 'P', 'o', 'i', 'n', 't', 'e', 'r', 0,
    's', 'e', 't', 'U', 'r', 'i', 'R', 'e', 's', 'o', 'l', 'v', 'e', 'r', 0,
    'm', 'e', 's', 's', 'a', 'g', 'e', 'H', 'a', 'n', 'd', 'l', 'e', 'r', 0,
    'Q', 'X', 'm', 'l', 'S', 'e', 'r', 'i', 'a', 'l', 'i', 'z', 'e', 'r', 0,
    'a', 'd', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'D', 'a', 't', 'a', 0,
    's', 'o', 'u', 'r', 'c', 'e', 'L', 'o', 'c', 'a', 't', 'i', 'o', 'n', 0,
    'q', 'u', 'e', 'r', 'y', 'L', 'a', 'n', 'g', 'u', 'a', 'g', 'e', 0,
    'f', 'r', 'o', 'm', 'C', 'l', 'a', 'r', 'k', 'N', 'a', 'm', 'e', 0,
    'Q', 'X', 'm', 'l', 'F', 'o', 'r', 'm', 'a', 't', 't', 'e', 'r', 0,
    'e', 'n', 'd', 'O', 'f', 'S', 'e', 'q', 'u', 'e', 'n', 'c', 'e', 0,
    's', 't', 'a', 'r', 't', 'D', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0,
    't', 'o', 'A', 't', 'o', 'm', 'i', 'c', 'V', 'a', 'l', 'u', 'e', 0,
    'i', 's', 'A', 't', 'o', 'm', 'i', 'c', 'V', 'a', 'l', 'u', 'e', 0,
    'h', 'a', 'n', 'd', 'l', 'e', 'M', 'e', 's', 's', 'a', 'g', 'e', 0,
    'b', 'i', 'n', 'd', 'V', 'a', 'r', 'i', 'a', 'b', 'l', 'e', 0,
    'Q', 'X', 'm', 'l', 'N', 'a', 'm', 'e', 'P', 'o', 'o', 'l', 0,
    'o', 'u', 't', 'p', 'u', 't', 'D', 'e', 'v', 'i', 'c', 'e', 0,
    's', 't', 'a', 'r', 't', 'E', 'l', 'e', 'm', 'e', 'n', 't', 0,
    'n', 'o', 'd', 'e', 's', 'B', 'y', 'I', 'd', 'r', 'e', 'f', 0,
    'c', 'o', 'm', 'p', 'a', 'r', 'e', 'O', 'r', 'd', 'e', 'r', 0,
    'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', 'U', 'r', 'i', 0,
    'u', 'r', 'i', 'R', 'e', 's', 'o', 'l', 'v', 'e', 'r', 0,
    't', 'o', 'C', 'l', 'a', 'r', 'k', 'N', 'a', 'm', 'e', 0,
    'e', 'n', 'd', 'D', 'o', 'c', 'u', 'm', 'e', 'n', 't', 0,
    'a', 't', 'o', 'm', 'i', 'c', 'V', 'a', 'l', 'u', 'e', 0,
    'e', 'l', 'e', 'm', 'e', 'n', 't', 'B', 'y', 'I', 'd', 0,
    's', 't', 'r', 'i', 'n', 'g', 'V', 'a', 'l', 'u', 'e', 0,
    'd', 'o', 'c', 'u', 'm', 'e', 'n', 't', 'U', 'r', 'i', 0,
    'N', 'e', 'x', 't', 'S', 'i', 'b', 'l', 'i', 'n', 'g', 0,
    'c', 'u', 's', 't', 'o', 'm', 'E', 'v', 'e', 'n', 't', 0,
    'e', 'v', 'e', 'n', 't', 'F', 'i', 'l', 't', 'e', 'r', 0,
    'c', 'r', 'e', 'a', 't', 'e', 'I', 'n', 'd', 'e', 'x', 0,
    'Q', 'X', 'm', 'l', 'S', 'c', 'h', 'e', 'm', 'a', 0,
    'e', 'v', 'a', 'l', 'u', 'a', 't', 'e', 'T', 'o', 0,
    'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', 0,
    'e', 'n', 'd', 'E', 'l', 'e', 'm', 'e', 'n', 't', 0,
    't', 'y', 'p', 'e', 'd', 'V', 'a', 'l', 'u', 'e', 0,
    'F', 'i', 'r', 's', 't', 'C', 'h', 'i', 'l', 'd', 0,
    'i', 'd', 'e', 'n', 't', 'i', 'f', 'i', 'e', 'r', 0,
    'a', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 's', 0,
    'f', 'i', 'e', 'l', 'd', 'W', 'i', 'd', 't', 'h', 0,
    'c', 'h', 'i', 'l', 'd', 'E', 'v', 'e', 'n', 't', 0,
    't', 'i', 'm', 'e', 'r', 'E', 'v', 'e', 'n', 't', 0,
    's', 'e', 't', 'S', 'c', 'h', 'e', 'm', 'a', 0,
    'Q', 'X', 'm', 'l', 'Q', 'u', 'e', 'r', 'y', 0,
    'l', 'o', 'c', 'a', 'l', 'N', 'a', 'm', 'e', 0,
    's', 'e', 't', 'C', 'o', 'l', 'u', 'm', 'n', 0,
    'N', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', 0,
    'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 0,
    'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', 0,
    'r', 'e', 'c', 'e', 'i', 'v', 'e', 'r', 's', 0,
    'a', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 0,
    'p', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 0,
    'v', 'a', 'l', 'i', 'd', 'a', 't', 'e', 0,
    's', 'e', 't', 'F', 'o', 'c', 'u', 's', 0,
    's', 'e', 't', 'Q', 'u', 'e', 'r', 'y', 0,
    'X', 'Q', 'u', 'e', 'r', 'y', '1', '0', 0,
    'i', 's', 'N', 'C', 'N', 'a', 'm', 'e', 0,
    'Q', 'X', 'm', 'l', 'N', 'a', 'm', 'e', 0,
    'n', 'a', 'm', 'e', 'P', 'o', 'o', 'l', 0,
    'Q', 'X', 'm', 'l', 'I', 't', 'e', 'm', 0,
    'P', 'r', 'e', 'c', 'e', 'd', 'e', 's', 0,
    'h', 'a', 's', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'e', 't', 'C', 'o', 'd', 'e', 'c', 0,
    'b', 'e', 'h', 'a', 'v', 'i', 'o', 'r', 0,
    'f', 'i', 'l', 'l', 'C', 'h', 'a', 'r', 0,
    '_', '_', 'h', 'a', 's', 'h', '_', '_', 0,
    'b', 'a', 's', 'e', 'U', 'r', 'i', 0,
    'F', 'o', 'l', 'l', 'o', 'w', 's', 0,
    'C', 'o', 'm', 'm', 'e', 'n', 't', 0,
    'c', 'o', 'm', 'm', 'e', 'n', 't', 0,
    's', 'e', 't', 'L', 'i', 'n', 'e', 0,
    'r', 'e', 's', 'o', 'l', 'v', 'e', 0,
    'c', 'u', 'r', 'r', 'e', 'n', 't', 0,
    'e', 'n', 'a', 'b', 'l', 'e', 'd', 0,
    'i', 's', 'V', 'a', 'l', 'i', 'd', 0,
    'f', 'i', 'l', 't', 'e', 'r', 's', 0,
    'm', 'e', 's', 's', 'a', 'g', 'e', 0,
    'Q', 'S', 't', 'r', 'i', 'n', 'g', 0,
    's', 'c', 'h', 'e', 'm', 'a', 0,
    'X', 'S', 'L', 'T', '2', '0', 0,
    's', 'e', 't', 'U', 'r', 'i', 0,
    'i', 's', 'N', 'o', 'd', 'e', 0,
    'P', 'a', 'r', 'e', 'n', 't', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 0,
    's', 'e', 'n', 'd', 'e', 'r', 0,
    'v', 'a', 'l', 'u', 'e', '9', 0,
    'v', 'a', 'l', 'u', 'e', '8', 0,
    'v', 'a', 'l', 'u', 'e', '7', 0,
    'v', 'a', 'l', 'u', 'e', '6', 0,
    'v', 'a', 'l', 'u', 'e', '5', 0,
    'v', 'a', 'l', 'u', 'e', '4', 0,
    'v', 'a', 'l', 'u', 'e', '3', 0,
    'v', 'a', 'l', 'u', 'e', '0', 0,
    's', 'y', 'm', 'b', 'o', 'l', 0,
    's', 'u', 'f', 'f', 'i', 'x', 0,
    'p', 'r', 'e', 'f', 'i', 'x', 0,
    'd', 'e', 'v', 'i', 'c', 'e', 0,
    'f', 'o', 'r', 'm', 'a', 't', 0,
    'v', 'a', 'l', 'u', 'e', '2', 0,
    'v', 'a', 'l', 'u', 'e', '1', 0,
    'i', 's', 'N', 'u', 'l', 'l', 0,
    'c', 'o', 'l', 'u', 'm', 'n', 0,
    'o', 'b', 'j', 'e', 'c', 't', 0,
    'p', 'a', 'r', 'e', 'n', 't', 0,
    '_', '_', 'n', 'e', '_', '_', 0,
    '_', '_', 'e', 'q', '_', '_', 0,
    'c', 'o', 'd', 'e', 'c', 0,
    'm', 'o', 'd', 'e', 'l', 0,
    'f', 'l', 'a', 'g', 's', 0,
    'e', 'v', 'e', 'n', 't', 0,
    'm', 's', 'e', 'c', 's', 0,
    'p', 'o', 'o', 'l', 0,
    'k', 'i', 'n', 'd', 0,
    'p', 'o', 'r', 't', 0,
    'l', 'i', 'n', 'e', 0,
    'l', 'o', 'a', 'd', 0,
    'm', 'o', 'd', 'e', 0,
    'T', 'e', 'x', 't', 0,
    'r', 'o', 'o', 't', 0,
    'n', 'a', 'm', 'e', 0,
    'b', 'a', 's', 'e', 0,
    'f', 'r', 'o', 'm', 0,
    's', 'o', 'r', 't', 0,
    'n', 'e', 'x', 't', 0,
    'd', 'a', 't', 'a', 0,
    't', 'y', 'p', 'e', 0,
    'u', 'r', 'i', 0,
    'e', 'n', 'd', 0,
    'I', 's', 0,
    't', 'o', 0,
};

void sipVH_QtXmlPatterns_0(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlName& a0,const QString& a1)
{
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "NN",new QXmlName(a0),sipType_QXmlName,NULL,new QString(a1),sipType_QString,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "Z");
}

void sipVH_QtXmlPatterns_1(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlName& a0,const QStringRef& a1)
{
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "NN",new QXmlName(a0),sipType_QXmlName,NULL,new QStringRef(a1),sipType_QStringRef,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "Z");
}

void sipVH_QtXmlPatterns_2(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlName& a0)
{
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QXmlName(a0),sipType_QXmlName,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "Z");
}

void sipVH_QtXmlPatterns_3(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QStringRef& a0)
{
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QStringRef(a0),sipType_QStringRef,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "Z");
}

QVector<QXmlNodeModelIndex> sipVH_QtXmlPatterns_4(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlName& a0)
{
    QVector<QXmlNodeModelIndex> sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QXmlName(a0),sipType_QXmlName,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QVector_0100QXmlNodeModelIndex, &sipRes);

    return sipRes;
}

QXmlNodeModelIndex sipVH_QtXmlPatterns_5(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlName& a0)
{
    QXmlNodeModelIndex sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QXmlName(a0),sipType_QXmlName,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QXmlNodeModelIndex, &sipRes);

    return sipRes;
}

QString sipVH_QtXmlPatterns_6(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlNodeModelIndex& a0)
{
    QString sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QXmlNodeModelIndex(a0),sipType_QXmlNodeModelIndex,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QString, &sipRes);

    return sipRes;
}

QVector<QXmlName> sipVH_QtXmlPatterns_7(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlNodeModelIndex& a0)
{
    QVector<QXmlName> sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QXmlNodeModelIndex(a0),sipType_QXmlNodeModelIndex,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QVector_0100QXmlName, &sipRes);

    return sipRes;
}

QUrl sipVH_QtXmlPatterns_8(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlNodeModelIndex& a0)
{
    QUrl sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QXmlNodeModelIndex(a0),sipType_QXmlNodeModelIndex,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QUrl, &sipRes);

    return sipRes;
}

QVector<QXmlNodeModelIndex> sipVH_QtXmlPatterns_9(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlNodeModelIndex& a0)
{
    QVector<QXmlNodeModelIndex> sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QXmlNodeModelIndex(a0),sipType_QXmlNodeModelIndex,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QVector_0100QXmlNodeModelIndex, &sipRes);

    return sipRes;
}

QXmlNodeModelIndex sipVH_QtXmlPatterns_10(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, QAbstractXmlNodeModel::SimpleAxis a0,const QXmlNodeModelIndex& a1)
{
    QXmlNodeModelIndex sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "FN",a0,sipType_QAbstractXmlNodeModel_SimpleAxis,new QXmlNodeModelIndex(a1),sipType_QXmlNodeModelIndex,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QXmlNodeModelIndex, &sipRes);

    return sipRes;
}

QVariant sipVH_QtXmlPatterns_11(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlNodeModelIndex& a0)
{
    QVariant sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QXmlNodeModelIndex(a0),sipType_QXmlNodeModelIndex,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QVariant, &sipRes);

    return sipRes;
}

QXmlName sipVH_QtXmlPatterns_12(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlNodeModelIndex& a0)
{
    QXmlName sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QXmlNodeModelIndex(a0),sipType_QXmlNodeModelIndex,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QXmlName, &sipRes);

    return sipRes;
}

QXmlNodeModelIndex sipVH_QtXmlPatterns_13(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlNodeModelIndex& a0)
{
    QXmlNodeModelIndex sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QXmlNodeModelIndex(a0),sipType_QXmlNodeModelIndex,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QXmlNodeModelIndex, &sipRes);

    return sipRes;
}

QXmlNodeModelIndex::DocumentOrder sipVH_QtXmlPatterns_14(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlNodeModelIndex& a0,const QXmlNodeModelIndex& a1)
{
    QXmlNodeModelIndex::DocumentOrder sipRes = (QXmlNodeModelIndex::DocumentOrder)0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "NN",new QXmlNodeModelIndex(a0),sipType_QXmlNodeModelIndex,NULL,new QXmlNodeModelIndex(a1),sipType_QXmlNodeModelIndex,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "F", sipType_QXmlNodeModelIndex_DocumentOrder, &sipRes);

    return sipRes;
}

QXmlNodeModelIndex::NodeKind sipVH_QtXmlPatterns_15(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QXmlNodeModelIndex& a0)
{
    QXmlNodeModelIndex::NodeKind sipRes = (QXmlNodeModelIndex::NodeKind)0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QXmlNodeModelIndex(a0),sipType_QXmlNodeModelIndex,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "F", sipType_QXmlNodeModelIndex_NodeKind, &sipRes);

    return sipRes;
}

QUrl sipVH_QtXmlPatterns_16(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QUrl& a0,const QUrl& a1)
{
    QUrl sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "NN",new QUrl(a0),sipType_QUrl,NULL,new QUrl(a1),sipType_QUrl,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QUrl, &sipRes);

    return sipRes;
}

void sipVH_QtXmlPatterns_17(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, QtMsgType a0,const QString& a1,const QUrl& a2,const QSourceLocation& a3)
{
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "FNNN",a0,sipType_QtMsgType,new QString(a1),sipType_QString,NULL,new QUrl(a2),sipType_QUrl,NULL,new QSourceLocation(a3),sipType_QSourceLocation,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "Z");
}


/* Convert to a sub-class if possible. */
extern "C" {static const sipTypeDef *sipSubClass_QAbstractMessageHandler(void **);}
static const sipTypeDef *sipSubClass_QAbstractMessageHandler(void **sipCppRet)
{
    QObject *sipCpp = reinterpret_cast<QObject *>(*sipCppRet);
    const sipTypeDef *sipType;

#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractmessagehandler.sip"
    static struct class_graph {
            const char *name;
            sipTypeDef **type;
            int yes, no;
        } graph[] = {
            {sipName_QAbstractUriResolver,	&sipType_QAbstractUriResolver,	-1, 1},
            {sipName_QAbstractMessageHandler,	&sipType_QAbstractMessageHandler,	-1, -1},
        };
    
        int i = 0;
    
        sipType = 0;
    
        do
        {
            struct class_graph *cg = &graph[i];
    
            if (cg->name != NULL && sipCpp->inherits(cg->name))
            {
                sipType = *cg->type;
                i = cg->yes;
            }
            else
                i = cg->no;
        }
        while (i >= 0);
#line 447 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

    return sipType;
}
static sipEnumTypeDef enumTypes[] = {
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QXmlQuery__QueryLanguage, {0}}, sipNameNr_QueryLanguage, 16, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QAbstractXmlNodeModel__SimpleAxis, {0}}, sipNameNr_SimpleAxis, 2, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QXmlNodeModelIndex__DocumentOrder, {0}}, sipNameNr_DocumentOrder, 13, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QXmlNodeModelIndex__NodeKind, {0}}, sipNameNr_NodeKind, 13, NULL},
};


/*
 * This defines each type in this module.
 */
static sipTypeDef *typesTable[] = {
    &sipTypeDef_QtXmlPatterns_QAbstractMessageHandler.super.ctd_base,
    &sipTypeDef_QtXmlPatterns_QAbstractUriResolver.super.ctd_base,
    &sipTypeDef_QtXmlPatterns_QAbstractXmlNodeModel.super.ctd_base,
    &enumTypes[1].etd_base,
    &sipTypeDef_QtXmlPatterns_QAbstractXmlReceiver.super.ctd_base,
    &sipTypeDef_QtXmlPatterns_QSimpleXmlNodeModel.super.ctd_base,
    &sipTypeDef_QtXmlPatterns_QSourceLocation.super.ctd_base,
    &sipTypeDef_QtXmlPatterns_QVector_0100QXmlName.mtd_base,
    &sipTypeDef_QtXmlPatterns_QVector_0100QXmlNodeModelIndex.mtd_base,
    &sipTypeDef_QtXmlPatterns_QXmlFormatter.super.ctd_base,
    &sipTypeDef_QtXmlPatterns_QXmlItem.super.ctd_base,
    &sipTypeDef_QtXmlPatterns_QXmlName.super.ctd_base,
    &sipTypeDef_QtXmlPatterns_QXmlNamePool.super.ctd_base,
    &sipTypeDef_QtXmlPatterns_QXmlNodeModelIndex.super.ctd_base,
    &enumTypes[2].etd_base,
    &enumTypes[3].etd_base,
    &sipTypeDef_QtXmlPatterns_QXmlQuery.super.ctd_base,
    &enumTypes[0].etd_base,
    &sipTypeDef_QtXmlPatterns_QXmlResultItems.super.ctd_base,
    &sipTypeDef_QtXmlPatterns_QXmlSchema.super.ctd_base,
    &sipTypeDef_QtXmlPatterns_QXmlSchemaValidator.super.ctd_base,
    &sipTypeDef_QtXmlPatterns_QXmlSerializer.super.ctd_base,
};


/*
 * This defines the virtual handlers that this module implements and can be
 * used by other modules.
 */
static sipVirtHandlerFunc virtHandlersTable[] = {
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_0,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_1,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_2,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_3,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_4,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_5,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_6,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_7,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_8,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_9,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_10,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_11,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_12,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_13,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_14,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_15,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_16,
    (sipVirtHandlerFunc)sipVH_QtXmlPatterns_17,
};


/* This defines the modules that this module needs to import. */
static sipImportedModuleDef importsTable[] = {
    {"PyQt4.QtCore", 1, NULL},
    {"PyQt4.QtNetwork", -1, NULL},
    {NULL, -1, NULL}
};


/* This defines the class sub-convertors that this module defines. */
static sipSubClassConvertorDef convertorsTable[] = {
    {sipSubClass_QAbstractMessageHandler, {141, 0, 0}, NULL},
    {NULL, {0, 0, 0}, NULL}
};


/* This defines the API versions and ranges in use. */
static int apiVersions[] = {sipNameNr_QString, 0, 2, -1};


/* This defines this module. */
sipExportedModuleDef sipModuleAPI_QtXmlPatterns = {
    0,
    SIP_API_MINOR_NR,
    sipNameNr_PyQt4_QtXmlPatterns,
    0,
    -1,
    sipStrings_QtXmlPatterns,
    importsTable,
    NULL,
    22,
    typesTable,
    NULL,
    0,
    NULL,
    0,
    NULL,
    virtHandlersTable,
    NULL,
    convertorsTable,
    {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    apiVersions,
    NULL
};


/* The SIP API and the APIs of any imported modules. */
const sipAPIDef *sipAPI_QtXmlPatterns;
const sipExportedModuleDef *sipModuleAPI_QtXmlPatterns_QtCore;
const sipExportedModuleDef *sipModuleAPI_QtXmlPatterns_QtNetwork;

sip_qt_metaobject_func sip_QtXmlPatterns_qt_metaobject;
sip_qt_metacall_func sip_QtXmlPatterns_qt_metacall;
sip_qt_metacast_func sip_QtXmlPatterns_qt_metacast;


/* The Python module initialisation function. */
#if PY_MAJOR_VERSION >= 3
#define SIP_MODULE_ENTRY        PyInit_QtXmlPatterns
#define SIP_MODULE_TYPE         PyObject *
#define SIP_MODULE_DISCARD(r)   Py_DECREF(r)
#define SIP_MODULE_RETURN(r)    return (r)
#else
#define SIP_MODULE_ENTRY        initQtXmlPatterns
#define SIP_MODULE_TYPE         void
#define SIP_MODULE_DISCARD(r)
#define SIP_MODULE_RETURN(r)    return
#endif

#if defined(SIP_STATIC_MODULE)
extern "C" SIP_MODULE_TYPE SIP_MODULE_ENTRY()
#else
PyMODINIT_FUNC SIP_MODULE_ENTRY()
#endif
{
    static PyMethodDef sip_methods[] = {
        {0, 0, 0, 0}
    };

#if PY_MAJOR_VERSION >= 3
    static PyModuleDef sip_module_def = {
        PyModuleDef_HEAD_INIT,
        "PyQt4.QtXmlPatterns",
        NULL,
        -1,
        sip_methods,
        NULL,
        NULL,
        NULL,
        NULL
    };
#endif

    PyObject *sipModule, *sipModuleDict;
    PyObject *sip_sipmod, *sip_capiobj;

    /* Initialise the module and get it's dictionary. */
#if PY_MAJOR_VERSION >= 3
    sipModule = PyModule_Create(&sip_module_def);
#elif PY_VERSION_HEX >= 0x02050000
    sipModule = Py_InitModule(sipName_PyQt4_QtXmlPatterns, sip_methods);
#else
    sipModule = Py_InitModule(const_cast<char *>(sipName_PyQt4_QtXmlPatterns), sip_methods);
#endif

    if (sipModule == NULL)
        SIP_MODULE_RETURN(NULL);

    sipModuleDict = PyModule_GetDict(sipModule);

    /* Get the SIP module's API. */
#if PY_VERSION_HEX >= 0x02050000
    sip_sipmod = PyImport_ImportModule(SIP_MODULE_NAME);
#else
    sip_sipmod = PyImport_ImportModule(const_cast<char *>(SIP_MODULE_NAME));
#endif

    if (sip_sipmod == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

    sip_capiobj = PyDict_GetItemString(PyModule_GetDict(sip_sipmod), "_C_API");
    Py_DECREF(sip_sipmod);

#if defined(SIP_USE_PYCAPSULE)
    if (sip_capiobj == NULL || !PyCapsule_CheckExact(sip_capiobj))
#else
    if (sip_capiobj == NULL || !PyCObject_Check(sip_capiobj))
#endif
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

#if defined(SIP_USE_PYCAPSULE)
    sipAPI_QtXmlPatterns = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, SIP_MODULE_NAME "._C_API"));
#else
    sipAPI_QtXmlPatterns = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif

#if defined(SIP_USE_PYCAPSULE)
    if (sipAPI_QtXmlPatterns == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }
#endif

    /* Export the module and publish it's API. */
    if (sipExportModule(&sipModuleAPI_QtXmlPatterns,SIP_API_MAJOR_NR,SIP_API_MINOR_NR,0) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    sip_QtXmlPatterns_qt_metaobject = (sip_qt_metaobject_func)sipImportSymbol("qtcore_qt_metaobject");
    sip_QtXmlPatterns_qt_metacall = (sip_qt_metacall_func)sipImportSymbol("qtcore_qt_metacall");
    sip_QtXmlPatterns_qt_metacast = (sip_qt_metacast_func)sipImportSymbol("qtcore_qt_metacast");

    if (!sip_QtXmlPatterns_qt_metacast)
        Py_FatalError("Unable to import qtcore_qt_metacast");

    /* Initialise the module now all its dependencies have been set up. */
    if (sipInitModule(&sipModuleAPI_QtXmlPatterns,sipModuleDict) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    /* Get the APIs of the modules that this one is dependent on. */
    sipModuleAPI_QtXmlPatterns_QtCore = sipModuleAPI_QtXmlPatterns.em_imports[0].im_module;
    sipModuleAPI_QtXmlPatterns_QtNetwork = sipModuleAPI_QtXmlPatterns.em_imports[1].im_module;

    SIP_MODULE_RETURN(sipModule);
}

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvector.sip"
#include <qvector.h>
#line 699 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 703 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


extern "C" {static void assign_QVector_0100QXmlNodeModelIndex(void *, SIP_SSIZE_T, const void *);}
static void assign_QVector_0100QXmlNodeModelIndex(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QVector<QXmlNodeModelIndex> *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QVector<QXmlNodeModelIndex> *>(sipSrc);
}


extern "C" {static void *array_QVector_0100QXmlNodeModelIndex(SIP_SSIZE_T);}
static void *array_QVector_0100QXmlNodeModelIndex(SIP_SSIZE_T sipNrElem)
{
    return new QVector<QXmlNodeModelIndex>[sipNrElem];
}


extern "C" {static void *copy_QVector_0100QXmlNodeModelIndex(const void *, SIP_SSIZE_T);}
static void *copy_QVector_0100QXmlNodeModelIndex(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QVector<QXmlNodeModelIndex>(reinterpret_cast<const QVector<QXmlNodeModelIndex> *>(sipSrc)[sipSrcIdx]);
}


/* Call the mapped type's destructor. */
extern "C" {static void release_QVector_0100QXmlNodeModelIndex(void *, int);}
static void release_QVector_0100QXmlNodeModelIndex(void *ptr, int)
{
    Py_BEGIN_ALLOW_THREADS
    delete reinterpret_cast<QVector<QXmlNodeModelIndex> *>(ptr);
    Py_END_ALLOW_THREADS
}



extern "C" {static int convertTo_QVector_0100QXmlNodeModelIndex(PyObject *, void **, int *, PyObject *);}
static int convertTo_QVector_0100QXmlNodeModelIndex(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QVector<QXmlNodeModelIndex> **sipCppPtr = reinterpret_cast<QVector<QXmlNodeModelIndex> **>(sipCppPtrV);

#line 64 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvector.sip"
    // Check the type if that is all that is required.
    if (sipIsErr == NULL)
    {
        if (!PyList_Check(sipPy))
            return 0;

        for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i)
            if (!sipCanConvertToType(PyList_GET_ITEM(sipPy, i), sipType_QXmlNodeModelIndex, SIP_NOT_NONE))
                return 0;

        return 1;
    }

    QVector<QXmlNodeModelIndex> *qv = new QVector<QXmlNodeModelIndex>;
 
    for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i)
    {
        int state;
        QXmlNodeModelIndex *t = reinterpret_cast<QXmlNodeModelIndex *>(sipConvertToType(PyList_GET_ITEM(sipPy, i), sipType_QXmlNodeModelIndex, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
 
        if (*sipIsErr)
        {
            sipReleaseType(t, sipType_QXmlNodeModelIndex, state);

            delete qv;
            return 0;
        }

        qv->append(*t);

        sipReleaseType(t, sipType_QXmlNodeModelIndex, state);
    }
 
    *sipCppPtr = qv;
 
    return sipGetState(sipTransferObj);
#line 780 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
}


extern "C" {static PyObject *convertFrom_QVector_0100QXmlNodeModelIndex(void *, PyObject *);}
static PyObject *convertFrom_QVector_0100QXmlNodeModelIndex(void *sipCppV, PyObject *sipTransferObj)
{
   QVector<QXmlNodeModelIndex> *sipCpp = reinterpret_cast<QVector<QXmlNodeModelIndex> *>(sipCppV);

#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvector.sip"
    // Create the list.
    PyObject *l;

    if ((l = PyList_New(sipCpp->size())) == NULL)
        return NULL;

    // Set the list elements.
    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QXmlNodeModelIndex *t = new QXmlNodeModelIndex(sipCpp->at(i));
        PyObject *tobj;

        if ((tobj = sipConvertFromNewType(t, sipType_QXmlNodeModelIndex, sipTransferObj)) == NULL)
        {
            Py_DECREF(l);
            delete t;

            return NULL;
        }

        PyList_SET_ITEM(l, i, tobj);
    }

    return l;
#line 814 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtXmlPatterns_QVector_0100QXmlNodeModelIndex = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_126,
        {0}
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QVector_0100QXmlNodeModelIndex,
    array_QVector_0100QXmlNodeModelIndex,
    copy_QVector_0100QXmlNodeModelIndex,
    release_QVector_0100QXmlNodeModelIndex,
    convertTo_QVector_0100QXmlNodeModelIndex,
    convertFrom_QVector_0100QXmlNodeModelIndex
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvector.sip"
#include <qvector.h>
#line 845 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlname.sip"
#include <qxmlname.h>
#line 849 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


extern "C" {static void assign_QVector_0100QXmlName(void *, SIP_SSIZE_T, const void *);}
static void assign_QVector_0100QXmlName(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QVector<QXmlName> *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QVector<QXmlName> *>(sipSrc);
}


extern "C" {static void *array_QVector_0100QXmlName(SIP_SSIZE_T);}
static void *array_QVector_0100QXmlName(SIP_SSIZE_T sipNrElem)
{
    return new QVector<QXmlName>[sipNrElem];
}


extern "C" {static void *copy_QVector_0100QXmlName(const void *, SIP_SSIZE_T);}
static void *copy_QVector_0100QXmlName(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QVector<QXmlName>(reinterpret_cast<const QVector<QXmlName> *>(sipSrc)[sipSrcIdx]);
}


/* Call the mapped type's destructor. */
extern "C" {static void release_QVector_0100QXmlName(void *, int);}
static void release_QVector_0100QXmlName(void *ptr, int)
{
    Py_BEGIN_ALLOW_THREADS
    delete reinterpret_cast<QVector<QXmlName> *>(ptr);
    Py_END_ALLOW_THREADS
}



extern "C" {static int convertTo_QVector_0100QXmlName(PyObject *, void **, int *, PyObject *);}
static int convertTo_QVector_0100QXmlName(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QVector<QXmlName> **sipCppPtr = reinterpret_cast<QVector<QXmlName> **>(sipCppPtrV);

#line 64 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvector.sip"
    // Check the type if that is all that is required.
    if (sipIsErr == NULL)
    {
        if (!PyList_Check(sipPy))
            return 0;

        for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i)
            if (!sipCanConvertToType(PyList_GET_ITEM(sipPy, i), sipType_QXmlName, SIP_NOT_NONE))
                return 0;

        return 1;
    }

    QVector<QXmlName> *qv = new QVector<QXmlName>;
 
    for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i)
    {
        int state;
        QXmlName *t = reinterpret_cast<QXmlName *>(sipConvertToType(PyList_GET_ITEM(sipPy, i), sipType_QXmlName, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
 
        if (*sipIsErr)
        {
            sipReleaseType(t, sipType_QXmlName, state);

            delete qv;
            return 0;
        }

        qv->append(*t);

        sipReleaseType(t, sipType_QXmlName, state);
    }
 
    *sipCppPtr = qv;
 
    return sipGetState(sipTransferObj);
#line 926 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
}


extern "C" {static PyObject *convertFrom_QVector_0100QXmlName(void *, PyObject *);}
static PyObject *convertFrom_QVector_0100QXmlName(void *sipCppV, PyObject *sipTransferObj)
{
   QVector<QXmlName> *sipCpp = reinterpret_cast<QVector<QXmlName> *>(sipCppV);

#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvector.sip"
    // Create the list.
    PyObject *l;

    if ((l = PyList_New(sipCpp->size())) == NULL)
        return NULL;

    // Set the list elements.
    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QXmlName *t = new QXmlName(sipCpp->at(i));
        PyObject *tobj;

        if ((tobj = sipConvertFromNewType(t, sipType_QXmlName, sipTransferObj)) == NULL)
        {
            Py_DECREF(l);
            delete t;

            return NULL;
        }

        PyList_SET_ITEM(l, i, tobj);
    }

    return l;
#line 960 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtXmlPatterns_QVector_0100QXmlName = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_538,
        {0}
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QVector_0100QXmlName,
    array_QVector_0100QXmlName,
    copy_QVector_0100QXmlName,
    release_QVector_0100QXmlName,
    convertTo_QVector_0100QXmlName,
    convertFrom_QVector_0100QXmlName
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlschemavalidator.sip"
#include <qxmlschemavalidator.h>
#line 991 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlschema.sip"
#include <qxmlschema.h>
#line 995 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtNetwork/qnetworkaccessmanager.sip"
#include <qnetworkaccessmanager.h>
#line 998 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstracturiresolver.sip"
#include <qabstracturiresolver.h>
#line 1001 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractmessagehandler.sip"
#include <qabstractmessagehandler.h>
#line 1004 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlnamepool.sip"
#include <qxmlnamepool.h>
#line 1007 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 107 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qurl.sip"
#include <qurl.h>
#line 1010 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qiodevice.sip"
#include <qiodevice.h>
#line 1013 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 1016 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


PyDoc_STRVAR(doc_QXmlSchemaValidator_setSchema, "QXmlSchemaValidator.setSchema(QXmlSchema)");

extern "C" {static PyObject *meth_QXmlSchemaValidator_setSchema(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchemaValidator_setSchema(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSchema* a0;
        QXmlSchemaValidator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QXmlSchemaValidator, &sipCpp, sipType_QXmlSchema, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setSchema(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchemaValidator, sipName_setSchema, doc_QXmlSchemaValidator_setSchema);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchemaValidator_validate, "QXmlSchemaValidator.validate(QUrl) -> bool\n"
    "QXmlSchemaValidator.validate(QIODevice, QUrl documentUri=QUrl()) -> bool\n"
    "QXmlSchemaValidator.validate(QByteArray, QUrl documentUri=QUrl()) -> bool");

extern "C" {static PyObject *meth_QXmlSchemaValidator_validate(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QXmlSchemaValidator_validate(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QUrl* a0;
        const QXmlSchemaValidator *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QXmlSchemaValidator, &sipCpp, sipType_QUrl, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->validate(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    {
        QIODevice* a0;
        const QUrl& a1def = QUrl();
        const QUrl* a1 = &a1def;
        const QXmlSchemaValidator *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_documentUri,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ8|J9", &sipSelf, sipType_QXmlSchemaValidator, &sipCpp, sipType_QIODevice, &a0, sipType_QUrl, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->validate(a0,*a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    {
        const QByteArray* a0;
        int a0State = 0;
        const QUrl& a1def = QUrl();
        const QUrl* a1 = &a1def;
        const QXmlSchemaValidator *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_documentUri,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|J9", &sipSelf, sipType_QXmlSchemaValidator, &sipCpp, sipType_QByteArray, &a0, &a0State, sipType_QUrl, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->validate(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QByteArray *>(a0),sipType_QByteArray,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchemaValidator, sipName_validate, doc_QXmlSchemaValidator_validate);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchemaValidator_namePool, "QXmlSchemaValidator.namePool() -> QXmlNamePool");

extern "C" {static PyObject *meth_QXmlSchemaValidator_namePool(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchemaValidator_namePool(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSchemaValidator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSchemaValidator, &sipCpp))
        {
            QXmlNamePool*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNamePool(sipCpp->namePool());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNamePool,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchemaValidator, sipName_namePool, doc_QXmlSchemaValidator_namePool);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchemaValidator_schema, "QXmlSchemaValidator.schema() -> QXmlSchema");

extern "C" {static PyObject *meth_QXmlSchemaValidator_schema(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchemaValidator_schema(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSchemaValidator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSchemaValidator, &sipCpp))
        {
            QXmlSchema*sipRes = 0;

#line 47 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlschemavalidator.sip"
        // For reasons we don't quite understand QXmlSchema's copy ctor has to be
        // private as far as sip is concerned - otherwise we get compiler errors.
        // However that means that sip generates the wrong code here, because it
        // doesn't realise it can take a copy of the result.
        
        Py_BEGIN_ALLOW_THREADS
        sipRes = new QXmlSchema(sipCpp->schema());
        Py_END_ALLOW_THREADS
#line 1180 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

            return sipConvertFromType(sipRes,sipType_QXmlSchema,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchemaValidator, sipName_schema, doc_QXmlSchemaValidator_schema);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchemaValidator_setMessageHandler, "QXmlSchemaValidator.setMessageHandler(QAbstractMessageHandler)");

extern "C" {static PyObject *meth_QXmlSchemaValidator_setMessageHandler(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchemaValidator_setMessageHandler(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QAbstractMessageHandler* a0;
        PyObject *a0Keep;
        QXmlSchemaValidator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QXmlSchemaValidator, &sipCpp, &a0Keep, sipType_QAbstractMessageHandler, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setMessageHandler(a0);
            Py_END_ALLOW_THREADS

            sipKeepReference(sipSelf, -8, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchemaValidator, sipName_setMessageHandler, doc_QXmlSchemaValidator_setMessageHandler);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchemaValidator_messageHandler, "QXmlSchemaValidator.messageHandler() -> QAbstractMessageHandler");

extern "C" {static PyObject *meth_QXmlSchemaValidator_messageHandler(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchemaValidator_messageHandler(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSchemaValidator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSchemaValidator, &sipCpp))
        {
            QAbstractMessageHandler*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->messageHandler();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QAbstractMessageHandler,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchemaValidator, sipName_messageHandler, doc_QXmlSchemaValidator_messageHandler);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchemaValidator_setUriResolver, "QXmlSchemaValidator.setUriResolver(QAbstractUriResolver)");

extern "C" {static PyObject *meth_QXmlSchemaValidator_setUriResolver(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchemaValidator_setUriResolver(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QAbstractUriResolver* a0;
        PyObject *a0Keep;
        QXmlSchemaValidator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QXmlSchemaValidator, &sipCpp, &a0Keep, sipType_QAbstractUriResolver, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUriResolver(a0);
            Py_END_ALLOW_THREADS

            sipKeepReference(sipSelf, -9, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchemaValidator, sipName_setUriResolver, doc_QXmlSchemaValidator_setUriResolver);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchemaValidator_uriResolver, "QXmlSchemaValidator.uriResolver() -> QAbstractUriResolver");

extern "C" {static PyObject *meth_QXmlSchemaValidator_uriResolver(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchemaValidator_uriResolver(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSchemaValidator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSchemaValidator, &sipCpp))
        {
            const QAbstractUriResolver*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->uriResolver();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(const_cast<QAbstractUriResolver *>(sipRes),sipType_QAbstractUriResolver,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchemaValidator, sipName_uriResolver, doc_QXmlSchemaValidator_uriResolver);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchemaValidator_setNetworkAccessManager, "QXmlSchemaValidator.setNetworkAccessManager(QNetworkAccessManager)");

extern "C" {static PyObject *meth_QXmlSchemaValidator_setNetworkAccessManager(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchemaValidator_setNetworkAccessManager(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QNetworkAccessManager* a0;
        PyObject *a0Keep;
        QXmlSchemaValidator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QXmlSchemaValidator, &sipCpp, &a0Keep, sipType_QNetworkAccessManager, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setNetworkAccessManager(a0);
            Py_END_ALLOW_THREADS

            sipKeepReference(sipSelf, -10, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchemaValidator, sipName_setNetworkAccessManager, doc_QXmlSchemaValidator_setNetworkAccessManager);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchemaValidator_networkAccessManager, "QXmlSchemaValidator.networkAccessManager() -> QNetworkAccessManager");

extern "C" {static PyObject *meth_QXmlSchemaValidator_networkAccessManager(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchemaValidator_networkAccessManager(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSchemaValidator *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSchemaValidator, &sipCpp))
        {
            QNetworkAccessManager*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->networkAccessManager();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QNetworkAccessManager,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchemaValidator, sipName_networkAccessManager, doc_QXmlSchemaValidator_networkAccessManager);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QXmlSchemaValidator(void *, const sipTypeDef *);}
static void *cast_QXmlSchemaValidator(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QXmlSchemaValidator)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QXmlSchemaValidator(void *, int);}
static void release_QXmlSchemaValidator(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QXmlSchemaValidator *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QXmlSchemaValidator(sipSimpleWrapper *);}
static void dealloc_QXmlSchemaValidator(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QXmlSchemaValidator(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QXmlSchemaValidator(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QXmlSchemaValidator(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QXmlSchemaValidator *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlSchemaValidator();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QXmlSchema* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QXmlSchema, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlSchemaValidator(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QXmlSchemaValidator[] = {
    {SIP_MLNAME_CAST(sipName_messageHandler), meth_QXmlSchemaValidator_messageHandler, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchemaValidator_messageHandler)},
    {SIP_MLNAME_CAST(sipName_namePool), meth_QXmlSchemaValidator_namePool, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchemaValidator_namePool)},
    {SIP_MLNAME_CAST(sipName_networkAccessManager), meth_QXmlSchemaValidator_networkAccessManager, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchemaValidator_networkAccessManager)},
    {SIP_MLNAME_CAST(sipName_schema), meth_QXmlSchemaValidator_schema, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchemaValidator_schema)},
    {SIP_MLNAME_CAST(sipName_setMessageHandler), meth_QXmlSchemaValidator_setMessageHandler, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchemaValidator_setMessageHandler)},
    {SIP_MLNAME_CAST(sipName_setNetworkAccessManager), meth_QXmlSchemaValidator_setNetworkAccessManager, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchemaValidator_setNetworkAccessManager)},
    {SIP_MLNAME_CAST(sipName_setSchema), meth_QXmlSchemaValidator_setSchema, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchemaValidator_setSchema)},
    {SIP_MLNAME_CAST(sipName_setUriResolver), meth_QXmlSchemaValidator_setUriResolver, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchemaValidator_setUriResolver)},
    {SIP_MLNAME_CAST(sipName_uriResolver), meth_QXmlSchemaValidator_uriResolver, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchemaValidator_uriResolver)},
    {SIP_MLNAME_CAST(sipName_validate), (PyCFunction)meth_QXmlSchemaValidator_validate, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QXmlSchemaValidator_validate)}
};

PyDoc_STRVAR(doc_QXmlSchemaValidator, "\1QXmlSchemaValidator()\n"
    "QXmlSchemaValidator(QXmlSchema)");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QXmlSchemaValidator = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QXmlSchemaValidator,
        {0}
    },
    {
        sipNameNr_QXmlSchemaValidator,
        {0, 0, 1},
        10, methods_QXmlSchemaValidator,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QXmlSchemaValidator,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QXmlSchemaValidator,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QXmlSchemaValidator,
    0,
    0,
    0,
    release_QXmlSchemaValidator,
    cast_QXmlSchemaValidator,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlschema.sip"
#include <qxmlschema.h>
#line 1515 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtNetwork/qnetworkaccessmanager.sip"
#include <qnetworkaccessmanager.h>
#line 1519 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstracturiresolver.sip"
#include <qabstracturiresolver.h>
#line 1522 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractmessagehandler.sip"
#include <qabstractmessagehandler.h>
#line 1525 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 107 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qurl.sip"
#include <qurl.h>
#line 1528 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlnamepool.sip"
#include <qxmlnamepool.h>
#line 1531 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qiodevice.sip"
#include <qiodevice.h>
#line 1534 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 1537 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


PyDoc_STRVAR(doc_QXmlSchema_load, "QXmlSchema.load(QUrl) -> bool\n"
    "QXmlSchema.load(QIODevice, QUrl documentUri=QUrl()) -> bool\n"
    "QXmlSchema.load(QByteArray, QUrl documentUri=QUrl()) -> bool");

extern "C" {static PyObject *meth_QXmlSchema_load(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QXmlSchema_load(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QUrl* a0;
        QXmlSchema *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QXmlSchema, &sipCpp, sipType_QUrl, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->load(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    {
        QIODevice* a0;
        const QUrl& a1def = QUrl();
        const QUrl* a1 = &a1def;
        QXmlSchema *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_documentUri,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ8|J9", &sipSelf, sipType_QXmlSchema, &sipCpp, sipType_QIODevice, &a0, sipType_QUrl, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->load(a0,*a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    {
        const QByteArray* a0;
        int a0State = 0;
        const QUrl& a1def = QUrl();
        const QUrl* a1 = &a1def;
        QXmlSchema *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_documentUri,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|J9", &sipSelf, sipType_QXmlSchema, &sipCpp, sipType_QByteArray, &a0, &a0State, sipType_QUrl, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->load(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QByteArray *>(a0),sipType_QByteArray,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchema, sipName_load, doc_QXmlSchema_load);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchema_isValid, "QXmlSchema.isValid() -> bool");

extern "C" {static PyObject *meth_QXmlSchema_isValid(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchema_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSchema *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSchema, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchema, sipName_isValid, doc_QXmlSchema_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchema_namePool, "QXmlSchema.namePool() -> QXmlNamePool");

extern "C" {static PyObject *meth_QXmlSchema_namePool(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchema_namePool(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSchema *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSchema, &sipCpp))
        {
            QXmlNamePool*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNamePool(sipCpp->namePool());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNamePool,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchema, sipName_namePool, doc_QXmlSchema_namePool);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchema_documentUri, "QXmlSchema.documentUri() -> QUrl");

extern "C" {static PyObject *meth_QXmlSchema_documentUri(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchema_documentUri(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSchema *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSchema, &sipCpp))
        {
            QUrl*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QUrl(sipCpp->documentUri());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QUrl,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchema, sipName_documentUri, doc_QXmlSchema_documentUri);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchema_setMessageHandler, "QXmlSchema.setMessageHandler(QAbstractMessageHandler)");

extern "C" {static PyObject *meth_QXmlSchema_setMessageHandler(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchema_setMessageHandler(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QAbstractMessageHandler* a0;
        PyObject *a0Keep;
        QXmlSchema *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QXmlSchema, &sipCpp, &a0Keep, sipType_QAbstractMessageHandler, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setMessageHandler(a0);
            Py_END_ALLOW_THREADS

            sipKeepReference(sipSelf, -5, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchema, sipName_setMessageHandler, doc_QXmlSchema_setMessageHandler);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchema_messageHandler, "QXmlSchema.messageHandler() -> QAbstractMessageHandler");

extern "C" {static PyObject *meth_QXmlSchema_messageHandler(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchema_messageHandler(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSchema *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSchema, &sipCpp))
        {
            QAbstractMessageHandler*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->messageHandler();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QAbstractMessageHandler,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchema, sipName_messageHandler, doc_QXmlSchema_messageHandler);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchema_setUriResolver, "QXmlSchema.setUriResolver(QAbstractUriResolver)");

extern "C" {static PyObject *meth_QXmlSchema_setUriResolver(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchema_setUriResolver(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QAbstractUriResolver* a0;
        PyObject *a0Keep;
        QXmlSchema *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QXmlSchema, &sipCpp, &a0Keep, sipType_QAbstractUriResolver, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUriResolver(a0);
            Py_END_ALLOW_THREADS

            sipKeepReference(sipSelf, -6, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchema, sipName_setUriResolver, doc_QXmlSchema_setUriResolver);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchema_uriResolver, "QXmlSchema.uriResolver() -> QAbstractUriResolver");

extern "C" {static PyObject *meth_QXmlSchema_uriResolver(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchema_uriResolver(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSchema *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSchema, &sipCpp))
        {
            const QAbstractUriResolver*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->uriResolver();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(const_cast<QAbstractUriResolver *>(sipRes),sipType_QAbstractUriResolver,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchema, sipName_uriResolver, doc_QXmlSchema_uriResolver);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchema_setNetworkAccessManager, "QXmlSchema.setNetworkAccessManager(QNetworkAccessManager)");

extern "C" {static PyObject *meth_QXmlSchema_setNetworkAccessManager(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchema_setNetworkAccessManager(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QNetworkAccessManager* a0;
        PyObject *a0Keep;
        QXmlSchema *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QXmlSchema, &sipCpp, &a0Keep, sipType_QNetworkAccessManager, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setNetworkAccessManager(a0);
            Py_END_ALLOW_THREADS

            sipKeepReference(sipSelf, -7, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchema, sipName_setNetworkAccessManager, doc_QXmlSchema_setNetworkAccessManager);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSchema_networkAccessManager, "QXmlSchema.networkAccessManager() -> QNetworkAccessManager");

extern "C" {static PyObject *meth_QXmlSchema_networkAccessManager(PyObject *, PyObject *);}
static PyObject *meth_QXmlSchema_networkAccessManager(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSchema *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSchema, &sipCpp))
        {
            QNetworkAccessManager*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->networkAccessManager();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QNetworkAccessManager,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSchema, sipName_networkAccessManager, doc_QXmlSchema_networkAccessManager);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QXmlSchema(void *, const sipTypeDef *);}
static void *cast_QXmlSchema(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QXmlSchema)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QXmlSchema(void *, int);}
static void release_QXmlSchema(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QXmlSchema *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QXmlSchema(sipSimpleWrapper *);}
static void dealloc_QXmlSchema(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QXmlSchema(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QXmlSchema(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QXmlSchema(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QXmlSchema *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlSchema();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QXmlSchema[] = {
    {SIP_MLNAME_CAST(sipName_documentUri), meth_QXmlSchema_documentUri, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchema_documentUri)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QXmlSchema_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchema_isValid)},
    {SIP_MLNAME_CAST(sipName_load), (PyCFunction)meth_QXmlSchema_load, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QXmlSchema_load)},
    {SIP_MLNAME_CAST(sipName_messageHandler), meth_QXmlSchema_messageHandler, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchema_messageHandler)},
    {SIP_MLNAME_CAST(sipName_namePool), meth_QXmlSchema_namePool, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchema_namePool)},
    {SIP_MLNAME_CAST(sipName_networkAccessManager), meth_QXmlSchema_networkAccessManager, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchema_networkAccessManager)},
    {SIP_MLNAME_CAST(sipName_setMessageHandler), meth_QXmlSchema_setMessageHandler, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchema_setMessageHandler)},
    {SIP_MLNAME_CAST(sipName_setNetworkAccessManager), meth_QXmlSchema_setNetworkAccessManager, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchema_setNetworkAccessManager)},
    {SIP_MLNAME_CAST(sipName_setUriResolver), meth_QXmlSchema_setUriResolver, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchema_setUriResolver)},
    {SIP_MLNAME_CAST(sipName_uriResolver), meth_QXmlSchema_uriResolver, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSchema_uriResolver)}
};

PyDoc_STRVAR(doc_QXmlSchema, "\1QXmlSchema()");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QXmlSchema = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QXmlSchema,
        {0}
    },
    {
        sipNameNr_QXmlSchema,
        {0, 0, 1},
        10, methods_QXmlSchema,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QXmlSchema,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QXmlSchema,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QXmlSchema,
    0,
    0,
    0,
    release_QXmlSchema,
    cast_QXmlSchema,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlresultitems.sip"
#include <qxmlresultitems.h>
#line 2015 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 132 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 2019 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


class sipQXmlResultItems : public QXmlResultItems
{
public:
    sipQXmlResultItems();
    ~sipQXmlResultItems();

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQXmlResultItems(const sipQXmlResultItems &);
    sipQXmlResultItems &operator = (const sipQXmlResultItems &);
};

sipQXmlResultItems::sipQXmlResultItems(): QXmlResultItems(), sipPySelf(0)
{
}

sipQXmlResultItems::~sipQXmlResultItems()
{
    sipCommonDtor(sipPySelf);
}


PyDoc_STRVAR(doc_QXmlResultItems_hasError, "QXmlResultItems.hasError() -> bool");

extern "C" {static PyObject *meth_QXmlResultItems_hasError(PyObject *, PyObject *);}
static PyObject *meth_QXmlResultItems_hasError(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlResultItems *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlResultItems, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->hasError();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlResultItems, sipName_hasError, doc_QXmlResultItems_hasError);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlResultItems_next, "QXmlResultItems.next() -> QXmlItem");

extern "C" {static PyObject *meth_QXmlResultItems_next(PyObject *, PyObject *);}
static PyObject *meth_QXmlResultItems_next(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QXmlResultItems *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlResultItems, &sipCpp))
        {
            QXmlItem*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlItem(sipCpp->next());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlItem,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlResultItems, sipName_next, doc_QXmlResultItems_next);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlResultItems_current, "QXmlResultItems.current() -> QXmlItem");

extern "C" {static PyObject *meth_QXmlResultItems_current(PyObject *, PyObject *);}
static PyObject *meth_QXmlResultItems_current(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlResultItems *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlResultItems, &sipCpp))
        {
            QXmlItem*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlItem(sipCpp->current());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlItem,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlResultItems, sipName_current, doc_QXmlResultItems_current);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QXmlResultItems(void *, const sipTypeDef *);}
static void *cast_QXmlResultItems(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QXmlResultItems)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QXmlResultItems(void *, int);}
static void release_QXmlResultItems(void *sipCppV,int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQXmlResultItems *>(sipCppV);
    else
        delete reinterpret_cast<QXmlResultItems *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QXmlResultItems(sipSimpleWrapper *);}
static void dealloc_QXmlResultItems(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQXmlResultItems *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QXmlResultItems(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QXmlResultItems(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QXmlResultItems(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQXmlResultItems *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQXmlResultItems();
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QXmlResultItems[] = {
    {SIP_MLNAME_CAST(sipName_current), meth_QXmlResultItems_current, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlResultItems_current)},
    {SIP_MLNAME_CAST(sipName_hasError), meth_QXmlResultItems_hasError, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlResultItems_hasError)},
    {SIP_MLNAME_CAST(sipName_next), meth_QXmlResultItems_next, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlResultItems_next)}
};

PyDoc_STRVAR(doc_QXmlResultItems, "\1QXmlResultItems()");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QXmlResultItems = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QXmlResultItems,
        {0}
    },
    {
        sipNameNr_QXmlResultItems,
        {0, 0, 1},
        3, methods_QXmlResultItems,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QXmlResultItems,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QXmlResultItems,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QXmlResultItems,
    0,
    0,
    0,
    release_QXmlResultItems,
    cast_QXmlResultItems,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlquery.sip"
#include <qxmlquery.h>
#line 2259 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlnamepool.sip"
#include <qxmlnamepool.h>
#line 2263 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtNetwork/qnetworkaccessmanager.sip"
#include <qnetworkaccessmanager.h>
#line 2266 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlname.sip"
#include <qxmlname.h>
#line 2269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 36 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 2272 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 132 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 2275 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 107 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qurl.sip"
#include <qurl.h>
#line 2278 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qiodevice.sip"
#include <qiodevice.h>
#line 2281 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstracturiresolver.sip"
#include <qabstracturiresolver.h>
#line 2284 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlresultitems.sip"
#include <qxmlresultitems.h>
#line 2287 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlreceiver.sip"
#include <qabstractxmlreceiver.h>
#line 2290 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 36 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 2293 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractmessagehandler.sip"
#include <qabstractmessagehandler.h>
#line 2296 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


PyDoc_STRVAR(doc_QXmlQuery_setMessageHandler, "QXmlQuery.setMessageHandler(QAbstractMessageHandler)");

extern "C" {static PyObject *meth_QXmlQuery_setMessageHandler(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_setMessageHandler(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QAbstractMessageHandler* a0;
        PyObject *a0Keep;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QXmlQuery, &sipCpp, &a0Keep, sipType_QAbstractMessageHandler, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setMessageHandler(a0);
            Py_END_ALLOW_THREADS

            sipKeepReference(sipSelf, -2, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_setMessageHandler, doc_QXmlQuery_setMessageHandler);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_messageHandler, "QXmlQuery.messageHandler() -> QAbstractMessageHandler");

extern "C" {static PyObject *meth_QXmlQuery_messageHandler(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_messageHandler(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlQuery, &sipCpp))
        {
            QAbstractMessageHandler*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->messageHandler();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QAbstractMessageHandler,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_messageHandler, doc_QXmlQuery_messageHandler);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_setQuery, "QXmlQuery.setQuery(str, QUrl documentUri=QUrl())\n"
    "QXmlQuery.setQuery(QIODevice, QUrl documentUri=QUrl())\n"
    "QXmlQuery.setQuery(QUrl, QUrl baseUri=QUrl())");

extern "C" {static PyObject *meth_QXmlQuery_setQuery(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_setQuery(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        const QUrl& a1def = QUrl();
        const QUrl* a1 = &a1def;
        QXmlQuery *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_documentUri,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|J9", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QString,&a0, &a0State, sipType_QUrl, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setQuery(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QIODevice* a0;
        const QUrl& a1def = QUrl();
        const QUrl* a1 = &a1def;
        QXmlQuery *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_documentUri,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ8|J9", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QIODevice, &a0, sipType_QUrl, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setQuery(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QUrl* a0;
        const QUrl& a1def = QUrl();
        const QUrl* a1 = &a1def;
        QXmlQuery *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_baseUri,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|J9", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QUrl, &a0, sipType_QUrl, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setQuery(*a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_setQuery, doc_QXmlQuery_setQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_namePool, "QXmlQuery.namePool() -> QXmlNamePool");

extern "C" {static PyObject *meth_QXmlQuery_namePool(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_namePool(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlQuery, &sipCpp))
        {
            QXmlNamePool*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNamePool(sipCpp->namePool());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNamePool,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_namePool, doc_QXmlQuery_namePool);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_bindVariable, "QXmlQuery.bindVariable(QXmlName, QXmlItem)\n"
    "QXmlQuery.bindVariable(QXmlName, QIODevice)\n"
    "QXmlQuery.bindVariable(QXmlName, QXmlQuery)\n"
    "QXmlQuery.bindVariable(str, QXmlItem)\n"
    "QXmlQuery.bindVariable(str, QIODevice)\n"
    "QXmlQuery.bindVariable(str, QXmlQuery)");

extern "C" {static PyObject *meth_QXmlQuery_bindVariable(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_bindVariable(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlName* a0;
        const QXmlItem* a1;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9J9", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QXmlName, &a0, sipType_QXmlItem, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->bindVariable(*a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QXmlName* a0;
        QIODevice* a1;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9J8", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QXmlName, &a0, sipType_QIODevice, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->bindVariable(*a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QXmlName* a0;
        const QXmlQuery* a1;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9J9", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QXmlName, &a0, sipType_QXmlQuery, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->bindVariable(*a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        const QXmlItem* a1;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J9", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QString,&a0, &a0State, sipType_QXmlItem, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->bindVariable(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        QIODevice* a1;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J8", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QString,&a0, &a0State, sipType_QIODevice, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->bindVariable(*a0,a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        const QXmlQuery* a1;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J9", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QString,&a0, &a0State, sipType_QXmlQuery, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->bindVariable(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_bindVariable, doc_QXmlQuery_bindVariable);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_isValid, "QXmlQuery.isValid() -> bool");

extern "C" {static PyObject *meth_QXmlQuery_isValid(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlQuery, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_isValid, doc_QXmlQuery_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_evaluateTo, "QXmlQuery.evaluateTo(QXmlResultItems)\n"
    "QXmlQuery.evaluateTo(QAbstractXmlReceiver) -> bool\n"
    "QXmlQuery.evaluateTo(QIODevice) -> bool");

extern "C" {static PyObject *meth_QXmlQuery_evaluateTo(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_evaluateTo(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QXmlResultItems* a0;
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QXmlResultItems, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->evaluateTo(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QAbstractXmlReceiver* a0;
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QAbstractXmlReceiver, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->evaluateTo(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    if (sipIsAPIEnabled(sipName_QString, 0, 2))
    {
        QStringList* a0;
        int a0State = 0;
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ0", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QStringList,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->evaluateTo(a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QStringList,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    {
        QIODevice* a0;
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QIODevice, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->evaluateTo(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    if (sipIsAPIEnabled(sipName_QString, 0, 2))
    {
        QString* a0;
        int a0State = 0;
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ0", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->evaluateTo(a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_evaluateTo, doc_QXmlQuery_evaluateTo);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_evaluateToStringList, "QXmlQuery.evaluateToStringList() -> list-of-str");

extern "C" {static PyObject *meth_QXmlQuery_evaluateToStringList(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_evaluateToStringList(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlQuery, &sipCpp))
        {
            PyObject * sipRes = 0;

#line 75 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlquery.sip"
        bool ok;
        QStringList *result = new QStringList;
        
        Py_BEGIN_ALLOW_THREADS
        ok = sipCpp->evaluateTo(result);
        Py_END_ALLOW_THREADS
        
        if (ok)
        {
            sipRes = sipConvertFromNewType(result, sipType_QStringList, NULL);
        }
        else
        {
            delete result;
            sipRes = Py_None;
            Py_INCREF(Py_None);
        }
#line 2756 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

            return sipRes;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_evaluateToStringList, doc_QXmlQuery_evaluateToStringList);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_evaluateToString, "QXmlQuery.evaluateToString() -> str");

extern "C" {static PyObject *meth_QXmlQuery_evaluateToString(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_evaluateToString(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlQuery, &sipCpp))
        {
            PyObject * sipRes = 0;

#line 103 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlquery.sip"
        bool ok;
        QString *result = new QString;
        
        Py_BEGIN_ALLOW_THREADS
        ok = sipCpp->evaluateTo(result);
        Py_END_ALLOW_THREADS
        
        if (ok)
        {
            sipRes = sipConvertFromNewType(result, sipType_QString, NULL);
        }
        else
        {
            delete result;
            sipRes = Py_None;
            Py_INCREF(Py_None);
        }
#line 2801 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

            return sipRes;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_evaluateToString, doc_QXmlQuery_evaluateToString);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_setUriResolver, "QXmlQuery.setUriResolver(QAbstractUriResolver)");

extern "C" {static PyObject *meth_QXmlQuery_setUriResolver(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_setUriResolver(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QAbstractUriResolver* a0;
        PyObject *a0Keep;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QXmlQuery, &sipCpp, &a0Keep, sipType_QAbstractUriResolver, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUriResolver(a0);
            Py_END_ALLOW_THREADS

            sipKeepReference(sipSelf, -3, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_setUriResolver, doc_QXmlQuery_setUriResolver);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_uriResolver, "QXmlQuery.uriResolver() -> QAbstractUriResolver");

extern "C" {static PyObject *meth_QXmlQuery_uriResolver(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_uriResolver(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlQuery, &sipCpp))
        {
            const QAbstractUriResolver*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->uriResolver();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(const_cast<QAbstractUriResolver *>(sipRes),sipType_QAbstractUriResolver,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_uriResolver, doc_QXmlQuery_uriResolver);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_setFocus, "QXmlQuery.setFocus(QXmlItem)\n"
    "QXmlQuery.setFocus(QUrl) -> bool\n"
    "QXmlQuery.setFocus(QIODevice) -> bool\n"
    "QXmlQuery.setFocus(str) -> bool");

extern "C" {static PyObject *meth_QXmlQuery_setFocus(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_setFocus(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlItem* a0;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QXmlItem, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setFocus(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QUrl* a0;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QUrl, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->setFocus(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    {
        QIODevice* a0;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QIODevice, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->setFocus(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->setFocus(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_setFocus, doc_QXmlQuery_setFocus);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_setInitialTemplateName, "QXmlQuery.setInitialTemplateName(QXmlName)\n"
    "QXmlQuery.setInitialTemplateName(str)");

extern "C" {static PyObject *meth_QXmlQuery_setInitialTemplateName(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_setInitialTemplateName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlName* a0;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QXmlName, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setInitialTemplateName(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QXmlQuery, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setInitialTemplateName(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_setInitialTemplateName, doc_QXmlQuery_setInitialTemplateName);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_initialTemplateName, "QXmlQuery.initialTemplateName() -> QXmlName");

extern "C" {static PyObject *meth_QXmlQuery_initialTemplateName(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_initialTemplateName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlQuery, &sipCpp))
        {
            QXmlName*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlName(sipCpp->initialTemplateName());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlName,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_initialTemplateName, doc_QXmlQuery_initialTemplateName);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_setNetworkAccessManager, "QXmlQuery.setNetworkAccessManager(QNetworkAccessManager)");

extern "C" {static PyObject *meth_QXmlQuery_setNetworkAccessManager(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_setNetworkAccessManager(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QNetworkAccessManager* a0;
        PyObject *a0Keep;
        QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QXmlQuery, &sipCpp, &a0Keep, sipType_QNetworkAccessManager, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setNetworkAccessManager(a0);
            Py_END_ALLOW_THREADS

            sipKeepReference(sipSelf, -4, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_setNetworkAccessManager, doc_QXmlQuery_setNetworkAccessManager);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_networkAccessManager, "QXmlQuery.networkAccessManager() -> QNetworkAccessManager");

extern "C" {static PyObject *meth_QXmlQuery_networkAccessManager(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_networkAccessManager(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlQuery, &sipCpp))
        {
            QNetworkAccessManager*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->networkAccessManager();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QNetworkAccessManager,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_networkAccessManager, doc_QXmlQuery_networkAccessManager);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlQuery_queryLanguage, "QXmlQuery.queryLanguage() -> QXmlQuery.QueryLanguage");

extern "C" {static PyObject *meth_QXmlQuery_queryLanguage(PyObject *, PyObject *);}
static PyObject *meth_QXmlQuery_queryLanguage(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlQuery, &sipCpp))
        {
            QXmlQuery::QueryLanguage sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->queryLanguage();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(sipRes,sipType_QXmlQuery_QueryLanguage);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlQuery, sipName_queryLanguage, doc_QXmlQuery_queryLanguage);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QXmlQuery(void *, const sipTypeDef *);}
static void *cast_QXmlQuery(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QXmlQuery)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QXmlQuery(void *, int);}
static void release_QXmlQuery(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QXmlQuery *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QXmlQuery(void *, SIP_SSIZE_T, const void *);}
static void assign_QXmlQuery(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QXmlQuery *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QXmlQuery *>(sipSrc);
}


extern "C" {static void *array_QXmlQuery(SIP_SSIZE_T);}
static void *array_QXmlQuery(SIP_SSIZE_T sipNrElem)
{
    return new QXmlQuery[sipNrElem];
}


extern "C" {static void *copy_QXmlQuery(const void *, SIP_SSIZE_T);}
static void *copy_QXmlQuery(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QXmlQuery(reinterpret_cast<const QXmlQuery *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QXmlQuery(sipSimpleWrapper *);}
static void dealloc_QXmlQuery(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QXmlQuery(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QXmlQuery(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QXmlQuery(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QXmlQuery *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlQuery();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QXmlQuery* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QXmlQuery, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlQuery(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QXmlNamePool* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QXmlNamePool, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlQuery(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        QXmlQuery::QueryLanguage a0;
        const QXmlNamePool& a1def = QXmlNamePool();
        const QXmlNamePool* a1 = &a1def;

        static const char *sipKwdList[] = {
            NULL,
            sipName_pool,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "E|J9", sipType_QXmlQuery_QueryLanguage, &a0, sipType_QXmlNamePool, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlQuery(a0,*a1);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QXmlQuery[] = {
    {SIP_MLNAME_CAST(sipName_bindVariable), meth_QXmlQuery_bindVariable, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_bindVariable)},
    {SIP_MLNAME_CAST(sipName_evaluateTo), meth_QXmlQuery_evaluateTo, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_evaluateTo)},
    {SIP_MLNAME_CAST(sipName_evaluateToString), meth_QXmlQuery_evaluateToString, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_evaluateToString)},
    {SIP_MLNAME_CAST(sipName_evaluateToStringList), meth_QXmlQuery_evaluateToStringList, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_evaluateToStringList)},
    {SIP_MLNAME_CAST(sipName_initialTemplateName), meth_QXmlQuery_initialTemplateName, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_initialTemplateName)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QXmlQuery_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_isValid)},
    {SIP_MLNAME_CAST(sipName_messageHandler), meth_QXmlQuery_messageHandler, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_messageHandler)},
    {SIP_MLNAME_CAST(sipName_namePool), meth_QXmlQuery_namePool, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_namePool)},
    {SIP_MLNAME_CAST(sipName_networkAccessManager), meth_QXmlQuery_networkAccessManager, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_networkAccessManager)},
    {SIP_MLNAME_CAST(sipName_queryLanguage), meth_QXmlQuery_queryLanguage, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_queryLanguage)},
    {SIP_MLNAME_CAST(sipName_setFocus), meth_QXmlQuery_setFocus, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_setFocus)},
    {SIP_MLNAME_CAST(sipName_setInitialTemplateName), meth_QXmlQuery_setInitialTemplateName, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_setInitialTemplateName)},
    {SIP_MLNAME_CAST(sipName_setMessageHandler), meth_QXmlQuery_setMessageHandler, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_setMessageHandler)},
    {SIP_MLNAME_CAST(sipName_setNetworkAccessManager), meth_QXmlQuery_setNetworkAccessManager, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_setNetworkAccessManager)},
    {SIP_MLNAME_CAST(sipName_setQuery), (PyCFunction)meth_QXmlQuery_setQuery, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QXmlQuery_setQuery)},
    {SIP_MLNAME_CAST(sipName_setUriResolver), meth_QXmlQuery_setUriResolver, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_setUriResolver)},
    {SIP_MLNAME_CAST(sipName_uriResolver), meth_QXmlQuery_uriResolver, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlQuery_uriResolver)}
};

static sipEnumMemberDef enummembers_QXmlQuery[] = {
    {sipName_XQuery10, static_cast<int>(QXmlQuery::XQuery10), 17},
    {sipName_XSLT20, static_cast<int>(QXmlQuery::XSLT20), 17},
};

PyDoc_STRVAR(doc_QXmlQuery, "\1QXmlQuery()\n"
    "QXmlQuery(QXmlQuery)\n"
    "QXmlQuery(QXmlNamePool)\n"
    "QXmlQuery(QXmlQuery.QueryLanguage, QXmlNamePool pool=QXmlNamePool())");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QXmlQuery = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QXmlQuery,
        {0}
    },
    {
        sipNameNr_QXmlQuery,
        {0, 0, 1},
        17, methods_QXmlQuery,
        2, enummembers_QXmlQuery,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QXmlQuery,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QXmlQuery,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QXmlQuery,
    assign_QXmlQuery,
    array_QXmlQuery,
    copy_QXmlQuery,
    release_QXmlQuery,
    cast_QXmlQuery,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlnamepool.sip"
#include <qxmlnamepool.h>
#line 3330 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"



/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QXmlNamePool(void *, const sipTypeDef *);}
static void *cast_QXmlNamePool(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QXmlNamePool)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QXmlNamePool(void *, int);}
static void release_QXmlNamePool(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QXmlNamePool *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QXmlNamePool(void *, SIP_SSIZE_T, const void *);}
static void assign_QXmlNamePool(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QXmlNamePool *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QXmlNamePool *>(sipSrc);
}


extern "C" {static void *array_QXmlNamePool(SIP_SSIZE_T);}
static void *array_QXmlNamePool(SIP_SSIZE_T sipNrElem)
{
    return new QXmlNamePool[sipNrElem];
}


extern "C" {static void *copy_QXmlNamePool(const void *, SIP_SSIZE_T);}
static void *copy_QXmlNamePool(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QXmlNamePool(reinterpret_cast<const QXmlNamePool *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QXmlNamePool(sipSimpleWrapper *);}
static void dealloc_QXmlNamePool(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QXmlNamePool(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QXmlNamePool(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QXmlNamePool(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QXmlNamePool *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlNamePool();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QXmlNamePool* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QXmlNamePool, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlNamePool(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}

PyDoc_STRVAR(doc_QXmlNamePool, "\1QXmlNamePool()\n"
    "QXmlNamePool(QXmlNamePool)");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QXmlNamePool = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QXmlNamePool,
        {0}
    },
    {
        sipNameNr_QXmlNamePool,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QXmlNamePool,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QXmlNamePool,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QXmlNamePool,
    assign_QXmlNamePool,
    array_QXmlNamePool,
    copy_QXmlNamePool,
    release_QXmlNamePool,
    cast_QXmlNamePool,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlname.sip"
#include <qxmlname.h>
#line 3480 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlnamepool.sip"
#include <qxmlnamepool.h>
#line 3484 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 36 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 3487 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


PyDoc_STRVAR(doc_QXmlName_namespaceUri, "QXmlName.namespaceUri(QXmlNamePool) -> str");

extern "C" {static PyObject *meth_QXmlName_namespaceUri(PyObject *, PyObject *);}
static PyObject *meth_QXmlName_namespaceUri(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlNamePool* a0;
        const QXmlName *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QXmlName, &sipCpp, sipType_QXmlNamePool, &a0))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->namespaceUri(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlName, sipName_namespaceUri, doc_QXmlName_namespaceUri);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlName_prefix, "QXmlName.prefix(QXmlNamePool) -> str");

extern "C" {static PyObject *meth_QXmlName_prefix(PyObject *, PyObject *);}
static PyObject *meth_QXmlName_prefix(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlNamePool* a0;
        const QXmlName *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QXmlName, &sipCpp, sipType_QXmlNamePool, &a0))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->prefix(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlName, sipName_prefix, doc_QXmlName_prefix);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlName_localName, "QXmlName.localName(QXmlNamePool) -> str");

extern "C" {static PyObject *meth_QXmlName_localName(PyObject *, PyObject *);}
static PyObject *meth_QXmlName_localName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlNamePool* a0;
        const QXmlName *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QXmlName, &sipCpp, sipType_QXmlNamePool, &a0))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->localName(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlName, sipName_localName, doc_QXmlName_localName);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlName_toClarkName, "QXmlName.toClarkName(QXmlNamePool) -> str");

extern "C" {static PyObject *meth_QXmlName_toClarkName(PyObject *, PyObject *);}
static PyObject *meth_QXmlName_toClarkName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlNamePool* a0;
        const QXmlName *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QXmlName, &sipCpp, sipType_QXmlNamePool, &a0))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->toClarkName(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlName, sipName_toClarkName, doc_QXmlName_toClarkName);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlName_isNull, "QXmlName.isNull() -> bool");

extern "C" {static PyObject *meth_QXmlName_isNull(PyObject *, PyObject *);}
static PyObject *meth_QXmlName_isNull(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlName *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlName, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isNull();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlName, sipName_isNull, doc_QXmlName_isNull);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlName_isNCName, "QXmlName.isNCName(str) -> bool");

extern "C" {static PyObject *meth_QXmlName_isNCName(PyObject *, PyObject *);}
static PyObject *meth_QXmlName_isNCName(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J1", sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = QXmlName::isNCName(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlName, sipName_isNCName, doc_QXmlName_isNCName);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlName_fromClarkName, "QXmlName.fromClarkName(str, QXmlNamePool) -> QXmlName");

extern "C" {static PyObject *meth_QXmlName_fromClarkName(PyObject *, PyObject *);}
static PyObject *meth_QXmlName_fromClarkName(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        const QXmlNamePool* a1;

        if (sipParseArgs(&sipParseErr, sipArgs, "J1J9", sipType_QString,&a0, &a0State, sipType_QXmlNamePool, &a1))
        {
            QXmlName*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlName(QXmlName::fromClarkName(*a0,*a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QXmlName,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlName, sipName_fromClarkName, doc_QXmlName_fromClarkName);

    return NULL;
}


extern "C" {static long slot_QXmlName___hash__(PyObject *);}
static long slot_QXmlName___hash__(PyObject *sipSelf)
{
    QXmlName *sipCpp = reinterpret_cast<QXmlName *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QXmlName));

    if (!sipCpp)
        return 0;


    {
        {
            long sipRes = 0;

#line 52 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlname.sip"
        sipRes = qHash(*sipCpp);
#line 3717 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QXmlName___ne__(PyObject *,PyObject *);}
static PyObject *slot_QXmlName___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QXmlName *sipCpp = reinterpret_cast<QXmlName *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QXmlName));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QXmlName* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QXmlName, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->QXmlName::operator!=(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtXmlPatterns,ne_slot,sipType_QXmlName,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QXmlName___eq__(PyObject *,PyObject *);}
static PyObject *slot_QXmlName___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QXmlName *sipCpp = reinterpret_cast<QXmlName *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QXmlName));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QXmlName* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QXmlName, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->QXmlName::operator==(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtXmlPatterns,eq_slot,sipType_QXmlName,sipSelf,sipArg);
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QXmlName(void *, const sipTypeDef *);}
static void *cast_QXmlName(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QXmlName)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QXmlName(void *, int);}
static void release_QXmlName(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QXmlName *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QXmlName(void *, SIP_SSIZE_T, const void *);}
static void assign_QXmlName(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QXmlName *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QXmlName *>(sipSrc);
}


extern "C" {static void *array_QXmlName(SIP_SSIZE_T);}
static void *array_QXmlName(SIP_SSIZE_T sipNrElem)
{
    return new QXmlName[sipNrElem];
}


extern "C" {static void *copy_QXmlName(const void *, SIP_SSIZE_T);}
static void *copy_QXmlName(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QXmlName(reinterpret_cast<const QXmlName *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QXmlName(sipSimpleWrapper *);}
static void dealloc_QXmlName(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QXmlName(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QXmlName(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QXmlName(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QXmlName *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlName();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        QXmlNamePool* a0;
        const QString* a1;
        int a1State = 0;
        const QString& a2def = QString();
        const QString* a2 = &a2def;
        int a2State = 0;
        const QString& a3def = QString();
        const QString* a3 = &a3def;
        int a3State = 0;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_namespaceUri,
            sipName_prefix,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9J1|J1J1", sipType_QXmlNamePool, &a0, sipType_QString,&a1, &a1State, sipType_QString,&a2, &a2State, sipType_QString,&a3, &a3State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlName(*a0,*a1,*a2,*a3);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);
            sipReleaseType(const_cast<QString *>(a2),sipType_QString,a2State);
            sipReleaseType(const_cast<QString *>(a3),sipType_QString,a3State);

            return sipCpp;
        }
    }

    {
        const QXmlName* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QXmlName, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlName(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QXmlName[] = {
    {(void *)slot_QXmlName___hash__, hash_slot},
    {(void *)slot_QXmlName___ne__, ne_slot},
    {(void *)slot_QXmlName___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QXmlName[] = {
    {SIP_MLNAME_CAST(sipName_fromClarkName), meth_QXmlName_fromClarkName, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlName_fromClarkName)},
    {SIP_MLNAME_CAST(sipName_isNCName), meth_QXmlName_isNCName, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlName_isNCName)},
    {SIP_MLNAME_CAST(sipName_isNull), meth_QXmlName_isNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlName_isNull)},
    {SIP_MLNAME_CAST(sipName_localName), meth_QXmlName_localName, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlName_localName)},
    {SIP_MLNAME_CAST(sipName_namespaceUri), meth_QXmlName_namespaceUri, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlName_namespaceUri)},
    {SIP_MLNAME_CAST(sipName_prefix), meth_QXmlName_prefix, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlName_prefix)},
    {SIP_MLNAME_CAST(sipName_toClarkName), meth_QXmlName_toClarkName, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlName_toClarkName)}
};

PyDoc_STRVAR(doc_QXmlName, "\1QXmlName()\n"
    "QXmlName(QXmlNamePool, str, str namespaceUri='', str prefix='')\n"
    "QXmlName(QXmlName)");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QXmlName = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QXmlName,
        {0}
    },
    {
        sipNameNr_QXmlName,
        {0, 0, 1},
        7, methods_QXmlName,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QXmlName,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QXmlName,
    init_type_QXmlName,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QXmlName,
    assign_QXmlName,
    array_QXmlName,
    copy_QXmlName,
    release_QXmlName,
    cast_QXmlName,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlformatter.sip"
#include <qxmlformatter.h>
#line 3993 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlquery.sip"
#include <qxmlquery.h>
#line 3997 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qiodevice.sip"
#include <qiodevice.h>
#line 4000 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 274 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 4003 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlname.sip"
#include <qxmlname.h>
#line 4006 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 36 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 4009 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 801 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 4012 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qtextcodec.sip"
#include <qtextcodec.h>
#line 4015 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


class sipQXmlFormatter : public QXmlFormatter
{
public:
    sipQXmlFormatter(const QXmlQuery&,QIODevice*);
    virtual ~sipQXmlFormatter();

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void namespaceBinding(const QXmlName&);
    void endOfSequence();
    void startOfSequence();
    void endDocument();
    void startDocument();
    void atomicValue(const QVariant&);
    void processingInstruction(const QXmlName&,const QString&);
    void attribute(const QXmlName&,const QStringRef&);
    void endElement();
    void startElement(const QXmlName&);
    void comment(const QString&);
    void characters(const QStringRef&);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQXmlFormatter(const sipQXmlFormatter &);
    sipQXmlFormatter &operator = (const sipQXmlFormatter &);

    char sipPyMethods[12];
};

sipQXmlFormatter::sipQXmlFormatter(const QXmlQuery& a0,QIODevice*a1): QXmlFormatter(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQXmlFormatter::~sipQXmlFormatter()
{
    sipCommonDtor(sipPySelf);
}

void sipQXmlFormatter::namespaceBinding(const QXmlName& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_namespaceBinding);

    if (!sipMeth)
    {
        QXmlFormatter::namespaceBinding(a0);
        return;
    }

    extern void sipVH_QtXmlPatterns_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&);

    sipVH_QtXmlPatterns_2(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQXmlFormatter::endOfSequence()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_endOfSequence);

    if (!sipMeth)
    {
        QXmlFormatter::endOfSequence();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQXmlFormatter::startOfSequence()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_startOfSequence);

    if (!sipMeth)
    {
        QXmlFormatter::startOfSequence();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQXmlFormatter::endDocument()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_endDocument);

    if (!sipMeth)
    {
        QXmlFormatter::endDocument();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQXmlFormatter::startDocument()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_startDocument);

    if (!sipMeth)
    {
        QXmlFormatter::startDocument();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQXmlFormatter::atomicValue(const QVariant& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_atomicValue);

    if (!sipMeth)
    {
        QXmlFormatter::atomicValue(a0);
        return;
    }

    typedef void (*sipVH_QtCore_2)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QVariant&);

    ((sipVH_QtCore_2)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[2]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQXmlFormatter::processingInstruction(const QXmlName& a0,const QString& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_processingInstruction);

    if (!sipMeth)
    {
        QXmlFormatter::processingInstruction(a0,a1);
        return;
    }

    extern void sipVH_QtXmlPatterns_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&,const QString&);

    sipVH_QtXmlPatterns_0(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQXmlFormatter::attribute(const QXmlName& a0,const QStringRef& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,NULL,sipName_attribute);

    if (!sipMeth)
    {
        QXmlFormatter::attribute(a0,a1);
        return;
    }

    extern void sipVH_QtXmlPatterns_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&,const QStringRef&);

    sipVH_QtXmlPatterns_1(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQXmlFormatter::endElement()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[8],sipPySelf,NULL,sipName_endElement);

    if (!sipMeth)
    {
        QXmlFormatter::endElement();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQXmlFormatter::startElement(const QXmlName& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[9],sipPySelf,NULL,sipName_startElement);

    if (!sipMeth)
    {
        QXmlFormatter::startElement(a0);
        return;
    }

    extern void sipVH_QtXmlPatterns_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&);

    sipVH_QtXmlPatterns_2(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQXmlFormatter::comment(const QString& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[10],sipPySelf,NULL,sipName_comment);

    if (!sipMeth)
    {
        QXmlFormatter::comment(a0);
        return;
    }

    typedef void (*sipVH_QtCore_33)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    ((sipVH_QtCore_33)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[33]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQXmlFormatter::characters(const QStringRef& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[11],sipPySelf,NULL,sipName_characters);

    if (!sipMeth)
    {
        QXmlFormatter::characters(a0);
        return;
    }

    extern void sipVH_QtXmlPatterns_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QStringRef&);

    sipVH_QtXmlPatterns_3(sipGILState, 0, sipPySelf, sipMeth, a0);
}


PyDoc_STRVAR(doc_QXmlFormatter_characters, "QXmlFormatter.characters(QStringRef)");

extern "C" {static PyObject *meth_QXmlFormatter_characters(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_characters(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QStringRef* a0;
        int a0State = 0;
        QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QXmlFormatter, &sipCpp, sipType_QStringRef,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlFormatter::characters(*a0) : sipCpp->characters(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QStringRef *>(a0),sipType_QStringRef,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_characters, doc_QXmlFormatter_characters);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlFormatter_comment, "QXmlFormatter.comment(str)");

extern "C" {static PyObject *meth_QXmlFormatter_comment(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_comment(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QString* a0;
        int a0State = 0;
        QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QXmlFormatter, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlFormatter::comment(*a0) : sipCpp->comment(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_comment, doc_QXmlFormatter_comment);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlFormatter_startElement, "QXmlFormatter.startElement(QXmlName)");

extern "C" {static PyObject *meth_QXmlFormatter_startElement(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_startElement(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QXmlName* a0;
        QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QXmlFormatter, &sipCpp, sipType_QXmlName, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlFormatter::startElement(*a0) : sipCpp->startElement(*a0));
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_startElement, doc_QXmlFormatter_startElement);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlFormatter_endElement, "QXmlFormatter.endElement()");

extern "C" {static PyObject *meth_QXmlFormatter_endElement(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_endElement(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlFormatter, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlFormatter::endElement() : sipCpp->endElement());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_endElement, doc_QXmlFormatter_endElement);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlFormatter_attribute, "QXmlFormatter.attribute(QXmlName, QStringRef)");

extern "C" {static PyObject *meth_QXmlFormatter_attribute(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_attribute(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QXmlName* a0;
        const QStringRef* a1;
        int a1State = 0;
        QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9J1", &sipSelf, sipType_QXmlFormatter, &sipCpp, sipType_QXmlName, &a0, sipType_QStringRef,&a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlFormatter::attribute(*a0,*a1) : sipCpp->attribute(*a0,*a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QStringRef *>(a1),sipType_QStringRef,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_attribute, doc_QXmlFormatter_attribute);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlFormatter_processingInstruction, "QXmlFormatter.processingInstruction(QXmlName, str)");

extern "C" {static PyObject *meth_QXmlFormatter_processingInstruction(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_processingInstruction(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QXmlName* a0;
        const QString* a1;
        int a1State = 0;
        QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9J1", &sipSelf, sipType_QXmlFormatter, &sipCpp, sipType_QXmlName, &a0, sipType_QString,&a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlFormatter::processingInstruction(*a0,*a1) : sipCpp->processingInstruction(*a0,*a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_processingInstruction, doc_QXmlFormatter_processingInstruction);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlFormatter_atomicValue, "QXmlFormatter.atomicValue(object)");

extern "C" {static PyObject *meth_QXmlFormatter_atomicValue(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_atomicValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QVariant* a0;
        int a0State = 0;
        QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QXmlFormatter, &sipCpp, sipType_QVariant,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlFormatter::atomicValue(*a0) : sipCpp->atomicValue(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a0),sipType_QVariant,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_atomicValue, doc_QXmlFormatter_atomicValue);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlFormatter_startDocument, "QXmlFormatter.startDocument()");

extern "C" {static PyObject *meth_QXmlFormatter_startDocument(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_startDocument(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlFormatter, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlFormatter::startDocument() : sipCpp->startDocument());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_startDocument, doc_QXmlFormatter_startDocument);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlFormatter_endDocument, "QXmlFormatter.endDocument()");

extern "C" {static PyObject *meth_QXmlFormatter_endDocument(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_endDocument(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlFormatter, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlFormatter::endDocument() : sipCpp->endDocument());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_endDocument, doc_QXmlFormatter_endDocument);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlFormatter_startOfSequence, "QXmlFormatter.startOfSequence()");

extern "C" {static PyObject *meth_QXmlFormatter_startOfSequence(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_startOfSequence(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlFormatter, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlFormatter::startOfSequence() : sipCpp->startOfSequence());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_startOfSequence, doc_QXmlFormatter_startOfSequence);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlFormatter_endOfSequence, "QXmlFormatter.endOfSequence()");

extern "C" {static PyObject *meth_QXmlFormatter_endOfSequence(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_endOfSequence(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlFormatter, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlFormatter::endOfSequence() : sipCpp->endOfSequence());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_endOfSequence, doc_QXmlFormatter_endOfSequence);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlFormatter_indentationDepth, "QXmlFormatter.indentationDepth() -> int");

extern "C" {static PyObject *meth_QXmlFormatter_indentationDepth(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_indentationDepth(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlFormatter, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->indentationDepth();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_indentationDepth, doc_QXmlFormatter_indentationDepth);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlFormatter_setIndentationDepth, "QXmlFormatter.setIndentationDepth(int)");

extern "C" {static PyObject *meth_QXmlFormatter_setIndentationDepth(PyObject *, PyObject *);}
static PyObject *meth_QXmlFormatter_setIndentationDepth(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        QXmlFormatter *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QXmlFormatter, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setIndentationDepth(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlFormatter, sipName_setIndentationDepth, doc_QXmlFormatter_setIndentationDepth);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QXmlFormatter(void *, const sipTypeDef *);}
static void *cast_QXmlFormatter(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QXmlFormatter)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QXmlSerializer)->ctd_cast((QXmlSerializer *)(QXmlFormatter *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QXmlFormatter(void *, int);}
static void release_QXmlFormatter(void *sipCppV,int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQXmlFormatter *>(sipCppV);
    else
        delete reinterpret_cast<QXmlFormatter *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QXmlFormatter(sipSimpleWrapper *);}
static void dealloc_QXmlFormatter(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQXmlFormatter *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QXmlFormatter(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QXmlFormatter(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QXmlFormatter(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQXmlFormatter *sipCpp = 0;

    {
        const QXmlQuery* a0;
        QIODevice* a1;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9J8", sipType_QXmlQuery, &a0, sipType_QIODevice, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQXmlFormatter(*a0,a1);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QXmlFormatter[] = {{21, 255, 1}};


static PyMethodDef methods_QXmlFormatter[] = {
    {SIP_MLNAME_CAST(sipName_atomicValue), meth_QXmlFormatter_atomicValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_atomicValue)},
    {SIP_MLNAME_CAST(sipName_attribute), meth_QXmlFormatter_attribute, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_attribute)},
    {SIP_MLNAME_CAST(sipName_characters), meth_QXmlFormatter_characters, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_characters)},
    {SIP_MLNAME_CAST(sipName_comment), meth_QXmlFormatter_comment, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_comment)},
    {SIP_MLNAME_CAST(sipName_endDocument), meth_QXmlFormatter_endDocument, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_endDocument)},
    {SIP_MLNAME_CAST(sipName_endElement), meth_QXmlFormatter_endElement, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_endElement)},
    {SIP_MLNAME_CAST(sipName_endOfSequence), meth_QXmlFormatter_endOfSequence, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_endOfSequence)},
    {SIP_MLNAME_CAST(sipName_indentationDepth), meth_QXmlFormatter_indentationDepth, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_indentationDepth)},
    {SIP_MLNAME_CAST(sipName_processingInstruction), meth_QXmlFormatter_processingInstruction, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_processingInstruction)},
    {SIP_MLNAME_CAST(sipName_setIndentationDepth), meth_QXmlFormatter_setIndentationDepth, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_setIndentationDepth)},
    {SIP_MLNAME_CAST(sipName_startDocument), meth_QXmlFormatter_startDocument, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_startDocument)},
    {SIP_MLNAME_CAST(sipName_startElement), meth_QXmlFormatter_startElement, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_startElement)},
    {SIP_MLNAME_CAST(sipName_startOfSequence), meth_QXmlFormatter_startOfSequence, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlFormatter_startOfSequence)}
};

PyDoc_STRVAR(doc_QXmlFormatter, "\1QXmlFormatter(QXmlQuery, QIODevice)");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QXmlFormatter = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QXmlFormatter,
        {0}
    },
    {
        sipNameNr_QXmlFormatter,
        {0, 0, 1},
        13, methods_QXmlFormatter,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QXmlFormatter,
    -1,
    -1,
    supers_QXmlFormatter,
    0,
    init_type_QXmlFormatter,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QXmlFormatter,
    0,
    0,
    0,
    release_QXmlFormatter,
    cast_QXmlFormatter,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlserializer.sip"
#include <qxmlserializer.h>
#line 4822 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlquery.sip"
#include <qxmlquery.h>
#line 4826 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qiodevice.sip"
#include <qiodevice.h>
#line 4829 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qtextcodec.sip"
#include <qtextcodec.h>
#line 4832 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 274 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 4835 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlname.sip"
#include <qxmlname.h>
#line 4838 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 36 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 4841 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 801 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 4844 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


class sipQXmlSerializer : public QXmlSerializer
{
public:
    sipQXmlSerializer(const QXmlQuery&,QIODevice*);
    virtual ~sipQXmlSerializer();

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void endOfSequence();
    void startOfSequence();
    void endDocument();
    void startDocument();
    void atomicValue(const QVariant&);
    void processingInstruction(const QXmlName&,const QString&);
    void attribute(const QXmlName&,const QStringRef&);
    void endElement();
    void startElement(const QXmlName&);
    void comment(const QString&);
    void characters(const QStringRef&);
    void namespaceBinding(const QXmlName&);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQXmlSerializer(const sipQXmlSerializer &);
    sipQXmlSerializer &operator = (const sipQXmlSerializer &);

    char sipPyMethods[12];
};

sipQXmlSerializer::sipQXmlSerializer(const QXmlQuery& a0,QIODevice*a1): QXmlSerializer(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQXmlSerializer::~sipQXmlSerializer()
{
    sipCommonDtor(sipPySelf);
}

void sipQXmlSerializer::endOfSequence()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_endOfSequence);

    if (!sipMeth)
    {
        QXmlSerializer::endOfSequence();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQXmlSerializer::startOfSequence()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_startOfSequence);

    if (!sipMeth)
    {
        QXmlSerializer::startOfSequence();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQXmlSerializer::endDocument()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_endDocument);

    if (!sipMeth)
    {
        QXmlSerializer::endDocument();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQXmlSerializer::startDocument()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_startDocument);

    if (!sipMeth)
    {
        QXmlSerializer::startDocument();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQXmlSerializer::atomicValue(const QVariant& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_atomicValue);

    if (!sipMeth)
    {
        QXmlSerializer::atomicValue(a0);
        return;
    }

    typedef void (*sipVH_QtCore_2)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QVariant&);

    ((sipVH_QtCore_2)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[2]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQXmlSerializer::processingInstruction(const QXmlName& a0,const QString& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_processingInstruction);

    if (!sipMeth)
    {
        QXmlSerializer::processingInstruction(a0,a1);
        return;
    }

    extern void sipVH_QtXmlPatterns_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&,const QString&);

    sipVH_QtXmlPatterns_0(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQXmlSerializer::attribute(const QXmlName& a0,const QStringRef& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_attribute);

    if (!sipMeth)
    {
        QXmlSerializer::attribute(a0,a1);
        return;
    }

    extern void sipVH_QtXmlPatterns_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&,const QStringRef&);

    sipVH_QtXmlPatterns_1(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQXmlSerializer::endElement()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,NULL,sipName_endElement);

    if (!sipMeth)
    {
        QXmlSerializer::endElement();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQXmlSerializer::startElement(const QXmlName& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[8],sipPySelf,NULL,sipName_startElement);

    if (!sipMeth)
    {
        QXmlSerializer::startElement(a0);
        return;
    }

    extern void sipVH_QtXmlPatterns_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&);

    sipVH_QtXmlPatterns_2(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQXmlSerializer::comment(const QString& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[9],sipPySelf,NULL,sipName_comment);

    if (!sipMeth)
    {
        QXmlSerializer::comment(a0);
        return;
    }

    typedef void (*sipVH_QtCore_33)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    ((sipVH_QtCore_33)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[33]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQXmlSerializer::characters(const QStringRef& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[10],sipPySelf,NULL,sipName_characters);

    if (!sipMeth)
    {
        QXmlSerializer::characters(a0);
        return;
    }

    extern void sipVH_QtXmlPatterns_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QStringRef&);

    sipVH_QtXmlPatterns_3(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQXmlSerializer::namespaceBinding(const QXmlName& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[11],sipPySelf,NULL,sipName_namespaceBinding);

    if (!sipMeth)
    {
        QXmlSerializer::namespaceBinding(a0);
        return;
    }

    extern void sipVH_QtXmlPatterns_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&);

    sipVH_QtXmlPatterns_2(sipGILState, 0, sipPySelf, sipMeth, a0);
}


PyDoc_STRVAR(doc_QXmlSerializer_namespaceBinding, "QXmlSerializer.namespaceBinding(QXmlName)");

extern "C" {static PyObject *meth_QXmlSerializer_namespaceBinding(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_namespaceBinding(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QXmlName* a0;
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QXmlSerializer, &sipCpp, sipType_QXmlName, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlSerializer::namespaceBinding(*a0) : sipCpp->namespaceBinding(*a0));
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_namespaceBinding, doc_QXmlSerializer_namespaceBinding);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_characters, "QXmlSerializer.characters(QStringRef)");

extern "C" {static PyObject *meth_QXmlSerializer_characters(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_characters(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QStringRef* a0;
        int a0State = 0;
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QXmlSerializer, &sipCpp, sipType_QStringRef,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlSerializer::characters(*a0) : sipCpp->characters(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QStringRef *>(a0),sipType_QStringRef,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_characters, doc_QXmlSerializer_characters);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_comment, "QXmlSerializer.comment(str)");

extern "C" {static PyObject *meth_QXmlSerializer_comment(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_comment(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QString* a0;
        int a0State = 0;
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QXmlSerializer, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlSerializer::comment(*a0) : sipCpp->comment(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_comment, doc_QXmlSerializer_comment);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_startElement, "QXmlSerializer.startElement(QXmlName)");

extern "C" {static PyObject *meth_QXmlSerializer_startElement(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_startElement(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QXmlName* a0;
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QXmlSerializer, &sipCpp, sipType_QXmlName, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlSerializer::startElement(*a0) : sipCpp->startElement(*a0));
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_startElement, doc_QXmlSerializer_startElement);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_endElement, "QXmlSerializer.endElement()");

extern "C" {static PyObject *meth_QXmlSerializer_endElement(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_endElement(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSerializer, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlSerializer::endElement() : sipCpp->endElement());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_endElement, doc_QXmlSerializer_endElement);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_attribute, "QXmlSerializer.attribute(QXmlName, QStringRef)");

extern "C" {static PyObject *meth_QXmlSerializer_attribute(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_attribute(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QXmlName* a0;
        const QStringRef* a1;
        int a1State = 0;
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9J1", &sipSelf, sipType_QXmlSerializer, &sipCpp, sipType_QXmlName, &a0, sipType_QStringRef,&a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlSerializer::attribute(*a0,*a1) : sipCpp->attribute(*a0,*a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QStringRef *>(a1),sipType_QStringRef,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_attribute, doc_QXmlSerializer_attribute);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_processingInstruction, "QXmlSerializer.processingInstruction(QXmlName, str)");

extern "C" {static PyObject *meth_QXmlSerializer_processingInstruction(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_processingInstruction(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QXmlName* a0;
        const QString* a1;
        int a1State = 0;
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9J1", &sipSelf, sipType_QXmlSerializer, &sipCpp, sipType_QXmlName, &a0, sipType_QString,&a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlSerializer::processingInstruction(*a0,*a1) : sipCpp->processingInstruction(*a0,*a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_processingInstruction, doc_QXmlSerializer_processingInstruction);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_atomicValue, "QXmlSerializer.atomicValue(object)");

extern "C" {static PyObject *meth_QXmlSerializer_atomicValue(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_atomicValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QVariant* a0;
        int a0State = 0;
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QXmlSerializer, &sipCpp, sipType_QVariant,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlSerializer::atomicValue(*a0) : sipCpp->atomicValue(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a0),sipType_QVariant,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_atomicValue, doc_QXmlSerializer_atomicValue);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_startDocument, "QXmlSerializer.startDocument()");

extern "C" {static PyObject *meth_QXmlSerializer_startDocument(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_startDocument(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSerializer, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlSerializer::startDocument() : sipCpp->startDocument());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_startDocument, doc_QXmlSerializer_startDocument);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_endDocument, "QXmlSerializer.endDocument()");

extern "C" {static PyObject *meth_QXmlSerializer_endDocument(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_endDocument(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSerializer, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlSerializer::endDocument() : sipCpp->endDocument());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_endDocument, doc_QXmlSerializer_endDocument);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_startOfSequence, "QXmlSerializer.startOfSequence()");

extern "C" {static PyObject *meth_QXmlSerializer_startOfSequence(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_startOfSequence(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSerializer, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlSerializer::startOfSequence() : sipCpp->startOfSequence());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_startOfSequence, doc_QXmlSerializer_startOfSequence);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_endOfSequence, "QXmlSerializer.endOfSequence()");

extern "C" {static PyObject *meth_QXmlSerializer_endOfSequence(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_endOfSequence(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSerializer, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QXmlSerializer::endOfSequence() : sipCpp->endOfSequence());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_endOfSequence, doc_QXmlSerializer_endOfSequence);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_outputDevice, "QXmlSerializer.outputDevice() -> QIODevice");

extern "C" {static PyObject *meth_QXmlSerializer_outputDevice(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_outputDevice(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSerializer, &sipCpp))
        {
            QIODevice*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->outputDevice();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QIODevice,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_outputDevice, doc_QXmlSerializer_outputDevice);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_setCodec, "QXmlSerializer.setCodec(QTextCodec)");

extern "C" {static PyObject *meth_QXmlSerializer_setCodec(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_setCodec(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QTextCodec* a0;
        PyObject *a0Keep;
        QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QXmlSerializer, &sipCpp, &a0Keep, sipType_QTextCodec, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setCodec(a0);
            Py_END_ALLOW_THREADS

            sipKeepReference(sipSelf, -11, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_setCodec, doc_QXmlSerializer_setCodec);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlSerializer_codec, "QXmlSerializer.codec() -> QTextCodec");

extern "C" {static PyObject *meth_QXmlSerializer_codec(PyObject *, PyObject *);}
static PyObject *meth_QXmlSerializer_codec(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlSerializer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlSerializer, &sipCpp))
        {
            const QTextCodec*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->codec();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(const_cast<QTextCodec *>(sipRes),sipType_QTextCodec,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlSerializer, sipName_codec, doc_QXmlSerializer_codec);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QXmlSerializer(void *, const sipTypeDef *);}
static void *cast_QXmlSerializer(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QXmlSerializer)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QAbstractXmlReceiver)->ctd_cast((QAbstractXmlReceiver *)(QXmlSerializer *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QXmlSerializer(void *, int);}
static void release_QXmlSerializer(void *sipCppV,int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQXmlSerializer *>(sipCppV);
    else
        delete reinterpret_cast<QXmlSerializer *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QXmlSerializer(sipSimpleWrapper *);}
static void dealloc_QXmlSerializer(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQXmlSerializer *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QXmlSerializer(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QXmlSerializer(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QXmlSerializer(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQXmlSerializer *sipCpp = 0;

    {
        const QXmlQuery* a0;
        QIODevice* a1;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9J8", sipType_QXmlQuery, &a0, sipType_QIODevice, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQXmlSerializer(*a0,a1);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QXmlSerializer[] = {{4, 255, 1}};


static PyMethodDef methods_QXmlSerializer[] = {
    {SIP_MLNAME_CAST(sipName_atomicValue), meth_QXmlSerializer_atomicValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_atomicValue)},
    {SIP_MLNAME_CAST(sipName_attribute), meth_QXmlSerializer_attribute, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_attribute)},
    {SIP_MLNAME_CAST(sipName_characters), meth_QXmlSerializer_characters, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_characters)},
    {SIP_MLNAME_CAST(sipName_codec), meth_QXmlSerializer_codec, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_codec)},
    {SIP_MLNAME_CAST(sipName_comment), meth_QXmlSerializer_comment, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_comment)},
    {SIP_MLNAME_CAST(sipName_endDocument), meth_QXmlSerializer_endDocument, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_endDocument)},
    {SIP_MLNAME_CAST(sipName_endElement), meth_QXmlSerializer_endElement, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_endElement)},
    {SIP_MLNAME_CAST(sipName_endOfSequence), meth_QXmlSerializer_endOfSequence, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_endOfSequence)},
    {SIP_MLNAME_CAST(sipName_namespaceBinding), meth_QXmlSerializer_namespaceBinding, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_namespaceBinding)},
    {SIP_MLNAME_CAST(sipName_outputDevice), meth_QXmlSerializer_outputDevice, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_outputDevice)},
    {SIP_MLNAME_CAST(sipName_processingInstruction), meth_QXmlSerializer_processingInstruction, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_processingInstruction)},
    {SIP_MLNAME_CAST(sipName_setCodec), meth_QXmlSerializer_setCodec, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_setCodec)},
    {SIP_MLNAME_CAST(sipName_startDocument), meth_QXmlSerializer_startDocument, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_startDocument)},
    {SIP_MLNAME_CAST(sipName_startElement), meth_QXmlSerializer_startElement, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_startElement)},
    {SIP_MLNAME_CAST(sipName_startOfSequence), meth_QXmlSerializer_startOfSequence, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlSerializer_startOfSequence)}
};

PyDoc_STRVAR(doc_QXmlSerializer, "\1QXmlSerializer(QXmlQuery, QIODevice)");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QXmlSerializer = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QXmlSerializer,
        {0}
    },
    {
        sipNameNr_QXmlSerializer,
        {0, 0, 1},
        15, methods_QXmlSerializer,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QXmlSerializer,
    -1,
    -1,
    supers_QXmlSerializer,
    0,
    init_type_QXmlSerializer,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QXmlSerializer,
    0,
    0,
    0,
    release_QXmlSerializer,
    cast_QXmlSerializer,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qsourcelocation.sip"
#include <qsourcelocation.h>
#line 5715 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 107 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qurl.sip"
#include <qurl.h>
#line 5719 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


PyDoc_STRVAR(doc_QSourceLocation_column, "QSourceLocation.column() -> int");

extern "C" {static PyObject *meth_QSourceLocation_column(PyObject *, PyObject *);}
static PyObject *meth_QSourceLocation_column(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSourceLocation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSourceLocation, &sipCpp))
        {
            qint64 sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->column();
            Py_END_ALLOW_THREADS

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSourceLocation, sipName_column, doc_QSourceLocation_column);

    return NULL;
}


PyDoc_STRVAR(doc_QSourceLocation_setColumn, "QSourceLocation.setColumn(int)");

extern "C" {static PyObject *meth_QSourceLocation_setColumn(PyObject *, PyObject *);}
static PyObject *meth_QSourceLocation_setColumn(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        qint64 a0;
        QSourceLocation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bn", &sipSelf, sipType_QSourceLocation, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setColumn(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSourceLocation, sipName_setColumn, doc_QSourceLocation_setColumn);

    return NULL;
}


PyDoc_STRVAR(doc_QSourceLocation_line, "QSourceLocation.line() -> int");

extern "C" {static PyObject *meth_QSourceLocation_line(PyObject *, PyObject *);}
static PyObject *meth_QSourceLocation_line(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSourceLocation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSourceLocation, &sipCpp))
        {
            qint64 sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->line();
            Py_END_ALLOW_THREADS

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSourceLocation, sipName_line, doc_QSourceLocation_line);

    return NULL;
}


PyDoc_STRVAR(doc_QSourceLocation_setLine, "QSourceLocation.setLine(int)");

extern "C" {static PyObject *meth_QSourceLocation_setLine(PyObject *, PyObject *);}
static PyObject *meth_QSourceLocation_setLine(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        qint64 a0;
        QSourceLocation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bn", &sipSelf, sipType_QSourceLocation, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setLine(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSourceLocation, sipName_setLine, doc_QSourceLocation_setLine);

    return NULL;
}


PyDoc_STRVAR(doc_QSourceLocation_uri, "QSourceLocation.uri() -> QUrl");

extern "C" {static PyObject *meth_QSourceLocation_uri(PyObject *, PyObject *);}
static PyObject *meth_QSourceLocation_uri(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSourceLocation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSourceLocation, &sipCpp))
        {
            QUrl*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QUrl(sipCpp->uri());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QUrl,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSourceLocation, sipName_uri, doc_QSourceLocation_uri);

    return NULL;
}


PyDoc_STRVAR(doc_QSourceLocation_setUri, "QSourceLocation.setUri(QUrl)");

extern "C" {static PyObject *meth_QSourceLocation_setUri(PyObject *, PyObject *);}
static PyObject *meth_QSourceLocation_setUri(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QUrl* a0;
        QSourceLocation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSourceLocation, &sipCpp, sipType_QUrl, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUri(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSourceLocation, sipName_setUri, doc_QSourceLocation_setUri);

    return NULL;
}


PyDoc_STRVAR(doc_QSourceLocation_isNull, "QSourceLocation.isNull() -> bool");

extern "C" {static PyObject *meth_QSourceLocation_isNull(PyObject *, PyObject *);}
static PyObject *meth_QSourceLocation_isNull(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSourceLocation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSourceLocation, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isNull();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSourceLocation, sipName_isNull, doc_QSourceLocation_isNull);

    return NULL;
}


extern "C" {static long slot_QSourceLocation___hash__(PyObject *);}
static long slot_QSourceLocation___hash__(PyObject *sipSelf)
{
    QSourceLocation *sipCpp = reinterpret_cast<QSourceLocation *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSourceLocation));

    if (!sipCpp)
        return 0;


    {
        {
            long sipRes = 0;

#line 52 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qsourcelocation.sip"
        sipRes = qHash(*sipCpp);
#line 5940 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QSourceLocation___ne__(PyObject *,PyObject *);}
static PyObject *slot_QSourceLocation___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QSourceLocation *sipCpp = reinterpret_cast<QSourceLocation *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSourceLocation));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QSourceLocation* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QSourceLocation, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->QSourceLocation::operator!=(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtXmlPatterns,ne_slot,sipType_QSourceLocation,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QSourceLocation___eq__(PyObject *,PyObject *);}
static PyObject *slot_QSourceLocation___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QSourceLocation *sipCpp = reinterpret_cast<QSourceLocation *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSourceLocation));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QSourceLocation* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QSourceLocation, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->QSourceLocation::operator==(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtXmlPatterns,eq_slot,sipType_QSourceLocation,sipSelf,sipArg);
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSourceLocation(void *, const sipTypeDef *);}
static void *cast_QSourceLocation(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QSourceLocation)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSourceLocation(void *, int);}
static void release_QSourceLocation(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QSourceLocation *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QSourceLocation(void *, SIP_SSIZE_T, const void *);}
static void assign_QSourceLocation(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QSourceLocation *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QSourceLocation *>(sipSrc);
}


extern "C" {static void *array_QSourceLocation(SIP_SSIZE_T);}
static void *array_QSourceLocation(SIP_SSIZE_T sipNrElem)
{
    return new QSourceLocation[sipNrElem];
}


extern "C" {static void *copy_QSourceLocation(const void *, SIP_SSIZE_T);}
static void *copy_QSourceLocation(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QSourceLocation(reinterpret_cast<const QSourceLocation *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QSourceLocation(sipSimpleWrapper *);}
static void dealloc_QSourceLocation(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QSourceLocation(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QSourceLocation(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSourceLocation(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QSourceLocation *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSourceLocation();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QSourceLocation* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QSourceLocation, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSourceLocation(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QUrl* a0;
        int a1 = -1;
        int a2 = -1;

        static const char *sipKwdList[] = {
            NULL,
            sipName_line,
            sipName_column,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9|ii", sipType_QUrl, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSourceLocation(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QSourceLocation[] = {
    {(void *)slot_QSourceLocation___hash__, hash_slot},
    {(void *)slot_QSourceLocation___ne__, ne_slot},
    {(void *)slot_QSourceLocation___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QSourceLocation[] = {
    {SIP_MLNAME_CAST(sipName_column), meth_QSourceLocation_column, METH_VARARGS, SIP_MLDOC_CAST(doc_QSourceLocation_column)},
    {SIP_MLNAME_CAST(sipName_isNull), meth_QSourceLocation_isNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QSourceLocation_isNull)},
    {SIP_MLNAME_CAST(sipName_line), meth_QSourceLocation_line, METH_VARARGS, SIP_MLDOC_CAST(doc_QSourceLocation_line)},
    {SIP_MLNAME_CAST(sipName_setColumn), meth_QSourceLocation_setColumn, METH_VARARGS, SIP_MLDOC_CAST(doc_QSourceLocation_setColumn)},
    {SIP_MLNAME_CAST(sipName_setLine), meth_QSourceLocation_setLine, METH_VARARGS, SIP_MLDOC_CAST(doc_QSourceLocation_setLine)},
    {SIP_MLNAME_CAST(sipName_setUri), meth_QSourceLocation_setUri, METH_VARARGS, SIP_MLDOC_CAST(doc_QSourceLocation_setUri)},
    {SIP_MLNAME_CAST(sipName_uri), meth_QSourceLocation_uri, METH_VARARGS, SIP_MLDOC_CAST(doc_QSourceLocation_uri)}
};

PyDoc_STRVAR(doc_QSourceLocation, "\1QSourceLocation()\n"
    "QSourceLocation(QSourceLocation)\n"
    "QSourceLocation(QUrl, int line=-1, int column=-1)");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QSourceLocation = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QSourceLocation,
        {0}
    },
    {
        sipNameNr_QSourceLocation,
        {0, 0, 1},
        7, methods_QSourceLocation,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSourceLocation,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QSourceLocation,
    init_type_QSourceLocation,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSourceLocation,
    assign_QSourceLocation,
    array_QSourceLocation,
    copy_QSourceLocation,
    release_QSourceLocation,
    cast_QSourceLocation,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qsimplexmlnodemodel.sip"
#include <qsimplexmlnodemodel.h>
#line 6206 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlnamepool.sip"
#include <qxmlnamepool.h>
#line 6210 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvector.sip"
#include <qvector.h>
#line 6213 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 6216 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlname.sip"
#include <qxmlname.h>
#line 6219 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 36 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 6222 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvector.sip"
#include <qvector.h>
#line 6225 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 107 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qurl.sip"
#include <qurl.h>
#line 6228 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 86 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 6231 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qsourcelocation.sip"
#include <qsourcelocation.h>
#line 6234 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 274 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 6237 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


class sipQSimpleXmlNodeModel : public QSimpleXmlNodeModel
{
public:
    sipQSimpleXmlNodeModel(const QXmlNamePool&);
    virtual ~sipQSimpleXmlNodeModel();

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QXmlNodeModelIndex sipProtect_nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis,const QXmlNodeModelIndex&) const;
    QVector<QXmlNodeModelIndex> sipProtect_attributes(const QXmlNodeModelIndex&) const;
    QXmlNodeModelIndex sipProtect_createIndex(qint64) const;
    QXmlNodeModelIndex sipProtect_createIndex(qint64,qint64) const;
    QXmlNodeModelIndex sipProtect_createIndex(void*,qint64) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    QVector<QXmlNodeModelIndex> attributes(const QXmlNodeModelIndex&) const;
    QXmlNodeModelIndex nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis,const QXmlNodeModelIndex&) const;
    QVariant typedValue(const QXmlNodeModelIndex&) const;
    QXmlName name(const QXmlNodeModelIndex&) const;
    QXmlNodeModelIndex root(const QXmlNodeModelIndex&) const;
    QXmlNodeModelIndex::DocumentOrder compareOrder(const QXmlNodeModelIndex&,const QXmlNodeModelIndex&) const;
    QXmlNodeModelIndex::NodeKind kind(const QXmlNodeModelIndex&) const;
    QUrl documentUri(const QXmlNodeModelIndex&) const;
    QVector<QXmlNodeModelIndex> nodesByIdref(const QXmlName&) const;
    QXmlNodeModelIndex elementById(const QXmlName&) const;
    QString stringValue(const QXmlNodeModelIndex&) const;
    QVector<QXmlName> namespaceBindings(const QXmlNodeModelIndex&) const;
    QUrl baseUri(const QXmlNodeModelIndex&) const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQSimpleXmlNodeModel(const sipQSimpleXmlNodeModel &);
    sipQSimpleXmlNodeModel &operator = (const sipQSimpleXmlNodeModel &);

    char sipPyMethods[13];
};

sipQSimpleXmlNodeModel::sipQSimpleXmlNodeModel(const QXmlNamePool& a0): QSimpleXmlNodeModel(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSimpleXmlNodeModel::~sipQSimpleXmlNodeModel()
{
    sipCommonDtor(sipPySelf);
}

QVector<QXmlNodeModelIndex> sipQSimpleXmlNodeModel::attributes(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[0]),sipPySelf,sipName_QSimpleXmlNodeModel,sipName_attributes);

    if (!sipMeth)
        return QVector<QXmlNodeModelIndex>();

    extern QVector<QXmlNodeModelIndex> sipVH_QtXmlPatterns_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_9(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QXmlNodeModelIndex sipQSimpleXmlNodeModel::nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis a0,const QXmlNodeModelIndex& a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[1]),sipPySelf,sipName_QSimpleXmlNodeModel,sipName_nextFromSimpleAxis);

    if (!sipMeth)
        return QXmlNodeModelIndex();

    extern QXmlNodeModelIndex sipVH_QtXmlPatterns_10(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QAbstractXmlNodeModel::SimpleAxis,const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_10(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QVariant sipQSimpleXmlNodeModel::typedValue(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[2]),sipPySelf,sipName_QSimpleXmlNodeModel,sipName_typedValue);

    if (!sipMeth)
        return QVariant();

    extern QVariant sipVH_QtXmlPatterns_11(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_11(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QXmlName sipQSimpleXmlNodeModel::name(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[3]),sipPySelf,sipName_QSimpleXmlNodeModel,sipName_name);

    if (!sipMeth)
        return QXmlName();

    extern QXmlName sipVH_QtXmlPatterns_12(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_12(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QXmlNodeModelIndex sipQSimpleXmlNodeModel::root(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[4]),sipPySelf,sipName_QSimpleXmlNodeModel,sipName_root);

    if (!sipMeth)
        return QXmlNodeModelIndex();

    extern QXmlNodeModelIndex sipVH_QtXmlPatterns_13(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_13(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QXmlNodeModelIndex::DocumentOrder sipQSimpleXmlNodeModel::compareOrder(const QXmlNodeModelIndex& a0,const QXmlNodeModelIndex& a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[5]),sipPySelf,sipName_QSimpleXmlNodeModel,sipName_compareOrder);

    if (!sipMeth)
        return (QXmlNodeModelIndex::DocumentOrder)0;

    extern QXmlNodeModelIndex::DocumentOrder sipVH_QtXmlPatterns_14(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&,const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_14(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QXmlNodeModelIndex::NodeKind sipQSimpleXmlNodeModel::kind(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[6]),sipPySelf,sipName_QSimpleXmlNodeModel,sipName_kind);

    if (!sipMeth)
        return (QXmlNodeModelIndex::NodeKind)0;

    extern QXmlNodeModelIndex::NodeKind sipVH_QtXmlPatterns_15(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_15(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QUrl sipQSimpleXmlNodeModel::documentUri(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[7]),sipPySelf,sipName_QSimpleXmlNodeModel,sipName_documentUri);

    if (!sipMeth)
        return QUrl();

    extern QUrl sipVH_QtXmlPatterns_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_8(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QVector<QXmlNodeModelIndex> sipQSimpleXmlNodeModel::nodesByIdref(const QXmlName& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[8]),sipPySelf,NULL,sipName_nodesByIdref);

    if (!sipMeth)
        return QSimpleXmlNodeModel::nodesByIdref(a0);

    extern QVector<QXmlNodeModelIndex> sipVH_QtXmlPatterns_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&);

    return sipVH_QtXmlPatterns_4(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QXmlNodeModelIndex sipQSimpleXmlNodeModel::elementById(const QXmlName& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[9]),sipPySelf,NULL,sipName_elementById);

    if (!sipMeth)
        return QSimpleXmlNodeModel::elementById(a0);

    extern QXmlNodeModelIndex sipVH_QtXmlPatterns_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&);

    return sipVH_QtXmlPatterns_5(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QString sipQSimpleXmlNodeModel::stringValue(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[10]),sipPySelf,NULL,sipName_stringValue);

    if (!sipMeth)
        return QSimpleXmlNodeModel::stringValue(a0);

    extern QString sipVH_QtXmlPatterns_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_6(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QVector<QXmlName> sipQSimpleXmlNodeModel::namespaceBindings(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[11]),sipPySelf,NULL,sipName_namespaceBindings);

    if (!sipMeth)
        return QSimpleXmlNodeModel::namespaceBindings(a0);

    extern QVector<QXmlName> sipVH_QtXmlPatterns_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_7(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QUrl sipQSimpleXmlNodeModel::baseUri(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[12]),sipPySelf,NULL,sipName_baseUri);

    if (!sipMeth)
        return QSimpleXmlNodeModel::baseUri(a0);

    extern QUrl sipVH_QtXmlPatterns_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_8(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QXmlNodeModelIndex sipQSimpleXmlNodeModel::sipProtect_nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis a0,const QXmlNodeModelIndex& a1) const
{
    return nextFromSimpleAxis(a0,a1);
}

QVector<QXmlNodeModelIndex> sipQSimpleXmlNodeModel::sipProtect_attributes(const QXmlNodeModelIndex& a0) const
{
    return attributes(a0);
}

QXmlNodeModelIndex sipQSimpleXmlNodeModel::sipProtect_createIndex(qint64 a0) const
{
    return QAbstractXmlNodeModel::createIndex(a0);
}

QXmlNodeModelIndex sipQSimpleXmlNodeModel::sipProtect_createIndex(qint64 a0,qint64 a1) const
{
    return QAbstractXmlNodeModel::createIndex(a0,a1);
}

QXmlNodeModelIndex sipQSimpleXmlNodeModel::sipProtect_createIndex(void*a0,qint64 a1) const
{
    return QAbstractXmlNodeModel::createIndex(a0,a1);
}


PyDoc_STRVAR(doc_QSimpleXmlNodeModel_nextFromSimpleAxis, "QSimpleXmlNodeModel.nextFromSimpleAxis(QAbstractXmlNodeModel.SimpleAxis, QXmlNodeModelIndex) -> QXmlNodeModelIndex");

extern "C" {static PyObject *meth_QSimpleXmlNodeModel_nextFromSimpleAxis(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSimpleXmlNodeModel_nextFromSimpleAxis(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        QAbstractXmlNodeModel::SimpleAxis a0;
        const QXmlNodeModelIndex* a1;
        const sipQSimpleXmlNodeModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BEJ9", &sipSelf, sipType_QSimpleXmlNodeModel, &sipCpp, sipType_QAbstractXmlNodeModel_SimpleAxis, &a0, sipType_QXmlNodeModelIndex, &a1))
        {
            QXmlNodeModelIndex*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSimpleXmlNodeModel, sipName_nextFromSimpleAxis);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNodeModelIndex(sipCpp->sipProtect_nextFromSimpleAxis(a0,*a1));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNodeModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSimpleXmlNodeModel, sipName_nextFromSimpleAxis, doc_QSimpleXmlNodeModel_nextFromSimpleAxis);

    return NULL;
}


PyDoc_STRVAR(doc_QSimpleXmlNodeModel_attributes, "QSimpleXmlNodeModel.attributes(QXmlNodeModelIndex) -> list-of-QXmlNodeModelIndex");

extern "C" {static PyObject *meth_QSimpleXmlNodeModel_attributes(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSimpleXmlNodeModel_attributes(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlNodeModelIndex* a0;
        const sipQSimpleXmlNodeModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSimpleXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QVector<QXmlNodeModelIndex>*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSimpleXmlNodeModel, sipName_attributes);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVector<QXmlNodeModelIndex>(sipCpp->sipProtect_attributes(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVector_0100QXmlNodeModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSimpleXmlNodeModel, sipName_attributes, doc_QSimpleXmlNodeModel_attributes);

    return NULL;
}


PyDoc_STRVAR(doc_QSimpleXmlNodeModel_createIndex, "QSimpleXmlNodeModel.createIndex(int) -> QXmlNodeModelIndex\n"
    "QSimpleXmlNodeModel.createIndex(int, int) -> QXmlNodeModelIndex\n"
    "QSimpleXmlNodeModel.createIndex(object, int additionalData=0) -> QXmlNodeModelIndex");

extern "C" {static PyObject *meth_QSimpleXmlNodeModel_createIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSimpleXmlNodeModel_createIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        qint64 a0;
        const sipQSimpleXmlNodeModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bn", &sipSelf, sipType_QSimpleXmlNodeModel, &sipCpp, &a0))
        {
            QXmlNodeModelIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNodeModelIndex(sipCpp->sipProtect_createIndex(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNodeModelIndex,NULL);
        }
    }

    {
        qint64 a0;
        qint64 a1;
        const sipQSimpleXmlNodeModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bnn", &sipSelf, sipType_QSimpleXmlNodeModel, &sipCpp, &a0, &a1))
        {
            QXmlNodeModelIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNodeModelIndex(sipCpp->sipProtect_createIndex(a0,a1));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNodeModelIndex,NULL);
        }
    }

    {
        PyObject * a0;
        qint64 a1 = 0;
        const sipQSimpleXmlNodeModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_additionalData,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BP0|n", &sipSelf, sipType_QSimpleXmlNodeModel, &sipCpp, &a0, &a1))
        {
            QXmlNodeModelIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNodeModelIndex(sipCpp->sipProtect_createIndex(a0,a1));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNodeModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSimpleXmlNodeModel, sipName_createIndex, doc_QSimpleXmlNodeModel_createIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSimpleXmlNodeModel_baseUri, "QSimpleXmlNodeModel.baseUri(QXmlNodeModelIndex) -> QUrl");

extern "C" {static PyObject *meth_QSimpleXmlNodeModel_baseUri(PyObject *, PyObject *);}
static PyObject *meth_QSimpleXmlNodeModel_baseUri(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QXmlNodeModelIndex* a0;
        const QSimpleXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSimpleXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QUrl*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QUrl((sipSelfWasArg ? sipCpp->QSimpleXmlNodeModel::baseUri(*a0) : sipCpp->baseUri(*a0)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QUrl,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSimpleXmlNodeModel, sipName_baseUri, doc_QSimpleXmlNodeModel_baseUri);

    return NULL;
}


PyDoc_STRVAR(doc_QSimpleXmlNodeModel_namePool, "QSimpleXmlNodeModel.namePool() -> QXmlNamePool");

extern "C" {static PyObject *meth_QSimpleXmlNodeModel_namePool(PyObject *, PyObject *);}
static PyObject *meth_QSimpleXmlNodeModel_namePool(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSimpleXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSimpleXmlNodeModel, &sipCpp))
        {
            QXmlNamePool*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = &sipCpp->namePool();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QXmlNamePool,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSimpleXmlNodeModel, sipName_namePool, doc_QSimpleXmlNodeModel_namePool);

    return NULL;
}


PyDoc_STRVAR(doc_QSimpleXmlNodeModel_namespaceBindings, "QSimpleXmlNodeModel.namespaceBindings(QXmlNodeModelIndex) -> list-of-QXmlName");

extern "C" {static PyObject *meth_QSimpleXmlNodeModel_namespaceBindings(PyObject *, PyObject *);}
static PyObject *meth_QSimpleXmlNodeModel_namespaceBindings(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QXmlNodeModelIndex* a0;
        const QSimpleXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSimpleXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QVector<QXmlName>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVector<QXmlName>((sipSelfWasArg ? sipCpp->QSimpleXmlNodeModel::namespaceBindings(*a0) : sipCpp->namespaceBindings(*a0)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVector_0100QXmlName,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSimpleXmlNodeModel, sipName_namespaceBindings, doc_QSimpleXmlNodeModel_namespaceBindings);

    return NULL;
}


PyDoc_STRVAR(doc_QSimpleXmlNodeModel_stringValue, "QSimpleXmlNodeModel.stringValue(QXmlNodeModelIndex) -> str");

extern "C" {static PyObject *meth_QSimpleXmlNodeModel_stringValue(PyObject *, PyObject *);}
static PyObject *meth_QSimpleXmlNodeModel_stringValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QXmlNodeModelIndex* a0;
        const QSimpleXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSimpleXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString((sipSelfWasArg ? sipCpp->QSimpleXmlNodeModel::stringValue(*a0) : sipCpp->stringValue(*a0)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSimpleXmlNodeModel, sipName_stringValue, doc_QSimpleXmlNodeModel_stringValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSimpleXmlNodeModel_elementById, "QSimpleXmlNodeModel.elementById(QXmlName) -> QXmlNodeModelIndex");

extern "C" {static PyObject *meth_QSimpleXmlNodeModel_elementById(PyObject *, PyObject *);}
static PyObject *meth_QSimpleXmlNodeModel_elementById(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QXmlName* a0;
        const QSimpleXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSimpleXmlNodeModel, &sipCpp, sipType_QXmlName, &a0))
        {
            QXmlNodeModelIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNodeModelIndex((sipSelfWasArg ? sipCpp->QSimpleXmlNodeModel::elementById(*a0) : sipCpp->elementById(*a0)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNodeModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSimpleXmlNodeModel, sipName_elementById, doc_QSimpleXmlNodeModel_elementById);

    return NULL;
}


PyDoc_STRVAR(doc_QSimpleXmlNodeModel_nodesByIdref, "QSimpleXmlNodeModel.nodesByIdref(QXmlName) -> list-of-QXmlNodeModelIndex");

extern "C" {static PyObject *meth_QSimpleXmlNodeModel_nodesByIdref(PyObject *, PyObject *);}
static PyObject *meth_QSimpleXmlNodeModel_nodesByIdref(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QXmlName* a0;
        const QSimpleXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSimpleXmlNodeModel, &sipCpp, sipType_QXmlName, &a0))
        {
            QVector<QXmlNodeModelIndex>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVector<QXmlNodeModelIndex>((sipSelfWasArg ? sipCpp->QSimpleXmlNodeModel::nodesByIdref(*a0) : sipCpp->nodesByIdref(*a0)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVector_0100QXmlNodeModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSimpleXmlNodeModel, sipName_nodesByIdref, doc_QSimpleXmlNodeModel_nodesByIdref);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSimpleXmlNodeModel(void *, const sipTypeDef *);}
static void *cast_QSimpleXmlNodeModel(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QSimpleXmlNodeModel)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QAbstractXmlNodeModel)->ctd_cast((QAbstractXmlNodeModel *)(QSimpleXmlNodeModel *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSimpleXmlNodeModel(void *, int);}
static void release_QSimpleXmlNodeModel(void *sipCppV,int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQSimpleXmlNodeModel *>(sipCppV);
    else
        delete reinterpret_cast<QSimpleXmlNodeModel *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QSimpleXmlNodeModel(sipSimpleWrapper *);}
static void dealloc_QSimpleXmlNodeModel(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQSimpleXmlNodeModel *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QSimpleXmlNodeModel(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QSimpleXmlNodeModel(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSimpleXmlNodeModel(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQSimpleXmlNodeModel *sipCpp = 0;

    {
        const QXmlNamePool* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QXmlNamePool, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSimpleXmlNodeModel(*a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QSimpleXmlNodeModel[] = {{2, 255, 1}};


static PyMethodDef methods_QSimpleXmlNodeModel[] = {
    {SIP_MLNAME_CAST(sipName_attributes), (PyCFunction)meth_QSimpleXmlNodeModel_attributes, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_baseUri), meth_QSimpleXmlNodeModel_baseUri, METH_VARARGS, SIP_MLDOC_CAST(doc_QSimpleXmlNodeModel_baseUri)},
    {SIP_MLNAME_CAST(sipName_createIndex), (PyCFunction)meth_QSimpleXmlNodeModel_createIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_elementById), meth_QSimpleXmlNodeModel_elementById, METH_VARARGS, SIP_MLDOC_CAST(doc_QSimpleXmlNodeModel_elementById)},
    {SIP_MLNAME_CAST(sipName_namePool), meth_QSimpleXmlNodeModel_namePool, METH_VARARGS, SIP_MLDOC_CAST(doc_QSimpleXmlNodeModel_namePool)},
    {SIP_MLNAME_CAST(sipName_namespaceBindings), meth_QSimpleXmlNodeModel_namespaceBindings, METH_VARARGS, SIP_MLDOC_CAST(doc_QSimpleXmlNodeModel_namespaceBindings)},
    {SIP_MLNAME_CAST(sipName_nextFromSimpleAxis), (PyCFunction)meth_QSimpleXmlNodeModel_nextFromSimpleAxis, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_nodesByIdref), meth_QSimpleXmlNodeModel_nodesByIdref, METH_VARARGS, SIP_MLDOC_CAST(doc_QSimpleXmlNodeModel_nodesByIdref)},
    {SIP_MLNAME_CAST(sipName_stringValue), meth_QSimpleXmlNodeModel_stringValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QSimpleXmlNodeModel_stringValue)}
};

PyDoc_STRVAR(doc_QSimpleXmlNodeModel, "\1QSimpleXmlNodeModel(QXmlNamePool)");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QSimpleXmlNodeModel = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_CLASS,
        sipNameNr_QSimpleXmlNodeModel,
        {0}
    },
    {
        sipNameNr_QSimpleXmlNodeModel,
        {0, 0, 1},
        9, methods_QSimpleXmlNodeModel,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSimpleXmlNodeModel,
    -1,
    -1,
    supers_QSimpleXmlNodeModel,
    0,
    init_type_QSimpleXmlNodeModel,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSimpleXmlNodeModel,
    0,
    0,
    0,
    release_QSimpleXmlNodeModel,
    cast_QSimpleXmlNodeModel,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlreceiver.sip"
#include <qabstractxmlreceiver.h>
#line 6989 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlname.sip"
#include <qxmlname.h>
#line 6993 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 274 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 6996 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 36 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 6999 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 801 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 7002 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


class sipQAbstractXmlReceiver : public QAbstractXmlReceiver
{
public:
    sipQAbstractXmlReceiver();
    virtual ~sipQAbstractXmlReceiver();

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void endOfSequence();
    void startOfSequence();
    void namespaceBinding(const QXmlName&);
    void atomicValue(const QVariant&);
    void processingInstruction(const QXmlName&,const QString&);
    void endDocument();
    void startDocument();
    void characters(const QStringRef&);
    void comment(const QString&);
    void attribute(const QXmlName&,const QStringRef&);
    void endElement();
    void startElement(const QXmlName&);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQAbstractXmlReceiver(const sipQAbstractXmlReceiver &);
    sipQAbstractXmlReceiver &operator = (const sipQAbstractXmlReceiver &);

    char sipPyMethods[12];
};

sipQAbstractXmlReceiver::sipQAbstractXmlReceiver(): QAbstractXmlReceiver(), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQAbstractXmlReceiver::~sipQAbstractXmlReceiver()
{
    sipCommonDtor(sipPySelf);
}

void sipQAbstractXmlReceiver::endOfSequence()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,sipName_QAbstractXmlReceiver,sipName_endOfSequence);

    if (!sipMeth)
        return;

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQAbstractXmlReceiver::startOfSequence()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,sipName_QAbstractXmlReceiver,sipName_startOfSequence);

    if (!sipMeth)
        return;

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQAbstractXmlReceiver::namespaceBinding(const QXmlName& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,sipName_QAbstractXmlReceiver,sipName_namespaceBinding);

    if (!sipMeth)
        return;

    extern void sipVH_QtXmlPatterns_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&);

    sipVH_QtXmlPatterns_2(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractXmlReceiver::atomicValue(const QVariant& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,sipName_QAbstractXmlReceiver,sipName_atomicValue);

    if (!sipMeth)
        return;

    typedef void (*sipVH_QtCore_2)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QVariant&);

    ((sipVH_QtCore_2)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[2]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractXmlReceiver::processingInstruction(const QXmlName& a0,const QString& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,sipName_QAbstractXmlReceiver,sipName_processingInstruction);

    if (!sipMeth)
        return;

    extern void sipVH_QtXmlPatterns_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&,const QString&);

    sipVH_QtXmlPatterns_0(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQAbstractXmlReceiver::endDocument()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,sipName_QAbstractXmlReceiver,sipName_endDocument);

    if (!sipMeth)
        return;

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQAbstractXmlReceiver::startDocument()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,sipName_QAbstractXmlReceiver,sipName_startDocument);

    if (!sipMeth)
        return;

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQAbstractXmlReceiver::characters(const QStringRef& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,sipName_QAbstractXmlReceiver,sipName_characters);

    if (!sipMeth)
        return;

    extern void sipVH_QtXmlPatterns_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QStringRef&);

    sipVH_QtXmlPatterns_3(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractXmlReceiver::comment(const QString& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[8],sipPySelf,sipName_QAbstractXmlReceiver,sipName_comment);

    if (!sipMeth)
        return;

    typedef void (*sipVH_QtCore_33)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    ((sipVH_QtCore_33)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[33]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractXmlReceiver::attribute(const QXmlName& a0,const QStringRef& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[9],sipPySelf,sipName_QAbstractXmlReceiver,sipName_attribute);

    if (!sipMeth)
        return;

    extern void sipVH_QtXmlPatterns_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&,const QStringRef&);

    sipVH_QtXmlPatterns_1(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQAbstractXmlReceiver::endElement()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[10],sipPySelf,sipName_QAbstractXmlReceiver,sipName_endElement);

    if (!sipMeth)
        return;

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQAbstractXmlReceiver::startElement(const QXmlName& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[11],sipPySelf,sipName_QAbstractXmlReceiver,sipName_startElement);

    if (!sipMeth)
        return;

    extern void sipVH_QtXmlPatterns_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&);

    sipVH_QtXmlPatterns_2(sipGILState, 0, sipPySelf, sipMeth, a0);
}


PyDoc_STRVAR(doc_QAbstractXmlReceiver_startElement, "QAbstractXmlReceiver.startElement(QXmlName)");

extern "C" {static PyObject *meth_QAbstractXmlReceiver_startElement(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlReceiver_startElement(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlName* a0;
        QAbstractXmlReceiver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlReceiver, &sipCpp, sipType_QXmlName, &a0))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlReceiver, sipName_startElement);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->startElement(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlReceiver, sipName_startElement, doc_QAbstractXmlReceiver_startElement);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlReceiver_endElement, "QAbstractXmlReceiver.endElement()");

extern "C" {static PyObject *meth_QAbstractXmlReceiver_endElement(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlReceiver_endElement(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        QAbstractXmlReceiver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAbstractXmlReceiver, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlReceiver, sipName_endElement);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->endElement();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlReceiver, sipName_endElement, doc_QAbstractXmlReceiver_endElement);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlReceiver_attribute, "QAbstractXmlReceiver.attribute(QXmlName, QStringRef)");

extern "C" {static PyObject *meth_QAbstractXmlReceiver_attribute(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlReceiver_attribute(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlName* a0;
        const QStringRef* a1;
        int a1State = 0;
        QAbstractXmlReceiver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9J1", &sipSelf, sipType_QAbstractXmlReceiver, &sipCpp, sipType_QXmlName, &a0, sipType_QStringRef,&a1, &a1State))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlReceiver, sipName_attribute);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->attribute(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QStringRef *>(a1),sipType_QStringRef,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlReceiver, sipName_attribute, doc_QAbstractXmlReceiver_attribute);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlReceiver_comment, "QAbstractXmlReceiver.comment(str)");

extern "C" {static PyObject *meth_QAbstractXmlReceiver_comment(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlReceiver_comment(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QString* a0;
        int a0State = 0;
        QAbstractXmlReceiver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QAbstractXmlReceiver, &sipCpp, sipType_QString,&a0, &a0State))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlReceiver, sipName_comment);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->comment(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlReceiver, sipName_comment, doc_QAbstractXmlReceiver_comment);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlReceiver_characters, "QAbstractXmlReceiver.characters(QStringRef)");

extern "C" {static PyObject *meth_QAbstractXmlReceiver_characters(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlReceiver_characters(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QStringRef* a0;
        int a0State = 0;
        QAbstractXmlReceiver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QAbstractXmlReceiver, &sipCpp, sipType_QStringRef,&a0, &a0State))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlReceiver, sipName_characters);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->characters(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QStringRef *>(a0),sipType_QStringRef,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlReceiver, sipName_characters, doc_QAbstractXmlReceiver_characters);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlReceiver_startDocument, "QAbstractXmlReceiver.startDocument()");

extern "C" {static PyObject *meth_QAbstractXmlReceiver_startDocument(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlReceiver_startDocument(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        QAbstractXmlReceiver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAbstractXmlReceiver, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlReceiver, sipName_startDocument);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->startDocument();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlReceiver, sipName_startDocument, doc_QAbstractXmlReceiver_startDocument);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlReceiver_endDocument, "QAbstractXmlReceiver.endDocument()");

extern "C" {static PyObject *meth_QAbstractXmlReceiver_endDocument(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlReceiver_endDocument(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        QAbstractXmlReceiver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAbstractXmlReceiver, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlReceiver, sipName_endDocument);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->endDocument();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlReceiver, sipName_endDocument, doc_QAbstractXmlReceiver_endDocument);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlReceiver_processingInstruction, "QAbstractXmlReceiver.processingInstruction(QXmlName, str)");

extern "C" {static PyObject *meth_QAbstractXmlReceiver_processingInstruction(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlReceiver_processingInstruction(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlName* a0;
        const QString* a1;
        int a1State = 0;
        QAbstractXmlReceiver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9J1", &sipSelf, sipType_QAbstractXmlReceiver, &sipCpp, sipType_QXmlName, &a0, sipType_QString,&a1, &a1State))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlReceiver, sipName_processingInstruction);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->processingInstruction(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlReceiver, sipName_processingInstruction, doc_QAbstractXmlReceiver_processingInstruction);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlReceiver_atomicValue, "QAbstractXmlReceiver.atomicValue(object)");

extern "C" {static PyObject *meth_QAbstractXmlReceiver_atomicValue(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlReceiver_atomicValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QVariant* a0;
        int a0State = 0;
        QAbstractXmlReceiver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QAbstractXmlReceiver, &sipCpp, sipType_QVariant,&a0, &a0State))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlReceiver, sipName_atomicValue);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->atomicValue(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a0),sipType_QVariant,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlReceiver, sipName_atomicValue, doc_QAbstractXmlReceiver_atomicValue);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlReceiver_namespaceBinding, "QAbstractXmlReceiver.namespaceBinding(QXmlName)");

extern "C" {static PyObject *meth_QAbstractXmlReceiver_namespaceBinding(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlReceiver_namespaceBinding(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlName* a0;
        QAbstractXmlReceiver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlReceiver, &sipCpp, sipType_QXmlName, &a0))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlReceiver, sipName_namespaceBinding);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->namespaceBinding(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlReceiver, sipName_namespaceBinding, doc_QAbstractXmlReceiver_namespaceBinding);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlReceiver_startOfSequence, "QAbstractXmlReceiver.startOfSequence()");

extern "C" {static PyObject *meth_QAbstractXmlReceiver_startOfSequence(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlReceiver_startOfSequence(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        QAbstractXmlReceiver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAbstractXmlReceiver, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlReceiver, sipName_startOfSequence);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->startOfSequence();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlReceiver, sipName_startOfSequence, doc_QAbstractXmlReceiver_startOfSequence);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlReceiver_endOfSequence, "QAbstractXmlReceiver.endOfSequence()");

extern "C" {static PyObject *meth_QAbstractXmlReceiver_endOfSequence(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlReceiver_endOfSequence(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        QAbstractXmlReceiver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QAbstractXmlReceiver, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlReceiver, sipName_endOfSequence);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->endOfSequence();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlReceiver, sipName_endOfSequence, doc_QAbstractXmlReceiver_endOfSequence);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QAbstractXmlReceiver(void *, const sipTypeDef *);}
static void *cast_QAbstractXmlReceiver(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QAbstractXmlReceiver)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QAbstractXmlReceiver(void *, int);}
static void release_QAbstractXmlReceiver(void *sipCppV,int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQAbstractXmlReceiver *>(sipCppV);
    else
        delete reinterpret_cast<QAbstractXmlReceiver *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QAbstractXmlReceiver(sipSimpleWrapper *);}
static void dealloc_QAbstractXmlReceiver(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQAbstractXmlReceiver *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QAbstractXmlReceiver(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QAbstractXmlReceiver(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QAbstractXmlReceiver(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQAbstractXmlReceiver *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQAbstractXmlReceiver();
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QAbstractXmlReceiver[] = {
    {SIP_MLNAME_CAST(sipName_atomicValue), meth_QAbstractXmlReceiver_atomicValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlReceiver_atomicValue)},
    {SIP_MLNAME_CAST(sipName_attribute), meth_QAbstractXmlReceiver_attribute, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlReceiver_attribute)},
    {SIP_MLNAME_CAST(sipName_characters), meth_QAbstractXmlReceiver_characters, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlReceiver_characters)},
    {SIP_MLNAME_CAST(sipName_comment), meth_QAbstractXmlReceiver_comment, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlReceiver_comment)},
    {SIP_MLNAME_CAST(sipName_endDocument), meth_QAbstractXmlReceiver_endDocument, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlReceiver_endDocument)},
    {SIP_MLNAME_CAST(sipName_endElement), meth_QAbstractXmlReceiver_endElement, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlReceiver_endElement)},
    {SIP_MLNAME_CAST(sipName_endOfSequence), meth_QAbstractXmlReceiver_endOfSequence, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlReceiver_endOfSequence)},
    {SIP_MLNAME_CAST(sipName_namespaceBinding), meth_QAbstractXmlReceiver_namespaceBinding, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlReceiver_namespaceBinding)},
    {SIP_MLNAME_CAST(sipName_processingInstruction), meth_QAbstractXmlReceiver_processingInstruction, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlReceiver_processingInstruction)},
    {SIP_MLNAME_CAST(sipName_startDocument), meth_QAbstractXmlReceiver_startDocument, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlReceiver_startDocument)},
    {SIP_MLNAME_CAST(sipName_startElement), meth_QAbstractXmlReceiver_startElement, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlReceiver_startElement)},
    {SIP_MLNAME_CAST(sipName_startOfSequence), meth_QAbstractXmlReceiver_startOfSequence, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlReceiver_startOfSequence)}
};

PyDoc_STRVAR(doc_QAbstractXmlReceiver, "\1QAbstractXmlReceiver()");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QAbstractXmlReceiver = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_CLASS,
        sipNameNr_QAbstractXmlReceiver,
        {0}
    },
    {
        sipNameNr_QAbstractXmlReceiver,
        {0, 0, 1},
        12, methods_QAbstractXmlReceiver,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QAbstractXmlReceiver,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QAbstractXmlReceiver,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QAbstractXmlReceiver,
    0,
    0,
    0,
    release_QAbstractXmlReceiver,
    cast_QAbstractXmlReceiver,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 132 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 7804 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 7808 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 274 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 7811 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


PyDoc_STRVAR(doc_QXmlItem_isNull, "QXmlItem.isNull() -> bool");

extern "C" {static PyObject *meth_QXmlItem_isNull(PyObject *, PyObject *);}
static PyObject *meth_QXmlItem_isNull(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlItem *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlItem, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isNull();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlItem, sipName_isNull, doc_QXmlItem_isNull);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlItem_isNode, "QXmlItem.isNode() -> bool");

extern "C" {static PyObject *meth_QXmlItem_isNode(PyObject *, PyObject *);}
static PyObject *meth_QXmlItem_isNode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlItem *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlItem, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isNode();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlItem, sipName_isNode, doc_QXmlItem_isNode);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlItem_isAtomicValue, "QXmlItem.isAtomicValue() -> bool");

extern "C" {static PyObject *meth_QXmlItem_isAtomicValue(PyObject *, PyObject *);}
static PyObject *meth_QXmlItem_isAtomicValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlItem *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlItem, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isAtomicValue();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlItem, sipName_isAtomicValue, doc_QXmlItem_isAtomicValue);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlItem_toAtomicValue, "QXmlItem.toAtomicValue() -> object");

extern "C" {static PyObject *meth_QXmlItem_toAtomicValue(PyObject *, PyObject *);}
static PyObject *meth_QXmlItem_toAtomicValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlItem *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlItem, &sipCpp))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->toAtomicValue());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlItem, sipName_toAtomicValue, doc_QXmlItem_toAtomicValue);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlItem_toNodeModelIndex, "QXmlItem.toNodeModelIndex() -> QXmlNodeModelIndex");

extern "C" {static PyObject *meth_QXmlItem_toNodeModelIndex(PyObject *, PyObject *);}
static PyObject *meth_QXmlItem_toNodeModelIndex(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlItem *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlItem, &sipCpp))
        {
            QXmlNodeModelIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNodeModelIndex(sipCpp->toNodeModelIndex());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNodeModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlItem, sipName_toNodeModelIndex, doc_QXmlItem_toNodeModelIndex);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QXmlItem(void *, const sipTypeDef *);}
static void *cast_QXmlItem(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QXmlItem)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QXmlItem(void *, int);}
static void release_QXmlItem(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QXmlItem *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QXmlItem(void *, SIP_SSIZE_T, const void *);}
static void assign_QXmlItem(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QXmlItem *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QXmlItem *>(sipSrc);
}


extern "C" {static void *array_QXmlItem(SIP_SSIZE_T);}
static void *array_QXmlItem(SIP_SSIZE_T sipNrElem)
{
    return new QXmlItem[sipNrElem];
}


extern "C" {static void *copy_QXmlItem(const void *, SIP_SSIZE_T);}
static void *copy_QXmlItem(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QXmlItem(reinterpret_cast<const QXmlItem *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QXmlItem(sipSimpleWrapper *);}
static void dealloc_QXmlItem(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QXmlItem(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QXmlItem(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QXmlItem(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QXmlItem *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlItem();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QXmlItem* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QXmlItem, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlItem(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QXmlNodeModelIndex* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QXmlNodeModelIndex, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlItem(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QVariant* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QVariant,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlItem(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a0),sipType_QVariant,a0State);

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QXmlItem[] = {
    {SIP_MLNAME_CAST(sipName_isAtomicValue), meth_QXmlItem_isAtomicValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlItem_isAtomicValue)},
    {SIP_MLNAME_CAST(sipName_isNode), meth_QXmlItem_isNode, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlItem_isNode)},
    {SIP_MLNAME_CAST(sipName_isNull), meth_QXmlItem_isNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlItem_isNull)},
    {SIP_MLNAME_CAST(sipName_toAtomicValue), meth_QXmlItem_toAtomicValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlItem_toAtomicValue)},
    {SIP_MLNAME_CAST(sipName_toNodeModelIndex), meth_QXmlItem_toNodeModelIndex, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlItem_toNodeModelIndex)}
};

PyDoc_STRVAR(doc_QXmlItem, "\1QXmlItem()\n"
    "QXmlItem(QXmlItem)\n"
    "QXmlItem(QXmlNodeModelIndex)\n"
    "QXmlItem(object)");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QXmlItem = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QXmlItem,
        {0}
    },
    {
        sipNameNr_QXmlItem,
        {0, 0, 1},
        5, methods_QXmlItem,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QXmlItem,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QXmlItem,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QXmlItem,
    assign_QXmlItem,
    array_QXmlItem,
    copy_QXmlItem,
    release_QXmlItem,
    cast_QXmlItem,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 86 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 8144 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 8148 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvector.sip"
#include <qvector.h>
#line 8151 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qsourcelocation.sip"
#include <qsourcelocation.h>
#line 8154 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qxmlname.sip"
#include <qxmlname.h>
#line 8157 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvector.sip"
#include <qvector.h>
#line 8160 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 274 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 8163 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 36 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 8166 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 107 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qurl.sip"
#include <qurl.h>
#line 8169 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


class sipQAbstractXmlNodeModel : public QAbstractXmlNodeModel
{
public:
    sipQAbstractXmlNodeModel();
    virtual ~sipQAbstractXmlNodeModel();

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QXmlNodeModelIndex sipProtect_nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis,const QXmlNodeModelIndex&) const;
    QVector<QXmlNodeModelIndex> sipProtect_attributes(const QXmlNodeModelIndex&) const;
    QXmlNodeModelIndex sipProtect_createIndex(qint64) const;
    QXmlNodeModelIndex sipProtect_createIndex(qint64,qint64) const;
    QXmlNodeModelIndex sipProtect_createIndex(void*,qint64) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    QVector<QXmlNodeModelIndex> attributes(const QXmlNodeModelIndex&) const;
    QXmlNodeModelIndex nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis,const QXmlNodeModelIndex&) const;
    QVector<QXmlNodeModelIndex> nodesByIdref(const QXmlName&) const;
    QXmlNodeModelIndex elementById(const QXmlName&) const;
    QVector<QXmlName> namespaceBindings(const QXmlNodeModelIndex&) const;
    QVariant typedValue(const QXmlNodeModelIndex&) const;
    QString stringValue(const QXmlNodeModelIndex&) const;
    QXmlName name(const QXmlNodeModelIndex&) const;
    QXmlNodeModelIndex root(const QXmlNodeModelIndex&) const;
    QXmlNodeModelIndex::DocumentOrder compareOrder(const QXmlNodeModelIndex&,const QXmlNodeModelIndex&) const;
    QXmlNodeModelIndex::NodeKind kind(const QXmlNodeModelIndex&) const;
    QUrl documentUri(const QXmlNodeModelIndex&) const;
    QUrl baseUri(const QXmlNodeModelIndex&) const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQAbstractXmlNodeModel(const sipQAbstractXmlNodeModel &);
    sipQAbstractXmlNodeModel &operator = (const sipQAbstractXmlNodeModel &);

    char sipPyMethods[13];
};

sipQAbstractXmlNodeModel::sipQAbstractXmlNodeModel(): QAbstractXmlNodeModel(), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQAbstractXmlNodeModel::~sipQAbstractXmlNodeModel()
{
    sipCommonDtor(sipPySelf);
}

QVector<QXmlNodeModelIndex> sipQAbstractXmlNodeModel::attributes(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[0]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_attributes);

    if (!sipMeth)
        return QVector<QXmlNodeModelIndex>();

    extern QVector<QXmlNodeModelIndex> sipVH_QtXmlPatterns_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_9(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QXmlNodeModelIndex sipQAbstractXmlNodeModel::nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis a0,const QXmlNodeModelIndex& a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[1]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_nextFromSimpleAxis);

    if (!sipMeth)
        return QXmlNodeModelIndex();

    extern QXmlNodeModelIndex sipVH_QtXmlPatterns_10(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QAbstractXmlNodeModel::SimpleAxis,const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_10(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QVector<QXmlNodeModelIndex> sipQAbstractXmlNodeModel::nodesByIdref(const QXmlName& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[2]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_nodesByIdref);

    if (!sipMeth)
        return QVector<QXmlNodeModelIndex>();

    extern QVector<QXmlNodeModelIndex> sipVH_QtXmlPatterns_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&);

    return sipVH_QtXmlPatterns_4(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QXmlNodeModelIndex sipQAbstractXmlNodeModel::elementById(const QXmlName& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[3]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_elementById);

    if (!sipMeth)
        return QXmlNodeModelIndex();

    extern QXmlNodeModelIndex sipVH_QtXmlPatterns_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlName&);

    return sipVH_QtXmlPatterns_5(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QVector<QXmlName> sipQAbstractXmlNodeModel::namespaceBindings(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[4]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_namespaceBindings);

    if (!sipMeth)
        return QVector<QXmlName>();

    extern QVector<QXmlName> sipVH_QtXmlPatterns_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_7(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QVariant sipQAbstractXmlNodeModel::typedValue(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[5]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_typedValue);

    if (!sipMeth)
        return QVariant();

    extern QVariant sipVH_QtXmlPatterns_11(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_11(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QString sipQAbstractXmlNodeModel::stringValue(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[6]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_stringValue);

    if (!sipMeth)
        return QString();

    extern QString sipVH_QtXmlPatterns_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_6(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QXmlName sipQAbstractXmlNodeModel::name(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[7]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_name);

    if (!sipMeth)
        return QXmlName();

    extern QXmlName sipVH_QtXmlPatterns_12(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_12(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QXmlNodeModelIndex sipQAbstractXmlNodeModel::root(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[8]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_root);

    if (!sipMeth)
        return QXmlNodeModelIndex();

    extern QXmlNodeModelIndex sipVH_QtXmlPatterns_13(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_13(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QXmlNodeModelIndex::DocumentOrder sipQAbstractXmlNodeModel::compareOrder(const QXmlNodeModelIndex& a0,const QXmlNodeModelIndex& a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[9]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_compareOrder);

    if (!sipMeth)
        return (QXmlNodeModelIndex::DocumentOrder)0;

    extern QXmlNodeModelIndex::DocumentOrder sipVH_QtXmlPatterns_14(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&,const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_14(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QXmlNodeModelIndex::NodeKind sipQAbstractXmlNodeModel::kind(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[10]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_kind);

    if (!sipMeth)
        return (QXmlNodeModelIndex::NodeKind)0;

    extern QXmlNodeModelIndex::NodeKind sipVH_QtXmlPatterns_15(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_15(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QUrl sipQAbstractXmlNodeModel::documentUri(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[11]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_documentUri);

    if (!sipMeth)
        return QUrl();

    extern QUrl sipVH_QtXmlPatterns_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_8(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QUrl sipQAbstractXmlNodeModel::baseUri(const QXmlNodeModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[12]),sipPySelf,sipName_QAbstractXmlNodeModel,sipName_baseUri);

    if (!sipMeth)
        return QUrl();

    extern QUrl sipVH_QtXmlPatterns_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QXmlNodeModelIndex&);

    return sipVH_QtXmlPatterns_8(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QXmlNodeModelIndex sipQAbstractXmlNodeModel::sipProtect_nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis a0,const QXmlNodeModelIndex& a1) const
{
    return nextFromSimpleAxis(a0,a1);
}

QVector<QXmlNodeModelIndex> sipQAbstractXmlNodeModel::sipProtect_attributes(const QXmlNodeModelIndex& a0) const
{
    return attributes(a0);
}

QXmlNodeModelIndex sipQAbstractXmlNodeModel::sipProtect_createIndex(qint64 a0) const
{
    return QAbstractXmlNodeModel::createIndex(a0);
}

QXmlNodeModelIndex sipQAbstractXmlNodeModel::sipProtect_createIndex(qint64 a0,qint64 a1) const
{
    return QAbstractXmlNodeModel::createIndex(a0,a1);
}

QXmlNodeModelIndex sipQAbstractXmlNodeModel::sipProtect_createIndex(void*a0,qint64 a1) const
{
    return QAbstractXmlNodeModel::createIndex(a0,a1);
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_baseUri, "QAbstractXmlNodeModel.baseUri(QXmlNodeModelIndex) -> QUrl");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_baseUri(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_baseUri(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlNodeModelIndex* a0;
        const QAbstractXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QUrl*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_baseUri);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QUrl(sipCpp->baseUri(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QUrl,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_baseUri, doc_QAbstractXmlNodeModel_baseUri);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_documentUri, "QAbstractXmlNodeModel.documentUri(QXmlNodeModelIndex) -> QUrl");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_documentUri(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_documentUri(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlNodeModelIndex* a0;
        const QAbstractXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QUrl*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_documentUri);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QUrl(sipCpp->documentUri(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QUrl,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_documentUri, doc_QAbstractXmlNodeModel_documentUri);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_kind, "QAbstractXmlNodeModel.kind(QXmlNodeModelIndex) -> QXmlNodeModelIndex.NodeKind");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_kind(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_kind(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlNodeModelIndex* a0;
        const QAbstractXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QXmlNodeModelIndex::NodeKind sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_kind);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->kind(*a0);
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(sipRes,sipType_QXmlNodeModelIndex_NodeKind);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_kind, doc_QAbstractXmlNodeModel_kind);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_compareOrder, "QAbstractXmlNodeModel.compareOrder(QXmlNodeModelIndex, QXmlNodeModelIndex) -> QXmlNodeModelIndex.DocumentOrder");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_compareOrder(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_compareOrder(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlNodeModelIndex* a0;
        const QXmlNodeModelIndex* a1;
        const QAbstractXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9J9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0, sipType_QXmlNodeModelIndex, &a1))
        {
            QXmlNodeModelIndex::DocumentOrder sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_compareOrder);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->compareOrder(*a0,*a1);
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(sipRes,sipType_QXmlNodeModelIndex_DocumentOrder);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_compareOrder, doc_QAbstractXmlNodeModel_compareOrder);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_root, "QAbstractXmlNodeModel.root(QXmlNodeModelIndex) -> QXmlNodeModelIndex");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_root(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_root(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlNodeModelIndex* a0;
        const QAbstractXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QXmlNodeModelIndex*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_root);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNodeModelIndex(sipCpp->root(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNodeModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_root, doc_QAbstractXmlNodeModel_root);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_name, "QAbstractXmlNodeModel.name(QXmlNodeModelIndex) -> QXmlName");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_name(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_name(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlNodeModelIndex* a0;
        const QAbstractXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QXmlName*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_name);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlName(sipCpp->name(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlName,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_name, doc_QAbstractXmlNodeModel_name);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_stringValue, "QAbstractXmlNodeModel.stringValue(QXmlNodeModelIndex) -> str");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_stringValue(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_stringValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlNodeModelIndex* a0;
        const QAbstractXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QString*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_stringValue);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->stringValue(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_stringValue, doc_QAbstractXmlNodeModel_stringValue);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_typedValue, "QAbstractXmlNodeModel.typedValue(QXmlNodeModelIndex) -> object");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_typedValue(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_typedValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlNodeModelIndex* a0;
        const QAbstractXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QVariant*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_typedValue);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->typedValue(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_typedValue, doc_QAbstractXmlNodeModel_typedValue);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_namespaceBindings, "QAbstractXmlNodeModel.namespaceBindings(QXmlNodeModelIndex) -> list-of-QXmlName");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_namespaceBindings(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_namespaceBindings(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlNodeModelIndex* a0;
        const QAbstractXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QVector<QXmlName>*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_namespaceBindings);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVector<QXmlName>(sipCpp->namespaceBindings(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVector_0100QXmlName,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_namespaceBindings, doc_QAbstractXmlNodeModel_namespaceBindings);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_elementById, "QAbstractXmlNodeModel.elementById(QXmlName) -> QXmlNodeModelIndex");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_elementById(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_elementById(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlName* a0;
        const QAbstractXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlName, &a0))
        {
            QXmlNodeModelIndex*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_elementById);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNodeModelIndex(sipCpp->elementById(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNodeModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_elementById, doc_QAbstractXmlNodeModel_elementById);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_nodesByIdref, "QAbstractXmlNodeModel.nodesByIdref(QXmlName) -> list-of-QXmlNodeModelIndex");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_nodesByIdref(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_nodesByIdref(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlName* a0;
        const QAbstractXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlName, &a0))
        {
            QVector<QXmlNodeModelIndex>*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_nodesByIdref);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVector<QXmlNodeModelIndex>(sipCpp->nodesByIdref(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVector_0100QXmlNodeModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_nodesByIdref, doc_QAbstractXmlNodeModel_nodesByIdref);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_sourceLocation, "QAbstractXmlNodeModel.sourceLocation(QXmlNodeModelIndex) -> QSourceLocation");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_sourceLocation(PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_sourceLocation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlNodeModelIndex* a0;
        const QAbstractXmlNodeModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QSourceLocation*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSourceLocation(sipCpp->sourceLocation(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSourceLocation,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_sourceLocation, doc_QAbstractXmlNodeModel_sourceLocation);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_nextFromSimpleAxis, "QAbstractXmlNodeModel.nextFromSimpleAxis(QAbstractXmlNodeModel.SimpleAxis, QXmlNodeModelIndex) -> QXmlNodeModelIndex");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_nextFromSimpleAxis(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_nextFromSimpleAxis(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        QAbstractXmlNodeModel::SimpleAxis a0;
        const QXmlNodeModelIndex* a1;
        const sipQAbstractXmlNodeModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BEJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QAbstractXmlNodeModel_SimpleAxis, &a0, sipType_QXmlNodeModelIndex, &a1))
        {
            QXmlNodeModelIndex*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_nextFromSimpleAxis);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNodeModelIndex(sipCpp->sipProtect_nextFromSimpleAxis(a0,*a1));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNodeModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_nextFromSimpleAxis, doc_QAbstractXmlNodeModel_nextFromSimpleAxis);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_attributes, "QAbstractXmlNodeModel.attributes(QXmlNodeModelIndex) -> list-of-QXmlNodeModelIndex");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_attributes(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_attributes(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QXmlNodeModelIndex* a0;
        const sipQAbstractXmlNodeModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, sipType_QXmlNodeModelIndex, &a0))
        {
            QVector<QXmlNodeModelIndex>*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractXmlNodeModel, sipName_attributes);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVector<QXmlNodeModelIndex>(sipCpp->sipProtect_attributes(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVector_0100QXmlNodeModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_attributes, doc_QAbstractXmlNodeModel_attributes);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractXmlNodeModel_createIndex, "QAbstractXmlNodeModel.createIndex(int) -> QXmlNodeModelIndex\n"
    "QAbstractXmlNodeModel.createIndex(int, int) -> QXmlNodeModelIndex\n"
    "QAbstractXmlNodeModel.createIndex(object, int additionalData=0) -> QXmlNodeModelIndex");

extern "C" {static PyObject *meth_QAbstractXmlNodeModel_createIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractXmlNodeModel_createIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        qint64 a0;
        const sipQAbstractXmlNodeModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bn", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, &a0))
        {
            QXmlNodeModelIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNodeModelIndex(sipCpp->sipProtect_createIndex(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNodeModelIndex,NULL);
        }
    }

    {
        qint64 a0;
        qint64 a1;
        const sipQAbstractXmlNodeModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bnn", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, &a0, &a1))
        {
            QXmlNodeModelIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNodeModelIndex(sipCpp->sipProtect_createIndex(a0,a1));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNodeModelIndex,NULL);
        }
    }

    {
        PyObject * a0;
        qint64 a1 = 0;
        const sipQAbstractXmlNodeModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_additionalData,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BP0|n", &sipSelf, sipType_QAbstractXmlNodeModel, &sipCpp, &a0, &a1))
        {
            QXmlNodeModelIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QXmlNodeModelIndex(sipCpp->sipProtect_createIndex(a0,a1));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QXmlNodeModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractXmlNodeModel, sipName_createIndex, doc_QAbstractXmlNodeModel_createIndex);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QAbstractXmlNodeModel(void *, const sipTypeDef *);}
static void *cast_QAbstractXmlNodeModel(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QAbstractXmlNodeModel)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QAbstractXmlNodeModel(void *, int);}
static void release_QAbstractXmlNodeModel(void *sipCppV,int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQAbstractXmlNodeModel *>(sipCppV);
    else
        delete reinterpret_cast<QAbstractXmlNodeModel *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QAbstractXmlNodeModel(sipSimpleWrapper *);}
static void dealloc_QAbstractXmlNodeModel(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQAbstractXmlNodeModel *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QAbstractXmlNodeModel(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QAbstractXmlNodeModel(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QAbstractXmlNodeModel(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQAbstractXmlNodeModel *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQAbstractXmlNodeModel();
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QAbstractXmlNodeModel[] = {
    {SIP_MLNAME_CAST(sipName_attributes), (PyCFunction)meth_QAbstractXmlNodeModel_attributes, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_attributes)},
    {SIP_MLNAME_CAST(sipName_baseUri), meth_QAbstractXmlNodeModel_baseUri, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_baseUri)},
    {SIP_MLNAME_CAST(sipName_compareOrder), meth_QAbstractXmlNodeModel_compareOrder, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_compareOrder)},
    {SIP_MLNAME_CAST(sipName_createIndex), (PyCFunction)meth_QAbstractXmlNodeModel_createIndex, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_createIndex)},
    {SIP_MLNAME_CAST(sipName_documentUri), meth_QAbstractXmlNodeModel_documentUri, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_documentUri)},
    {SIP_MLNAME_CAST(sipName_elementById), meth_QAbstractXmlNodeModel_elementById, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_elementById)},
    {SIP_MLNAME_CAST(sipName_kind), meth_QAbstractXmlNodeModel_kind, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_kind)},
    {SIP_MLNAME_CAST(sipName_name), meth_QAbstractXmlNodeModel_name, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_name)},
    {SIP_MLNAME_CAST(sipName_namespaceBindings), meth_QAbstractXmlNodeModel_namespaceBindings, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_namespaceBindings)},
    {SIP_MLNAME_CAST(sipName_nextFromSimpleAxis), (PyCFunction)meth_QAbstractXmlNodeModel_nextFromSimpleAxis, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_nextFromSimpleAxis)},
    {SIP_MLNAME_CAST(sipName_nodesByIdref), meth_QAbstractXmlNodeModel_nodesByIdref, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_nodesByIdref)},
    {SIP_MLNAME_CAST(sipName_root), meth_QAbstractXmlNodeModel_root, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_root)},
    {SIP_MLNAME_CAST(sipName_sourceLocation), meth_QAbstractXmlNodeModel_sourceLocation, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_sourceLocation)},
    {SIP_MLNAME_CAST(sipName_stringValue), meth_QAbstractXmlNodeModel_stringValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_stringValue)},
    {SIP_MLNAME_CAST(sipName_typedValue), meth_QAbstractXmlNodeModel_typedValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractXmlNodeModel_typedValue)}
};

static sipEnumMemberDef enummembers_QAbstractXmlNodeModel[] = {
    {sipName_FirstChild, static_cast<int>(QAbstractXmlNodeModel::FirstChild), 3},
    {sipName_NextSibling, static_cast<int>(QAbstractXmlNodeModel::NextSibling), 3},
    {sipName_Parent, static_cast<int>(QAbstractXmlNodeModel::Parent), 3},
    {sipName_PreviousSibling, static_cast<int>(QAbstractXmlNodeModel::PreviousSibling), 3},
};

PyDoc_STRVAR(doc_QAbstractXmlNodeModel, "\1QAbstractXmlNodeModel()");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QAbstractXmlNodeModel = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_CLASS,
        sipNameNr_QAbstractXmlNodeModel,
        {0}
    },
    {
        sipNameNr_QAbstractXmlNodeModel,
        {0, 0, 1},
        15, methods_QAbstractXmlNodeModel,
        4, enummembers_QAbstractXmlNodeModel,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QAbstractXmlNodeModel,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QAbstractXmlNodeModel,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QAbstractXmlNodeModel,
    0,
    0,
    0,
    release_QAbstractXmlNodeModel,
    cast_QAbstractXmlNodeModel,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 9177 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 86 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
#include <qabstractxmlnodemodel.h>
#line 9181 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


PyDoc_STRVAR(doc_QXmlNodeModelIndex_data, "QXmlNodeModelIndex.data() -> int");

extern "C" {static PyObject *meth_QXmlNodeModelIndex_data(PyObject *, PyObject *);}
static PyObject *meth_QXmlNodeModelIndex_data(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlNodeModelIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlNodeModelIndex, &sipCpp))
        {
            qint64 sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->data();
            Py_END_ALLOW_THREADS

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlNodeModelIndex, sipName_data, doc_QXmlNodeModelIndex_data);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlNodeModelIndex_internalPointer, "QXmlNodeModelIndex.internalPointer() -> object");

extern "C" {static PyObject *meth_QXmlNodeModelIndex_internalPointer(PyObject *, PyObject *);}
static PyObject *meth_QXmlNodeModelIndex_internalPointer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlNodeModelIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlNodeModelIndex, &sipCpp))
        {
            PyObject * sipRes = 0;

#line 63 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
        sipRes = reinterpret_cast<PyObject *>(sipCpp->internalPointer());
        
        if (!sipRes)
            sipRes = Py_None;
        
        Py_INCREF(sipRes);
#line 9234 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

            return sipRes;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlNodeModelIndex, sipName_internalPointer, doc_QXmlNodeModelIndex_internalPointer);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlNodeModelIndex_model, "QXmlNodeModelIndex.model() -> QAbstractXmlNodeModel");

extern "C" {static PyObject *meth_QXmlNodeModelIndex_model(PyObject *, PyObject *);}
static PyObject *meth_QXmlNodeModelIndex_model(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlNodeModelIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlNodeModelIndex, &sipCpp))
        {
            const QAbstractXmlNodeModel*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->model();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(const_cast<QAbstractXmlNodeModel *>(sipRes),sipType_QAbstractXmlNodeModel,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlNodeModelIndex, sipName_model, doc_QXmlNodeModelIndex_model);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlNodeModelIndex_additionalData, "QXmlNodeModelIndex.additionalData() -> int");

extern "C" {static PyObject *meth_QXmlNodeModelIndex_additionalData(PyObject *, PyObject *);}
static PyObject *meth_QXmlNodeModelIndex_additionalData(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlNodeModelIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlNodeModelIndex, &sipCpp))
        {
            qint64 sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->additionalData();
            Py_END_ALLOW_THREADS

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlNodeModelIndex, sipName_additionalData, doc_QXmlNodeModelIndex_additionalData);

    return NULL;
}


PyDoc_STRVAR(doc_QXmlNodeModelIndex_isNull, "QXmlNodeModelIndex.isNull() -> bool");

extern "C" {static PyObject *meth_QXmlNodeModelIndex_isNull(PyObject *, PyObject *);}
static PyObject *meth_QXmlNodeModelIndex_isNull(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QXmlNodeModelIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QXmlNodeModelIndex, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isNull();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QXmlNodeModelIndex, sipName_isNull, doc_QXmlNodeModelIndex_isNull);

    return NULL;
}


extern "C" {static long slot_QXmlNodeModelIndex___hash__(PyObject *);}
static long slot_QXmlNodeModelIndex___hash__(PyObject *sipSelf)
{
    QXmlNodeModelIndex *sipCpp = reinterpret_cast<QXmlNodeModelIndex *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QXmlNodeModelIndex));

    if (!sipCpp)
        return 0;


    {
        {
            long sipRes = 0;

#line 76 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractxmlnodemodel.sip"
        sipRes = qHash(*sipCpp);
#line 9349 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QXmlNodeModelIndex___ne__(PyObject *,PyObject *);}
static PyObject *slot_QXmlNodeModelIndex___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QXmlNodeModelIndex *sipCpp = reinterpret_cast<QXmlNodeModelIndex *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QXmlNodeModelIndex));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QXmlNodeModelIndex* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QXmlNodeModelIndex, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->QXmlNodeModelIndex::operator!=(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtXmlPatterns,ne_slot,sipType_QXmlNodeModelIndex,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QXmlNodeModelIndex___eq__(PyObject *,PyObject *);}
static PyObject *slot_QXmlNodeModelIndex___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QXmlNodeModelIndex *sipCpp = reinterpret_cast<QXmlNodeModelIndex *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QXmlNodeModelIndex));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QXmlNodeModelIndex* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QXmlNodeModelIndex, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->QXmlNodeModelIndex::operator==(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtXmlPatterns,eq_slot,sipType_QXmlNodeModelIndex,sipSelf,sipArg);
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QXmlNodeModelIndex(void *, const sipTypeDef *);}
static void *cast_QXmlNodeModelIndex(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QXmlNodeModelIndex)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QXmlNodeModelIndex(void *, int);}
static void release_QXmlNodeModelIndex(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QXmlNodeModelIndex *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QXmlNodeModelIndex(void *, SIP_SSIZE_T, const void *);}
static void assign_QXmlNodeModelIndex(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QXmlNodeModelIndex *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QXmlNodeModelIndex *>(sipSrc);
}


extern "C" {static void *array_QXmlNodeModelIndex(SIP_SSIZE_T);}
static void *array_QXmlNodeModelIndex(SIP_SSIZE_T sipNrElem)
{
    return new QXmlNodeModelIndex[sipNrElem];
}


extern "C" {static void *copy_QXmlNodeModelIndex(const void *, SIP_SSIZE_T);}
static void *copy_QXmlNodeModelIndex(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QXmlNodeModelIndex(reinterpret_cast<const QXmlNodeModelIndex *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QXmlNodeModelIndex(sipSimpleWrapper *);}
static void dealloc_QXmlNodeModelIndex(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QXmlNodeModelIndex(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QXmlNodeModelIndex(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QXmlNodeModelIndex(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QXmlNodeModelIndex *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlNodeModelIndex();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QXmlNodeModelIndex* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QXmlNodeModelIndex, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QXmlNodeModelIndex(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QXmlNodeModelIndex[] = {
    {(void *)slot_QXmlNodeModelIndex___hash__, hash_slot},
    {(void *)slot_QXmlNodeModelIndex___ne__, ne_slot},
    {(void *)slot_QXmlNodeModelIndex___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QXmlNodeModelIndex[] = {
    {SIP_MLNAME_CAST(sipName_additionalData), meth_QXmlNodeModelIndex_additionalData, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlNodeModelIndex_additionalData)},
    {SIP_MLNAME_CAST(sipName_data), meth_QXmlNodeModelIndex_data, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlNodeModelIndex_data)},
    {SIP_MLNAME_CAST(sipName_internalPointer), meth_QXmlNodeModelIndex_internalPointer, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlNodeModelIndex_internalPointer)},
    {SIP_MLNAME_CAST(sipName_isNull), meth_QXmlNodeModelIndex_isNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlNodeModelIndex_isNull)},
    {SIP_MLNAME_CAST(sipName_model), meth_QXmlNodeModelIndex_model, METH_VARARGS, SIP_MLDOC_CAST(doc_QXmlNodeModelIndex_model)}
};

static sipEnumMemberDef enummembers_QXmlNodeModelIndex[] = {
    {sipName_Attribute, static_cast<int>(QXmlNodeModelIndex::Attribute), 15},
    {sipName_Comment, static_cast<int>(QXmlNodeModelIndex::Comment), 15},
    {sipName_Document, static_cast<int>(QXmlNodeModelIndex::Document), 15},
    {sipName_Element, static_cast<int>(QXmlNodeModelIndex::Element), 15},
    {sipName_Follows, static_cast<int>(QXmlNodeModelIndex::Follows), 14},
    {sipName_Is, static_cast<int>(QXmlNodeModelIndex::Is), 14},
    {sipName_Namespace, static_cast<int>(QXmlNodeModelIndex::Namespace), 15},
    {sipName_Precedes, static_cast<int>(QXmlNodeModelIndex::Precedes), 14},
    {sipName_ProcessingInstruction, static_cast<int>(QXmlNodeModelIndex::ProcessingInstruction), 15},
    {sipName_Text, static_cast<int>(QXmlNodeModelIndex::Text), 15},
};

PyDoc_STRVAR(doc_QXmlNodeModelIndex, "\1QXmlNodeModelIndex()\n"
    "QXmlNodeModelIndex(QXmlNodeModelIndex)");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QXmlNodeModelIndex = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QXmlNodeModelIndex,
        {0}
    },
    {
        sipNameNr_QXmlNodeModelIndex,
        {0, 0, 1},
        5, methods_QXmlNodeModelIndex,
        10, enummembers_QXmlNodeModelIndex,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QXmlNodeModelIndex,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QXmlNodeModelIndex,
    init_type_QXmlNodeModelIndex,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QXmlNodeModelIndex,
    assign_QXmlNodeModelIndex,
    array_QXmlNodeModelIndex,
    copy_QXmlNodeModelIndex,
    release_QXmlNodeModelIndex,
    cast_QXmlNodeModelIndex,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstracturiresolver.sip"
#include <qabstracturiresolver.h>
#line 9604 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 34 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 9608 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 107 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qurl.sip"
#include <qurl.h>
#line 9611 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 9614 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 355 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 9617 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 338 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 9620 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 274 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 9623 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 9626 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 9629 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 9632 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 120 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 9635 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 9638 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 36 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 9641 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 9644 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 9647 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


class sipQAbstractUriResolver : public QAbstractUriResolver
{
public:
    sipQAbstractUriResolver(QObject*);
    virtual ~sipQAbstractUriResolver();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool,QTimerEvent*);
    void sipProtectVirt_childEvent(bool,QChildEvent*);
    void sipProtectVirt_customEvent(bool,QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const char*);
    void connectNotify(const char*);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);
    QUrl resolve(const QUrl&,const QUrl&) const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQAbstractUriResolver(const sipQAbstractUriResolver &);
    sipQAbstractUriResolver &operator = (const sipQAbstractUriResolver &);

    char sipPyMethods[8];
};

sipQAbstractUriResolver::sipQAbstractUriResolver(QObject*a0): QAbstractUriResolver(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQAbstractUriResolver::~sipQAbstractUriResolver()
{
    sipCommonDtor(sipPySelf);
}

const QMetaObject *sipQAbstractUriResolver::metaObject() const
{
    return sip_QtXmlPatterns_qt_metaobject(sipPySelf,sipType_QAbstractUriResolver);
}

int sipQAbstractUriResolver::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = QAbstractUriResolver::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtXmlPatterns_qt_metacall(sipPySelf,sipType_QAbstractUriResolver,_c,_id,_a);

    return _id;
}

void *sipQAbstractUriResolver::qt_metacast(const char *_clname)
{
    return (sip_QtXmlPatterns_qt_metacast(sipPySelf, sipType_QAbstractUriResolver, _clname)) ? this : QAbstractUriResolver::qt_metacast(_clname);
}

void sipQAbstractUriResolver::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
        QAbstractUriResolver::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractUriResolver::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
        QAbstractUriResolver::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractUriResolver::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
        QAbstractUriResolver::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_17)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_17)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[17]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractUriResolver::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
        QAbstractUriResolver::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[25]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractUriResolver::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
        QAbstractUriResolver::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[9]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQAbstractUriResolver::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return QAbstractUriResolver::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_18)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_18)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[18]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

bool sipQAbstractUriResolver::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return QAbstractUriResolver::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[5]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QUrl sipQAbstractUriResolver::resolve(const QUrl& a0,const QUrl& a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[7]),sipPySelf,sipName_QAbstractUriResolver,sipName_resolve);

    if (!sipMeth)
        return QUrl();

    extern QUrl sipVH_QtXmlPatterns_16(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QUrl&,const QUrl&);

    return sipVH_QtXmlPatterns_16(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QObject* sipQAbstractUriResolver::sipProtect_sender() const
{
    return QObject::sender();
}

int sipQAbstractUriResolver::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipQAbstractUriResolver::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQAbstractUriResolver::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipQAbstractUriResolver::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipQAbstractUriResolver::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQAbstractUriResolver::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQAbstractUriResolver::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}


PyDoc_STRVAR(doc_QAbstractUriResolver_sender, "QAbstractUriResolver.sender() -> QObject");

extern "C" {static PyObject *meth_QAbstractUriResolver_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractUriResolver_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQAbstractUriResolver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QAbstractUriResolver, &sipCpp))
        {
            QObject*sipRes = 0;

#line 643 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        if (helper)
            sipRes = helper(sipRes);
#line 9940 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractUriResolver, sipName_sender, doc_QAbstractUriResolver_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractUriResolver_receivers, "QAbstractUriResolver.receivers(SIGNAL()) -> int");

extern "C" {static PyObject *meth_QAbstractUriResolver_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractUriResolver_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        char* a0;
        const sipQAbstractUriResolver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAbstractUriResolver, &sipCpp, &a0))
        {
            int sipRes = 0;

#line 669 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helper if it hasn't already been done.
        typedef int (*helper_func)(QObject *, const char *, int);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_receivers");
        
        // PyQt5: Get rid of the const casts.
        if (helper)
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = helper(const_cast<QObject *>(sipCpp), a0, sipCpp->receivers(a0));
        #else
            sipRes = helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), a0, sipCpp->sipProtect_receivers(a0));
        #endif
#line 9985 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractUriResolver, sipName_receivers, doc_QAbstractUriResolver_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractUriResolver_timerEvent, "QAbstractUriResolver.timerEvent(QTimerEvent)");

extern "C" {static PyObject *meth_QAbstractUriResolver_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractUriResolver_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QTimerEvent* a0;
        sipQAbstractUriResolver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAbstractUriResolver, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractUriResolver, sipName_timerEvent, doc_QAbstractUriResolver_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractUriResolver_childEvent, "QAbstractUriResolver.childEvent(QChildEvent)");

extern "C" {static PyObject *meth_QAbstractUriResolver_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractUriResolver_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QChildEvent* a0;
        sipQAbstractUriResolver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAbstractUriResolver, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractUriResolver, sipName_childEvent, doc_QAbstractUriResolver_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractUriResolver_customEvent, "QAbstractUriResolver.customEvent(QEvent)");

extern "C" {static PyObject *meth_QAbstractUriResolver_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractUriResolver_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QEvent* a0;
        sipQAbstractUriResolver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAbstractUriResolver, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractUriResolver, sipName_customEvent, doc_QAbstractUriResolver_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractUriResolver_connectNotify, "QAbstractUriResolver.connectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QAbstractUriResolver_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractUriResolver_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQAbstractUriResolver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAbstractUriResolver, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractUriResolver, sipName_connectNotify, doc_QAbstractUriResolver_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractUriResolver_disconnectNotify, "QAbstractUriResolver.disconnectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QAbstractUriResolver_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractUriResolver_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQAbstractUriResolver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAbstractUriResolver, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractUriResolver, sipName_disconnectNotify, doc_QAbstractUriResolver_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractUriResolver_senderSignalIndex, "QAbstractUriResolver.senderSignalIndex() -> int");

extern "C" {static PyObject *meth_QAbstractUriResolver_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractUriResolver_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQAbstractUriResolver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QAbstractUriResolver, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractUriResolver, sipName_senderSignalIndex, doc_QAbstractUriResolver_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractUriResolver_resolve, "QAbstractUriResolver.resolve(QUrl, QUrl) -> QUrl");

extern "C" {static PyObject *meth_QAbstractUriResolver_resolve(PyObject *, PyObject *);}
static PyObject *meth_QAbstractUriResolver_resolve(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QUrl* a0;
        const QUrl* a1;
        const QAbstractUriResolver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9J9", &sipSelf, sipType_QAbstractUriResolver, &sipCpp, sipType_QUrl, &a0, sipType_QUrl, &a1))
        {
            QUrl*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractUriResolver, sipName_resolve);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QUrl(sipCpp->resolve(*a0,*a1));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QUrl,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractUriResolver, sipName_resolve, doc_QAbstractUriResolver_resolve);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QAbstractUriResolver(void *, const sipTypeDef *);}
static void *cast_QAbstractUriResolver(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QAbstractUriResolver)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(QAbstractUriResolver *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QAbstractUriResolver(void *, int);}
static void release_QAbstractUriResolver(void *sipCppV,int)
{
    QAbstractUriResolver *sipCpp = reinterpret_cast<QAbstractUriResolver *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QAbstractUriResolver(sipSimpleWrapper *);}
static void dealloc_QAbstractUriResolver(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQAbstractUriResolver *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QAbstractUriResolver(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QAbstractUriResolver(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QAbstractUriResolver(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQAbstractUriResolver *sipCpp = 0;

    {
        QObject* a0 = 0;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JH", sipType_QObject, &a0, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQAbstractUriResolver(a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QAbstractUriResolver[] = {{141, 0, 1}};


static PyMethodDef methods_QAbstractUriResolver[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QAbstractUriResolver_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QAbstractUriResolver_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QAbstractUriResolver_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QAbstractUriResolver_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QAbstractUriResolver_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_resolve), meth_QAbstractUriResolver_resolve, METH_VARARGS, SIP_MLDOC_CAST(doc_QAbstractUriResolver_resolve)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QAbstractUriResolver_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QAbstractUriResolver_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QAbstractUriResolver_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QAbstractUriResolver, "\1QAbstractUriResolver(QObject parent=None)");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QAbstractUriResolver = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QAbstractUriResolver,
        {0}
    },
    {
        sipNameNr_QAbstractUriResolver,
        {0, 0, 1},
        9, methods_QAbstractUriResolver,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QAbstractUriResolver,
    -1,
    -1,
    supers_QAbstractUriResolver,
    0,
    init_type_QAbstractUriResolver,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QAbstractUriResolver,
    0,
    0,
    0,
    release_QAbstractUriResolver,
    cast_QAbstractUriResolver,
    0,
    0,
    0,
    0,
    0,
    0
},
    &QAbstractUriResolver::staticMetaObject,
    0,
    0
};

#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qabstractmessagehandler.sip"
#include <qabstractmessagehandler.h>
#line 10364 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

#line 34 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 10368 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 36 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 10371 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 107 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qurl.sip"
#include <qurl.h>
#line 10374 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtXmlPatterns/qsourcelocation.sip"
#include <qsourcelocation.h>
#line 10377 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 10380 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 355 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 10383 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 338 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 10386 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 274 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 10389 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 33 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 10392 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 10395 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 10398 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 120 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 10401 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 10404 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 10407 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 10410 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"


class sipQAbstractMessageHandler : public QAbstractMessageHandler
{
public:
    sipQAbstractMessageHandler(QObject*);
    virtual ~sipQAbstractMessageHandler();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool,QTimerEvent*);
    void sipProtectVirt_childEvent(bool,QChildEvent*);
    void sipProtectVirt_customEvent(bool,QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;
    void sipProtect_handleMessage(QtMsgType,const QString&,const QUrl&,const QSourceLocation&);

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const char*);
    void connectNotify(const char*);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);
    void handleMessage(QtMsgType,const QString&,const QUrl&,const QSourceLocation&);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQAbstractMessageHandler(const sipQAbstractMessageHandler &);
    sipQAbstractMessageHandler &operator = (const sipQAbstractMessageHandler &);

    char sipPyMethods[8];
};

sipQAbstractMessageHandler::sipQAbstractMessageHandler(QObject*a0): QAbstractMessageHandler(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQAbstractMessageHandler::~sipQAbstractMessageHandler()
{
    sipCommonDtor(sipPySelf);
}

const QMetaObject *sipQAbstractMessageHandler::metaObject() const
{
    return sip_QtXmlPatterns_qt_metaobject(sipPySelf,sipType_QAbstractMessageHandler);
}

int sipQAbstractMessageHandler::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = QAbstractMessageHandler::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtXmlPatterns_qt_metacall(sipPySelf,sipType_QAbstractMessageHandler,_c,_id,_a);

    return _id;
}

void *sipQAbstractMessageHandler::qt_metacast(const char *_clname)
{
    return (sip_QtXmlPatterns_qt_metacast(sipPySelf, sipType_QAbstractMessageHandler, _clname)) ? this : QAbstractMessageHandler::qt_metacast(_clname);
}

void sipQAbstractMessageHandler::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
        QAbstractMessageHandler::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractMessageHandler::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
        QAbstractMessageHandler::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractMessageHandler::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
        QAbstractMessageHandler::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_17)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_17)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[17]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractMessageHandler::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
        QAbstractMessageHandler::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[25]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractMessageHandler::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
        QAbstractMessageHandler::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[9]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQAbstractMessageHandler::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return QAbstractMessageHandler::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_18)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_18)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[18]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

bool sipQAbstractMessageHandler::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return QAbstractMessageHandler::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtXmlPatterns_QtCore->em_virthandlers[5]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQAbstractMessageHandler::handleMessage(QtMsgType a0,const QString& a1,const QUrl& a2,const QSourceLocation& a3)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,sipName_QAbstractMessageHandler,sipName_handleMessage);

    if (!sipMeth)
        return;

    extern void sipVH_QtXmlPatterns_17(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QtMsgType,const QString&,const QUrl&,const QSourceLocation&);

    sipVH_QtXmlPatterns_17(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3);
}

QObject* sipQAbstractMessageHandler::sipProtect_sender() const
{
    return QObject::sender();
}

int sipQAbstractMessageHandler::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipQAbstractMessageHandler::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQAbstractMessageHandler::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipQAbstractMessageHandler::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipQAbstractMessageHandler::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQAbstractMessageHandler::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQAbstractMessageHandler::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

void sipQAbstractMessageHandler::sipProtect_handleMessage(QtMsgType a0,const QString& a1,const QUrl& a2,const QSourceLocation& a3)
{
    handleMessage(a0,a1,a2,a3);
}


PyDoc_STRVAR(doc_QAbstractMessageHandler_sender, "QAbstractMessageHandler.sender() -> QObject");

extern "C" {static PyObject *meth_QAbstractMessageHandler_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractMessageHandler_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQAbstractMessageHandler *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QAbstractMessageHandler, &sipCpp))
        {
            QObject*sipRes = 0;

#line 643 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        if (helper)
            sipRes = helper(sipRes);
#line 10709 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractMessageHandler, sipName_sender, doc_QAbstractMessageHandler_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractMessageHandler_receivers, "QAbstractMessageHandler.receivers(SIGNAL()) -> int");

extern "C" {static PyObject *meth_QAbstractMessageHandler_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractMessageHandler_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        char* a0;
        const sipQAbstractMessageHandler *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAbstractMessageHandler, &sipCpp, &a0))
        {
            int sipRes = 0;

#line 669 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helper if it hasn't already been done.
        typedef int (*helper_func)(QObject *, const char *, int);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_receivers");
        
        // PyQt5: Get rid of the const casts.
        if (helper)
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = helper(const_cast<QObject *>(sipCpp), a0, sipCpp->receivers(a0));
        #else
            sipRes = helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), a0, sipCpp->sipProtect_receivers(a0));
        #endif
#line 10754 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.3-2.x86_64/build/QtXmlPatterns/sipQtXmlPatternspart0.cpp"

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractMessageHandler, sipName_receivers, doc_QAbstractMessageHandler_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractMessageHandler_timerEvent, "QAbstractMessageHandler.timerEvent(QTimerEvent)");

extern "C" {static PyObject *meth_QAbstractMessageHandler_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractMessageHandler_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QTimerEvent* a0;
        sipQAbstractMessageHandler *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAbstractMessageHandler, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractMessageHandler, sipName_timerEvent, doc_QAbstractMessageHandler_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractMessageHandler_childEvent, "QAbstractMessageHandler.childEvent(QChildEvent)");

extern "C" {static PyObject *meth_QAbstractMessageHandler_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractMessageHandler_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QChildEvent* a0;
        sipQAbstractMessageHandler *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAbstractMessageHandler, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractMessageHandler, sipName_childEvent, doc_QAbstractMessageHandler_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractMessageHandler_customEvent, "QAbstractMessageHandler.customEvent(QEvent)");

extern "C" {static PyObject *meth_QAbstractMessageHandler_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractMessageHandler_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QEvent* a0;
        sipQAbstractMessageHandler *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QAbstractMessageHandler, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractMessageHandler, sipName_customEvent, doc_QAbstractMessageHandler_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractMessageHandler_connectNotify, "QAbstractMessageHandler.connectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QAbstractMessageHandler_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractMessageHandler_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQAbstractMessageHandler *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAbstractMessageHandler, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractMessageHandler, sipName_connectNotify, doc_QAbstractMessageHandler_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractMessageHandler_disconnectNotify, "QAbstractMessageHandler.disconnectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QAbstractMessageHandler_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractMessageHandler_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQAbstractMessageHandler *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QAbstractMessageHandler, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractMessageHandler, sipName_disconnectNotify, doc_QAbstractMessageHandler_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractMessageHandler_senderSignalIndex, "QAbstractMessageHandler.senderSignalIndex() -> int");

extern "C" {static PyObject *meth_QAbstractMessageHandler_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractMessageHandler_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQAbstractMessageHandler *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QAbstractMessageHandler, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractMessageHandler, sipName_senderSignalIndex, doc_QAbstractMessageHandler_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractMessageHandler_message, "QAbstractMessageHandler.message(QtMsgType, str, QUrl identifier=QUrl(), QSourceLocation sourceLocation=QSourceLocation())");

extern "C" {static PyObject *meth_QAbstractMessageHandler_message(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractMessageHandler_message(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QtMsgType a0;
        const QString* a1;
        int a1State = 0;
        const QUrl& a2def = QUrl();
        const QUrl* a2 = &a2def;
        const QSourceLocation& a3def = QSourceLocation();
        const QSourceLocation* a3 = &a3def;
        QAbstractMessageHandler *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_identifier,
            sipName_sourceLocation,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BEJ1|J9J9", &sipSelf, sipType_QAbstractMessageHandler, &sipCpp, sipType_QtMsgType, &a0, sipType_QString,&a1, &a1State, sipType_QUrl, &a2, sipType_QSourceLocation, &a3))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->message(a0,*a1,*a2,*a3);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractMessageHandler, sipName_message, doc_QAbstractMessageHandler_message);

    return NULL;
}


PyDoc_STRVAR(doc_QAbstractMessageHandler_handleMessage, "QAbstractMessageHandler.handleMessage(QtMsgType, str, QUrl, QSourceLocation)");

extern "C" {static PyObject *meth_QAbstractMessageHandler_handleMessage(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QAbstractMessageHandler_handleMessage(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        QtMsgType a0;
        const QString* a1;
        int a1State = 0;
        const QUrl* a2;
        const QSourceLocation* a3;
        sipQAbstractMessageHandler *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BEJ1J9J9", &sipSelf, sipType_QAbstractMessageHandler, &sipCpp, sipType_QtMsgType, &a0, sipType_QString,&a1, &a1State, sipType_QUrl, &a2, sipType_QSourceLocation, &a3))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QAbstractMessageHandler, sipName_handleMessage);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_handleMessage(a0,*a1,*a2,*a3);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QAbstractMessageHandler, sipName_handleMessage, doc_QAbstractMessageHandler_handleMessage);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QAbstractMessageHandler(void *, const sipTypeDef *);}
static void *cast_QAbstractMessageHandler(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QAbstractMessageHandler)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(QAbstractMessageHandler *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QAbstractMessageHandler(void *, int);}
static void release_QAbstractMessageHandler(void *sipCppV,int)
{
    QAbstractMessageHandler *sipCpp = reinterpret_cast<QAbstractMessageHandler *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QAbstractMessageHandler(sipSimpleWrapper *);}
static void dealloc_QAbstractMessageHandler(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQAbstractMessageHandler *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QAbstractMessageHandler(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QAbstractMessageHandler(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QAbstractMessageHandler(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQAbstractMessageHandler *sipCpp = 0;

    {
        QObject* a0 = 0;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JH", sipType_QObject, &a0, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQAbstractMessageHandler(a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QAbstractMessageHandler[] = {{141, 0, 1}};


static PyMethodDef methods_QAbstractMessageHandler[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QAbstractMessageHandler_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QAbstractMessageHandler_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QAbstractMessageHandler_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QAbstractMessageHandler_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_handleMessage), (PyCFunction)meth_QAbstractMessageHandler_handleMessage, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QAbstractMessageHandler_handleMessage)},
    {SIP_MLNAME_CAST(sipName_message), (PyCFunction)meth_QAbstractMessageHandler_message, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QAbstractMessageHandler_message)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QAbstractMessageHandler_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QAbstractMessageHandler_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QAbstractMessageHandler_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QAbstractMessageHandler_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QAbstractMessageHandler, "\1QAbstractMessageHandler(QObject parent=None)");


pyqt4ClassTypeDef sipTypeDef_QtXmlPatterns_QAbstractMessageHandler = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QAbstractMessageHandler,
        {0}
    },
    {
        sipNameNr_QAbstractMessageHandler,
        {0, 0, 1},
        10, methods_QAbstractMessageHandler,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QAbstractMessageHandler,
    -1,
    -1,
    supers_QAbstractMessageHandler,
    0,
    init_type_QAbstractMessageHandler,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QAbstractMessageHandler,
    0,
    0,
    0,
    release_QAbstractMessageHandler,
    cast_QAbstractMessageHandler,
    0,
    0,
    0,
    0,
    0,
    0
},
    &QAbstractMessageHandler::staticMetaObject,
    0,
    0
};
