/*
 * Module code.
 *
 * Generated by SIP 4.19.3
 *
 * 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 "sipAPIQtWebSockets.h"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 29 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 32 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 35 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 38 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 41 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qwebsocket.sip"
#include <qwebsocket.h>
#line 44 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"

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

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

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

    return sipRes;
}

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

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

    return sipRes;
}

bool sipVH_QtWebSockets_6(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_QtWebSockets_5(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_QtWebSockets_4(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;
}

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

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

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

void sipVH_QtWebSockets_0(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);
}


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

#line 32 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qwebsocket.sip"
    static struct class_graph {
        const char *name;
        sipTypeDef **type;
        int yes, no;
    } graph[] = {
        {sipName_QWebSocket, &sipType_QWebSocket, -1, 1},
        {sipName_QWebSocketServer, &sipType_QWebSocketServer, -1, 2},
        {sipName_QMaskGenerator, &sipType_QMaskGenerator, -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 314 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"

    return sipType;
}
static sipEnumTypeDef enumTypes[] = {
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QWebSocketServer__SslMode, {0}, 0}, sipNameNr_SslMode, 7, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QWebSocketProtocol__CloseCode, {0}, 0}, sipNameNr_CloseCode, 4, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QWebSocketProtocol__Version, {0}, 0}, sipNameNr_Version, 4, NULL},
};


/*
 * This defines each type in this module.
 */
sipTypeDef *sipExportedTypes_QtWebSockets[] = {
    &sipTypeDef_QtWebSockets_QList_0100QWebSocketProtocol_Version.mtd_base,
    &sipTypeDef_QtWebSockets_QMaskGenerator.ctd_base,
    &sipTypeDef_QtWebSockets_QWebSocket.ctd_base,
    &sipTypeDef_QtWebSockets_QWebSocketCorsAuthenticator.ctd_base,
    &sipTypeDef_QtWebSockets_QWebSocketProtocol.ctd_base,
    &enumTypes[1].etd_base,
    &enumTypes[2].etd_base,
    &sipTypeDef_QtWebSockets_QWebSocketServer.ctd_base,
    &enumTypes[0].etd_base,
};


/* This defines the types that this module needs to import from QtCore. */
sipImportedTypeDef sipImportedTypes_QtWebSockets_QtCore[] = {
    {"QByteArray"},
    {"QChildEvent"},
    {"QEvent"},
    {"QMetaMethod"},
    {"QObject"},
    {"QString"},
    {"QTimerEvent"},
    {"QUrl"},
    {NULL}
};


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


/* This defines the types that this module needs to import from QtNetwork. */
sipImportedTypeDef sipImportedTypes_QtWebSockets_QtNetwork[] = {
    {"QAbstractSocket::PauseModes"},
    {"QAbstractSocket::SocketError"},
    {"QAbstractSocket::SocketState"},
    {"QAuthenticator"},
    {"QHostAddress"},
    {"QList<QSslError>"},
    {"QNetworkProxy"},
    {"QNetworkRequest"},
    {"QSslConfiguration"},
    {"QSslError"},
    {"QSslPreSharedKeyAuthenticator"},
    {"QTcpSocket"},
    {NULL}
};


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


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


/* This defines this module. */
sipExportedModuleDef sipModuleAPI_QtWebSockets = {
    0,
    SIP_API_MINOR_NR,
    sipNameNr_PyQt5_QtWebSockets,
    0,
    sipStrings_QtWebSockets,
    importsTable,
    NULL,
    9,
    sipExportedTypes_QtWebSockets,
    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_QtWebSockets;

sip_qt_metaobject_func sip_QtWebSockets_qt_metaobject;
sip_qt_metacall_func sip_QtWebSockets_qt_metacall;
sip_qt_metacast_func sip_QtWebSockets_qt_metacast;


/* The Python module initialisation function. */
#if PY_MAJOR_VERSION >= 3
#define SIP_MODULE_ENTRY        PyInit_QtWebSockets
#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        initQtWebSockets
#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.QtWebSockets",
        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_QtWebSockets, sip_methods);
#else
    sipModule = Py_InitModule(const_cast<char *>(sipName_PyQt5_QtWebSockets), 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_QtWebSockets = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, SIP_MODULE_NAME "._C_API"));
#else
    sipAPI_QtWebSockets = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif

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

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

    sip_QtWebSockets_qt_metaobject = (sip_qt_metaobject_func)sipImportSymbol("qtcore_qt_metaobject");
    sip_QtWebSockets_qt_metacall = (sip_qt_metacall_func)sipImportSymbol("qtcore_qt_metacall");
    sip_QtWebSockets_qt_metacast = (sip_qt_metacast_func)sipImportSymbol("qtcore_qt_metacast");

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

    /* Initialise the module now all its dependencies have been set up. */
    if (sipInitModule(&sipModuleAPI_QtWebSockets,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 556 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qwebsocketprotocol.sip"
#include <qwebsocketprotocol.h>
#line 560 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"


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


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


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


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



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

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

    if (!sipIsErr)
    {
        Py_XDECREF(iter);

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

    if (!iter)
    {
        *sipIsErr = 1;

        return 0;
    }

    QList<QWebSocketProtocol::Version> *ql = new QList<QWebSocketProtocol::Version>;
 
    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;
        QWebSocketProtocol::Version *t = reinterpret_cast<QWebSocketProtocol::Version *>(
                sipForceConvertToType(itm, sipType_QWebSocketProtocol_Version, sipTransferObj,
                        SIP_NOT_NONE, &state, sipIsErr));

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

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

            return 0;
        }

        ql->append(*t);

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

    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 669 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
}


extern "C" {static PyObject *convertFrom_QList_0100QWebSocketProtocol_Version(void *, PyObject *);}
static PyObject *convertFrom_QList_0100QWebSocketProtocol_Version(void *sipCppV, PyObject *sipTransferObj)
{
   QList< ::QWebSocketProtocol::Version> *sipCpp = reinterpret_cast<QList< ::QWebSocketProtocol::Version> *>(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)
    {
        QWebSocketProtocol::Version *t = new QWebSocketProtocol::Version(sipCpp->at(i));
        PyObject *tobj = sipConvertFromNewType(t, sipType_QWebSocketProtocol_Version,
                sipTransferObj);

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

            return 0;
        }

        PyList_SetItem(l, i, tobj);
    }

    return l;
#line 702 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtWebSockets_QList_0100QWebSocketProtocol_Version = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_0,     /* QList<QWebSocketProtocol::Version> */
        {0},
        0
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0100QWebSocketProtocol_Version,
    array_QList_0100QWebSocketProtocol_Version,
    copy_QList_0100QWebSocketProtocol_Version,
    release_QList_0100QWebSocketProtocol_Version,
    convertTo_QList_0100QWebSocketProtocol_Version,
    convertFrom_QList_0100QWebSocketProtocol_Version
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qwebsocketserver.sip"
#include <qwebsocketserver.h>
#line 734 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"

#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 738 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 741 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 29 "sip/QtNetwork/qsslpresharedkeyauthenticator.sip"
#include <qsslpresharedkeyauthenticator.h>
#line 744 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 747 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 28 "sip/QtNetwork/qsslerror.sip"
#include <qsslerror.h>
#line 750 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qwebsocketcorsauthenticator.sip"
#include <qwebsocketcorsauthenticator.h>
#line 753 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qwebsocketprotocol.sip"
#include <qwebsocketprotocol.h>
#line 756 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtNetwork/qabstractsocket.sip"
#include <qabstractsocket.h>
#line 759 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtNetwork/qtcpsocket.sip"
#include <qtcpsocket.h>
#line 762 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 96 "sip/QtCore/qurl.sip"
#include <qurl.h>
#line 765 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 768 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 28 "sip/QtNetwork/qsslconfiguration.sip"
#include <qsslconfiguration.h>
#line 771 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtNetwork/qnetworkproxy.sip"
#include <qnetworkproxy.h>
#line 774 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qwebsocket.sip"
#include <qwebsocket.h>
#line 777 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtNetwork/qhostaddress.sip"
#include <qhostaddress.h>
#line 780 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 783 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 786 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 789 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 792 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 795 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 798 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 801 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 148 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 804 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 807 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 810 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 813 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 816 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 819 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 822 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"


class sipQWebSocketServer : public  ::QWebSocketServer
{
public:
    sipQWebSocketServer(const  ::QString&, ::QWebSocketServer::SslMode, ::QObject*);
    virtual ~sipQWebSocketServer();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
     ::QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool, ::QTimerEvent*);
    void sipProtectVirt_childEvent(bool, ::QChildEvent*);
    void sipProtectVirt_customEvent(bool, ::QEvent*);
    void sipProtectVirt_connectNotify(bool,const  ::QMetaMethod&);
    void sipProtectVirt_disconnectNotify(bool,const  ::QMetaMethod&);
    int sipProtect_senderSignalIndex() const;
    bool sipProtect_isSignalConnected(const  ::QMetaMethod&) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
     ::QWebSocket* nextPendingConnection();
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const  ::QMetaMethod&);
    void disconnectNotify(const  ::QMetaMethod&);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[8];
};

