/*
 * Module code.
 *
 * Generated by SIP 4.19.6
 *
 * Copyright (c) 2017 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 "sipAPIQtSerialPort.h"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 29 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
#include <qserialport.h>
#line 32 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qiodevice.sip"
#include <qiodevice.h>
#line 35 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 38 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 41 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 44 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 47 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
#include <qserialport.h>
#line 50 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
#include <qserialport.h>
#line 53 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialportinfo.sip"
#include <qserialportinfo.h>
#line 56 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

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

void sipVH_QtSerialPort_14(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const  ::QMetaMethod& a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "N", new  ::QMetaMethod(a0), sipType_QMetaMethod, NULL);
}

void sipVH_QtSerialPort_13(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QEvent, NULL);
}

void sipVH_QtSerialPort_12(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QChildEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QChildEvent, NULL);
}

void sipVH_QtSerialPort_11(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QTimerEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QTimerEvent, NULL);
}

bool sipVH_QtSerialPort_10(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QObject*a0, ::QEvent*a1)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "DD", a0, sipType_QObject, NULL, a1, sipType_QEvent, NULL);

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

    return sipRes;
}

bool sipVH_QtSerialPort_9(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QEvent*a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "D", a0, sipType_QEvent, NULL);

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

    return sipRes;
}

bool sipVH_QtSerialPort_8(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QIODevice::OpenMode a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N", new  ::QIODevice::OpenMode(a0), sipType_QIODevice_OpenMode, NULL);

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

    return sipRes;
}

void sipVH_QtSerialPort_7(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "");
}

bool sipVH_QtSerialPort_6(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::qint64 a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "n", a0);

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

    return sipRes;
}

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

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

    return sipRes;
}

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

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

    return sipRes;
}

bool sipVH_QtSerialPort_3(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, int a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "i", a0);

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

    return sipRes;
}

 ::qint64 sipVH_QtSerialPort_2(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, char*a0, ::qint64 a1)
{
     ::qint64 sipRes = 0;
    int sipIsErr = 0;

#line 200 "sip/QtCore/qiodevice.sip"
        PyObject *result = sipCallMethod(&sipIsErr, sipMethod, "n", a1);
        
        if (result != NULL)
        {
            PyObject *buf;
        
            sipParseResult(&sipIsErr, sipMethod, result, "O", &buf);
        
            if (buf == Py_None)
                sipRes = -1L;
            else if (!SIPBytes_Check(buf))
            {
                sipBadCatcherResult(sipMethod);
                sipIsErr = 1;
            }
            else
            {
                memcpy(a0, SIPBytes_AsString(buf), SIPBytes_Size(buf));
                sipRes = SIPBytes_Size(buf);
            }
        
            Py_DECREF(buf);
            Py_DECREF(result);
        }
#line 391 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

    Py_DECREF(sipMethod);

    if (sipIsErr)
        sipCallErrorHandler(sipErrorHandler, sipPySelf, sipGILState);

    SIP_RELEASE_GIL(sipGILState)

    return sipRes;
}

 ::qint64 sipVH_QtSerialPort_1(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, char*a0, ::qint64 a1)
{
     ::qint64 sipRes = 0;
    int sipIsErr = 0;

#line 265 "sip/QtCore/qiodevice.sip"
        PyObject *result = sipCallMethod(&sipIsErr, sipMethod, "n", a1);
        
        if (result != NULL)
        {
            PyObject *buf;
        
            sipParseResult(&sipIsErr, sipMethod, result, "O", &buf);
        
            if (buf == Py_None)
                sipRes = -1L;
            else if (!SIPBytes_Check(buf))
            {
                sipBadCatcherResult(sipMethod);
                sipIsErr = 1;
            }
            else
            {
                memcpy(a0, SIPBytes_AsString(buf), SIPBytes_Size(buf));
                sipRes = SIPBytes_Size(buf);
            }
        
            Py_DECREF(buf);
            Py_DECREF(result);
        }
#line 433 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

    Py_DECREF(sipMethod);

    if (sipIsErr)
        sipCallErrorHandler(sipErrorHandler, sipPySelf, sipGILState);

    SIP_RELEASE_GIL(sipGILState)

    return sipRes;
}

 ::qint64 sipVH_QtSerialPort_0(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const char*a0,PY_LONG_LONG a1)
{
     ::qint64 sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "g", a0, (SIP_SSIZE_T)a1);

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

    return sipRes;
}


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

#line 32 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
    static struct class_graph {
        const char *name;
        sipTypeDef **type;
        int yes, no;
    } graph[] = {
        {sipName_QSerialPort, &sipType_QSerialPort, -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 489 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

    return sipType;
}


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

    {
         ::QSerialPort::PinoutSignal a0;
         ::QSerialPort::PinoutSignals* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "EJ1", sipType_QSerialPort_PinoutSignal, &a0, sipType_QSerialPort_PinoutSignals, &a1, &a1State))
        {
             ::QSerialPort::PinoutSignals*sipRes;

            sipRes = new  ::QSerialPort::PinoutSignals((a0 | *a1));
            sipReleaseType(a1,sipType_QSerialPort_PinoutSignals,a1State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

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



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

    {
         ::QSerialPort::Direction a0;
         ::QSerialPort::Directions* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "EJ1", sipType_QSerialPort_Direction, &a0, sipType_QSerialPort_Directions, &a1, &a1State))
        {
             ::QSerialPort::Directions*sipRes;

            sipRes = new  ::QSerialPort::Directions((a0 | *a1));
            sipReleaseType(a1,sipType_QSerialPort_Directions,a1State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

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

static sipEnumTypeDef enumTypes[] = {
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSerialPort__SerialPortError, {0}, 0}, sipNameNr_SerialPortError, 1, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSerialPort__DataErrorPolicy, {0}, 0}, sipNameNr_DataErrorPolicy, 1, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSerialPort__PinoutSignal, {0}, 0}, sipNameNr_PinoutSignal, 1, slots_QSerialPort_PinoutSignal},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSerialPort__FlowControl, {0}, 0}, sipNameNr_FlowControl, 1, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSerialPort__StopBits, {0}, 0}, sipNameNr_StopBits, 1, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSerialPort__Parity, {0}, 0}, sipNameNr_Parity, 1, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSerialPort__DataBits, {0}, 0}, sipNameNr_DataBits, 1, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSerialPort__BaudRate, {0}, 0}, sipNameNr_BaudRate, 1, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSerialPort__Direction, {0}, 0}, sipNameNr_Direction, 1, slots_QSerialPort_Direction},
};


/*
 * This defines each type in this module.
 */
sipTypeDef *sipExportedTypes_QtSerialPort[] = {
    &sipTypeDef_QtSerialPort_QList_0100QSerialPortInfo.mtd_base,
    &sipTypeDef_QtSerialPort_QSerialPort.ctd_base,
    &enumTypes[7].etd_base,
    &enumTypes[6].etd_base,
    &enumTypes[1].etd_base,
    &enumTypes[8].etd_base,
    &sipTypeDef_QtSerialPort_QSerialPort_Directions.ctd_base,
    &enumTypes[3].etd_base,
    &enumTypes[5].etd_base,
    &enumTypes[2].etd_base,
    &sipTypeDef_QtSerialPort_QSerialPort_PinoutSignals.ctd_base,
    &enumTypes[0].etd_base,
    &enumTypes[4].etd_base,
    &sipTypeDef_QtSerialPort_QSerialPortInfo.ctd_base,
};


/* This defines the types that this module needs to import from QtCore. */
sipImportedTypeDef sipImportedTypes_QtSerialPort_QtCore[] = {
    {"QChildEvent"},
    {"QEvent"},
    {"QIODevice"},
    {"QIODevice::OpenMode"},
    {"QList<int>"},
    {"QMetaMethod"},
    {"QObject"},
    {"QString"},
    {"QTimerEvent"},
    {NULL}
};


/*
 * This defines the virtual error handlers that this module needs to import
 * from QtCore.
 */
sipImportedVirtErrorHandlerDef sipImportedVirtErrorHandlers_QtSerialPort_QtCore[] = {
    {"PyQt5"},
    {NULL}
};


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


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


/* This defines this module. */
sipExportedModuleDef sipModuleAPI_QtSerialPort = {
    0,
    SIP_API_MINOR_NR,
    sipNameNr_PyQt5_QtSerialPort,
    0,
    sipStrings_QtSerialPort,
    importsTable,
    NULL,
    14,
    sipExportedTypes_QtSerialPort,
    NULL,
    0,
    NULL,
    0,
    NULL,
    NULL,
    convertorsTable,
    {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};


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

sip_qt_metaobject_func sip_QtSerialPort_qt_metaobject;
sip_qt_metacall_func sip_QtSerialPort_qt_metacall;
sip_qt_metacast_func sip_QtSerialPort_qt_metacast;


/* The Python module initialisation function. */
#if PY_MAJOR_VERSION >= 3
#define SIP_MODULE_ENTRY        PyInit_QtSerialPort
#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        initQtSerialPort
#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.QtSerialPort",
        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_QtSerialPort, sip_methods);
#else
    sipModule = Py_InitModule(const_cast<char *>(sipName_PyQt5_QtSerialPort), 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_QtSerialPort = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, SIP_MODULE_NAME "._C_API"));
#else
    sipAPI_QtSerialPort = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif

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

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

    sip_QtSerialPort_qt_metaobject = (sip_qt_metaobject_func)sipImportSymbol("qtcore_qt_metaobject");
    sip_QtSerialPort_qt_metacall = (sip_qt_metacall_func)sipImportSymbol("qtcore_qt_metacall");
    sip_QtSerialPort_qt_metacast = (sip_qt_metacast_func)sipImportSymbol("qtcore_qt_metacast");

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

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

    SIP_MODULE_RETURN(sipModule);
}

#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 798 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialportinfo.sip"
#include <qserialportinfo.h>
#line 802 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"


extern "C" {static void assign_QList_0100QSerialPortInfo(void *, SIP_SSIZE_T, void *);}
static void assign_QList_0100QSerialPortInfo(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast<QList< ::QSerialPortInfo> *>(sipDst)[sipDstIdx] = *reinterpret_cast<QList< ::QSerialPortInfo> *>(sipSrc);
}


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


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


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



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

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

    if (!sipIsErr)
    {
        PyErr_Clear();
        Py_XDECREF(iter);

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

    if (!iter)
    {
        *sipIsErr = 1;

        return 0;
    }

    QList<QSerialPortInfo> *ql = new QList<QSerialPortInfo>;
 
    for (Py_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;
        QSerialPortInfo *t = reinterpret_cast<QSerialPortInfo *>(
                sipForceConvertToType(itm, sipType_QSerialPortInfo, sipTransferObj,
                        SIP_NOT_NONE, &state, sipIsErr));

        if (*sipIsErr)
        {
            PyErr_Format(PyExc_TypeError,
                    "index %zd has type '%s' but 'QSerialPortInfo' is expected", i,
                    sipPyTypeName(Py_TYPE(itm)));

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

            return 0;
        }

        ql->append(*t);

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

    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 912 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
}


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

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

    if (!l)
        return 0;

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

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

            return 0;
        }

        PyList_SetItem(l, i, tobj);
    }

    return l;
