QAbstractSocket

La classe QAbstractSocket fournit les fonctionnalités de base communes à tous les types de sockets. Plus d'informations...

 #include <QAbstractSocket>

Héritage

Hérite de QIODevice.

Héritage

Hérité par QTcpSocket et QUdpSocket.

Note : toutes les fonctions de cette classe sont réentrantes.

Description détaillée

La classe QAbstractSocket fournit les fonctionnalités de base communes à tous les types de sockets.

La classe QAbstractSocket est la base pour les classes QTcpSocket et QUdpSocket et contient toutes les fonctionnalités communes aux deux classes. Si vous avez besoin d'un socket, vous avez deux options :

• instancier QTcpSocket ou QUdpSocket ;
• créer un descripteur de socket natif, instancier QAbstractSocket et appeler la fonction setSocketDescriptor() pour intégrer le socket natif.

TCP (Transmission Control Protocol) est un protocole de transport fiable basé sur des flux et des connexions. UDP (User Datagram Protocol) est un protocole non fiable, basé sur des datagrammes, sans connexion. En pratique, cela signifie que TCP est plus adapté aux transmissions continues de données, alors que le protocole UDP, plus léger, peut être utilisé lorsque la fiabilité n'est pas importante.

Les fonctions de QAbstractSocket unifient la plupart des différences entre les deux protocoles. Par exemple, bien que l'UDP soit sans connexion, la fonction connectToHost() établit une connexion virtuelle pour les sockets UDP, vous permettant d'utiliser QAbstractSocket plus ou moins de la même façon sans vous soucier du protocole sous-jacent. En interne, QAbstractSocket sauvegarde l'adresse et le port passé à la fonction connectToHost() et les fonctions comme read() et write() utilisent ces valeurs.

À tout moment, QAbstractSocket possède un état (retourné par la fonction state()). L'état initial est UnconnectedState. Après l'appel à la fonction connectToHost(), le socket entre d'abord dans l'état HostLookupState. Si l'hôte est trouvé, QAbstractSocket entre dans l'état ConnectingState et envoie le signal hostFound(). Lorsque la connexion est établie, il entre dans l'état ConnectedState et envoie le signal connected(). À tout moment, si une erreur se produit, le signal error() est envoyé. Quel que soit le changement d'état, le signal stateChanged() est émis. Par commodité, la fonction isValid() retourne true si le socket est prêt à lire ou écrire mais notez que l'état du socket doit être ConnectedState avant qu'une opération de lecture ou écriture puisse être effectuée.

