##// END OF EJS Templates
Added generator to install targets and removed examples from build.
Added generator to install targets and removed examples from build.

File last commit:

r11:b89840e63daa default
r12:17486c75e366 tip default
Show More
com_trolltech_qt_network1.h
375 lines | 19.4 KiB | text/x-c | CLexer
#include <PythonQt.h>
#include <QObject>
#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
class PythonQtWrapper_QSslKey : public QObject
{ Q_OBJECT
public:
public slots:
QSslKey* new_QSslKey();
QSslKey* new_QSslKey(QIODevice* device, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format = QSsl::Pem, QSsl::KeyType type = QSsl::PrivateKey, const QByteArray& passPhrase = QByteArray());
QSslKey* new_QSslKey(Qt::HANDLE handle, QSsl::KeyType type = QSsl::PrivateKey);
QSslKey* new_QSslKey(const QByteArray& encoded, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format = QSsl::Pem, QSsl::KeyType type = QSsl::PrivateKey, const QByteArray& passPhrase = QByteArray());
QSslKey* new_QSslKey(const QSslKey& other);
void delete_QSslKey(QSslKey* obj) { delete obj; }
QSsl::KeyAlgorithm algorithm(QSslKey* theWrappedObject) const;
void clear(QSslKey* theWrappedObject);
Qt::HANDLE handle(QSslKey* theWrappedObject) const;
bool isNull(QSslKey* theWrappedObject) const;
int length(QSslKey* theWrappedObject) const;
bool __ne__(QSslKey* theWrappedObject, const QSslKey& key) const;
QSslKey* operator_assign(QSslKey* theWrappedObject, const QSslKey& other);
bool __eq__(QSslKey* theWrappedObject, const QSslKey& key) const;
void swap(QSslKey* theWrappedObject, QSslKey& other);
QByteArray toDer(QSslKey* theWrappedObject, const QByteArray& passPhrase = QByteArray()) const;
QByteArray toPem(QSslKey* theWrappedObject, const QByteArray& passPhrase = QByteArray()) const;
QSsl::KeyType type(QSslKey* theWrappedObject) const;
QString py_toString(QSslKey*);
bool __nonzero__(QSslKey* obj) { return !obj->isNull(); }
};
#endif
#ifndef QT_NO_OPENSSL
class PythonQtShell_QSslSocket : public QSslSocket
{
public:
PythonQtShell_QSslSocket(QObject* parent = 0):QSslSocket(parent),_wrapper(NULL) {};
~PythonQtShell_QSslSocket();
virtual bool atEnd() const;
virtual qint64 bytesAvailable() const;
virtual qint64 bytesToWrite() const;
virtual bool canReadLine() const;
virtual void childEvent(QChildEvent* arg__1);
virtual void close();
virtual void connectToHost(const QString& hostName, unsigned short port, QIODevice::OpenMode openMode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = QAbstractSocket::AnyIPProtocol);
virtual void customEvent(QEvent* arg__1);
virtual void disconnectFromHost();
virtual bool event(QEvent* arg__1);
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
virtual bool isSequential() const;
virtual bool open(QIODevice::OpenMode mode);
virtual qint64 pos() const;
virtual qint64 readData(char* data, qint64 maxlen);
virtual qint64 readLineData(char* data, qint64 maxlen);
virtual bool reset();
virtual void resume();
virtual bool seek(qint64 pos);
virtual void setReadBufferSize(qint64 size);
virtual void setSocketOption(QAbstractSocket::SocketOption option, const QVariant& value);
virtual qint64 size() const;
virtual QVariant socketOption(QAbstractSocket::SocketOption option);
virtual void timerEvent(QTimerEvent* arg__1);
virtual bool waitForBytesWritten(int msecs = 30000);
virtual bool waitForConnected(int msecs = 30000);
virtual bool waitForDisconnected(int msecs = 30000);
virtual bool waitForReadyRead(int msecs = 30000);
virtual qint64 writeData(const char* data, qint64 len);
PythonQtInstanceWrapper* _wrapper;
};
class PythonQtPublicPromoter_QSslSocket : public QSslSocket
{ public:
inline bool promoted_atEnd() const { return QSslSocket::atEnd(); }
inline qint64 promoted_bytesAvailable() const { return QSslSocket::bytesAvailable(); }
inline qint64 promoted_bytesToWrite() const { return QSslSocket::bytesToWrite(); }
inline bool promoted_canReadLine() const { return QSslSocket::canReadLine(); }
inline void promoted_close() { QSslSocket::close(); }
inline void promoted_connectToHost(const QString& hostName, unsigned short port, QIODevice::OpenMode openMode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = QAbstractSocket::AnyIPProtocol) { QSslSocket::connectToHost(hostName, port, openMode, protocol); }
inline void promoted_disconnectFromHost() { QSslSocket::disconnectFromHost(); }
inline qint64 promoted_readData(char* data, qint64 maxlen) { return QSslSocket::readData(data, maxlen); }
inline void promoted_resume() { QSslSocket::resume(); }
inline void promoted_setReadBufferSize(qint64 size) { QSslSocket::setReadBufferSize(size); }
inline void promoted_setSocketOption(QAbstractSocket::SocketOption option, const QVariant& value) { QSslSocket::setSocketOption(option, value); }
inline QVariant promoted_socketOption(QAbstractSocket::SocketOption option) { return QSslSocket::socketOption(option); }
inline bool promoted_waitForBytesWritten(int msecs = 30000) { return QSslSocket::waitForBytesWritten(msecs); }
inline bool promoted_waitForConnected(int msecs = 30000) { return QSslSocket::waitForConnected(msecs); }
inline bool promoted_waitForDisconnected(int msecs = 30000) { return QSslSocket::waitForDisconnected(msecs); }
inline bool promoted_waitForReadyRead(int msecs = 30000) { return QSslSocket::waitForReadyRead(msecs); }
inline qint64 promoted_writeData(const char* data, qint64 len) { return QSslSocket::writeData(data, len); }
};
class PythonQtWrapper_QSslSocket : public QObject
{ Q_OBJECT
public:
Q_ENUMS(PeerVerifyMode SslMode )
enum PeerVerifyMode{
VerifyNone = QSslSocket::VerifyNone, QueryPeer = QSslSocket::QueryPeer, VerifyPeer = QSslSocket::VerifyPeer, AutoVerifyPeer = QSslSocket::AutoVerifyPeer};
enum SslMode{
UnencryptedMode = QSslSocket::UnencryptedMode, SslClientMode = QSslSocket::SslClientMode, SslServerMode = QSslSocket::SslServerMode};
public slots:
QSslSocket* new_QSslSocket(QObject* parent = 0);
void delete_QSslSocket(QSslSocket* obj) { delete obj; }
void abort(QSslSocket* theWrappedObject);
void addCaCertificate(QSslSocket* theWrappedObject, const QSslCertificate& certificate);
void addCaCertificates(QSslSocket* theWrappedObject, const QList<QSslCertificate >& certificates);
bool addCaCertificates(QSslSocket* theWrappedObject, const QString& path, QSsl::EncodingFormat format = QSsl::Pem, QRegExp::PatternSyntax syntax = QRegExp::FixedString);
void static_QSslSocket_addDefaultCaCertificate(const QSslCertificate& certificate);
void static_QSslSocket_addDefaultCaCertificates(const QList<QSslCertificate >& certificates);
bool static_QSslSocket_addDefaultCaCertificates(const QString& path, QSsl::EncodingFormat format = QSsl::Pem, QRegExp::PatternSyntax syntax = QRegExp::FixedString);
bool atEnd(QSslSocket* theWrappedObject) const;
qint64 bytesAvailable(QSslSocket* theWrappedObject) const;
qint64 bytesToWrite(QSslSocket* theWrappedObject) const;
QList<QSslCertificate > caCertificates(QSslSocket* theWrappedObject) const;
bool canReadLine(QSslSocket* theWrappedObject) const;
QList<QSslCipher > ciphers(QSslSocket* theWrappedObject) const;
void close(QSslSocket* theWrappedObject);
void connectToHost(QSslSocket* theWrappedObject, const QString& hostName, unsigned short port, QIODevice::OpenMode openMode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = QAbstractSocket::AnyIPProtocol);
void connectToHostEncrypted(QSslSocket* theWrappedObject, const QString& hostName, unsigned short port, QIODevice::OpenMode mode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = QAbstractSocket::AnyIPProtocol);
void connectToHostEncrypted(QSslSocket* theWrappedObject, const QString& hostName, unsigned short port, const QString& sslPeerName, QIODevice::OpenMode mode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = QAbstractSocket::AnyIPProtocol);
QList<QSslCertificate > static_QSslSocket_defaultCaCertificates();
QList<QSslCipher > static_QSslSocket_defaultCiphers();
void disconnectFromHost(QSslSocket* theWrappedObject);
qint64 encryptedBytesAvailable(QSslSocket* theWrappedObject) const;
qint64 encryptedBytesToWrite(QSslSocket* theWrappedObject) const;
bool flush(QSslSocket* theWrappedObject);
void ignoreSslErrors(QSslSocket* theWrappedObject, const QList<QSslError >& errors);
bool isEncrypted(QSslSocket* theWrappedObject) const;
QSslCertificate localCertificate(QSslSocket* theWrappedObject) const;
QList<QSslCertificate > localCertificateChain(QSslSocket* theWrappedObject) const;
QSslSocket::SslMode mode(QSslSocket* theWrappedObject) const;
QSslCertificate peerCertificate(QSslSocket* theWrappedObject) const;
QList<QSslCertificate > peerCertificateChain(QSslSocket* theWrappedObject) const;
int peerVerifyDepth(QSslSocket* theWrappedObject) const;
QSslSocket::PeerVerifyMode peerVerifyMode(QSslSocket* theWrappedObject) const;
QString peerVerifyName(QSslSocket* theWrappedObject) const;
QSslKey privateKey(QSslSocket* theWrappedObject) const;
QSsl::SslProtocol protocol(QSslSocket* theWrappedObject) const;
qint64 readData(QSslSocket* theWrappedObject, char* data, qint64 maxlen);
void resume(QSslSocket* theWrappedObject);
QSslCipher sessionCipher(QSslSocket* theWrappedObject) const;
void setCaCertificates(QSslSocket* theWrappedObject, const QList<QSslCertificate >& certificates);
void setCiphers(QSslSocket* theWrappedObject, const QList<QSslCipher >& ciphers);
void setCiphers(QSslSocket* theWrappedObject, const QString& ciphers);
void static_QSslSocket_setDefaultCaCertificates(const QList<QSslCertificate >& certificates);
void static_QSslSocket_setDefaultCiphers(const QList<QSslCipher >& ciphers);
void setLocalCertificate(QSslSocket* theWrappedObject, const QSslCertificate& certificate);
void setLocalCertificate(QSslSocket* theWrappedObject, const QString& fileName, QSsl::EncodingFormat format = QSsl::Pem);
void setLocalCertificateChain(QSslSocket* theWrappedObject, const QList<QSslCertificate >& localChain);
void setPeerVerifyDepth(QSslSocket* theWrappedObject, int depth);
void setPeerVerifyMode(QSslSocket* theWrappedObject, QSslSocket::PeerVerifyMode mode);
void setPeerVerifyName(QSslSocket* theWrappedObject, const QString& hostName);
void setPrivateKey(QSslSocket* theWrappedObject, const QSslKey& key);
void setPrivateKey(QSslSocket* theWrappedObject, const QString& fileName, QSsl::KeyAlgorithm algorithm = QSsl::Rsa, QSsl::EncodingFormat format = QSsl::Pem, const QByteArray& passPhrase = QByteArray());
void setProtocol(QSslSocket* theWrappedObject, QSsl::SslProtocol protocol);
void setReadBufferSize(QSslSocket* theWrappedObject, qint64 size);
void setSocketOption(QSslSocket* theWrappedObject, QAbstractSocket::SocketOption option, const QVariant& value);
void setSslConfiguration(QSslSocket* theWrappedObject, const QSslConfiguration& config);
QVariant socketOption(QSslSocket* theWrappedObject, QAbstractSocket::SocketOption option);
QSslConfiguration sslConfiguration(QSslSocket* theWrappedObject) const;
QList<QSslError > sslErrors(QSslSocket* theWrappedObject) const;
long static_QSslSocket_sslLibraryVersionNumber();
QString static_QSslSocket_sslLibraryVersionString();
QList<QSslCipher > static_QSslSocket_supportedCiphers();
bool static_QSslSocket_supportsSsl();
QList<QSslCertificate > static_QSslSocket_systemCaCertificates();
bool waitForBytesWritten(QSslSocket* theWrappedObject, int msecs = 30000);
bool waitForConnected(QSslSocket* theWrappedObject, int msecs = 30000);
bool waitForDisconnected(QSslSocket* theWrappedObject, int msecs = 30000);
bool waitForEncrypted(QSslSocket* theWrappedObject, int msecs = 30000);
bool waitForReadyRead(QSslSocket* theWrappedObject, int msecs = 30000);
qint64 writeData(QSslSocket* theWrappedObject, const char* data, qint64 len);
};
#endif
class PythonQtShell_QTcpServer : public QTcpServer
{
public:
PythonQtShell_QTcpServer(QObject* parent = 0):QTcpServer(parent),_wrapper(NULL) {};
~PythonQtShell_QTcpServer();
virtual void childEvent(QChildEvent* arg__1);
virtual void customEvent(QEvent* arg__1);
virtual bool event(QEvent* arg__1);
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
virtual bool hasPendingConnections() const;
virtual QTcpSocket* nextPendingConnection();
virtual void timerEvent(QTimerEvent* arg__1);
PythonQtInstanceWrapper* _wrapper;
};
class PythonQtPublicPromoter_QTcpServer : public QTcpServer
{ public:
inline void promoted_addPendingConnection(QTcpSocket* socket) { QTcpServer::addPendingConnection(socket); }
inline bool promoted_hasPendingConnections() const { return QTcpServer::hasPendingConnections(); }
inline QTcpSocket* promoted_nextPendingConnection() { return QTcpServer::nextPendingConnection(); }
};
class PythonQtWrapper_QTcpServer : public QObject
{ Q_OBJECT
public:
public slots:
QTcpServer* new_QTcpServer(QObject* parent = 0);
void delete_QTcpServer(QTcpServer* obj) { delete obj; }
void addPendingConnection(QTcpServer* theWrappedObject, QTcpSocket* socket);
void close(QTcpServer* theWrappedObject);
QString errorString(QTcpServer* theWrappedObject) const;
bool hasPendingConnections(QTcpServer* theWrappedObject) const;
bool isListening(QTcpServer* theWrappedObject) const;
bool listen(QTcpServer* theWrappedObject, const QHostAddress& address = QHostAddress::Any, unsigned short port = 0);
int maxPendingConnections(QTcpServer* theWrappedObject) const;
QTcpSocket* nextPendingConnection(QTcpServer* theWrappedObject);
void pauseAccepting(QTcpServer* theWrappedObject);
QNetworkProxy proxy(QTcpServer* theWrappedObject) const;
void resumeAccepting(QTcpServer* theWrappedObject);
QHostAddress serverAddress(QTcpServer* theWrappedObject) const;
QAbstractSocket::SocketError serverError(QTcpServer* theWrappedObject) const;
unsigned short serverPort(QTcpServer* theWrappedObject) const;
void setMaxPendingConnections(QTcpServer* theWrappedObject, int numConnections);
void setProxy(QTcpServer* theWrappedObject, const QNetworkProxy& networkProxy);
bool waitForNewConnection(QTcpServer* theWrappedObject, int msec = 0, bool* timedOut = 0);
};
class PythonQtShell_QTcpSocket : public QTcpSocket
{
public:
PythonQtShell_QTcpSocket(QObject* parent = 0):QTcpSocket(parent),_wrapper(NULL) {};
~PythonQtShell_QTcpSocket();
virtual bool atEnd() const;
virtual qint64 bytesAvailable() const;
virtual qint64 bytesToWrite() const;
virtual bool canReadLine() const;
virtual void childEvent(QChildEvent* arg__1);
virtual void close();
virtual void connectToHost(const QHostAddress& address, unsigned short port, QIODevice::OpenMode mode = QIODevice::ReadWrite);
virtual void connectToHost(const QString& hostName, unsigned short port, QIODevice::OpenMode mode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = QAbstractSocket::AnyIPProtocol);
virtual void customEvent(QEvent* arg__1);
virtual void disconnectFromHost();
virtual bool event(QEvent* arg__1);
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
virtual bool isSequential() const;
virtual bool open(QIODevice::OpenMode mode);
virtual qint64 pos() const;
virtual qint64 readData(char* data, qint64 maxlen);
virtual qint64 readLineData(char* data, qint64 maxlen);
virtual bool reset();
virtual void resume();
virtual bool seek(qint64 pos);
virtual void setReadBufferSize(qint64 size);
virtual void setSocketOption(QAbstractSocket::SocketOption option, const QVariant& value);
virtual qint64 size() const;
virtual QVariant socketOption(QAbstractSocket::SocketOption option);
virtual void timerEvent(QTimerEvent* arg__1);
virtual bool waitForBytesWritten(int msecs = 30000);
virtual bool waitForConnected(int msecs = 30000);
virtual bool waitForDisconnected(int msecs = 30000);
virtual bool waitForReadyRead(int msecs = 30000);
virtual qint64 writeData(const char* data, qint64 len);
PythonQtInstanceWrapper* _wrapper;
};
class PythonQtWrapper_QTcpSocket : public QObject
{ Q_OBJECT
public:
public slots:
QTcpSocket* new_QTcpSocket(QObject* parent = 0);
void delete_QTcpSocket(QTcpSocket* obj) { delete obj; }
};
class PythonQtShell_QUdpSocket : public QUdpSocket
{
public:
PythonQtShell_QUdpSocket(QObject* parent = 0):QUdpSocket(parent),_wrapper(NULL) {};
~PythonQtShell_QUdpSocket();
virtual bool atEnd() const;
virtual qint64 bytesAvailable() const;
virtual qint64 bytesToWrite() const;
virtual bool canReadLine() const;
virtual void childEvent(QChildEvent* arg__1);
virtual void close();
virtual void connectToHost(const QHostAddress& address, unsigned short port, QIODevice::OpenMode mode = QIODevice::ReadWrite);
virtual void connectToHost(const QString& hostName, unsigned short port, QIODevice::OpenMode mode = QIODevice::ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = QAbstractSocket::AnyIPProtocol);
virtual void customEvent(QEvent* arg__1);
virtual void disconnectFromHost();
virtual bool event(QEvent* arg__1);
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
virtual bool isSequential() const;
virtual bool open(QIODevice::OpenMode mode);
virtual qint64 pos() const;
virtual qint64 readData(char* data, qint64 maxlen);
virtual qint64 readLineData(char* data, qint64 maxlen);
virtual bool reset();
virtual void resume();
virtual bool seek(qint64 pos);
virtual void setReadBufferSize(qint64 size);
virtual void setSocketOption(QAbstractSocket::SocketOption option, const QVariant& value);
virtual qint64 size() const;
virtual QVariant socketOption(QAbstractSocket::SocketOption option);
virtual void timerEvent(QTimerEvent* arg__1);
virtual bool waitForBytesWritten(int msecs = 30000);
virtual bool waitForConnected(int msecs = 30000);
virtual bool waitForDisconnected(int msecs = 30000);
virtual bool waitForReadyRead(int msecs = 30000);
virtual qint64 writeData(const char* data, qint64 len);
PythonQtInstanceWrapper* _wrapper;
};
class PythonQtWrapper_QUdpSocket : public QObject
{ Q_OBJECT
public:
public slots:
QUdpSocket* new_QUdpSocket(QObject* parent = 0);
void delete_QUdpSocket(QUdpSocket* obj) { delete obj; }
bool hasPendingDatagrams(QUdpSocket* theWrappedObject) const;
bool joinMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress& groupAddress);
bool joinMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress& groupAddress, const QNetworkInterface& iface);
bool leaveMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress& groupAddress);
bool leaveMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress& groupAddress, const QNetworkInterface& iface);
QNetworkInterface multicastInterface(QUdpSocket* theWrappedObject) const;
qint64 pendingDatagramSize(QUdpSocket* theWrappedObject) const;
qint64 readDatagram(QUdpSocket* theWrappedObject, char* data, qint64 maxlen, QHostAddress* host = 0, unsigned short* port = 0);
void setMulticastInterface(QUdpSocket* theWrappedObject, const QNetworkInterface& iface);
qint64 writeDatagram(QUdpSocket* theWrappedObject, const QByteArray& datagram, const QHostAddress& host, unsigned short port);
};