sipQWebSocketServer::sipQWebSocketServer(const  ::QString& a0, ::QWebSocketServer::SslMode a1, ::QObject*a2):  ::QWebSocketServer(a0,a1,a2), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

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

const QMetaObject *sipQWebSocketServer::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtWebSockets_qt_metaobject(sipPySelf,sipType_QWebSocketServer);

    return  ::QWebSocketServer::metaObject();
}

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

    if (_id >= 0)
        _id = sip_QtWebSockets_qt_metacall(sipPySelf,sipType_QWebSocketServer,_c,_id,_a);

    return _id;
}

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

    return (sip_QtWebSockets_qt_metacast(sipPySelf, sipType_QWebSocketServer, _clname, &sipCpp) ? sipCpp :  ::QWebSocketServer::qt_metacast(_clname));
}

 ::QWebSocket* sipQWebSocketServer::nextPendingConnection()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::QWebSocketServer::nextPendingConnection();

    extern  ::QWebSocket* sipVH_QtWebSockets_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtWebSockets_8(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

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

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

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

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

    return sipVH_QtWebSockets_5(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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

    sipVH_QtWebSockets_3(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

    sipVH_QtWebSockets_2(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

    sipVH_QtWebSockets_1(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

    sipVH_QtWebSockets_0(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

    sipVH_QtWebSockets_0(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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


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

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

    {
        const sipQWebSocketServer *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QWebSocketServer, &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 1132 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"

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

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

    return NULL;
}


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

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

    {
        PyObject * a0;
        const sipQWebSocketServer *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QWebSocketServer, &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 1192 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.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_QWebSocketServer, sipName_receivers, doc_QWebSocketServer_receivers);

    return NULL;
}


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

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

    {
         ::QTimerEvent* a0;
        sipQWebSocketServer *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QWebSocketServer, &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_QWebSocketServer, sipName_timerEvent, doc_QWebSocketServer_timerEvent);

    return NULL;
}


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

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

    {
         ::QChildEvent* a0;
        sipQWebSocketServer *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QWebSocketServer, &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_QWebSocketServer, sipName_childEvent, doc_QWebSocketServer_childEvent);

    return NULL;
}


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

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

    {
         ::QEvent* a0;
        sipQWebSocketServer *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QWebSocketServer, &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_QWebSocketServer, sipName_customEvent, doc_QWebSocketServer_customEvent);

    return NULL;
}


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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QWebSocketServer, &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_QWebSocketServer, sipName_connectNotify, doc_QWebSocketServer_connectNotify);

    return NULL;
}


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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QWebSocketServer, &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_QWebSocketServer, sipName_disconnectNotify, doc_QWebSocketServer_disconnectNotify);

    return NULL;
}


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

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

    {
        const sipQWebSocketServer *sipCpp;

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

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

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

    return NULL;
}


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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QWebSocketServer, &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_QWebSocketServer, sipName_isSignalConnected, doc_QWebSocketServer_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_listen, "listen(self, address: Union[QHostAddress, QHostAddress.SpecialAddress] = QHostAddress.Any, port: int = 0) -> bool");

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

    {
        const  ::QHostAddress& a0def = QHostAddress::Any;
        const  ::QHostAddress* a0 = &a0def;
        int a0State = 0;
         ::quint16 a1 = 0;
         ::QWebSocketServer *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J1t", &sipSelf, sipType_QWebSocketServer, &sipCpp, sipType_QHostAddress, &a0, &a0State, &a1))
        {
            bool sipRes;

            sipRes = sipCpp->listen(*a0,a1);
            sipReleaseType(const_cast< ::QHostAddress *>(a0),sipType_QHostAddress,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_listen, doc_QWebSocketServer_listen);

    return NULL;
}


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

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

    {
         ::QWebSocketServer *sipCpp;

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

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_isListening, "isListening(self) -> bool");

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

    {
        const  ::QWebSocketServer *sipCpp;

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

            sipRes = sipCpp->isListening();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_isListening, doc_QWebSocketServer_isListening);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_setMaxPendingConnections, "setMaxPendingConnections(self, int)");

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

    {
        int a0;
         ::QWebSocketServer *sipCpp;

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

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_setMaxPendingConnections, doc_QWebSocketServer_setMaxPendingConnections);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_maxPendingConnections, "maxPendingConnections(self) -> int");

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

    {
        const  ::QWebSocketServer *sipCpp;

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

            sipRes = sipCpp->maxPendingConnections();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_maxPendingConnections, doc_QWebSocketServer_maxPendingConnections);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_serverPort, "serverPort(self) -> int");

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

    {
        const  ::QWebSocketServer *sipCpp;

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

            sipRes = sipCpp->serverPort();

#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_QWebSocketServer, sipName_serverPort, doc_QWebSocketServer_serverPort);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_serverAddress, "serverAddress(self) -> QHostAddress");

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

    {
        const  ::QWebSocketServer *sipCpp;

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

            sipRes = new  ::QHostAddress(sipCpp->serverAddress());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_serverAddress, doc_QWebSocketServer_serverAddress);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_secureMode, "secureMode(self) -> QWebSocketServer.SslMode");

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

    {
        const  ::QWebSocketServer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QWebSocketServer, &sipCpp))
        {
             ::QWebSocketServer::SslMode sipRes;

            sipRes = sipCpp->secureMode();

            return sipConvertFromEnum(sipRes,sipType_QWebSocketServer_SslMode);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_secureMode, doc_QWebSocketServer_secureMode);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_setSocketDescriptor, "setSocketDescriptor(self, int) -> bool");

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

    {
        int a0;
         ::QWebSocketServer *sipCpp;

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

            sipRes = sipCpp->setSocketDescriptor(a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_setSocketDescriptor, doc_QWebSocketServer_setSocketDescriptor);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_socketDescriptor, "socketDescriptor(self) -> int");

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

    {
        const  ::QWebSocketServer *sipCpp;

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

            sipRes = sipCpp->socketDescriptor();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_socketDescriptor, doc_QWebSocketServer_socketDescriptor);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_hasPendingConnections, "hasPendingConnections(self) -> bool");

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

    {
        const  ::QWebSocketServer *sipCpp;

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

            sipRes = sipCpp->hasPendingConnections();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_hasPendingConnections, doc_QWebSocketServer_hasPendingConnections);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_nextPendingConnection, "nextPendingConnection(self) -> QWebSocket");

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

    {
         ::QWebSocketServer *sipCpp;

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

            sipRes = (sipSelfWasArg ? sipCpp-> ::QWebSocketServer::nextPendingConnection() : sipCpp->nextPendingConnection());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_nextPendingConnection, doc_QWebSocketServer_nextPendingConnection);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_error, "error(self) -> QWebSocketProtocol.CloseCode");

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

    {
        const  ::QWebSocketServer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QWebSocketServer, &sipCpp))
        {
             ::QWebSocketProtocol::CloseCode sipRes;

            sipRes = sipCpp->error();

            return sipConvertFromEnum(sipRes,sipType_QWebSocketProtocol_CloseCode);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_errorString, "errorString(self) -> str");

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

    {
        const  ::QWebSocketServer *sipCpp;

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

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

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_errorString, doc_QWebSocketServer_errorString);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_pauseAccepting, "pauseAccepting(self)");

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

    {
         ::QWebSocketServer *sipCpp;

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

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_pauseAccepting, doc_QWebSocketServer_pauseAccepting);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_resumeAccepting, "resumeAccepting(self)");

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

    {
         ::QWebSocketServer *sipCpp;

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

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_resumeAccepting, doc_QWebSocketServer_resumeAccepting);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_setServerName, "setServerName(self, str)");

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

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

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QWebSocketServer, &sipCpp, sipType_QString,&a0, &a0State))
        {
            sipCpp->setServerName(*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_QWebSocketServer, sipName_setServerName, doc_QWebSocketServer_setServerName);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_serverName, "serverName(self) -> str");

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

    {
        const  ::QWebSocketServer *sipCpp;

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

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

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_serverName, doc_QWebSocketServer_serverName);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_setProxy, "setProxy(self, QNetworkProxy)");

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

    {
        const  ::QNetworkProxy* a0;
         ::QWebSocketServer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QWebSocketServer, &sipCpp, sipType_QNetworkProxy, &a0))
        {
            sipCpp->setProxy(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_setProxy, doc_QWebSocketServer_setProxy);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_proxy, "proxy(self) -> QNetworkProxy");

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

    {
        const  ::QWebSocketServer *sipCpp;

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

            sipRes = new  ::QNetworkProxy(sipCpp->proxy());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_proxy, doc_QWebSocketServer_proxy);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_setSslConfiguration, "setSslConfiguration(self, QSslConfiguration)");

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

    {
        const  ::QSslConfiguration* a0;
         ::QWebSocketServer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QWebSocketServer, &sipCpp, sipType_QSslConfiguration, &a0))
        {
            sipCpp->setSslConfiguration(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_setSslConfiguration, doc_QWebSocketServer_setSslConfiguration);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_sslConfiguration, "sslConfiguration(self) -> QSslConfiguration");

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

    {
        const  ::QWebSocketServer *sipCpp;

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

            sipRes = new  ::QSslConfiguration(sipCpp->sslConfiguration());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_sslConfiguration, doc_QWebSocketServer_sslConfiguration);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_supportedVersions, "supportedVersions(self) -> object");

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

    {
        const  ::QWebSocketServer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QWebSocketServer, &sipCpp))
        {
            QList< ::QWebSocketProtocol::Version>*sipRes;

            sipRes = new QList< ::QWebSocketProtocol::Version>(sipCpp->supportedVersions());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_supportedVersions, doc_QWebSocketServer_supportedVersions);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_serverUrl, "serverUrl(self) -> QUrl");

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

    {
        const  ::QWebSocketServer *sipCpp;

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

            sipRes = new  ::QUrl(sipCpp->serverUrl());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_serverUrl, doc_QWebSocketServer_serverUrl);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketServer_handleConnection, "handleConnection(self, QTcpSocket)");

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

    {
         ::QTcpSocket* a0;
        const  ::QWebSocketServer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QWebSocketServer, &sipCpp, sipType_QTcpSocket, &a0))
        {
            sipCpp->handleConnection(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketServer, sipName_handleConnection, doc_QWebSocketServer_handleConnection);

    return NULL;
}


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

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

    return sipCppV;
}


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

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


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

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


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

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

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

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

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QWebSocketServer[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QWebSocketServer_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_close), meth_QWebSocketServer_close, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_close)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QWebSocketServer_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QWebSocketServer_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QWebSocketServer_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_error), meth_QWebSocketServer_error, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_error)},
    {SIP_MLNAME_CAST(sipName_errorString), meth_QWebSocketServer_errorString, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_errorString)},
    {SIP_MLNAME_CAST(sipName_handleConnection), meth_QWebSocketServer_handleConnection, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_handleConnection)},
    {SIP_MLNAME_CAST(sipName_hasPendingConnections), meth_QWebSocketServer_hasPendingConnections, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_hasPendingConnections)},
    {SIP_MLNAME_CAST(sipName_isListening), meth_QWebSocketServer_isListening, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_isListening)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QWebSocketServer_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_listen), (PyCFunction)meth_QWebSocketServer_listen, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QWebSocketServer_listen)},
    {SIP_MLNAME_CAST(sipName_maxPendingConnections), meth_QWebSocketServer_maxPendingConnections, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_maxPendingConnections)},
    {SIP_MLNAME_CAST(sipName_nextPendingConnection), meth_QWebSocketServer_nextPendingConnection, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_nextPendingConnection)},
    {SIP_MLNAME_CAST(sipName_pauseAccepting), meth_QWebSocketServer_pauseAccepting, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_pauseAccepting)},
    {SIP_MLNAME_CAST(sipName_proxy), meth_QWebSocketServer_proxy, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_proxy)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QWebSocketServer_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_resumeAccepting), meth_QWebSocketServer_resumeAccepting, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_resumeAccepting)},
    {SIP_MLNAME_CAST(sipName_secureMode), meth_QWebSocketServer_secureMode, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_secureMode)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QWebSocketServer_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QWebSocketServer_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_serverAddress), meth_QWebSocketServer_serverAddress, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_serverAddress)},
    {SIP_MLNAME_CAST(sipName_serverName), meth_QWebSocketServer_serverName, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_serverName)},
    {SIP_MLNAME_CAST(sipName_serverPort), meth_QWebSocketServer_serverPort, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_serverPort)},
    {SIP_MLNAME_CAST(sipName_serverUrl), meth_QWebSocketServer_serverUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_serverUrl)},
    {SIP_MLNAME_CAST(sipName_setMaxPendingConnections), meth_QWebSocketServer_setMaxPendingConnections, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_setMaxPendingConnections)},
    {SIP_MLNAME_CAST(sipName_setProxy), meth_QWebSocketServer_setProxy, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_setProxy)},
    {SIP_MLNAME_CAST(sipName_setServerName), meth_QWebSocketServer_setServerName, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_setServerName)},
    {SIP_MLNAME_CAST(sipName_setSocketDescriptor), meth_QWebSocketServer_setSocketDescriptor, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_setSocketDescriptor)},
    {SIP_MLNAME_CAST(sipName_setSslConfiguration), meth_QWebSocketServer_setSslConfiguration, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_setSslConfiguration)},
    {SIP_MLNAME_CAST(sipName_socketDescriptor), meth_QWebSocketServer_socketDescriptor, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_socketDescriptor)},
    {SIP_MLNAME_CAST(sipName_sslConfiguration), meth_QWebSocketServer_sslConfiguration, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_sslConfiguration)},
    {SIP_MLNAME_CAST(sipName_supportedVersions), meth_QWebSocketServer_supportedVersions, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketServer_supportedVersions)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QWebSocketServer_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

