/*
 * Module code.
 *
 * Generated by SIP 4.16.8
 *
 * Copyright (c) 2015 Riverbank Computing Limited <info@riverbankcomputing.com>
 * 
 * This file is part of PyQt5.
 * 
 * This file may be used under the terms of the GNU General Public License
 * version 3.0 as published by the Free Software Foundation and appearing in
 * the file LICENSE included in the packaging of this file.  Please review the
 * following information to ensure the GNU General Public License version 3.0
 * requirements will be met: http://www.gnu.org/copyleft/gpl.html.
 * 
 * If you do not wish to use this file under the terms of the GPL version 3.0
 * then you may purchase a commercial license.  For more information contact
 * info@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 "sipAPIQtPositioning.h"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 29 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoshape.sip"
#include <qgeoshape.h>
#line 32 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfo.sip"
#include <qgeopositioninfo.h>
#line 35 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfosource.sip"
#include <qgeopositioninfosource.h>
#line 38 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfosource.sip"
#include <qgeopositioninfosource.h>
#line 41 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeosatelliteinfosource.sip"
#include <qgeosatelliteinfosource.h>
#line 44 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 47 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoareamonitorinfo.sip"
#include <qgeoareamonitorinfo.h>
#line 50 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoareamonitorsource.sip"
#include <qgeoareamonitorsource.h>
#line 53 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoareamonitorsource.sip"
#include <qgeoareamonitorsource.h>
#line 56 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qdatastream.sip"
#include <qdatastream.h>
#line 59 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeocoordinate.sip"
#include <qgeocoordinate.h>
#line 62 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeosatelliteinfo.sip"
#include <qgeosatelliteinfo.h>
#line 65 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoaddress.sip"
#include <qgeoaddress.h>
#line 68 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeocircle.sip"
#include <qgeocircle.h>
#line 71 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeolocation.sip"
#include <qgeolocation.h>
#line 74 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeorectangle.sip"
#include <qgeorectangle.h>
#line 77 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

/* Define the strings used by this module. */
const char sipStrings_QtPositioning[] = {
    'Q', 'G', 'e', 'o', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'I', 'n', 'f', 'o', 'S', 'o', 'u', 'r', 'c', 'e', ':', ':', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'i', 'n', 'g', 'M', 'e', 't', 'h', 'o', 'd', 's', 0,
    'Q', 'G', 'e', 'o', 'A', 'r', 'e', 'a', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'S', 'o', 'u', 'r', 'c', 'e', ':', ':', 'A', 'r', 'e', 'a', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'F', 'e', 'a', 't', 'u', 'r', 'e', 's', 0,
    'Q', 'G', 'e', 'o', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'I', 'n', 'f', 'o', 'S', 'o', 'u', 'r', 'c', 'e', ':', ':', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'i', 'n', 'g', 'M', 'e', 't', 'h', 'o', 'd', 0,
    'Q', 'G', 'e', 'o', 'A', 'r', 'e', 'a', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'S', 'o', 'u', 'r', 'c', 'e', ':', ':', 'A', 'r', 'e', 'a', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'F', 'e', 'a', 't', 'u', 'r', 'e', 0,
    'Q', 'N', 'm', 'e', 'a', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'I', 'n', 'f', 'o', 'S', 'o', 'u', 'r', 'c', 'e', ':', ':', 'U', 'p', 'd', 'a', 't', 'e', 'M', 'o', 'd', 'e', 0,
    'f', 'r', 'o', 'm', 'S', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'i', 'n', 'g', 'M', 'e', 't', 'h', 'o', 'd', 's', 'O', 'n', 'l', 'y', 0,
    'D', 'e', 'g', 'r', 'e', 'e', 's', 'M', 'i', 'n', 'u', 't', 'e', 's', 'S', 'e', 'c', 'o', 'n', 'd', 's', 'W', 'i', 't', 'h', 'H', 'e', 'm', 'i', 's', 'p', 'h', 'e', 'r', 'e', 0,
    'Q', 'G', 'e', 'o', 'S', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'I', 'n', 'f', 'o', ':', ':', 'S', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'S', 'y', 's', 't', 'e', 'm', 0,
    'Q', 'G', 'e', 'o', 'C', 'o', 'o', 'r', 'd', 'i', 'n', 'a', 't', 'e', ':', ':', 'C', 'o', 'o', 'r', 'd', 'i', 'n', 'a', 't', 'e', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'Q', 'G', 'e', 'o', 'S', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'I', 'n', 'f', 'o', 'S', 'o', 'u', 'r', 'c', 'e', ':', ':', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'e', 't', 'P', 'r', 'e', 'f', 'e', 'r', 'r', 'e', 'd', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'i', 'n', 'g', 'M', 'e', 't', 'h', 'o', 'd', 's', 0,
    'N', 'o', 'n', 'S', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'i', 'n', 'g', 'M', 'e', 't', 'h', 'o', 'd', 's', 0,
    'Q', 'G', 'e', 'o', 'C', 'o', 'o', 'r', 'd', 'i', 'n', 'a', 't', 'e', ':', ':', 'C', 'o', 'o', 'r', 'd', 'i', 'n', 'a', 't', 'e', 'T', 'y', 'p', 'e', 0,
    'Q', 'G', 'e', 'o', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'I', 'n', 'f', 'o', 'S', 'o', 'u', 'r', 'c', 'e', ':', ':', 'E', 'r', 'r', 'o', 'r', 0,
    'Q', 'G', 'e', 'o', 'S', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'I', 'n', 'f', 'o', ':', ':', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 0,
    'D', 'e', 'g', 'r', 'e', 'e', 's', 'M', 'i', 'n', 'u', 't', 'e', 's', 'W', 'i', 't', 'h', 'H', 'e', 'm', 'i', 's', 'p', 'h', 'e', 'r', 'e', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'A', 'r', 'e', 'a', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'F', 'e', 'a', 't', 'u', 'r', 'e', 's', 0,
    'P', 'e', 'r', 's', 'i', 's', 't', 'e', 'n', 't', 'A', 'r', 'e', 'a', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'F', 'e', 'a', 't', 'u', 'r', 'e', 0,
    'Q', 'G', 'e', 'o', 'A', 'r', 'e', 'a', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'S', 'o', 'u', 'r', 'c', 'e', ':', ':', 'E', 'r', 'r', 'o', 'r', 0,
    'P', 'y', 'Q', 't', '5', '.', 'Q', 't', 'C', 'o', 'r', 'e', '.', 'p', 'y', 'q', 't', 'W', 'r', 'a', 'p', 'p', 'e', 'r', 'T', 'y', 'p', 'e', 0,
    's', 'e', 't', 'U', 's', 'e', 'r', 'E', 'q', 'u', 'i', 'v', 'a', 'l', 'e', 'n', 't', 'R', 'a', 'n', 'g', 'e', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'i', 'n', 'g', 'M', 'e', 't', 'h', 'o', 'd', 's', 0,
    'p', 'r', 'e', 'f', 'e', 'r', 'r', 'e', 'd', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'i', 'n', 'g', 'M', 'e', 't', 'h', 'o', 'd', 's', 0,
    'Q', 'G', 'e', 'o', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'I', 'n', 'f', 'o', ':', ':', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 0,
    'Q', 'L', 'i', 's', 't', '<', 'Q', 'G', 'e', 'o', 'A', 'r', 'e', 'a', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'I', 'n', 'f', 'o', '>', 0,
    's', 'e', 't', 'N', 'o', 't', 'i', 'f', 'i', 'c', 'a', 't', 'i', 'o', 'n', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 's', 0,
    'Q', 'L', 'i', 's', 't', '<', 'Q', 'G', 'e', 'o', 'S', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'I', 'n', 'f', 'o', '>', 0,
    'u', 's', 'e', 'r', 'E', 'q', 'u', 'i', 'v', 'a', 'l', 'e', 'n', 't', 'R', 'a', 'n', 'g', 'e', 'E', 'r', 'r', 'o', 'r', 0,
    'p', 'a', 'r', 's', 'e', 'P', 'o', 's', 'I', 'n', 'f', 'o', 'F', 'r', 'o', 'm', 'N', 'm', 'e', 'a', 'D', 'a', 't', 'a', 0,
    'I', 'n', 's', 'u', 'f', 'f', 'i', 'c', 'i', 'e', 'n', 't', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'I', 'n', 'f', 'o', 0,
    'Q', 'N', 'm', 'e', 'a', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'I', 'n', 'f', 'o', 'S', 'o', 'u', 'r', 'c', 'e', 0,
    's', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 's', 'I', 'n', 'V', 'i', 'e', 'w', 'U', 'p', 'd', 'a', 't', 'e', 'd', 0,
    'Q', 'G', 'e', 'o', 'S', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'I', 'n', 'f', 'o', 'S', 'o', 'u', 'r', 'c', 'e', 0,
    's', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 's', 'I', 'n', 'U', 's', 'e', 'U', 'p', 'd', 'a', 't', 'e', 'd', 0,
    's', 'e', 't', 'S', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'I', 'd', 'e', 'n', 't', 'i', 'f', 'i', 'e', 'r', 0,
    'Q', 'G', 'e', 'o', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'I', 'n', 'f', 'o', 'S', 'o', 'u', 'r', 'c', 'e', 0,
    'n', 'o', 't', 'i', 'f', 'i', 'c', 'a', 't', 'i', 'o', 'n', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 's', 0,
    'Q', 'L', 'i', 's', 't', '<', 'Q', 'G', 'e', 'o', 'C', 'o', 'o', 'r', 'd', 'i', 'n', 'a', 't', 'e', '>', 0,
    'm', 'i', 'n', 'i', 'm', 'u', 'm', 'U', 'p', 'd', 'a', 't', 'e', 'I', 'n', 't', 'e', 'r', 'v', 'a', 'l', 0,
    'A', 'l', 'l', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'i', 'n', 'g', 'M', 'e', 't', 'h', 'o', 'd', 's', 0,
    'D', 'e', 'g', 'r', 'e', 'e', 's', 'M', 'i', 'n', 'u', 't', 'e', 's', 'S', 'e', 'c', 'o', 'n', 'd', 's', 0,
    'D', 'e', 'g', 'r', 'e', 'e', 's', 'W', 'i', 't', 'h', 'H', 'e', 'm', 'i', 's', 'p', 'h', 'e', 'r', 'e', 0,
    's', 'e', 't', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'I', 'n', 'f', 'o', 'S', 'o', 'u', 'r', 'c', 'e', 0,
    'A', 'n', 'y', 'A', 'r', 'e', 'a', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'F', 'e', 'a', 't', 'u', 'r', 'e', 0,
    'Q', 'G', 'e', 'o', 'A', 'r', 'e', 'a', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'S', 'o', 'u', 'r', 'c', 'e', 0,
    'Q', 'G', 'e', 'o', 'S', 'h', 'a', 'p', 'e', ':', ':', 'S', 'h', 'a', 'p', 'e', 'T', 'y', 'p', 'e', 0,
    'N', 'o', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'i', 'n', 'g', 'M', 'e', 't', 'h', 'o', 'd', 's', 0,
    'a', 't', 'D', 'i', 's', 't', 'a', 'n', 'c', 'e', 'A', 'n', 'd', 'A', 'z', 'i', 'm', 'u', 't', 'h', 0,
    's', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'I', 'd', 'e', 'n', 't', 'i', 'f', 'i', 'e', 'r', 0,
    'c', 'r', 'e', 'a', 't', 'e', 'D', 'e', 'f', 'a', 'u', 'l', 't', 'S', 'o', 'u', 'r', 'c', 'e', 0,
    'Q', 'G', 'e', 'o', 'A', 'r', 'e', 'a', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'I', 'n', 'f', 'o', 0,
    'P', 'y', 'Q', 't', '5', '.', 'Q', 't', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'i', 'n', 'g', 0,
    's', 'e', 't', 'S', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'S', 'y', 's', 't', 'e', 'm', 0,
    'H', 'o', 'r', 'i', 'z', 'o', 'n', 't', 'a', 'l', 'A', 'c', 'c', 'u', 'r', 'a', 'c', 'y', 0,
    'p', 'o', 's', 'i', 't', 'i', 'o', 'n', 'I', 'n', 'f', 'o', 'S', 'o', 'u', 'r', 'c', 'e', 0,
    'U', 'n', 'k', 'n', 'o', 'w', 'n', 'S', 'o', 'u', 'r', 'c', 'e', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'e', 't', 'S', 'i', 'g', 'n', 'a', 'l', 'S', 't', 'r', 'e', 'n', 'g', 't', 'h', 0,
    'Q', 'G', 'e', 'o', 'S', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'I', 'n', 'f', 'o', 0,
    'l', 'a', 's', 't', 'K', 'n', 'o', 'w', 'n', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 0,
    'M', 'a', 'g', 'n', 'e', 't', 'i', 'c', 'V', 'a', 'r', 'i', 'a', 't', 'i', 'o', 'n', 0,
    'I', 'n', 'v', 'a', 'l', 'i', 'd', 'C', 'o', 'o', 'r', 'd', 'i', 'n', 'a', 't', 'e', 0,
    's', 'e', 't', 'U', 'p', 'd', 'a', 't', 'e', 'I', 'n', 't', 'e', 'r', 'v', 'a', 'l', 0,
    'i', 's', 'S', 'i', 'g', 'n', 'a', 'l', 'C', 'o', 'n', 'n', 'e', 'c', 't', 'e', 'd', 0,
    's', 'e', 'n', 'd', 'e', 'r', 'S', 'i', 'g', 'n', 'a', 'l', 'I', 'n', 'd', 'e', 'x', 0,
    'V', 'e', 'r', 't', 'i', 'c', 'a', 'l', 'A', 'c', 'c', 'u', 'r', 'a', 'c', 'y', 0,
    'Q', 'G', 'e', 'o', 'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'I', 'n', 'f', 'o', 0,
    'a', 'v', 'a', 'i', 'l', 'a', 'b', 'l', 'e', 'S', 'o', 'u', 'r', 'c', 'e', 's', 0,
    'd', 'i', 's', 'c', 'o', 'n', 'n', 'e', 'c', 't', 'N', 'o', 't', 'i', 'f', 'y', 0,
    's', 'a', 't', 'e', 'l', 'l', 'i', 't', 'e', 'S', 'y', 's', 't', 'e', 'm', 0,
    'p', 'o', 's', 'i', 't', 'i', 'o', 'n', 'U', 'p', 'd', 'a', 't', 'e', 'd', 0,
    'r', 'e', 'm', 'o', 'v', 'e', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 0,
    's', 't', 'a', 'r', 't', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'i', 'n', 'g', 0,
    'i', 's', 'T', 'e', 'x', 't', 'G', 'e', 'n', 'e', 'r', 'a', 't', 'e', 'd', 0,
    'S', 'i', 'm', 'u', 'l', 'a', 't', 'i', 'o', 'n', 'M', 'o', 'd', 'e', 0,
    'r', 'e', 'q', 'u', 'e', 's', 't', 'T', 'i', 'm', 'e', 'o', 'u', 't', 0,
    's', 'i', 'g', 'n', 'a', 'l', 'S', 't', 'r', 'e', 'n', 'g', 't', 'h', 0,
    's', 'e', 't', 'B', 'o', 'u', 'n', 'd', 'i', 'n', 'g', 'B', 'o', 'x', 0,
    'D', 'e', 'g', 'r', 'e', 'e', 's', 'M', 'i', 'n', 'u', 't', 'e', 's', 0,
    'Q', 'G', 'e', 'o', 'C', 'o', 'o', 'r', 'd', 'i', 'n', 'a', 't', 'e', 0,
    'm', 'o', 'n', 'i', 't', 'o', 'r', 'E', 'x', 'p', 'i', 'r', 'e', 'd', 0,
    'a', 'c', 't', 'i', 'v', 'e', 'M', 'o', 'n', 'i', 't', 'o', 'r', 's', 0,
    's', 't', 'o', 'p', 'M', 'o', 'n', 'i', 't', 'o', 'r', 'i', 'n', 'g', 0,
    's', 'e', 't', 'C', 'o', 'u', 'n', 't', 'r', 'y', 'C', 'o', 'd', 'e', 0,
    'u', 'p', 'd', 'a', 't', 'e', 'I', 'n', 't', 'e', 'r', 'v', 'a', 'l', 0,
    's', 'e', 't', 'B', 'o', 't', 't', 'o', 'm', 'R', 'i', 'g', 'h', 't', 0,
    'R', 'e', 'c', 't', 'a', 'n', 'g', 'l', 'e', 'T', 'y', 'p', 'e', 0,
    'Q', 'G', 'e', 'o', 'R', 'e', 'c', 't', 'a', 'n', 'g', 'l', 'e', 0,
    'u', 'p', 'd', 'a', 't', 'e', 'T', 'i', 'm', 'e', 'o', 'u', 't', 0,
    'V', 'e', 'r', 't', 'i', 'c', 'a', 'l', 'S', 'p', 'e', 'e', 'd', 0,
    's', 'e', 't', 'C', 'o', 'o', 'r', 'd', 'i', 'n', 'a', 't', 'e', 0,
    'r', 'e', 'q', 'u', 'e', 's', 't', 'U', 'p', 'd', 'a', 't', 'e', 0,
    's', 'e', 't', 'P', 'e', 'r', 's', 'i', 's', 't', 'e', 'n', 't', 0,
    's', 'e', 't', 'E', 'x', 'p', 'i', 'r', 'a', 't', 'i', 'o', 'n', 0,
    's', 'e', 't', 'P', 'o', 's', 't', 'a', 'l', 'C', 'o', 'd', 'e', 0,
    's', 'e', 't', 'B', 'o', 't', 't', 'o', 'm', 'L', 'e', 'f', 't', 0,
    'R', 'e', 'a', 'l', 'T', 'i', 'm', 'e', 'M', 'o', 'd', 'e', 0,
    's', 't', 'a', 'r', 't', 'U', 'p', 'd', 'a', 't', 'e', 's', 0,
    's', 'e', 't', 'T', 'i', 'm', 'e', 's', 't', 'a', 'm', 'p', 0,
    'Q', 'G', 'e', 'o', 'L', 'o', 'c', 'a', 't', 'i', 'o', 'n', 0,
    's', 'e', 't', 'L', 'o', 'n', 'g', 'i', 't', 'u', 'd', 'e', 0,
    'C', 'o', 'o', 'r', 'd', 'i', 'n', 'a', 't', 'e', '3', 'D', 0,
    'C', 'o', 'o', 'r', 'd', 'i', 'n', 'a', 't', 'e', '2', 'D', 0,
    'c', 'r', 'e', 'a', 't', 'e', 'S', 'o', 'u', 'r', 'c', 'e', 0,
    'i', 's', 'P', 'e', 'r', 's', 'i', 's', 't', 'e', 'n', 't', 0,
    'h', 'a', 's', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 0,
    's', 'e', 't', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 0,
    'e', 'x', 't', 'e', 'n', 'd', 'S', 'h', 'a', 'p', 'e', 0,
    's', 't', 'o', 'p', 'U', 'p', 'd', 'a', 't', 'e', 's', 0,
    'C', 'l', 'o', 's', 'e', 'd', 'E', 'r', 'r', 'o', 'r', 0,
    'G', 'r', 'o', 'u', 'n', 'd', 'S', 'p', 'e', 'e', 'd', 0,
    'b', 'o', 'u', 'n', 'd', 'i', 'n', 'g', 'B', 'o', 'x', 0,
    's', 'e', 't', 'A', 'l', 't', 'i', 't', 'u', 'd', 'e', 0,
    's', 'e', 't', 'L', 'a', 't', 'i', 't', 'u', 'd', 'e', 0,
    'a', 'r', 'e', 'a', 'E', 'n', 't', 'e', 'r', 'e', 'd', 0,
    's', 'e', 't', 'D', 'i', 's', 't', 'r', 'i', 'c', 't', 0,
    'c', 'o', 'u', 'n', 't', 'r', 'y', 'C', 'o', 'd', 'e', 0,
    'Q', 'G', 'e', 'o', 'A', 'd', 'd', 'r', 'e', 's', 's', 0,
    'A', 'c', 'c', 'e', 's', 's', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'e', 't', 'T', 'o', 'p', 'R', 'i', 'g', 'h', 't', 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,
    'U', 'n', 'k', 'n', 'o', 'w', 'n', 'T', 'y', 'p', 'e', 0,
    'b', 'o', 't', 't', 'o', 'm', 'R', 'i', 'g', 'h', 't', 0,
    'u', 'p', 'd', 'a', 't', 'e', 'M', 'o', 'd', 'e', 0,
    'C', 'i', 'r', 'c', 'l', 'e', 'T', 'y', 'p', 'e', 0,
    's', 'e', 't', 'A', 'd', 'd', 'r', 'e', 's', 's', 0,
    'c', 'o', 'o', 'r', 'd', 'i', 'n', 'a', 't', 'e', 0,
    'd', 'i', 's', 't', 'a', 'n', 'c', 'e', 'U', 'p', 0,
    'd', 'i', 's', 't', 'a', 'n', 'c', 'e', 'T', 'o', 0,
    'Q', 'G', 'e', 'o', 'C', 'i', 'r', 'c', 'l', 'e', 0,
    'a', 'r', 'e', 'a', 'E', 'x', 'i', 't', 'e', 'd', 0,
    's', 'o', 'u', 'r', 'c', 'e', 'N', 'a', 'm', 'e', 0,
    'e', 'x', 'p', 'i', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'i', 'd', 'e', 'n', 't', 'i', 'f', 'i', 'e', 'r', 0,
    'p', 'o', 's', 't', 'a', 'l', 'C', 'o', 'd', 'e', 0,
    's', 'e', 't', 'C', 'o', 'u', 'n', 't', 'r', 'y', 0,
    'b', 'o', 't', 't', 'o', 'm', 'L', 'e', 'f', 't', 0,
    's', 'e', 't', 'T', 'o', 'p', 'L', 'e', 'f', 't', 0,
    'c', 'h', 'i', 'l', 'd', 'E', 'v', 'e', 'n', 't', 0,
    't', 'i', 'm', 'e', 'r', 'E', 'v', 'e', 'n', 't', 0,
    't', 'r', 'a', 'n', 's', 'l', 'a', 't', 'e', 'd', 0,
    'i', 'n', 't', 'e', 'r', 's', 'e', 'c', 't', 's', 0,
    '_', '_', 'r', 's', 'h', 'i', 'f', 't', '_', '_', 0,
    '_', '_', 'l', 's', 'h', 'i', 'f', 't', '_', '_', 0,
    '_', '_', 'i', 'n', 'v', 'e', 'r', 't', '_', '_', 0,
    'E', 'l', 'e', 'v', 'a', 't', 'i', 'o', 'n', 0,
    't', 'i', 'm', 'e', 's', 't', 'a', 'm', 'p', 0,
    'a', 'z', 'i', 'm', 'u', 't', 'h', 'T', 'o', 0,
    'l', 'o', 'n', 'g', 'i', 't', 'u', 'd', 'e', 0,
    's', 'e', 't', 'R', 'a', 'd', 'i', 'u', 's', 0,
    's', 'e', 't', 'C', 'e', 'n', 't', 'e', 'r', 0,
    'Q', 'G', 'e', 'o', 'S', 'h', 'a', 'p', 'e', 0,
    's', 'e', 't', 'S', 't', 'r', 'e', 'e', 't', 0,
    's', 'e', 't', 'C', 'o', 'u', 'n', 't', 'y', 0,
    'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', 0,
    's', 'e', 't', 'H', 'e', 'i', 'g', 'h', 't', 0,
    'r', 'e', 'c', 'e', 'i', 'v', 'e', 'r', 's', 0,
    'U', 'n', 'd', 'e', 'f', 'i', 'n', 'e', 'd', 0,
    's', 'e', 't', 'D', 'e', 'v', 'i', 'c', 'e', 0,
    'a', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 0,
    't', 'r', 'a', 'n', 's', 'l', 'a', 't', 'e', 0,
    'p', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 0,
    'D', 'i', 'r', 'e', 'c', 't', 'i', 'o', 'n', 0,
    'a', 'l', 't', 'i', 't', 'u', 'd', 'e', 0,
    'l', 'a', 't', 'i', 't', 'u', 'd', 'e', 0,
    'd', 'i', 's', 't', 'r', 'i', 'c', 't', 0,
    's', 'e', 't', 'S', 't', 'a', 't', 'e', 0,
    'n', 'a', 'm', 'e', 'T', 'y', 'p', 'e', 0,
    's', 'e', 't', 'W', 'i', 'd', 't', 'h', 0,
    't', 'o', 'p', 'R', 'i', 'g', 'h', 't', 0,
    't', 'o', 'S', 't', 'r', 'i', 'n', 'g', 0,
    'c', 'o', 'n', 't', 'a', 'i', 'n', 's', 0,
    '_', '_', 'b', 'o', 'o', 'l', '_', '_', 0,
    '_', '_', 'i', 'x', 'o', 'r', '_', '_', 0,
    '_', '_', 'i', 'a', 'n', 'd', '_', '_', 0,
    'G', 'L', 'O', 'N', 'A', 'S', 'S', 0,
    'D', 'e', 'g', 'r', 'e', 'e', 's', 0,
    's', 'e', 't', 'A', 'r', 'e', 'a', 0,
    's', 'e', 't', 'N', 'a', 'm', 'e', 0,
    's', 'e', 't', 'C', 'i', 't', 'y', 0,
    's', 'e', 't', 'T', 'e', 'x', 't', 0,
    'c', 'o', 'u', 'n', 't', 'r', 'y', 0,
    'a', 'd', 'd', 'r', 'e', 's', 's', 0,
    'N', 'o', 'E', 'r', 'r', 'o', 'r', 0,
    't', 'i', 'm', 'e', 'o', 'u', 't', 0,
    'f', 'i', 'l', 't', 'e', 'r', 's', 0,
    'e', 'n', 'a', 'b', 'l', 'e', 'd', 0,
    'o', 'p', 't', 'i', 'o', 'n', 's', 0,
    'i', 's', 'E', 'm', 'p', 't', 'y', 0,
    't', 'o', 'p', 'L', 'e', 'f', 't', 0,
    'i', 's', 'V', 'a', 'l', 'i', 'd', 0,
    '_', '_', 'a', 'n', 'd', '_', '_', 0,
    '_', '_', 'x', 'o', 'r', '_', '_', 0,
    '_', '_', 'i', 'n', 't', '_', '_', 0,
    '_', '_', 'i', 'o', 'r', '_', '_', 0,
    'r', 'a', 'd', 'i', 'u', 's', 0,
    's', 't', 'r', 'e', 'e', 't', 0,
    'c', 'o', 'u', 'n', 't', 'y', 0,
    'u', 'n', 'i', 't', 'e', 'd', 0,
    'c', 'e', 'n', 't', 'e', 'r', 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', '2', 0,
    'v', 'a', 'l', 'u', 'e', '1', 0,
    'v', 'a', 'l', 'u', 'e', '0', 0,
    's', 'y', 'm', 'b', 'o', 'l', 0,
    'h', 'e', 'i', 'g', 'h', 't', 0,
    's', 'u', 'f', 'f', 'i', 'x', 0,
    'p', 'r', 'e', 'f', 'i', 'x', 0,
    'd', 'e', 'v', 'i', 'c', 'e', 0,
    'l', 'o', 'c', 'a', 'l', 'e', 0,
    'f', 'o', 'r', 'm', 'a', 't', 0,
    'o', 'b', 'j', 'e', 'c', 't', 0,
    'p', 'a', 'r', 'e', 'n', 't', 0,
    '_', '_', 'n', 'e', '_', '_', 0,
    '_', '_', 'e', 'q', '_', '_', 0,
    '_', '_', 'o', 'r', '_', '_', 0,
    'e', 'r', 'r', 'o', 'r', 0,
    'w', 'i', 'd', 't', 'h', 0,
    'c', 'l', 'e', 'a', 'r', 0,
    'e', 'v', 'e', 'n', 't', 0,
    'm', 's', 'e', 'c', 's', 0,
    's', 't', 'a', 't', 'e', 0,
    'a', 'r', 'e', 'a', 0,
    'c', 'i', 't', 'y', 0,
    't', 'e', 'x', 't', 0,
    'm', 'o', 'd', 'e', 0,
    't', 'y', 'p', 'e', 0,
    'n', 'a', 'm', 'e', 0,
    'b', 'a', 's', 'e', 0,
    'f', 'r', 'o', 'm', 0,
    's', 'o', 'r', 't', 0,
    'G', 'P', 'S', 0,
};
#line 25 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoareamonitorinfo.sip"
#include <qgeoareamonitorinfo.h>
#line 25 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeocoordinate.sip"
#include <qgeocoordinate.h>
#line 25 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfo.sip"
#include <qgeopositioninfo.h>
#line 25 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfosource.sip"
#include <qgeopositioninfosource.h>
#line 25 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeosatelliteinfo.sip"
#include <qgeosatelliteinfo.h>
#line 25 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoshape.sip"
#include <qgeoshape.h>
#line 334 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

bool sipVH_QtPositioning_0(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const char*a0,int a1,QGeoPositionInfo*a2,bool*a3)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "siD",a0,a1,a2,sipType_QGeoPositionInfo,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "(bb)", &sipRes, a3);

    return sipRes;
}

QGeoPositionInfoSource::Error sipVH_QtPositioning_1(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    QGeoPositionInfoSource::Error sipRes = (QGeoPositionInfoSource::Error)0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

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

    return sipRes;
}

QGeoPositionInfoSource::PositioningMethods sipVH_QtPositioning_2(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    QGeoPositionInfoSource::PositioningMethods sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

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

    return sipRes;
}

QGeoPositionInfo sipVH_QtPositioning_3(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, bool a0)
{
    QGeoPositionInfo sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "b",a0);

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

    return sipRes;
}

QGeoSatelliteInfoSource::Error sipVH_QtPositioning_4(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    QGeoSatelliteInfoSource::Error sipRes = (QGeoSatelliteInfoSource::Error)0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

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

    return sipRes;
}

void sipVH_QtPositioning_5(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, QGeoPositionInfoSource::PositioningMethods a0)
{
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QGeoPositionInfoSource::PositioningMethods(a0),sipType_QGeoPositionInfoSource_PositioningMethods,NULL);

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

QList<QGeoAreaMonitorInfo> sipVH_QtPositioning_6(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QGeoShape& a0)
{
    QList<QGeoAreaMonitorInfo> sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QGeoShape(a0),sipType_QGeoShape,NULL);

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

    return sipRes;
}

