|
|
#include "PythonQtWrapper_QAbstractSocket.h"
|
|
|
|
|
|
#include <PythonQtSignalReceiver.h>
|
|
|
#include <PythonQtMethodInfo.h>
|
|
|
#include <PythonQtConversion.h>
|
|
|
#include <QVariant>
|
|
|
#include <qabstractsocket.h>
|
|
|
#include <qauthenticator.h>
|
|
|
#include <qbytearray.h>
|
|
|
#include <qcoreevent.h>
|
|
|
#include <qhostaddress.h>
|
|
|
#include <qlist.h>
|
|
|
#include <qnetworkproxy.h>
|
|
|
#include <qobject.h>
|
|
|
|
|
|
bool PythonQtShell_QAbstractSocket::atEnd() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "atEnd");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"atEnd(QAbstractSocket*)");
|
|
|
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) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::atEnd();
|
|
|
}
|
|
|
qint64 PythonQtShell_QAbstractSocket::bytesAvailable() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesAvailable");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"bytesAvailable(QAbstractSocket*)");
|
|
|
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) {
|
|
|
returnValue = *((qint64 *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::bytesAvailable();
|
|
|
}
|
|
|
qint64 PythonQtShell_QAbstractSocket::bytesToWrite() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesToWrite");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"bytesToWrite(QAbstractSocket*)");
|
|
|
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) {
|
|
|
returnValue = *((qint64 *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::bytesToWrite();
|
|
|
}
|
|
|
bool PythonQtShell_QAbstractSocket::canReadLine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canReadLine");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"canReadLine(QAbstractSocket*)");
|
|
|
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) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::canReadLine();
|
|
|
}
|
|
|
void PythonQtShell_QAbstractSocket::childEvent(QChildEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"childEvent(QAbstractSocket*,QChildEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QAbstractSocket::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QAbstractSocket::close()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "close");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"close(QAbstractSocket*)");
|
|
|
void* args[1] = {NULL};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QAbstractSocket::close();
|
|
|
}
|
|
|
void PythonQtShell_QAbstractSocket::customEvent(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"customEvent(QAbstractSocket*,QEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QAbstractSocket::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QAbstractSocket::event(QEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"event(QAbstractSocket*,QEvent* )");
|
|
|
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) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QAbstractSocket::eventFilter(QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"eventFilter(QAbstractSocket*,QObject* ,QEvent* )");
|
|
|
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) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
bool PythonQtShell_QAbstractSocket::isSequential() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isSequential");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"isSequential(QAbstractSocket*)");
|
|
|
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) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::isSequential();
|
|
|
}
|
|
|
bool PythonQtShell_QAbstractSocket::open(QIODevice::OpenMode mode)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"open(QAbstractSocket*,QIODevice::OpenMode )");
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&mode};
|
|
|
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) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::open(mode);
|
|
|
}
|
|
|
qint64 PythonQtShell_QAbstractSocket::pos() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pos");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"pos(QAbstractSocket*)");
|
|
|
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) {
|
|
|
returnValue = *((qint64 *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::pos();
|
|
|
}
|
|
|
qint64 PythonQtShell_QAbstractSocket::readData(char* data, qint64 maxlen)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"readData(QAbstractSocket*,char* ,qint64 )");
|
|
|
qint64 returnValue;
|
|
|
void* args[3] = {NULL, (void*)&data, (void*)&maxlen};
|
|
|
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) {
|
|
|
returnValue = *((qint64 *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::readData(data, maxlen);
|
|
|
}
|
|
|
qint64 PythonQtShell_QAbstractSocket::readLineData(char* data, qint64 maxlen)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readLineData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"readLineData(QAbstractSocket*,char* ,qint64 )");
|
|
|
qint64 returnValue;
|
|
|
void* args[3] = {NULL, (void*)&data, (void*)&maxlen};
|
|
|
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) {
|
|
|
returnValue = *((qint64 *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::readLineData(data, maxlen);
|
|
|
}
|
|
|
bool PythonQtShell_QAbstractSocket::reset()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"reset(QAbstractSocket*)");
|
|
|
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) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::reset();
|
|
|
}
|
|
|
bool PythonQtShell_QAbstractSocket::seek(qint64 pos)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"seek(QAbstractSocket*,qint64 )");
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&pos};
|
|
|
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) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::seek(pos);
|
|
|
}
|
|
|
qint64 PythonQtShell_QAbstractSocket::size() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "size");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"size(QAbstractSocket*)");
|
|
|
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) {
|
|
|
returnValue = *((qint64 *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::size();
|
|
|
}
|
|
|
void PythonQtShell_QAbstractSocket::timerEvent(QTimerEvent* arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"timerEvent(QAbstractSocket*,QTimerEvent* )");
|
|
|
void* args[2] = {NULL, (void*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QAbstractSocket::timerEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QAbstractSocket::waitForBytesWritten(int msecs)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForBytesWritten");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"waitForBytesWritten(QAbstractSocket*,int )");
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&msecs};
|
|
|
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) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::waitForBytesWritten(msecs);
|
|
|
}
|
|
|
bool PythonQtShell_QAbstractSocket::waitForReadyRead(int msecs)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForReadyRead");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"waitForReadyRead(QAbstractSocket*,int )");
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&msecs};
|
|
|
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) {
|
|
|
returnValue = *((bool *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::waitForReadyRead(msecs);
|
|
|
}
|
|
|
qint64 PythonQtShell_QAbstractSocket::writeData(const char* data, qint64 len)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "writeData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromMetaObjectAndSignature(
|
|
|
&PythonQtWrapper_QAbstractSocket::staticMetaObject,
|
|
|
"writeData(QAbstractSocket*,const char* ,qint64 )");
|
|
|
qint64 returnValue;
|
|
|
void* args[3] = {NULL, (void*)&data, (void*)&len};
|
|
|
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) {
|
|
|
returnValue = *((qint64 *)args[0]);
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QAbstractSocket::writeData(data, len);
|
|
|
}
|
|
|
QAbstractSocket* PythonQtWrapper_QAbstractSocket::new_QAbstractSocket(QAbstractSocket::SocketType socketType, QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QAbstractSocket(socketType, parent); }
|
|
|
|
|
|
int PythonQtWrapper_QAbstractSocket::socketDescriptor(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->socketDescriptor();
|
|
|
}
|
|
|
|
|
|
QAbstractSocket::SocketError PythonQtWrapper_QAbstractSocket::error(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->error();
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QAbstractSocket::readLineData(QAbstractSocket* theWrappedObject, char* data, qint64 maxlen)
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_readLineData(data, maxlen);
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QAbstractSocket::peerName(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->peerName();
|
|
|
}
|
|
|
|
|
|
unsigned short PythonQtWrapper_QAbstractSocket::peerPort(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->peerPort();
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QAbstractSocket::readBufferSize(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->readBufferSize();
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QAbstractSocket::bytesAvailable(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_bytesAvailable();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QAbstractSocket::disconnectFromHost(QAbstractSocket* theWrappedObject)
|
|
|
{
|
|
|
theWrappedObject->disconnectFromHost();
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QAbstractSocket::waitForDisconnected(QAbstractSocket* theWrappedObject, int msecs)
|
|
|
{
|
|
|
return theWrappedObject->waitForDisconnected(msecs);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QAbstractSocket::connectToHost(QAbstractSocket* theWrappedObject, const QHostAddress& address, unsigned short port, QIODevice::OpenMode mode)
|
|
|
{
|
|
|
theWrappedObject->connectToHost(address, port, mode);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QAbstractSocket::waitForReadyRead(QAbstractSocket* theWrappedObject, int msecs)
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_waitForReadyRead(msecs);
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QAbstractSocket::bytesToWrite(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_bytesToWrite();
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QAbstractSocket::isValid(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->isValid();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QAbstractSocket::connectToHost(QAbstractSocket* theWrappedObject, const QString& hostName, unsigned short port, QIODevice::OpenMode mode)
|
|
|
{
|
|
|
theWrappedObject->connectToHost(hostName, port, mode);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QAbstractSocket::abort(QAbstractSocket* theWrappedObject)
|
|
|
{
|
|
|
theWrappedObject->abort();
|
|
|
}
|
|
|
|
|
|
unsigned short PythonQtWrapper_QAbstractSocket::localPort(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->localPort();
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QAbstractSocket::atEnd(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_atEnd();
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QAbstractSocket::waitForConnected(QAbstractSocket* theWrappedObject, int msecs)
|
|
|
{
|
|
|
return theWrappedObject->waitForConnected(msecs);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QAbstractSocket::setProxy(QAbstractSocket* theWrappedObject, const QNetworkProxy& networkProxy)
|
|
|
{
|
|
|
theWrappedObject->setProxy(networkProxy);
|
|
|
}
|
|
|
|
|
|
QAbstractSocket::SocketType PythonQtWrapper_QAbstractSocket::socketType(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->socketType();
|
|
|
}
|
|
|
|
|
|
QAbstractSocket::SocketState PythonQtWrapper_QAbstractSocket::state(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->state();
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QAbstractSocket::flush(QAbstractSocket* theWrappedObject)
|
|
|
{
|
|
|
return theWrappedObject->flush();
|
|
|
}
|
|
|
|
|
|
QHostAddress PythonQtWrapper_QAbstractSocket::localAddress(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->localAddress();
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QAbstractSocket::writeData(QAbstractSocket* theWrappedObject, const char* data, qint64 len)
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_writeData(data, len);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QAbstractSocket::setSocketDescriptor(QAbstractSocket* theWrappedObject, int socketDescriptor, QAbstractSocket::SocketState state, QIODevice::OpenMode openMode)
|
|
|
{
|
|
|
return theWrappedObject->setSocketDescriptor(socketDescriptor, state, openMode);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QAbstractSocket::isSequential(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_isSequential();
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QAbstractSocket::canReadLine(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_canReadLine();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QAbstractSocket::setReadBufferSize(QAbstractSocket* theWrappedObject, qint64 size)
|
|
|
{
|
|
|
theWrappedObject->setReadBufferSize(size);
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QAbstractSocket::readData(QAbstractSocket* theWrappedObject, char* data, qint64 maxlen)
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_readData(data, maxlen);
|
|
|
}
|
|
|
|
|
|
QNetworkProxy PythonQtWrapper_QAbstractSocket::proxy(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->proxy();
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QAbstractSocket::close(QAbstractSocket* theWrappedObject)
|
|
|
{
|
|
|
((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_close();
|
|
|
}
|
|
|
|
|
|
QHostAddress PythonQtWrapper_QAbstractSocket::peerAddress(QAbstractSocket* theWrappedObject) const
|
|
|
{
|
|
|
return theWrappedObject->peerAddress();
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QAbstractSocket::waitForBytesWritten(QAbstractSocket* theWrappedObject, int msecs)
|
|
|
{
|
|
|
return ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_waitForBytesWritten(msecs);
|
|
|
}
|
|
|
|
|
|
|