#line 945 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtSerialPort_QList_0100QSerialPortInfo = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_400,     /* QList<QSerialPortInfo> */
        {0},
        0
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0100QSerialPortInfo,
    array_QList_0100QSerialPortInfo,
    copy_QList_0100QSerialPortInfo,
    release_QList_0100QSerialPortInfo,
    convertTo_QList_0100QSerialPortInfo,
    convertFrom_QList_0100QSerialPortInfo
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialportinfo.sip"
#include <qserialportinfo.h>
#line 977 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
#include <qserialport.h>
#line 981 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 984 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 987 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 646 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 990 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"


PyDoc_STRVAR(doc_QSerialPortInfo_swap, "swap(self, QSerialPortInfo)");

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

    {
         ::QSerialPortInfo* a0;
         ::QSerialPortInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSerialPortInfo, &sipCpp, sipType_QSerialPortInfo, &a0))
        {
            sipCpp->swap(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_swap, doc_QSerialPortInfo_swap);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_portName, "portName(self) -> str");

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

    {
        const  ::QSerialPortInfo *sipCpp;

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

            sipRes = new  ::QString(sipCpp->portName());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_portName, doc_QSerialPortInfo_portName);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_systemLocation, "systemLocation(self) -> str");

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

    {
        const  ::QSerialPortInfo *sipCpp;

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

            sipRes = new  ::QString(sipCpp->systemLocation());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_systemLocation, doc_QSerialPortInfo_systemLocation);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_description, "description(self) -> str");

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

    {
        const  ::QSerialPortInfo *sipCpp;

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

            sipRes = new  ::QString(sipCpp->description());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_description, doc_QSerialPortInfo_description);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_manufacturer, "manufacturer(self) -> str");

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

    {
        const  ::QSerialPortInfo *sipCpp;

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

            sipRes = new  ::QString(sipCpp->manufacturer());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_manufacturer, doc_QSerialPortInfo_manufacturer);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_vendorIdentifier, "vendorIdentifier(self) -> int");

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

    {
        const  ::QSerialPortInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSerialPortInfo, &sipCpp))
        {
             ::quint16 sipRes;

            sipRes = sipCpp->vendorIdentifier();

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_vendorIdentifier, doc_QSerialPortInfo_vendorIdentifier);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_productIdentifier, "productIdentifier(self) -> int");

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

    {
        const  ::QSerialPortInfo *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSerialPortInfo, &sipCpp))
        {
             ::quint16 sipRes;

            sipRes = sipCpp->productIdentifier();

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_productIdentifier, doc_QSerialPortInfo_productIdentifier);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_hasVendorIdentifier, "hasVendorIdentifier(self) -> bool");

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

    {
        const  ::QSerialPortInfo *sipCpp;

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

            sipRes = sipCpp->hasVendorIdentifier();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_hasVendorIdentifier, doc_QSerialPortInfo_hasVendorIdentifier);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_hasProductIdentifier, "hasProductIdentifier(self) -> bool");

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

    {
        const  ::QSerialPortInfo *sipCpp;

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

            sipRes = sipCpp->hasProductIdentifier();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_hasProductIdentifier, doc_QSerialPortInfo_hasProductIdentifier);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_isBusy, "isBusy(self) -> bool");

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

    {
        const  ::QSerialPortInfo *sipCpp;

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

            sipRes = sipCpp->isBusy();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_isBusy, doc_QSerialPortInfo_isBusy);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_isValid, "isValid(self) -> bool");

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

    {
        const  ::QSerialPortInfo *sipCpp;

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

            sipRes = sipCpp->isValid();

            return PyBool_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_standardBaudRates, "standardBaudRates() -> List[int]");

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

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
             ::QList<int>*sipRes;

            sipRes = new  ::QList<int>( ::QSerialPortInfo::standardBaudRates());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_standardBaudRates, doc_QSerialPortInfo_standardBaudRates);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_availablePorts, "availablePorts() -> object");

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

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            QList< ::QSerialPortInfo>*sipRes;

            sipRes = new QList< ::QSerialPortInfo>( ::QSerialPortInfo::availablePorts());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_availablePorts, doc_QSerialPortInfo_availablePorts);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_isNull, "isNull(self) -> bool");

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

    {
        const  ::QSerialPortInfo *sipCpp;

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

            sipRes = sipCpp->isNull();

            return PyBool_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPortInfo_serialNumber, "serialNumber(self) -> str");

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

    {
        const  ::QSerialPortInfo *sipCpp;

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

            sipRes = new  ::QString(sipCpp->serialNumber());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPortInfo, sipName_serialNumber, doc_QSerialPortInfo_serialNumber);

    return NULL;
}


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


extern "C" {static void assign_QSerialPortInfo(void *, SIP_SSIZE_T, void *);}
static void assign_QSerialPortInfo(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QSerialPortInfo *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QSerialPortInfo *>(sipSrc);
}


extern "C" {static void *array_QSerialPortInfo(SIP_SSIZE_T);}
static void *array_QSerialPortInfo(SIP_SSIZE_T sipNrElem)
{
    return new  ::QSerialPortInfo[sipNrElem];
}


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


extern "C" {static void dealloc_QSerialPortInfo(sipSimpleWrapper *);}
static void dealloc_QSerialPortInfo(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QSerialPortInfo(sipGetAddress(sipSelf), 0);
    }
}


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

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

            return sipCpp;
        }
    }

    {
        const  ::QSerialPort* a0;

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

            return sipCpp;
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QString,&a0, &a0State))
        {
            sipCpp = new  ::QSerialPortInfo(*a0);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return sipCpp;
        }
    }

    {
        const  ::QSerialPortInfo* a0;

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

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QSerialPortInfo[] = {
    {SIP_MLNAME_CAST(sipName_availablePorts), meth_QSerialPortInfo_availablePorts, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_availablePorts)},
    {SIP_MLNAME_CAST(sipName_description), meth_QSerialPortInfo_description, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_description)},
    {SIP_MLNAME_CAST(sipName_hasProductIdentifier), meth_QSerialPortInfo_hasProductIdentifier, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_hasProductIdentifier)},
    {SIP_MLNAME_CAST(sipName_hasVendorIdentifier), meth_QSerialPortInfo_hasVendorIdentifier, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_hasVendorIdentifier)},
    {SIP_MLNAME_CAST(sipName_isBusy), meth_QSerialPortInfo_isBusy, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_isBusy)},
    {SIP_MLNAME_CAST(sipName_isNull), meth_QSerialPortInfo_isNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_isNull)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QSerialPortInfo_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_isValid)},
    {SIP_MLNAME_CAST(sipName_manufacturer), meth_QSerialPortInfo_manufacturer, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_manufacturer)},
    {SIP_MLNAME_CAST(sipName_portName), meth_QSerialPortInfo_portName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_portName)},
    {SIP_MLNAME_CAST(sipName_productIdentifier), meth_QSerialPortInfo_productIdentifier, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_productIdentifier)},
    {SIP_MLNAME_CAST(sipName_serialNumber), meth_QSerialPortInfo_serialNumber, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_serialNumber)},
    {SIP_MLNAME_CAST(sipName_standardBaudRates), meth_QSerialPortInfo_standardBaudRates, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_standardBaudRates)},
    {SIP_MLNAME_CAST(sipName_swap), meth_QSerialPortInfo_swap, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_swap)},
    {SIP_MLNAME_CAST(sipName_systemLocation), meth_QSerialPortInfo_systemLocation, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_systemLocation)},
    {SIP_MLNAME_CAST(sipName_vendorIdentifier), meth_QSerialPortInfo_vendorIdentifier, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPortInfo_vendorIdentifier)}
};

PyDoc_STRVAR(doc_QSerialPortInfo, "\1QSerialPortInfo()\n"
    "QSerialPortInfo(QSerialPort)\n"
    "QSerialPortInfo(str)\n"
    "QSerialPortInfo(QSerialPortInfo)");


static pyqt5ClassPluginDef plugin_QSerialPortInfo = {
    0,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtSerialPort_QSerialPortInfo = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QSerialPortInfo,
        {0},
        &plugin_QSerialPortInfo
    },
    {
        sipNameNr_QSerialPortInfo,
        {0, 0, 1},
        15, methods_QSerialPortInfo,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSerialPortInfo,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QSerialPortInfo,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSerialPortInfo,
    assign_QSerialPortInfo,
    array_QSerialPortInfo,
    copy_QSerialPortInfo,
    release_QSerialPortInfo,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
#include <qserialport.h>
#line 1593 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
#include <qserialport.h>
#line 1597 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"


extern "C" {static long slot_QSerialPort_PinoutSignals___hash__(PyObject *);}
static long slot_QSerialPort_PinoutSignals___hash__(PyObject *sipSelf)
{
     ::QSerialPort::PinoutSignals *sipCpp = reinterpret_cast< ::QSerialPort::PinoutSignals *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_PinoutSignals));

    if (!sipCpp)
        return 0;


    {
        {
            long sipRes = 0;

#line 116 "sip/QtCore/qglobal.sip"
        sipRes = sipCpp->operator QSerialPort::PinoutSignals::Int();
#line 1615 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static int slot_QSerialPort_PinoutSignals___bool__(PyObject *);}
static int slot_QSerialPort_PinoutSignals___bool__(PyObject *sipSelf)
{
     ::QSerialPort::PinoutSignals *sipCpp = reinterpret_cast< ::QSerialPort::PinoutSignals *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_PinoutSignals));

    if (!sipCpp)
        return -1;


    {
        {
            int sipRes = 0;

#line 111 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QSerialPort::PinoutSignals::Int() != 0);
#line 1640 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QSerialPort_PinoutSignals___ne__(PyObject *,PyObject *);}
static PyObject *slot_QSerialPort_PinoutSignals___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QSerialPort::PinoutSignals *sipCpp = reinterpret_cast< ::QSerialPort::PinoutSignals *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_PinoutSignals));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QSerialPort::PinoutSignals* a0;
        int a0State = 0;

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

#line 106 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QSerialPort::PinoutSignals::Int() != a0->operator QSerialPort::PinoutSignals::Int());
#line 1670 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
            sipReleaseType(const_cast< ::QSerialPort::PinoutSignals *>(a0),sipType_QSerialPort_PinoutSignals,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSerialPort, ne_slot, sipType_QSerialPort_PinoutSignals, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QSerialPort_PinoutSignals___eq__(PyObject *,PyObject *);}
static PyObject *slot_QSerialPort_PinoutSignals___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QSerialPort::PinoutSignals *sipCpp = reinterpret_cast< ::QSerialPort::PinoutSignals *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_PinoutSignals));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QSerialPort::PinoutSignals* a0;
        int a0State = 0;

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