QList<QGeoAreaMonitorInfo> sipVH_QtPositioning_7(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    QList<QGeoAreaMonitorInfo> sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

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

    return sipRes;
}

bool sipVH_QtPositioning_8(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QGeoAreaMonitorInfo& a0,const char*a1)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "NA",new QGeoAreaMonitorInfo(a0),sipType_QGeoAreaMonitorInfo,NULL,a1);

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

    return sipRes;
}

bool sipVH_QtPositioning_9(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QGeoAreaMonitorInfo& a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QGeoAreaMonitorInfo(a0),sipType_QGeoAreaMonitorInfo,NULL);

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

    return sipRes;
}

QGeoAreaMonitorSource::AreaMonitorFeatures sipVH_QtPositioning_10(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    QGeoAreaMonitorSource::AreaMonitorFeatures sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

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

    return sipRes;
}

QGeoAreaMonitorSource::Error sipVH_QtPositioning_11(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    QGeoAreaMonitorSource::Error sipRes = (QGeoAreaMonitorSource::Error)0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

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

    return sipRes;
}

QGeoPositionInfoSource* sipVH_QtPositioning_12(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    QGeoPositionInfoSource* sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H0", sipType_QGeoPositionInfoSource, &sipRes);

    return sipRes;
}

void sipVH_QtPositioning_13(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, QGeoPositionInfoSource*a0)
{
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "D",a0,sipType_QGeoPositionInfoSource,NULL);

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


extern "C" {static PyObject *slot___rshift__(PyObject *,PyObject *);}
static PyObject *slot___rshift__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QDataStream* a0;
        QGeoAreaMonitorInfo* a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J9J9", sipType_QDataStream, &a0, sipType_QGeoAreaMonitorInfo, &a1))
        {
            QDataStream*sipRes;

            sipRes = &(*a0 >> *a1);

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

    {
        QDataStream* a0;
        QGeoCoordinate* a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J9J9", sipType_QDataStream, &a0, sipType_QGeoCoordinate, &a1))
        {
            QDataStream*sipRes;

            sipRes = &(*a0 >> *a1);

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

    {
        QDataStream* a0;
        QGeoPositionInfo* a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J9J9", sipType_QDataStream, &a0, sipType_QGeoPositionInfo, &a1))
        {
            QDataStream*sipRes;

            sipRes = &(*a0 >> *a1);

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

    {
        QDataStream* a0;
        QGeoSatelliteInfo* a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J9J9", sipType_QDataStream, &a0, sipType_QGeoSatelliteInfo, &a1))
        {
            QDataStream*sipRes;

            sipRes = &(*a0 >> *a1);

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

    {
        QDataStream* a0;
        QGeoShape* a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J9J9", sipType_QDataStream, &a0, sipType_QGeoShape, &a1))
        {
            QDataStream*sipRes;

            sipRes = &(*a0 >> *a1);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot___lshift__(PyObject *,PyObject *);}
static PyObject *slot___lshift__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QDataStream* a0;
        const QGeoAreaMonitorInfo* a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J9J9", sipType_QDataStream, &a0, sipType_QGeoAreaMonitorInfo, &a1))
        {
            QDataStream*sipRes;

            sipRes = &(*a0 << *a1);

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

    {
        QDataStream* a0;
        const QGeoCoordinate* a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J9J9", sipType_QDataStream, &a0, sipType_QGeoCoordinate, &a1))
        {
            QDataStream*sipRes;

            sipRes = &(*a0 << *a1);

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

    {
        QDataStream* a0;
        const QGeoPositionInfo* a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J9J9", sipType_QDataStream, &a0, sipType_QGeoPositionInfo, &a1))
        {
            QDataStream*sipRes;

            sipRes = &(*a0 << *a1);

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

    {
        QDataStream* a0;
        const QGeoSatelliteInfo* a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J9J9", sipType_QDataStream, &a0, sipType_QGeoSatelliteInfo, &a1))
        {
            QDataStream*sipRes;

            sipRes = &(*a0 << *a1);

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

    {
        QDataStream* a0;
        const QGeoShape* a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J9J9", sipType_QDataStream, &a0, sipType_QGeoShape, &a1))
        {
            QDataStream*sipRes;

            sipRes = &(*a0 << *a1);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

static sipPySlotExtenderDef slotExtenders[] = {
    {(void *)slot___rshift__, rshift_slot, {0, 0, 0}},
    {(void *)slot___lshift__, lshift_slot, {0, 0, 0}},
    {NULL, (sipPySlotType)0, {0, 0, 0}}
};


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

#line 38 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoshape.sip"
    switch (sipCpp->type())
    {
    case QGeoShape::CircleType:
        sipType = sipType_QGeoCircle;
        break;
    
    case QGeoShape::RectangleType:
        sipType = sipType_QGeoRectangle;
        break;
    
    default:
        sipType = 0;
    }
#line 668 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

    return sipType;
}


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

#line 38 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfosource.sip"
    static struct class_graph {
        const char *name;
        sipTypeDef **type;
        int yes, no;
    } graph[] = {
        {sipName_QGeoPositionInfoSource, &sipType_QGeoPositionInfoSource, 3, 1},
        {sipName_QGeoSatelliteInfoSource, &sipType_QGeoSatelliteInfoSource, -1, 2},
        {sipName_QGeoAreaMonitorSource, &sipType_QGeoAreaMonitorSource, -1, -1},
        {sipName_QNmeaPositionInfoSource, &sipType_QNmeaPositionInfoSource, -1, -1},
    };
    
    int i = 0;
    
    sipType = NULL;
    
    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 710 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

    return sipType;
}


extern "C" {static PyObject *slot_QGeoPositionInfoSource_PositioningMethod___or__(PyObject *,PyObject *);}
static PyObject *slot_QGeoPositionInfoSource_PositioningMethod___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QGeoPositionInfoSource::PositioningMethod a0;
        QGeoPositionInfoSource::PositioningMethods* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "EJ1", sipType_QGeoPositionInfoSource_PositioningMethod, &a0, sipType_QGeoPositionInfoSource_PositioningMethods, &a1, &a1State))
        {
            QGeoPositionInfoSource::PositioningMethods*sipRes;

            sipRes = new QGeoPositionInfoSource::PositioningMethods((a0 | *a1));
            sipReleaseType(a1,sipType_QGeoPositionInfoSource_PositioningMethods,a1State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

static sipPySlotDef slots_QGeoPositionInfoSource_PositioningMethod[] = {
    {(void *)slot_QGeoPositionInfoSource_PositioningMethod___or__, or_slot},
    {0, (sipPySlotType)0}
};

static sipEnumTypeDef enumTypes[] = {
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QNmeaPositionInfoSource__UpdateMode, {0}}, sipNameNr_UpdateMode, 28, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGeoShape__ShapeType, {0}}, sipNameNr_ShapeType, 23, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGeoSatelliteInfoSource__Error, {0}}, sipNameNr_Error, 21, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGeoSatelliteInfo__SatelliteSystem, {0}}, sipNameNr_SatelliteSystem, 18, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGeoSatelliteInfo__Attribute, {0}}, sipNameNr_Attribute, 18, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGeoPositionInfoSource__PositioningMethod, {0}}, sipNameNr_PositioningMethod, 13, slots_QGeoPositionInfoSource_PositioningMethod},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGeoPositionInfoSource__Error, {0}}, sipNameNr_Error, 13, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGeoPositionInfo__Attribute, {0}}, sipNameNr_Attribute, 11, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGeoCoordinate__CoordinateFormat, {0}}, sipNameNr_CoordinateFormat, 7, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGeoCoordinate__CoordinateType, {0}}, sipNameNr_CoordinateType, 7, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGeoAreaMonitorSource__AreaMonitorFeature, {0}}, sipNameNr_AreaMonitorFeature, 2, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGeoAreaMonitorSource__Error, {0}}, sipNameNr_Error, 2, NULL},
};


/*
 * This defines each type in this module.
 */
static sipTypeDef *typesTable[] = {
    &sipTypeDef_QtPositioning_QGeoAddress.super.ctd_base,
    &sipTypeDef_QtPositioning_QGeoAreaMonitorInfo.super.ctd_base,
    &sipTypeDef_QtPositioning_QGeoAreaMonitorSource.super.ctd_base,
    &enumTypes[10].etd_base,
    &sipTypeDef_QtPositioning_QGeoAreaMonitorSource_AreaMonitorFeatures.super.ctd_base,
    &enumTypes[11].etd_base,
    &sipTypeDef_QtPositioning_QGeoCircle.super.ctd_base,
    &sipTypeDef_QtPositioning_QGeoCoordinate.super.ctd_base,
    &enumTypes[8].etd_base,
    &enumTypes[9].etd_base,
    &sipTypeDef_QtPositioning_QGeoLocation.super.ctd_base,
    &sipTypeDef_QtPositioning_QGeoPositionInfo.super.ctd_base,
    &enumTypes[7].etd_base,
    &sipTypeDef_QtPositioning_QGeoPositionInfoSource.super.ctd_base,
    &enumTypes[6].etd_base,
    &enumTypes[5].etd_base,
    &sipTypeDef_QtPositioning_QGeoPositionInfoSource_PositioningMethods.super.ctd_base,
    &sipTypeDef_QtPositioning_QGeoRectangle.super.ctd_base,
    &sipTypeDef_QtPositioning_QGeoSatelliteInfo.super.ctd_base,
    &enumTypes[4].etd_base,
    &enumTypes[3].etd_base,
    &sipTypeDef_QtPositioning_QGeoSatelliteInfoSource.super.ctd_base,
    &enumTypes[2].etd_base,
    &sipTypeDef_QtPositioning_QGeoShape.super.ctd_base,
    &enumTypes[1].etd_base,
    &sipTypeDef_QtPositioning_QList_0100QGeoAreaMonitorInfo.mtd_base,
    &sipTypeDef_QtPositioning_QList_0100QGeoCoordinate.mtd_base,
    &sipTypeDef_QtPositioning_QList_0100QGeoSatelliteInfo.mtd_base,
    &sipTypeDef_QtPositioning_QNmeaPositionInfoSource.super.ctd_base,
    &enumTypes[0].etd_base,
};


/*
 * This defines the virtual handlers that this module implements and can be
 * used by other modules.
 */
static sipVirtHandlerFunc virtHandlersTable[] = {
    (sipVirtHandlerFunc)sipVH_QtPositioning_0,
    (sipVirtHandlerFunc)sipVH_QtPositioning_1,
    (sipVirtHandlerFunc)sipVH_QtPositioning_2,
    (sipVirtHandlerFunc)sipVH_QtPositioning_3,
    (sipVirtHandlerFunc)sipVH_QtPositioning_4,
    (sipVirtHandlerFunc)sipVH_QtPositioning_5,
    (sipVirtHandlerFunc)sipVH_QtPositioning_6,
    (sipVirtHandlerFunc)sipVH_QtPositioning_7,
    (sipVirtHandlerFunc)sipVH_QtPositioning_8,
    (sipVirtHandlerFunc)sipVH_QtPositioning_9,
    (sipVirtHandlerFunc)sipVH_QtPositioning_10,
    (sipVirtHandlerFunc)sipVH_QtPositioning_11,
    (sipVirtHandlerFunc)sipVH_QtPositioning_12,
    (sipVirtHandlerFunc)sipVH_QtPositioning_13,
};


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


/* This defines the class sub-convertors that this module defines. */
static sipSubClassConvertorDef convertorsTable[] = {
    {sipSubClass_QGeoShape, {23, 255, 0}, NULL},
    {sipSubClass_QGeoPositionInfoSource, {162, 0, 0}, NULL},
    {NULL, {0, 0, 0}, NULL}
};


/* This defines this module. */
sipExportedModuleDef sipModuleAPI_QtPositioning = {
    0,
    SIP_API_MINOR_NR,
    sipNameNr_PyQt5_QtPositioning,
    0,
    -1,
    sipStrings_QtPositioning,
    importsTable,
    NULL,
    30,
    typesTable,
    NULL,
    0,
    NULL,
    0,
    NULL,
    virtHandlersTable,
    NULL,
    convertorsTable,
    {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
    NULL,
    NULL,
    slotExtenders,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};


/* The SIP API and the APIs of any imported modules. */
const sipAPIDef *sipAPI_QtPositioning;
const sipExportedModuleDef *sipModuleAPI_QtPositioning_QtCore;

sip_qt_metaobject_func sip_QtPositioning_qt_metaobject;
sip_qt_metacall_func sip_QtPositioning_qt_metacall;
sip_qt_metacast_func sip_QtPositioning_qt_metacast;


/* The Python module initialisation function. */
#if PY_MAJOR_VERSION >= 3
#define SIP_MODULE_ENTRY        PyInit_QtPositioning
#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        initQtPositioning
#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,
        "PyQt5.QtPositioning",
        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_PyQt5_QtPositioning, sip_methods);
#else
    sipModule = Py_InitModule(const_cast<char *>(sipName_PyQt5_QtPositioning), 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_QtPositioning = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, SIP_MODULE_NAME "._C_API"));
#else
    sipAPI_QtPositioning = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif

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

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

    sip_QtPositioning_qt_metaobject = (sip_qt_metaobject_func)sipImportSymbol("qtcore_qt_metaobject");
    sip_QtPositioning_qt_metacall = (sip_qt_metacall_func)sipImportSymbol("qtcore_qt_metacall");
    sip_QtPositioning_qt_metacast = (sip_qt_metacast_func)sipImportSymbol("qtcore_qt_metacast");

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

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

    /* Get the APIs of the modules that this one is dependent on. */
    sipModuleAPI_QtPositioning_QtCore = sipModuleAPI_QtPositioning.em_imports[0].im_module;

    SIP_MODULE_RETURN(sipModule);
}

#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 1005 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeosatelliteinfo.sip"
#include <qgeosatelliteinfo.h>
#line 1009 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


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


extern "C" {static void *array_QList_0100QGeoSatelliteInfo(SIP_SSIZE_T);}
static void *array_QList_0100QGeoSatelliteInfo(SIP_SSIZE_T sipNrElem)
{
    return new QList<QGeoSatelliteInfo>[sipNrElem];
}


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


/* Call the mapped type's destructor. */
extern "C" {static void release_QList_0100QGeoSatelliteInfo(void *, int);}
static void release_QList_0100QGeoSatelliteInfo(void *ptr, int)
{
    delete reinterpret_cast<QList<QGeoSatelliteInfo> *>(ptr);
}



extern "C" {static int convertTo_QList_0100QGeoSatelliteInfo(PyObject *, void **, int *, PyObject *);}
static int convertTo_QList_0100QGeoSatelliteInfo(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QList<QGeoSatelliteInfo> **sipCppPtr = reinterpret_cast<QList<QGeoSatelliteInfo> **>(sipCppPtrV);

#line 66 "sip/QtCore/qpycore_qlist.sip"
    PyObject *iter = PyObject_GetIter(sipPy);

    if (!sipIsErr)
    {
        Py_XDECREF(iter);

        return (iter
#if PY_MAJOR_VERSION < 3
                && !PyString_Check(sipPy)
#endif
                && !PyUnicode_Check(sipPy));
    }

    if (!iter)
    {
        *sipIsErr = 1;

        return 0;
    }

    QList<QGeoSatelliteInfo> *ql = new QList<QGeoSatelliteInfo>;
 
    for (SIP_SSIZE_T i = 0; ; ++i)
    {
        PyErr_Clear();
        PyObject *itm = PyIter_Next(iter);

        if (!itm)
        {
            if (PyErr_Occurred())
            {
                delete ql;
                Py_DECREF(iter);
                *sipIsErr = 1;

                return 0;
            }

            break;
        }

        int state;
        QGeoSatelliteInfo *t = reinterpret_cast<QGeoSatelliteInfo *>(
                sipForceConvertToType(itm, sipType_QGeoSatelliteInfo, sipTransferObj,
                        SIP_NOT_NONE, &state, sipIsErr));

        if (*sipIsErr)
        {
            PyErr_Format(PyExc_TypeError,
                    "index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QGeoSatelliteInfo' is expected",
                    i, Py_TYPE(itm)->tp_name);

            Py_DECREF(itm);
            delete ql;
            Py_DECREF(iter);

            return 0;
        }

        ql->append(*t);

        sipReleaseType(t, sipType_QGeoSatelliteInfo, state);
        Py_DECREF(itm);
    }
 
    Py_DECREF(iter);

    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 1118 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
}


extern "C" {static PyObject *convertFrom_QList_0100QGeoSatelliteInfo(void *, PyObject *);}
static PyObject *convertFrom_QList_0100QGeoSatelliteInfo(void *sipCppV, PyObject *sipTransferObj)
{
   QList<QGeoSatelliteInfo> *sipCpp = reinterpret_cast<QList<QGeoSatelliteInfo> *>(sipCppV);

#line 40 "sip/QtCore/qpycore_qlist.sip"
    PyObject *l = PyList_New(sipCpp->size());

    if (!l)
        return 0;

    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QGeoSatelliteInfo *t = new QGeoSatelliteInfo(sipCpp->at(i));
        PyObject *tobj = sipConvertFromNewType(t, sipType_QGeoSatelliteInfo,
                sipTransferObj);

        if (!tobj)
        {
            delete t;
            Py_DECREF(l);

            return 0;
        }

        PyList_SET_ITEM(l, i, tobj);
    }

    return l;
#line 1151 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtPositioning_QList_0100QGeoSatelliteInfo = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_839,
        {0}
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0100QGeoSatelliteInfo,
    array_QList_0100QGeoSatelliteInfo,
    copy_QList_0100QGeoSatelliteInfo,
    release_QList_0100QGeoSatelliteInfo,
    convertTo_QList_0100QGeoSatelliteInfo,
    convertFrom_QList_0100QGeoSatelliteInfo
};

#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 1182 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeocoordinate.sip"
#include <qgeocoordinate.h>
#line 1186 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


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


extern "C" {static void *array_QList_0100QGeoCoordinate(SIP_SSIZE_T);}
static void *array_QList_0100QGeoCoordinate(SIP_SSIZE_T sipNrElem)
{
    return new QList<QGeoCoordinate>[sipNrElem];
}


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


/* Call the mapped type's destructor. */
extern "C" {static void release_QList_0100QGeoCoordinate(void *, int);}
static void release_QList_0100QGeoCoordinate(void *ptr, int)
{
    delete reinterpret_cast<QList<QGeoCoordinate> *>(ptr);
}



extern "C" {static int convertTo_QList_0100QGeoCoordinate(PyObject *, void **, int *, PyObject *);}
static int convertTo_QList_0100QGeoCoordinate(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QList<QGeoCoordinate> **sipCppPtr = reinterpret_cast<QList<QGeoCoordinate> **>(sipCppPtrV);

#line 66 "sip/QtCore/qpycore_qlist.sip"
    PyObject *iter = PyObject_GetIter(sipPy);

    if (!sipIsErr)
    {
        Py_XDECREF(iter);

        return (iter
#if PY_MAJOR_VERSION < 3
                && !PyString_Check(sipPy)
#endif
                && !PyUnicode_Check(sipPy));
    }

    if (!iter)
    {
        *sipIsErr = 1;

        return 0;
    }

    QList<QGeoCoordinate> *ql = new QList<QGeoCoordinate>;
 
    for (SIP_SSIZE_T i = 0; ; ++i)
    {
        PyErr_Clear();
        PyObject *itm = PyIter_Next(iter);

        if (!itm)
        {
            if (PyErr_Occurred())
            {
                delete ql;
                Py_DECREF(iter);
                *sipIsErr = 1;

                return 0;
            }

            break;
        }

        int state;
        QGeoCoordinate *t = reinterpret_cast<QGeoCoordinate *>(
                sipForceConvertToType(itm, sipType_QGeoCoordinate, sipTransferObj,
                        SIP_NOT_NONE, &state, sipIsErr));

        if (*sipIsErr)
        {
            PyErr_Format(PyExc_TypeError,
                    "index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QGeoCoordinate' is expected",
                    i, Py_TYPE(itm)->tp_name);

            Py_DECREF(itm);
            delete ql;
            Py_DECREF(iter);

            return 0;
        }

        ql->append(*t);

        sipReleaseType(t, sipType_QGeoCoordinate, state);
        Py_DECREF(itm);
    }
 
    Py_DECREF(iter);

    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 1295 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
}


extern "C" {static PyObject *convertFrom_QList_0100QGeoCoordinate(void *, PyObject *);}
static PyObject *convertFrom_QList_0100QGeoCoordinate(void *sipCppV, PyObject *sipTransferObj)
{
   QList<QGeoCoordinate> *sipCpp = reinterpret_cast<QList<QGeoCoordinate> *>(sipCppV);

#line 40 "sip/QtCore/qpycore_qlist.sip"
    PyObject *l = PyList_New(sipCpp->size());

    if (!l)
        return 0;

    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QGeoCoordinate *t = new QGeoCoordinate(sipCpp->at(i));
        PyObject *tobj = sipConvertFromNewType(t, sipType_QGeoCoordinate,
                sipTransferObj);

        if (!tobj)
        {
            delete t;
            Py_DECREF(l);

            return 0;
        }

        PyList_SET_ITEM(l, i, tobj);
    }

    return l;
#line 1328 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtPositioning_QList_0100QGeoCoordinate = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_1103,
        {0}
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0100QGeoCoordinate,
    array_QList_0100QGeoCoordinate,
    copy_QList_0100QGeoCoordinate,
    release_QList_0100QGeoCoordinate,
    convertTo_QList_0100QGeoCoordinate,
    convertFrom_QList_0100QGeoCoordinate
};

#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 1359 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoareamonitorinfo.sip"
#include <qgeoareamonitorinfo.h>
#line 1363 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


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


extern "C" {static void *array_QList_0100QGeoAreaMonitorInfo(SIP_SSIZE_T);}
static void *array_QList_0100QGeoAreaMonitorInfo(SIP_SSIZE_T sipNrElem)
{
    return new QList<QGeoAreaMonitorInfo>[sipNrElem];
}


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


/* Call the mapped type's destructor. */
extern "C" {static void release_QList_0100QGeoAreaMonitorInfo(void *, int);}
static void release_QList_0100QGeoAreaMonitorInfo(void *ptr, int)
{
    delete reinterpret_cast<QList<QGeoAreaMonitorInfo> *>(ptr);
}



extern "C" {static int convertTo_QList_0100QGeoAreaMonitorInfo(PyObject *, void **, int *, PyObject *);}
static int convertTo_QList_0100QGeoAreaMonitorInfo(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QList<QGeoAreaMonitorInfo> **sipCppPtr = reinterpret_cast<QList<QGeoAreaMonitorInfo> **>(sipCppPtrV);

#line 66 "sip/QtCore/qpycore_qlist.sip"
    PyObject *iter = PyObject_GetIter(sipPy);

    if (!sipIsErr)
    {
        Py_XDECREF(iter);

        return (iter
#if PY_MAJOR_VERSION < 3
                && !PyString_Check(sipPy)
#endif
                && !PyUnicode_Check(sipPy));
    }

    if (!iter)
    {
        *sipIsErr = 1;

        return 0;
    }

    QList<QGeoAreaMonitorInfo> *ql = new QList<QGeoAreaMonitorInfo>;
 
    for (SIP_SSIZE_T i = 0; ; ++i)
    {
        PyErr_Clear();
        PyObject *itm = PyIter_Next(iter);

        if (!itm)
        {
            if (PyErr_Occurred())
            {
                delete ql;
                Py_DECREF(iter);
                *sipIsErr = 1;

                return 0;
            }

            break;
        }

        int state;
        QGeoAreaMonitorInfo *t = reinterpret_cast<QGeoAreaMonitorInfo *>(
                sipForceConvertToType(itm, sipType_QGeoAreaMonitorInfo, sipTransferObj,
                        SIP_NOT_NONE, &state, sipIsErr));

        if (*sipIsErr)
        {
            PyErr_Format(PyExc_TypeError,
                    "index " SIP_SSIZE_T_FORMAT " has type '%s' but 'QGeoAreaMonitorInfo' is expected",
                    i, Py_TYPE(itm)->tp_name);

            Py_DECREF(itm);
            delete ql;
            Py_DECREF(iter);

            return 0;
        }

        ql->append(*t);

        sipReleaseType(t, sipType_QGeoAreaMonitorInfo, state);
        Py_DECREF(itm);
    }
 
    Py_DECREF(iter);

    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 1472 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
}


extern "C" {static PyObject *convertFrom_QList_0100QGeoAreaMonitorInfo(void *, PyObject *);}
static PyObject *convertFrom_QList_0100QGeoAreaMonitorInfo(void *sipCppV, PyObject *sipTransferObj)
{
   QList<QGeoAreaMonitorInfo> *sipCpp = reinterpret_cast<QList<QGeoAreaMonitorInfo> *>(sipCppV);

#line 40 "sip/QtCore/qpycore_qlist.sip"
    PyObject *l = PyList_New(sipCpp->size());

    if (!l)
        return 0;

    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QGeoAreaMonitorInfo *t = new QGeoAreaMonitorInfo(sipCpp->at(i));
        PyObject *tobj = sipConvertFromNewType(t, sipType_QGeoAreaMonitorInfo,
                sipTransferObj);

        if (!tobj)
        {
            delete t;
            Py_DECREF(l);

            return 0;
        }

        PyList_SET_ITEM(l, i, tobj);
    }

    return l;
#line 1505 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtPositioning_QList_0100QGeoAreaMonitorInfo = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_786,
        {0}
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0100QGeoAreaMonitorInfo,
    array_QList_0100QGeoAreaMonitorInfo,
    copy_QList_0100QGeoAreaMonitorInfo,
    release_QList_0100QGeoAreaMonitorInfo,
    convertTo_QList_0100QGeoAreaMonitorInfo,
    convertFrom_QList_0100QGeoAreaMonitorInfo
};

#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qnmeapositioninfosource.sip"
#include <qnmeapositioninfosource.h>
#line 1536 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 1540 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfo.sip"
#include <qgeopositioninfo.h>
#line 1543 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfosource.sip"
#include <qgeopositioninfosource.h>
#line 1546 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfosource.sip"
#include <qgeopositioninfosource.h>
#line 1549 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qiodevice.sip"
#include <qiodevice.h>
#line 1552 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 1555 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 1558 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 1561 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 1564 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 241 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 1567 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 229 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 1570 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 1573 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 1576 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 32 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 1579 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 144 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 1582 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 1585 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 1588 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 1591 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 1594 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 1597 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 1600 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


class sipQNmeaPositionInfoSource : public QNmeaPositionInfoSource
{
public:
    sipQNmeaPositionInfoSource(QNmeaPositionInfoSource::UpdateMode,QObject*);
    virtual ~sipQNmeaPositionInfoSource();

    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 QMetaMethod&);
    void sipProtectVirt_disconnectNotify(bool,const QMetaMethod&);
    int sipProtect_senderSignalIndex() const;
    bool sipProtect_isSignalConnected(const QMetaMethod&) const;
    bool sipProtectVirt_parsePosInfoFromNmeaData(bool,const char*,int,QGeoPositionInfo*,bool*);

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const QMetaMethod&);
    void connectNotify(const QMetaMethod&);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);
    void setPreferredPositioningMethods(QGeoPositionInfoSource::PositioningMethods);
    bool parsePosInfoFromNmeaData(const char*,int,QGeoPositionInfo*,bool*);
    void requestUpdate(int);
    void stopUpdates();
    void startUpdates();
    QGeoPositionInfoSource::Error error() const;
    int minimumUpdateInterval() const;
    QGeoPositionInfoSource::PositioningMethods supportedPositioningMethods() const;
    QGeoPositionInfo lastKnownPosition(bool) const;
    void setUpdateInterval(int);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[17];
};

sipQNmeaPositionInfoSource::sipQNmeaPositionInfoSource(QNmeaPositionInfoSource::UpdateMode a0,QObject*a1): QNmeaPositionInfoSource(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

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

const QMetaObject *sipQNmeaPositionInfoSource::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtPositioning_qt_metaobject(sipPySelf,sipType_QNmeaPositionInfoSource);
}

int sipQNmeaPositionInfoSource::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = QNmeaPositionInfoSource::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtPositioning_qt_metacall(sipPySelf,sipType_QNmeaPositionInfoSource,_c,_id,_a);

    return _id;
}

void *sipQNmeaPositionInfoSource::qt_metacast(const char *_clname)
{
    void *sipCpp;

    return (sip_QtPositioning_qt_metacast(sipPySelf, sipType_QNmeaPositionInfoSource, _clname, &sipCpp) ? sipCpp : QNmeaPositionInfoSource::qt_metacast(_clname));
}

void sipQNmeaPositionInfoSource::disconnectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QNmeaPositionInfoSource::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQNmeaPositionInfoSource::connectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QNmeaPositionInfoSource::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQNmeaPositionInfoSource::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QNmeaPositionInfoSource::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[25]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQNmeaPositionInfoSource::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QNmeaPositionInfoSource::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_47)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_47)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[47]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQNmeaPositionInfoSource::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QNmeaPositionInfoSource::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[9]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipQNmeaPositionInfoSource::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return QNmeaPositionInfoSource::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_26)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_26)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[26]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1);
}

bool sipQNmeaPositionInfoSource::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return QNmeaPositionInfoSource::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[5]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQNmeaPositionInfoSource::setPreferredPositioningMethods(QGeoPositionInfoSource::PositioningMethods a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QNmeaPositionInfoSource::setPreferredPositioningMethods(a0);
        return;
    }

    extern void sipVH_QtPositioning_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QGeoPositionInfoSource::PositioningMethods);

    sipVH_QtPositioning_5(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipQNmeaPositionInfoSource::parsePosInfoFromNmeaData(const char*a0,int a1,QGeoPositionInfo*a2,bool*a3)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return QNmeaPositionInfoSource::parsePosInfoFromNmeaData(a0,a1,a2,a3);

    extern bool sipVH_QtPositioning_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*,int,QGeoPositionInfo*,bool*);

    return sipVH_QtPositioning_0(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1, a2, a3);
}

void sipQNmeaPositionInfoSource::requestUpdate(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QNmeaPositionInfoSource::requestUpdate(a0);
        return;
    }

    typedef void (*sipVH_QtCore_4)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    ((sipVH_QtCore_4)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[4]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQNmeaPositionInfoSource::stopUpdates()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QNmeaPositionInfoSource::stopUpdates();
        return;
    }

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

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