static sipEnumMemberDef enummembers_QWebSocketServer[] = {
    {sipName_NonSecureMode, static_cast<int>( ::QWebSocketServer::NonSecureMode), 8},
    {sipName_SecureMode, static_cast<int>( ::QWebSocketServer::SecureMode), 8},
};

PyDoc_STRVAR(doc_QWebSocketServer, "\1QWebSocketServer(str, QWebSocketServer.SslMode, parent: QObject = None)");


/* Define this type's signals. */
static const pyqt5QtSignal signals_QWebSocketServer[] = {
    {"preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator*)", "\1preSharedKeyAuthenticationRequired(self, QSslPreSharedKeyAuthenticator)", 0, 0},
    {"closed()", "\1closed(self)", 0, 0},
    {"sslErrors(QList<QSslError>)", "\1sslErrors(self, Iterable[QSslError])", 0, 0},
    {"peerVerifyError(QSslError)", "\1peerVerifyError(self, QSslError)", 0, 0},
    {"newConnection()", "\1newConnection(self)", 0, 0},
    {"originAuthenticationRequired(QWebSocketCorsAuthenticator*)", "\1originAuthenticationRequired(self, QWebSocketCorsAuthenticator)", 0, 0},
    {"serverError(QWebSocketProtocol::CloseCode)", "\1serverError(self, QWebSocketProtocol.CloseCode)", 0, 0},
    {"acceptError(QAbstractSocket::SocketError)", "\1acceptError(self, QAbstractSocket.SocketError)", 0, 0},
    {0, 0, 0, 0}
};


