QLocalSocket

La classe QLocalSocket fournit un socket local. Plus d'informations...

#include <QLocalSocket>

Voir la position dans l'arbre des classes.

Héritage

Hérite de QIODevice.

Cette classe a été introduite dans Qt 4.4.

Description détaillée

La classe QLocalSocket fournit un socket local.

Sur Windows, c'est un tube nommé (named pipe) et sous Unix c'est un socket local au domaine.

Si une erreur se produit, la fonction socketError() retourne le type de l'erreur et errorString() peut être appelée pour récupérer une description en clair de ce qui s'est produit.

Bien que la classe QLocalSocket soit conçue pour être utilisée dans une boucle événementielle, il est possible de l'utiliser sans. Dans ce cas, vous devez utiliser les fonctions waitForConnected(), waitForReadyRead(), waitForBytesWritten() et waitForDisconnected() qui bloquent tant que l'opération n'est pas finie ou que le délai n'est pas dépassé.

Notez que cette fonctionnalité n'est pas gérée par les versions de Windows antérieures à Windows XP.

Voir aussi QLocalServer.

Type

enum QLocalSocket::LocalSocketError

L'énumération LocalServerError représente les erreurs qui peuvent se produire. L'erreur la plus récente peut être récupérée en appelant la fonction QLocalSocket::error().

enum QLocalSocket::LocalSocketState

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

Voir aussi QLocalSocket::state().

Fonctions membres

QLocalSocket::QLocalSocket (QObject * parent = 0)

Crée un nouveau socket local. L'argument parent est passé au constructeur de QObject.

QLocalSocket::~QLocalSocket ()

Détruit le socket, fermant la connexion si nécessaire.

void QLocalSocket::abort ()

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

Voir aussi disconnectFromServer() et close().

qint64 QLocalSocket::bytesAvailable () const [virtual]

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

qint64 QLocalSocket::bytesToWrite () const [virtual]

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

bool QLocalSocket::canReadLine () const [virtual]

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

void QLocalSocket::close () [virtual]

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

void QLocalSocket::connectToServer (const QString & name, OpenMode openMode = ReadWrite)

Essaie de créer une connexion vers name.

Le socket est ouvert dans le mode openMode et passe dans l'état ConnectingState. Il essaie alors de se connecter à l'adresse ou aux adresses retournée(s) par la recherche de correspondance. Finalement, si une connexion est établie, QLocalSocket passe à l'état ConnectedState et envoie le signal connected().

À n'importe quel moment, le socket peut envoyer le signal error() pour prévenir qu'une erreur a eu lieu.

Voir aussi state(), serverName() et waitForConnected().

void QLocalSocket::connected () [signal]

Ce signal est émis après que la fonction connectToServer() a été appelée et que la connexion a été établie.

Voir aussi connectToServer() et disconnected().

void QLocalSocket::disconnectFromServer ()

Essaie de fermer le socket. Si des données sont en attente d'écriture, QLocalSocket entrera dans l'état ClosingState et attendra jusqu'à l'envoi de toutes les données. Éventuellement, il entrera dans l'état UnconnectedState et enverra le signal disconnectedFromServer().

Voir aussi connectToServer().

void QLocalSocket::disconnected () [signal]

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

Voir aussi connectToServer(), disconnectFromServer(), abort() et connected().

LocalSocketError QLocalSocket::error () const

Retourne le type de la dernière erreur s'étant produite.

Voir aussi state() et errorString().

void QLocalSocket::error (QLocalSocket::LocalSocketError socketError) [signal]

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

QLocalSocket::LocalSocketError 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 QLocalSocket::flush ()

Cette fonction écrit le plus de données possible depuis le tampon d'écriture vers le socket. Si des données ont été écrites, cette fonction retourne true ; sinon elle renvoie false.

Appelez cette fonction si vous voulez que QLocalSocket 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 QLocalSocket 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().

QString QLocalSocket::fullServerName () const

Retourne le chemin du serveur auquel ce socket est connecté.

Note : la valeur de retour de cette fonction dépend de la plate-forme.

Voir aussi connectToServer() et serverName().

bool QLocalSocket::isSequential () const [virtual]

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

bool QLocalSocket::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 de pouvoir écrire ou lire.

Voir aussi state() et connectToServer().

qint64 QLocalSocket::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 QLocalSocket::readData (char * data, qint64 c) [virtual protected]

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

QString QLocalSocket::serverName () const

Retourne le nom du correspondant spécifié par la fonction connectToServer() ou un QString vide si connectToServer() n'a pas été appelée ou a échoué.

Voir aussi connectToServer() et fullServerName().

void QLocalSocket::setReadBufferSize (qint64 size)

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

Si la taille du tampon est limitée à une certaine taille, QLocalSocket 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.

Voir aussi readBufferSize() et read().

bool QLocalSocket::setSocketDescriptor ( quintptr socketDescriptor, LocalSocketState socketState = ConnectedState, OpenMode openMode = ReadWrite )

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

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

Voir aussi socketDescriptor(), state() et openMode().

quintptr QLocalSocket::socketDescriptor () const

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

Le descripteur de socket peut ne pas être disponible lorsque QLocalSocket est dans l'état UnconnectedState.

Voir aussi setSocketDescriptor().

LocalSocketState QLocalSocket::state () const

Retourne l'état du socket.

Voir aussi error().

void QLocalSocket::stateChanged (QLocalSocket::LocalSocketState socketState) [signal]

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

QLocalSocket::SocketState 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 QLocalSocket::waitForBytesWritten (int msecs = 30000) [virtual]

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

bool QLocalSocket::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->connectToServer("market");
 if (socket->waitForConnected(1000))
     qDebug("Connected!");

Si msecs est -1, cette fonction ne dépassera pas de délai.

Voir aussi connectToServer() et connected().

bool QLocalSocket::waitForDisconnected (int msecs = 30000)

Attend la déconnexion du socket, pendant msecs millisecondes. Si la connexion a été rompue, 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->disconnectFromServer();
 if (socket->waitForDisconnected(1000))
     qDebug("Disconnected!");

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

Voir aussi disconnectFromServer() et close().

bool QLocalSocket::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 des 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 QLocalSocket::writeData (const char * data, qint64 c) [virtual protected]

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

Remerciements

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