void sipQNmeaPositionInfoSource::startUpdates()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QNmeaPositionInfoSource::startUpdates();
        return;
    }

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

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

QGeoPositionInfoSource::Error sipQNmeaPositionInfoSource::error() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[12]),sipPySelf,NULL,sipName_error);

    if (!sipMeth)
        return QNmeaPositionInfoSource::error();

    extern QGeoPositionInfoSource::Error sipVH_QtPositioning_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtPositioning_1(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

int sipQNmeaPositionInfoSource::minimumUpdateInterval() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[13]),sipPySelf,NULL,sipName_minimumUpdateInterval);

    if (!sipMeth)
        return QNmeaPositionInfoSource::minimumUpdateInterval();

    typedef int (*sipVH_QtCore_6)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_6)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[6]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

QGeoPositionInfoSource::PositioningMethods sipQNmeaPositionInfoSource::supportedPositioningMethods() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[14]),sipPySelf,NULL,sipName_supportedPositioningMethods);

    if (!sipMeth)
        return QNmeaPositionInfoSource::supportedPositioningMethods();

    extern QGeoPositionInfoSource::PositioningMethods sipVH_QtPositioning_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtPositioning_2(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

QGeoPositionInfo sipQNmeaPositionInfoSource::lastKnownPosition(bool a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[15]),sipPySelf,NULL,sipName_lastKnownPosition);

    if (!sipMeth)
        return QNmeaPositionInfoSource::lastKnownPosition(a0);

    extern QGeoPositionInfo sipVH_QtPositioning_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    return sipVH_QtPositioning_3(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQNmeaPositionInfoSource::setUpdateInterval(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[16],sipPySelf,NULL,sipName_setUpdateInterval);

    if (!sipMeth)
    {
        QNmeaPositionInfoSource::setUpdateInterval(a0);
        return;
    }

    typedef void (*sipVH_QtCore_4)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    ((sipVH_QtCore_4)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[4]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QObject* sipQNmeaPositionInfoSource::sipProtect_sender() const
{
    return QObject::sender();
}

int sipQNmeaPositionInfoSource::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipQNmeaPositionInfoSource::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQNmeaPositionInfoSource::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipQNmeaPositionInfoSource::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipQNmeaPositionInfoSource::sipProtectVirt_connectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQNmeaPositionInfoSource::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQNmeaPositionInfoSource::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

bool sipQNmeaPositionInfoSource::sipProtect_isSignalConnected(const QMetaMethod& a0) const
{
    return QObject::isSignalConnected(a0);
}

bool sipQNmeaPositionInfoSource::sipProtectVirt_parsePosInfoFromNmeaData(bool sipSelfWasArg,const char*a0,int a1,QGeoPositionInfo*a2,bool*a3)
{
    return (sipSelfWasArg ? QNmeaPositionInfoSource::parsePosInfoFromNmeaData(a0,a1,a2,a3) : parsePosInfoFromNmeaData(a0,a1,a2,a3));
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_sender, "QNmeaPositionInfoSource.sender() -> QObject");

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

    {
        const sipQNmeaPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp))
        {
            QObject*sipRes = 0;

#line 546 "sip/QtCore/qobject.sip"
        // 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 (!sipRes)
        {
            typedef QObject *(*qtcore_qobject_sender_t)();
        
            static qtcore_qobject_sender_t qtcore_qobject_sender = 0;
        
            if (!qtcore_qobject_sender)
                qtcore_qobject_sender = (qtcore_qobject_sender_t)sipImportSymbol("qtcore_qobject_sender");
        
            if (qtcore_qobject_sender)
                sipRes = qtcore_qobject_sender();
        }
#line 2069 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_sender, doc_QNmeaPositionInfoSource_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_receivers, "QNmeaPositionInfoSource.receivers(signal) -> int");

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

    {
        PyObject * a0;
        const sipQNmeaPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 575 "sip/QtCore/qobject.sip"
        // We need to handle the signal object.  Import the helper if it hasn't already
        // been done.
        typedef sipErrorState (*pyqt5_get_signal_signature_t)(PyObject *, const QObject *, const QByteArray &);
        
        static pyqt5_get_signal_signature_t pyqt5_get_signal_signature = 0;
        
        if (!pyqt5_get_signal_signature)
            pyqt5_get_signal_signature = (pyqt5_get_signal_signature_t)sipImportSymbol("pyqt5_get_signal_signature");
        
        if (pyqt5_get_signal_signature)
        {
            QByteArray signal_signature;
            
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            if ((sipError = pyqt5_get_signal_signature(a0, sipCpp, signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->receivers(signal_signature.constData());
            }
        #else
            if ((sipError = pyqt5_get_signal_signature(a0, static_cast<const QObject *>(sipCpp), signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->sipProtect_receivers(signal_signature.constData());
            }
        #endif
            else if (sipError == sipErrorContinue)
            {
                sipError = sipBadCallableArg(0, a0);
            }
        }
#line 2128 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_receivers, doc_QNmeaPositionInfoSource_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_timerEvent, "QNmeaPositionInfoSource.timerEvent(QTimerEvent)");

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

    {
        QTimerEvent* a0;
        sipQNmeaPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp, sipType_QTimerEvent, &a0))
        {
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_timerEvent, doc_QNmeaPositionInfoSource_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_childEvent, "QNmeaPositionInfoSource.childEvent(QChildEvent)");

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

    {
        QChildEvent* a0;
        sipQNmeaPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp, sipType_QChildEvent, &a0))
        {
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_childEvent, doc_QNmeaPositionInfoSource_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_customEvent, "QNmeaPositionInfoSource.customEvent(QEvent)");

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

    {
        QEvent* a0;
        sipQNmeaPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp, sipType_QEvent, &a0))
        {
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_customEvent, doc_QNmeaPositionInfoSource_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_connectNotify, "QNmeaPositionInfoSource.connectNotify(QMetaMethod)");

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

    {
        const QMetaMethod* a0;
        sipQNmeaPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_connectNotify, doc_QNmeaPositionInfoSource_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_disconnectNotify, "QNmeaPositionInfoSource.disconnectNotify(QMetaMethod)");

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

    {
        const QMetaMethod* a0;
        sipQNmeaPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_disconnectNotify, doc_QNmeaPositionInfoSource_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_senderSignalIndex, "QNmeaPositionInfoSource.senderSignalIndex() -> int");

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

    {
        const sipQNmeaPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_senderSignalIndex, doc_QNmeaPositionInfoSource_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_isSignalConnected, "QNmeaPositionInfoSource.isSignalConnected(QMetaMethod) -> bool");

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

    {
        const QMetaMethod* a0;
        const sipQNmeaPositionInfoSource *sipCpp;

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

            sipRes = sipCpp->sipProtect_isSignalConnected(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_isSignalConnected, doc_QNmeaPositionInfoSource_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_updateMode, "QNmeaPositionInfoSource.updateMode() -> QNmeaPositionInfoSource.UpdateMode");

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

    {
        const QNmeaPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp))
        {
            QNmeaPositionInfoSource::UpdateMode sipRes;

            sipRes = sipCpp->updateMode();

            return sipConvertFromEnum(sipRes,sipType_QNmeaPositionInfoSource_UpdateMode);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_updateMode, doc_QNmeaPositionInfoSource_updateMode);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_setDevice, "QNmeaPositionInfoSource.setDevice(QIODevice)");

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

    {
        QIODevice* a0;
        QNmeaPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp, sipType_QIODevice, &a0))
        {
            sipCpp->setDevice(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_setDevice, doc_QNmeaPositionInfoSource_setDevice);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_device, "QNmeaPositionInfoSource.device() -> QIODevice");

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

    {
        const QNmeaPositionInfoSource *sipCpp;

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

            sipRes = sipCpp->device();

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_device, doc_QNmeaPositionInfoSource_device);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_setUpdateInterval, "QNmeaPositionInfoSource.setUpdateInterval(int)");

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

    {
        int a0;
        QNmeaPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp, &a0))
        {
            (sipSelfWasArg ? sipCpp->QNmeaPositionInfoSource::setUpdateInterval(a0) : sipCpp->setUpdateInterval(a0));

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_setUpdateInterval, doc_QNmeaPositionInfoSource_setUpdateInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_lastKnownPosition, "QNmeaPositionInfoSource.lastKnownPosition(bool fromSatellitePositioningMethodsOnly=False) -> QGeoPositionInfo");

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

    {
        bool a0 = 0;
        const QNmeaPositionInfoSource *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|b", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp, &a0))
        {
            QGeoPositionInfo*sipRes;

            sipRes = new QGeoPositionInfo((sipSelfWasArg ? sipCpp->QNmeaPositionInfoSource::lastKnownPosition(a0) : sipCpp->lastKnownPosition(a0)));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_lastKnownPosition, doc_QNmeaPositionInfoSource_lastKnownPosition);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_supportedPositioningMethods, "QNmeaPositionInfoSource.supportedPositioningMethods() -> QGeoPositionInfoSource.PositioningMethods");

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

    {
        const QNmeaPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp))
        {
            QGeoPositionInfoSource::PositioningMethods*sipRes;

            sipRes = new QGeoPositionInfoSource::PositioningMethods((sipSelfWasArg ? sipCpp->QNmeaPositionInfoSource::supportedPositioningMethods() : sipCpp->supportedPositioningMethods()));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_supportedPositioningMethods, doc_QNmeaPositionInfoSource_supportedPositioningMethods);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_minimumUpdateInterval, "QNmeaPositionInfoSource.minimumUpdateInterval() -> int");

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

    {
        const QNmeaPositionInfoSource *sipCpp;

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

            sipRes = (sipSelfWasArg ? sipCpp->QNmeaPositionInfoSource::minimumUpdateInterval() : sipCpp->minimumUpdateInterval());

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_minimumUpdateInterval, doc_QNmeaPositionInfoSource_minimumUpdateInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_error, "QNmeaPositionInfoSource.error() -> QGeoPositionInfoSource.Error");

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

    {
        const QNmeaPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp))
        {
            QGeoPositionInfoSource::Error sipRes;

            sipRes = (sipSelfWasArg ? sipCpp->QNmeaPositionInfoSource::error() : sipCpp->error());

            return sipConvertFromEnum(sipRes,sipType_QGeoPositionInfoSource_Error);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_error, doc_QNmeaPositionInfoSource_error);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_startUpdates, "QNmeaPositionInfoSource.startUpdates()");

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

    {
        QNmeaPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp))
        {
            (sipSelfWasArg ? sipCpp->QNmeaPositionInfoSource::startUpdates() : sipCpp->startUpdates());

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_startUpdates, doc_QNmeaPositionInfoSource_startUpdates);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_stopUpdates, "QNmeaPositionInfoSource.stopUpdates()");

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

    {
        QNmeaPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp))
        {
            (sipSelfWasArg ? sipCpp->QNmeaPositionInfoSource::stopUpdates() : sipCpp->stopUpdates());

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_stopUpdates, doc_QNmeaPositionInfoSource_stopUpdates);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_requestUpdate, "QNmeaPositionInfoSource.requestUpdate(int timeout=0)");

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

    {
        int a0 = 0;
        QNmeaPositionInfoSource *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|i", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp, &a0))
        {
            (sipSelfWasArg ? sipCpp->QNmeaPositionInfoSource::requestUpdate(a0) : sipCpp->requestUpdate(a0));

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_requestUpdate, doc_QNmeaPositionInfoSource_requestUpdate);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_parsePosInfoFromNmeaData, "QNmeaPositionInfoSource.parsePosInfoFromNmeaData(str, int, QGeoPositionInfo) -> (bool, bool)");

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

    {
        const char* a0;
        int a1;
        QGeoPositionInfo* a2;
        bool a3;
        sipQNmeaPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BsiJ8", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp, &a0, &a1, sipType_QGeoPositionInfo, &a2))
        {
            bool sipRes;

            sipRes = sipCpp->sipProtectVirt_parsePosInfoFromNmeaData(sipSelfWasArg,a0,a1,a2,&a3);

            return sipBuildResult(0,"(bb)",sipRes,a3);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_parsePosInfoFromNmeaData, doc_QNmeaPositionInfoSource_parsePosInfoFromNmeaData);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_setUserEquivalentRangeError, "QNmeaPositionInfoSource.setUserEquivalentRangeError(float)");

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

    {
        double a0;
        QNmeaPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bd", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp, &a0))
        {
            sipCpp->setUserEquivalentRangeError(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_setUserEquivalentRangeError, doc_QNmeaPositionInfoSource_setUserEquivalentRangeError);

    return NULL;
}


PyDoc_STRVAR(doc_QNmeaPositionInfoSource_userEquivalentRangeError, "QNmeaPositionInfoSource.userEquivalentRangeError() -> float");

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

    {
        const QNmeaPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QNmeaPositionInfoSource, &sipCpp))
        {
            double sipRes;

            sipRes = sipCpp->userEquivalentRangeError();

            return PyFloat_FromDouble(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QNmeaPositionInfoSource, sipName_userEquivalentRangeError, doc_QNmeaPositionInfoSource_userEquivalentRangeError);

    return NULL;
}


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

    if (targetType == sipType_QNmeaPositionInfoSource)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QGeoPositionInfoSource)->ctd_cast((QGeoPositionInfoSource *)(QNmeaPositionInfoSource *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QNmeaPositionInfoSource(void *, int);}
static void release_QNmeaPositionInfoSource(void *sipCppV,int)
{
    QNmeaPositionInfoSource *sipCpp = reinterpret_cast<QNmeaPositionInfoSource *>(sipCppV);

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();
}


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

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


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

    {
        QNmeaPositionInfoSource::UpdateMode a0;
        QObject* a1 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "E|JH", sipType_QNmeaPositionInfoSource_UpdateMode, &a0, sipType_QObject, &a1, sipOwner))
        {
            sipCpp = new sipQNmeaPositionInfoSource(a0,a1);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QNmeaPositionInfoSource[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QNmeaPositionInfoSource_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QNmeaPositionInfoSource_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QNmeaPositionInfoSource_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_device), meth_QNmeaPositionInfoSource_device, METH_VARARGS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_device)},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QNmeaPositionInfoSource_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_error), meth_QNmeaPositionInfoSource_error, METH_VARARGS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_error)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QNmeaPositionInfoSource_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_lastKnownPosition), (PyCFunction)meth_QNmeaPositionInfoSource_lastKnownPosition, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_lastKnownPosition)},
    {SIP_MLNAME_CAST(sipName_minimumUpdateInterval), meth_QNmeaPositionInfoSource_minimumUpdateInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_minimumUpdateInterval)},
    {SIP_MLNAME_CAST(sipName_parsePosInfoFromNmeaData), (PyCFunction)meth_QNmeaPositionInfoSource_parsePosInfoFromNmeaData, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_parsePosInfoFromNmeaData)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QNmeaPositionInfoSource_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_requestUpdate), (PyCFunction)meth_QNmeaPositionInfoSource_requestUpdate, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_requestUpdate)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QNmeaPositionInfoSource_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QNmeaPositionInfoSource_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setDevice), meth_QNmeaPositionInfoSource_setDevice, METH_VARARGS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_setDevice)},
    {SIP_MLNAME_CAST(sipName_setUpdateInterval), meth_QNmeaPositionInfoSource_setUpdateInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_setUpdateInterval)},
    {SIP_MLNAME_CAST(sipName_setUserEquivalentRangeError), meth_QNmeaPositionInfoSource_setUserEquivalentRangeError, METH_VARARGS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_setUserEquivalentRangeError)},
    {SIP_MLNAME_CAST(sipName_startUpdates), meth_QNmeaPositionInfoSource_startUpdates, METH_VARARGS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_startUpdates)},
    {SIP_MLNAME_CAST(sipName_stopUpdates), meth_QNmeaPositionInfoSource_stopUpdates, METH_VARARGS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_stopUpdates)},
    {SIP_MLNAME_CAST(sipName_supportedPositioningMethods), meth_QNmeaPositionInfoSource_supportedPositioningMethods, METH_VARARGS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_supportedPositioningMethods)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QNmeaPositionInfoSource_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_updateMode), meth_QNmeaPositionInfoSource_updateMode, METH_VARARGS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_updateMode)},
    {SIP_MLNAME_CAST(sipName_userEquivalentRangeError), meth_QNmeaPositionInfoSource_userEquivalentRangeError, METH_VARARGS, SIP_MLDOC_CAST(doc_QNmeaPositionInfoSource_userEquivalentRangeError)}
};

static sipEnumMemberDef enummembers_QNmeaPositionInfoSource[] = {
    {sipName_RealTimeMode, static_cast<int>(QNmeaPositionInfoSource::RealTimeMode), 29},
    {sipName_SimulationMode, static_cast<int>(QNmeaPositionInfoSource::SimulationMode), 29},
};

PyDoc_STRVAR(doc_QNmeaPositionInfoSource, "\1QNmeaPositionInfoSource(QNmeaPositionInfoSource.UpdateMode, QObject parent=None)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QNmeaPositionInfoSource = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QNmeaPositionInfoSource,
        {0}
    },
    {
        sipNameNr_QNmeaPositionInfoSource,
        {0, 0, 1},
        23, methods_QNmeaPositionInfoSource,
        2, enummembers_QNmeaPositionInfoSource,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QNmeaPositionInfoSource,
    -1,
    -1,
    supers_QNmeaPositionInfoSource,
    0,
    init_type_QNmeaPositionInfoSource,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QNmeaPositionInfoSource,
    0,
    0,
    0,
    release_QNmeaPositionInfoSource,
    cast_QNmeaPositionInfoSource,
    0,
    0,
    0,
    0,
    0,
    0
},
    &QNmeaPositionInfoSource::staticMetaObject,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeosatelliteinfosource.sip"
#include <qgeosatelliteinfosource.h>
#line 2907 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 2911 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2914 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeosatelliteinfo.sip"
#include <qgeosatelliteinfo.h>
#line 2917 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 2920 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 2923 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 2926 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2929 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 241 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2932 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 229 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2935 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 2938 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2941 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 32 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 2944 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 144 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2947 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 2950 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 2953 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 2956 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 2959 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 2962 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 2965 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


class sipQGeoSatelliteInfoSource : public QGeoSatelliteInfoSource
{
public:
    sipQGeoSatelliteInfoSource(QObject*);
    virtual ~sipQGeoSatelliteInfoSource();

    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 QMetaMethod&);
    void sipProtectVirt_disconnectNotify(bool,const QMetaMethod&);
    int sipProtect_senderSignalIndex() const;
    bool sipProtect_isSignalConnected(const QMetaMethod&) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const QMetaMethod&);
    void connectNotify(const QMetaMethod&);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);
    void requestUpdate(int);
    void stopUpdates();
    void startUpdates();
    QGeoSatelliteInfoSource::Error error() const;
    int minimumUpdateInterval() const;
    void setUpdateInterval(int);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[13];
};

sipQGeoSatelliteInfoSource::sipQGeoSatelliteInfoSource(QObject*a0): QGeoSatelliteInfoSource(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

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

const QMetaObject *sipQGeoSatelliteInfoSource::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtPositioning_qt_metaobject(sipPySelf,sipType_QGeoSatelliteInfoSource);
}

int sipQGeoSatelliteInfoSource::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = QGeoSatelliteInfoSource::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtPositioning_qt_metacall(sipPySelf,sipType_QGeoSatelliteInfoSource,_c,_id,_a);

    return _id;
}

void *sipQGeoSatelliteInfoSource::qt_metacast(const char *_clname)
{
    void *sipCpp;

    return (sip_QtPositioning_qt_metacast(sipPySelf, sipType_QGeoSatelliteInfoSource, _clname, &sipCpp) ? sipCpp : QGeoSatelliteInfoSource::qt_metacast(_clname));
}

void sipQGeoSatelliteInfoSource::disconnectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoSatelliteInfoSource::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoSatelliteInfoSource::connectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoSatelliteInfoSource::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoSatelliteInfoSource::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoSatelliteInfoSource::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[25]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoSatelliteInfoSource::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoSatelliteInfoSource::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_47)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_47)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[47]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoSatelliteInfoSource::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoSatelliteInfoSource::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[9]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipQGeoSatelliteInfoSource::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return QGeoSatelliteInfoSource::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_26)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_26)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[26]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1);
}

bool sipQGeoSatelliteInfoSource::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return QGeoSatelliteInfoSource::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[5]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoSatelliteInfoSource::requestUpdate(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,sipName_QGeoSatelliteInfoSource,sipName_requestUpdate);

    if (!sipMeth)
        return;

    typedef void (*sipVH_QtCore_4)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    ((sipVH_QtCore_4)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[4]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoSatelliteInfoSource::stopUpdates()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[8],sipPySelf,sipName_QGeoSatelliteInfoSource,sipName_stopUpdates);

    if (!sipMeth)
        return;

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

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

void sipQGeoSatelliteInfoSource::startUpdates()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[9],sipPySelf,sipName_QGeoSatelliteInfoSource,sipName_startUpdates);

    if (!sipMeth)
        return;

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

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

QGeoSatelliteInfoSource::Error sipQGeoSatelliteInfoSource::error() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[10]),sipPySelf,sipName_QGeoSatelliteInfoSource,sipName_error);

    if (!sipMeth)
        return (QGeoSatelliteInfoSource::Error)0;

    extern QGeoSatelliteInfoSource::Error sipVH_QtPositioning_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtPositioning_4(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

int sipQGeoSatelliteInfoSource::minimumUpdateInterval() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[11]),sipPySelf,sipName_QGeoSatelliteInfoSource,sipName_minimumUpdateInterval);

    if (!sipMeth)
        return 0;

    typedef int (*sipVH_QtCore_6)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_6)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[6]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

void sipQGeoSatelliteInfoSource::setUpdateInterval(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[12],sipPySelf,NULL,sipName_setUpdateInterval);

    if (!sipMeth)
    {
        QGeoSatelliteInfoSource::setUpdateInterval(a0);
        return;
    }

    typedef void (*sipVH_QtCore_4)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    ((sipVH_QtCore_4)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[4]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QObject* sipQGeoSatelliteInfoSource::sipProtect_sender() const
{
    return QObject::sender();
}

int sipQGeoSatelliteInfoSource::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipQGeoSatelliteInfoSource::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQGeoSatelliteInfoSource::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipQGeoSatelliteInfoSource::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipQGeoSatelliteInfoSource::sipProtectVirt_connectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQGeoSatelliteInfoSource::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQGeoSatelliteInfoSource::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

bool sipQGeoSatelliteInfoSource::sipProtect_isSignalConnected(const QMetaMethod& a0) const
{
    return QObject::isSignalConnected(a0);
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_sender, "QGeoSatelliteInfoSource.sender() -> QObject");

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

    {
        const sipQGeoSatelliteInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp))
        {
            QObject*sipRes = 0;

#line 546 "sip/QtCore/qobject.sip"
        // 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 (!sipRes)
        {
            typedef QObject *(*qtcore_qobject_sender_t)();
        
            static qtcore_qobject_sender_t qtcore_qobject_sender = 0;
        
            if (!qtcore_qobject_sender)
                qtcore_qobject_sender = (qtcore_qobject_sender_t)sipImportSymbol("qtcore_qobject_sender");
        
            if (qtcore_qobject_sender)
                sipRes = qtcore_qobject_sender();
        }
#line 3352 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_sender, doc_QGeoSatelliteInfoSource_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_receivers, "QGeoSatelliteInfoSource.receivers(signal) -> int");

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

    {
        PyObject * a0;
        const sipQGeoSatelliteInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 575 "sip/QtCore/qobject.sip"
        // We need to handle the signal object.  Import the helper if it hasn't already
        // been done.
        typedef sipErrorState (*pyqt5_get_signal_signature_t)(PyObject *, const QObject *, const QByteArray &);
        
        static pyqt5_get_signal_signature_t pyqt5_get_signal_signature = 0;
        
        if (!pyqt5_get_signal_signature)
            pyqt5_get_signal_signature = (pyqt5_get_signal_signature_t)sipImportSymbol("pyqt5_get_signal_signature");
        
        if (pyqt5_get_signal_signature)
        {
            QByteArray signal_signature;
            
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            if ((sipError = pyqt5_get_signal_signature(a0, sipCpp, signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->receivers(signal_signature.constData());
            }
        #else
            if ((sipError = pyqt5_get_signal_signature(a0, static_cast<const QObject *>(sipCpp), signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->sipProtect_receivers(signal_signature.constData());
            }
        #endif
            else if (sipError == sipErrorContinue)
            {
                sipError = sipBadCallableArg(0, a0);
            }
        }
#line 3411 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_receivers, doc_QGeoSatelliteInfoSource_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_timerEvent, "QGeoSatelliteInfoSource.timerEvent(QTimerEvent)");

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

    {
        QTimerEvent* a0;
        sipQGeoSatelliteInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp, sipType_QTimerEvent, &a0))
        {
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_timerEvent, doc_QGeoSatelliteInfoSource_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_childEvent, "QGeoSatelliteInfoSource.childEvent(QChildEvent)");

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

    {
        QChildEvent* a0;
        sipQGeoSatelliteInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp, sipType_QChildEvent, &a0))
        {
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_childEvent, doc_QGeoSatelliteInfoSource_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_customEvent, "QGeoSatelliteInfoSource.customEvent(QEvent)");

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

    {
        QEvent* a0;
        sipQGeoSatelliteInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp, sipType_QEvent, &a0))
        {
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_customEvent, doc_QGeoSatelliteInfoSource_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_connectNotify, "QGeoSatelliteInfoSource.connectNotify(QMetaMethod)");

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

    {
        const QMetaMethod* a0;
        sipQGeoSatelliteInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_connectNotify, doc_QGeoSatelliteInfoSource_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_disconnectNotify, "QGeoSatelliteInfoSource.disconnectNotify(QMetaMethod)");

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

    {
        const QMetaMethod* a0;
        sipQGeoSatelliteInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_disconnectNotify, doc_QGeoSatelliteInfoSource_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_senderSignalIndex, "QGeoSatelliteInfoSource.senderSignalIndex() -> int");

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

    {
        const sipQGeoSatelliteInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_senderSignalIndex, doc_QGeoSatelliteInfoSource_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_isSignalConnected, "QGeoSatelliteInfoSource.isSignalConnected(QMetaMethod) -> bool");

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

    {
        const QMetaMethod* a0;
        const sipQGeoSatelliteInfoSource *sipCpp;

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

            sipRes = sipCpp->sipProtect_isSignalConnected(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_isSignalConnected, doc_QGeoSatelliteInfoSource_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_createDefaultSource, "QGeoSatelliteInfoSource.createDefaultSource(QObject) -> QGeoSatelliteInfoSource");

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

    {
        QObject* a0;
        sipWrapper *sipOwner = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "JH", sipType_QObject, &a0, &sipOwner))
        {
            QGeoSatelliteInfoSource*sipRes;

            sipRes = QGeoSatelliteInfoSource::createDefaultSource(a0);

            return sipConvertFromNewType(sipRes,sipType_QGeoSatelliteInfoSource,(PyObject *)sipOwner);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_createDefaultSource, doc_QGeoSatelliteInfoSource_createDefaultSource);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_createSource, "QGeoSatelliteInfoSource.createSource(str, QObject) -> QGeoSatelliteInfoSource");

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

    {
        const QString* a0;
        int a0State = 0;
        QObject* a1;
        sipWrapper *sipOwner = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J1JH", sipType_QString,&a0, &a0State, sipType_QObject, &a1, &sipOwner))
        {
            QGeoSatelliteInfoSource*sipRes;

            sipRes = QGeoSatelliteInfoSource::createSource(*a0,a1);
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGeoSatelliteInfoSource,(PyObject *)sipOwner);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_createSource, doc_QGeoSatelliteInfoSource_createSource);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_availableSources, "QGeoSatelliteInfoSource.availableSources() -> list-of-str");

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

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            QStringList*sipRes;

            sipRes = new QStringList(QGeoSatelliteInfoSource::availableSources());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_availableSources, doc_QGeoSatelliteInfoSource_availableSources);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_sourceName, "QGeoSatelliteInfoSource.sourceName() -> str");

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

    {
        const QGeoSatelliteInfoSource *sipCpp;

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

            sipRes = new QString(sipCpp->sourceName());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_sourceName, doc_QGeoSatelliteInfoSource_sourceName);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_setUpdateInterval, "QGeoSatelliteInfoSource.setUpdateInterval(int)");

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

    {
        int a0;
        QGeoSatelliteInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp, &a0))
        {
            (sipSelfWasArg ? sipCpp->QGeoSatelliteInfoSource::setUpdateInterval(a0) : sipCpp->setUpdateInterval(a0));

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_setUpdateInterval, doc_QGeoSatelliteInfoSource_setUpdateInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_updateInterval, "QGeoSatelliteInfoSource.updateInterval() -> int");

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

    {
        const QGeoSatelliteInfoSource *sipCpp;

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

            sipRes = sipCpp->updateInterval();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_updateInterval, doc_QGeoSatelliteInfoSource_updateInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_minimumUpdateInterval, "QGeoSatelliteInfoSource.minimumUpdateInterval() -> int");

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

    {
        const QGeoSatelliteInfoSource *sipCpp;

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

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoSatelliteInfoSource, sipName_minimumUpdateInterval);
                return NULL;
            }

            sipRes = sipCpp->minimumUpdateInterval();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_minimumUpdateInterval, doc_QGeoSatelliteInfoSource_minimumUpdateInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_error, "QGeoSatelliteInfoSource.error() -> QGeoSatelliteInfoSource.Error");

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

    {
        const QGeoSatelliteInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp))
        {
            QGeoSatelliteInfoSource::Error sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoSatelliteInfoSource, sipName_error);
                return NULL;
            }

            sipRes = sipCpp->error();

            return sipConvertFromEnum(sipRes,sipType_QGeoSatelliteInfoSource_Error);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_error, doc_QGeoSatelliteInfoSource_error);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_startUpdates, "QGeoSatelliteInfoSource.startUpdates()");

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

    {
        QGeoSatelliteInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoSatelliteInfoSource, sipName_startUpdates);
                return NULL;
            }

            sipCpp->startUpdates();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_startUpdates, doc_QGeoSatelliteInfoSource_startUpdates);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_stopUpdates, "QGeoSatelliteInfoSource.stopUpdates()");

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

    {
        QGeoSatelliteInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoSatelliteInfoSource, sipName_stopUpdates);
                return NULL;
            }

            sipCpp->stopUpdates();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_stopUpdates, doc_QGeoSatelliteInfoSource_stopUpdates);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfoSource_requestUpdate, "QGeoSatelliteInfoSource.requestUpdate(int timeout=0)");

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

    {
        int a0 = 0;
        QGeoSatelliteInfoSource *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|i", &sipSelf, sipType_QGeoSatelliteInfoSource, &sipCpp, &a0))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoSatelliteInfoSource, sipName_requestUpdate);
                return NULL;
            }

            sipCpp->requestUpdate(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfoSource, sipName_requestUpdate, doc_QGeoSatelliteInfoSource_requestUpdate);

    return NULL;
}


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

    if (targetType == sipType_QGeoSatelliteInfoSource)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(QGeoSatelliteInfoSource *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoSatelliteInfoSource(void *, int);}