static pyqt5ClassPluginDef plugin_QWebSocketServer = {
    & ::QWebSocketServer::staticMetaObject,
    0,
    signals_QWebSocketServer,
    0
};


sipClassTypeDef sipTypeDef_QtWebSockets_QWebSocketServer = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QWebSocketServer,
        {0},
        &plugin_QWebSocketServer
    },
    {
        sipNameNr_QWebSocketServer,
        {0, 0, 1},
        34, methods_QWebSocketServer,
        2, enummembers_QWebSocketServer,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QWebSocketServer,
    -1,
    -1,
    supers_QWebSocketServer,
    0,
    init_type_QWebSocketServer,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QWebSocketServer,
    0,
    0,
    0,
    release_QWebSocketServer,
    cast_QWebSocketServer,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qwebsocketprotocol.sip"
#include <qwebsocketprotocol.h>
#line 2324 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"


static sipEnumMemberDef enummembers_QWebSocketProtocol[] = {
    {sipName_CloseCodeAbnormalDisconnection, static_cast<int>( ::QWebSocketProtocol::CloseCodeAbnormalDisconnection), 5},
    {sipName_CloseCodeBadOperation, static_cast<int>( ::QWebSocketProtocol::CloseCodeBadOperation), 5},
    {sipName_CloseCodeDatatypeNotSupported, static_cast<int>( ::QWebSocketProtocol::CloseCodeDatatypeNotSupported), 5},
    {sipName_CloseCodeGoingAway, static_cast<int>( ::QWebSocketProtocol::CloseCodeGoingAway), 5},
    {sipName_CloseCodeMissingExtension, static_cast<int>( ::QWebSocketProtocol::CloseCodeMissingExtension), 5},
    {sipName_CloseCodeMissingStatusCode, static_cast<int>( ::QWebSocketProtocol::CloseCodeMissingStatusCode), 5},
    {sipName_CloseCodeNormal, static_cast<int>( ::QWebSocketProtocol::CloseCodeNormal), 5},
    {sipName_CloseCodePolicyViolated, static_cast<int>( ::QWebSocketProtocol::CloseCodePolicyViolated), 5},
    {sipName_CloseCodeProtocolError, static_cast<int>( ::QWebSocketProtocol::CloseCodeProtocolError), 5},
    {sipName_CloseCodeReserved1004, static_cast<int>( ::QWebSocketProtocol::CloseCodeReserved1004), 5},
    {sipName_CloseCodeTlsHandshakeFailed, static_cast<int>( ::QWebSocketProtocol::CloseCodeTlsHandshakeFailed), 5},
    {sipName_CloseCodeTooMuchData, static_cast<int>( ::QWebSocketProtocol::CloseCodeTooMuchData), 5},
    {sipName_CloseCodeWrongDatatype, static_cast<int>( ::QWebSocketProtocol::CloseCodeWrongDatatype), 5},
    {sipName_Version0, static_cast<int>( ::QWebSocketProtocol::Version0), 6},
    {sipName_Version13, static_cast<int>( ::QWebSocketProtocol::Version13), 6},
    {sipName_Version4, static_cast<int>( ::QWebSocketProtocol::Version4), 6},
    {sipName_Version5, static_cast<int>( ::QWebSocketProtocol::Version5), 6},
    {sipName_Version6, static_cast<int>( ::QWebSocketProtocol::Version6), 6},
    {sipName_Version7, static_cast<int>( ::QWebSocketProtocol::Version7), 6},
    {sipName_Version8, static_cast<int>( ::QWebSocketProtocol::Version8), 6},
    {sipName_VersionLatest, static_cast<int>( ::QWebSocketProtocol::VersionLatest), 6},
    {sipName_VersionUnknown, static_cast<int>( ::QWebSocketProtocol::VersionUnknown), 6},
};


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


sipClassTypeDef sipTypeDef_QtWebSockets_QWebSocketProtocol = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_NAMESPACE,
        sipNameNr_QWebSocketProtocol,
        {0},
        &plugin_QWebSocketProtocol
    },
    {
        sipNameNr_QWebSocketProtocol,
        {0, 0, 1},
        0, 0,
        22, enummembers_QWebSocketProtocol,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    0,
    -1,
    -1,
    0,
    0,
    0,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qwebsocketcorsauthenticator.sip"
#include <qwebsocketcorsauthenticator.h>
#line 2412 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"

#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 2416 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"


PyDoc_STRVAR(doc_QWebSocketCorsAuthenticator_swap, "swap(self, QWebSocketCorsAuthenticator)");

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

    {
         ::QWebSocketCorsAuthenticator* a0;
         ::QWebSocketCorsAuthenticator *sipCpp;

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

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketCorsAuthenticator_origin, "origin(self) -> str");

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

    {
        const  ::QWebSocketCorsAuthenticator *sipCpp;

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

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

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketCorsAuthenticator, sipName_origin, doc_QWebSocketCorsAuthenticator_origin);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketCorsAuthenticator_setAllowed, "setAllowed(self, bool)");

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

    {
        bool a0;
         ::QWebSocketCorsAuthenticator *sipCpp;

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

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketCorsAuthenticator, sipName_setAllowed, doc_QWebSocketCorsAuthenticator_setAllowed);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocketCorsAuthenticator_allowed, "allowed(self) -> bool");

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

    {
        const  ::QWebSocketCorsAuthenticator *sipCpp;

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

            sipRes = sipCpp->allowed();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocketCorsAuthenticator, sipName_allowed, doc_QWebSocketCorsAuthenticator_allowed);

    return NULL;
}


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


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


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

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

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

            return sipCpp;
        }
    }

    {
        const  ::QWebSocketCorsAuthenticator* a0;

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

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QWebSocketCorsAuthenticator[] = {
    {SIP_MLNAME_CAST(sipName_allowed), meth_QWebSocketCorsAuthenticator_allowed, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketCorsAuthenticator_allowed)},
    {SIP_MLNAME_CAST(sipName_origin), meth_QWebSocketCorsAuthenticator_origin, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketCorsAuthenticator_origin)},
    {SIP_MLNAME_CAST(sipName_setAllowed), meth_QWebSocketCorsAuthenticator_setAllowed, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketCorsAuthenticator_setAllowed)},
    {SIP_MLNAME_CAST(sipName_swap), meth_QWebSocketCorsAuthenticator_swap, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocketCorsAuthenticator_swap)}
};