#line 101 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QSerialPort::PinoutSignals::Int() == a0->operator QSerialPort::PinoutSignals::Int());
#line 1706 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
            sipReleaseType(const_cast< ::QSerialPort::PinoutSignals *>(a0),sipType_QSerialPort_PinoutSignals,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSerialPort, eq_slot, sipType_QSerialPort_PinoutSignals, sipSelf, sipArg);
}


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

     ::QSerialPort::PinoutSignals *sipCpp = reinterpret_cast< ::QSerialPort::PinoutSignals *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_PinoutSignals));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 95 "sip/QtCore/qglobal.sip"
        *sipCpp = QSerialPort::PinoutSignals(*sipCpp ^ a0);
#line 1745 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

            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_QSerialPort_PinoutSignals___xor__(PyObject *,PyObject *);}
static PyObject *slot_QSerialPort_PinoutSignals___xor__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QSerialPort::PinoutSignals* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QSerialPort_PinoutSignals, &a0, &a0State, &a1))
        {
             ::QSerialPort::PinoutSignals*sipRes;

            sipRes = new  ::QSerialPort::PinoutSignals((*a0 ^ a1));
            sipReleaseType(a0,sipType_QSerialPort_PinoutSignals,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSerialPort, xor_slot, NULL, sipArg0, sipArg1);
}


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

     ::QSerialPort::PinoutSignals *sipCpp = reinterpret_cast< ::QSerialPort::PinoutSignals *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_PinoutSignals));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 89 "sip/QtCore/qglobal.sip"
        *sipCpp = QSerialPort::PinoutSignals(*sipCpp | a0);
#line 1817 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

            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_QSerialPort_PinoutSignals___or__(PyObject *,PyObject *);}
static PyObject *slot_QSerialPort_PinoutSignals___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QSerialPort::PinoutSignals* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QSerialPort_PinoutSignals, &a0, &a0State, &a1))
        {
             ::QSerialPort::PinoutSignals*sipRes;

            sipRes = new  ::QSerialPort::PinoutSignals((*a0 | a1));
            sipReleaseType(a0,sipType_QSerialPort_PinoutSignals,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

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


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

     ::QSerialPort::PinoutSignals *sipCpp = reinterpret_cast< ::QSerialPort::PinoutSignals *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_PinoutSignals));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            sipCpp-> ::QSerialPort::PinoutSignals::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_QSerialPort_PinoutSignals___and__(PyObject *,PyObject *);}
static PyObject *slot_QSerialPort_PinoutSignals___and__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QSerialPort::PinoutSignals* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QSerialPort_PinoutSignals, &a0, &a0State, &a1))
        {
             ::QSerialPort::PinoutSignals*sipRes;

            sipRes = new  ::QSerialPort::PinoutSignals((*a0 & a1));
            sipReleaseType(a0,sipType_QSerialPort_PinoutSignals,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

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


extern "C" {static PyObject *slot_QSerialPort_PinoutSignals___invert__(PyObject *);}
static PyObject *slot_QSerialPort_PinoutSignals___invert__(PyObject *sipSelf)
{
     ::QSerialPort::PinoutSignals *sipCpp = reinterpret_cast< ::QSerialPort::PinoutSignals *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_PinoutSignals));

    if (!sipCpp)
        return 0;


    {
        {
             ::QSerialPort::PinoutSignals*sipRes;

            sipRes = new  ::QSerialPort::PinoutSignals(~(*sipCpp));

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

    return 0;
}


extern "C" {static PyObject *slot_QSerialPort_PinoutSignals___int__(PyObject *);}
static PyObject *slot_QSerialPort_PinoutSignals___int__(PyObject *sipSelf)
{
     ::QSerialPort::PinoutSignals *sipCpp = reinterpret_cast< ::QSerialPort::PinoutSignals *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_PinoutSignals));

    if (!sipCpp)
        return 0;


    {
        {
            int sipRes;

            sipRes = *sipCpp;

            return SIPLong_FromLong(sipRes);
        }
    }

    return 0;
}


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


extern "C" {static void assign_QSerialPort_PinoutSignals(void *, SIP_SSIZE_T, void *);}
static void assign_QSerialPort_PinoutSignals(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QSerialPort::PinoutSignals *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QSerialPort::PinoutSignals *>(sipSrc);
}


extern "C" {static void *array_QSerialPort_PinoutSignals(SIP_SSIZE_T);}
static void *array_QSerialPort_PinoutSignals(SIP_SSIZE_T sipNrElem)
{
    return new  ::QSerialPort::PinoutSignals[sipNrElem];
}


extern "C" {static void *copy_QSerialPort_PinoutSignals(const void *, SIP_SSIZE_T);}
static void *copy_QSerialPort_PinoutSignals(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QSerialPort::PinoutSignals(reinterpret_cast<const  ::QSerialPort::PinoutSignals *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QSerialPort_PinoutSignals(sipSimpleWrapper *);}
static void dealloc_QSerialPort_PinoutSignals(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QSerialPort_PinoutSignals(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QSerialPort_PinoutSignals(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSerialPort_PinoutSignals(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QSerialPort::PinoutSignals *sipCpp = 0;

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

            return sipCpp;
        }
    }

    {
        int a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "i", &a0))
        {
            sipCpp = new  ::QSerialPort::PinoutSignals(a0);

            return sipCpp;
        }
    }

    {
        const  ::QSerialPort::PinoutSignals* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QSerialPort_PinoutSignals, &a0, &a0State))
        {
            sipCpp = new  ::QSerialPort::PinoutSignals(*a0);
            sipReleaseType(const_cast< ::QSerialPort::PinoutSignals *>(a0),sipType_QSerialPort_PinoutSignals,a0State);

            return sipCpp;
        }
    }

    return NULL;
}


extern "C" {static int convertTo_QSerialPort_PinoutSignals(PyObject *, void **, int *, PyObject *);}
static int convertTo_QSerialPort_PinoutSignals(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
     ::QSerialPort::PinoutSignals **sipCppPtr = reinterpret_cast< ::QSerialPort::PinoutSignals **>(sipCppPtrV);

#line 121 "sip/QtCore/qglobal.sip"
// Allow an instance of the base enum whenever a QSerialPort::PinoutSignals is expected.

if (sipIsErr == NULL)
    return (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QSerialPort_PinoutSignal)) ||
            sipCanConvertToType(sipPy, sipType_QSerialPort_PinoutSignals, SIP_NO_CONVERTORS));

if (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QSerialPort_PinoutSignal)))
{
    *sipCppPtr = new QSerialPort::PinoutSignals(int(SIPLong_AsLong(sipPy)));

    return sipGetState(sipTransferObj);
}

*sipCppPtr = reinterpret_cast<QSerialPort::PinoutSignals *>(sipConvertToType(sipPy, sipType_QSerialPort_PinoutSignals, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr));

return 0;
#line 2085 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QSerialPort_PinoutSignals[] = {
    {(void *)slot_QSerialPort_PinoutSignals___hash__, hash_slot},
    {(void *)slot_QSerialPort_PinoutSignals___bool__, bool_slot},
    {(void *)slot_QSerialPort_PinoutSignals___ne__, ne_slot},
    {(void *)slot_QSerialPort_PinoutSignals___eq__, eq_slot},
    {(void *)slot_QSerialPort_PinoutSignals___ixor__, ixor_slot},
    {(void *)slot_QSerialPort_PinoutSignals___xor__, xor_slot},
    {(void *)slot_QSerialPort_PinoutSignals___ior__, ior_slot},
    {(void *)slot_QSerialPort_PinoutSignals___or__, or_slot},
    {(void *)slot_QSerialPort_PinoutSignals___iand__, iand_slot},
    {(void *)slot_QSerialPort_PinoutSignals___and__, and_slot},
    {(void *)slot_QSerialPort_PinoutSignals___invert__, invert_slot},
    {(void *)slot_QSerialPort_PinoutSignals___int__, int_slot},
    {0, (sipPySlotType)0}
};

PyDoc_STRVAR(doc_QSerialPort_PinoutSignals, "\1QSerialPort.PinoutSignals()\n"
    "QSerialPort.PinoutSignals(Union[QSerialPort.PinoutSignals, QSerialPort.PinoutSignal])\n"
    "QSerialPort.PinoutSignals(QSerialPort.PinoutSignals)");