static void release_QGeoSatelliteInfoSource(void *sipCppV,int)
{
    QGeoSatelliteInfoSource *sipCpp = reinterpret_cast<QGeoSatelliteInfoSource *>(sipCppV);

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();
}


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

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


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

    {
        QObject* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "JH", sipType_QObject, &a0, sipOwner))
        {
            sipCpp = new sipQGeoSatelliteInfoSource(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QGeoSatelliteInfoSource[] = {{162, 0, 1}};


static PyMethodDef methods_QGeoSatelliteInfoSource[] = {
    {SIP_MLNAME_CAST(sipName_availableSources), meth_QGeoSatelliteInfoSource_availableSources, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfoSource_availableSources)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QGeoSatelliteInfoSource_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QGeoSatelliteInfoSource_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_createDefaultSource), meth_QGeoSatelliteInfoSource_createDefaultSource, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfoSource_createDefaultSource)},
    {SIP_MLNAME_CAST(sipName_createSource), meth_QGeoSatelliteInfoSource_createSource, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfoSource_createSource)},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QGeoSatelliteInfoSource_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QGeoSatelliteInfoSource_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_error), meth_QGeoSatelliteInfoSource_error, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfoSource_error)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QGeoSatelliteInfoSource_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_minimumUpdateInterval), meth_QGeoSatelliteInfoSource_minimumUpdateInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfoSource_minimumUpdateInterval)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QGeoSatelliteInfoSource_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_requestUpdate), (PyCFunction)meth_QGeoSatelliteInfoSource_requestUpdate, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfoSource_requestUpdate)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QGeoSatelliteInfoSource_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QGeoSatelliteInfoSource_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setUpdateInterval), meth_QGeoSatelliteInfoSource_setUpdateInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfoSource_setUpdateInterval)},
    {SIP_MLNAME_CAST(sipName_sourceName), meth_QGeoSatelliteInfoSource_sourceName, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfoSource_sourceName)},
    {SIP_MLNAME_CAST(sipName_startUpdates), meth_QGeoSatelliteInfoSource_startUpdates, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfoSource_startUpdates)},
    {SIP_MLNAME_CAST(sipName_stopUpdates), meth_QGeoSatelliteInfoSource_stopUpdates, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfoSource_stopUpdates)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QGeoSatelliteInfoSource_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_updateInterval), meth_QGeoSatelliteInfoSource_updateInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfoSource_updateInterval)}
};

static sipEnumMemberDef enummembers_QGeoSatelliteInfoSource[] = {
    {sipName_AccessError, static_cast<int>(QGeoSatelliteInfoSource::AccessError), 22},
    {sipName_ClosedError, static_cast<int>(QGeoSatelliteInfoSource::ClosedError), 22},
    {sipName_NoError, static_cast<int>(QGeoSatelliteInfoSource::NoError), 22},
    {sipName_UnknownSourceError, static_cast<int>(QGeoSatelliteInfoSource::UnknownSourceError), 22},
};


/* Define this type's signals. */
static const pyqt5QtSignal signals_QGeoSatelliteInfoSource[] = {
    {"requestTimeout()", "\1QGeoSatelliteInfoSource.requestTimeout", 0, 0},
    {"satellitesInUseUpdated(QList<QGeoSatelliteInfo>)", "\1QGeoSatelliteInfoSource.satellitesInUseUpdated[list-of-QGeoSatelliteInfo]", 0, 0},
    {"satellitesInViewUpdated(QList<QGeoSatelliteInfo>)", "\1QGeoSatelliteInfoSource.satellitesInViewUpdated[list-of-QGeoSatelliteInfo]", 0, 0},
    {"error(QGeoSatelliteInfoSource::Error)", "\1QGeoSatelliteInfoSource.error[QGeoSatelliteInfoSource.Error]", &methods_QGeoSatelliteInfoSource[7], 0},
    {0, 0, 0, 0}
};

PyDoc_STRVAR(doc_QGeoSatelliteInfoSource, "\1QGeoSatelliteInfoSource(QObject)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoSatelliteInfoSource = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoSatelliteInfoSource,
        {0}
    },
    {
        sipNameNr_QGeoSatelliteInfoSource,
        {0, 0, 1},
        20, methods_QGeoSatelliteInfoSource,
        4, enummembers_QGeoSatelliteInfoSource,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoSatelliteInfoSource,
    -1,
    -1,
    supers_QGeoSatelliteInfoSource,
    0,
    init_type_QGeoSatelliteInfoSource,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoSatelliteInfoSource,
    0,
    0,
    0,
    release_QGeoSatelliteInfoSource,
    cast_QGeoSatelliteInfoSource,
    0,
    0,
    0,
    0,
    0,
    0
},
    &QGeoSatelliteInfoSource::staticMetaObject,
    0,
    signals_QGeoSatelliteInfoSource,
    0
};

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeosatelliteinfo.sip"
#include <qgeosatelliteinfo.h>
#line 4133 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"



PyDoc_STRVAR(doc_QGeoSatelliteInfo_setSatelliteSystem, "QGeoSatelliteInfo.setSatelliteSystem(QGeoSatelliteInfo.SatelliteSystem)");

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

    {
        QGeoSatelliteInfo::SatelliteSystem a0;
        QGeoSatelliteInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QGeoSatelliteInfo, &sipCpp, sipType_QGeoSatelliteInfo_SatelliteSystem, &a0))
        {
            sipCpp->setSatelliteSystem(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfo, sipName_setSatelliteSystem, doc_QGeoSatelliteInfo_setSatelliteSystem);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfo_satelliteSystem, "QGeoSatelliteInfo.satelliteSystem() -> QGeoSatelliteInfo.SatelliteSystem");

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

    {
        const QGeoSatelliteInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoSatelliteInfo, &sipCpp))
        {
            QGeoSatelliteInfo::SatelliteSystem sipRes;

            sipRes = sipCpp->satelliteSystem();

            return sipConvertFromEnum(sipRes,sipType_QGeoSatelliteInfo_SatelliteSystem);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfo, sipName_satelliteSystem, doc_QGeoSatelliteInfo_satelliteSystem);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfo_setSatelliteIdentifier, "QGeoSatelliteInfo.setSatelliteIdentifier(int)");

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

    {
        int a0;
        QGeoSatelliteInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGeoSatelliteInfo, &sipCpp, &a0))
        {
            sipCpp->setSatelliteIdentifier(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfo, sipName_setSatelliteIdentifier, doc_QGeoSatelliteInfo_setSatelliteIdentifier);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfo_satelliteIdentifier, "QGeoSatelliteInfo.satelliteIdentifier() -> int");

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

    {
        const QGeoSatelliteInfo *sipCpp;

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

            sipRes = sipCpp->satelliteIdentifier();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfo, sipName_satelliteIdentifier, doc_QGeoSatelliteInfo_satelliteIdentifier);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfo_setSignalStrength, "QGeoSatelliteInfo.setSignalStrength(int)");

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

    {
        int a0;
        QGeoSatelliteInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGeoSatelliteInfo, &sipCpp, &a0))
        {
            sipCpp->setSignalStrength(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfo, sipName_setSignalStrength, doc_QGeoSatelliteInfo_setSignalStrength);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfo_signalStrength, "QGeoSatelliteInfo.signalStrength() -> int");

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

    {
        const QGeoSatelliteInfo *sipCpp;

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

            sipRes = sipCpp->signalStrength();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfo, sipName_signalStrength, doc_QGeoSatelliteInfo_signalStrength);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfo_setAttribute, "QGeoSatelliteInfo.setAttribute(QGeoSatelliteInfo.Attribute, float)");

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

    {
        QGeoSatelliteInfo::Attribute a0;
        qreal a1;
        QGeoSatelliteInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEd", &sipSelf, sipType_QGeoSatelliteInfo, &sipCpp, sipType_QGeoSatelliteInfo_Attribute, &a0, &a1))
        {
            sipCpp->setAttribute(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfo, sipName_setAttribute, doc_QGeoSatelliteInfo_setAttribute);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfo_attribute, "QGeoSatelliteInfo.attribute(QGeoSatelliteInfo.Attribute) -> float");

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

    {
        QGeoSatelliteInfo::Attribute a0;
        const QGeoSatelliteInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QGeoSatelliteInfo, &sipCpp, sipType_QGeoSatelliteInfo_Attribute, &a0))
        {
            qreal sipRes;

            sipRes = sipCpp->attribute(a0);

            return PyFloat_FromDouble(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfo_removeAttribute, "QGeoSatelliteInfo.removeAttribute(QGeoSatelliteInfo.Attribute)");

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

    {
        QGeoSatelliteInfo::Attribute a0;
        QGeoSatelliteInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QGeoSatelliteInfo, &sipCpp, sipType_QGeoSatelliteInfo_Attribute, &a0))
        {
            sipCpp->removeAttribute(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfo, sipName_removeAttribute, doc_QGeoSatelliteInfo_removeAttribute);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoSatelliteInfo_hasAttribute, "QGeoSatelliteInfo.hasAttribute(QGeoSatelliteInfo.Attribute) -> bool");

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

    {
        QGeoSatelliteInfo::Attribute a0;
        const QGeoSatelliteInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QGeoSatelliteInfo, &sipCpp, sipType_QGeoSatelliteInfo_Attribute, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->hasAttribute(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoSatelliteInfo, sipName_hasAttribute, doc_QGeoSatelliteInfo_hasAttribute);

    return NULL;
}


extern "C" {static PyObject *slot_QGeoSatelliteInfo___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGeoSatelliteInfo___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoSatelliteInfo *sipCpp = reinterpret_cast<QGeoSatelliteInfo *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoSatelliteInfo));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoSatelliteInfo* a0;

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

            sipRes = sipCpp->QGeoSatelliteInfo::operator!=(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,ne_slot,sipType_QGeoSatelliteInfo,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoSatelliteInfo___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGeoSatelliteInfo___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoSatelliteInfo *sipCpp = reinterpret_cast<QGeoSatelliteInfo *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoSatelliteInfo));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoSatelliteInfo* a0;

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

            sipRes = sipCpp->QGeoSatelliteInfo::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,eq_slot,sipType_QGeoSatelliteInfo,sipSelf,sipArg);
}


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

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoSatelliteInfo(void *, int);}
static void release_QGeoSatelliteInfo(void *sipCppV,int)
{
    delete reinterpret_cast<QGeoSatelliteInfo *>(sipCppV);
}


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


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


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


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


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

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

            return sipCpp;
        }
    }

    {
        const QGeoSatelliteInfo* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGeoSatelliteInfo, &a0))
        {
            sipCpp = new QGeoSatelliteInfo(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGeoSatelliteInfo[] = {
    {(void *)slot_QGeoSatelliteInfo___ne__, ne_slot},
    {(void *)slot_QGeoSatelliteInfo___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QGeoSatelliteInfo[] = {
    {SIP_MLNAME_CAST(sipName_attribute), meth_QGeoSatelliteInfo_attribute, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfo_attribute)},
    {SIP_MLNAME_CAST(sipName_hasAttribute), meth_QGeoSatelliteInfo_hasAttribute, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfo_hasAttribute)},
    {SIP_MLNAME_CAST(sipName_removeAttribute), meth_QGeoSatelliteInfo_removeAttribute, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfo_removeAttribute)},
    {SIP_MLNAME_CAST(sipName_satelliteIdentifier), meth_QGeoSatelliteInfo_satelliteIdentifier, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfo_satelliteIdentifier)},
    {SIP_MLNAME_CAST(sipName_satelliteSystem), meth_QGeoSatelliteInfo_satelliteSystem, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfo_satelliteSystem)},
    {SIP_MLNAME_CAST(sipName_setAttribute), meth_QGeoSatelliteInfo_setAttribute, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfo_setAttribute)},
    {SIP_MLNAME_CAST(sipName_setSatelliteIdentifier), meth_QGeoSatelliteInfo_setSatelliteIdentifier, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfo_setSatelliteIdentifier)},
    {SIP_MLNAME_CAST(sipName_setSatelliteSystem), meth_QGeoSatelliteInfo_setSatelliteSystem, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfo_setSatelliteSystem)},
    {SIP_MLNAME_CAST(sipName_setSignalStrength), meth_QGeoSatelliteInfo_setSignalStrength, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfo_setSignalStrength)},
    {SIP_MLNAME_CAST(sipName_signalStrength), meth_QGeoSatelliteInfo_signalStrength, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoSatelliteInfo_signalStrength)}
};

static sipEnumMemberDef enummembers_QGeoSatelliteInfo[] = {
    {sipName_Azimuth, static_cast<int>(QGeoSatelliteInfo::Azimuth), 19},
    {sipName_Elevation, static_cast<int>(QGeoSatelliteInfo::Elevation), 19},
    {sipName_GLONASS, static_cast<int>(QGeoSatelliteInfo::GLONASS), 20},
    {sipName_GPS, static_cast<int>(QGeoSatelliteInfo::GPS), 20},
    {sipName_Undefined, static_cast<int>(QGeoSatelliteInfo::Undefined), 20},
};

PyDoc_STRVAR(doc_QGeoSatelliteInfo, "\1QGeoSatelliteInfo()\n"
    "QGeoSatelliteInfo(QGeoSatelliteInfo)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoSatelliteInfo = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoSatelliteInfo,
        {0}
    },
    {
        sipNameNr_QGeoSatelliteInfo,
        {0, 0, 1},
        10, methods_QGeoSatelliteInfo,
        5, enummembers_QGeoSatelliteInfo,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoSatelliteInfo,
    sipNameNr_PyQt5_QtCore_pyqtWrapperType,
    -1,
    0,
    slots_QGeoSatelliteInfo,
    init_type_QGeoSatelliteInfo,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoSatelliteInfo,
    assign_QGeoSatelliteInfo,
    array_QGeoSatelliteInfo,
    copy_QGeoSatelliteInfo,
    release_QGeoSatelliteInfo,
    cast_QGeoSatelliteInfo,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeorectangle.sip"
#include <qgeorectangle.h>
#line 4643 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeocoordinate.sip"
#include <qgeocoordinate.h>
#line 4647 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 4650 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoshape.sip"
#include <qgeoshape.h>
#line 4653 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


PyDoc_STRVAR(doc_QGeoRectangle_setTopLeft, "QGeoRectangle.setTopLeft(QGeoCoordinate)");

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

    {
        const QGeoCoordinate* a0;
        QGeoRectangle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoRectangle, &sipCpp, sipType_QGeoCoordinate, &a0))
        {
            sipCpp->setTopLeft(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_setTopLeft, doc_QGeoRectangle_setTopLeft);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_topLeft, "QGeoRectangle.topLeft() -> QGeoCoordinate");

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

    {
        const QGeoRectangle *sipCpp;

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

            sipRes = new QGeoCoordinate(sipCpp->topLeft());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_topLeft, doc_QGeoRectangle_topLeft);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_setTopRight, "QGeoRectangle.setTopRight(QGeoCoordinate)");

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

    {
        const QGeoCoordinate* a0;
        QGeoRectangle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoRectangle, &sipCpp, sipType_QGeoCoordinate, &a0))
        {
            sipCpp->setTopRight(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_setTopRight, doc_QGeoRectangle_setTopRight);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_topRight, "QGeoRectangle.topRight() -> QGeoCoordinate");

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

    {
        const QGeoRectangle *sipCpp;

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

            sipRes = new QGeoCoordinate(sipCpp->topRight());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_topRight, doc_QGeoRectangle_topRight);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_setBottomLeft, "QGeoRectangle.setBottomLeft(QGeoCoordinate)");

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

    {
        const QGeoCoordinate* a0;
        QGeoRectangle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoRectangle, &sipCpp, sipType_QGeoCoordinate, &a0))
        {
            sipCpp->setBottomLeft(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_setBottomLeft, doc_QGeoRectangle_setBottomLeft);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_bottomLeft, "QGeoRectangle.bottomLeft() -> QGeoCoordinate");

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

    {
        const QGeoRectangle *sipCpp;

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

            sipRes = new QGeoCoordinate(sipCpp->bottomLeft());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_bottomLeft, doc_QGeoRectangle_bottomLeft);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_setBottomRight, "QGeoRectangle.setBottomRight(QGeoCoordinate)");

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

    {
        const QGeoCoordinate* a0;
        QGeoRectangle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoRectangle, &sipCpp, sipType_QGeoCoordinate, &a0))
        {
            sipCpp->setBottomRight(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_setBottomRight, doc_QGeoRectangle_setBottomRight);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_bottomRight, "QGeoRectangle.bottomRight() -> QGeoCoordinate");

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

    {
        const QGeoRectangle *sipCpp;

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

            sipRes = new QGeoCoordinate(sipCpp->bottomRight());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_bottomRight, doc_QGeoRectangle_bottomRight);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_setCenter, "QGeoRectangle.setCenter(QGeoCoordinate)");

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

    {
        const QGeoCoordinate* a0;
        QGeoRectangle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoRectangle, &sipCpp, sipType_QGeoCoordinate, &a0))
        {
            sipCpp->setCenter(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_setCenter, doc_QGeoRectangle_setCenter);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_center, "QGeoRectangle.center() -> QGeoCoordinate");

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

    {
        const QGeoRectangle *sipCpp;

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

            sipRes = new QGeoCoordinate(sipCpp->center());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_center, doc_QGeoRectangle_center);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_setWidth, "QGeoRectangle.setWidth(float)");

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

    {
        double a0;
        QGeoRectangle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bd", &sipSelf, sipType_QGeoRectangle, &sipCpp, &a0))
        {
            sipCpp->setWidth(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_setWidth, doc_QGeoRectangle_setWidth);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_width, "QGeoRectangle.width() -> float");

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

    {
        const QGeoRectangle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoRectangle, &sipCpp))
        {
            double sipRes;

            sipRes = sipCpp->width();

            return PyFloat_FromDouble(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_width, doc_QGeoRectangle_width);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_setHeight, "QGeoRectangle.setHeight(float)");

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

    {
        double a0;
        QGeoRectangle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bd", &sipSelf, sipType_QGeoRectangle, &sipCpp, &a0))
        {
            sipCpp->setHeight(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_setHeight, doc_QGeoRectangle_setHeight);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_height, "QGeoRectangle.height() -> float");

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

    {
        const QGeoRectangle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoRectangle, &sipCpp))
        {
            double sipRes;

            sipRes = sipCpp->height();

            return PyFloat_FromDouble(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_height, doc_QGeoRectangle_height);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_contains, "QGeoRectangle.contains(QGeoRectangle) -> bool");

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

    {
        const QGeoRectangle* a0;
        const QGeoRectangle *sipCpp;

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

            sipRes = sipCpp->contains(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_contains, doc_QGeoRectangle_contains);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_intersects, "QGeoRectangle.intersects(QGeoRectangle) -> bool");

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

    {
        const QGeoRectangle* a0;
        const QGeoRectangle *sipCpp;

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

            sipRes = sipCpp->intersects(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_intersects, doc_QGeoRectangle_intersects);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_translate, "QGeoRectangle.translate(float, float)");

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

    {
        double a0;
        double a1;
        QGeoRectangle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bdd", &sipSelf, sipType_QGeoRectangle, &sipCpp, &a0, &a1))
        {
            sipCpp->translate(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_translate, doc_QGeoRectangle_translate);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_translated, "QGeoRectangle.translated(float, float) -> QGeoRectangle");

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

    {
        double a0;
        double a1;
        const QGeoRectangle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bdd", &sipSelf, sipType_QGeoRectangle, &sipCpp, &a0, &a1))
        {
            QGeoRectangle*sipRes;

            sipRes = new QGeoRectangle(sipCpp->translated(a0,a1));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_translated, doc_QGeoRectangle_translated);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoRectangle_united, "QGeoRectangle.united(QGeoRectangle) -> QGeoRectangle");

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

    {
        const QGeoRectangle* a0;
        const QGeoRectangle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoRectangle, &sipCpp, sipType_QGeoRectangle, &a0))
        {
            QGeoRectangle*sipRes;

            sipRes = new QGeoRectangle(sipCpp->united(*a0));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoRectangle, sipName_united, doc_QGeoRectangle_united);

    return NULL;
}


extern "C" {static PyObject *slot_QGeoRectangle___or__(PyObject *,PyObject *);}
static PyObject *slot_QGeoRectangle___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QGeoRectangle* a0;
        const QGeoRectangle* a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J9J9", sipType_QGeoRectangle, &a0, sipType_QGeoRectangle, &a1))
        {
            QGeoRectangle*sipRes;

            sipRes = new QGeoRectangle((*a0 | *a1));

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,or_slot,NULL,sipArg0,sipArg1);
}


extern "C" {static PyObject *slot_QGeoRectangle___ior__(PyObject *,PyObject *);}
static PyObject *slot_QGeoRectangle___ior__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGeoRectangle)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    QGeoRectangle *sipCpp = reinterpret_cast<QGeoRectangle *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoRectangle));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoRectangle* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QGeoRectangle, &a0))
        {
            sipCpp->QGeoRectangle::operator|=(*a0);

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGeoRectangle___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGeoRectangle___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoRectangle *sipCpp = reinterpret_cast<QGeoRectangle *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoRectangle));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoRectangle* a0;

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

            sipRes = sipCpp->QGeoRectangle::operator!=(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,ne_slot,sipType_QGeoRectangle,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoRectangle___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGeoRectangle___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoRectangle *sipCpp = reinterpret_cast<QGeoRectangle *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoRectangle));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoRectangle* a0;

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

            sipRes = sipCpp->QGeoRectangle::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,eq_slot,sipType_QGeoRectangle,sipSelf,sipArg);
}


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

    if (targetType == sipType_QGeoRectangle)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QGeoShape)->ctd_cast((QGeoShape *)(QGeoRectangle *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoRectangle(void *, int);}
static void release_QGeoRectangle(void *sipCppV,int)
{
    delete reinterpret_cast<QGeoRectangle *>(sipCppV);
}


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


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


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


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


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

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

            return sipCpp;
        }
    }

    {
        const QGeoCoordinate* a0;
        double a1;
        double a2;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9dd", sipType_QGeoCoordinate, &a0, &a1, &a2))
        {
            sipCpp = new QGeoRectangle(*a0,a1,a2);

            return sipCpp;
        }
    }

    {
        const QGeoCoordinate* a0;
        const QGeoCoordinate* a1;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9J9", sipType_QGeoCoordinate, &a0, sipType_QGeoCoordinate, &a1))
        {
            sipCpp = new QGeoRectangle(*a0,*a1);

            return sipCpp;
        }
    }

    {
        const QList<QGeoCoordinate>* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QList_0100QGeoCoordinate,&a0, &a0State))
        {
            sipCpp = new QGeoRectangle(*a0);
            sipReleaseType(const_cast<QList<QGeoCoordinate> *>(a0),sipType_QList_0100QGeoCoordinate,a0State);

            return sipCpp;
        }
    }

    {
        const QGeoRectangle* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGeoRectangle, &a0))
        {
            sipCpp = new QGeoRectangle(*a0);

            return sipCpp;
        }
    }

    {
        const QGeoShape* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGeoShape, &a0))
        {
            sipCpp = new QGeoRectangle(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


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


/* Define this type's Python slots. */
static sipPySlotDef slots_QGeoRectangle[] = {
    {(void *)slot_QGeoRectangle___or__, or_slot},
    {(void *)slot_QGeoRectangle___ior__, ior_slot},
    {(void *)slot_QGeoRectangle___ne__, ne_slot},
    {(void *)slot_QGeoRectangle___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QGeoRectangle[] = {
    {SIP_MLNAME_CAST(sipName_bottomLeft), meth_QGeoRectangle_bottomLeft, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_bottomLeft)},
    {SIP_MLNAME_CAST(sipName_bottomRight), meth_QGeoRectangle_bottomRight, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_bottomRight)},
    {SIP_MLNAME_CAST(sipName_center), meth_QGeoRectangle_center, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_center)},
    {SIP_MLNAME_CAST(sipName_contains), meth_QGeoRectangle_contains, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_contains)},
    {SIP_MLNAME_CAST(sipName_height), meth_QGeoRectangle_height, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_height)},
    {SIP_MLNAME_CAST(sipName_intersects), meth_QGeoRectangle_intersects, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_intersects)},
    {SIP_MLNAME_CAST(sipName_setBottomLeft), meth_QGeoRectangle_setBottomLeft, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_setBottomLeft)},
    {SIP_MLNAME_CAST(sipName_setBottomRight), meth_QGeoRectangle_setBottomRight, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_setBottomRight)},
    {SIP_MLNAME_CAST(sipName_setCenter), meth_QGeoRectangle_setCenter, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_setCenter)},
    {SIP_MLNAME_CAST(sipName_setHeight), meth_QGeoRectangle_setHeight, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_setHeight)},
    {SIP_MLNAME_CAST(sipName_setTopLeft), meth_QGeoRectangle_setTopLeft, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_setTopLeft)},
    {SIP_MLNAME_CAST(sipName_setTopRight), meth_QGeoRectangle_setTopRight, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_setTopRight)},
    {SIP_MLNAME_CAST(sipName_setWidth), meth_QGeoRectangle_setWidth, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_setWidth)},
    {SIP_MLNAME_CAST(sipName_topLeft), meth_QGeoRectangle_topLeft, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_topLeft)},
    {SIP_MLNAME_CAST(sipName_topRight), meth_QGeoRectangle_topRight, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_topRight)},
    {SIP_MLNAME_CAST(sipName_translate), meth_QGeoRectangle_translate, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_translate)},
    {SIP_MLNAME_CAST(sipName_translated), meth_QGeoRectangle_translated, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_translated)},
    {SIP_MLNAME_CAST(sipName_united), meth_QGeoRectangle_united, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_united)},
    {SIP_MLNAME_CAST(sipName_width), meth_QGeoRectangle_width, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoRectangle_width)}
};

PyDoc_STRVAR(doc_QGeoRectangle, "\1QGeoRectangle()\n"
    "QGeoRectangle(QGeoCoordinate, float, float)\n"
    "QGeoRectangle(QGeoCoordinate, QGeoCoordinate)\n"
    "QGeoRectangle(list-of-QGeoCoordinate)\n"
    "QGeoRectangle(QGeoRectangle)\n"
    "QGeoRectangle(QGeoShape)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoRectangle = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoRectangle,
        {0}
    },
    {
        sipNameNr_QGeoRectangle,
        {0, 0, 1},
        19, methods_QGeoRectangle,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoRectangle,
    -1,
    -1,
    supers_QGeoRectangle,
    slots_QGeoRectangle,
    init_type_QGeoRectangle,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoRectangle,
    assign_QGeoRectangle,
    array_QGeoRectangle,
    copy_QGeoRectangle,
    release_QGeoRectangle,
    cast_QGeoRectangle,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfosource.sip"
#include <qgeopositioninfosource.h>
#line 5541 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfosource.sip"
#include <qgeopositioninfosource.h>
#line 5545 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


extern "C" {static int slot_QGeoPositionInfoSource_PositioningMethods___bool__(PyObject *);}
static int slot_QGeoPositionInfoSource_PositioningMethods___bool__(PyObject *sipSelf)
{
    QGeoPositionInfoSource::PositioningMethods *sipCpp = reinterpret_cast<QGeoPositionInfoSource::PositioningMethods *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoPositionInfoSource_PositioningMethods));

    if (!sipCpp)
        return -1;


    {
        {
            int sipRes = 0;

#line 119 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QGeoPositionInfoSource::PositioningMethods::Int() != 0);
#line 5563 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoPositionInfoSource::PositioningMethods *sipCpp = reinterpret_cast<QGeoPositionInfoSource::PositioningMethods *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoPositionInfoSource_PositioningMethods));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoPositionInfoSource::PositioningMethods* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGeoPositionInfoSource_PositioningMethods, &a0, &a0State))
        {
            bool sipRes = 0;

#line 114 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QGeoPositionInfoSource::PositioningMethods::Int() != a0->operator QGeoPositionInfoSource::PositioningMethods::Int());
#line 5593 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
            sipReleaseType(const_cast<QGeoPositionInfoSource::PositioningMethods *>(a0),sipType_QGeoPositionInfoSource_PositioningMethods,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,ne_slot,sipType_QGeoPositionInfoSource_PositioningMethods,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoPositionInfoSource::PositioningMethods *sipCpp = reinterpret_cast<QGeoPositionInfoSource::PositioningMethods *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoPositionInfoSource_PositioningMethods));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoPositionInfoSource::PositioningMethods* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGeoPositionInfoSource_PositioningMethods, &a0, &a0State))
        {
            bool sipRes = 0;

#line 109 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QGeoPositionInfoSource::PositioningMethods::Int() == a0->operator QGeoPositionInfoSource::PositioningMethods::Int());
#line 5629 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
            sipReleaseType(const_cast<QGeoPositionInfoSource::PositioningMethods *>(a0),sipType_QGeoPositionInfoSource_PositioningMethods,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,eq_slot,sipType_QGeoPositionInfoSource_PositioningMethods,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___invert__(PyObject *);}
static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___invert__(PyObject *sipSelf)
{
    QGeoPositionInfoSource::PositioningMethods *sipCpp = reinterpret_cast<QGeoPositionInfoSource::PositioningMethods *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoPositionInfoSource_PositioningMethods));

    if (!sipCpp)
        return 0;


    {
        {
            QGeoPositionInfoSource::PositioningMethods*sipRes;

            sipRes = new QGeoPositionInfoSource::PositioningMethods(~(*sipCpp));

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

    return 0;
}


extern "C" {static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___and__(PyObject *,PyObject *);}
static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___and__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QGeoPositionInfoSource::PositioningMethods* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGeoPositionInfoSource_PositioningMethods, &a0, &a0State, &a1))
        {
            QGeoPositionInfoSource::PositioningMethods*sipRes;

            sipRes = new QGeoPositionInfoSource::PositioningMethods((*a0 & a1));
            sipReleaseType(a0,sipType_QGeoPositionInfoSource_PositioningMethods,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,and_slot,NULL,sipArg0,sipArg1);
}