PyDoc_STRVAR(doc_QWebSocketCorsAuthenticator, "\1QWebSocketCorsAuthenticator(str)\n"
    "QWebSocketCorsAuthenticator(QWebSocketCorsAuthenticator)");


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


sipClassTypeDef sipTypeDef_QtWebSockets_QWebSocketCorsAuthenticator = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QWebSocketCorsAuthenticator,
        {0},
        &plugin_QWebSocketCorsAuthenticator
    },
    {
        sipNameNr_QWebSocketCorsAuthenticator,
        {0, 0, 1},
        4, methods_QWebSocketCorsAuthenticator,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QWebSocketCorsAuthenticator,
    -1,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QWebSocketCorsAuthenticator,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QWebSocketCorsAuthenticator,
    0,
    0,
    0,
    release_QWebSocketCorsAuthenticator,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qwebsocket.sip"
#include <qwebsocket.h>
#line 2653 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"

#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 2657 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qwebsocketprotocol.sip"
#include <qwebsocketprotocol.h>
#line 2660 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 2663 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 29 "sip/QtNetwork/qsslpresharedkeyauthenticator.sip"
#include <qsslpresharedkeyauthenticator.h>
#line 2666 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2669 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 28 "sip/QtNetwork/qsslerror.sip"
#include <qsslerror.h>
#line 2672 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 2675 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtNetwork/qnetworkproxy.sip"
#include <qnetworkproxy.h>
#line 2678 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtNetwork/qauthenticator.sip"
#include <qauthenticator.h>
#line 2681 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtNetwork/qabstractsocket.sip"
#include <qabstractsocket.h>
#line 2684 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 96 "sip/QtCore/qurl.sip"
#include <qurl.h>
#line 2687 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtNetwork/qnetworkrequest.sip"
#include <qnetworkrequest.h>
#line 2690 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 28 "sip/QtNetwork/qsslconfiguration.sip"
#include <qsslconfiguration.h>
#line 2693 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtNetwork/qabstractsocket.sip"
#include <qabstractsocket.h>
#line 2696 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qmaskgenerator.sip"
#include <qmaskgenerator.h>
#line 2699 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtNetwork/qhostaddress.sip"
#include <qhostaddress.h>
#line 2702 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 2705 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2708 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2711 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2714 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 2717 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2720 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 148 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2723 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 2726 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 2729 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 2732 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 2735 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 2738 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 2741 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"


class sipQWebSocket : public  ::QWebSocket
{
public:
    sipQWebSocket(const  ::QString&, ::QWebSocketProtocol::Version, ::QObject*);
    virtual ~sipQWebSocket();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
     ::QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool, ::QTimerEvent*);
    void sipProtectVirt_childEvent(bool, ::QChildEvent*);
    void sipProtectVirt_customEvent(bool, ::QEvent*);
    void sipProtectVirt_connectNotify(bool,const  ::QMetaMethod&);
    void sipProtectVirt_disconnectNotify(bool,const  ::QMetaMethod&);
    int sipProtect_senderSignalIndex() const;
    bool sipProtect_isSignalConnected(const  ::QMetaMethod&) const;

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

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[7];
};

sipQWebSocket::sipQWebSocket(const  ::QString& a0, ::QWebSocketProtocol::Version a1, ::QObject*a2):  ::QWebSocket(a0,a1,a2), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

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