static pyqt5ClassPluginDef plugin_QSerialPort_PinoutSignals = {
    0,
    1,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtSerialPort_QSerialPort_PinoutSignals = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QSerialPort__PinoutSignals,
        {0},
        &plugin_QSerialPort_PinoutSignals
    },
    {
        sipNameNr_PinoutSignals,
        {1, 255, 0},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSerialPort_PinoutSignals,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QSerialPort_PinoutSignals,
    init_type_QSerialPort_PinoutSignals,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSerialPort_PinoutSignals,
    assign_QSerialPort_PinoutSignals,
    array_QSerialPort_PinoutSignals,
    copy_QSerialPort_PinoutSignals,
    release_QSerialPort_PinoutSignals,
    0,
    convertTo_QSerialPort_PinoutSignals,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
#include <qserialport.h>
#line 2171 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
#include <qserialport.h>
#line 2175 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"


extern "C" {static long slot_QSerialPort_Directions___hash__(PyObject *);}
static long slot_QSerialPort_Directions___hash__(PyObject *sipSelf)
{
     ::QSerialPort::Directions *sipCpp = reinterpret_cast< ::QSerialPort::Directions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_Directions));

    if (!sipCpp)
        return 0;


    {
        {
            long sipRes = 0;

#line 116 "sip/QtCore/qglobal.sip"
        sipRes = sipCpp->operator QSerialPort::Directions::Int();
#line 2193 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static int slot_QSerialPort_Directions___bool__(PyObject *);}
static int slot_QSerialPort_Directions___bool__(PyObject *sipSelf)
{
     ::QSerialPort::Directions *sipCpp = reinterpret_cast< ::QSerialPort::Directions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_Directions));

    if (!sipCpp)
        return -1;


    {
        {
            int sipRes = 0;

#line 111 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QSerialPort::Directions::Int() != 0);
#line 2218 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QSerialPort_Directions___ne__(PyObject *,PyObject *);}
static PyObject *slot_QSerialPort_Directions___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QSerialPort::Directions *sipCpp = reinterpret_cast< ::QSerialPort::Directions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_Directions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QSerialPort::Directions* a0;
        int a0State = 0;

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

#line 106 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QSerialPort::Directions::Int() != a0->operator QSerialPort::Directions::Int());
#line 2248 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
            sipReleaseType(const_cast< ::QSerialPort::Directions *>(a0),sipType_QSerialPort_Directions,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSerialPort, ne_slot, sipType_QSerialPort_Directions, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QSerialPort_Directions___eq__(PyObject *,PyObject *);}
static PyObject *slot_QSerialPort_Directions___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QSerialPort::Directions *sipCpp = reinterpret_cast< ::QSerialPort::Directions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_Directions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QSerialPort::Directions* a0;
        int a0State = 0;

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

#line 101 "sip/QtCore/qglobal.sip"
        sipRes = (sipCpp->operator QSerialPort::Directions::Int() == a0->operator QSerialPort::Directions::Int());
#line 2284 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
            sipReleaseType(const_cast< ::QSerialPort::Directions *>(a0),sipType_QSerialPort_Directions,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSerialPort, eq_slot, sipType_QSerialPort_Directions, sipSelf, sipArg);
}


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

     ::QSerialPort::Directions *sipCpp = reinterpret_cast< ::QSerialPort::Directions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_Directions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 95 "sip/QtCore/qglobal.sip"
        *sipCpp = QSerialPort::Directions(*sipCpp ^ a0);
#line 2323 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

            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_QSerialPort_Directions___xor__(PyObject *,PyObject *);}
static PyObject *slot_QSerialPort_Directions___xor__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QSerialPort::Directions* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QSerialPort_Directions, &a0, &a0State, &a1))
        {
             ::QSerialPort::Directions*sipRes;

            sipRes = new  ::QSerialPort::Directions((*a0 ^ a1));
            sipReleaseType(a0,sipType_QSerialPort_Directions,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSerialPort, xor_slot, NULL, sipArg0, sipArg1);
}


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

     ::QSerialPort::Directions *sipCpp = reinterpret_cast< ::QSerialPort::Directions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_Directions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 89 "sip/QtCore/qglobal.sip"
        *sipCpp = QSerialPort::Directions(*sipCpp | a0);
#line 2395 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

            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_QSerialPort_Directions___or__(PyObject *,PyObject *);}
static PyObject *slot_QSerialPort_Directions___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QSerialPort::Directions* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QSerialPort_Directions, &a0, &a0State, &a1))
        {
             ::QSerialPort::Directions*sipRes;

            sipRes = new  ::QSerialPort::Directions((*a0 | a1));
            sipReleaseType(a0,sipType_QSerialPort_Directions,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

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


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

     ::QSerialPort::Directions *sipCpp = reinterpret_cast< ::QSerialPort::Directions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_Directions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            sipCpp-> ::QSerialPort::Directions::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_QSerialPort_Directions___and__(PyObject *,PyObject *);}
static PyObject *slot_QSerialPort_Directions___and__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QSerialPort::Directions* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QSerialPort_Directions, &a0, &a0State, &a1))
        {
             ::QSerialPort::Directions*sipRes;

            sipRes = new  ::QSerialPort::Directions((*a0 & a1));
            sipReleaseType(a0,sipType_QSerialPort_Directions,a0State);

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

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

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


extern "C" {static PyObject *slot_QSerialPort_Directions___invert__(PyObject *);}
static PyObject *slot_QSerialPort_Directions___invert__(PyObject *sipSelf)
{
     ::QSerialPort::Directions *sipCpp = reinterpret_cast< ::QSerialPort::Directions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_Directions));

    if (!sipCpp)
        return 0;


    {
        {
             ::QSerialPort::Directions*sipRes;

            sipRes = new  ::QSerialPort::Directions(~(*sipCpp));

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

    return 0;
}


extern "C" {static PyObject *slot_QSerialPort_Directions___int__(PyObject *);}
static PyObject *slot_QSerialPort_Directions___int__(PyObject *sipSelf)
{
     ::QSerialPort::Directions *sipCpp = reinterpret_cast< ::QSerialPort::Directions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSerialPort_Directions));

    if (!sipCpp)
        return 0;


    {
        {
            int sipRes;

            sipRes = *sipCpp;

            return SIPLong_FromLong(sipRes);
        }
    }

    return 0;
}


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


extern "C" {static void assign_QSerialPort_Directions(void *, SIP_SSIZE_T, void *);}
static void assign_QSerialPort_Directions(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QSerialPort::Directions *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QSerialPort::Directions *>(sipSrc);
}


extern "C" {static void *array_QSerialPort_Directions(SIP_SSIZE_T);}
static void *array_QSerialPort_Directions(SIP_SSIZE_T sipNrElem)
{
    return new  ::QSerialPort::Directions[sipNrElem];
}


extern "C" {static void *copy_QSerialPort_Directions(const void *, SIP_SSIZE_T);}
static void *copy_QSerialPort_Directions(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QSerialPort::Directions(reinterpret_cast<const  ::QSerialPort::Directions *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QSerialPort_Directions(sipSimpleWrapper *);}
static void dealloc_QSerialPort_Directions(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QSerialPort_Directions(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QSerialPort_Directions(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSerialPort_Directions(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QSerialPort::Directions *sipCpp = 0;

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

            return sipCpp;
        }
    }

    {
        int a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "i", &a0))
        {
            sipCpp = new  ::QSerialPort::Directions(a0);

            return sipCpp;
        }
    }

    {
        const  ::QSerialPort::Directions* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QSerialPort_Directions, &a0, &a0State))
        {
            sipCpp = new  ::QSerialPort::Directions(*a0);
            sipReleaseType(const_cast< ::QSerialPort::Directions *>(a0),sipType_QSerialPort_Directions,a0State);

            return sipCpp;
        }
    }

    return NULL;
}


extern "C" {static int convertTo_QSerialPort_Directions(PyObject *, void **, int *, PyObject *);}
static int convertTo_QSerialPort_Directions(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
     ::QSerialPort::Directions **sipCppPtr = reinterpret_cast< ::QSerialPort::Directions **>(sipCppPtrV);

#line 121 "sip/QtCore/qglobal.sip"
// Allow an instance of the base enum whenever a QSerialPort::Directions is expected.

if (sipIsErr == NULL)
    return (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QSerialPort_Direction)) ||
            sipCanConvertToType(sipPy, sipType_QSerialPort_Directions, SIP_NO_CONVERTORS));

if (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QSerialPort_Direction)))
{
    *sipCppPtr = new QSerialPort::Directions(int(SIPLong_AsLong(sipPy)));

    return sipGetState(sipTransferObj);
}

*sipCppPtr = reinterpret_cast<QSerialPort::Directions *>(sipConvertToType(sipPy, sipType_QSerialPort_Directions, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr));

return 0;
#line 2663 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QSerialPort_Directions[] = {
    {(void *)slot_QSerialPort_Directions___hash__, hash_slot},
    {(void *)slot_QSerialPort_Directions___bool__, bool_slot},
    {(void *)slot_QSerialPort_Directions___ne__, ne_slot},
    {(void *)slot_QSerialPort_Directions___eq__, eq_slot},
    {(void *)slot_QSerialPort_Directions___ixor__, ixor_slot},
    {(void *)slot_QSerialPort_Directions___xor__, xor_slot},
    {(void *)slot_QSerialPort_Directions___ior__, ior_slot},
    {(void *)slot_QSerialPort_Directions___or__, or_slot},
    {(void *)slot_QSerialPort_Directions___iand__, iand_slot},
    {(void *)slot_QSerialPort_Directions___and__, and_slot},
    {(void *)slot_QSerialPort_Directions___invert__, invert_slot},
    {(void *)slot_QSerialPort_Directions___int__, int_slot},
    {0, (sipPySlotType)0}
};

PyDoc_STRVAR(doc_QSerialPort_Directions, "\1QSerialPort.Directions()\n"
    "QSerialPort.Directions(Union[QSerialPort.Directions, QSerialPort.Direction])\n"
    "QSerialPort.Directions(QSerialPort.Directions)");