extern "C" {static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___xor__(PyObject *,PyObject *);}
static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___xor__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QGeoPositionInfoSource::PositioningMethods* a0;
        int a0State = 0;
        QGeoPositionInfoSource::PositioningMethods* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1J1", sipType_QGeoPositionInfoSource_PositioningMethods, &a0, &a0State, sipType_QGeoPositionInfoSource_PositioningMethods, &a1, &a1State))
        {
            QGeoPositionInfoSource::PositioningMethods*sipRes;

            sipRes = new QGeoPositionInfoSource::PositioningMethods((*a0 ^ *a1));
            sipReleaseType(a0,sipType_QGeoPositionInfoSource_PositioningMethods,a0State);
            sipReleaseType(a1,sipType_QGeoPositionInfoSource_PositioningMethods,a1State);

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

    {
        QGeoPositionInfoSource::PositioningMethods* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGeoPositionInfoSource_PositioningMethods, &a0, &a0State, &a1))
        {
            QGeoPositionInfoSource::PositioningMethods*sipRes = 0;

#line 103 "sip/QtCore/qglobal.sip"
        sipRes = new QGeoPositionInfoSource::PositioningMethods(*a0 ^ a1);
#line 5732 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
            sipReleaseType(a0,sipType_QGeoPositionInfoSource_PositioningMethods,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,xor_slot,NULL,sipArg0,sipArg1);
}


extern "C" {static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___or__(PyObject *,PyObject *);}
static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QGeoPositionInfoSource::PositioningMethods* a0;
        int a0State = 0;
        QGeoPositionInfoSource::PositioningMethods* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1J1", sipType_QGeoPositionInfoSource_PositioningMethods, &a0, &a0State, sipType_QGeoPositionInfoSource_PositioningMethods, &a1, &a1State))
        {
            QGeoPositionInfoSource::PositioningMethods*sipRes;

            sipRes = new QGeoPositionInfoSource::PositioningMethods((*a0 | *a1));
            sipReleaseType(a0,sipType_QGeoPositionInfoSource_PositioningMethods,a0State);
            sipReleaseType(a1,sipType_QGeoPositionInfoSource_PositioningMethods,a1State);

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

    {
        QGeoPositionInfoSource::PositioningMethods* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGeoPositionInfoSource_PositioningMethods, &a0, &a0State, &a1))
        {
            QGeoPositionInfoSource::PositioningMethods*sipRes = 0;

#line 98 "sip/QtCore/qglobal.sip"
        sipRes = new QGeoPositionInfoSource::PositioningMethods(*a0 | a1);
#line 5782 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
            sipReleaseType(a0,sipType_QGeoPositionInfoSource_PositioningMethods,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,or_slot,NULL,sipArg0,sipArg1);
}


extern "C" {static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___int__(PyObject *);}
static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___int__(PyObject *sipSelf)
{
    QGeoPositionInfoSource::PositioningMethods *sipCpp = reinterpret_cast<QGeoPositionInfoSource::PositioningMethods *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoPositionInfoSource_PositioningMethods));

    if (!sipCpp)
        return 0;


    {
        {
            int sipRes;

            sipRes = *sipCpp;

            return SIPLong_FromLong(sipRes);
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___ixor__(PyObject *,PyObject *);}
static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGeoPositionInfoSource_PositioningMethods)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    QGeoPositionInfoSource::PositioningMethods *sipCpp = reinterpret_cast<QGeoPositionInfoSource::PositioningMethods *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoPositionInfoSource_PositioningMethods));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        QGeoPositionInfoSource::PositioningMethods* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGeoPositionInfoSource_PositioningMethods, &a0, &a0State))
        {
            sipCpp->QGeoPositionInfoSource::PositioningMethods::operator^=(*a0);
            sipReleaseType(a0,sipType_QGeoPositionInfoSource_PositioningMethods,a0State);

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___ior__(PyObject *,PyObject *);}
static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___ior__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGeoPositionInfoSource_PositioningMethods)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    QGeoPositionInfoSource::PositioningMethods *sipCpp = reinterpret_cast<QGeoPositionInfoSource::PositioningMethods *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoPositionInfoSource_PositioningMethods));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        QGeoPositionInfoSource::PositioningMethods* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGeoPositionInfoSource_PositioningMethods, &a0, &a0State))
        {
            sipCpp->QGeoPositionInfoSource::PositioningMethods::operator|=(*a0);
            sipReleaseType(a0,sipType_QGeoPositionInfoSource_PositioningMethods,a0State);

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___iand__(PyObject *,PyObject *);}
static PyObject *slot_QGeoPositionInfoSource_PositioningMethods___iand__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGeoPositionInfoSource_PositioningMethods)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    QGeoPositionInfoSource::PositioningMethods *sipCpp = reinterpret_cast<QGeoPositionInfoSource::PositioningMethods *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoPositionInfoSource_PositioningMethods));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            sipCpp->QGeoPositionInfoSource::PositioningMethods::operator&=(a0);

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


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

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoPositionInfoSource_PositioningMethods(void *, int);}
static void release_QGeoPositionInfoSource_PositioningMethods(void *sipCppV,int)
{
    delete reinterpret_cast<QGeoPositionInfoSource::PositioningMethods *>(sipCppV);
}


extern "C" {static void assign_QGeoPositionInfoSource_PositioningMethods(void *, SIP_SSIZE_T, const void *);}
static void assign_QGeoPositionInfoSource_PositioningMethods(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QGeoPositionInfoSource::PositioningMethods *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QGeoPositionInfoSource::PositioningMethods *>(sipSrc);
}


extern "C" {static void *array_QGeoPositionInfoSource_PositioningMethods(SIP_SSIZE_T);}
static void *array_QGeoPositionInfoSource_PositioningMethods(SIP_SSIZE_T sipNrElem)
{
    return new QGeoPositionInfoSource::PositioningMethods[sipNrElem];
}


extern "C" {static void *copy_QGeoPositionInfoSource_PositioningMethods(const void *, SIP_SSIZE_T);}
static void *copy_QGeoPositionInfoSource_PositioningMethods(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QGeoPositionInfoSource::PositioningMethods(reinterpret_cast<const QGeoPositionInfoSource::PositioningMethods *>(sipSrc)[sipSrcIdx]);
}


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


extern "C" {static void *init_type_QGeoPositionInfoSource_PositioningMethods(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGeoPositionInfoSource_PositioningMethods(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QGeoPositionInfoSource::PositioningMethods *sipCpp = 0;

    {
        const QGeoPositionInfoSource::PositioningMethods* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QGeoPositionInfoSource_PositioningMethods, &a0, &a0State))
        {
            sipCpp = new QGeoPositionInfoSource::PositioningMethods(*a0);
            sipReleaseType(const_cast<QGeoPositionInfoSource::PositioningMethods *>(a0),sipType_QGeoPositionInfoSource_PositioningMethods,a0State);

            return sipCpp;
        }
    }

    {
        int a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "i", &a0))
        {
            sipCpp = new QGeoPositionInfoSource::PositioningMethods(a0);

            return sipCpp;
        }
    }

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new QGeoPositionInfoSource::PositioningMethods();

            return sipCpp;
        }
    }

    return NULL;
}


extern "C" {static int convertTo_QGeoPositionInfoSource_PositioningMethods(PyObject *, void **, int *, PyObject *);}
static int convertTo_QGeoPositionInfoSource_PositioningMethods(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QGeoPositionInfoSource::PositioningMethods **sipCppPtr = reinterpret_cast<QGeoPositionInfoSource::PositioningMethods **>(sipCppPtrV);

#line 124 "sip/QtCore/qglobal.sip"
// Allow an instance of the base enum whenever a QGeoPositionInfoSource::PositioningMethods is expected.

if (sipIsErr == NULL)
    return (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QGeoPositionInfoSource_PositioningMethod)) ||
            sipCanConvertToType(sipPy, sipType_QGeoPositionInfoSource_PositioningMethods, SIP_NO_CONVERTORS));

if (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QGeoPositionInfoSource_PositioningMethod)))
{
    *sipCppPtr = new QGeoPositionInfoSource::PositioningMethods(int(SIPLong_AsLong(sipPy)));

    return sipGetState(sipTransferObj);
}

*sipCppPtr = reinterpret_cast<QGeoPositionInfoSource::PositioningMethods *>(sipConvertToType(sipPy, sipType_QGeoPositionInfoSource_PositioningMethods, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr));

return 0;
#line 6059 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGeoPositionInfoSource_PositioningMethods[] = {
    {(void *)slot_QGeoPositionInfoSource_PositioningMethods___bool__, bool_slot},
    {(void *)slot_QGeoPositionInfoSource_PositioningMethods___ne__, ne_slot},
    {(void *)slot_QGeoPositionInfoSource_PositioningMethods___eq__, eq_slot},
    {(void *)slot_QGeoPositionInfoSource_PositioningMethods___invert__, invert_slot},
    {(void *)slot_QGeoPositionInfoSource_PositioningMethods___and__, and_slot},
    {(void *)slot_QGeoPositionInfoSource_PositioningMethods___xor__, xor_slot},
    {(void *)slot_QGeoPositionInfoSource_PositioningMethods___or__, or_slot},
    {(void *)slot_QGeoPositionInfoSource_PositioningMethods___int__, int_slot},
    {(void *)slot_QGeoPositionInfoSource_PositioningMethods___ixor__, ixor_slot},
    {(void *)slot_QGeoPositionInfoSource_PositioningMethods___ior__, ior_slot},
    {(void *)slot_QGeoPositionInfoSource_PositioningMethods___iand__, iand_slot},
    {0, (sipPySlotType)0}
};

PyDoc_STRVAR(doc_QGeoPositionInfoSource_PositioningMethods, "\1QGeoPositionInfoSource.PositioningMethods(QGeoPositionInfoSource.PositioningMethods)\n"
    "QGeoPositionInfoSource.PositioningMethods(int)\n"
    "QGeoPositionInfoSource.PositioningMethods()");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoPositionInfoSource_PositioningMethods = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoPositionInfoSource__PositioningMethods,
        {0}
    },
    {
        sipNameNr_PositioningMethods,
        {13, 255, 0},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoPositionInfoSource_PositioningMethods,
    sipNameNr_PyQt5_QtCore_pyqtWrapperType,
    -1,
    0,
    slots_QGeoPositionInfoSource_PositioningMethods,
    init_type_QGeoPositionInfoSource_PositioningMethods,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoPositionInfoSource_PositioningMethods,
    assign_QGeoPositionInfoSource_PositioningMethods,
    array_QGeoPositionInfoSource_PositioningMethods,
    copy_QGeoPositionInfoSource_PositioningMethods,
    release_QGeoPositionInfoSource_PositioningMethods,
    cast_QGeoPositionInfoSource_PositioningMethods,
    convertTo_QGeoPositionInfoSource_PositioningMethods,
    0,
    0,
    0,
    0,
    0
},
    0,
    1,
    0,
    0
};

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfosource.sip"
#include <qgeopositioninfosource.h>
#line 6141 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 6145 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfo.sip"
#include <qgeopositioninfo.h>
#line 6148 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 6151 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 6154 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfosource.sip"
#include <qgeopositioninfosource.h>
#line 6157 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 6160 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 6163 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 241 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 6166 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 229 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 6169 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 6172 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 6175 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 32 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 6178 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 144 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 6181 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 6184 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 6187 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 6190 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 6193 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 6196 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 6199 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


class sipQGeoPositionInfoSource : public QGeoPositionInfoSource
{
public:
    sipQGeoPositionInfoSource(QObject*);
    virtual ~sipQGeoPositionInfoSource();

    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 QMetaMethod&);
    void sipProtectVirt_disconnectNotify(bool,const QMetaMethod&);
    int sipProtect_senderSignalIndex() const;
    bool sipProtect_isSignalConnected(const QMetaMethod&) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const QMetaMethod&);
    void connectNotify(const QMetaMethod&);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);
    void requestUpdate(int);
    void stopUpdates();
    void startUpdates();
    QGeoPositionInfoSource::Error error() const;
    int minimumUpdateInterval() const;
    QGeoPositionInfoSource::PositioningMethods supportedPositioningMethods() const;
    QGeoPositionInfo lastKnownPosition(bool) const;
    void setPreferredPositioningMethods(QGeoPositionInfoSource::PositioningMethods);
    void setUpdateInterval(int);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[16];
};

sipQGeoPositionInfoSource::sipQGeoPositionInfoSource(QObject*a0): QGeoPositionInfoSource(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

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

const QMetaObject *sipQGeoPositionInfoSource::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtPositioning_qt_metaobject(sipPySelf,sipType_QGeoPositionInfoSource);
}

int sipQGeoPositionInfoSource::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = QGeoPositionInfoSource::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtPositioning_qt_metacall(sipPySelf,sipType_QGeoPositionInfoSource,_c,_id,_a);

    return _id;
}

void *sipQGeoPositionInfoSource::qt_metacast(const char *_clname)
{
    void *sipCpp;

    return (sip_QtPositioning_qt_metacast(sipPySelf, sipType_QGeoPositionInfoSource, _clname, &sipCpp) ? sipCpp : QGeoPositionInfoSource::qt_metacast(_clname));
}

void sipQGeoPositionInfoSource::disconnectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoPositionInfoSource::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoPositionInfoSource::connectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoPositionInfoSource::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoPositionInfoSource::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoPositionInfoSource::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[25]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoPositionInfoSource::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoPositionInfoSource::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_47)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_47)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[47]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoPositionInfoSource::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoPositionInfoSource::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[9]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipQGeoPositionInfoSource::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return QGeoPositionInfoSource::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_26)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_26)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[26]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1);
}

bool sipQGeoPositionInfoSource::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return QGeoPositionInfoSource::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[5]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoPositionInfoSource::requestUpdate(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,sipName_QGeoPositionInfoSource,sipName_requestUpdate);

    if (!sipMeth)
        return;

    typedef void (*sipVH_QtCore_4)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    ((sipVH_QtCore_4)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[4]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoPositionInfoSource::stopUpdates()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[8],sipPySelf,sipName_QGeoPositionInfoSource,sipName_stopUpdates);

    if (!sipMeth)
        return;

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

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

void sipQGeoPositionInfoSource::startUpdates()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[9],sipPySelf,sipName_QGeoPositionInfoSource,sipName_startUpdates);

    if (!sipMeth)
        return;

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

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

QGeoPositionInfoSource::Error sipQGeoPositionInfoSource::error() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[10]),sipPySelf,sipName_QGeoPositionInfoSource,sipName_error);

    if (!sipMeth)
        return (QGeoPositionInfoSource::Error)0;

    extern QGeoPositionInfoSource::Error sipVH_QtPositioning_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtPositioning_1(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

int sipQGeoPositionInfoSource::minimumUpdateInterval() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[11]),sipPySelf,sipName_QGeoPositionInfoSource,sipName_minimumUpdateInterval);

    if (!sipMeth)
        return 0;

    typedef int (*sipVH_QtCore_6)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_6)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[6]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

QGeoPositionInfoSource::PositioningMethods sipQGeoPositionInfoSource::supportedPositioningMethods() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[12]),sipPySelf,sipName_QGeoPositionInfoSource,sipName_supportedPositioningMethods);

    if (!sipMeth)
        return QGeoPositionInfoSource::PositioningMethods();

    extern QGeoPositionInfoSource::PositioningMethods sipVH_QtPositioning_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtPositioning_2(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

QGeoPositionInfo sipQGeoPositionInfoSource::lastKnownPosition(bool a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[13]),sipPySelf,sipName_QGeoPositionInfoSource,sipName_lastKnownPosition);

    if (!sipMeth)
        return QGeoPositionInfo();

    extern QGeoPositionInfo sipVH_QtPositioning_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    return sipVH_QtPositioning_3(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoPositionInfoSource::setPreferredPositioningMethods(QGeoPositionInfoSource::PositioningMethods a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[14],sipPySelf,NULL,sipName_setPreferredPositioningMethods);

    if (!sipMeth)
    {
        QGeoPositionInfoSource::setPreferredPositioningMethods(a0);
        return;
    }

    extern void sipVH_QtPositioning_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QGeoPositionInfoSource::PositioningMethods);

    sipVH_QtPositioning_5(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoPositionInfoSource::setUpdateInterval(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[15],sipPySelf,NULL,sipName_setUpdateInterval);

    if (!sipMeth)
    {
        QGeoPositionInfoSource::setUpdateInterval(a0);
        return;
    }

    typedef void (*sipVH_QtCore_4)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    ((sipVH_QtCore_4)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[4]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QObject* sipQGeoPositionInfoSource::sipProtect_sender() const
{
    return QObject::sender();
}

int sipQGeoPositionInfoSource::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipQGeoPositionInfoSource::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQGeoPositionInfoSource::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipQGeoPositionInfoSource::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipQGeoPositionInfoSource::sipProtectVirt_connectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQGeoPositionInfoSource::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQGeoPositionInfoSource::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

bool sipQGeoPositionInfoSource::sipProtect_isSignalConnected(const QMetaMethod& a0) const
{
    return QObject::isSignalConnected(a0);
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_sender, "QGeoPositionInfoSource.sender() -> QObject");

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

    {
        const sipQGeoPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp))
        {
            QObject*sipRes = 0;

#line 546 "sip/QtCore/qobject.sip"
        // 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 (!sipRes)
        {
            typedef QObject *(*qtcore_qobject_sender_t)();
        
            static qtcore_qobject_sender_t qtcore_qobject_sender = 0;
        
            if (!qtcore_qobject_sender)
                qtcore_qobject_sender = (qtcore_qobject_sender_t)sipImportSymbol("qtcore_qobject_sender");
        
            if (qtcore_qobject_sender)
                sipRes = qtcore_qobject_sender();
        }
#line 6637 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_sender, doc_QGeoPositionInfoSource_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_receivers, "QGeoPositionInfoSource.receivers(signal) -> int");

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

    {
        PyObject * a0;
        const sipQGeoPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 575 "sip/QtCore/qobject.sip"
        // We need to handle the signal object.  Import the helper if it hasn't already
        // been done.
        typedef sipErrorState (*pyqt5_get_signal_signature_t)(PyObject *, const QObject *, const QByteArray &);
        
        static pyqt5_get_signal_signature_t pyqt5_get_signal_signature = 0;
        
        if (!pyqt5_get_signal_signature)
            pyqt5_get_signal_signature = (pyqt5_get_signal_signature_t)sipImportSymbol("pyqt5_get_signal_signature");
        
        if (pyqt5_get_signal_signature)
        {
            QByteArray signal_signature;
            
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            if ((sipError = pyqt5_get_signal_signature(a0, sipCpp, signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->receivers(signal_signature.constData());
            }
        #else
            if ((sipError = pyqt5_get_signal_signature(a0, static_cast<const QObject *>(sipCpp), signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->sipProtect_receivers(signal_signature.constData());
            }
        #endif
            else if (sipError == sipErrorContinue)
            {
                sipError = sipBadCallableArg(0, a0);
            }
        }
#line 6696 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_receivers, doc_QGeoPositionInfoSource_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_timerEvent, "QGeoPositionInfoSource.timerEvent(QTimerEvent)");

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

    {
        QTimerEvent* a0;
        sipQGeoPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp, sipType_QTimerEvent, &a0))
        {
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_timerEvent, doc_QGeoPositionInfoSource_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_childEvent, "QGeoPositionInfoSource.childEvent(QChildEvent)");

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

    {
        QChildEvent* a0;
        sipQGeoPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp, sipType_QChildEvent, &a0))
        {
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_childEvent, doc_QGeoPositionInfoSource_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_customEvent, "QGeoPositionInfoSource.customEvent(QEvent)");

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

    {
        QEvent* a0;
        sipQGeoPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp, sipType_QEvent, &a0))
        {
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_customEvent, doc_QGeoPositionInfoSource_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_connectNotify, "QGeoPositionInfoSource.connectNotify(QMetaMethod)");

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

    {
        const QMetaMethod* a0;
        sipQGeoPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_connectNotify, doc_QGeoPositionInfoSource_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_disconnectNotify, "QGeoPositionInfoSource.disconnectNotify(QMetaMethod)");

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

    {
        const QMetaMethod* a0;
        sipQGeoPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_disconnectNotify, doc_QGeoPositionInfoSource_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_senderSignalIndex, "QGeoPositionInfoSource.senderSignalIndex() -> int");

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

    {
        const sipQGeoPositionInfoSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_senderSignalIndex, doc_QGeoPositionInfoSource_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_isSignalConnected, "QGeoPositionInfoSource.isSignalConnected(QMetaMethod) -> bool");

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

    {
        const QMetaMethod* a0;
        const sipQGeoPositionInfoSource *sipCpp;

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

            sipRes = sipCpp->sipProtect_isSignalConnected(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_isSignalConnected, doc_QGeoPositionInfoSource_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_setUpdateInterval, "QGeoPositionInfoSource.setUpdateInterval(int)");

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

    {
        int a0;
        QGeoPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp, &a0))
        {
            (sipSelfWasArg ? sipCpp->QGeoPositionInfoSource::setUpdateInterval(a0) : sipCpp->setUpdateInterval(a0));

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_setUpdateInterval, doc_QGeoPositionInfoSource_setUpdateInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_updateInterval, "QGeoPositionInfoSource.updateInterval() -> int");

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

    {
        const QGeoPositionInfoSource *sipCpp;

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

            sipRes = sipCpp->updateInterval();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_updateInterval, doc_QGeoPositionInfoSource_updateInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_setPreferredPositioningMethods, "QGeoPositionInfoSource.setPreferredPositioningMethods(QGeoPositionInfoSource.PositioningMethods)");

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

    {
        QGeoPositionInfoSource::PositioningMethods* a0;
        int a0State = 0;
        QGeoPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp, sipType_QGeoPositionInfoSource_PositioningMethods, &a0, &a0State))
        {
            (sipSelfWasArg ? sipCpp->QGeoPositionInfoSource::setPreferredPositioningMethods(*a0) : sipCpp->setPreferredPositioningMethods(*a0));
            sipReleaseType(a0,sipType_QGeoPositionInfoSource_PositioningMethods,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_setPreferredPositioningMethods, doc_QGeoPositionInfoSource_setPreferredPositioningMethods);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_preferredPositioningMethods, "QGeoPositionInfoSource.preferredPositioningMethods() -> QGeoPositionInfoSource.PositioningMethods");

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

    {
        const QGeoPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp))
        {
            QGeoPositionInfoSource::PositioningMethods*sipRes;

            sipRes = new QGeoPositionInfoSource::PositioningMethods(sipCpp->preferredPositioningMethods());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_preferredPositioningMethods, doc_QGeoPositionInfoSource_preferredPositioningMethods);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_lastKnownPosition, "QGeoPositionInfoSource.lastKnownPosition(bool fromSatellitePositioningMethodsOnly=False) -> QGeoPositionInfo");

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

    {
        bool a0 = 0;
        const QGeoPositionInfoSource *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|b", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp, &a0))
        {
            QGeoPositionInfo*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoPositionInfoSource, sipName_lastKnownPosition);
                return NULL;
            }

            sipRes = new QGeoPositionInfo(sipCpp->lastKnownPosition(a0));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_lastKnownPosition, doc_QGeoPositionInfoSource_lastKnownPosition);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_supportedPositioningMethods, "QGeoPositionInfoSource.supportedPositioningMethods() -> QGeoPositionInfoSource.PositioningMethods");

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

    {
        const QGeoPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp))
        {
            QGeoPositionInfoSource::PositioningMethods*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoPositionInfoSource, sipName_supportedPositioningMethods);
                return NULL;
            }

            sipRes = new QGeoPositionInfoSource::PositioningMethods(sipCpp->supportedPositioningMethods());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_supportedPositioningMethods, doc_QGeoPositionInfoSource_supportedPositioningMethods);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_minimumUpdateInterval, "QGeoPositionInfoSource.minimumUpdateInterval() -> int");

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

    {
        const QGeoPositionInfoSource *sipCpp;

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

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoPositionInfoSource, sipName_minimumUpdateInterval);
                return NULL;
            }

            sipRes = sipCpp->minimumUpdateInterval();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_minimumUpdateInterval, doc_QGeoPositionInfoSource_minimumUpdateInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_sourceName, "QGeoPositionInfoSource.sourceName() -> str");

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

    {
        const QGeoPositionInfoSource *sipCpp;

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

            sipRes = new QString(sipCpp->sourceName());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_sourceName, doc_QGeoPositionInfoSource_sourceName);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_createDefaultSource, "QGeoPositionInfoSource.createDefaultSource(QObject) -> QGeoPositionInfoSource");

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

    {
        QObject* a0;
        sipWrapper *sipOwner = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "JH", sipType_QObject, &a0, &sipOwner))
        {
            QGeoPositionInfoSource*sipRes;

            sipRes = QGeoPositionInfoSource::createDefaultSource(a0);

            return sipConvertFromNewType(sipRes,sipType_QGeoPositionInfoSource,(PyObject *)sipOwner);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_createDefaultSource, doc_QGeoPositionInfoSource_createDefaultSource);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_createSource, "QGeoPositionInfoSource.createSource(str, QObject) -> QGeoPositionInfoSource");

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

    {
        const QString* a0;
        int a0State = 0;
        QObject* a1;
        sipWrapper *sipOwner = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J1JH", sipType_QString,&a0, &a0State, sipType_QObject, &a1, &sipOwner))
        {
            QGeoPositionInfoSource*sipRes;

            sipRes = QGeoPositionInfoSource::createSource(*a0,a1);
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGeoPositionInfoSource,(PyObject *)sipOwner);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_createSource, doc_QGeoPositionInfoSource_createSource);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_availableSources, "QGeoPositionInfoSource.availableSources() -> list-of-str");

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

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            QStringList*sipRes;

            sipRes = new QStringList(QGeoPositionInfoSource::availableSources());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_availableSources, doc_QGeoPositionInfoSource_availableSources);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_error, "QGeoPositionInfoSource.error() -> QGeoPositionInfoSource.Error");

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

    {
        const QGeoPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp))
        {
            QGeoPositionInfoSource::Error sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoPositionInfoSource, sipName_error);
                return NULL;
            }

            sipRes = sipCpp->error();

            return sipConvertFromEnum(sipRes,sipType_QGeoPositionInfoSource_Error);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_error, doc_QGeoPositionInfoSource_error);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_startUpdates, "QGeoPositionInfoSource.startUpdates()");

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

    {
        QGeoPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoPositionInfoSource, sipName_startUpdates);
                return NULL;
            }

            sipCpp->startUpdates();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_startUpdates, doc_QGeoPositionInfoSource_startUpdates);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_stopUpdates, "QGeoPositionInfoSource.stopUpdates()");

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

    {
        QGeoPositionInfoSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoPositionInfoSource, sipName_stopUpdates);
                return NULL;
            }

            sipCpp->stopUpdates();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_stopUpdates, doc_QGeoPositionInfoSource_stopUpdates);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfoSource_requestUpdate, "QGeoPositionInfoSource.requestUpdate(int timeout=0)");

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

    {
        int a0 = 0;
        QGeoPositionInfoSource *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|i", &sipSelf, sipType_QGeoPositionInfoSource, &sipCpp, &a0))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoPositionInfoSource, sipName_requestUpdate);
                return NULL;
            }

            sipCpp->requestUpdate(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfoSource, sipName_requestUpdate, doc_QGeoPositionInfoSource_requestUpdate);

    return NULL;
}


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

    if (targetType == sipType_QGeoPositionInfoSource)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(QGeoPositionInfoSource *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoPositionInfoSource(void *, int);}
static void release_QGeoPositionInfoSource(void *sipCppV,int)
{
    QGeoPositionInfoSource *sipCpp = reinterpret_cast<QGeoPositionInfoSource *>(sipCppV);

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();
}


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

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


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

    {
        QObject* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "JH", sipType_QObject, &a0, sipOwner))
        {
            sipCpp = new sipQGeoPositionInfoSource(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QGeoPositionInfoSource[] = {{162, 0, 1}};


static PyMethodDef methods_QGeoPositionInfoSource[] = {
    {SIP_MLNAME_CAST(sipName_availableSources), meth_QGeoPositionInfoSource_availableSources, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_availableSources)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QGeoPositionInfoSource_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QGeoPositionInfoSource_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_createDefaultSource), meth_QGeoPositionInfoSource_createDefaultSource, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_createDefaultSource)},
    {SIP_MLNAME_CAST(sipName_createSource), meth_QGeoPositionInfoSource_createSource, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_createSource)},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QGeoPositionInfoSource_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QGeoPositionInfoSource_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_error), meth_QGeoPositionInfoSource_error, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_error)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QGeoPositionInfoSource_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_lastKnownPosition), (PyCFunction)meth_QGeoPositionInfoSource_lastKnownPosition, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_lastKnownPosition)},
    {SIP_MLNAME_CAST(sipName_minimumUpdateInterval), meth_QGeoPositionInfoSource_minimumUpdateInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_minimumUpdateInterval)},
    {SIP_MLNAME_CAST(sipName_preferredPositioningMethods), meth_QGeoPositionInfoSource_preferredPositioningMethods, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_preferredPositioningMethods)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QGeoPositionInfoSource_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_requestUpdate), (PyCFunction)meth_QGeoPositionInfoSource_requestUpdate, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_requestUpdate)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QGeoPositionInfoSource_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QGeoPositionInfoSource_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setPreferredPositioningMethods), meth_QGeoPositionInfoSource_setPreferredPositioningMethods, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_setPreferredPositioningMethods)},
    {SIP_MLNAME_CAST(sipName_setUpdateInterval), meth_QGeoPositionInfoSource_setUpdateInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_setUpdateInterval)},
    {SIP_MLNAME_CAST(sipName_sourceName), meth_QGeoPositionInfoSource_sourceName, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_sourceName)},
    {SIP_MLNAME_CAST(sipName_startUpdates), meth_QGeoPositionInfoSource_startUpdates, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_startUpdates)},
    {SIP_MLNAME_CAST(sipName_stopUpdates), meth_QGeoPositionInfoSource_stopUpdates, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_stopUpdates)},
    {SIP_MLNAME_CAST(sipName_supportedPositioningMethods), meth_QGeoPositionInfoSource_supportedPositioningMethods, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_supportedPositioningMethods)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QGeoPositionInfoSource_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_updateInterval), meth_QGeoPositionInfoSource_updateInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfoSource_updateInterval)}
};