const QMetaObject *sipQWebSocket::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtWebSockets_qt_metaobject(sipPySelf,sipType_QWebSocket);

    return  ::QWebSocket::metaObject();
}

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

    if (_id >= 0)
        _id = sip_QtWebSockets_qt_metacall(sipPySelf,sipType_QWebSocket,_c,_id,_a);

    return _id;
}

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

    return (sip_QtWebSockets_qt_metacast(sipPySelf, sipType_QWebSocket, _clname, &sipCpp) ? sipCpp :  ::QWebSocket::qt_metacast(_clname));
}

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

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

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

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

    return sipVH_QtWebSockets_5(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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

    sipVH_QtWebSockets_3(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

    sipVH_QtWebSockets_2(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

    sipVH_QtWebSockets_1(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

    sipVH_QtWebSockets_0(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

    sipVH_QtWebSockets_0(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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


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

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

    {
        const sipQWebSocket *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QWebSocket, &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 3035 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"

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

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

    return NULL;
}


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

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

    {
        PyObject * a0;
        const sipQWebSocket *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QWebSocket, &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 3095 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.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_QWebSocket, sipName_receivers, doc_QWebSocket_receivers);

    return NULL;
}


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

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

    {
         ::QTimerEvent* a0;
        sipQWebSocket *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QWebSocket, &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_QWebSocket, sipName_timerEvent, doc_QWebSocket_timerEvent);

    return NULL;
}


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

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

    {
         ::QChildEvent* a0;
        sipQWebSocket *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QWebSocket, &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_QWebSocket, sipName_childEvent, doc_QWebSocket_childEvent);

    return NULL;
}


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

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

    {
         ::QEvent* a0;
        sipQWebSocket *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QWebSocket, &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_QWebSocket, sipName_customEvent, doc_QWebSocket_customEvent);

    return NULL;
}


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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QWebSocket, &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_QWebSocket, sipName_connectNotify, doc_QWebSocket_connectNotify);

    return NULL;
}


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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QWebSocket, &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_QWebSocket, sipName_disconnectNotify, doc_QWebSocket_disconnectNotify);

    return NULL;
}


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

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

    {
        const sipQWebSocket *sipCpp;

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

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

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

    return NULL;
}


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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QWebSocket, &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_QWebSocket, sipName_isSignalConnected, doc_QWebSocket_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_abort, "abort(self)");

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

    {
         ::QWebSocket *sipCpp;

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

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_abort, doc_QWebSocket_abort);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_error, "error(self) -> QAbstractSocket.SocketError");

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

    {
        const  ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QWebSocket, &sipCpp))
        {
             ::QAbstractSocket::SocketError sipRes;

            sipRes = sipCpp->error();

            return sipConvertFromEnum(sipRes,sipType_QAbstractSocket_SocketError);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_errorString, "errorString(self) -> str");

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

    {
        const  ::QWebSocket *sipCpp;

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

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

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_errorString, doc_QWebSocket_errorString);

    return NULL;
}


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

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

    {
         ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QWebSocket, &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_QWebSocket, sipName_flush, doc_QWebSocket_flush);

    return NULL;
}


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

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

    {
        const  ::QWebSocket *sipCpp;

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

            sipRes = sipCpp->isValid();

            return PyBool_FromLong(sipRes);
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_localAddress, "localAddress(self) -> QHostAddress");

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

    {
        const  ::QWebSocket *sipCpp;

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

            sipRes = new  ::QHostAddress(sipCpp->localAddress());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_localAddress, doc_QWebSocket_localAddress);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_localPort, "localPort(self) -> int");

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

    {
        const  ::QWebSocket *sipCpp;

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

            sipRes = sipCpp->localPort();

#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_QWebSocket, sipName_localPort, doc_QWebSocket_localPort);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_pauseMode, "pauseMode(self) -> QAbstractSocket.PauseModes");

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

    {
        const  ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QWebSocket, &sipCpp))
        {
             ::QAbstractSocket::PauseModes*sipRes;

            sipRes = new  ::QAbstractSocket::PauseModes(sipCpp->pauseMode());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_pauseMode, doc_QWebSocket_pauseMode);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_peerAddress, "peerAddress(self) -> QHostAddress");

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

    {
        const  ::QWebSocket *sipCpp;

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

            sipRes = new  ::QHostAddress(sipCpp->peerAddress());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_peerAddress, doc_QWebSocket_peerAddress);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_peerName, "peerName(self) -> str");

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

    {
        const  ::QWebSocket *sipCpp;

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

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

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_peerName, doc_QWebSocket_peerName);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_peerPort, "peerPort(self) -> int");

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

    {
        const  ::QWebSocket *sipCpp;

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

            sipRes = sipCpp->peerPort();

#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_QWebSocket, sipName_peerPort, doc_QWebSocket_peerPort);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_proxy, "proxy(self) -> QNetworkProxy");

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

    {
        const  ::QWebSocket *sipCpp;

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

            sipRes = new  ::QNetworkProxy(sipCpp->proxy());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_proxy, doc_QWebSocket_proxy);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_setProxy, "setProxy(self, QNetworkProxy)");

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

    {
        const  ::QNetworkProxy* a0;
         ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QWebSocket, &sipCpp, sipType_QNetworkProxy, &a0))
        {
            sipCpp->setProxy(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_setProxy, doc_QWebSocket_setProxy);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_setMaskGenerator, "setMaskGenerator(self, QMaskGenerator)");

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

    {
        const  ::QMaskGenerator* a0;
        PyObject *a0Keep;
         ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B@J8", &sipSelf, sipType_QWebSocket, &sipCpp, &a0Keep, sipType_QMaskGenerator, &a0))
        {
            sipCpp->setMaskGenerator(a0);

            sipKeepReference(sipSelf, -1, a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_setMaskGenerator, doc_QWebSocket_setMaskGenerator);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_maskGenerator, "maskGenerator(self) -> QMaskGenerator");

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

    {
        const  ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QWebSocket, &sipCpp))
        {
            const  ::QMaskGenerator*sipRes;

            sipRes = sipCpp->maskGenerator();

            return sipConvertFromType(const_cast< ::QMaskGenerator *>(sipRes),sipType_QMaskGenerator,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_maskGenerator, doc_QWebSocket_maskGenerator);

    return NULL;
}


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

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

    {
        const  ::QWebSocket *sipCpp;

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

            sipRes = sipCpp->readBufferSize();

            return PyLong_FromLongLong(sipRes);
        }
    }

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

    return NULL;
}


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

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

    {
         ::qint64 a0;
         ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bn", &sipSelf, sipType_QWebSocket, &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_QWebSocket, sipName_setReadBufferSize, doc_QWebSocket_setReadBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_resume, "resume(self)");

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

    {
         ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QWebSocket, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->resume();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_resume, doc_QWebSocket_resume);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_setPauseMode, "setPauseMode(self, Union[QAbstractSocket.PauseModes, QAbstractSocket.PauseMode])");

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

    {
         ::QAbstractSocket::PauseModes* a0;
        int a0State = 0;
         ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QWebSocket, &sipCpp, sipType_QAbstractSocket_PauseModes, &a0, &a0State))
        {
            sipCpp->setPauseMode(*a0);
            sipReleaseType(a0,sipType_QAbstractSocket_PauseModes,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_setPauseMode, doc_QWebSocket_setPauseMode);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_state, "state(self) -> QAbstractSocket.SocketState");

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

    {
        const  ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QWebSocket, &sipCpp))
        {
             ::QAbstractSocket::SocketState sipRes;

            sipRes = sipCpp->state();

            return sipConvertFromEnum(sipRes,sipType_QAbstractSocket_SocketState);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_state, doc_QWebSocket_state);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_version, "version(self) -> QWebSocketProtocol.Version");

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

    {
        const  ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QWebSocket, &sipCpp))
        {
             ::QWebSocketProtocol::Version sipRes;

            sipRes = sipCpp->version();

            return sipConvertFromEnum(sipRes,sipType_QWebSocketProtocol_Version);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_version, doc_QWebSocket_version);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_resourceName, "resourceName(self) -> str");

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

    {
        const  ::QWebSocket *sipCpp;

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

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

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_resourceName, doc_QWebSocket_resourceName);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_requestUrl, "requestUrl(self) -> QUrl");

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

    {
        const  ::QWebSocket *sipCpp;

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

            sipRes = new  ::QUrl(sipCpp->requestUrl());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_requestUrl, doc_QWebSocket_requestUrl);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_origin, "origin(self) -> str");

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

    {
        const  ::QWebSocket *sipCpp;

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

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

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_origin, doc_QWebSocket_origin);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_closeCode, "closeCode(self) -> QWebSocketProtocol.CloseCode");

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

    {
        const  ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QWebSocket, &sipCpp))
        {
             ::QWebSocketProtocol::CloseCode sipRes;

            sipRes = sipCpp->closeCode();

            return sipConvertFromEnum(sipRes,sipType_QWebSocketProtocol_CloseCode);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_closeCode, doc_QWebSocket_closeCode);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_closeReason, "closeReason(self) -> str");

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

    {
        const  ::QWebSocket *sipCpp;

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

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

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_closeReason, doc_QWebSocket_closeReason);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_sendTextMessage, "sendTextMessage(self, str) -> int");

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

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

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QWebSocket, &sipCpp, sipType_QString,&a0, &a0State))
        {
             ::qint64 sipRes;

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

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_sendTextMessage, doc_QWebSocket_sendTextMessage);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_sendBinaryMessage, "sendBinaryMessage(self, Union[QByteArray, bytes, bytearray]) -> int");

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

    {
        const  ::QByteArray* a0;
        int a0State = 0;
         ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QWebSocket, &sipCpp, sipType_QByteArray, &a0, &a0State))
        {
             ::qint64 sipRes;

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

            return PyLong_FromLongLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_sendBinaryMessage, doc_QWebSocket_sendBinaryMessage);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_ignoreSslErrors, "ignoreSslErrors(self, Iterable[QSslError])\n"
    "ignoreSslErrors(self)");

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

    {
        const QList< ::QSslError>* a0;
        int a0State = 0;
         ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QWebSocket, &sipCpp, sipType_QList_0100QSslError,&a0, &a0State))
        {
            sipCpp->ignoreSslErrors(*a0);
            sipReleaseType(const_cast<QList< ::QSslError> *>(a0),sipType_QList_0100QSslError,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::QWebSocket *sipCpp;

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

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_ignoreSslErrors, doc_QWebSocket_ignoreSslErrors);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_setSslConfiguration, "setSslConfiguration(self, QSslConfiguration)");

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

    {
        const  ::QSslConfiguration* a0;
         ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QWebSocket, &sipCpp, sipType_QSslConfiguration, &a0))
        {
            sipCpp->setSslConfiguration(*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_setSslConfiguration, doc_QWebSocket_setSslConfiguration);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_sslConfiguration, "sslConfiguration(self) -> QSslConfiguration");

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

    {
        const  ::QWebSocket *sipCpp;

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

            sipRes = new  ::QSslConfiguration(sipCpp->sslConfiguration());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_sslConfiguration, doc_QWebSocket_sslConfiguration);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_request, "request(self) -> QNetworkRequest");

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

    {
        const  ::QWebSocket *sipCpp;

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

            sipRes = new  ::QNetworkRequest(sipCpp->request());

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_request, doc_QWebSocket_request);

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_close, "close(self, closeCode: QWebSocketProtocol.CloseCode = QWebSocketProtocol.CloseCodeNormal, reason: str = '')");

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

    {
         ::QWebSocketProtocol::CloseCode a0 = QWebSocketProtocol::CloseCodeNormal;
        const  ::QString& a1def = QString();
        const  ::QString* a1 = &a1def;
        int a1State = 0;
         ::QWebSocket *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|EJ1", &sipSelf, sipType_QWebSocket, &sipCpp, sipType_QWebSocketProtocol_CloseCode, &a0, sipType_QString,&a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->close(a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_open, "open(self, QUrl)\n"
    "open(self, QNetworkRequest)");

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

    {
        const  ::QUrl* a0;
         ::QWebSocket *sipCpp;

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

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QNetworkRequest* a0;
         ::QWebSocket *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QWebSocket, &sipCpp, sipType_QNetworkRequest, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->open(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

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

    return NULL;
}


PyDoc_STRVAR(doc_QWebSocket_ping, "ping(self, payload: Union[QByteArray, bytes, bytearray] = QByteArray())");

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

    {
        const  ::QByteArray& a0def = QByteArray();
        const  ::QByteArray* a0 = &a0def;
        int a0State = 0;
         ::QWebSocket *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J1", &sipSelf, sipType_QWebSocket, &sipCpp, sipType_QByteArray, &a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->ping(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QByteArray *>(a0),sipType_QByteArray,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QWebSocket, sipName_ping, doc_QWebSocket_ping);

    return NULL;
}


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

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

    return sipCppV;
}


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

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


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

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


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

    {
        const  ::QString& a0def = QString();
        const  ::QString* a0 = &a0def;
        int a0State = 0;
         ::QWebSocketProtocol::Version a1 = QWebSocketProtocol::VersionLatest;
         ::QObject* a2 = 0;

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

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

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QWebSocket[] = {
    {SIP_MLNAME_CAST(sipName_abort), meth_QWebSocket_abort, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_abort)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QWebSocket_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_close), (PyCFunction)meth_QWebSocket_close, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QWebSocket_close)},
    {SIP_MLNAME_CAST(sipName_closeCode), meth_QWebSocket_closeCode, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_closeCode)},
    {SIP_MLNAME_CAST(sipName_closeReason), meth_QWebSocket_closeReason, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_closeReason)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QWebSocket_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QWebSocket_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QWebSocket_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_error), meth_QWebSocket_error, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_error)},
    {SIP_MLNAME_CAST(sipName_errorString), meth_QWebSocket_errorString, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_errorString)},
    {SIP_MLNAME_CAST(sipName_flush), meth_QWebSocket_flush, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_flush)},
    {SIP_MLNAME_CAST(sipName_ignoreSslErrors), meth_QWebSocket_ignoreSslErrors, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_ignoreSslErrors)},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QWebSocket_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QWebSocket_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_isValid)},
    {SIP_MLNAME_CAST(sipName_localAddress), meth_QWebSocket_localAddress, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_localAddress)},
    {SIP_MLNAME_CAST(sipName_localPort), meth_QWebSocket_localPort, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_localPort)},
    {SIP_MLNAME_CAST(sipName_maskGenerator), meth_QWebSocket_maskGenerator, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_maskGenerator)},
    {SIP_MLNAME_CAST(sipName_open), meth_QWebSocket_open, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_open)},
    {SIP_MLNAME_CAST(sipName_origin), meth_QWebSocket_origin, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_origin)},
    {SIP_MLNAME_CAST(sipName_pauseMode), meth_QWebSocket_pauseMode, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_pauseMode)},
    {SIP_MLNAME_CAST(sipName_peerAddress), meth_QWebSocket_peerAddress, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_peerAddress)},
    {SIP_MLNAME_CAST(sipName_peerName), meth_QWebSocket_peerName, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_peerName)},
    {SIP_MLNAME_CAST(sipName_peerPort), meth_QWebSocket_peerPort, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_peerPort)},
    {SIP_MLNAME_CAST(sipName_ping), (PyCFunction)meth_QWebSocket_ping, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QWebSocket_ping)},
    {SIP_MLNAME_CAST(sipName_proxy), meth_QWebSocket_proxy, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_proxy)},
    {SIP_MLNAME_CAST(sipName_readBufferSize), meth_QWebSocket_readBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_readBufferSize)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QWebSocket_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_request), meth_QWebSocket_request, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_request)},
    {SIP_MLNAME_CAST(sipName_requestUrl), meth_QWebSocket_requestUrl, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_requestUrl)},
    {SIP_MLNAME_CAST(sipName_resourceName), meth_QWebSocket_resourceName, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_resourceName)},
    {SIP_MLNAME_CAST(sipName_resume), meth_QWebSocket_resume, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_resume)},
    {SIP_MLNAME_CAST(sipName_sendBinaryMessage), meth_QWebSocket_sendBinaryMessage, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_sendBinaryMessage)},
    {SIP_MLNAME_CAST(sipName_sendTextMessage), meth_QWebSocket_sendTextMessage, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_sendTextMessage)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QWebSocket_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QWebSocket_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setMaskGenerator), meth_QWebSocket_setMaskGenerator, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_setMaskGenerator)},
    {SIP_MLNAME_CAST(sipName_setPauseMode), meth_QWebSocket_setPauseMode, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_setPauseMode)},
    {SIP_MLNAME_CAST(sipName_setProxy), meth_QWebSocket_setProxy, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_setProxy)},
    {SIP_MLNAME_CAST(sipName_setReadBufferSize), meth_QWebSocket_setReadBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_setReadBufferSize)},
    {SIP_MLNAME_CAST(sipName_setSslConfiguration), meth_QWebSocket_setSslConfiguration, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_setSslConfiguration)},
    {SIP_MLNAME_CAST(sipName_sslConfiguration), meth_QWebSocket_sslConfiguration, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_sslConfiguration)},
    {SIP_MLNAME_CAST(sipName_state), meth_QWebSocket_state, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_state)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QWebSocket_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_version), meth_QWebSocket_version, METH_VARARGS, SIP_MLDOC_CAST(doc_QWebSocket_version)}
};