Vous pouvez lire ou écrire des données avec les fonctions read() ou write() ou utiliser les fonctions de commodité readLine() et readAll(). QAbstractSocket hérite aussi ses fonctions getChar(), putChar() et ungetChar() de QIODevice, qui travaille octet par octet. Le signal bytesWritten() est envoyé lorsque les données ont été écrites sur le socket (c'est-à-dire lorsque le client a lu les données). Notez que Qt n'a pas de limite de taille de tampon d'écriture. Vous pouvez surveiller sa taille en écoutant ce signal.

Le signal readyRead() est envoyé chaque fois qu'un nouveau paquet de données est arrivé. La fonction bytesAvailable() retourne alors le nombre d'octets disponibles à la lecture. Typiquement, vous allez connecter le signal readyRead() à un slot et y lire les données disponibles. Si vous ne lisez pas toutes les données en une fois, les non-lues resteront disponibles et les nouvelles données entrantes seront ajoutées dans le tampon de lecture interne de QAbstractSocket. Pour limiter la taille du tampon de lecture, appelez la fonction setReadBufferSize().

Pour fermer le socket, appelez la fonction disconnectFromHost(). QAbstractSocket entre dans l'état QAbstractSocket::ClosingState. Après que toutes les données ont été écrites sur le socket, QAbstractSocket ferme le socket, entre dans l'état QAbstractSocket::ClosedState et envoie le signal disconnected(). Si vous souhaitez annuler la connexion immédiatement, en supprimant toutes les données en attente, appelez la fonction abort(). Si l'hôte distant ferme la connexion, QAbstractSocket enverra l'erreur (QAbstractSocket::RemoteHostClosedError), pendant laquelle le socket restera dans l'état ConnectedState puis enverra le signal disconnected().

Le port et l'adresse du correspondant connecté sont donnés par les fonctions peerPort() et peerAddress(). La fonction peerName() retourne le nom de l'hôte, tel qu'il est passé à la fonction connectToHost(). Les fonctions localPort() et localAddress() retournent le port et l'adresse du socket local.

QAbstractSocket fournit un ensemble de fonctions qui bloquent le thread appelant tant que certains signaux ne sont pas envoyés. Ces fonctions peuvent être utilisées pour implémenter des sockets bloquants :

• waitForConnected() bloque tant que la connexion n'est pas établie ;
• waitForReadyRead() bloque tant qu'aucune nouvelle donnée n'est disponible en lecture ;
• waitForBytesWritten() bloque tant qu'aucune donnée n'est écrite sur le socket ;
• waitForDisconnected() bloque tant que la connexion n'est pas fermée.

Voici un exemple :

     int numRead = 0, numReadTotal = 0;
     char buffer[50];
 
     forever {
         numRead  = socket.read(buffer, 50);
 
         // Travailler sur le tableau
 
         numReadTotal += numRead;
         if (numRead == 0 && !socket.waitForReadyRead())
             break;
     }

Si la fonction waitForReadyRead() retourne false, la connexion a été fermée ou une erreur s'est produite.

La programmation avec un socket bloquant est totalement différente de la programmation avec les sockets non bloquants. Un socket bloquant ne nécessite pas de boucle événementielle et habituellement, aboutit à un code plus simple. Par contre, dans une application à interface utilisateur graphique, les sockets bloquants doivent être utilisés seulement dans les threads non liés à l'interface graphique afin d'éviter les blocages de l'interface utilisateur. Voir les exemples network/fortuneclient et network/blockingfortuneclient pour un aperçu des différentes approches.

Note : nous décourageons l'utilisation des fonctions bloquantes avec les signaux. Il faut choisir une seule des deux possibilités.

La classe QAbstractSocket peut être utilisée avec les opérateurs de flux (operator<<() et operator>>()) de QTextStream et QDataStream. Cependant, un point doit être pris en compte : vous devez vous assurer qu'il y a assez de données disponibles avant d'essayer de lire avec operator>>().

Voir aussi QFtp, QNetworkAccessManager et QTcpServer.

Type

enum QAbstractSocket::NetworkLayerProtocol

Cette énumération décrit les valeurs utilisées pour le protocole de la couche réseau dans Qt.

Voir aussi QHostAddress::protocol().

enum QAbstractSocket::SocketError

Cette énumération décrit les erreurs de socket qui peuvent se produire.

Voir aussi QAbstractSocket::error().

enum QAbstractSocket::SocketOption

Cette énumération représente les options pouvant être définies sur le socket. Si nécessaire, elles peuvent être définies après la réception du signal connected() depuis le socket ou après avoir reçu un nouveau socket depuis un QTcpServer.

Cette énumération a été introduite ou modifiée dans Qt 4.6.

Voir aussi QAbstractSocket::setSocketOption() et QAbstractSocket::socketOption().

enum QAbstractSocket::SocketState

Cette énumération décrit les différents états dans lesquels le socket peut être.

Voir aussi QAbstractSocket::state().

enum QAbstractSocket::SocketType

Cette énumération décrit le protocole de la couche de transport.

Voir aussi QAbstractSocket::socketType().

Fonctions membres

QAbstractSocket::QAbstractSocket ( SocketType socketType, QObject * parent )

Créer un nouveau socket abstrait de type socketType. L'argument parent est passé au constructeur de QObject.

Voir aussi socketType(), QTcpSocket et QUdpSocket.

QAbstractSocket::~QAbstractSocket () [virtual]

Détruit le socket.

void QAbstractSocket::abort ()

Annule la connexion courante et réinitialise le socket. Contrairement à la fonction disconnectFromHost(), cette fonction ferme immédiatement le socket, abandonnant toutes les données en attente dans le tampon d'écriture.

Voir aussi disconnectFromHost() et close().

bool QAbstractSocket::atEnd () const [virtual]

Réimplémentation de QIODevice::atEnd().

Retourne true si plus aucune donnée n'est disponible à la lecture ; sinon retourne false.

Cette fonction est le plus souvent utilisée lors de la lecture des données dans une boucle. Par exemple :

  // Ce slot est connecté à QAbstractSocket::readyRead()
  void SocketClass::readyReadSlot()
  {
      while (!socket.atEnd()) {
          QByteArray data = socket.read(100);
          ....
      }
  }

Voir aussi bytesAvailable() et readyRead().

qint64 QAbstractSocket::bytesAvailable () const [virtual]

Réimplémentation de QIODevice::bytesAvailable().

Retourne le nombre d'octets entrants prêts à être lus.

Voir aussi bytesToWrite() et read().

qint64 QAbstractSocket::bytesToWrite () const [virtual]

Réimplémentation de QIODevice::bytesToWrite().

Retourne le nombre d'octets qui sont en attente d'écriture. Les octets sont écrits lorsque la boucle d'événements reprend la main ou lorsque la fonction flush() est appelée.

Voir aussi bytesAvailable() et flush().

bool QAbstractSocket::canReadLine () const [virtual]

Réimplémentation de QIODevice::canReadLine().

Retoure true si une ligne de données peut être lue à partir du socket ; sinon retourne false.

Voir aussi readLine().

void QAbstractSocket::close () [virtual]

Réimplémentation de QIODevice::close().

Ferme le périphérique d'entrée/sortie pour le socket, déconnectant la connexion du socket avec l'hôte, fermant le socket et réinitialisant le nom, adresse, port et le descripteur sous-jacent.

Voir QIODevice::close() pour une description des actions effectuées lorsqu'un périphérique d'entrée/sortie est fermé.

Voir aussi abort().

void QAbstractSocket::connectToHost ( const QString & hostName, quint16 port, OpenMode openMode = ReadWrite )

Essaie de se connecter à hostName avec le port donné.

Le socket est ouvert dans le mode openMode donné et entre dans l'état HostLookupState, puis effectue une recherche du nom d'hôte hostName. Si la recherche aboutit, le signal hostFound() est envoyé et QAbstractSocket entre dans l'état ConnectingState. La classe essaie ensuite de se connecter à l'adresse ou aux adresses retournées par la recherche. Finalement, si la connexion est établie, QAbstractSocket entre dans l'état ConnectedState et envoie le signal connected().

À tout moment, le socket peut envoyer le signal error() pour notifier qu'une erreur s'est produite.

Le nom d'hôte hostName peut être une adresse IP sous la forme d'une chaîne de caractères (par exemple, « 43.195.83.32 ») ou un nom d'hôte (par exemple, « example.com »). QAbstractSocket effectuera une recherche seulement si nécessaire. Le port est dans l'ordre d'octets natif.

Voir aussi state(), peerName(), peerAddress(), peerPort() et waitForConnected().

void QAbstractSocket::connectToHost ( const QHostAddress & address, quint16 port, OpenMode openMode = ReadWrite )

Il s'agit d'une fonction surchargée.

Essaie de créer une connexion sur l'adresse address avec le port donné.

void QAbstractSocket::connectToHostImplementation ( const QString & hostName, quint16 port, OpenMode openMode = ReadWrite ) [protected slot]

Contient l'implémentation de connectToHost().

Essaie de créer une connexion à hostName avec le port port donné. Le socket est ouvert dans le mode openMode donné.

Cette fonction a été introduite dans Qt 4.1.

void QAbstractSocket::connected () [signal]

Ce signal est envoyé après l'appel de la fonction connectToHost() et si une connexion a été établie.

Note : sur certains systèmes d'exploitation le signal connected() peut être directement envoyé à partir de l'appel connectToHost() pour les connexions à l'hôte local.

Voir aussi connectToHost() et disconnected().

void QAbstractSocket::disconnectFromHost ()

Essaie de fermer le socket. Si des données sont en attente d'écriture, le QAbstractSocket entrera dans l'état ClosingState et attendra jusqu'à ce que les données soient toutes écrites. Pour finir, il entrera dans l'état UnconnectedState et enverra le signal disconnected().

Voir aussi connectToHost().

void QAbstractSocket::disconnectFromHostImplementation () [protected slot]

Contient l'implémentation de disconnectFromHost().

Cette fonction a été introduite dans Qt 4.1.

void QAbstractSocket::disconnected () [signal]

Ce signal est envoyé lorsque le socket a été déconnecté.

Attention : si vous avez besoin de détruire le sender() de ce signal dans un slot qui lui est connecté, utilisez la fonction deleteLater().

Voir aussi connectToHost(), disconnectFromHost() et abort().

SocketError QAbstractSocket::error () const

Retourne le type de la dernière erreur rencontrée.

Voir aussi state() et errorString().

void QAbstractSocket::error ( QAbstractSocket::SocketError socketError ) [signal]

Ce signal est envoyé après qu'une erreur s'est produite. Le paramètre socketError décrit le type d'erreur rencontré.

QAbstractSocket::SocketError n'est pas un métatype enregistré, donc pour les connexions avec file d'attente (QueuedConnection), vous aurez besoin de l'enregistrer avec Q_DECLARE_METATYPE() et qRegisterMetaType().

Voir aussi error(), errorString() et Créer des types Qt personnalisés.

bool QAbstractSocket::flush ()

Cette fonction écrit le plus de donnée possibles depuis le tampon d'écriture vers le socket réseau sous-jacent, sans blocage. Si des données ont été écrites, cette fonction retourne true ; sinon elle renvoie false.

Appelez cette fonction si vous voulez que QAbstractSocket démarre immédiatement l'envoi des données présentes dans le tampon. Le nombre d'octets écrits avec succès dépend du système d'exploitation. Dans la plupart des cas, vous n'avez pas besoin d'appeler cette fonction, car QAbstractSocket démarrera automatiquement l'envoi des données dès que l'exécution de la boucle d'événements reprendra. En l'absence de boucle d'événements, appelez la fonction waitForBytesWritten() à la place.

Voir aussi write() et waitForBytesWritten().

void QAbstractSocket::hostFound () [signal]

Ce signal est envoyé après que la fonction connectToHost() a été appelée et que la recherche d'hôte a réussi.

Note : depuis Qt 4.6.3, QAbstractSocket peut envoyer le signal hostFound() directement à partir de la fonction connectToHost() étant donné que le résultat DNS peut avoir été mis en cache.

Voir aussi connected().

bool QAbstractSocket::isSequential () const [virtual]

Réimplémentation de QIODevice::isSequential().

bool QAbstractSocket::isValid () const

Retourne true si le socket est valide et prêt à être utilisé ; sinon retourne false.

Note : l'état du socket doit être ConnectedState avant qu'une opération de lecture ou d'écriture ne puisse être effectuée.

Voir aussi state().

QHostAddress QAbstractSocket::localAddress () const

Retourne l'adresse hôte du socket local si disponible ; sinon retourne QHostAddress::Null.

Il s'agit normalement de l'adresse IP principale de l'hôte mais cela peut être QHostAddress::LocalHost (127.0.0.1) pour les connexions à l'hôte local.

Voir aussi localPort(), peerAddress() et setLocalAddress().

quint16 QAbstractSocket::localPort () const

Retourne le numéro de port hôte (dans l'ordre d'octets natif) du socket local si disponible ; sinon retourne 0.

Voir aussi localAddress(), peerPort() et setLocalPort().

QHostAddress QAbstractSocket::peerAddress () const

Retourne l'adresse du correspondant connecté si le socket est dans l'état ConnectedState ; sinon retourne QHostAddress::Null.

Voir aussi peerName(), peerPort(), localAddress() et setPeerAddress().

QString QAbstractSocket::peerName () const

Retourne le nom du correspondant tel que spécifié à la fonction connectToHost() ou un QString vide si connectToHost() n'a pas été appelé.

Voir aussi peerAddress(), peerPort() et setPeerName().

quint16 QAbstractSocket::peerPort () const

Retourne le port du correspondant connecté si le socket est dans l'état ConnectedState ; sinon retourne 0.

Voir aussi peerAddress(), localPort() et setPeerPort().

QNetworkProxy QAbstractSocket::proxy () const

Retourne le proxy réseau pour ce socket. On utilise QNetworkProxy::DefaultProxy par défaut, ce qui signifie que ce socket récupérera les paramètres de proxy par défaut de l'application.

Cette fonction a été introduite dans Qt 4.1.

Voir aussi setProxy(), QNetworkProxy et QNetworkProxyFactory.

void QAbstractSocket::proxyAuthenticationRequired ( const QNetworkProxy & proxy, QAuthenticator * authenticator ) [signal]

Ce signal peut être envoyé lorsqu'un proxy nécessitant une authentification est utilisé. L'objet authenticator peut être alors être renseigné avec les détails requis pour permettre l'authentification et continuer la connexion.

Note : il n'est pas possible d'utiliser une QueuedConnection pour se connecter à ce signal, étant donné que la connexion peut échouer si l'authentificateur n'a pas été renseigné avec les nouvelles informations lors du retour du signal.

Cette fonction a été introduite dans Qt 4.3.

Voir aussi QAuthenticator et QNetworkProxy.

qint64 QAbstractSocket::readBufferSize () const

Retourne la taille du tampon interne de lecture. Cette limite représente la quantité de données que le client peut recevoir avant un appel aux fonctions read() ou readAll().

Une taille de 0 (par défaut) signifie que le tampon n'a pas de limite de taille, ce qui garantit de ne pas perdre de données.

Voir aussi setReadBufferSize() et read().

qint64 QAbstractSocket::readData ( char * data, qint64 maxSize ) [virtual protected]

Réimplémentation de QIODevice::readData().

qint64 QAbstractSocket::readLineData ( char * data, qint64 maxlen ) [virtual protected]

Réimplémentation de QIODevice::readLineData().

void QAbstractSocket::setLocalAddress ( const QHostAddress & address ) [protected]

Définit l'adresse du côté local de la connexion à address.

Vous pouvez appeler cette fonction dans une sous-classe de QAbstractSocket pour changer la valeur de retour de la fonction localAddress() après qu'une connexion a été établie. Cette fonctionnalité est habituellement utilisée par les connexions proxy pour les paramètres de la connexion virtuelle.

Notez que cette fonction ne lie pas l'adresse locale du socket avant une connexion (par exemple, QUdpSocket::bind()).

Cette fonction a été introduite dans Qt 4.1.

Voir aussi localAddress(), setLocalPort() et setPeerAddress().

void QAbstractSocket::setLocalPort ( quint16 port ) [protected]

Définit le port du côté local de la connexion à port.

Vous pouvez appeler cette fonction dans une sous-classe de QAbstractSocket pour changer la valeur de retour de la fonction localPort() après qu'une connexion a été établie. Cette fonctionnalité est habituellement utilisée par les connexions proxy pour les paramètres de la connexion virtuelle.

Notez que cette fonction ne lie pas le port local du socket avant une connexion (par exemple, QUdpSocket::bind()).

Cette fonction a été introduite dans Qt 4.1.

Voir aussi localPort(), localAddress(), setLocalAddress() et setPeerPort().

void QAbstractSocket::setPeerAddress ( const QHostAddress & address ) [protected]

Définit l'adresse du côté distant de la connexion à address.

Vous pouvez appeler cette fonction dans une sous-classe de QAbstractSocket pour changer la valeur de retour de la fonction peerAddress() après qu'une connexion a été établie. Cette fonctionnalité est habituellement utilisée par les connexions proxy pour les paramètres de la connexion virtuelle.

Cette fonction a été introduite dans Qt 4.1.

Voir aussi peerAddress(), setPeerPort() et setLocalAddress().

void QAbstractSocket::setPeerName ( const QString & name ) [protected]

Définit le nom d'hôte du correspondant distant à name.

Vous pouvez appeler cette fonction dans une sous-classe de QAbstractSocket pour changer la valeur de retour de la fonction peerName() après qu'une connexion a été établie. Cette fonctionnalité est habituellement utilisée par les connexions proxy pour les paramètres de la connexion virtuelle.

Cette fonction a été introduite dans Qt 4.1.

Voir aussi peerName().

void QAbstractSocket::setPeerPort ( quint16 port ) [protected]

Définit le port du côté du correspondant de la connexion à port.

Vous pouvez appeler cette fonction dans une sous-classe de QAbstractSocket pour changer la valeur de retour de la fonction peerPort() après qu'une connexion a été établie. Cette fonctionnalité est habituellement utilisée par les connexions proxy pour les paramètres de la connexion virtuelle.

Cette fonction a été introduite dans Qt 4.1.

Voir aussi peerPort(), setPeerAddress() et setLocalPort().

void QAbstractSocket::setProxy ( const QNetworkProxy & networkProxy )

Définit le proxy réseau explicite pour ce socket à networkProxy.

Pour désactiver l'utilisation d'un proxy pour ce socket, utilisez le type de proxy QNetworkProxy::NoProxy :

 socket->setProxy(QNetworkProxy::NoProxy);

La valeur par défaut pour le proxy est QNetworkProxy::DefaultProxy, ce qui signifie que le socket utilisera les paramètres de l'application : si un proxy est défini avec QNetworkProxy::setApplicationProxy, il l'utilisera ; sinon, si une fabrique est définie avec QNetworkProxyFactory::setApplicationProxyFactory, il appellera la fabrique avec le type QNetworkProxyQuery::TcpSocket.

Cette fonction a été introduite dans Qt 4.1.

Voir aussi proxy(), QNetworkProxy et QNetworkProxyFactory::queryProxy().

void QAbstractSocket::setReadBufferSize ( qint64 size )

Définit la taille du tampon de lecture interne de QAbstractSocket à size octets.

Si la taille du tampon est limitée à une certaine taille, QAbstractSocket ne stockera pas plus de données que cette taille. L'exception est une taille de tampon de 0, qui signifie que le tampon de lecture est illimité et que toutes les données sont stockées dans le tampon. C'est la valeur par défaut.

Cette option est utile si vous voulez lire les données à des moments précis (par exemple, dans une application de streaming en temps réel) ou si vous souhaitez protéger votre socket contre la réception d'une quantité de données trop importante pouvant provoquer le remplissage de la mémoire.

Seul QTcpSocket utilise le tampon interne de QAbstractSocket ; QUdpSocket n'utilise aucune mise en cache mais s'appuie plutôt sur la mise en cache implicite du système d'exploitation. En conséquence, l'appel de cette fonction sur un QUdpSocket n'a aucun effet.

Voir aussi readBufferSize() et read().

bool QAbstractSocket::setSocketDescriptor ( int socketDescriptor, SocketState socketState = ConnectedState, OpenMode openMode = ReadWrite )

Initialise QAbstractSocket avec le descripteur de socket natif socketDescriptor. Retourne true si socketDescriptor est accepté comme descripteur de socket valide ; sinon retourne false. Le socket est ouvert dans le mode spécifié par openMode et entre dans l'état de socket spécifié par socketState.

Note : il n'est pas possible d'initialiser deux sockets abstraits avec le même descripteur de socket natif.

Voir aussi socketDescriptor().

void QAbstractSocket::setSocketError ( SocketError socketError ) [protected]

Définit le type de la dernière erreur produite à socketError.

Voir aussi setSocketState() et setErrorString().

void QAbstractSocket::setSocketOption ( QAbstractSocket::SocketOption option, const QVariant & value )

Définit l‹option donnée à la valeur value.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi socketOption().

void QAbstractSocket::setSocketState ( SocketState state ) [protected]

Définit l'état du socket à state.

Voir aussi state().

int QAbstractSocket::socketDescriptor () const

Retourne le descripteur de socket natif de l'objet QAbstractSocket si disponible ; sinon retourne -1.

Si le socket utilise QNetworkProxy, le descripteur retourné peut ne pas être utilisable avec les fonctions du socket natif.

Le descripteur de socket n'est pas disponible lorsque QAbstractSocket est dans l'état UnconnectedState.

Voir aussi setSocketDescriptor().

QVariant QAbstractSocket::socketOption ( QAbstractSocket::SocketOption option )

Retourne la valeur de l‹option.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setSocketOption().

SocketType QAbstractSocket::socketType () const

Retourne le type de socket (TCP, UDP ou autre).

Voir aussi QTcpSocket et QUdpSocket.

SocketState QAbstractSocket::state () const

Retourne l'état du socket.

Voir aussi error().

void QAbstractSocket::stateChanged ( QAbstractSocket::SocketState socketState ) [signal]

Ce signal est envoyé à chaque changement d'état de QAbstractSocket. Le paramètre socketState est le nouvel état.

QAbstractSocket::SocketError n'est pas un métatype enregistré, donc pour les connexions avec file d'attente (QueuedConnection), vous aurez besoin de l'enregistrer avec Q_DECLARE_METATYPE() et qRegisterMetaType().

Voir aussi state() et Créer des types Qt personnalisés.

bool QAbstractSocket::waitForBytesWritten ( int msecs = 30000 ) [virtual]

Réimplémentation de QIODevice::waitForBytesWritten().

bool QAbstractSocket::waitForConnected ( int msecs = 30000 )

Attend la connexion du socket pendant msecs millisecondes. Si la connexion est établie, cette fonction retourne true ; sinon elle retourne false. Dans le cas où la fonction retourne false, vous pouvez appeler la fonction error() pour connaître la cause de l'erreur.

L'exemple suivant attend une seconde que la connexion soit établie :

 socket->connectToHost("imap", 143);
 if (socket->waitForConnected(1000))
     qDebug("Connected!");

Si msecs est -1, la fonction attendra sans limite de temps.

Note : la fonction peut attendre un peu plus de msecs, selon le temps que prend une recherche d'hôte.

Note : les temps d'attente ne se cumulent pas en cas d'appels multiples à cette fonction. Si le délai d'attente est dépassé, le processus de connexion sera annulé.

Voir aussi connectToHost() et connected().

bool QAbstractSocket::waitForDisconnected ( int msecs = 30000 )

Attend la déconnexion du socket pendant msecs millisecondes. Si la connexion a été déconnectée, cette fonction retourne true ; sinon elle retourne false. Dans le cas où la fonction retourne false, vous pouvez appeler la fonction error() pour connaître la cause de l'erreur.

L'exemple suivant attend une seconde que la connexion soit fermée :

 socket->disconnectFromHost();
     if (socket->state() == QAbstractSocket::UnconnectedState ||
         socket->waitForDisconnected(1000))
         qDebug("Disconnected!");

Si msecs est -1, la fonction attendra sans limite de temps.

Voir aussi disconnectFromHost() et close().

bool QAbstractSocket::waitForReadyRead ( int msecs = 30000 ) [virtual]

Réimplémentation de QIODevice::waitForReadyRead().

Cette fonction attend que des données soient disponibles en lecture et que le signal readyRead() soit envoyé. Le délai d'attente est de msecs millisecondes ; le délai par défaut est de 30 000 millisecondes.

La fonction retourne true si le signal readyRead() est envoyé et que de nouvelles données sont disponibles en lecture ; sinon elle retourne false (si une erreur s'est produite ou que le délai est dépassé).

Voir aussi waitForBytesWritten().

qint64 QAbstractSocket::writeData ( const char * data, qint64 size ) [virtual protected]

Réimplémentation de QIODevice::writeData().

Remerciements

Merci à Alexandre Laurent pour la traduction, ainsi qu'à Ilya Diallo et Claude Leloup pour la relecture !