static sipEnumMemberDef enummembers_QGeoPositionInfoSource[] = {
    {sipName_AccessError, static_cast<int>(QGeoPositionInfoSource::AccessError), 14},
    {sipName_AllPositioningMethods, static_cast<int>(QGeoPositionInfoSource::AllPositioningMethods), 15},
    {sipName_ClosedError, static_cast<int>(QGeoPositionInfoSource::ClosedError), 14},
    {sipName_NoError, static_cast<int>(QGeoPositionInfoSource::NoError), 14},
    {sipName_NoPositioningMethods, static_cast<int>(QGeoPositionInfoSource::NoPositioningMethods), 15},
    {sipName_NonSatellitePositioningMethods, static_cast<int>(QGeoPositionInfoSource::NonSatellitePositioningMethods), 15},
    {sipName_SatellitePositioningMethods, static_cast<int>(QGeoPositionInfoSource::SatellitePositioningMethods), 15},
    {sipName_UnknownSourceError, static_cast<int>(QGeoPositionInfoSource::UnknownSourceError), 14},
};


/* Define this type's signals. */
static const pyqt5QtSignal signals_QGeoPositionInfoSource[] = {
    {"updateTimeout()", "\1QGeoPositionInfoSource.updateTimeout", 0, 0},
    {"positionUpdated(QGeoPositionInfo)", "\1QGeoPositionInfoSource.positionUpdated[QGeoPositionInfo]", 0, 0},
    {"error(QGeoPositionInfoSource::Error)", "\1QGeoPositionInfoSource.error[QGeoPositionInfoSource.Error]", &methods_QGeoPositionInfoSource[7], 0},
    {0, 0, 0, 0}
};

PyDoc_STRVAR(doc_QGeoPositionInfoSource, "\1QGeoPositionInfoSource(QObject)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoPositionInfoSource = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoPositionInfoSource,
        {0}
    },
    {
        sipNameNr_QGeoPositionInfoSource,
        {0, 0, 1},
        24, methods_QGeoPositionInfoSource,
        8, enummembers_QGeoPositionInfoSource,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoPositionInfoSource,
    -1,
    -1,
    supers_QGeoPositionInfoSource,
    0,
    init_type_QGeoPositionInfoSource,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoPositionInfoSource,
    0,
    0,
    0,
    release_QGeoPositionInfoSource,
    cast_QGeoPositionInfoSource,
    0,
    0,
    0,
    0,
    0,
    0
},
    &QGeoPositionInfoSource::staticMetaObject,
    0,
    signals_QGeoPositionInfoSource,
    0
};

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfo.sip"
#include <qgeopositioninfo.h>
#line 7555 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeocoordinate.sip"
#include <qgeocoordinate.h>
#line 7559 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 299 "sip/QtCore/qdatetime.sip"
#include <qdatetime.h>
#line 7562 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


PyDoc_STRVAR(doc_QGeoPositionInfo_isValid, "QGeoPositionInfo.isValid() -> bool");

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

    {
        const QGeoPositionInfo *sipCpp;

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

            sipRes = sipCpp->isValid();

            return PyBool_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfo_setTimestamp, "QGeoPositionInfo.setTimestamp(QDateTime)");

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

    {
        const QDateTime* a0;
        int a0State = 0;
        QGeoPositionInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoPositionInfo, &sipCpp, sipType_QDateTime, &a0, &a0State))
        {
            sipCpp->setTimestamp(*a0);
            sipReleaseType(const_cast<QDateTime *>(a0),sipType_QDateTime,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfo, sipName_setTimestamp, doc_QGeoPositionInfo_setTimestamp);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfo_timestamp, "QGeoPositionInfo.timestamp() -> QDateTime");

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

    {
        const QGeoPositionInfo *sipCpp;

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

            sipRes = new QDateTime(sipCpp->timestamp());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfo, sipName_timestamp, doc_QGeoPositionInfo_timestamp);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfo_setCoordinate, "QGeoPositionInfo.setCoordinate(QGeoCoordinate)");

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

    {
        const QGeoCoordinate* a0;
        QGeoPositionInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoPositionInfo, &sipCpp, sipType_QGeoCoordinate, &a0))
        {
            sipCpp->setCoordinate(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfo, sipName_setCoordinate, doc_QGeoPositionInfo_setCoordinate);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfo_coordinate, "QGeoPositionInfo.coordinate() -> QGeoCoordinate");

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

    {
        const QGeoPositionInfo *sipCpp;

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

            sipRes = new QGeoCoordinate(sipCpp->coordinate());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfo, sipName_coordinate, doc_QGeoPositionInfo_coordinate);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfo_setAttribute, "QGeoPositionInfo.setAttribute(QGeoPositionInfo.Attribute, float)");

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

    {
        QGeoPositionInfo::Attribute a0;
        qreal a1;
        QGeoPositionInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEd", &sipSelf, sipType_QGeoPositionInfo, &sipCpp, sipType_QGeoPositionInfo_Attribute, &a0, &a1))
        {
            sipCpp->setAttribute(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfo, sipName_setAttribute, doc_QGeoPositionInfo_setAttribute);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfo_attribute, "QGeoPositionInfo.attribute(QGeoPositionInfo.Attribute) -> float");

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

    {
        QGeoPositionInfo::Attribute a0;
        const QGeoPositionInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QGeoPositionInfo, &sipCpp, sipType_QGeoPositionInfo_Attribute, &a0))
        {
            qreal sipRes;

            sipRes = sipCpp->attribute(a0);

            return PyFloat_FromDouble(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfo_removeAttribute, "QGeoPositionInfo.removeAttribute(QGeoPositionInfo.Attribute)");

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

    {
        QGeoPositionInfo::Attribute a0;
        QGeoPositionInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QGeoPositionInfo, &sipCpp, sipType_QGeoPositionInfo_Attribute, &a0))
        {
            sipCpp->removeAttribute(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfo, sipName_removeAttribute, doc_QGeoPositionInfo_removeAttribute);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoPositionInfo_hasAttribute, "QGeoPositionInfo.hasAttribute(QGeoPositionInfo.Attribute) -> bool");

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

    {
        QGeoPositionInfo::Attribute a0;
        const QGeoPositionInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QGeoPositionInfo, &sipCpp, sipType_QGeoPositionInfo_Attribute, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->hasAttribute(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoPositionInfo, sipName_hasAttribute, doc_QGeoPositionInfo_hasAttribute);

    return NULL;
}


extern "C" {static PyObject *slot_QGeoPositionInfo___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGeoPositionInfo___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoPositionInfo *sipCpp = reinterpret_cast<QGeoPositionInfo *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoPositionInfo));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoPositionInfo* a0;

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

            sipRes = sipCpp->QGeoPositionInfo::operator!=(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,ne_slot,sipType_QGeoPositionInfo,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoPositionInfo___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGeoPositionInfo___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoPositionInfo *sipCpp = reinterpret_cast<QGeoPositionInfo *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoPositionInfo));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoPositionInfo* a0;

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

            sipRes = sipCpp->QGeoPositionInfo::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,eq_slot,sipType_QGeoPositionInfo,sipSelf,sipArg);
}


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

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoPositionInfo(void *, int);}
static void release_QGeoPositionInfo(void *sipCppV,int)
{
    delete reinterpret_cast<QGeoPositionInfo *>(sipCppV);
}


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


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


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


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


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

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

            return sipCpp;
        }
    }

    {
        const QGeoCoordinate* a0;
        const QDateTime* a1;
        int a1State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9J1", sipType_QGeoCoordinate, &a0, sipType_QDateTime, &a1, &a1State))
        {
            sipCpp = new QGeoPositionInfo(*a0,*a1);
            sipReleaseType(const_cast<QDateTime *>(a1),sipType_QDateTime,a1State);

            return sipCpp;
        }
    }

    {
        const QGeoPositionInfo* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGeoPositionInfo, &a0))
        {
            sipCpp = new QGeoPositionInfo(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGeoPositionInfo[] = {
    {(void *)slot_QGeoPositionInfo___ne__, ne_slot},
    {(void *)slot_QGeoPositionInfo___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QGeoPositionInfo[] = {
    {SIP_MLNAME_CAST(sipName_attribute), meth_QGeoPositionInfo_attribute, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfo_attribute)},
    {SIP_MLNAME_CAST(sipName_coordinate), meth_QGeoPositionInfo_coordinate, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfo_coordinate)},
    {SIP_MLNAME_CAST(sipName_hasAttribute), meth_QGeoPositionInfo_hasAttribute, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfo_hasAttribute)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QGeoPositionInfo_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfo_isValid)},
    {SIP_MLNAME_CAST(sipName_removeAttribute), meth_QGeoPositionInfo_removeAttribute, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfo_removeAttribute)},
    {SIP_MLNAME_CAST(sipName_setAttribute), meth_QGeoPositionInfo_setAttribute, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfo_setAttribute)},
    {SIP_MLNAME_CAST(sipName_setCoordinate), meth_QGeoPositionInfo_setCoordinate, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfo_setCoordinate)},
    {SIP_MLNAME_CAST(sipName_setTimestamp), meth_QGeoPositionInfo_setTimestamp, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfo_setTimestamp)},
    {SIP_MLNAME_CAST(sipName_timestamp), meth_QGeoPositionInfo_timestamp, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoPositionInfo_timestamp)}
};

static sipEnumMemberDef enummembers_QGeoPositionInfo[] = {
    {sipName_Direction, static_cast<int>(QGeoPositionInfo::Direction), 12},
    {sipName_GroundSpeed, static_cast<int>(QGeoPositionInfo::GroundSpeed), 12},
    {sipName_HorizontalAccuracy, static_cast<int>(QGeoPositionInfo::HorizontalAccuracy), 12},
    {sipName_MagneticVariation, static_cast<int>(QGeoPositionInfo::MagneticVariation), 12},
    {sipName_VerticalAccuracy, static_cast<int>(QGeoPositionInfo::VerticalAccuracy), 12},
    {sipName_VerticalSpeed, static_cast<int>(QGeoPositionInfo::VerticalSpeed), 12},
};

PyDoc_STRVAR(doc_QGeoPositionInfo, "\1QGeoPositionInfo()\n"
    "QGeoPositionInfo(QGeoCoordinate, QDateTime)\n"
    "QGeoPositionInfo(QGeoPositionInfo)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoPositionInfo = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoPositionInfo,
        {0}
    },
    {
        sipNameNr_QGeoPositionInfo,
        {0, 0, 1},
        9, methods_QGeoPositionInfo,
        6, enummembers_QGeoPositionInfo,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoPositionInfo,
    sipNameNr_PyQt5_QtCore_pyqtWrapperType,
    -1,
    0,
    slots_QGeoPositionInfo,
    init_type_QGeoPositionInfo,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoPositionInfo,
    assign_QGeoPositionInfo,
    array_QGeoPositionInfo,
    copy_QGeoPositionInfo,
    release_QGeoPositionInfo,
    cast_QGeoPositionInfo,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeolocation.sip"
#include <qgeolocation.h>
#line 8061 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeorectangle.sip"
#include <qgeorectangle.h>
#line 8065 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeocoordinate.sip"
#include <qgeocoordinate.h>
#line 8068 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoaddress.sip"
#include <qgeoaddress.h>
#line 8071 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


PyDoc_STRVAR(doc_QGeoLocation_address, "QGeoLocation.address() -> QGeoAddress");

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

    {
        const QGeoLocation *sipCpp;

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

            sipRes = new QGeoAddress(sipCpp->address());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoLocation, sipName_address, doc_QGeoLocation_address);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoLocation_setAddress, "QGeoLocation.setAddress(QGeoAddress)");

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

    {
        const QGeoAddress* a0;
        QGeoLocation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoLocation, &sipCpp, sipType_QGeoAddress, &a0))
        {
            sipCpp->setAddress(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoLocation, sipName_setAddress, doc_QGeoLocation_setAddress);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoLocation_coordinate, "QGeoLocation.coordinate() -> QGeoCoordinate");

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

    {
        const QGeoLocation *sipCpp;

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

            sipRes = new QGeoCoordinate(sipCpp->coordinate());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoLocation, sipName_coordinate, doc_QGeoLocation_coordinate);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoLocation_setCoordinate, "QGeoLocation.setCoordinate(QGeoCoordinate)");

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

    {
        const QGeoCoordinate* a0;
        QGeoLocation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoLocation, &sipCpp, sipType_QGeoCoordinate, &a0))
        {
            sipCpp->setCoordinate(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoLocation, sipName_setCoordinate, doc_QGeoLocation_setCoordinate);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoLocation_boundingBox, "QGeoLocation.boundingBox() -> QGeoRectangle");

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

    {
        const QGeoLocation *sipCpp;

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

            sipRes = new QGeoRectangle(sipCpp->boundingBox());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoLocation, sipName_boundingBox, doc_QGeoLocation_boundingBox);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoLocation_setBoundingBox, "QGeoLocation.setBoundingBox(QGeoRectangle)");

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

    {
        const QGeoRectangle* a0;
        QGeoLocation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoLocation, &sipCpp, sipType_QGeoRectangle, &a0))
        {
            sipCpp->setBoundingBox(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoLocation, sipName_setBoundingBox, doc_QGeoLocation_setBoundingBox);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoLocation_isEmpty, "QGeoLocation.isEmpty() -> bool");

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

    {
        const QGeoLocation *sipCpp;

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

            sipRes = sipCpp->isEmpty();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoLocation, sipName_isEmpty, doc_QGeoLocation_isEmpty);

    return NULL;
}


extern "C" {static PyObject *slot_QGeoLocation___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGeoLocation___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoLocation *sipCpp = reinterpret_cast<QGeoLocation *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoLocation));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoLocation* a0;

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

            sipRes = sipCpp->QGeoLocation::operator!=(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,ne_slot,sipType_QGeoLocation,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoLocation___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGeoLocation___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoLocation *sipCpp = reinterpret_cast<QGeoLocation *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoLocation));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoLocation* a0;

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

            sipRes = sipCpp->QGeoLocation::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,eq_slot,sipType_QGeoLocation,sipSelf,sipArg);
}


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

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoLocation(void *, int);}
static void release_QGeoLocation(void *sipCppV,int)
{
    delete reinterpret_cast<QGeoLocation *>(sipCppV);
}


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


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


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


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


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

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

            return sipCpp;
        }
    }

    {
        const QGeoLocation* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGeoLocation, &a0))
        {
            sipCpp = new QGeoLocation(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGeoLocation[] = {
    {(void *)slot_QGeoLocation___ne__, ne_slot},
    {(void *)slot_QGeoLocation___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QGeoLocation[] = {
    {SIP_MLNAME_CAST(sipName_address), meth_QGeoLocation_address, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoLocation_address)},
    {SIP_MLNAME_CAST(sipName_boundingBox), meth_QGeoLocation_boundingBox, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoLocation_boundingBox)},
    {SIP_MLNAME_CAST(sipName_coordinate), meth_QGeoLocation_coordinate, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoLocation_coordinate)},
    {SIP_MLNAME_CAST(sipName_isEmpty), meth_QGeoLocation_isEmpty, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoLocation_isEmpty)},
    {SIP_MLNAME_CAST(sipName_setAddress), meth_QGeoLocation_setAddress, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoLocation_setAddress)},
    {SIP_MLNAME_CAST(sipName_setBoundingBox), meth_QGeoLocation_setBoundingBox, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoLocation_setBoundingBox)},
    {SIP_MLNAME_CAST(sipName_setCoordinate), meth_QGeoLocation_setCoordinate, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoLocation_setCoordinate)}
};

PyDoc_STRVAR(doc_QGeoLocation, "\1QGeoLocation()\n"
    "QGeoLocation(QGeoLocation)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoLocation = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoLocation,
        {0}
    },
    {
        sipNameNr_QGeoLocation,
        {0, 0, 1},
        7, methods_QGeoLocation,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoLocation,
    sipNameNr_PyQt5_QtCore_pyqtWrapperType,
    -1,
    0,
    slots_QGeoLocation,
    init_type_QGeoLocation,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoLocation,
    assign_QGeoLocation,
    array_QGeoLocation,
    copy_QGeoLocation,
    release_QGeoLocation,
    cast_QGeoLocation,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeocoordinate.sip"
#include <qgeocoordinate.h>
#line 8485 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 8489 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


PyDoc_STRVAR(doc_QGeoCoordinate_isValid, "QGeoCoordinate.isValid() -> bool");

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

    {
        const QGeoCoordinate *sipCpp;

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

            sipRes = sipCpp->isValid();

            return PyBool_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCoordinate_type, "QGeoCoordinate.type() -> QGeoCoordinate.CoordinateType");

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

    {
        const QGeoCoordinate *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoCoordinate, &sipCpp))
        {
            QGeoCoordinate::CoordinateType sipRes;

            sipRes = sipCpp->type();

            return sipConvertFromEnum(sipRes,sipType_QGeoCoordinate_CoordinateType);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCoordinate, sipName_type, doc_QGeoCoordinate_type);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCoordinate_setLatitude, "QGeoCoordinate.setLatitude(float)");

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

    {
        double a0;
        QGeoCoordinate *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bd", &sipSelf, sipType_QGeoCoordinate, &sipCpp, &a0))
        {
            sipCpp->setLatitude(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCoordinate, sipName_setLatitude, doc_QGeoCoordinate_setLatitude);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCoordinate_latitude, "QGeoCoordinate.latitude() -> float");

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

    {
        const QGeoCoordinate *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoCoordinate, &sipCpp))
        {
            double sipRes;

            sipRes = sipCpp->latitude();

            return PyFloat_FromDouble(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCoordinate, sipName_latitude, doc_QGeoCoordinate_latitude);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCoordinate_setLongitude, "QGeoCoordinate.setLongitude(float)");

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

    {
        double a0;
        QGeoCoordinate *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bd", &sipSelf, sipType_QGeoCoordinate, &sipCpp, &a0))
        {
            sipCpp->setLongitude(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCoordinate, sipName_setLongitude, doc_QGeoCoordinate_setLongitude);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCoordinate_longitude, "QGeoCoordinate.longitude() -> float");

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

    {
        const QGeoCoordinate *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoCoordinate, &sipCpp))
        {
            double sipRes;

            sipRes = sipCpp->longitude();

            return PyFloat_FromDouble(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCoordinate, sipName_longitude, doc_QGeoCoordinate_longitude);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCoordinate_setAltitude, "QGeoCoordinate.setAltitude(float)");

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

    {
        double a0;
        QGeoCoordinate *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bd", &sipSelf, sipType_QGeoCoordinate, &sipCpp, &a0))
        {
            sipCpp->setAltitude(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCoordinate, sipName_setAltitude, doc_QGeoCoordinate_setAltitude);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCoordinate_altitude, "QGeoCoordinate.altitude() -> float");

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

    {
        const QGeoCoordinate *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoCoordinate, &sipCpp))
        {
            double sipRes;

            sipRes = sipCpp->altitude();

            return PyFloat_FromDouble(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCoordinate, sipName_altitude, doc_QGeoCoordinate_altitude);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCoordinate_distanceTo, "QGeoCoordinate.distanceTo(QGeoCoordinate) -> float");

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

    {
        const QGeoCoordinate* a0;
        const QGeoCoordinate *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoCoordinate, &sipCpp, sipType_QGeoCoordinate, &a0))
        {
            qreal sipRes;

            sipRes = sipCpp->distanceTo(*a0);

            return PyFloat_FromDouble(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCoordinate, sipName_distanceTo, doc_QGeoCoordinate_distanceTo);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCoordinate_azimuthTo, "QGeoCoordinate.azimuthTo(QGeoCoordinate) -> float");

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

    {
        const QGeoCoordinate* a0;
        const QGeoCoordinate *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoCoordinate, &sipCpp, sipType_QGeoCoordinate, &a0))
        {
            qreal sipRes;

            sipRes = sipCpp->azimuthTo(*a0);

            return PyFloat_FromDouble(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCoordinate, sipName_azimuthTo, doc_QGeoCoordinate_azimuthTo);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCoordinate_atDistanceAndAzimuth, "QGeoCoordinate.atDistanceAndAzimuth(float, float, float distanceUp=0) -> QGeoCoordinate");

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

    {
        qreal a0;
        qreal a1;
        qreal a2 = 0;
        const QGeoCoordinate *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bdd|d", &sipSelf, sipType_QGeoCoordinate, &sipCpp, &a0, &a1, &a2))
        {
            QGeoCoordinate*sipRes;

            sipRes = new QGeoCoordinate(sipCpp->atDistanceAndAzimuth(a0,a1,a2));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCoordinate, sipName_atDistanceAndAzimuth, doc_QGeoCoordinate_atDistanceAndAzimuth);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCoordinate_toString, "QGeoCoordinate.toString(QGeoCoordinate.CoordinateFormat format=QGeoCoordinate.DegreesMinutesSecondsWithHemisphere) -> str");

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

    {
        QGeoCoordinate::CoordinateFormat a0 = QGeoCoordinate::DegreesMinutesSecondsWithHemisphere;
        const QGeoCoordinate *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|E", &sipSelf, sipType_QGeoCoordinate, &sipCpp, sipType_QGeoCoordinate_CoordinateFormat, &a0))
        {
            QString*sipRes;

            sipRes = new QString(sipCpp->toString(a0));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCoordinate, sipName_toString, doc_QGeoCoordinate_toString);

    return NULL;
}


extern "C" {static PyObject *slot_QGeoCoordinate___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGeoCoordinate___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoCoordinate *sipCpp = reinterpret_cast<QGeoCoordinate *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoCoordinate));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoCoordinate* a0;

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

            sipRes = sipCpp->QGeoCoordinate::operator!=(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,ne_slot,sipType_QGeoCoordinate,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoCoordinate___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGeoCoordinate___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoCoordinate *sipCpp = reinterpret_cast<QGeoCoordinate *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoCoordinate));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoCoordinate* a0;

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

            sipRes = sipCpp->QGeoCoordinate::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,eq_slot,sipType_QGeoCoordinate,sipSelf,sipArg);
}


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

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoCoordinate(void *, int);}
static void release_QGeoCoordinate(void *sipCppV,int)
{
    delete reinterpret_cast<QGeoCoordinate *>(sipCppV);
}


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


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


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


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


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

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

            return sipCpp;
        }
    }

    {
        double a0;
        double a1;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "dd", &a0, &a1))
        {
            sipCpp = new QGeoCoordinate(a0,a1);

            return sipCpp;
        }
    }

    {
        double a0;
        double a1;
        double a2;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "ddd", &a0, &a1, &a2))
        {
            sipCpp = new QGeoCoordinate(a0,a1,a2);

            return sipCpp;
        }
    }

    {
        const QGeoCoordinate* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGeoCoordinate, &a0))
        {
            sipCpp = new QGeoCoordinate(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGeoCoordinate[] = {
    {(void *)slot_QGeoCoordinate___ne__, ne_slot},
    {(void *)slot_QGeoCoordinate___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QGeoCoordinate[] = {
    {SIP_MLNAME_CAST(sipName_altitude), meth_QGeoCoordinate_altitude, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCoordinate_altitude)},
    {SIP_MLNAME_CAST(sipName_atDistanceAndAzimuth), (PyCFunction)meth_QGeoCoordinate_atDistanceAndAzimuth, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGeoCoordinate_atDistanceAndAzimuth)},
    {SIP_MLNAME_CAST(sipName_azimuthTo), meth_QGeoCoordinate_azimuthTo, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCoordinate_azimuthTo)},
    {SIP_MLNAME_CAST(sipName_distanceTo), meth_QGeoCoordinate_distanceTo, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCoordinate_distanceTo)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QGeoCoordinate_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCoordinate_isValid)},
    {SIP_MLNAME_CAST(sipName_latitude), meth_QGeoCoordinate_latitude, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCoordinate_latitude)},
    {SIP_MLNAME_CAST(sipName_longitude), meth_QGeoCoordinate_longitude, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCoordinate_longitude)},
    {SIP_MLNAME_CAST(sipName_setAltitude), meth_QGeoCoordinate_setAltitude, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCoordinate_setAltitude)},
    {SIP_MLNAME_CAST(sipName_setLatitude), meth_QGeoCoordinate_setLatitude, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCoordinate_setLatitude)},
    {SIP_MLNAME_CAST(sipName_setLongitude), meth_QGeoCoordinate_setLongitude, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCoordinate_setLongitude)},
    {SIP_MLNAME_CAST(sipName_toString), (PyCFunction)meth_QGeoCoordinate_toString, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGeoCoordinate_toString)},
    {SIP_MLNAME_CAST(sipName_type), meth_QGeoCoordinate_type, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCoordinate_type)}
};

static sipEnumMemberDef enummembers_QGeoCoordinate[] = {
    {sipName_Coordinate2D, static_cast<int>(QGeoCoordinate::Coordinate2D), 9},
    {sipName_Coordinate3D, static_cast<int>(QGeoCoordinate::Coordinate3D), 9},
    {sipName_Degrees, static_cast<int>(QGeoCoordinate::Degrees), 8},
    {sipName_DegreesMinutes, static_cast<int>(QGeoCoordinate::DegreesMinutes), 8},
    {sipName_DegreesMinutesSeconds, static_cast<int>(QGeoCoordinate::DegreesMinutesSeconds), 8},
    {sipName_DegreesMinutesSecondsWithHemisphere, static_cast<int>(QGeoCoordinate::DegreesMinutesSecondsWithHemisphere), 8},
    {sipName_DegreesMinutesWithHemisphere, static_cast<int>(QGeoCoordinate::DegreesMinutesWithHemisphere), 8},
    {sipName_DegreesWithHemisphere, static_cast<int>(QGeoCoordinate::DegreesWithHemisphere), 8},
    {sipName_InvalidCoordinate, static_cast<int>(QGeoCoordinate::InvalidCoordinate), 9},
};

PyDoc_STRVAR(doc_QGeoCoordinate, "\1QGeoCoordinate()\n"
    "QGeoCoordinate(float, float)\n"
    "QGeoCoordinate(float, float, float)\n"
    "QGeoCoordinate(QGeoCoordinate)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoCoordinate = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoCoordinate,
        {0}
    },
    {
        sipNameNr_QGeoCoordinate,
        {0, 0, 1},
        12, methods_QGeoCoordinate,
        9, enummembers_QGeoCoordinate,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoCoordinate,
    sipNameNr_PyQt5_QtCore_pyqtWrapperType,
    -1,
    0,
    slots_QGeoCoordinate,
    init_type_QGeoCoordinate,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoCoordinate,
    assign_QGeoCoordinate,
    array_QGeoCoordinate,
    copy_QGeoCoordinate,
    release_QGeoCoordinate,
    cast_QGeoCoordinate,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeocircle.sip"
#include <qgeocircle.h>
#line 9098 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeocoordinate.sip"
#include <qgeocoordinate.h>
#line 9102 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoshape.sip"
#include <qgeoshape.h>
#line 9105 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


PyDoc_STRVAR(doc_QGeoCircle_setCenter, "QGeoCircle.setCenter(QGeoCoordinate)");

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

    {
        const QGeoCoordinate* a0;
        QGeoCircle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoCircle, &sipCpp, sipType_QGeoCoordinate, &a0))
        {
            sipCpp->setCenter(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCircle, sipName_setCenter, doc_QGeoCircle_setCenter);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCircle_center, "QGeoCircle.center() -> QGeoCoordinate");

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

    {
        const QGeoCircle *sipCpp;

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

            sipRes = new QGeoCoordinate(sipCpp->center());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCircle, sipName_center, doc_QGeoCircle_center);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCircle_setRadius, "QGeoCircle.setRadius(float)");

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

    {
        qreal a0;
        QGeoCircle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bd", &sipSelf, sipType_QGeoCircle, &sipCpp, &a0))
        {
            sipCpp->setRadius(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCircle, sipName_setRadius, doc_QGeoCircle_setRadius);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCircle_radius, "QGeoCircle.radius() -> float");

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

    {
        const QGeoCircle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoCircle, &sipCpp))
        {
            qreal sipRes;

            sipRes = sipCpp->radius();

            return PyFloat_FromDouble(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCircle, sipName_radius, doc_QGeoCircle_radius);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCircle_translate, "QGeoCircle.translate(float, float)");

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

    {
        double a0;
        double a1;
        QGeoCircle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bdd", &sipSelf, sipType_QGeoCircle, &sipCpp, &a0, &a1))
        {
            sipCpp->translate(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCircle, sipName_translate, doc_QGeoCircle_translate);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoCircle_translated, "QGeoCircle.translated(float, float) -> QGeoCircle");

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

    {
        double a0;
        double a1;
        const QGeoCircle *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bdd", &sipSelf, sipType_QGeoCircle, &sipCpp, &a0, &a1))
        {
            QGeoCircle*sipRes;

            sipRes = new QGeoCircle(sipCpp->translated(a0,a1));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoCircle, sipName_translated, doc_QGeoCircle_translated);

    return NULL;
}


extern "C" {static PyObject *slot_QGeoCircle___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGeoCircle___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoCircle *sipCpp = reinterpret_cast<QGeoCircle *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoCircle));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoCircle* a0;

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

            sipRes = sipCpp->QGeoCircle::operator!=(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,ne_slot,sipType_QGeoCircle,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoCircle___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGeoCircle___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoCircle *sipCpp = reinterpret_cast<QGeoCircle *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoCircle));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoCircle* a0;

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

            sipRes = sipCpp->QGeoCircle::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,eq_slot,sipType_QGeoCircle,sipSelf,sipArg);
}


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

    if (targetType == sipType_QGeoCircle)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QGeoShape)->ctd_cast((QGeoShape *)(QGeoCircle *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoCircle(void *, int);}
static void release_QGeoCircle(void *sipCppV,int)
{
    delete reinterpret_cast<QGeoCircle *>(sipCppV);
}


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


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


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


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


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

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

            return sipCpp;
        }
    }

    {
        const QGeoCoordinate* a0;
        qreal a1 = -1;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9|d", sipType_QGeoCoordinate, &a0, &a1))
        {
            sipCpp = new QGeoCircle(*a0,a1);

            return sipCpp;
        }
    }

    {
        const QGeoCircle* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGeoCircle, &a0))
        {
            sipCpp = new QGeoCircle(*a0);

            return sipCpp;
        }
    }

    {
        const QGeoShape* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGeoShape, &a0))
        {
            sipCpp = new QGeoCircle(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


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


/* Define this type's Python slots. */
static sipPySlotDef slots_QGeoCircle[] = {
    {(void *)slot_QGeoCircle___ne__, ne_slot},
    {(void *)slot_QGeoCircle___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QGeoCircle[] = {
    {SIP_MLNAME_CAST(sipName_center), meth_QGeoCircle_center, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCircle_center)},
    {SIP_MLNAME_CAST(sipName_radius), meth_QGeoCircle_radius, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCircle_radius)},
    {SIP_MLNAME_CAST(sipName_setCenter), meth_QGeoCircle_setCenter, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCircle_setCenter)},
    {SIP_MLNAME_CAST(sipName_setRadius), meth_QGeoCircle_setRadius, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCircle_setRadius)},
    {SIP_MLNAME_CAST(sipName_translate), meth_QGeoCircle_translate, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCircle_translate)},
    {SIP_MLNAME_CAST(sipName_translated), meth_QGeoCircle_translated, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoCircle_translated)}
};