PyDoc_STRVAR(doc_QWebSocket, "\1QWebSocket(origin: str = '', version: QWebSocketProtocol.Version = QWebSocketProtocol.VersionLatest, parent: QObject = None)");


/* Define this type's signals. */
static const pyqt5QtSignal signals_QWebSocket[] = {
    {"preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator*)", "\1preSharedKeyAuthenticationRequired(self, QSslPreSharedKeyAuthenticator)", 0, 0},
    {"sslErrors(QList<QSslError>)", "\1sslErrors(self, Iterable[QSslError])", 0, 0},
    {"bytesWritten(qint64)", "\1bytesWritten(self, int)", 0, 0},
    {"pong(quint64,QByteArray)", "\1pong(self, int, Union[QByteArray, bytes, bytearray])", 0, 0},
    {"binaryMessageReceived(QByteArray)", "\1binaryMessageReceived(self, Union[QByteArray, bytes, bytearray])", 0, 0},
    {"textMessageReceived(QString)", "\1textMessageReceived(self, str)", 0, 0},
    {"binaryFrameReceived(QByteArray,bool)", "\1binaryFrameReceived(self, Union[QByteArray, bytes, bytearray], bool)", 0, 0},
    {"textFrameReceived(QString,bool)", "\1textFrameReceived(self, str, bool)", 0, 0},
    {"readChannelFinished()", "\1readChannelFinished(self)", 0, 0},
    {"proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)", "\1proxyAuthenticationRequired(self, QNetworkProxy, QAuthenticator)", 0, 0},
    {"stateChanged(QAbstractSocket::SocketState)", "\1stateChanged(self, QAbstractSocket.SocketState)", 0, 0},
    {"disconnected()", "\1disconnected(self)", 0, 0},
    {"connected()", "\1connected(self)", 0, 0},
    {"aboutToClose()", "\1aboutToClose(self)", 0, 0},
    {"error(QAbstractSocket::SocketError)", "\1error(self, QAbstractSocket.SocketError)", &methods_QWebSocket[8], 0},
    {0, 0, 0, 0}
};