static pyqt5ClassPluginDef plugin_QSerialPort_Directions = {
    0,
    1,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtSerialPort_QSerialPort_Directions = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QSerialPort__Directions,
        {0},
        &plugin_QSerialPort_Directions
    },
    {
        sipNameNr_Directions,
        {1, 255, 0},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSerialPort_Directions,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QSerialPort_Directions,
    init_type_QSerialPort_Directions,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSerialPort_Directions,
    assign_QSerialPort_Directions,
    array_QSerialPort_Directions,
    copy_QSerialPort_Directions,
    release_QSerialPort_Directions,
    0,
    convertTo_QSerialPort_Directions,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
#include <qserialport.h>
#line 2749 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 2753 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 2756 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialportinfo.sip"
#include <qserialportinfo.h>
#line 2759 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
#include <qserialport.h>
#line 2762 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
#include <qserialport.h>
#line 2765 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qiodevice.sip"
#include <qiodevice.h>
#line 2768 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 2771 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 2774 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2777 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2780 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2783 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 2786 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2789 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 149 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2792 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 2795 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 2798 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 2801 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 2804 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 2807 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 2810 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"


class sipQSerialPort : public  ::QSerialPort
{
public:
    sipQSerialPort( ::QObject*);
    sipQSerialPort(const  ::QString&, ::QObject*);
    sipQSerialPort(const  ::QSerialPortInfo&, ::QObject*);
    virtual ~sipQSerialPort();

    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;
    void sipProtect_setOpenMode( ::QIODevice::OpenMode);
    void sipProtect_setErrorString(const  ::QString&);
     ::qint64 sipProtectVirt_readData(bool,char*, ::qint64);
     ::qint64 sipProtectVirt_readLineData(bool,char*, ::qint64);
     ::qint64 sipProtectVirt_writeData(bool,const char*,PY_LONG_LONG);

    /*
     * 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*);
    bool isSequential() const;
    bool open( ::QIODevice::OpenMode);
    void close();
     ::qint64 pos() const;
     ::qint64 size() const;
    bool seek( ::qint64);
    bool atEnd() const;
    bool reset();
     ::qint64 bytesAvailable() const;
     ::qint64 bytesToWrite() const;
    bool canReadLine() const;
    bool waitForReadyRead(int);
    bool waitForBytesWritten(int);
     ::qint64 readData(char*, ::qint64);
     ::qint64 readLineData(char*, ::qint64);
     ::qint64 writeData(const char*,PY_LONG_LONG);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[23];
};

sipQSerialPort::sipQSerialPort( ::QObject*a0):  ::QSerialPort(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSerialPort::sipQSerialPort(const  ::QString& a0, ::QObject*a1):  ::QSerialPort(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSerialPort::sipQSerialPort(const  ::QSerialPortInfo& a0, ::QObject*a1):  ::QSerialPort(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSerialPort::~sipQSerialPort()
{
    sipInstanceDestroyed(sipPySelf);
}

const QMetaObject *sipQSerialPort::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtSerialPort_qt_metaobject(sipPySelf,sipType_QSerialPort);

    return  ::QSerialPort::metaObject();
}

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

    if (_id >= 0)
        _id = sip_QtSerialPort_qt_metacall(sipPySelf,sipType_QSerialPort,_c,_id,_a);

    return _id;
}

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

    return (sip_QtSerialPort_qt_metacast(sipPySelf, sipType_QSerialPort, _clname, &sipCpp) ? sipCpp :  ::QSerialPort::qt_metacast(_clname));
}

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

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

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

    extern void sipVH_QtSerialPort_14(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtSerialPort_14(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtSerialPort_14(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QMetaMethod&);

    sipVH_QtSerialPort_14(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtSerialPort_13(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtSerialPort_13(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtSerialPort_12(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtSerialPort_12(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern void sipVH_QtSerialPort_11(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtSerialPort_11(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

    extern bool sipVH_QtSerialPort_10(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtSerialPort_10(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

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

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

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

    extern bool sipVH_QtSerialPort_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtSerialPort_9(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

bool sipQSerialPort::isSequential() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QSerialPort::isSequential();

    extern bool sipVH_QtSerialPort_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSerialPort_4(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

bool sipQSerialPort::open( ::QIODevice::OpenMode a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QSerialPort::open(a0);

    extern bool sipVH_QtSerialPort_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QIODevice::OpenMode);

    return sipVH_QtSerialPort_8(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

void sipQSerialPort::close()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
         ::QSerialPort::close();
        return;
    }

    extern void sipVH_QtSerialPort_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtSerialPort_7(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

 ::qint64 sipQSerialPort::pos() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QSerialPort::pos();

    extern  ::qint64 sipVH_QtSerialPort_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSerialPort_5(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

 ::qint64 sipQSerialPort::size() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QSerialPort::size();

    extern  ::qint64 sipVH_QtSerialPort_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSerialPort_5(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

bool sipQSerialPort::seek( ::qint64 a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QSerialPort::seek(a0);

    extern bool sipVH_QtSerialPort_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::qint64);

    return sipVH_QtSerialPort_6(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

bool sipQSerialPort::atEnd() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QSerialPort::atEnd();

    extern bool sipVH_QtSerialPort_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSerialPort_4(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

bool sipQSerialPort::reset()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[14],sipPySelf,NULL,sipName_reset);

    if (!sipMeth)
        return  ::QSerialPort::reset();

    extern bool sipVH_QtSerialPort_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSerialPort_4(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

 ::qint64 sipQSerialPort::bytesAvailable() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QSerialPort::bytesAvailable();

    extern  ::qint64 sipVH_QtSerialPort_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSerialPort_5(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

 ::qint64 sipQSerialPort::bytesToWrite() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QSerialPort::bytesToWrite();

    extern  ::qint64 sipVH_QtSerialPort_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSerialPort_5(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

bool sipQSerialPort::canReadLine() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QSerialPort::canReadLine();

    extern bool sipVH_QtSerialPort_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSerialPort_4(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

bool sipQSerialPort::waitForReadyRead(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[18],sipPySelf,NULL,sipName_waitForReadyRead);

    if (!sipMeth)
        return  ::QSerialPort::waitForReadyRead(a0);

    extern bool sipVH_QtSerialPort_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    return sipVH_QtSerialPort_3(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

bool sipQSerialPort::waitForBytesWritten(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[19],sipPySelf,NULL,sipName_waitForBytesWritten);

    if (!sipMeth)
        return  ::QSerialPort::waitForBytesWritten(a0);

    extern bool sipVH_QtSerialPort_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    return sipVH_QtSerialPort_3(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

 ::qint64 sipQSerialPort::readData(char*a0, ::qint64 a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[20],sipPySelf,NULL,sipName_readData);

    if (!sipMeth)
        return  ::QSerialPort::readData(a0,a1);

    extern  ::qint64 sipVH_QtSerialPort_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, char*, ::qint64);

    return sipVH_QtSerialPort_2(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

 ::qint64 sipQSerialPort::readLineData(char*a0, ::qint64 a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[21],sipPySelf,NULL,sipName_readLineData);

    if (!sipMeth)
        return  ::QSerialPort::readLineData(a0,a1);

    extern  ::qint64 sipVH_QtSerialPort_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, char*, ::qint64);

    return sipVH_QtSerialPort_1(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

 ::qint64 sipQSerialPort::writeData(const char*a0,PY_LONG_LONG a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[22],sipPySelf,NULL,sipName_writeData);

    if (!sipMeth)
        return  ::QSerialPort::writeData(a0,a1);

    extern  ::qint64 sipVH_QtSerialPort_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*,PY_LONG_LONG);

    return sipVH_QtSerialPort_0(sipGILState, sipImportedVirtErrorHandlers_QtSerialPort_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0, a1);
}

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

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

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

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

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

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

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

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

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

void sipQSerialPort::sipProtect_setOpenMode( ::QIODevice::OpenMode a0)
{
     ::QIODevice::setOpenMode(a0);
}

void sipQSerialPort::sipProtect_setErrorString(const  ::QString& a0)
{
     ::QIODevice::setErrorString(a0);
}

 ::qint64 sipQSerialPort::sipProtectVirt_readData(bool sipSelfWasArg,char*a0, ::qint64 a1)
{
    return (sipSelfWasArg ?  ::QSerialPort::readData(a0,a1) : readData(a0,a1));
}

 ::qint64 sipQSerialPort::sipProtectVirt_readLineData(bool sipSelfWasArg,char*a0, ::qint64 a1)
{
    return (sipSelfWasArg ?  ::QSerialPort::readLineData(a0,a1) : readLineData(a0,a1));
}

 ::qint64 sipQSerialPort::sipProtectVirt_writeData(bool sipSelfWasArg,const char*a0,PY_LONG_LONG a1)
{
    return (sipSelfWasArg ?  ::QSerialPort::writeData(a0,a1) : writeData(a0,a1));
}


PyDoc_STRVAR(doc_QSerialPort_sender, "sender(self) -> QObject");

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

    {
        const sipQSerialPort *sipCpp;

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

#line 560 "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");
                Q_ASSERT(qtcore_qobject_sender);
            }
        
            sipRes = qtcore_qobject_sender();
        }
#line 3405 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

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

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

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_receivers, "receivers(self, PYQT_SIGNAL) -> int");

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

    {
        PyObject * a0;
        const sipQSerialPort *sipCpp;

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

#line 591 "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");
            Q_ASSERT(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 3465 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.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_QSerialPort, sipName_receivers, doc_QSerialPort_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_timerEvent, "timerEvent(self, QTimerEvent)");

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

    {
         ::QTimerEvent* a0;
        sipQSerialPort *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSerialPort, &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_QSerialPort, sipName_timerEvent, doc_QSerialPort_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_childEvent, "childEvent(self, QChildEvent)");

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

    {
         ::QChildEvent* a0;
        sipQSerialPort *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSerialPort, &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_QSerialPort, sipName_childEvent, doc_QSerialPort_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_customEvent, "customEvent(self, QEvent)");

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

    {
         ::QEvent* a0;
        sipQSerialPort *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSerialPort, &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_QSerialPort, sipName_customEvent, doc_QSerialPort_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_connectNotify, "connectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQSerialPort *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSerialPort, &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_QSerialPort, sipName_connectNotify, doc_QSerialPort_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_disconnectNotify, "disconnectNotify(self, QMetaMethod)");

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

    {
        const  ::QMetaMethod* a0;
        sipQSerialPort *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSerialPort, &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_QSerialPort, sipName_disconnectNotify, doc_QSerialPort_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_senderSignalIndex, "senderSignalIndex(self) -> int");

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

    {
        const sipQSerialPort *sipCpp;

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

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_isSignalConnected, "isSignalConnected(self, QMetaMethod) -> bool");

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

    {
        const  ::QMetaMethod* a0;
        const sipQSerialPort *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSerialPort, &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_QSerialPort, sipName_isSignalConnected, doc_QSerialPort_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setOpenMode, "setOpenMode(self, Union[QIODevice.OpenMode, QIODevice.OpenModeFlag])");

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

    {
         ::QIODevice::OpenMode* a0;
        int a0State = 0;
        sipQSerialPort *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSerialPort, &sipCpp, sipType_QIODevice_OpenMode, &a0, &a0State))
        {
            sipCpp->sipProtect_setOpenMode(*a0);
            sipReleaseType(a0,sipType_QIODevice_OpenMode,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setOpenMode, doc_QSerialPort_setOpenMode);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setErrorString, "setErrorString(self, str)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
        sipQSerialPort *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSerialPort, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->sipProtect_setErrorString(*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_QSerialPort, sipName_setErrorString, doc_QSerialPort_setErrorString);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setPortName, "setPortName(self, str)");

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

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSerialPort, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setPortName(*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_QSerialPort, sipName_setPortName, doc_QSerialPort_setPortName);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_portName, "portName(self) -> str");

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

    {
        const  ::QSerialPort *sipCpp;

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

            sipRes = new  ::QString(sipCpp->portName());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_portName, doc_QSerialPort_portName);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setPort, "setPort(self, QSerialPortInfo)");

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

    {
        const  ::QSerialPortInfo* a0;
         ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSerialPort, &sipCpp, sipType_QSerialPortInfo, &a0))
        {
            sipCpp->setPort(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setPort, doc_QSerialPort_setPort);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_open, "open(self, Union[QIODevice.OpenMode, QIODevice.OpenModeFlag]) -> bool");

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

    {
         ::QIODevice::OpenMode* a0;
        int a0State = 0;
         ::QSerialPort *sipCpp;

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

            sipRes = (sipSelfWasArg ? sipCpp-> ::QSerialPort::open(*a0) : sipCpp->open(*a0));
            sipReleaseType(a0,sipType_QIODevice_OpenMode,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_open, doc_QSerialPort_open);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_close, "close(self)");

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

    {
         ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSerialPort, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp-> ::QSerialPort::close() : sipCpp->close());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_close, doc_QSerialPort_close);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setSettingsRestoredOnClose, "setSettingsRestoredOnClose(self, bool)");

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

    {
        bool a0;
         ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QSerialPort, &sipCpp, &a0))
        {
            sipCpp->setSettingsRestoredOnClose(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setSettingsRestoredOnClose, doc_QSerialPort_setSettingsRestoredOnClose);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_settingsRestoredOnClose, "settingsRestoredOnClose(self) -> bool");

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

    {
        const  ::QSerialPort *sipCpp;

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

            sipRes = sipCpp->settingsRestoredOnClose();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_settingsRestoredOnClose, doc_QSerialPort_settingsRestoredOnClose);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setBaudRate, "setBaudRate(self, int, dir: Union[QSerialPort.Directions, QSerialPort.Direction] = QSerialPort.AllDirections) -> bool");

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

    {
         ::qint32 a0;
         ::QSerialPort::Directions a1def = QSerialPort::AllDirections;
         ::QSerialPort::Directions* a1 = &a1def;
        int a1State = 0;
         ::QSerialPort *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bi|J1", &sipSelf, sipType_QSerialPort, &sipCpp, &a0, sipType_QSerialPort_Directions, &a1, &a1State))
        {
            bool sipRes;

            sipRes = sipCpp->setBaudRate(a0,*a1);
            sipReleaseType(a1,sipType_QSerialPort_Directions,a1State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setBaudRate, doc_QSerialPort_setBaudRate);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_baudRate, "baudRate(self, dir: Union[QSerialPort.Directions, QSerialPort.Direction] = QSerialPort.AllDirections) -> int");

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

    {
         ::QSerialPort::Directions a0def = QSerialPort::AllDirections;
         ::QSerialPort::Directions* a0 = &a0def;
        int a0State = 0;
        const  ::QSerialPort *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J1", &sipSelf, sipType_QSerialPort, &sipCpp, sipType_QSerialPort_Directions, &a0, &a0State))
        {
             ::qint32 sipRes;

            sipRes = sipCpp->baudRate(*a0);
            sipReleaseType(a0,sipType_QSerialPort_Directions,a0State);

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_baudRate, doc_QSerialPort_baudRate);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setDataBits, "setDataBits(self, QSerialPort.DataBits) -> bool");

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

    {
         ::QSerialPort::DataBits a0;
         ::QSerialPort *sipCpp;

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

            sipRes = sipCpp->setDataBits(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setDataBits, doc_QSerialPort_setDataBits);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_dataBits, "dataBits(self) -> QSerialPort.DataBits");

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

    {
        const  ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSerialPort, &sipCpp))
        {
             ::QSerialPort::DataBits sipRes;

            sipRes = sipCpp->dataBits();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QSerialPort_DataBits);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_dataBits, doc_QSerialPort_dataBits);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setParity, "setParity(self, QSerialPort.Parity) -> bool");

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

    {
         ::QSerialPort::Parity a0;
         ::QSerialPort *sipCpp;

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

            sipRes = sipCpp->setParity(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setParity, doc_QSerialPort_setParity);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_parity, "parity(self) -> QSerialPort.Parity");

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

    {
        const  ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSerialPort, &sipCpp))
        {
             ::QSerialPort::Parity sipRes;

            sipRes = sipCpp->parity();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QSerialPort_Parity);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_parity, doc_QSerialPort_parity);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setStopBits, "setStopBits(self, QSerialPort.StopBits) -> bool");

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

    {
         ::QSerialPort::StopBits a0;
         ::QSerialPort *sipCpp;

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

            sipRes = sipCpp->setStopBits(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setStopBits, doc_QSerialPort_setStopBits);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_stopBits, "stopBits(self) -> QSerialPort.StopBits");

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

    {
        const  ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSerialPort, &sipCpp))
        {
             ::QSerialPort::StopBits sipRes;

            sipRes = sipCpp->stopBits();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QSerialPort_StopBits);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_stopBits, doc_QSerialPort_stopBits);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setFlowControl, "setFlowControl(self, QSerialPort.FlowControl) -> bool");

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

    {
         ::QSerialPort::FlowControl a0;
         ::QSerialPort *sipCpp;

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

            sipRes = sipCpp->setFlowControl(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setFlowControl, doc_QSerialPort_setFlowControl);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_flowControl, "flowControl(self) -> QSerialPort.FlowControl");

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

    {
        const  ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSerialPort, &sipCpp))
        {
             ::QSerialPort::FlowControl sipRes;

            sipRes = sipCpp->flowControl();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QSerialPort_FlowControl);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_flowControl, doc_QSerialPort_flowControl);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setDataTerminalReady, "setDataTerminalReady(self, bool) -> bool");

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

    {
        bool a0;
         ::QSerialPort *sipCpp;

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

            sipRes = sipCpp->setDataTerminalReady(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setDataTerminalReady, doc_QSerialPort_setDataTerminalReady);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_isDataTerminalReady, "isDataTerminalReady(self) -> bool");

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

    {
         ::QSerialPort *sipCpp;

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

            sipRes = sipCpp->isDataTerminalReady();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_isDataTerminalReady, doc_QSerialPort_isDataTerminalReady);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setRequestToSend, "setRequestToSend(self, bool) -> bool");

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

    {
        bool a0;
         ::QSerialPort *sipCpp;

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

            sipRes = sipCpp->setRequestToSend(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setRequestToSend, doc_QSerialPort_setRequestToSend);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_isRequestToSend, "isRequestToSend(self) -> bool");

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

    {
         ::QSerialPort *sipCpp;

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

            sipRes = sipCpp->isRequestToSend();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_isRequestToSend, doc_QSerialPort_isRequestToSend);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_pinoutSignals, "pinoutSignals(self) -> QSerialPort.PinoutSignals");

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

    {
         ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSerialPort, &sipCpp))
        {
             ::QSerialPort::PinoutSignals*sipRes;

            sipRes = new  ::QSerialPort::PinoutSignals(sipCpp->pinoutSignals());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_pinoutSignals, doc_QSerialPort_pinoutSignals);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_flush, "flush(self) -> bool");

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

    {
         ::QSerialPort *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->flush();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_flush, doc_QSerialPort_flush);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_clear, "clear(self, dir: Union[QSerialPort.Directions, QSerialPort.Direction] = QSerialPort.AllDirections) -> bool");

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

    {
         ::QSerialPort::Directions a0def = QSerialPort::AllDirections;
         ::QSerialPort::Directions* a0 = &a0def;
        int a0State = 0;
         ::QSerialPort *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J1", &sipSelf, sipType_QSerialPort, &sipCpp, sipType_QSerialPort_Directions, &a0, &a0State))
        {
            bool sipRes;

            sipRes = sipCpp->clear(*a0);
            sipReleaseType(a0,sipType_QSerialPort_Directions,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_clear, doc_QSerialPort_clear);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_atEnd, "atEnd(self) -> bool");

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

    {
        const  ::QSerialPort *sipCpp;

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

            sipRes = (sipSelfWasArg ? sipCpp-> ::QSerialPort::atEnd() : sipCpp->atEnd());

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_atEnd, doc_QSerialPort_atEnd);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setDataErrorPolicy, "setDataErrorPolicy(self, policy: QSerialPort.DataErrorPolicy = QSerialPort.IgnorePolicy) -> bool");

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

    {
         ::QSerialPort::DataErrorPolicy a0 = QSerialPort::IgnorePolicy;
         ::QSerialPort *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|E", &sipSelf, sipType_QSerialPort, &sipCpp, sipType_QSerialPort_DataErrorPolicy, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->setDataErrorPolicy(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setDataErrorPolicy, doc_QSerialPort_setDataErrorPolicy);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_dataErrorPolicy, "dataErrorPolicy(self) -> QSerialPort.DataErrorPolicy");

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

    {
        const  ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSerialPort, &sipCpp))
        {
             ::QSerialPort::DataErrorPolicy sipRes;

            sipRes = sipCpp->dataErrorPolicy();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QSerialPort_DataErrorPolicy);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_dataErrorPolicy, doc_QSerialPort_dataErrorPolicy);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_error, "error(self) -> QSerialPort.SerialPortError");

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

    {
        const  ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSerialPort, &sipCpp))
        {
             ::QSerialPort::SerialPortError sipRes;

            sipRes = sipCpp->error();

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QSerialPort_SerialPortError);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_clearError, "clearError(self)");

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

    {
         ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSerialPort, &sipCpp))
        {
            sipCpp->clearError();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_clearError, doc_QSerialPort_clearError);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_readBufferSize, "readBufferSize(self) -> int");

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

    {
        const  ::QSerialPort *sipCpp;

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

            sipRes = sipCpp->readBufferSize();

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_readBufferSize, doc_QSerialPort_readBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setReadBufferSize, "setReadBufferSize(self, int)");

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

    {
         ::qint64 a0;
         ::QSerialPort *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bn", &sipSelf, sipType_QSerialPort, &sipCpp, &a0))
        {
            sipCpp->setReadBufferSize(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setReadBufferSize, doc_QSerialPort_setReadBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_isSequential, "isSequential(self) -> bool");

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

    {
        const  ::QSerialPort *sipCpp;

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

            sipRes = (sipSelfWasArg ? sipCpp-> ::QSerialPort::isSequential() : sipCpp->isSequential());

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_isSequential, doc_QSerialPort_isSequential);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_bytesAvailable, "bytesAvailable(self) -> int");

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

    {
        const  ::QSerialPort *sipCpp;

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

            sipRes = (sipSelfWasArg ? sipCpp-> ::QSerialPort::bytesAvailable() : sipCpp->bytesAvailable());

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_bytesAvailable, doc_QSerialPort_bytesAvailable);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_bytesToWrite, "bytesToWrite(self) -> int");

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

    {
        const  ::QSerialPort *sipCpp;

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

            sipRes = (sipSelfWasArg ? sipCpp-> ::QSerialPort::bytesToWrite() : sipCpp->bytesToWrite());

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_bytesToWrite, doc_QSerialPort_bytesToWrite);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_canReadLine, "canReadLine(self) -> bool");

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

    {
        const  ::QSerialPort *sipCpp;

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

            sipRes = (sipSelfWasArg ? sipCpp-> ::QSerialPort::canReadLine() : sipCpp->canReadLine());

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_canReadLine, doc_QSerialPort_canReadLine);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_waitForReadyRead, "waitForReadyRead(self, int) -> bool");

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

    {
        int a0;
         ::QSerialPort *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp-> ::QSerialPort::waitForReadyRead(a0) : sipCpp->waitForReadyRead(a0));
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_waitForReadyRead, doc_QSerialPort_waitForReadyRead);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_waitForBytesWritten, "waitForBytesWritten(self, int) -> bool");

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

    {
        int a0;
         ::QSerialPort *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp-> ::QSerialPort::waitForBytesWritten(a0) : sipCpp->waitForBytesWritten(a0));
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_waitForBytesWritten, doc_QSerialPort_waitForBytesWritten);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_sendBreak, "sendBreak(self, duration: int = 0) -> bool");

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

    {
        int a0 = 0;
         ::QSerialPort *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|i", &sipSelf, sipType_QSerialPort, &sipCpp, &a0))
        {
            bool sipRes;

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

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_sendBreak, doc_QSerialPort_sendBreak);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_setBreakEnabled, "setBreakEnabled(self, enabled: bool = True) -> bool");

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

    {
        bool a0 = 1;
         ::QSerialPort *sipCpp;

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

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

            sipRes = sipCpp->setBreakEnabled(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_setBreakEnabled, doc_QSerialPort_setBreakEnabled);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_readData, "readData(self, int) -> bytes");

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

    {
         ::qint64 a0;
        sipQSerialPort *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bn", &sipSelf, sipType_QSerialPort, &sipCpp, &a0))
        {
            PyObject * sipRes = 0;
            int sipIsErr = 0;

#line 224 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
        // Return the data read or None if there was an error.
        if (a0 < 0)
        {
            PyErr_SetString(PyExc_ValueError, "maximum length of data to be read cannot be negative");
            sipIsErr = 1;
        }
        else
        {
            char *s = new char[a0];
            qint64 len;
        
            Py_BEGIN_ALLOW_THREADS
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            len = sipSelfWasArg ? sipCpp->QSerialPort::readData(s, a0) : sipCpp->readData(s, a0);
        #else
            len = sipCpp->sipProtectVirt_readData(sipSelfWasArg, s, a0);
        #endif
            Py_END_ALLOW_THREADS
        
            if (len < 0)
            {
                Py_INCREF(Py_None);
                sipRes = Py_None;
            }
            else
            {
                sipRes = SIPBytes_FromStringAndSize(s, len);
        
                if (!sipRes)
                    sipIsErr = 1;
            }
        
            delete[] s;
        }
#line 4964 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

            if (sipIsErr)
                return 0;

            return sipRes;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_readData, doc_QSerialPort_readData);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_readLineData, "readLineData(self, int) -> bytes");

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

    {
         ::qint64 a0;
        sipQSerialPort *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bn", &sipSelf, sipType_QSerialPort, &sipCpp, &a0))
        {
            PyObject * sipRes = 0;
            int sipIsErr = 0;

#line 262 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/sip/QtSerialPort/qserialport.sip"
        // Return the data read or None if there was an error.
        if (a0 < 0)
        {
            PyErr_SetString(PyExc_ValueError, "maximum length of data to be read cannot be negative");
            sipIsErr = 1;
        }
        else
        {
            char *s = new char[a0];
            qint64 len;
        
            Py_BEGIN_ALLOW_THREADS
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            len = sipSelfWasArg ? sipCpp->QSerialPort::readLineData(s, a0) : sipCpp->readLineData(s, a0);
        #else
            len = sipCpp->sipProtectVirt_readLineData(sipSelfWasArg, s, a0);
        #endif
            Py_END_ALLOW_THREADS
        
            if (len < 0)
            {
                Py_INCREF(Py_None);
                sipRes = Py_None;
            }
            else
            {
                sipRes = SIPBytes_FromStringAndSize(s, len);
        
                if (!sipRes)
                    sipIsErr = 1;
            }
        
            delete[] s;
        }
#line 5033 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9.2-1.i686/build/py3/QtSerialPort/sipQtSerialPortpart0.cpp"

            if (sipIsErr)
                return 0;

            return sipRes;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_readLineData, doc_QSerialPort_readLineData);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_writeData, "writeData(self, bytes) -> int");

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

    {
        const char* a0;
        SIP_SSIZE_T a1;
        sipQSerialPort *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bk", &sipSelf, sipType_QSerialPort, &sipCpp, &a0, &a1))
        {
             ::qint64 sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_writeData(sipSelfWasArg,a0,(PY_LONG_LONG)a1);
            Py_END_ALLOW_THREADS

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_writeData, doc_QSerialPort_writeData);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_handle, "handle(self) -> int");

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

    {
        const  ::QSerialPort *sipCpp;

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

            sipRes = sipCpp->handle();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_handle, doc_QSerialPort_handle);

    return NULL;
}


PyDoc_STRVAR(doc_QSerialPort_isBreakEnabled, "isBreakEnabled(self) -> bool");

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

    {
        const  ::QSerialPort *sipCpp;

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

            sipRes = sipCpp->isBreakEnabled();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSerialPort, sipName_isBreakEnabled, doc_QSerialPort_isBreakEnabled);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QSerialPort(void *, const sipTypeDef *);}
static void *cast_QSerialPort(void *sipCppV, const sipTypeDef *targetType)
{
     ::QSerialPort *sipCpp = reinterpret_cast< ::QSerialPort *>(sipCppV);

    if (targetType == sipType_QIODevice)
        return static_cast< ::QIODevice *>(sipCpp);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


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

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


extern "C" {static void dealloc_QSerialPort(sipSimpleWrapper *);}
static void dealloc_QSerialPort(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQSerialPort *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QSerialPort(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


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

    {
         ::QObject* a0 = 0;

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

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

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

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

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J1|JH", sipType_QString,&a0, &a0State, sipType_QObject, &a1, sipOwner))
        {
            sipCpp = new sipQSerialPort(*a0,a1);
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QSerialPortInfo* a0;
         ::QObject* a1 = 0;

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

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9|JH", sipType_QSerialPortInfo, &a0, sipType_QObject, &a1, sipOwner))
        {
            sipCpp = new sipQSerialPort(*a0,a1);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QSerialPort[] = {
    {SIP_MLNAME_CAST(sipName_atEnd), meth_QSerialPort_atEnd, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_atEnd)},
    {SIP_MLNAME_CAST(sipName_baudRate), (PyCFunction)meth_QSerialPort_baudRate, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSerialPort_baudRate)},
    {SIP_MLNAME_CAST(sipName_bytesAvailable), meth_QSerialPort_bytesAvailable, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_bytesAvailable)},
    {SIP_MLNAME_CAST(sipName_bytesToWrite), meth_QSerialPort_bytesToWrite, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_bytesToWrite)},
    {SIP_MLNAME_CAST(sipName_canReadLine), meth_QSerialPort_canReadLine, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_canReadLine)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QSerialPort_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_clear), (PyCFunction)meth_QSerialPort_clear, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSerialPort_clear)},
    {SIP_MLNAME_CAST(sipName_clearError), meth_QSerialPort_clearError, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_clearError)},
    {SIP_MLNAME_CAST(sipName_close), meth_QSerialPort_close, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_close)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QSerialPort_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QSerialPort_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_dataBits), meth_QSerialPort_dataBits, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_dataBits)},
    {SIP_MLNAME_CAST(sipName_dataErrorPolicy), meth_QSerialPort_dataErrorPolicy, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_dataErrorPolicy)},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QSerialPort_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_error), meth_QSerialPort_error, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_error)},
    {SIP_MLNAME_CAST(sipName_flowControl), meth_QSerialPort_flowControl, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_flowControl)},
    {SIP_MLNAME_CAST(sipName_flush), meth_QSerialPort_flush, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_flush)},
    {SIP_MLNAME_CAST(sipName_handle), meth_QSerialPort_handle, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_handle)},
    {SIP_MLNAME_CAST(sipName_isBreakEnabled), meth_QSerialPort_isBreakEnabled, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_isBreakEnabled)},
    {SIP_MLNAME_CAST(sipName_isDataTerminalReady), meth_QSerialPort_isDataTerminalReady, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_isDataTerminalReady)},
    {SIP_MLNAME_CAST(sipName_isRequestToSend), meth_QSerialPort_isRequestToSend, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_isRequestToSend)},
    {SIP_MLNAME_CAST(sipName_isSequential), meth_QSerialPort_isSequential, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_isSequential)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QSerialPort_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_open), meth_QSerialPort_open, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_open)},
    {SIP_MLNAME_CAST(sipName_parity), meth_QSerialPort_parity, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_parity)},
    {SIP_MLNAME_CAST(sipName_pinoutSignals), meth_QSerialPort_pinoutSignals, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_pinoutSignals)},
    {SIP_MLNAME_CAST(sipName_portName), meth_QSerialPort_portName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_portName)},
    {SIP_MLNAME_CAST(sipName_readBufferSize), meth_QSerialPort_readBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_readBufferSize)},
    {SIP_MLNAME_CAST(sipName_readData), (PyCFunction)meth_QSerialPort_readData, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSerialPort_readData)},
    {SIP_MLNAME_CAST(sipName_readLineData), (PyCFunction)meth_QSerialPort_readLineData, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSerialPort_readLineData)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QSerialPort_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_sendBreak), (PyCFunction)meth_QSerialPort_sendBreak, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSerialPort_sendBreak)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QSerialPort_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QSerialPort_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setBaudRate), (PyCFunction)meth_QSerialPort_setBaudRate, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSerialPort_setBaudRate)},
    {SIP_MLNAME_CAST(sipName_setBreakEnabled), (PyCFunction)meth_QSerialPort_setBreakEnabled, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSerialPort_setBreakEnabled)},
    {SIP_MLNAME_CAST(sipName_setDataBits), meth_QSerialPort_setDataBits, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_setDataBits)},
    {SIP_MLNAME_CAST(sipName_setDataErrorPolicy), (PyCFunction)meth_QSerialPort_setDataErrorPolicy, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSerialPort_setDataErrorPolicy)},
    {SIP_MLNAME_CAST(sipName_setDataTerminalReady), meth_QSerialPort_setDataTerminalReady, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_setDataTerminalReady)},
    {SIP_MLNAME_CAST(sipName_setErrorString), (PyCFunction)meth_QSerialPort_setErrorString, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setFlowControl), meth_QSerialPort_setFlowControl, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_setFlowControl)},
    {SIP_MLNAME_CAST(sipName_setOpenMode), (PyCFunction)meth_QSerialPort_setOpenMode, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setParity), meth_QSerialPort_setParity, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_setParity)},
    {SIP_MLNAME_CAST(sipName_setPort), meth_QSerialPort_setPort, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_setPort)},
    {SIP_MLNAME_CAST(sipName_setPortName), meth_QSerialPort_setPortName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_setPortName)},
    {SIP_MLNAME_CAST(sipName_setReadBufferSize), meth_QSerialPort_setReadBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_setReadBufferSize)},
    {SIP_MLNAME_CAST(sipName_setRequestToSend), meth_QSerialPort_setRequestToSend, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_setRequestToSend)},
    {SIP_MLNAME_CAST(sipName_setSettingsRestoredOnClose), meth_QSerialPort_setSettingsRestoredOnClose, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_setSettingsRestoredOnClose)},
    {SIP_MLNAME_CAST(sipName_setStopBits), meth_QSerialPort_setStopBits, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_setStopBits)},
    {SIP_MLNAME_CAST(sipName_settingsRestoredOnClose), meth_QSerialPort_settingsRestoredOnClose, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_settingsRestoredOnClose)},
    {SIP_MLNAME_CAST(sipName_stopBits), meth_QSerialPort_stopBits, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_stopBits)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QSerialPort_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_waitForBytesWritten), meth_QSerialPort_waitForBytesWritten, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_waitForBytesWritten)},
    {SIP_MLNAME_CAST(sipName_waitForReadyRead), meth_QSerialPort_waitForReadyRead, METH_VARARGS, SIP_MLDOC_CAST(doc_QSerialPort_waitForReadyRead)},
    {SIP_MLNAME_CAST(sipName_writeData), (PyCFunction)meth_QSerialPort_writeData, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSerialPort_writeData)}
};

static sipEnumMemberDef enummembers_QSerialPort[] = {
    {sipName_AllDirections, static_cast<int>( ::QSerialPort::AllDirections), 5},
    {sipName_Baud115200, static_cast<int>( ::QSerialPort::Baud115200), 2},
    {sipName_Baud1200, static_cast<int>( ::QSerialPort::Baud1200), 2},
    {sipName_Baud19200, static_cast<int>( ::QSerialPort::Baud19200), 2},
    {sipName_Baud2400, static_cast<int>( ::QSerialPort::Baud2400), 2},
    {sipName_Baud38400, static_cast<int>( ::QSerialPort::Baud38400), 2},
    {sipName_Baud4800, static_cast<int>( ::QSerialPort::Baud4800), 2},
    {sipName_Baud57600, static_cast<int>( ::QSerialPort::Baud57600), 2},
    {sipName_Baud9600, static_cast<int>( ::QSerialPort::Baud9600), 2},
    {sipName_BreakConditionError, static_cast<int>( ::QSerialPort::BreakConditionError), 11},
    {sipName_ClearToSendSignal, static_cast<int>( ::QSerialPort::ClearToSendSignal), 9},
    {sipName_Data5, static_cast<int>( ::QSerialPort::Data5), 3},
    {sipName_Data6, static_cast<int>( ::QSerialPort::Data6), 3},
    {sipName_Data7, static_cast<int>( ::QSerialPort::Data7), 3},
    {sipName_Data8, static_cast<int>( ::QSerialPort::Data8), 3},
    {sipName_DataCarrierDetectSignal, static_cast<int>( ::QSerialPort::DataCarrierDetectSignal), 9},
    {sipName_DataSetReadySignal, static_cast<int>( ::QSerialPort::DataSetReadySignal), 9},
    {sipName_DataTerminalReadySignal, static_cast<int>( ::QSerialPort::DataTerminalReadySignal), 9},
    {sipName_DeviceNotFoundError, static_cast<int>( ::QSerialPort::DeviceNotFoundError), 11},
    {sipName_EvenParity, static_cast<int>( ::QSerialPort::EvenParity), 8},
    {sipName_FramingError, static_cast<int>( ::QSerialPort::FramingError), 11},
    {sipName_HardwareControl, static_cast<int>( ::QSerialPort::HardwareControl), 7},
    {sipName_IgnorePolicy, static_cast<int>( ::QSerialPort::IgnorePolicy), 4},
    {sipName_Input, static_cast<int>( ::QSerialPort::Input), 5},
    {sipName_MarkParity, static_cast<int>( ::QSerialPort::MarkParity), 8},
    {sipName_NoError, static_cast<int>( ::QSerialPort::NoError), 11},
    {sipName_NoFlowControl, static_cast<int>( ::QSerialPort::NoFlowControl), 7},
    {sipName_NoParity, static_cast<int>( ::QSerialPort::NoParity), 8},
    {sipName_NoSignal, static_cast<int>( ::QSerialPort::NoSignal), 9},
    {sipName_NotOpenError, static_cast<int>( ::QSerialPort::NotOpenError), 11},
    {sipName_OddParity, static_cast<int>( ::QSerialPort::OddParity), 8},
    {sipName_OneAndHalfStop, static_cast<int>( ::QSerialPort::OneAndHalfStop), 12},
    {sipName_OneStop, static_cast<int>( ::QSerialPort::OneStop), 12},
    {sipName_OpenError, static_cast<int>( ::QSerialPort::OpenError), 11},
    {sipName_Output, static_cast<int>( ::QSerialPort::Output), 5},
    {sipName_ParityError, static_cast<int>( ::QSerialPort::ParityError), 11},
    {sipName_PassZeroPolicy, static_cast<int>( ::QSerialPort::PassZeroPolicy), 4},
    {sipName_PermissionError, static_cast<int>( ::QSerialPort::PermissionError), 11},
    {sipName_ReadError, static_cast<int>( ::QSerialPort::ReadError), 11},
    {sipName_ReceivedDataSignal, static_cast<int>( ::QSerialPort::ReceivedDataSignal), 9},
    {sipName_RequestToSendSignal, static_cast<int>( ::QSerialPort::RequestToSendSignal), 9},
    {sipName_ResourceError, static_cast<int>( ::QSerialPort::ResourceError), 11},
    {sipName_RingIndicatorSignal, static_cast<int>( ::QSerialPort::RingIndicatorSignal), 9},
    {sipName_SecondaryReceivedDataSignal, static_cast<int>( ::QSerialPort::SecondaryReceivedDataSignal), 9},
    {sipName_SecondaryTransmittedDataSignal, static_cast<int>( ::QSerialPort::SecondaryTransmittedDataSignal), 9},
    {sipName_SkipPolicy, static_cast<int>( ::QSerialPort::SkipPolicy), 4},
    {sipName_SoftwareControl, static_cast<int>( ::QSerialPort::SoftwareControl), 7},
    {sipName_SpaceParity, static_cast<int>( ::QSerialPort::SpaceParity), 8},
    {sipName_StopReceivingPolicy, static_cast<int>( ::QSerialPort::StopReceivingPolicy), 4},
    {sipName_TimeoutError, static_cast<int>( ::QSerialPort::TimeoutError), 11},
    {sipName_TransmittedDataSignal, static_cast<int>( ::QSerialPort::TransmittedDataSignal), 9},
    {sipName_TwoStop, static_cast<int>( ::QSerialPort::TwoStop), 12},
    {sipName_UnknownBaud, static_cast<int>( ::QSerialPort::UnknownBaud), 2},
    {sipName_UnknownDataBits, static_cast<int>( ::QSerialPort::UnknownDataBits), 3},
    {sipName_UnknownError, static_cast<int>( ::QSerialPort::UnknownError), 11},
    {sipName_UnknownFlowControl, static_cast<int>( ::QSerialPort::UnknownFlowControl), 7},
    {sipName_UnknownParity, static_cast<int>( ::QSerialPort::UnknownParity), 8},
    {sipName_UnknownPolicy, static_cast<int>( ::QSerialPort::UnknownPolicy), 4},
    {sipName_UnknownStopBits, static_cast<int>( ::QSerialPort::UnknownStopBits), 12},
    {sipName_UnsupportedOperationError, static_cast<int>( ::QSerialPort::UnsupportedOperationError), 11},
    {sipName_WriteError, static_cast<int>( ::QSerialPort::WriteError), 11},
};

PyDoc_STRVAR(doc_QSerialPort, "\1QSerialPort(parent: QObject = None)\n"
    "QSerialPort(str, parent: QObject = None)\n"
    "QSerialPort(QSerialPortInfo, parent: QObject = None)");


/* Define this type's signals. */
static const pyqt5QtSignal signals_QSerialPort[] = {
    {"errorOccurred(QSerialPort::SerialPortError)", "\1errorOccurred(self, QSerialPort.SerialPortError)", 0, 0},
    {"breakEnabledChanged(bool)", "\1breakEnabledChanged(self, bool)", 0, 0},
    {"settingsRestoredOnCloseChanged(bool)", "\1settingsRestoredOnCloseChanged(self, bool)", 0, 0},
    {"requestToSendChanged(bool)", "\1requestToSendChanged(self, bool)", 0, 0},
    {"dataTerminalReadyChanged(bool)", "\1dataTerminalReadyChanged(self, bool)", 0, 0},
    {"dataErrorPolicyChanged(QSerialPort::DataErrorPolicy)", "\1dataErrorPolicyChanged(self, QSerialPort.DataErrorPolicy)", 0, 0},
    {"flowControlChanged(QSerialPort::FlowControl)", "\1flowControlChanged(self, QSerialPort.FlowControl)", 0, 0},
    {"stopBitsChanged(QSerialPort::StopBits)", "\1stopBitsChanged(self, QSerialPort.StopBits)", 0, 0},
    {"parityChanged(QSerialPort::Parity)", "\1parityChanged(self, QSerialPort.Parity)", 0, 0},
    {"dataBitsChanged(QSerialPort::DataBits)", "\1dataBitsChanged(self, QSerialPort.DataBits)", 0, 0},
    {"baudRateChanged(qint32,QSerialPort::Directions)", "\1baudRateChanged(self, int, Union[QSerialPort.Directions, QSerialPort.Direction])", 0, 0},
    {"error(QSerialPort::SerialPortError)", "\1error(self, QSerialPort.SerialPortError)", &methods_QSerialPort[14], 0},
    {0, 0, 0, 0}
};


static pyqt5ClassPluginDef plugin_QSerialPort = {
    & ::QSerialPort::staticMetaObject,
    0,
    signals_QSerialPort,
    0
};


sipClassTypeDef sipTypeDef_QtSerialPort_QSerialPort = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QSerialPort,
        {0},
        &plugin_QSerialPort
    },
    {
        sipNameNr_QSerialPort,
        {0, 0, 1},
        55, methods_QSerialPort,
        61, enummembers_QSerialPort,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSerialPort,
    -1,
    -1,
    supers_QSerialPort,
    0,
    init_type_QSerialPort,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSerialPort,
    0,
    0,
    0,
    release_QSerialPort,
    cast_QSerialPort,
    0,
    0,
    0,
    0,
    0,
    0
};