PyDoc_STRVAR(doc_QGeoCircle, "\1QGeoCircle()\n"
    "QGeoCircle(QGeoCoordinate, float radius=-1)\n"
    "QGeoCircle(QGeoCircle)\n"
    "QGeoCircle(QGeoShape)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoCircle = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoCircle,
        {0}
    },
    {
        sipNameNr_QGeoCircle,
        {0, 0, 1},
        6, methods_QGeoCircle,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoCircle,
    -1,
    -1,
    supers_QGeoCircle,
    slots_QGeoCircle,
    init_type_QGeoCircle,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoCircle,
    assign_QGeoCircle,
    array_QGeoCircle,
    copy_QGeoCircle,
    release_QGeoCircle,
    cast_QGeoCircle,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoshape.sip"
#include <qgeoshape.h>
#line 9533 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeocoordinate.sip"
#include <qgeocoordinate.h>
#line 9537 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


PyDoc_STRVAR(doc_QGeoShape_type, "QGeoShape.type() -> QGeoShape.ShapeType");

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

    {
        const QGeoShape *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoShape, &sipCpp))
        {
            QGeoShape::ShapeType sipRes;

            sipRes = sipCpp->type();

            return sipConvertFromEnum(sipRes,sipType_QGeoShape_ShapeType);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoShape, sipName_type, doc_QGeoShape_type);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoShape_isValid, "QGeoShape.isValid() -> bool");

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

    {
        const QGeoShape *sipCpp;

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

            sipRes = sipCpp->isValid();

            return PyBool_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QGeoShape_isEmpty, "QGeoShape.isEmpty() -> bool");

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

    {
        const QGeoShape *sipCpp;

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

            sipRes = sipCpp->isEmpty();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoShape, sipName_isEmpty, doc_QGeoShape_isEmpty);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoShape_contains, "QGeoShape.contains(QGeoCoordinate) -> bool");

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

    {
        const QGeoCoordinate* a0;
        const QGeoShape *sipCpp;

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

            sipRes = sipCpp->contains(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoShape, sipName_contains, doc_QGeoShape_contains);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoShape_extendShape, "QGeoShape.extendShape(QGeoCoordinate)");

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

    {
        const QGeoCoordinate* a0;
        QGeoShape *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoShape, &sipCpp, sipType_QGeoCoordinate, &a0))
        {
            sipCpp->extendShape(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoShape, sipName_extendShape, doc_QGeoShape_extendShape);

    return NULL;
}


extern "C" {static PyObject *slot_QGeoShape___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGeoShape___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoShape *sipCpp = reinterpret_cast<QGeoShape *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoShape));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoShape* a0;

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

            sipRes = sipCpp->QGeoShape::operator!=(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,ne_slot,sipType_QGeoShape,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoShape___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGeoShape___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoShape *sipCpp = reinterpret_cast<QGeoShape *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoShape));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoShape* a0;

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

            sipRes = sipCpp->QGeoShape::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,eq_slot,sipType_QGeoShape,sipSelf,sipArg);
}


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

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoShape(void *, int);}
static void release_QGeoShape(void *sipCppV,int)
{
    delete reinterpret_cast<QGeoShape *>(sipCppV);
}


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


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


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


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


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

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

            return sipCpp;
        }
    }

    {
        const QGeoShape* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGeoShape, &a0))
        {
            sipCpp = new QGeoShape(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGeoShape[] = {
    {(void *)slot_QGeoShape___ne__, ne_slot},
    {(void *)slot_QGeoShape___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QGeoShape[] = {
    {SIP_MLNAME_CAST(sipName_contains), meth_QGeoShape_contains, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoShape_contains)},
    {SIP_MLNAME_CAST(sipName_extendShape), meth_QGeoShape_extendShape, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoShape_extendShape)},
    {SIP_MLNAME_CAST(sipName_isEmpty), meth_QGeoShape_isEmpty, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoShape_isEmpty)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QGeoShape_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoShape_isValid)},
    {SIP_MLNAME_CAST(sipName_type), meth_QGeoShape_type, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoShape_type)}
};

static sipEnumMemberDef enummembers_QGeoShape[] = {
    {sipName_CircleType, static_cast<int>(QGeoShape::CircleType), 24},
    {sipName_RectangleType, static_cast<int>(QGeoShape::RectangleType), 24},
    {sipName_UnknownType, static_cast<int>(QGeoShape::UnknownType), 24},
};

PyDoc_STRVAR(doc_QGeoShape, "\1QGeoShape()\n"
    "QGeoShape(QGeoShape)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoShape = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoShape,
        {0}
    },
    {
        sipNameNr_QGeoShape,
        {0, 0, 1},
        5, methods_QGeoShape,
        3, enummembers_QGeoShape,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoShape,
    sipNameNr_PyQt5_QtCore_pyqtWrapperType,
    -1,
    0,
    slots_QGeoShape,
    init_type_QGeoShape,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoShape,
    assign_QGeoShape,
    array_QGeoShape,
    copy_QGeoShape,
    release_QGeoShape,
    cast_QGeoShape,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoareamonitorsource.sip"
#include <qgeoareamonitorsource.h>
#line 9902 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoareamonitorsource.sip"
#include <qgeoareamonitorsource.h>
#line 9906 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


extern "C" {static int slot_QGeoAreaMonitorSource_AreaMonitorFeatures___bool__(PyObject *);}
static int slot_QGeoAreaMonitorSource_AreaMonitorFeatures___bool__(PyObject *sipSelf)
{
    QGeoAreaMonitorSource::AreaMonitorFeatures *sipCpp = reinterpret_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures));

    if (!sipCpp)
        return -1;


    {
        {
            int sipRes = 0;

#line 119 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QGeoAreaMonitorSource::AreaMonitorFeatures::Int() != 0);
#line 9924 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoAreaMonitorSource::AreaMonitorFeatures *sipCpp = reinterpret_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoAreaMonitorSource::AreaMonitorFeatures* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, &a0, &a0State))
        {
            bool sipRes = 0;

#line 114 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QGeoAreaMonitorSource::AreaMonitorFeatures::Int() != a0->operator QGeoAreaMonitorSource::AreaMonitorFeatures::Int());
#line 9954 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
            sipReleaseType(const_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(a0),sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,ne_slot,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoAreaMonitorSource::AreaMonitorFeatures *sipCpp = reinterpret_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoAreaMonitorSource::AreaMonitorFeatures* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, &a0, &a0State))
        {
            bool sipRes = 0;

#line 109 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QGeoAreaMonitorSource::AreaMonitorFeatures::Int() == a0->operator QGeoAreaMonitorSource::AreaMonitorFeatures::Int());
#line 9990 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
            sipReleaseType(const_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(a0),sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,eq_slot,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___invert__(PyObject *);}
static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___invert__(PyObject *sipSelf)
{
    QGeoAreaMonitorSource::AreaMonitorFeatures *sipCpp = reinterpret_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures));

    if (!sipCpp)
        return 0;


    {
        {
            QGeoAreaMonitorSource::AreaMonitorFeatures*sipRes;

            sipRes = new QGeoAreaMonitorSource::AreaMonitorFeatures(~(*sipCpp));

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

    return 0;
}


extern "C" {static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___and__(PyObject *,PyObject *);}
static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___and__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QGeoAreaMonitorSource::AreaMonitorFeatures* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, &a0, &a0State, &a1))
        {
            QGeoAreaMonitorSource::AreaMonitorFeatures*sipRes;

            sipRes = new QGeoAreaMonitorSource::AreaMonitorFeatures((*a0 & a1));
            sipReleaseType(a0,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,and_slot,NULL,sipArg0,sipArg1);
}


extern "C" {static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___xor__(PyObject *,PyObject *);}
static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___xor__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QGeoAreaMonitorSource::AreaMonitorFeatures* a0;
        int a0State = 0;
        QGeoAreaMonitorSource::AreaMonitorFeatures* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1J1", sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, &a0, &a0State, sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, &a1, &a1State))
        {
            QGeoAreaMonitorSource::AreaMonitorFeatures*sipRes;

            sipRes = new QGeoAreaMonitorSource::AreaMonitorFeatures((*a0 ^ *a1));
            sipReleaseType(a0,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,a0State);
            sipReleaseType(a1,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,a1State);

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

    {
        QGeoAreaMonitorSource::AreaMonitorFeatures* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, &a0, &a0State, &a1))
        {
            QGeoAreaMonitorSource::AreaMonitorFeatures*sipRes = 0;

#line 103 "sip/QtCore/qglobal.sip"
        sipRes = new QGeoAreaMonitorSource::AreaMonitorFeatures(*a0 ^ a1);
#line 10093 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
            sipReleaseType(a0,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,xor_slot,NULL,sipArg0,sipArg1);
}


extern "C" {static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___or__(PyObject *,PyObject *);}
static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QGeoAreaMonitorSource::AreaMonitorFeatures* a0;
        int a0State = 0;
        QGeoAreaMonitorSource::AreaMonitorFeatures* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1J1", sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, &a0, &a0State, sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, &a1, &a1State))
        {
            QGeoAreaMonitorSource::AreaMonitorFeatures*sipRes;

            sipRes = new QGeoAreaMonitorSource::AreaMonitorFeatures((*a0 | *a1));
            sipReleaseType(a0,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,a0State);
            sipReleaseType(a1,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,a1State);

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

    {
        QGeoAreaMonitorSource::AreaMonitorFeatures* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, &a0, &a0State, &a1))
        {
            QGeoAreaMonitorSource::AreaMonitorFeatures*sipRes = 0;

#line 98 "sip/QtCore/qglobal.sip"
        sipRes = new QGeoAreaMonitorSource::AreaMonitorFeatures(*a0 | a1);
#line 10143 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
            sipReleaseType(a0,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,or_slot,NULL,sipArg0,sipArg1);
}


extern "C" {static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___int__(PyObject *);}
static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___int__(PyObject *sipSelf)
{
    QGeoAreaMonitorSource::AreaMonitorFeatures *sipCpp = reinterpret_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures));

    if (!sipCpp)
        return 0;


    {
        {
            int sipRes;

            sipRes = *sipCpp;

            return SIPLong_FromLong(sipRes);
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___ixor__(PyObject *,PyObject *);}
static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGeoAreaMonitorSource_AreaMonitorFeatures)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    QGeoAreaMonitorSource::AreaMonitorFeatures *sipCpp = reinterpret_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        QGeoAreaMonitorSource::AreaMonitorFeatures* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, &a0, &a0State))
        {
            sipCpp->QGeoAreaMonitorSource::AreaMonitorFeatures::operator^=(*a0);
            sipReleaseType(a0,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,a0State);

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___ior__(PyObject *,PyObject *);}
static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___ior__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGeoAreaMonitorSource_AreaMonitorFeatures)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    QGeoAreaMonitorSource::AreaMonitorFeatures *sipCpp = reinterpret_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        QGeoAreaMonitorSource::AreaMonitorFeatures* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, &a0, &a0State))
        {
            sipCpp->QGeoAreaMonitorSource::AreaMonitorFeatures::operator|=(*a0);
            sipReleaseType(a0,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,a0State);

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___iand__(PyObject *,PyObject *);}
static PyObject *slot_QGeoAreaMonitorSource_AreaMonitorFeatures___iand__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGeoAreaMonitorSource_AreaMonitorFeatures)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    QGeoAreaMonitorSource::AreaMonitorFeatures *sipCpp = reinterpret_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoAreaMonitorSource_AreaMonitorFeatures));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            sipCpp->QGeoAreaMonitorSource::AreaMonitorFeatures::operator&=(a0);

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


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

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoAreaMonitorSource_AreaMonitorFeatures(void *, int);}
static void release_QGeoAreaMonitorSource_AreaMonitorFeatures(void *sipCppV,int)
{
    delete reinterpret_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipCppV);
}


extern "C" {static void assign_QGeoAreaMonitorSource_AreaMonitorFeatures(void *, SIP_SSIZE_T, const void *);}
static void assign_QGeoAreaMonitorSource_AreaMonitorFeatures(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipSrc);
}


extern "C" {static void *array_QGeoAreaMonitorSource_AreaMonitorFeatures(SIP_SSIZE_T);}
static void *array_QGeoAreaMonitorSource_AreaMonitorFeatures(SIP_SSIZE_T sipNrElem)
{
    return new QGeoAreaMonitorSource::AreaMonitorFeatures[sipNrElem];
}


extern "C" {static void *copy_QGeoAreaMonitorSource_AreaMonitorFeatures(const void *, SIP_SSIZE_T);}
static void *copy_QGeoAreaMonitorSource_AreaMonitorFeatures(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QGeoAreaMonitorSource::AreaMonitorFeatures(reinterpret_cast<const QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipSrc)[sipSrcIdx]);
}


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


extern "C" {static void *init_type_QGeoAreaMonitorSource_AreaMonitorFeatures(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGeoAreaMonitorSource_AreaMonitorFeatures(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QGeoAreaMonitorSource::AreaMonitorFeatures *sipCpp = 0;

    {
        const QGeoAreaMonitorSource::AreaMonitorFeatures* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, &a0, &a0State))
        {
            sipCpp = new QGeoAreaMonitorSource::AreaMonitorFeatures(*a0);
            sipReleaseType(const_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(a0),sipType_QGeoAreaMonitorSource_AreaMonitorFeatures,a0State);

            return sipCpp;
        }
    }

    {
        int a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "i", &a0))
        {
            sipCpp = new QGeoAreaMonitorSource::AreaMonitorFeatures(a0);

            return sipCpp;
        }
    }

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new QGeoAreaMonitorSource::AreaMonitorFeatures();

            return sipCpp;
        }
    }

    return NULL;
}


extern "C" {static int convertTo_QGeoAreaMonitorSource_AreaMonitorFeatures(PyObject *, void **, int *, PyObject *);}
static int convertTo_QGeoAreaMonitorSource_AreaMonitorFeatures(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QGeoAreaMonitorSource::AreaMonitorFeatures **sipCppPtr = reinterpret_cast<QGeoAreaMonitorSource::AreaMonitorFeatures **>(sipCppPtrV);

#line 124 "sip/QtCore/qglobal.sip"
// Allow an instance of the base enum whenever a QGeoAreaMonitorSource::AreaMonitorFeatures is expected.

if (sipIsErr == NULL)
    return (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QGeoAreaMonitorSource_AreaMonitorFeature)) ||
            sipCanConvertToType(sipPy, sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, SIP_NO_CONVERTORS));

if (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QGeoAreaMonitorSource_AreaMonitorFeature)))
{
    *sipCppPtr = new QGeoAreaMonitorSource::AreaMonitorFeatures(int(SIPLong_AsLong(sipPy)));

    return sipGetState(sipTransferObj);
}

*sipCppPtr = reinterpret_cast<QGeoAreaMonitorSource::AreaMonitorFeatures *>(sipConvertToType(sipPy, sipType_QGeoAreaMonitorSource_AreaMonitorFeatures, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr));

return 0;
#line 10420 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGeoAreaMonitorSource_AreaMonitorFeatures[] = {
    {(void *)slot_QGeoAreaMonitorSource_AreaMonitorFeatures___bool__, bool_slot},
    {(void *)slot_QGeoAreaMonitorSource_AreaMonitorFeatures___ne__, ne_slot},
    {(void *)slot_QGeoAreaMonitorSource_AreaMonitorFeatures___eq__, eq_slot},
    {(void *)slot_QGeoAreaMonitorSource_AreaMonitorFeatures___invert__, invert_slot},
    {(void *)slot_QGeoAreaMonitorSource_AreaMonitorFeatures___and__, and_slot},
    {(void *)slot_QGeoAreaMonitorSource_AreaMonitorFeatures___xor__, xor_slot},
    {(void *)slot_QGeoAreaMonitorSource_AreaMonitorFeatures___or__, or_slot},
    {(void *)slot_QGeoAreaMonitorSource_AreaMonitorFeatures___int__, int_slot},
    {(void *)slot_QGeoAreaMonitorSource_AreaMonitorFeatures___ixor__, ixor_slot},
    {(void *)slot_QGeoAreaMonitorSource_AreaMonitorFeatures___ior__, ior_slot},
    {(void *)slot_QGeoAreaMonitorSource_AreaMonitorFeatures___iand__, iand_slot},
    {0, (sipPySlotType)0}
};

PyDoc_STRVAR(doc_QGeoAreaMonitorSource_AreaMonitorFeatures, "\1QGeoAreaMonitorSource.AreaMonitorFeatures(QGeoAreaMonitorSource.AreaMonitorFeatures)\n"
    "QGeoAreaMonitorSource.AreaMonitorFeatures(int)\n"
    "QGeoAreaMonitorSource.AreaMonitorFeatures()");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoAreaMonitorSource_AreaMonitorFeatures = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoAreaMonitorSource__AreaMonitorFeatures,
        {0}
    },
    {
        sipNameNr_AreaMonitorFeatures,
        {2, 255, 0},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoAreaMonitorSource_AreaMonitorFeatures,
    sipNameNr_PyQt5_QtCore_pyqtWrapperType,
    -1,
    0,
    slots_QGeoAreaMonitorSource_AreaMonitorFeatures,
    init_type_QGeoAreaMonitorSource_AreaMonitorFeatures,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoAreaMonitorSource_AreaMonitorFeatures,
    assign_QGeoAreaMonitorSource_AreaMonitorFeatures,
    array_QGeoAreaMonitorSource_AreaMonitorFeatures,
    copy_QGeoAreaMonitorSource_AreaMonitorFeatures,
    release_QGeoAreaMonitorSource_AreaMonitorFeatures,
    cast_QGeoAreaMonitorSource_AreaMonitorFeatures,
    convertTo_QGeoAreaMonitorSource_AreaMonitorFeatures,
    0,
    0,
    0,
    0,
    0
},
    0,
    1,
    0,
    0
};

#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoareamonitorsource.sip"
#include <qgeoareamonitorsource.h>
#line 10502 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 10506 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoareamonitorinfo.sip"
#include <qgeoareamonitorinfo.h>
#line 10509 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfo.sip"
#include <qgeopositioninfo.h>
#line 10512 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 10515 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoshape.sip"
#include <qgeoshape.h>
#line 10518 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoareamonitorsource.sip"
#include <qgeoareamonitorsource.h>
#line 10521 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 10524 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeopositioninfosource.sip"
#include <qgeopositioninfosource.h>
#line 10527 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 10530 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 10533 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 10536 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 241 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 10539 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 229 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 10542 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 10545 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 10548 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 32 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 10551 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 144 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 10554 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 10557 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 10560 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 10563 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 10566 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 10569 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 10572 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


class sipQGeoAreaMonitorSource : public QGeoAreaMonitorSource
{
public:
    sipQGeoAreaMonitorSource(QObject*);
    virtual ~sipQGeoAreaMonitorSource();

    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 QMetaMethod&);
    void sipProtectVirt_disconnectNotify(bool,const QMetaMethod&);
    int sipProtect_senderSignalIndex() const;
    bool sipProtect_isSignalConnected(const QMetaMethod&) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const QMetaMethod&);
    void connectNotify(const QMetaMethod&);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);
    QList<QGeoAreaMonitorInfo> activeMonitors(const QGeoShape&) const;
    QList<QGeoAreaMonitorInfo> activeMonitors() const;
    bool requestUpdate(const QGeoAreaMonitorInfo&,const char*);
    bool stopMonitoring(const QGeoAreaMonitorInfo&);
    bool startMonitoring(const QGeoAreaMonitorInfo&);
    QGeoAreaMonitorSource::AreaMonitorFeatures supportedAreaMonitorFeatures() const;
    QGeoAreaMonitorSource::Error error() const;
    QGeoPositionInfoSource* positionInfoSource() const;
    void setPositionInfoSource(QGeoPositionInfoSource*);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[16];
};

sipQGeoAreaMonitorSource::sipQGeoAreaMonitorSource(QObject*a0): QGeoAreaMonitorSource(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

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

const QMetaObject *sipQGeoAreaMonitorSource::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtPositioning_qt_metaobject(sipPySelf,sipType_QGeoAreaMonitorSource);
}

int sipQGeoAreaMonitorSource::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = QGeoAreaMonitorSource::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtPositioning_qt_metacall(sipPySelf,sipType_QGeoAreaMonitorSource,_c,_id,_a);

    return _id;
}

void *sipQGeoAreaMonitorSource::qt_metacast(const char *_clname)
{
    void *sipCpp;

    return (sip_QtPositioning_qt_metacast(sipPySelf, sipType_QGeoAreaMonitorSource, _clname, &sipCpp) ? sipCpp : QGeoAreaMonitorSource::qt_metacast(_clname));
}

void sipQGeoAreaMonitorSource::disconnectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoAreaMonitorSource::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoAreaMonitorSource::connectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoAreaMonitorSource::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoAreaMonitorSource::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoAreaMonitorSource::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[25]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoAreaMonitorSource::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoAreaMonitorSource::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_47)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_47)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[47]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQGeoAreaMonitorSource::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
        QGeoAreaMonitorSource::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[9]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipQGeoAreaMonitorSource::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return QGeoAreaMonitorSource::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_26)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_26)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[26]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1);
}

bool sipQGeoAreaMonitorSource::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return QGeoAreaMonitorSource::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtPositioning_QtCore->em_virthandlers[5]))(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QList<QGeoAreaMonitorInfo> sipQGeoAreaMonitorSource::activeMonitors(const QGeoShape& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[7]),sipPySelf,sipName_QGeoAreaMonitorSource,sipName_activeMonitors);

    if (!sipMeth)
        return QList<QGeoAreaMonitorInfo>();

    extern QList<QGeoAreaMonitorInfo> sipVH_QtPositioning_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QGeoShape&);

    return sipVH_QtPositioning_6(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QList<QGeoAreaMonitorInfo> sipQGeoAreaMonitorSource::activeMonitors() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[8]),sipPySelf,sipName_QGeoAreaMonitorSource,sipName_activeMonitors);

    if (!sipMeth)
        return QList<QGeoAreaMonitorInfo>();

    extern QList<QGeoAreaMonitorInfo> sipVH_QtPositioning_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtPositioning_7(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

bool sipQGeoAreaMonitorSource::requestUpdate(const QGeoAreaMonitorInfo& a0,const char*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[9],sipPySelf,sipName_QGeoAreaMonitorSource,sipName_requestUpdate);

    if (!sipMeth)
        return 0;

    extern bool sipVH_QtPositioning_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QGeoAreaMonitorInfo&,const char*);

    return sipVH_QtPositioning_8(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1);
}

bool sipQGeoAreaMonitorSource::stopMonitoring(const QGeoAreaMonitorInfo& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[10],sipPySelf,sipName_QGeoAreaMonitorSource,sipName_stopMonitoring);

    if (!sipMeth)
        return 0;

    extern bool sipVH_QtPositioning_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QGeoAreaMonitorInfo&);

    return sipVH_QtPositioning_9(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipQGeoAreaMonitorSource::startMonitoring(const QGeoAreaMonitorInfo& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[11],sipPySelf,sipName_QGeoAreaMonitorSource,sipName_startMonitoring);

    if (!sipMeth)
        return 0;

    extern bool sipVH_QtPositioning_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QGeoAreaMonitorInfo&);

    return sipVH_QtPositioning_9(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QGeoAreaMonitorSource::AreaMonitorFeatures sipQGeoAreaMonitorSource::supportedAreaMonitorFeatures() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[12]),sipPySelf,sipName_QGeoAreaMonitorSource,sipName_supportedAreaMonitorFeatures);

    if (!sipMeth)
        return QGeoAreaMonitorSource::AreaMonitorFeatures();

    extern QGeoAreaMonitorSource::AreaMonitorFeatures sipVH_QtPositioning_10(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtPositioning_10(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

QGeoAreaMonitorSource::Error sipQGeoAreaMonitorSource::error() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[13]),sipPySelf,sipName_QGeoAreaMonitorSource,sipName_error);

    if (!sipMeth)
        return (QGeoAreaMonitorSource::Error)0;

    extern QGeoAreaMonitorSource::Error sipVH_QtPositioning_11(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtPositioning_11(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

QGeoPositionInfoSource* sipQGeoAreaMonitorSource::positionInfoSource() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[14]),sipPySelf,NULL,sipName_positionInfoSource);

    if (!sipMeth)
        return QGeoAreaMonitorSource::positionInfoSource();

    extern QGeoPositionInfoSource* sipVH_QtPositioning_12(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtPositioning_12(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}

void sipQGeoAreaMonitorSource::setPositionInfoSource(QGeoPositionInfoSource*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[15],sipPySelf,NULL,sipName_setPositionInfoSource);

    if (!sipMeth)
    {
        QGeoAreaMonitorSource::setPositionInfoSource(a0);
        return;
    }

    extern void sipVH_QtPositioning_13(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QGeoPositionInfoSource*);

    sipVH_QtPositioning_13(sipGILState, sipModuleAPI_QtPositioning_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QObject* sipQGeoAreaMonitorSource::sipProtect_sender() const
{
    return QObject::sender();
}

int sipQGeoAreaMonitorSource::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipQGeoAreaMonitorSource::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQGeoAreaMonitorSource::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipQGeoAreaMonitorSource::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipQGeoAreaMonitorSource::sipProtectVirt_connectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQGeoAreaMonitorSource::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQGeoAreaMonitorSource::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

bool sipQGeoAreaMonitorSource::sipProtect_isSignalConnected(const QMetaMethod& a0) const
{
    return QObject::isSignalConnected(a0);
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_sender, "QGeoAreaMonitorSource.sender() -> QObject");

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

    {
        const sipQGeoAreaMonitorSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp))
        {
            QObject*sipRes = 0;

#line 546 "sip/QtCore/qobject.sip"
        // 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 (!sipRes)
        {
            typedef QObject *(*qtcore_qobject_sender_t)();
        
            static qtcore_qobject_sender_t qtcore_qobject_sender = 0;
        
            if (!qtcore_qobject_sender)
                qtcore_qobject_sender = (qtcore_qobject_sender_t)sipImportSymbol("qtcore_qobject_sender");
        
            if (qtcore_qobject_sender)
                sipRes = qtcore_qobject_sender();
        }
#line 11007 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_sender, doc_QGeoAreaMonitorSource_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_receivers, "QGeoAreaMonitorSource.receivers(signal) -> int");

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

    {
        PyObject * a0;
        const sipQGeoAreaMonitorSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 575 "sip/QtCore/qobject.sip"
        // We need to handle the signal object.  Import the helper if it hasn't already
        // been done.
        typedef sipErrorState (*pyqt5_get_signal_signature_t)(PyObject *, const QObject *, const QByteArray &);
        
        static pyqt5_get_signal_signature_t pyqt5_get_signal_signature = 0;
        
        if (!pyqt5_get_signal_signature)
            pyqt5_get_signal_signature = (pyqt5_get_signal_signature_t)sipImportSymbol("pyqt5_get_signal_signature");
        
        if (pyqt5_get_signal_signature)
        {
            QByteArray signal_signature;
            
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            if ((sipError = pyqt5_get_signal_signature(a0, sipCpp, signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->receivers(signal_signature.constData());
            }
        #else
            if ((sipError = pyqt5_get_signal_signature(a0, static_cast<const QObject *>(sipCpp), signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->sipProtect_receivers(signal_signature.constData());
            }
        #endif
            else if (sipError == sipErrorContinue)
            {
                sipError = sipBadCallableArg(0, a0);
            }
        }
#line 11066 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_receivers, doc_QGeoAreaMonitorSource_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_timerEvent, "QGeoAreaMonitorSource.timerEvent(QTimerEvent)");

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

    {
        QTimerEvent* a0;
        sipQGeoAreaMonitorSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp, sipType_QTimerEvent, &a0))
        {
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_timerEvent, doc_QGeoAreaMonitorSource_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_childEvent, "QGeoAreaMonitorSource.childEvent(QChildEvent)");

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

    {
        QChildEvent* a0;
        sipQGeoAreaMonitorSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp, sipType_QChildEvent, &a0))
        {
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_childEvent, doc_QGeoAreaMonitorSource_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_customEvent, "QGeoAreaMonitorSource.customEvent(QEvent)");

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

    {
        QEvent* a0;
        sipQGeoAreaMonitorSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp, sipType_QEvent, &a0))
        {
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_customEvent, doc_QGeoAreaMonitorSource_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_connectNotify, "QGeoAreaMonitorSource.connectNotify(QMetaMethod)");

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

    {
        const QMetaMethod* a0;
        sipQGeoAreaMonitorSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_connectNotify, doc_QGeoAreaMonitorSource_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_disconnectNotify, "QGeoAreaMonitorSource.disconnectNotify(QMetaMethod)");

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

    {
        const QMetaMethod* a0;
        sipQGeoAreaMonitorSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_disconnectNotify, doc_QGeoAreaMonitorSource_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_senderSignalIndex, "QGeoAreaMonitorSource.senderSignalIndex() -> int");

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

    {
        const sipQGeoAreaMonitorSource *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_senderSignalIndex, doc_QGeoAreaMonitorSource_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_isSignalConnected, "QGeoAreaMonitorSource.isSignalConnected(QMetaMethod) -> bool");

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

    {
        const QMetaMethod* a0;
        const sipQGeoAreaMonitorSource *sipCpp;

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

            sipRes = sipCpp->sipProtect_isSignalConnected(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_isSignalConnected, doc_QGeoAreaMonitorSource_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_createDefaultSource, "QGeoAreaMonitorSource.createDefaultSource(QObject) -> QGeoAreaMonitorSource");

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

    {
        QObject* a0;
        sipWrapper *sipOwner = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "JH", sipType_QObject, &a0, &sipOwner))
        {
            QGeoAreaMonitorSource*sipRes;

            sipRes = QGeoAreaMonitorSource::createDefaultSource(a0);

            return sipConvertFromNewType(sipRes,sipType_QGeoAreaMonitorSource,(PyObject *)sipOwner);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_createDefaultSource, doc_QGeoAreaMonitorSource_createDefaultSource);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_createSource, "QGeoAreaMonitorSource.createSource(str, QObject) -> QGeoAreaMonitorSource");

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

    {
        const QString* a0;
        int a0State = 0;
        QObject* a1;
        sipWrapper *sipOwner = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J1JH", sipType_QString,&a0, &a0State, sipType_QObject, &a1, &sipOwner))
        {
            QGeoAreaMonitorSource*sipRes;

            sipRes = QGeoAreaMonitorSource::createSource(*a0,a1);
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGeoAreaMonitorSource,(PyObject *)sipOwner);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_createSource, doc_QGeoAreaMonitorSource_createSource);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_availableSources, "QGeoAreaMonitorSource.availableSources() -> list-of-str");

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

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            QStringList*sipRes;

            sipRes = new QStringList(QGeoAreaMonitorSource::availableSources());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_availableSources, doc_QGeoAreaMonitorSource_availableSources);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_setPositionInfoSource, "QGeoAreaMonitorSource.setPositionInfoSource(QGeoPositionInfoSource)");

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

    {
        QGeoPositionInfoSource* a0;
        QGeoAreaMonitorSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ:", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp, sipType_QGeoPositionInfoSource, &a0))
        {
            (sipSelfWasArg ? sipCpp->QGeoAreaMonitorSource::setPositionInfoSource(a0) : sipCpp->setPositionInfoSource(a0));

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_setPositionInfoSource, doc_QGeoAreaMonitorSource_setPositionInfoSource);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_positionInfoSource, "QGeoAreaMonitorSource.positionInfoSource() -> QGeoPositionInfoSource");

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

    {
        const QGeoAreaMonitorSource *sipCpp;

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

            sipRes = (sipSelfWasArg ? sipCpp->QGeoAreaMonitorSource::positionInfoSource() : sipCpp->positionInfoSource());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_positionInfoSource, doc_QGeoAreaMonitorSource_positionInfoSource);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_sourceName, "QGeoAreaMonitorSource.sourceName() -> str");

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

    {
        const QGeoAreaMonitorSource *sipCpp;

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

            sipRes = new QString(sipCpp->sourceName());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_sourceName, doc_QGeoAreaMonitorSource_sourceName);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_error, "QGeoAreaMonitorSource.error() -> QGeoAreaMonitorSource.Error");

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

    {
        const QGeoAreaMonitorSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp))
        {
            QGeoAreaMonitorSource::Error sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoAreaMonitorSource, sipName_error);
                return NULL;
            }

            sipRes = sipCpp->error();

            return sipConvertFromEnum(sipRes,sipType_QGeoAreaMonitorSource_Error);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_error, doc_QGeoAreaMonitorSource_error);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_supportedAreaMonitorFeatures, "QGeoAreaMonitorSource.supportedAreaMonitorFeatures() -> QGeoAreaMonitorSource.AreaMonitorFeatures");

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

    {
        const QGeoAreaMonitorSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp))
        {
            QGeoAreaMonitorSource::AreaMonitorFeatures*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoAreaMonitorSource, sipName_supportedAreaMonitorFeatures);
                return NULL;
            }

            sipRes = new QGeoAreaMonitorSource::AreaMonitorFeatures(sipCpp->supportedAreaMonitorFeatures());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_supportedAreaMonitorFeatures, doc_QGeoAreaMonitorSource_supportedAreaMonitorFeatures);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_startMonitoring, "QGeoAreaMonitorSource.startMonitoring(QGeoAreaMonitorInfo) -> bool");

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

    {
        const QGeoAreaMonitorInfo* a0;
        QGeoAreaMonitorSource *sipCpp;

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

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoAreaMonitorSource, sipName_startMonitoring);
                return NULL;
            }

            sipRes = sipCpp->startMonitoring(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_startMonitoring, doc_QGeoAreaMonitorSource_startMonitoring);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_stopMonitoring, "QGeoAreaMonitorSource.stopMonitoring(QGeoAreaMonitorInfo) -> bool");

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

    {
        const QGeoAreaMonitorInfo* a0;
        QGeoAreaMonitorSource *sipCpp;

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

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoAreaMonitorSource, sipName_stopMonitoring);
                return NULL;
            }

            sipRes = sipCpp->stopMonitoring(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_stopMonitoring, doc_QGeoAreaMonitorSource_stopMonitoring);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_requestUpdate, "QGeoAreaMonitorSource.requestUpdate(QGeoAreaMonitorInfo, str) -> bool");

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

    {
        const QGeoAreaMonitorInfo* a0;
        const char* a1;
        PyObject *a1Keep;
        QGeoAreaMonitorSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9AA", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp, sipType_QGeoAreaMonitorInfo, &a0, &a1Keep, &a1))
        {
            bool sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoAreaMonitorSource, sipName_requestUpdate);
                return NULL;
            }

            sipRes = sipCpp->requestUpdate(*a0,a1);
            Py_DECREF(a1Keep);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_requestUpdate, doc_QGeoAreaMonitorSource_requestUpdate);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorSource_activeMonitors, "QGeoAreaMonitorSource.activeMonitors() -> list-of-QGeoAreaMonitorInfo\n"
    "QGeoAreaMonitorSource.activeMonitors(QGeoShape) -> list-of-QGeoAreaMonitorInfo");

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

    {
        const QGeoAreaMonitorSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp))
        {
            QList<QGeoAreaMonitorInfo>*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoAreaMonitorSource, sipName_activeMonitors);
                return NULL;
            }

            sipRes = new QList<QGeoAreaMonitorInfo>(sipCpp->activeMonitors());

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

    {
        const QGeoShape* a0;
        const QGeoAreaMonitorSource *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoAreaMonitorSource, &sipCpp, sipType_QGeoShape, &a0))
        {
            QList<QGeoAreaMonitorInfo>*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QGeoAreaMonitorSource, sipName_activeMonitors);
                return NULL;
            }

            sipRes = new QList<QGeoAreaMonitorInfo>(sipCpp->activeMonitors(*a0));

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorSource, sipName_activeMonitors, doc_QGeoAreaMonitorSource_activeMonitors);

    return NULL;
}


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

    if (targetType == sipType_QGeoAreaMonitorSource)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(QGeoAreaMonitorSource *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoAreaMonitorSource(void *, int);}