static pyqt5ClassPluginDef plugin_QWebSocket = {
    & ::QWebSocket::staticMetaObject,
    0,
    signals_QWebSocket,
    0
};


sipClassTypeDef sipTypeDef_QtWebSockets_QWebSocket = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QWebSocket,
        {0},
        &plugin_QWebSocket
    },
    {
        sipNameNr_QWebSocket,
        {0, 0, 1},
        44, methods_QWebSocket,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QWebSocket,
    -1,
    -1,
    supers_QWebSocket,
    0,
    init_type_QWebSocket,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QWebSocket,
    0,
    0,
    0,
    release_QWebSocket,
    cast_QWebSocket,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/sip/QtWebSockets/qmaskgenerator.sip"
#include <qmaskgenerator.h>
#line 4585 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 4589 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 4592 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4595 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 247 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4598 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 235 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 4601 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 4604 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 4607 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 38 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 4610 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 30 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 4613 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 148 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 4616 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 4619 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 4622 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 4625 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 4628 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 4631 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 4634 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"


class sipQMaskGenerator : public  ::QMaskGenerator
{
public:
    sipQMaskGenerator( ::QObject*);
    virtual ~sipQMaskGenerator();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
     ::QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool, ::QTimerEvent*);
    void sipProtectVirt_childEvent(bool, ::QChildEvent*);
    void sipProtectVirt_customEvent(bool, ::QEvent*);
    void sipProtectVirt_connectNotify(bool,const  ::QMetaMethod&);
    void sipProtectVirt_disconnectNotify(bool,const  ::QMetaMethod&);
    int sipProtect_senderSignalIndex() const;
    bool sipProtect_isSignalConnected(const  ::QMetaMethod&) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
     ::quint32 nextMask();
    bool seed();
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const  ::QMetaMethod&);
    void disconnectNotify(const  ::QMetaMethod&);

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[9];
};

sipQMaskGenerator::sipQMaskGenerator( ::QObject*a0):  ::QMaskGenerator(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

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

const QMetaObject *sipQMaskGenerator::metaObject() const
{
    if (sipGetInterpreter())
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtWebSockets_qt_metaobject(sipPySelf,sipType_QMaskGenerator);

    return  ::QMaskGenerator::metaObject();
}

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

    if (_id >= 0)
        _id = sip_QtWebSockets_qt_metacall(sipPySelf,sipType_QMaskGenerator,_c,_id,_a);

    return _id;
}

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

    return (sip_QtWebSockets_qt_metacast(sipPySelf, sipType_QMaskGenerator, _clname, &sipCpp) ? sipCpp :  ::QMaskGenerator::qt_metacast(_clname));
}

 ::quint32 sipQMaskGenerator::nextMask()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,sipName_QMaskGenerator,sipName_nextMask);

    if (!sipMeth)
        return 0;

    extern  ::quint32 sipVH_QtWebSockets_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtWebSockets_7(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

bool sipQMaskGenerator::seed()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,sipName_QMaskGenerator,sipName_seed);

    if (!sipMeth)
        return 0;

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

    return sipVH_QtWebSockets_6(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth);
}

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

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

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

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

    return sipVH_QtWebSockets_5(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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

    sipVH_QtWebSockets_3(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

    sipVH_QtWebSockets_2(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

    sipVH_QtWebSockets_1(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

    sipVH_QtWebSockets_0(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

    sipVH_QtWebSockets_0(sipGILState, sipImportedVirtErrorHandlers_QtWebSockets_QtCore[0].iveh_handler, sipPySelf, sipMeth, a0);
}

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

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

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

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

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

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

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

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

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


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

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

    {
        const sipQMaskGenerator *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QMaskGenerator, &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 4960 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.cpp"

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

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

    return NULL;
}


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

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

    {
        PyObject * a0;
        const sipQMaskGenerator *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QMaskGenerator, &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 5020 "/usr/src/ports/python-pyqt5/python-pyqt5-5.9-1.i686/build/py2/QtWebSockets/sipQtWebSocketspart0.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_QMaskGenerator, sipName_receivers, doc_QMaskGenerator_receivers);

    return NULL;
}


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

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

    {
         ::QTimerEvent* a0;
        sipQMaskGenerator *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QMaskGenerator, &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_QMaskGenerator, sipName_timerEvent, doc_QMaskGenerator_timerEvent);

    return NULL;
}


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

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

    {
         ::QChildEvent* a0;
        sipQMaskGenerator *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QMaskGenerator, &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_QMaskGenerator, sipName_childEvent, doc_QMaskGenerator_childEvent);

    return NULL;
}


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

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

    {
         ::QEvent* a0;
        sipQMaskGenerator *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QMaskGenerator, &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_QMaskGenerator, sipName_customEvent, doc_QMaskGenerator_customEvent);

    return NULL;
}


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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QMaskGenerator, &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_QMaskGenerator, sipName_connectNotify, doc_QMaskGenerator_connectNotify);

    return NULL;
}


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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QMaskGenerator, &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_QMaskGenerator, sipName_disconnectNotify, doc_QMaskGenerator_disconnectNotify);

    return NULL;
}


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

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

    {
        const sipQMaskGenerator *sipCpp;

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

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

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

    return NULL;
}


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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QMaskGenerator, &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_QMaskGenerator, sipName_isSignalConnected, doc_QMaskGenerator_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QMaskGenerator_seed, "seed(self) -> bool");

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

    {
         ::QMaskGenerator *sipCpp;

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

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QMaskGenerator, sipName_seed);
                return NULL;
            }

            sipRes = sipCpp->seed();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QMaskGenerator, sipName_seed, doc_QMaskGenerator_seed);

    return NULL;
}


PyDoc_STRVAR(doc_QMaskGenerator_nextMask, "nextMask(self) -> int");

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

    {
         ::QMaskGenerator *sipCpp;

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

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QMaskGenerator, sipName_nextMask);
                return NULL;
            }

            sipRes = sipCpp->nextMask();

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QMaskGenerator, sipName_nextMask, doc_QMaskGenerator_nextMask);

    return NULL;
}


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

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

    return sipCppV;
}


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

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


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

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


extern "C" {static void *init_type_QMaskGenerator(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QMaskGenerator(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQMaskGenerator *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 sipQMaskGenerator(a0);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


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


static PyMethodDef methods_QMaskGenerator[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QMaskGenerator_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QMaskGenerator_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QMaskGenerator_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QMaskGenerator_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QMaskGenerator_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_nextMask), meth_QMaskGenerator_nextMask, METH_VARARGS, SIP_MLDOC_CAST(doc_QMaskGenerator_nextMask)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QMaskGenerator_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_seed), meth_QMaskGenerator_seed, METH_VARARGS, SIP_MLDOC_CAST(doc_QMaskGenerator_seed)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QMaskGenerator_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QMaskGenerator_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QMaskGenerator_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QMaskGenerator, "\1QMaskGenerator(parent: QObject = None)");


static pyqt5ClassPluginDef plugin_QMaskGenerator = {
    & ::QMaskGenerator::staticMetaObject,
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtWebSockets_QMaskGenerator = {
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_LIMITED_API|SIP_TYPE_CLASS,
        sipNameNr_QMaskGenerator,
        {0},
        &plugin_QMaskGenerator
    },
    {
        sipNameNr_QMaskGenerator,
        {0, 0, 1},
        11, methods_QMaskGenerator,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QMaskGenerator,
    -1,
    -1,
    supers_QMaskGenerator,
    0,
    init_type_QMaskGenerator,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QMaskGenerator,
    0,
    0,
    0,
    release_QMaskGenerator,
    cast_QMaskGenerator,
    0,
    0,
    0,
    0,
    0,
    0
};
