##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » USERS » JEANDET » PythonQt
RSS
Added generator to install targets and removed examples from build.
Added generator to install targets and removed examples from build.
jeandet - - Load All Authors

File last commit:

r11:b89840e63daa default
r12:17486c75e366 tip default
Show More
com_trolltech_qt_network1.cpp
3165 lines | 115.6 KiB | text/x-c | CppLexer
/ generated_cpp_53 / com_trolltech_qt_network / com_trolltech_qt_network1.cpp
History | Annotation | Raw |Copy content |Copy permalink
#include "com_trolltech_qt_network1.h"
#include <PythonQtConversion.h>
#include <PythonQtMethodInfo.h>
#include <PythonQtSignalReceiver.h>
#include <QVariant>
#include <qauthenticator.h>
#include <qbytearray.h>
#include <qcoreevent.h>
#include <qhostaddress.h>
#include <qiodevice.h>
#include <qlist.h>
#include <qmetaobject.h>
#include <qnetworkinterface.h>
#include <qnetworkproxy.h>
#include <qobject.h>
#include <qsslcertificate.h>
#include <qsslcipher.h>
#include <qsslconfiguration.h>
#include <qsslerror.h>
#include <qsslkey.h>
#include <qsslsocket.h>
#include <qtcpserver.h>
#include <qtcpsocket.h>
#include <qudpsocket.h>
#ifndef QT_NO_OPENSSL
QSslKey* PythonQtWrapper_QSslKey::new_QSslKey()
{
return new QSslKey(); }
QSslKey* PythonQtWrapper_QSslKey::new_QSslKey(QIODevice* device, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format, QSsl::KeyType type, const QByteArray& passPhrase)
{
return new QSslKey(device, algorithm, format, type, passPhrase); }
QSslKey* PythonQtWrapper_QSslKey::new_QSslKey(Qt::HANDLE handle, QSsl::KeyType type)
{
return new QSslKey(handle, type); }
QSslKey* PythonQtWrapper_QSslKey::new_QSslKey(const QByteArray& encoded, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format, QSsl::KeyType type, const QByteArray& passPhrase)
{
return new QSslKey(encoded, algorithm, format, type, passPhrase); }
QSslKey* PythonQtWrapper_QSslKey::new_QSslKey(const QSslKey& other)
{
return new QSslKey(other); }
QSsl::KeyAlgorithm PythonQtWrapper_QSslKey::algorithm(QSslKey* theWrappedObject) const
{
return ( theWrappedObject->algorithm());
}
void PythonQtWrapper_QSslKey::clear(QSslKey* theWrappedObject)
{
( theWrappedObject->clear());
}
Qt::HANDLE PythonQtWrapper_QSslKey::handle(QSslKey* theWrappedObject) const
{
return ( theWrappedObject->handle());
}
bool PythonQtWrapper_QSslKey::isNull(QSslKey* theWrappedObject) const
{
return ( theWrappedObject->isNull());
}
int PythonQtWrapper_QSslKey::length(QSslKey* theWrappedObject) const
{
return ( theWrappedObject->length());
}
bool PythonQtWrapper_QSslKey::__ne__(QSslKey* theWrappedObject, const QSslKey& key) const
{
return ( (*theWrappedObject)!= key);
}
QSslKey* PythonQtWrapper_QSslKey::operator_assign(QSslKey* theWrappedObject, const QSslKey& other)
{
return &( (*theWrappedObject)= other);
}
bool PythonQtWrapper_QSslKey::__eq__(QSslKey* theWrappedObject, const QSslKey& key) const
{
return ( (*theWrappedObject)== key);
}
void PythonQtWrapper_QSslKey::swap(QSslKey* theWrappedObject, QSslKey& other)
{
( theWrappedObject->swap(other));
}
QByteArray PythonQtWrapper_QSslKey::toDer(QSslKey* theWrappedObject, const QByteArray& passPhrase) const
{
return ( theWrappedObject->toDer(passPhrase));
}
QByteArray PythonQtWrapper_QSslKey::toPem(QSslKey* theWrappedObject, const QByteArray& passPhrase) const
{
return ( theWrappedObject->toPem(passPhrase));
}
QSsl::KeyType PythonQtWrapper_QSslKey::type(QSslKey* theWrappedObject) const
{
return ( theWrappedObject->type());
}
QString PythonQtWrapper_QSslKey::py_toString(QSslKey* obj) {
QString result;
QDebug d(&result);
d << *obj;
return result;
}
#endif
#ifndef QT_NO_OPENSSL
PythonQtShell_QSslSocket::~PythonQtShell_QSslSocket() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
bool PythonQtShell_QSslSocket::atEnd() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("atEnd");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("atEnd", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::atEnd();
}
qint64 PythonQtShell_QSslSocket::bytesAvailable() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("bytesAvailable");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("bytesAvailable", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::bytesAvailable();
}
qint64 PythonQtShell_QSslSocket::bytesToWrite() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("bytesToWrite");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("bytesToWrite", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::bytesToWrite();
}
bool PythonQtShell_QSslSocket::canReadLine() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("canReadLine");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("canReadLine", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::canReadLine();
}
void PythonQtShell_QSslSocket::childEvent(QChildEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("childEvent");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QChildEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QSslSocket::childEvent(arg__1);
}
void PythonQtShell_QSslSocket::close()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("close");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={""};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QSslSocket::close();
}
void PythonQtShell_QSslSocket::connectToHost(const QString& hostName0, unsigned short port1, QIODevice::OpenMode openMode2, QAbstractSocket::NetworkLayerProtocol protocol3)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("connectToHost");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "const QString&" , "unsigned short" , "QIODevice::OpenMode" , "QAbstractSocket::NetworkLayerProtocol"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
void* args[5] = {NULL, (void*)&hostName0, (void*)&port1, (void*)&openMode2, (void*)&protocol3};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QSslSocket::connectToHost(hostName0, port1, openMode2, protocol3);
}
void PythonQtShell_QSslSocket::customEvent(QEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("customEvent");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QSslSocket::customEvent(arg__1);
}
void PythonQtShell_QSslSocket::disconnectFromHost()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("disconnectFromHost");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={""};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QSslSocket::disconnectFromHost();
}
bool PythonQtShell_QSslSocket::event(QEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("event");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::event(arg__1);
}
bool PythonQtShell_QSslSocket::eventFilter(QObject* arg__1, QEvent* arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("eventFilter");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
bool returnValue;
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::eventFilter(arg__1, arg__2);
}
bool PythonQtShell_QSslSocket::isSequential() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("isSequential");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("isSequential", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::isSequential();
}
bool PythonQtShell_QSslSocket::open(QIODevice::OpenMode mode0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("open");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&mode0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::open(mode0);
}
qint64 PythonQtShell_QSslSocket::pos() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("pos");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("pos", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::pos();
}
qint64 PythonQtShell_QSslSocket::readData(char* data0, qint64 maxlen1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("readData");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64" , "char*" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
qint64 returnValue;
void* args[3] = {NULL, (void*)&data0, (void*)&maxlen1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("readData", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::readData(data0, maxlen1);
}
qint64 PythonQtShell_QSslSocket::readLineData(char* data0, qint64 maxlen1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("readLineData");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64" , "char*" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
qint64 returnValue;
void* args[3] = {NULL, (void*)&data0, (void*)&maxlen1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("readLineData", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::readLineData(data0, maxlen1);
}
bool PythonQtShell_QSslSocket::reset()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("reset");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("reset", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::reset();
}
void PythonQtShell_QSslSocket::resume()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("resume");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={""};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QSslSocket::resume();
}
bool PythonQtShell_QSslSocket::seek(qint64 pos0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("seek");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&pos0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::seek(pos0);
}
void PythonQtShell_QSslSocket::setReadBufferSize(qint64 size0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("setReadBufferSize");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&size0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QSslSocket::setReadBufferSize(size0);
}
void PythonQtShell_QSslSocket::setSocketOption(QAbstractSocket::SocketOption option0, const QVariant& value1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("setSocketOption");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QAbstractSocket::SocketOption" , "const QVariant&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
void* args[3] = {NULL, (void*)&option0, (void*)&value1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QSslSocket::setSocketOption(option0, value1);
}
qint64 PythonQtShell_QSslSocket::size() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("size");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("size", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::size();
}
QVariant PythonQtShell_QSslSocket::socketOption(QAbstractSocket::SocketOption option0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("socketOption");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"QVariant" , "QAbstractSocket::SocketOption"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QVariant returnValue;
void* args[2] = {NULL, (void*)&option0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("socketOption", methodInfo, result);
} else {
returnValue = *((QVariant*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::socketOption(option0);
}
void PythonQtShell_QSslSocket::timerEvent(QTimerEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("timerEvent");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QTimerEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QSslSocket::timerEvent(arg__1);
}
bool PythonQtShell_QSslSocket::waitForBytesWritten(int msecs0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("waitForBytesWritten");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&msecs0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("waitForBytesWritten", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::waitForBytesWritten(msecs0);
}
bool PythonQtShell_QSslSocket::waitForConnected(int msecs0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("waitForConnected");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&msecs0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("waitForConnected", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::waitForConnected(msecs0);
}
bool PythonQtShell_QSslSocket::waitForDisconnected(int msecs0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("waitForDisconnected");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&msecs0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("waitForDisconnected", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::waitForDisconnected(msecs0);
}
bool PythonQtShell_QSslSocket::waitForReadyRead(int msecs0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("waitForReadyRead");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&msecs0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("waitForReadyRead", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::waitForReadyRead(msecs0);
}
qint64 PythonQtShell_QSslSocket::writeData(const char* data0, qint64 len1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("writeData");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64" , "const char*" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
qint64 returnValue;
void* args[3] = {NULL, (void*)&data0, (void*)&len1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("writeData", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QSslSocket::writeData(data0, len1);
}
QSslSocket* PythonQtWrapper_QSslSocket::new_QSslSocket(QObject* parent)
{
return new PythonQtShell_QSslSocket(parent); }
void PythonQtWrapper_QSslSocket::abort(QSslSocket* theWrappedObject)
{
( theWrappedObject->abort());
}
void PythonQtWrapper_QSslSocket::addCaCertificate(QSslSocket* theWrappedObject, const QSslCertificate& certificate)
{
( theWrappedObject->addCaCertificate(certificate));
}
void PythonQtWrapper_QSslSocket::addCaCertificates(QSslSocket* theWrappedObject, const QList<QSslCertificate >& certificates)
{
( theWrappedObject->addCaCertificates(certificates));
}
bool PythonQtWrapper_QSslSocket::addCaCertificates(QSslSocket* theWrappedObject, const QString& path, QSsl::EncodingFormat format, QRegExp::PatternSyntax syntax)
{
return ( theWrappedObject->addCaCertificates(path, format, syntax));
}
void PythonQtWrapper_QSslSocket::static_QSslSocket_addDefaultCaCertificate(const QSslCertificate& certificate)
{
(QSslSocket::addDefaultCaCertificate(certificate));
}
void PythonQtWrapper_QSslSocket::static_QSslSocket_addDefaultCaCertificates(const QList<QSslCertificate >& certificates)
{
(QSslSocket::addDefaultCaCertificates(certificates));
}
bool PythonQtWrapper_QSslSocket::static_QSslSocket_addDefaultCaCertificates(const QString& path, QSsl::EncodingFormat format, QRegExp::PatternSyntax syntax)
{
return (QSslSocket::addDefaultCaCertificates(path, format, syntax));
}
bool PythonQtWrapper_QSslSocket::atEnd(QSslSocket* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_atEnd());
}
qint64 PythonQtWrapper_QSslSocket::bytesAvailable(QSslSocket* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_bytesAvailable());
}
qint64 PythonQtWrapper_QSslSocket::bytesToWrite(QSslSocket* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_bytesToWrite());
}
QList<QSslCertificate > PythonQtWrapper_QSslSocket::caCertificates(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->caCertificates());
}
bool PythonQtWrapper_QSslSocket::canReadLine(QSslSocket* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_canReadLine());
}
QList<QSslCipher > PythonQtWrapper_QSslSocket::ciphers(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->ciphers());
}
void PythonQtWrapper_QSslSocket::close(QSslSocket* theWrappedObject)
{
( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_close());
}
void PythonQtWrapper_QSslSocket::connectToHost(QSslSocket* theWrappedObject, const QString& hostName, unsigned short port, QIODevice::OpenMode openMode, QAbstractSocket::NetworkLayerProtocol protocol)
{
( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_connectToHost(hostName, port, openMode, protocol));
}
void PythonQtWrapper_QSslSocket::connectToHostEncrypted(QSslSocket* theWrappedObject, const QString& hostName, unsigned short port, QIODevice::OpenMode mode, QAbstractSocket::NetworkLayerProtocol protocol)
{
( theWrappedObject->connectToHostEncrypted(hostName, port, mode, protocol));
}
void PythonQtWrapper_QSslSocket::connectToHostEncrypted(QSslSocket* theWrappedObject, const QString& hostName, unsigned short port, const QString& sslPeerName, QIODevice::OpenMode mode, QAbstractSocket::NetworkLayerProtocol protocol)
{
( theWrappedObject->connectToHostEncrypted(hostName, port, sslPeerName, mode, protocol));
}
QList<QSslCertificate > PythonQtWrapper_QSslSocket::static_QSslSocket_defaultCaCertificates()
{
return (QSslSocket::defaultCaCertificates());
}
QList<QSslCipher > PythonQtWrapper_QSslSocket::static_QSslSocket_defaultCiphers()
{
return (QSslSocket::defaultCiphers());
}
void PythonQtWrapper_QSslSocket::disconnectFromHost(QSslSocket* theWrappedObject)
{
( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_disconnectFromHost());
}
qint64 PythonQtWrapper_QSslSocket::encryptedBytesAvailable(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->encryptedBytesAvailable());
}
qint64 PythonQtWrapper_QSslSocket::encryptedBytesToWrite(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->encryptedBytesToWrite());
}
bool PythonQtWrapper_QSslSocket::flush(QSslSocket* theWrappedObject)
{
return ( theWrappedObject->flush());
}
void PythonQtWrapper_QSslSocket::ignoreSslErrors(QSslSocket* theWrappedObject, const QList<QSslError >& errors)
{
( theWrappedObject->ignoreSslErrors(errors));
}
bool PythonQtWrapper_QSslSocket::isEncrypted(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->isEncrypted());
}
QSslCertificate PythonQtWrapper_QSslSocket::localCertificate(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->localCertificate());
}
QList<QSslCertificate > PythonQtWrapper_QSslSocket::localCertificateChain(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->localCertificateChain());
}
QSslSocket::SslMode PythonQtWrapper_QSslSocket::mode(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->mode());
}
QSslCertificate PythonQtWrapper_QSslSocket::peerCertificate(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->peerCertificate());
}
QList<QSslCertificate > PythonQtWrapper_QSslSocket::peerCertificateChain(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->peerCertificateChain());
}
int PythonQtWrapper_QSslSocket::peerVerifyDepth(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->peerVerifyDepth());
}
QSslSocket::PeerVerifyMode PythonQtWrapper_QSslSocket::peerVerifyMode(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->peerVerifyMode());
}
QString PythonQtWrapper_QSslSocket::peerVerifyName(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->peerVerifyName());
}
QSslKey PythonQtWrapper_QSslSocket::privateKey(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->privateKey());
}
QSsl::SslProtocol PythonQtWrapper_QSslSocket::protocol(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->protocol());
}
qint64 PythonQtWrapper_QSslSocket::readData(QSslSocket* theWrappedObject, char* data, qint64 maxlen)
{
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_readData(data, maxlen));
}
void PythonQtWrapper_QSslSocket::resume(QSslSocket* theWrappedObject)
{
( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_resume());
}
QSslCipher PythonQtWrapper_QSslSocket::sessionCipher(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->sessionCipher());
}
void PythonQtWrapper_QSslSocket::setCaCertificates(QSslSocket* theWrappedObject, const QList<QSslCertificate >& certificates)
{
( theWrappedObject->setCaCertificates(certificates));
}
void PythonQtWrapper_QSslSocket::setCiphers(QSslSocket* theWrappedObject, const QList<QSslCipher >& ciphers)
{
( theWrappedObject->setCiphers(ciphers));
}
void PythonQtWrapper_QSslSocket::setCiphers(QSslSocket* theWrappedObject, const QString& ciphers)
{
( theWrappedObject->setCiphers(ciphers));
}
void PythonQtWrapper_QSslSocket::static_QSslSocket_setDefaultCaCertificates(const QList<QSslCertificate >& certificates)
{
(QSslSocket::setDefaultCaCertificates(certificates));
}
void PythonQtWrapper_QSslSocket::static_QSslSocket_setDefaultCiphers(const QList<QSslCipher >& ciphers)
{
(QSslSocket::setDefaultCiphers(ciphers));
}
void PythonQtWrapper_QSslSocket::setLocalCertificate(QSslSocket* theWrappedObject, const QSslCertificate& certificate)
{
( theWrappedObject->setLocalCertificate(certificate));
}
void PythonQtWrapper_QSslSocket::setLocalCertificate(QSslSocket* theWrappedObject, const QString& fileName, QSsl::EncodingFormat format)
{
( theWrappedObject->setLocalCertificate(fileName, format));
}
void PythonQtWrapper_QSslSocket::setLocalCertificateChain(QSslSocket* theWrappedObject, const QList<QSslCertificate >& localChain)
{
( theWrappedObject->setLocalCertificateChain(localChain));
}
void PythonQtWrapper_QSslSocket::setPeerVerifyDepth(QSslSocket* theWrappedObject, int depth)
{
( theWrappedObject->setPeerVerifyDepth(depth));
}
void PythonQtWrapper_QSslSocket::setPeerVerifyMode(QSslSocket* theWrappedObject, QSslSocket::PeerVerifyMode mode)
{
( theWrappedObject->setPeerVerifyMode(mode));
}
void PythonQtWrapper_QSslSocket::setPeerVerifyName(QSslSocket* theWrappedObject, const QString& hostName)
{
( theWrappedObject->setPeerVerifyName(hostName));
}
void PythonQtWrapper_QSslSocket::setPrivateKey(QSslSocket* theWrappedObject, const QSslKey& key)
{
( theWrappedObject->setPrivateKey(key));
}
void PythonQtWrapper_QSslSocket::setPrivateKey(QSslSocket* theWrappedObject, const QString& fileName, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format, const QByteArray& passPhrase)
{
( theWrappedObject->setPrivateKey(fileName, algorithm, format, passPhrase));
}
void PythonQtWrapper_QSslSocket::setProtocol(QSslSocket* theWrappedObject, QSsl::SslProtocol protocol)
{
( theWrappedObject->setProtocol(protocol));
}
void PythonQtWrapper_QSslSocket::setReadBufferSize(QSslSocket* theWrappedObject, qint64 size)
{
( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_setReadBufferSize(size));
}
void PythonQtWrapper_QSslSocket::setSocketOption(QSslSocket* theWrappedObject, QAbstractSocket::SocketOption option, const QVariant& value)
{
( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_setSocketOption(option, value));
}
void PythonQtWrapper_QSslSocket::setSslConfiguration(QSslSocket* theWrappedObject, const QSslConfiguration& config)
{
( theWrappedObject->setSslConfiguration(config));
}
QVariant PythonQtWrapper_QSslSocket::socketOption(QSslSocket* theWrappedObject, QAbstractSocket::SocketOption option)
{
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_socketOption(option));
}
QSslConfiguration PythonQtWrapper_QSslSocket::sslConfiguration(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->sslConfiguration());
}
QList<QSslError > PythonQtWrapper_QSslSocket::sslErrors(QSslSocket* theWrappedObject) const
{
return ( theWrappedObject->sslErrors());
}
long PythonQtWrapper_QSslSocket::static_QSslSocket_sslLibraryVersionNumber()
{
return (QSslSocket::sslLibraryVersionNumber());
}
QString PythonQtWrapper_QSslSocket::static_QSslSocket_sslLibraryVersionString()
{
return (QSslSocket::sslLibraryVersionString());
}
QList<QSslCipher > PythonQtWrapper_QSslSocket::static_QSslSocket_supportedCiphers()
{
return (QSslSocket::supportedCiphers());
}
bool PythonQtWrapper_QSslSocket::static_QSslSocket_supportsSsl()
{
return (QSslSocket::supportsSsl());
}
QList<QSslCertificate > PythonQtWrapper_QSslSocket::static_QSslSocket_systemCaCertificates()
{
return (QSslSocket::systemCaCertificates());
}
bool PythonQtWrapper_QSslSocket::waitForBytesWritten(QSslSocket* theWrappedObject, int msecs)
{
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_waitForBytesWritten(msecs));
}
bool PythonQtWrapper_QSslSocket::waitForConnected(QSslSocket* theWrappedObject, int msecs)
{
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_waitForConnected(msecs));
}
bool PythonQtWrapper_QSslSocket::waitForDisconnected(QSslSocket* theWrappedObject, int msecs)
{
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_waitForDisconnected(msecs));
}
bool PythonQtWrapper_QSslSocket::waitForEncrypted(QSslSocket* theWrappedObject, int msecs)
{
return ( theWrappedObject->waitForEncrypted(msecs));
}
bool PythonQtWrapper_QSslSocket::waitForReadyRead(QSslSocket* theWrappedObject, int msecs)
{
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_waitForReadyRead(msecs));
}
qint64 PythonQtWrapper_QSslSocket::writeData(QSslSocket* theWrappedObject, const char* data, qint64 len)
{
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_writeData(data, len));
}
#endif
PythonQtShell_QTcpServer::~PythonQtShell_QTcpServer() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QTcpServer::childEvent(QChildEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("childEvent");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QChildEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpServer::childEvent(arg__1);
}
void PythonQtShell_QTcpServer::customEvent(QEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("customEvent");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpServer::customEvent(arg__1);
}
bool PythonQtShell_QTcpServer::event(QEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("event");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpServer::event(arg__1);
}
bool PythonQtShell_QTcpServer::eventFilter(QObject* arg__1, QEvent* arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("eventFilter");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
bool returnValue;
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpServer::eventFilter(arg__1, arg__2);
}
bool PythonQtShell_QTcpServer::hasPendingConnections() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("hasPendingConnections");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("hasPendingConnections", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpServer::hasPendingConnections();
}
QTcpSocket* PythonQtShell_QTcpServer::nextPendingConnection()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("nextPendingConnection");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"QTcpSocket*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
QTcpSocket* returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("nextPendingConnection", methodInfo, result);
} else {
returnValue = *((QTcpSocket**)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpServer::nextPendingConnection();
}
void PythonQtShell_QTcpServer::timerEvent(QTimerEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("timerEvent");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QTimerEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpServer::timerEvent(arg__1);
}
QTcpServer* PythonQtWrapper_QTcpServer::new_QTcpServer(QObject* parent)
{
return new PythonQtShell_QTcpServer(parent); }
void PythonQtWrapper_QTcpServer::addPendingConnection(QTcpServer* theWrappedObject, QTcpSocket* socket)
{
( ((PythonQtPublicPromoter_QTcpServer*)theWrappedObject)->promoted_addPendingConnection(socket));
}
void PythonQtWrapper_QTcpServer::close(QTcpServer* theWrappedObject)
{
( theWrappedObject->close());
}
QString PythonQtWrapper_QTcpServer::errorString(QTcpServer* theWrappedObject) const
{
return ( theWrappedObject->errorString());
}
bool PythonQtWrapper_QTcpServer::hasPendingConnections(QTcpServer* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QTcpServer*)theWrappedObject)->promoted_hasPendingConnections());
}
bool PythonQtWrapper_QTcpServer::isListening(QTcpServer* theWrappedObject) const
{
return ( theWrappedObject->isListening());
}
bool PythonQtWrapper_QTcpServer::listen(QTcpServer* theWrappedObject, const QHostAddress& address, unsigned short port)
{
return ( theWrappedObject->listen(address, port));
}
int PythonQtWrapper_QTcpServer::maxPendingConnections(QTcpServer* theWrappedObject) const
{
return ( theWrappedObject->maxPendingConnections());
}
QTcpSocket* PythonQtWrapper_QTcpServer::nextPendingConnection(QTcpServer* theWrappedObject)
{
return ( ((PythonQtPublicPromoter_QTcpServer*)theWrappedObject)->promoted_nextPendingConnection());
}
void PythonQtWrapper_QTcpServer::pauseAccepting(QTcpServer* theWrappedObject)
{
( theWrappedObject->pauseAccepting());
}
QNetworkProxy PythonQtWrapper_QTcpServer::proxy(QTcpServer* theWrappedObject) const
{
return ( theWrappedObject->proxy());
}
void PythonQtWrapper_QTcpServer::resumeAccepting(QTcpServer* theWrappedObject)
{
( theWrappedObject->resumeAccepting());
}
QHostAddress PythonQtWrapper_QTcpServer::serverAddress(QTcpServer* theWrappedObject) const
{
return ( theWrappedObject->serverAddress());
}
QAbstractSocket::SocketError PythonQtWrapper_QTcpServer::serverError(QTcpServer* theWrappedObject) const
{
return ( theWrappedObject->serverError());
}
unsigned short PythonQtWrapper_QTcpServer::serverPort(QTcpServer* theWrappedObject) const
{
return ( theWrappedObject->serverPort());
}
void PythonQtWrapper_QTcpServer::setMaxPendingConnections(QTcpServer* theWrappedObject, int numConnections)
{
( theWrappedObject->setMaxPendingConnections(numConnections));
}
void PythonQtWrapper_QTcpServer::setProxy(QTcpServer* theWrappedObject, const QNetworkProxy& networkProxy)
{
( theWrappedObject->setProxy(networkProxy));
}
bool PythonQtWrapper_QTcpServer::waitForNewConnection(QTcpServer* theWrappedObject, int msec, bool* timedOut)
{
return ( theWrappedObject->waitForNewConnection(msec, timedOut));
}
PythonQtShell_QTcpSocket::~PythonQtShell_QTcpSocket() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
bool PythonQtShell_QTcpSocket::atEnd() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("atEnd");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("atEnd", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::atEnd();
}
qint64 PythonQtShell_QTcpSocket::bytesAvailable() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("bytesAvailable");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("bytesAvailable", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::bytesAvailable();
}
qint64 PythonQtShell_QTcpSocket::bytesToWrite() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("bytesToWrite");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("bytesToWrite", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::bytesToWrite();
}
bool PythonQtShell_QTcpSocket::canReadLine() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("canReadLine");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("canReadLine", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::canReadLine();
}
void PythonQtShell_QTcpSocket::childEvent(QChildEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("childEvent");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QChildEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpSocket::childEvent(arg__1);
}
void PythonQtShell_QTcpSocket::close()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("close");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={""};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpSocket::close();
}
void PythonQtShell_QTcpSocket::connectToHost(const QHostAddress& address0, unsigned short port1, QIODevice::OpenMode mode2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("connectToHost");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "const QHostAddress&" , "unsigned short" , "QIODevice::OpenMode"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
void* args[4] = {NULL, (void*)&address0, (void*)&port1, (void*)&mode2};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpSocket::connectToHost(address0, port1, mode2);
}
void PythonQtShell_QTcpSocket::connectToHost(const QString& hostName0, unsigned short port1, QIODevice::OpenMode mode2, QAbstractSocket::NetworkLayerProtocol protocol3)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("connectToHost");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "const QString&" , "unsigned short" , "QIODevice::OpenMode" , "QAbstractSocket::NetworkLayerProtocol"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
void* args[5] = {NULL, (void*)&hostName0, (void*)&port1, (void*)&mode2, (void*)&protocol3};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpSocket::connectToHost(hostName0, port1, mode2, protocol3);
}
void PythonQtShell_QTcpSocket::customEvent(QEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("customEvent");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpSocket::customEvent(arg__1);
}
void PythonQtShell_QTcpSocket::disconnectFromHost()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("disconnectFromHost");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={""};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpSocket::disconnectFromHost();
}
bool PythonQtShell_QTcpSocket::event(QEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("event");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::event(arg__1);
}
bool PythonQtShell_QTcpSocket::eventFilter(QObject* arg__1, QEvent* arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("eventFilter");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
bool returnValue;
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::eventFilter(arg__1, arg__2);
}
bool PythonQtShell_QTcpSocket::isSequential() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("isSequential");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("isSequential", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::isSequential();
}
bool PythonQtShell_QTcpSocket::open(QIODevice::OpenMode mode0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("open");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&mode0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::open(mode0);
}
qint64 PythonQtShell_QTcpSocket::pos() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("pos");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("pos", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::pos();
}
qint64 PythonQtShell_QTcpSocket::readData(char* data0, qint64 maxlen1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("readData");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64" , "char*" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
qint64 returnValue;
void* args[3] = {NULL, (void*)&data0, (void*)&maxlen1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("readData", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::readData(data0, maxlen1);
}
qint64 PythonQtShell_QTcpSocket::readLineData(char* data0, qint64 maxlen1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("readLineData");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64" , "char*" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
qint64 returnValue;
void* args[3] = {NULL, (void*)&data0, (void*)&maxlen1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("readLineData", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::readLineData(data0, maxlen1);
}
bool PythonQtShell_QTcpSocket::reset()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("reset");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("reset", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::reset();
}
void PythonQtShell_QTcpSocket::resume()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("resume");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={""};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpSocket::resume();
}
bool PythonQtShell_QTcpSocket::seek(qint64 pos0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("seek");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&pos0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::seek(pos0);
}
void PythonQtShell_QTcpSocket::setReadBufferSize(qint64 size0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("setReadBufferSize");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&size0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpSocket::setReadBufferSize(size0);
}
void PythonQtShell_QTcpSocket::setSocketOption(QAbstractSocket::SocketOption option0, const QVariant& value1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("setSocketOption");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QAbstractSocket::SocketOption" , "const QVariant&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
void* args[3] = {NULL, (void*)&option0, (void*)&value1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpSocket::setSocketOption(option0, value1);
}
qint64 PythonQtShell_QTcpSocket::size() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("size");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("size", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::size();
}
QVariant PythonQtShell_QTcpSocket::socketOption(QAbstractSocket::SocketOption option0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("socketOption");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"QVariant" , "QAbstractSocket::SocketOption"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QVariant returnValue;
void* args[2] = {NULL, (void*)&option0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("socketOption", methodInfo, result);
} else {
returnValue = *((QVariant*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::socketOption(option0);
}
void PythonQtShell_QTcpSocket::timerEvent(QTimerEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("timerEvent");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QTimerEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QTcpSocket::timerEvent(arg__1);
}
bool PythonQtShell_QTcpSocket::waitForBytesWritten(int msecs0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("waitForBytesWritten");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&msecs0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("waitForBytesWritten", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::waitForBytesWritten(msecs0);
}
bool PythonQtShell_QTcpSocket::waitForConnected(int msecs0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("waitForConnected");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&msecs0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("waitForConnected", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::waitForConnected(msecs0);
}
bool PythonQtShell_QTcpSocket::waitForDisconnected(int msecs0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("waitForDisconnected");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&msecs0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("waitForDisconnected", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::waitForDisconnected(msecs0);
}
bool PythonQtShell_QTcpSocket::waitForReadyRead(int msecs0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("waitForReadyRead");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&msecs0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("waitForReadyRead", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::waitForReadyRead(msecs0);
}
qint64 PythonQtShell_QTcpSocket::writeData(const char* data0, qint64 len1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("writeData");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64" , "const char*" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
qint64 returnValue;
void* args[3] = {NULL, (void*)&data0, (void*)&len1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("writeData", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QTcpSocket::writeData(data0, len1);
}
QTcpSocket* PythonQtWrapper_QTcpSocket::new_QTcpSocket(QObject* parent)
{
return new PythonQtShell_QTcpSocket(parent); }
PythonQtShell_QUdpSocket::~PythonQtShell_QUdpSocket() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
bool PythonQtShell_QUdpSocket::atEnd() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("atEnd");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("atEnd", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::atEnd();
}
qint64 PythonQtShell_QUdpSocket::bytesAvailable() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("bytesAvailable");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("bytesAvailable", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::bytesAvailable();
}
qint64 PythonQtShell_QUdpSocket::bytesToWrite() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("bytesToWrite");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("bytesToWrite", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::bytesToWrite();
}
bool PythonQtShell_QUdpSocket::canReadLine() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("canReadLine");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("canReadLine", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::canReadLine();
}
void PythonQtShell_QUdpSocket::childEvent(QChildEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("childEvent");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QChildEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QUdpSocket::childEvent(arg__1);
}
void PythonQtShell_QUdpSocket::close()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("close");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={""};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QUdpSocket::close();
}
void PythonQtShell_QUdpSocket::connectToHost(const QHostAddress& address0, unsigned short port1, QIODevice::OpenMode mode2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("connectToHost");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "const QHostAddress&" , "unsigned short" , "QIODevice::OpenMode"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
void* args[4] = {NULL, (void*)&address0, (void*)&port1, (void*)&mode2};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QUdpSocket::connectToHost(address0, port1, mode2);
}
void PythonQtShell_QUdpSocket::connectToHost(const QString& hostName0, unsigned short port1, QIODevice::OpenMode mode2, QAbstractSocket::NetworkLayerProtocol protocol3)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("connectToHost");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "const QString&" , "unsigned short" , "QIODevice::OpenMode" , "QAbstractSocket::NetworkLayerProtocol"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
void* args[5] = {NULL, (void*)&hostName0, (void*)&port1, (void*)&mode2, (void*)&protocol3};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QUdpSocket::connectToHost(hostName0, port1, mode2, protocol3);
}
void PythonQtShell_QUdpSocket::customEvent(QEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("customEvent");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QUdpSocket::customEvent(arg__1);
}
void PythonQtShell_QUdpSocket::disconnectFromHost()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("disconnectFromHost");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={""};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QUdpSocket::disconnectFromHost();
}
bool PythonQtShell_QUdpSocket::event(QEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("event");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::event(arg__1);
}
bool PythonQtShell_QUdpSocket::eventFilter(QObject* arg__1, QEvent* arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("eventFilter");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
bool returnValue;
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::eventFilter(arg__1, arg__2);
}
bool PythonQtShell_QUdpSocket::isSequential() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("isSequential");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("isSequential", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::isSequential();
}
bool PythonQtShell_QUdpSocket::open(QIODevice::OpenMode mode0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("open");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&mode0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::open(mode0);
}
qint64 PythonQtShell_QUdpSocket::pos() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("pos");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("pos", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::pos();
}
qint64 PythonQtShell_QUdpSocket::readData(char* data0, qint64 maxlen1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("readData");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64" , "char*" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
qint64 returnValue;
void* args[3] = {NULL, (void*)&data0, (void*)&maxlen1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("readData", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::readData(data0, maxlen1);
}
qint64 PythonQtShell_QUdpSocket::readLineData(char* data0, qint64 maxlen1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("readLineData");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64" , "char*" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
qint64 returnValue;
void* args[3] = {NULL, (void*)&data0, (void*)&maxlen1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("readLineData", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::readLineData(data0, maxlen1);
}
bool PythonQtShell_QUdpSocket::reset()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("reset");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
bool returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("reset", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::reset();
}
void PythonQtShell_QUdpSocket::resume()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("resume");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={""};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QUdpSocket::resume();
}
bool PythonQtShell_QUdpSocket::seek(qint64 pos0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("seek");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&pos0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::seek(pos0);
}
void PythonQtShell_QUdpSocket::setReadBufferSize(qint64 size0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("setReadBufferSize");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&size0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QUdpSocket::setReadBufferSize(size0);
}
void PythonQtShell_QUdpSocket::setSocketOption(QAbstractSocket::SocketOption option0, const QVariant& value1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("setSocketOption");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QAbstractSocket::SocketOption" , "const QVariant&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
void* args[3] = {NULL, (void*)&option0, (void*)&value1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QUdpSocket::setSocketOption(option0, value1);
}
qint64 PythonQtShell_QUdpSocket::size() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("size");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
qint64 returnValue;
void* args[1] = {NULL};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("size", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::size();
}
QVariant PythonQtShell_QUdpSocket::socketOption(QAbstractSocket::SocketOption option0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("socketOption");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"QVariant" , "QAbstractSocket::SocketOption"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QVariant returnValue;
void* args[2] = {NULL, (void*)&option0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("socketOption", methodInfo, result);
} else {
returnValue = *((QVariant*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::socketOption(option0);
}
void PythonQtShell_QUdpSocket::timerEvent(QTimerEvent* arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("timerEvent");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"" , "QTimerEvent*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&arg__1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
} else {
PyErr_Clear();
}
}
QUdpSocket::timerEvent(arg__1);
}
bool PythonQtShell_QUdpSocket::waitForBytesWritten(int msecs0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("waitForBytesWritten");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&msecs0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("waitForBytesWritten", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::waitForBytesWritten(msecs0);
}
bool PythonQtShell_QUdpSocket::waitForConnected(int msecs0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("waitForConnected");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&msecs0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("waitForConnected", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::waitForConnected(msecs0);
}
bool PythonQtShell_QUdpSocket::waitForDisconnected(int msecs0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("waitForDisconnected");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&msecs0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("waitForDisconnected", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::waitForDisconnected(msecs0);
}
bool PythonQtShell_QUdpSocket::waitForReadyRead(int msecs0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("waitForReadyRead");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"bool" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&msecs0};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("waitForReadyRead", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::waitForReadyRead(msecs0);
}
qint64 PythonQtShell_QUdpSocket::writeData(const char* data0, qint64 len1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
static PyObject* name = PyString_FromString("writeData");
PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
if (obj) {
static const char* argumentList[] ={"qint64" , "const char*" , "qint64"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
qint64 returnValue;
void* args[3] = {NULL, (void*)&data0, (void*)&len1};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("writeData", methodInfo, result);
} else {
returnValue = *((qint64*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
} else {
PyErr_Clear();
}
}
return QUdpSocket::writeData(data0, len1);
}
QUdpSocket* PythonQtWrapper_QUdpSocket::new_QUdpSocket(QObject* parent)
{
return new PythonQtShell_QUdpSocket(parent); }
bool PythonQtWrapper_QUdpSocket::hasPendingDatagrams(QUdpSocket* theWrappedObject) const
{
return ( theWrappedObject->hasPendingDatagrams());
}
bool PythonQtWrapper_QUdpSocket::joinMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress& groupAddress)
{
return ( theWrappedObject->joinMulticastGroup(groupAddress));
}
bool PythonQtWrapper_QUdpSocket::joinMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress& groupAddress, const QNetworkInterface& iface)
{
return ( theWrappedObject->joinMulticastGroup(groupAddress, iface));
}
bool PythonQtWrapper_QUdpSocket::leaveMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress& groupAddress)
{
return ( theWrappedObject->leaveMulticastGroup(groupAddress));
}
bool PythonQtWrapper_QUdpSocket::leaveMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress& groupAddress, const QNetworkInterface& iface)
{
return ( theWrappedObject->leaveMulticastGroup(groupAddress, iface));
}
QNetworkInterface PythonQtWrapper_QUdpSocket::multicastInterface(QUdpSocket* theWrappedObject) const
{
return ( theWrappedObject->multicastInterface());
}
qint64 PythonQtWrapper_QUdpSocket::pendingDatagramSize(QUdpSocket* theWrappedObject) const
{
return ( theWrappedObject->pendingDatagramSize());
}
qint64 PythonQtWrapper_QUdpSocket::readDatagram(QUdpSocket* theWrappedObject, char* data, qint64 maxlen, QHostAddress* host, unsigned short* port)
{
return ( theWrappedObject->readDatagram(data, maxlen, host, port));
}
void PythonQtWrapper_QUdpSocket::setMulticastInterface(QUdpSocket* theWrappedObject, const QNetworkInterface& iface)
{
( theWrappedObject->setMulticastInterface(iface));
}
qint64 PythonQtWrapper_QUdpSocket::writeDatagram(QUdpSocket* theWrappedObject, const QByteArray& datagram, const QHostAddress& host, unsigned short port)
{
return ( theWrappedObject->writeDatagram(datagram, host, port));
}