static void release_QGeoAreaMonitorSource(void *sipCppV,int)
{
    QGeoAreaMonitorSource *sipCpp = reinterpret_cast<QGeoAreaMonitorSource *>(sipCppV);

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();
}


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

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


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

    {
        QObject* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "JH", sipType_QObject, &a0, sipOwner))
        {
            sipCpp = new sipQGeoAreaMonitorSource(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QGeoAreaMonitorSource[] = {{162, 0, 1}};


static PyMethodDef methods_QGeoAreaMonitorSource[] = {
    {SIP_MLNAME_CAST(sipName_activeMonitors), meth_QGeoAreaMonitorSource_activeMonitors, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorSource_activeMonitors)},
    {SIP_MLNAME_CAST(sipName_availableSources), meth_QGeoAreaMonitorSource_availableSources, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorSource_availableSources)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QGeoAreaMonitorSource_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QGeoAreaMonitorSource_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_createDefaultSource), meth_QGeoAreaMonitorSource_createDefaultSource, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorSource_createDefaultSource)},
    {SIP_MLNAME_CAST(sipName_createSource), meth_QGeoAreaMonitorSource_createSource, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorSource_createSource)},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QGeoAreaMonitorSource_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QGeoAreaMonitorSource_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_error), meth_QGeoAreaMonitorSource_error, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorSource_error)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QGeoAreaMonitorSource_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_positionInfoSource), meth_QGeoAreaMonitorSource_positionInfoSource, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorSource_positionInfoSource)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QGeoAreaMonitorSource_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_requestUpdate), meth_QGeoAreaMonitorSource_requestUpdate, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorSource_requestUpdate)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QGeoAreaMonitorSource_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QGeoAreaMonitorSource_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setPositionInfoSource), meth_QGeoAreaMonitorSource_setPositionInfoSource, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorSource_setPositionInfoSource)},
    {SIP_MLNAME_CAST(sipName_sourceName), meth_QGeoAreaMonitorSource_sourceName, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorSource_sourceName)},
    {SIP_MLNAME_CAST(sipName_startMonitoring), meth_QGeoAreaMonitorSource_startMonitoring, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorSource_startMonitoring)},
    {SIP_MLNAME_CAST(sipName_stopMonitoring), meth_QGeoAreaMonitorSource_stopMonitoring, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorSource_stopMonitoring)},
    {SIP_MLNAME_CAST(sipName_supportedAreaMonitorFeatures), meth_QGeoAreaMonitorSource_supportedAreaMonitorFeatures, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorSource_supportedAreaMonitorFeatures)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QGeoAreaMonitorSource_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

static sipEnumMemberDef enummembers_QGeoAreaMonitorSource[] = {
    {sipName_AccessError, static_cast<int>(QGeoAreaMonitorSource::AccessError), 5},
    {sipName_AnyAreaMonitorFeature, static_cast<int>(QGeoAreaMonitorSource::AnyAreaMonitorFeature), 3},
    {sipName_InsufficientPositionInfo, static_cast<int>(QGeoAreaMonitorSource::InsufficientPositionInfo), 5},
    {sipName_NoError, static_cast<int>(QGeoAreaMonitorSource::NoError), 5},
    {sipName_PersistentAreaMonitorFeature, static_cast<int>(QGeoAreaMonitorSource::PersistentAreaMonitorFeature), 3},
    {sipName_UnknownSourceError, static_cast<int>(QGeoAreaMonitorSource::UnknownSourceError), 5},
};


/* Define this type's signals. */
static const pyqt5QtSignal signals_QGeoAreaMonitorSource[] = {
    {"monitorExpired(QGeoAreaMonitorInfo)", "\1QGeoAreaMonitorSource.monitorExpired[QGeoAreaMonitorInfo]", 0, 0},
    {"areaExited(QGeoAreaMonitorInfo,QGeoPositionInfo)", "\1QGeoAreaMonitorSource.areaExited[QGeoAreaMonitorInfo, QGeoPositionInfo]", 0, 0},
    {"areaEntered(QGeoAreaMonitorInfo,QGeoPositionInfo)", "\1QGeoAreaMonitorSource.areaEntered[QGeoAreaMonitorInfo, QGeoPositionInfo]", 0, 0},
    {"error(QGeoAreaMonitorSource::Error)", "\1QGeoAreaMonitorSource.error[QGeoAreaMonitorSource.Error]", &methods_QGeoAreaMonitorSource[8], 0},
    {0, 0, 0, 0}
};

PyDoc_STRVAR(doc_QGeoAreaMonitorSource, "\1QGeoAreaMonitorSource(QObject)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoAreaMonitorSource = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoAreaMonitorSource,
        {0}
    },
    {
        sipNameNr_QGeoAreaMonitorSource,
        {0, 0, 1},
        21, methods_QGeoAreaMonitorSource,
        6, enummembers_QGeoAreaMonitorSource,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoAreaMonitorSource,
    -1,
    -1,
    supers_QGeoAreaMonitorSource,
    0,
    init_type_QGeoAreaMonitorSource,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoAreaMonitorSource,
    0,
    0,
    0,
    release_QGeoAreaMonitorSource,
    cast_QGeoAreaMonitorSource,
    0,
    0,
    0,
    0,
    0,
    0
},
    &QGeoAreaMonitorSource::staticMetaObject,
    0,
    signals_QGeoAreaMonitorSource,
    0
};

#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoareamonitorinfo.sip"
#include <qgeoareamonitorinfo.h>
#line 11851 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 11855 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 26 "sip/QtCore/qpycore_qmap.sip"
#include <qmap.h>
#line 11858 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 30 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 11861 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 299 "sip/QtCore/qdatetime.sip"
#include <qdatetime.h>
#line 11864 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"
#line 34 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoshape.sip"
#include <qgeoshape.h>
#line 11867 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


PyDoc_STRVAR(doc_QGeoAreaMonitorInfo_name, "QGeoAreaMonitorInfo.name() -> str");

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

    {
        const QGeoAreaMonitorInfo *sipCpp;

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

            sipRes = new QString(sipCpp->name());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorInfo, sipName_name, doc_QGeoAreaMonitorInfo_name);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorInfo_setName, "QGeoAreaMonitorInfo.setName(str)");

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

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

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoAreaMonitorInfo, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setName(*a0);
            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_QGeoAreaMonitorInfo, sipName_setName, doc_QGeoAreaMonitorInfo_setName);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorInfo_identifier, "QGeoAreaMonitorInfo.identifier() -> str");

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

    {
        const QGeoAreaMonitorInfo *sipCpp;

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

            sipRes = new QString(sipCpp->identifier());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorInfo, sipName_identifier, doc_QGeoAreaMonitorInfo_identifier);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorInfo_isValid, "QGeoAreaMonitorInfo.isValid() -> bool");

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

    {
        const QGeoAreaMonitorInfo *sipCpp;

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

            sipRes = sipCpp->isValid();

            return PyBool_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorInfo_area, "QGeoAreaMonitorInfo.area() -> QGeoShape");

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

    {
        const QGeoAreaMonitorInfo *sipCpp;

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

            sipRes = new QGeoShape(sipCpp->area());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorInfo, sipName_area, doc_QGeoAreaMonitorInfo_area);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorInfo_setArea, "QGeoAreaMonitorInfo.setArea(QGeoShape)");

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

    {
        const QGeoShape* a0;
        QGeoAreaMonitorInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGeoAreaMonitorInfo, &sipCpp, sipType_QGeoShape, &a0))
        {
            sipCpp->setArea(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorInfo, sipName_setArea, doc_QGeoAreaMonitorInfo_setArea);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorInfo_expiration, "QGeoAreaMonitorInfo.expiration() -> QDateTime");

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

    {
        const QGeoAreaMonitorInfo *sipCpp;

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

            sipRes = new QDateTime(sipCpp->expiration());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorInfo, sipName_expiration, doc_QGeoAreaMonitorInfo_expiration);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorInfo_setExpiration, "QGeoAreaMonitorInfo.setExpiration(QDateTime)");

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

    {
        const QDateTime* a0;
        int a0State = 0;
        QGeoAreaMonitorInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoAreaMonitorInfo, &sipCpp, sipType_QDateTime, &a0, &a0State))
        {
            sipCpp->setExpiration(*a0);
            sipReleaseType(const_cast<QDateTime *>(a0),sipType_QDateTime,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorInfo, sipName_setExpiration, doc_QGeoAreaMonitorInfo_setExpiration);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorInfo_isPersistent, "QGeoAreaMonitorInfo.isPersistent() -> bool");

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

    {
        const QGeoAreaMonitorInfo *sipCpp;

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

            sipRes = sipCpp->isPersistent();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorInfo, sipName_isPersistent, doc_QGeoAreaMonitorInfo_isPersistent);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorInfo_setPersistent, "QGeoAreaMonitorInfo.setPersistent(bool)");

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

    {
        bool a0;
        QGeoAreaMonitorInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGeoAreaMonitorInfo, &sipCpp, &a0))
        {
            sipCpp->setPersistent(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorInfo, sipName_setPersistent, doc_QGeoAreaMonitorInfo_setPersistent);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorInfo_notificationParameters, "QGeoAreaMonitorInfo.notificationParameters() -> dict-of-str-object");

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

    {
        const QGeoAreaMonitorInfo *sipCpp;

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

            sipRes = new QVariantMap(sipCpp->notificationParameters());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorInfo, sipName_notificationParameters, doc_QGeoAreaMonitorInfo_notificationParameters);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAreaMonitorInfo_setNotificationParameters, "QGeoAreaMonitorInfo.setNotificationParameters(dict-of-str-object)");

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

    {
        const QVariantMap* a0;
        int a0State = 0;
        QGeoAreaMonitorInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoAreaMonitorInfo, &sipCpp, sipType_QMap_0100QString_0100QVariant,&a0, &a0State))
        {
            sipCpp->setNotificationParameters(*a0);
            sipReleaseType(const_cast<QVariantMap *>(a0),sipType_QMap_0100QString_0100QVariant,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAreaMonitorInfo, sipName_setNotificationParameters, doc_QGeoAreaMonitorInfo_setNotificationParameters);

    return NULL;
}


extern "C" {static PyObject *slot_QGeoAreaMonitorInfo___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGeoAreaMonitorInfo___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoAreaMonitorInfo *sipCpp = reinterpret_cast<QGeoAreaMonitorInfo *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoAreaMonitorInfo));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoAreaMonitorInfo* a0;

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

            sipRes = sipCpp->QGeoAreaMonitorInfo::operator!=(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,ne_slot,sipType_QGeoAreaMonitorInfo,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoAreaMonitorInfo___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGeoAreaMonitorInfo___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoAreaMonitorInfo *sipCpp = reinterpret_cast<QGeoAreaMonitorInfo *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoAreaMonitorInfo));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoAreaMonitorInfo* a0;

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

            sipRes = sipCpp->QGeoAreaMonitorInfo::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,eq_slot,sipType_QGeoAreaMonitorInfo,sipSelf,sipArg);
}


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

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoAreaMonitorInfo(void *, int);}
static void release_QGeoAreaMonitorInfo(void *sipCppV,int)
{
    delete reinterpret_cast<QGeoAreaMonitorInfo *>(sipCppV);
}


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


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


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


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


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

    {
        const QString& a0def = QString();
        const QString* a0 = &a0def;
        int a0State = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|J1", sipType_QString,&a0, &a0State))
        {
            sipCpp = new QGeoAreaMonitorInfo(*a0);
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipCpp;
        }
    }

    {
        const QGeoAreaMonitorInfo* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGeoAreaMonitorInfo, &a0))
        {
            sipCpp = new QGeoAreaMonitorInfo(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGeoAreaMonitorInfo[] = {
    {(void *)slot_QGeoAreaMonitorInfo___ne__, ne_slot},
    {(void *)slot_QGeoAreaMonitorInfo___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QGeoAreaMonitorInfo[] = {
    {SIP_MLNAME_CAST(sipName_area), meth_QGeoAreaMonitorInfo_area, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorInfo_area)},
    {SIP_MLNAME_CAST(sipName_expiration), meth_QGeoAreaMonitorInfo_expiration, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorInfo_expiration)},
    {SIP_MLNAME_CAST(sipName_identifier), meth_QGeoAreaMonitorInfo_identifier, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorInfo_identifier)},
    {SIP_MLNAME_CAST(sipName_isPersistent), meth_QGeoAreaMonitorInfo_isPersistent, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorInfo_isPersistent)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QGeoAreaMonitorInfo_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorInfo_isValid)},
    {SIP_MLNAME_CAST(sipName_name), meth_QGeoAreaMonitorInfo_name, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorInfo_name)},
    {SIP_MLNAME_CAST(sipName_notificationParameters), meth_QGeoAreaMonitorInfo_notificationParameters, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorInfo_notificationParameters)},
    {SIP_MLNAME_CAST(sipName_setArea), meth_QGeoAreaMonitorInfo_setArea, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorInfo_setArea)},
    {SIP_MLNAME_CAST(sipName_setExpiration), meth_QGeoAreaMonitorInfo_setExpiration, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorInfo_setExpiration)},
    {SIP_MLNAME_CAST(sipName_setName), meth_QGeoAreaMonitorInfo_setName, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorInfo_setName)},
    {SIP_MLNAME_CAST(sipName_setNotificationParameters), meth_QGeoAreaMonitorInfo_setNotificationParameters, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorInfo_setNotificationParameters)},
    {SIP_MLNAME_CAST(sipName_setPersistent), meth_QGeoAreaMonitorInfo_setPersistent, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAreaMonitorInfo_setPersistent)}
};

PyDoc_STRVAR(doc_QGeoAreaMonitorInfo, "\1QGeoAreaMonitorInfo(str name='')\n"
    "QGeoAreaMonitorInfo(QGeoAreaMonitorInfo)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoAreaMonitorInfo = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoAreaMonitorInfo,
        {0}
    },
    {
        sipNameNr_QGeoAreaMonitorInfo,
        {0, 0, 1},
        12, methods_QGeoAreaMonitorInfo,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoAreaMonitorInfo,
    sipNameNr_PyQt5_QtCore_pyqtWrapperType,
    -1,
    0,
    slots_QGeoAreaMonitorInfo,
    init_type_QGeoAreaMonitorInfo,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoAreaMonitorInfo,
    assign_QGeoAreaMonitorInfo,
    array_QGeoAreaMonitorInfo,
    copy_QGeoAreaMonitorInfo,
    release_QGeoAreaMonitorInfo,
    cast_QGeoAreaMonitorInfo,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/sip/QtPositioning/qgeoaddress.sip"
#include <qgeoaddress.h>
#line 12436 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"

#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 12440 "/usr/src/ports/python3-pyqt5/python3-pyqt5-5.4.2-1.i686/build/QtPositioning/sipQtPositioningpart0.cpp"


PyDoc_STRVAR(doc_QGeoAddress_text, "QGeoAddress.text() -> str");

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

    {
        const QGeoAddress *sipCpp;

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

            sipRes = new QString(sipCpp->text());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAddress, sipName_text, doc_QGeoAddress_text);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_setText, "QGeoAddress.setText(str)");

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

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

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoAddress, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setText(*a0);
            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_QGeoAddress, sipName_setText, doc_QGeoAddress_setText);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_country, "QGeoAddress.country() -> str");

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

    {
        const QGeoAddress *sipCpp;

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

            sipRes = new QString(sipCpp->country());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAddress, sipName_country, doc_QGeoAddress_country);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_setCountry, "QGeoAddress.setCountry(str)");

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

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

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoAddress, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setCountry(*a0);
            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_QGeoAddress, sipName_setCountry, doc_QGeoAddress_setCountry);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_countryCode, "QGeoAddress.countryCode() -> str");

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

    {
        const QGeoAddress *sipCpp;

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

            sipRes = new QString(sipCpp->countryCode());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAddress, sipName_countryCode, doc_QGeoAddress_countryCode);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_setCountryCode, "QGeoAddress.setCountryCode(str)");

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

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

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoAddress, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setCountryCode(*a0);
            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_QGeoAddress, sipName_setCountryCode, doc_QGeoAddress_setCountryCode);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_state, "QGeoAddress.state() -> str");

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

    {
        const QGeoAddress *sipCpp;

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

            sipRes = new QString(sipCpp->state());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAddress, sipName_state, doc_QGeoAddress_state);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_setState, "QGeoAddress.setState(str)");

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

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

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoAddress, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setState(*a0);
            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_QGeoAddress, sipName_setState, doc_QGeoAddress_setState);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_county, "QGeoAddress.county() -> str");

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

    {
        const QGeoAddress *sipCpp;

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

            sipRes = new QString(sipCpp->county());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAddress, sipName_county, doc_QGeoAddress_county);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_setCounty, "QGeoAddress.setCounty(str)");

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

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

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoAddress, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setCounty(*a0);
            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_QGeoAddress, sipName_setCounty, doc_QGeoAddress_setCounty);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_city, "QGeoAddress.city() -> str");

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

    {
        const QGeoAddress *sipCpp;

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

            sipRes = new QString(sipCpp->city());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAddress, sipName_city, doc_QGeoAddress_city);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_setCity, "QGeoAddress.setCity(str)");

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

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

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoAddress, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setCity(*a0);
            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_QGeoAddress, sipName_setCity, doc_QGeoAddress_setCity);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_district, "QGeoAddress.district() -> str");

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

    {
        const QGeoAddress *sipCpp;

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

            sipRes = new QString(sipCpp->district());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAddress, sipName_district, doc_QGeoAddress_district);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_setDistrict, "QGeoAddress.setDistrict(str)");

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

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

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoAddress, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setDistrict(*a0);
            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_QGeoAddress, sipName_setDistrict, doc_QGeoAddress_setDistrict);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_postalCode, "QGeoAddress.postalCode() -> str");

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

    {
        const QGeoAddress *sipCpp;

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

            sipRes = new QString(sipCpp->postalCode());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAddress, sipName_postalCode, doc_QGeoAddress_postalCode);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_setPostalCode, "QGeoAddress.setPostalCode(str)");

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

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

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoAddress, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setPostalCode(*a0);
            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_QGeoAddress, sipName_setPostalCode, doc_QGeoAddress_setPostalCode);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_street, "QGeoAddress.street() -> str");

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

    {
        const QGeoAddress *sipCpp;

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

            sipRes = new QString(sipCpp->street());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAddress, sipName_street, doc_QGeoAddress_street);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_setStreet, "QGeoAddress.setStreet(str)");

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

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

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGeoAddress, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setStreet(*a0);
            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_QGeoAddress, sipName_setStreet, doc_QGeoAddress_setStreet);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_isEmpty, "QGeoAddress.isEmpty() -> bool");

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

    {
        const QGeoAddress *sipCpp;

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

            sipRes = sipCpp->isEmpty();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAddress, sipName_isEmpty, doc_QGeoAddress_isEmpty);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_clear, "QGeoAddress.clear()");

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

    {
        QGeoAddress *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGeoAddress, &sipCpp))
        {
            sipCpp->clear();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAddress, sipName_clear, doc_QGeoAddress_clear);

    return NULL;
}


PyDoc_STRVAR(doc_QGeoAddress_isTextGenerated, "QGeoAddress.isTextGenerated() -> bool");

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

    {
        const QGeoAddress *sipCpp;

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

            sipRes = sipCpp->isTextGenerated();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGeoAddress, sipName_isTextGenerated, doc_QGeoAddress_isTextGenerated);

    return NULL;
}


extern "C" {static PyObject *slot_QGeoAddress___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGeoAddress___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoAddress *sipCpp = reinterpret_cast<QGeoAddress *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoAddress));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoAddress* a0;

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

            sipRes = sipCpp->QGeoAddress::operator!=(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,ne_slot,sipType_QGeoAddress,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QGeoAddress___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGeoAddress___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QGeoAddress *sipCpp = reinterpret_cast<QGeoAddress *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGeoAddress));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QGeoAddress* a0;

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

            sipRes = sipCpp->QGeoAddress::operator==(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtPositioning,eq_slot,sipType_QGeoAddress,sipSelf,sipArg);
}


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

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGeoAddress(void *, int);}
static void release_QGeoAddress(void *sipCppV,int)
{
    delete reinterpret_cast<QGeoAddress *>(sipCppV);
}


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


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


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


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


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

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

            return sipCpp;
        }
    }

    {
        const QGeoAddress* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGeoAddress, &a0))
        {
            sipCpp = new QGeoAddress(*a0);

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGeoAddress[] = {
    {(void *)slot_QGeoAddress___ne__, ne_slot},
    {(void *)slot_QGeoAddress___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QGeoAddress[] = {
    {SIP_MLNAME_CAST(sipName_city), meth_QGeoAddress_city, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_city)},
    {SIP_MLNAME_CAST(sipName_clear), meth_QGeoAddress_clear, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_clear)},
    {SIP_MLNAME_CAST(sipName_country), meth_QGeoAddress_country, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_country)},
    {SIP_MLNAME_CAST(sipName_countryCode), meth_QGeoAddress_countryCode, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_countryCode)},
    {SIP_MLNAME_CAST(sipName_county), meth_QGeoAddress_county, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_county)},
    {SIP_MLNAME_CAST(sipName_district), meth_QGeoAddress_district, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_district)},
    {SIP_MLNAME_CAST(sipName_isEmpty), meth_QGeoAddress_isEmpty, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_isEmpty)},
    {SIP_MLNAME_CAST(sipName_isTextGenerated), meth_QGeoAddress_isTextGenerated, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_isTextGenerated)},
    {SIP_MLNAME_CAST(sipName_postalCode), meth_QGeoAddress_postalCode, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_postalCode)},
    {SIP_MLNAME_CAST(sipName_setCity), meth_QGeoAddress_setCity, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_setCity)},
    {SIP_MLNAME_CAST(sipName_setCountry), meth_QGeoAddress_setCountry, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_setCountry)},
    {SIP_MLNAME_CAST(sipName_setCountryCode), meth_QGeoAddress_setCountryCode, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_setCountryCode)},
    {SIP_MLNAME_CAST(sipName_setCounty), meth_QGeoAddress_setCounty, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_setCounty)},
    {SIP_MLNAME_CAST(sipName_setDistrict), meth_QGeoAddress_setDistrict, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_setDistrict)},
    {SIP_MLNAME_CAST(sipName_setPostalCode), meth_QGeoAddress_setPostalCode, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_setPostalCode)},
    {SIP_MLNAME_CAST(sipName_setState), meth_QGeoAddress_setState, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_setState)},
    {SIP_MLNAME_CAST(sipName_setStreet), meth_QGeoAddress_setStreet, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_setStreet)},
    {SIP_MLNAME_CAST(sipName_setText), meth_QGeoAddress_setText, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_setText)},
    {SIP_MLNAME_CAST(sipName_state), meth_QGeoAddress_state, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_state)},
    {SIP_MLNAME_CAST(sipName_street), meth_QGeoAddress_street, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_street)},
    {SIP_MLNAME_CAST(sipName_text), meth_QGeoAddress_text, METH_VARARGS, SIP_MLDOC_CAST(doc_QGeoAddress_text)}
};

PyDoc_STRVAR(doc_QGeoAddress, "\1QGeoAddress()\n"
    "QGeoAddress(QGeoAddress)");


pyqt5ClassTypeDef sipTypeDef_QtPositioning_QGeoAddress = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QGeoAddress,
        {0}
    },
    {
        sipNameNr_QGeoAddress,
        {0, 0, 1},
        21, methods_QGeoAddress,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGeoAddress,
    sipNameNr_PyQt5_QtCore_pyqtWrapperType,
    -1,
    0,
    slots_QGeoAddress,
    init_type_QGeoAddress,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGeoAddress,
    assign_QGeoAddress,
    array_QGeoAddress,
    copy_QGeoAddress,
    release_QGeoAddress,
    cast_QGeoAddress,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};
