Un exemple client - serveur

Nicolas SOUCHON · 25-04-2012 19:08:37

beaucoup de gens, quand il doivent réaliser une application client - serveur
attaquent directement le problème en se demandant, par exemple:
"je veux envoyer ceci, comment fais-je ?"
... puis:
"je veux envoyer cela, comment fais-je ?"
...

ce qui mène souvent à des solutions dans lesquelles le code est compliqué, difficilement maintenable / évolutif.

tout d'abord, il est souvent utile de disposer de petits de debug simples
exemple: QMap initialisables et à usage de mise au point

dans la suite, le "protocol" désignera le "format des message" pour échange,
par opposition à leur contenu qu'on pourait appeler le "protocole applicatif"

si la première question qu'on se pose est: "de quoi ai-je besoin ?"
la réponse ne doit pas être:
- envoyer mon nom et mon mot de passe --> récupérer et traiter
- envoyer ... --> récupérer et traiter

mais plutôt:
- d'un protocole de transport / échange de données ( n'importe quoi )
- d'un client
- d'un serveur
- d'un point de connection
- de quelques définitions communes ( et variables )

ceci m'amène à définir une structure globale Tcp dans laquelle tout sera imbriqué:
// tcp.h #ifndef __TCP_H__ #define __TCP_H__ #include "map.h" // cf: above struct Tcp // to be changed { typedef quint16 ProtocolVersion; // define exchanged protocol data types typedef quint16 CmdVal; // thus, changing actual types typedef quint16 DataSize; // does not need any correction elsewhere struct Command // force use of Command::XXXX { enum Val { /**/ NO_COMMAND, /**/ HANDSHAKE, /**/ BAD_PROTOCOL, /**/ // add command }; }; struct Error // force use of Error::XXXX { enum Val { /**/ SUCCESS, /**/ BAD_PROTOCOL, }; }; struct Listener; // the socket is the actual server struct Buffer; // manage the protocol input / output struct Socket; // client / server static const ProtocolVersion protocolVersion; // only speak with somebody who have same version static const MapName<int> cmdName; // command names for debug static const MapName<int> errName; // error / status names for debug }; #endif // __TCP_H__
// tcp.cpp #include "tcp.h" #define __CMDNAME_ADD__(n) add( Command::n, #n ) // #n stringify n #define __ERRNAME_ADD__(n) add( Error::n, #n ) // #n stringify n const Tcp::ProtocolVersion Tcp::protocolVersion = 1; const MapName<int> Tcp::cmdName = MapName<int>( "Command" ) .__CMDNAME_ADD__( NO_COMMAND ) .__CMDNAME_ADD__( HANDSHAKE ) .__CMDNAME_ADD__( BAD_PROTOCOL ); // add command const MapName<int> Tcp::errName = MapName<int>( "Error" ) .__ERRNAME_ADD__( SUCCESS ) .__ERRNAME_ADD__( BAD_PROTOCOL ); #undef __CMDNAME_ADD__ #undef __ERRNAME_ADD__
l'idée d'imbriquer les structures / classes est de complexifier la structure pour en simplifier l'usage
je dis bien complexifier et non compliquer dans le même sens qu'un nombre qu'un nombre complexe n'est pas un nombre compliqué !

il nous faut définir le protocole.
pour faire simple, disons:
COMMAND DATA_SIZE DATA
une réponse à une commande pouvant être considérée elle même comme une commande
les classes qui gèreront cela seront:
- Tcp::Buffer
- Tcp::Buffer::Input
- Tcp::Buffer::Output
// tcp_buffer.h #ifndef __TCP_BUFFER_H__ #define __TCP_BUFFER_H__ #include "tcp.h" #include <QtCore/QDataStream> struct Tcp::Buffer : // base class to manage protocol public QDataStream { public: struct Input; struct Output; /**/ Buffer( Socket & s ); // input : direct access to the socket /**/ Buffer( Socket & s, QByteArray & bytes ); // output : work on a buffer virtual ~Buffer() = 0; // make this class abstract protected: Socket & socket; // associated socket }; struct Tcp::Buffer::Input : // input buffer public Buffer { public: /**/ Input( Socket & s ); /**/ ~Input() {} bool msgRead(); // read msg header return true if complete msg ready void clear(); // prepare for next msg CmdVal command; // memorize received commande DataSize dataSize; // memorize received data length }; struct Tcp::Buffer::Output : // output buffer public Buffer { public: /**/ Output( Socket & s ); /**/ ~Output() {} void init(); // prepare for next command void send( CmdVal command ); // send a prepared command QByteArray bytes; // buffer to prepare command }; #endif // __TCP_BUFFER_H__
// tcp_buffer.cpp #include "tcp_buffer.h" #include "tcp_socket.h" #include <QtCore/QDebug> // constructor to use for input buffer : direct access to the socket Tcp::Buffer::Buffer( Socket & s ) : QDataStream( &s ), socket( s ) { } // constructor to use for output buffer : work on a buffer to prepare command Tcp::Buffer::Buffer( Socket & s, QByteArray & bytes ) : QDataStream( &bytes, QIODevice::ReadWrite ), socket( s ) { } Tcp::Buffer::~Buffer() { } Tcp::Buffer::Input::Input( Socket & s ) : Buffer( s ), command( Command::NO_COMMAND ), dataSize( 0 ) { } bool Tcp::Buffer::Input::msgRead() { if( command == Command::NO_COMMAND ) { if( uint( socket.bytesAvailable() ) < sizeof(command) ) return( false ); *this >> command; } if( ! dataSize ) { if( uint( socket.bytesAvailable() ) < sizeof(dataSize) ) return( false ); *this >> dataSize; } if( socket.bytesAvailable() < dataSize ) { return( false ); } return( true ); } void Tcp::Buffer::Input::clear() { command = Command::NO_COMMAND; dataSize = 0; } Tcp::Buffer::Output::Output( Socket & s ) : Buffer( s, bytes ) { init(); } void Tcp::Buffer::Output::init() { device()->seek( 0 ); bytes.clear(); *this << CmdVal( Command::NO_COMMAND ) << DataSize( 0 ); } void Tcp::Buffer::Output::send( CmdVal command ) { device()->seek( 0 ); DataSize dataSize = device()->size() - sizeof(command) - sizeof(dataSize); *this << command << dataSize; socket.write( bytes.data(), bytes.size() ); init(); }
un intérêt d'avoir la classe Buffer abstraite est d'avoir un seul point pour les modifications communes,
par exemple: QDatasStream::setByteOrder, QDatasStream::setVersion ... tout ce qui doit être "symétrique"

les seuls points de gestion de la cohérence emission / réception sont:
coté Tcp::Buffer::Output
- void init()
- void send( CmdVal command )
coté Tcp::Buffer::Input
- bool msgRead()
- CmdVal command;
- DataSize dataSize;

pour ce qui est du "support" Socket 3 classes
- Tcp::Socket fournit la gestion de base
- Tcp::Socket::Client gère emission, réception, exécution coté client
- Tcp::Socket::Server gère emission, réception, exécution coté serveur
// tcp_socket.h #ifndef __TCP_SOCKET_H__ #define __TCP_SOCKET_H__ #include "tcp.h" #include "tcp_buffer.h" #include <QtNetwork/QTcpSocket> struct Tcp::Socket : public QTcpSocket { Q_OBJECT; friend class Buffer; public: struct Server; struct Client; public: /**/ Socket( QObject * p = NULL ); virtual ~Socket(); virtual void execute() = 0; public slots: void on_readyRead(); private: Buffer::Input in; Buffer::Output out; }; struct Tcp::Socket::Server : public Socket { Q_OBJECT; public: /**/ Server( int sd, QObject * p = NULL ); /**/ ~Server(); void execute(); void execHandshake(); /**/ // add command from client void sendHandshake( QString hello ); void sendBadProtocol( ProtocolVersion remote ); /**/ // add command from server }; struct Tcp::Socket::Client : public Socket { Q_OBJECT; public: /**/ Client( QObject * p = NULL ); /**/ ~Client(); void execute(); void execHandshake(); void execBadProtocol(); /**/ // add command from server void sendHandshake( QString hello ); /**/ // add command from client }; #endif // __TCP_SOCKET_H__
// tcp_socket.cpp #include "tcp_socket.h" #include "moc_tcp_socket.cpp" // #include "tcp_thread.h" #include <QtCore/QDebug> #include <QtCore/QThread> #include <QtNetwork/QHostAddress> Tcp::Socket::Socket( QObject * p ) : QTcpSocket( p ), in( *this ), out( *this ) { connect( this, SIGNAL(readyRead()), SLOT(on_readyRead()) ); } Tcp::Socket::~Socket() { } void Tcp::Socket::on_readyRead() { // qDebug() << __PRETTY_FUNCTION__ << Thread::name( QThread::currentThreadId() ); while( true ) { if( ! in.msgRead() ) break; execute(); in.clear(); } } Tcp::Socket::Server::Server( int sd, QObject * p ) : Socket( p ) { setSocketDescriptor( sd ); } Tcp::Socket::Server::~Server() { } void Tcp::Socket::Server::execute() { switch( in.command ) { case Command::HANDSHAKE : execHandshake(); break; // add command from client } } Tcp::Socket::Client::Client( QObject * p ) : Socket( p ) { connectToHost( QHostAddress::LocalHost, 55555 ); if( ! waitForConnected() ) { qDebug() << "client : can't connect"; return; } qDebug() << "client : connected"; sendHandshake( "Hello from client" ); } Tcp::Socket::Client::~Client() { } void Tcp::Socket::Client::execute() { switch( in.command ) { case Command::HANDSHAKE : execHandshake(); break; case Command::BAD_PROTOCOL : execBadProtocol(); break; // add command from server } } void Tcp::Socket::Server::sendHandshake( QString hello ) { out << hello; out.send( Command::HANDSHAKE ); } void Tcp::Socket::Client::execHandshake() { QString hello; in >> hello; qDebug() << "client : <<" << cmdName( in.command ) << hello; } void Tcp::Socket::Client::sendHandshake( QString hello ) { out << hello << protocolVersion; out.send( Command::HANDSHAKE ); // could send user/passord for authentification ... } void Tcp::Socket::Server::execHandshake() { QString hello; ProtocolVersion version; in >> hello >> version; qDebug() << "server : <<" << cmdName( in.command ) << hello << ":" << version; if( version != protocolVersion ) { sendBadProtocol( version ); } else { sendHandshake( "Hello from server" ); } // could receive user/passord for authentification ... } void Tcp::Socket::Server::sendBadProtocol( ProtocolVersion remote ) { out << protocolVersion << remote; out.send( Command::BAD_PROTOCOL ); disconnectFromHost(); } void Tcp::Socket::Client::execBadProtocol() { ProtocolVersion required; ProtocolVersion version; in >> required >> version; qDebug() << "client : <<" << cmdName( in.command ) << "server requires :" << required << "client has:" << version; disconnectFromHost(); }
on peut constater qu'à ce stade, le traitement de chaque commande est simple
de même qu'il est facile d'en ajouter une nouvelle ou de modifier une qui existe

le point d'entrée, qui est vu de l'exterieur comme le server, que j'appèle Listener car "il ne fait qu'écouter" et créer une Socket qui est le serveur effectif
// tcp_listener.h #include "tcp.h" #include "tcp_socket.h" #include <QtNetwork/QTcpServer> struct Tcp::Listener : public QTcpServer { Q_OBJECT; public: /**/ Listener( QObject * p = NULL ); void incomingConnection( int sd ); private slots: void on_disconnected(); private: QList<Socket::Server *> servers; }; #endif // __TCP_LISTENER_H__
// tcp_listener.cpp #include "tcp_listener.h" #include "moc_tcp_listener.cpp" #include <QtCore/QDebug> Tcp::Listener::Listener( QObject * p ) : QTcpServer( p ) { if( ! listen( QHostAddress::LocalHost, 55555 ) ) { qDebug() << __PRETTY_FUNCTION__ << ": can't listen !!!"; return; } qDebug() << "listener : listening"; } void Tcp::Listener::incomingConnection( int sd ) { qDebug() << "listener : connection"; Socket::Server * server = new Socket::Server( sd ); servers << server; connect( server, SIGNAL(disconnected()), SLOT(on_disconnected()) ); } void Tcp::Listener::on_disconnected() { for( int i = 0; i < servers.count(); i++ ) { if( servers[i]->state() == QAbstractSocket::UnconnectedState ) { QTcpSocket * closed = servers.takeAt( i-- ); closed->deleteLater(); qDebug() << closed; } } }
et enfin !!! un petit test minimum
// main.cpp #include "tcp_listener.h" #include <QtGui/QApplication> int main( int ac, char * * av ) { QApplication app( ac, av ); Tcp::Listener listener; Tcp::Socket::Client client; return( app.exec() ); }
l'idée de ce sujet n'est pas de fournir
"un truc tout cuit"
encore moins "un truc unviersel" qui conviendrait à tout le monde
encore moins "un modèle de programmation"

mais plutôt de faire sentir que si la finalité est de transporter des données qui nous intéressent,
on peut avoir avantage à attaquer du coté du moyen de transport de ces données sans se soucier d'elles a priori

ou (sic) (Rouletabille) regarder par le bon bout de la lorgnette

Nicolas SOUCHON · 27-04-2012 12:00:07

si quelqu'un s'es intéressé au sujet (peut-être suis-je présomptueux)

il aura remarqué que le cas des commandes sans données n'est pas envisagé

la correction est facile
// tcp_buffer.cpp Tcp::Buffer::Input::Input( Socket & s ) : Buffer( s ), command( Command::NO_COMMAND ), dataSize( -1 ) // **************** { } bool Tcp::Buffer::Input::msgRead() { if( command == Command::NO_COMMAND ) { if( uint( socket.bytesAvailable() ) < sizeof(command) ) return( false ); *this >> command; } if( dataSize == DS( -1 ) ) // **************** { if( uint( socket.bytesAvailable() ) < sizeof(dataSize) ) return( false ); *this >> dataSize; } if( socket.bytesAvailable() < dataSize ) { return( false ); } return( true ); } void Tcp::Buffer::Input::clear() { command = Command::NO_COMMAND; dataSize = -1; // **************** } void Tcp::Buffer::Output::init() { device()->seek( 0 ); bytes.clear(); *this << CmdVal( Command::NO_COMMAND ) << DataSize( -1 ); // **************** }

dergen · 27-04-2012 13:49:45

IMPRESSIONNANT !

Excellent travail qui vas aider beaucoup de membres wink

Nicolas SOUCHON · 27-04-2012 14:55:21

Rome ne s'est pas faite en un jour !

recopier dans une nouvelle application un "modèle" existant (source + header),
changer les noms de fichier, les macros de protection des headers, les noms de structures
pour rester cohérent devient vite fastidieux et source d'erreur(s)

j'ai donc décidé de faire l'économie de la récuparation transport (struct Tcp::Buffer)

pour cela je l'ai "templatisé" avec pour paramètres:
- CV : type de la valeur de commande
- DS : type de la valeur data size
- S : type de la Socket associée
- NC : valeur indiquant une commande non initialisée

-->
- création de tcptransport.h
- suppression de tcp_buffer.h et tcp_buffer.cpp

// tcptransport.h #ifndef __TCPTRANSPORT_H__ #define __TCPTRANSPORT_H__ //------------------------------------------------------------------------------ __IDENT__( tcp_buffer_h, "@(#) $Id:$" ); #include <QtCore/QDataStream> //------------------------------------------------------------------------------ struct TcpTransport { template<typename CV, typename DS, typename S, int NC> struct Buffer; }; //------------------------------------------------------------------------------ template<typename CV, typename DS, typename S, int NC> struct TcpTransport::Buffer : // base class to manage protocol public QDataStream { public: struct Input; struct Output; /**/ Buffer( S & s ); // input : direct access to the socket /**/ Buffer( S & s, QByteArray & bytes ); // output : work on a buffer virtual ~Buffer() = 0; // make this class abstract protected: S & socket; // associated socket }; //------------------------------------------------------------------------------ template<typename CV, typename DS, typename S, int NC> struct TcpTransport::Buffer<CV,DS,S,NC>::Input : // input buffer public Buffer { public: /**/ Input( S & s ); /**/ ~Input() {} bool msgRead(); // read msg header return true if complete msg ready void clear(); // prepare for next msg CV command; // memorize received commande DS dataSize; // memorize received data length }; //------------------------------------------------------------------------------ template<typename CV, typename DS, typename S, int NC> struct TcpTransport::Buffer<CV,DS,S,NC>::Output : // output buffer public Buffer { public: /**/ Output( S & s ); /**/ ~Output() {} void init(); // prepare for next command void send( CV command ); // send a prepared command QByteArray bytes; // buffer to prepare command }; //------------------------------------------------------------------------------ template<typename CV, typename DS, typename S, int NC> TcpTransport::Buffer<CV,DS,S,NC>::Buffer( S & s ) : QDataStream( &s ), socket( s ) { } //------------------------------------------------------------------------------ template<typename CV, typename DS, typename S, int NC> TcpTransport::Buffer<CV,DS,S,NC>::Buffer( S & s, QByteArray & bytes ) : QDataStream( &bytes, QIODevice::ReadWrite ), socket( s ) { } //------------------------------------------------------------------------------ template<typename CV, typename DS, typename S, int NC> TcpTransport::Buffer<CV,DS,S,NC>::~Buffer() { } //------------------------------------------------------------------------------ template<typename CV, typename DS, typename S, int NC> TcpTransport::Buffer<CV,DS,S,NC>::Input::Input( S & s ) : Buffer( s ), command( NC ), dataSize( -1 ) { } //------------------------------------------------------------------------------ template<typename CV, typename DS, typename S, int NC> bool TcpTransport::Buffer<CV,DS,S,NC>::Input::msgRead() { if( command == NC ) { if( uint( socket.bytesAvailable() ) < sizeof(command) ) return( false ); *this >> command; } if( dataSize == DS( -1 ) ) { if( uint( socket.bytesAvailable() ) < sizeof(dataSize) ) return( false ); *this >> dataSize; } if( socket.bytesAvailable() < dataSize ) { return( false ); } return( true ); } //------------------------------------------------------------------------------ template<typename CV, typename DS, typename S, int NC> void TcpTransport::Buffer<CV,DS,S,NC>::Input::clear() { command = NC; dataSize = -1; } //------------------------------------------------------------------------------ template<typename CV, typename DS, typename S, int NC> TcpTransport::Buffer<CV,DS,S,NC>::Output::Output( S & s ) : Buffer( s, bytes ) { init(); } //------------------------------------------------------------------------------ template<typename CV, typename DS, typename S, int NC> void TcpTransport::Buffer<CV,DS,S,NC>::Output::init() { this->device()->seek( 0 ); bytes.clear(); *this << CV( NC ) << DS( -1 ); } //------------------------------------------------------------------------------ template<typename CV, typename DS, typename S, int NC> void TcpTransport::Buffer<CV,DS,S,NC>::Output::send( CV command ) { this->device()->seek( 0 ); DS dataSize = this->device()->size() - sizeof(command) - sizeof(dataSize); *this << command << dataSize; socket.write( bytes.data(), bytes.size() ); init(); } //------------------------------------------------------------------------------ #endif // __TCPTRANSPORT_H__
les corrections apportées au reste sont minimes:
- tcp.h suppression de la déclaration de Tcp::Buffer (+ une petite réorganisation)
- tcp_socket.h ajout d'un typedef pour acces au nouveau Transport
// tcp.h struct Tcp // to be changed { typedef quint16 Version; // define exchanged data types typedef quint16 CmdVal; // thus, changing actual types typedef quint32 DataSize; // does not need any correction elsewhere struct Listener; // the actual server is the socket struct Socket; // client / server struct Thread; // possibly "detach" treatment from main thread struct Command // force use of Command::XXXX { enum Val { /**/ NO_COMMAND, /**/ HANDSHAKE, /**/ BYE, /**/ BAD_PROTOCOL, /**/ // add command }; }; struct Error // force use of Error::XXXX { enum Val { /**/ SUCCESS, /**/ BAD_PROTOCOL, }; }; static const Version version; // only speak with somebody who have same version static const MapName<int> cmdName; // command names for debug static const MapName<int> errName; // error / status names for debug };
// tcp_socket.h struct Tcp::Socket : public QTcpSocket { Q_OBJECT; public: typedef TcpTransport::Buffer<CmdVal,DataSize,Socket,Command::NO_COMMAND> // **************** added for /**/ Buffer; // use of templated transport struct Server; struct Client; public: /**/ Socket( QObject * p = NULL ); virtual ~Socket(); virtual void execute() = 0; public slots: void on_readyRead(); signals: void finished(); private: Buffer::Input in; Buffer::Output out; };
et correction des directives #include

Nicolas SOUCHON · 27-04-2012 15:57:39

j'en ai profité pour changer le nom de la structure Tcp --> TcpProtocol

sans rapport avec la modif précedente sinon "logique"
TcpTransport gère le protocole de transport
TcpProtocol gère le protocole applicatif

changé aussi les noms de fichier, macros de protection ... pour rester cohérent

travail beaucoup plus long et fastidieux que le précedent !!!

je donne les nouveaux listings en vrac

// tcpprotocol.h #ifndef __TCPPROTOCOL_H__ #define __TCPPROTOCOL_H__ //{{{ includes ----------------------------------------------------------------- __IDENT__( tcpprotocol_h, "@(#) $Id:$" ); #include "map.h" //}}} -------------------------------------------------------------------------- //{{{ structures --------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .TcpProtocol ------------------------------------------------------------- struct TcpProtocol // to be changed { typedef quint16 Version; // define exchanged data types typedef quint16 CmdVal; // thus, changing actual types typedef quint32 DataSize; // does not need any correction elsewhere struct Listener; // the actual server is the socket struct Socket; // client / server struct Thread; // possibly "detach" treatment from main thread struct Command // force use of Command::XXXX { enum Val { /**/ NO_COMMAND, /**/ HANDSHAKE, /**/ BYE, /**/ BAD_PROTOCOL, /**/ // add command }; }; struct Error // force use of Error::XXXX { enum Val { /**/ SUCCESS, /**/ BAD_PROTOCOL, }; }; static const Version version; // only speak with somebody who have same version static const MapName<int> cmdName; // command names for debug static const MapName<int> errName; // error / status names for debug }; //}}} -------------------------------------------------------------------------- #endif // __TCPPROTOCOL_H__
// tcpprotocol.cpp //{{{ includes ----------------------------------------------------------------- __IDENT__( tcpprotocol_cpp, "@(#) $Id:$" ); #include "tcpprotocol.h" #include <QtCore/QDebug> //}}} -------------------------------------------------------------------------- //{{{ static variables --------------------------------------------------------- #define __CMDNAME_ADD__(n) add( Command::n, #n ) // #n stringify n #define __ERRNAME_ADD__(n) add( Error::n, #n ) // #n stringify n const TcpProtocol::Version TcpProtocol::version = 1; const MapName<int> TcpProtocol::cmdName = MapName<int>( "Command" ) .__CMDNAME_ADD__( NO_COMMAND ) .__CMDNAME_ADD__( HANDSHAKE ) .__CMDNAME_ADD__( BYE ) .__CMDNAME_ADD__( BAD_PROTOCOL ); // add command const MapName<int> TcpProtocol::errName = MapName<int>( "Error" ) .__ERRNAME_ADD__( SUCCESS ) .__ERRNAME_ADD__( BAD_PROTOCOL ); #undef __CMDNAME_ADD__ #undef __ERRNAME_ADD__ //}}} --------------------------------------------------------------------------
// tcpprotocol_socket.h #ifndef __TCPPROTOCOL_SOCKET_H__ #define __TCPPROTOCOL_SOCKET_H__ //{{{ includes ----------------------------------------------------------------- __IDENT__( tcpprotocol_socket_h, "@(#) $Id:$" ); #include "tcpprotocol.h" #include "tcptransport.h" #include <QtNetwork/QTcpSocket> //}}} -------------------------------------------------------------------------- //{{{ structures --------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .TcpProtocol ------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ ..Socket ----------------------------------------------------------------- struct TcpProtocol::Socket : public QTcpSocket { Q_OBJECT; public: typedef TcpTransport::Buffer<CmdVal,DataSize,Socket,Command::NO_COMMAND> /**/ Buffer; struct Server; struct Client; public: /**/ Socket( QObject * p = NULL ); virtual ~Socket(); virtual void execute() = 0; public slots: void on_readyRead(); signals: void finished(); private: Buffer::Input in; Buffer::Output out; }; //}}} -------------------------------------------------------------------------- //{{{ ...Server ---------------------------------------------------------------- struct TcpProtocol::Socket::Server : public Socket { Q_OBJECT; public: /**/ Server( int sd, QObject * p = NULL ); /**/ ~Server(); void sendHandshake( QString hello ); void sendBadProtocol( Version remoteVersion ); /**/ // add command from server void execute(); void execHandshake(); void execBye(); /**/ // add command from client }; //}}} -------------------------------------------------------------------------- //{{{ ...Client ---------------------------------------------------------------- struct TcpProtocol::Socket::Client : public Socket { Q_OBJECT; public: /**/ Client( QObject * p = NULL ); /**/ ~Client(); void sendHandshake( QString hello ); void sendBye(); /**/ // add command from client void execute(); void execHandshake(); void execBadProtocol(); /**/ // add command from server }; //}}} -------------------------------------------------------------------------- #endif // __TCPPROTOCOL_SOCKET_H__
// tcpprotocol_socket.cpp //{{{ includes ----------------------------------------------------------------- __IDENT__( tcpprotocol_socket_cpp, "@(#) $Id:$" ); #include "tcpprotocol_socket.h" #include "moc_tcpprotocol_socket.cpp" #include <QtCore/QDebug> #include <QtNetwork/QHostAddress> //}}} -------------------------------------------------------------------------- //{{{ TcpProtocol::Socket ------------------------------------------------------ //}}} -------------------------------------------------------------------------- //{{{ .Socket( QObject * p = NULL ) -------------------------------------------- TcpProtocol::Socket::Socket( QObject * p ) : QTcpSocket( p ), in( *this ), out( *this ) { connect( this, SIGNAL(readyRead()), SLOT(on_readyRead()) ); } //}}} -------------------------------------------------------------------------- //{{{ .~Socket() --------------------------------------------------------------- TcpProtocol::Socket::~Socket() { } //}}} -------------------------------------------------------------------------- //{{{ .void on_readyRead() ----------------------------------------------------- void TcpProtocol::Socket::on_readyRead() { qDebug() << __PRETTY_FUNCTION__; while( in.msgRead() ) { execute(); in.clear(); } } //}}} -------------------------------------------------------------------------- //{{{ TcpProtocol::Socket::Server ---------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .Server( QObject * p = NULL ) -------------------------------------------- TcpProtocol::Socket::Server::Server( int sd, QObject * p ) : Socket( p ) { setSocketDescriptor( sd ); } //}}} -------------------------------------------------------------------------- //{{{ .~Server() --------------------------------------------------------------- TcpProtocol::Socket::Server::~Server() { } //}}} -------------------------------------------------------------------------- //{{{ .void execute() ---------------------------------------------------------- void TcpProtocol::Socket::Server::execute() { switch( in.command ) { case Command::HANDSHAKE : execHandshake(); return; case Command::BYE : execBye(); return; // add command from client } return; } //}}} -------------------------------------------------------------------------- //{{{ TcpProtocol::Socket::Client ---------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .Client( QObject * p = NULL ) -------------------------------------------- TcpProtocol::Socket::Client::Client( QObject * p ) : Socket( p ) { connectToHost( QHostAddress::LocalHost, 55555 ); if( ! waitForConnected() ) { qDebug() << "client : can't connect"; return; } qDebug() << "client : connected"; sendHandshake( "Hello from client" ); } //}}} -------------------------------------------------------------------------- //{{{ .~Client() --------------------------------------------------------------- TcpProtocol::Socket::Client::~Client() { } //}}} -------------------------------------------------------------------------- //{{{ .void execute() ---------------------------------------------------------- void TcpProtocol::Socket::Client::execute() { switch( in.command ) { case Command::HANDSHAKE : execHandshake(); return; case Command::BAD_PROTOCOL : execBadProtocol(); return; // add command from server } return; } //}}} -------------------------------------------------------------------------- //{{{ from here keep pairs of functions ---------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .client : void Client::sendHandshake( QString hello ) -------------------- void TcpProtocol::Socket::Client::sendHandshake( QString hello ) { out << hello << version; out.send( Command::HANDSHAKE ); // could send user/passord for authentification ... } //}}} -------------------------------------------------------------------------- //{{{ ....void Server::execHandshake() ----------------------------------------- void TcpProtocol::Socket::Server::execHandshake() { QString hello; Version remoteVersion; in >> hello >> remoteVersion; qDebug() << "server : <<" << cmdName( in.command ) << hello << ":" << remoteVersion; if( remoteVersion != version ) { sendBadProtocol( remoteVersion ); } else { sendHandshake( "Hello from server" ); } // could receive user/passord for authentification ... } //}}} -------------------------------------------------------------------------- //{{{ .server : void Server::sendHandshake( QString hello ) -------------------- void TcpProtocol::Socket::Server::sendHandshake( QString hello ) { out << hello; out.send( Command::HANDSHAKE ); } //}}} -------------------------------------------------------------------------- //{{{ ....void Client::execHandshake() ----------------------------------------- void TcpProtocol::Socket::Client::execHandshake() { QString hello; in >> hello; qDebug() << "client : <<" << cmdName( in.command ) << hello; out.send( Command::BYE ); } //}}} -------------------------------------------------------------------------- //{{{ .client : void Client::sendBye() ----------------------------------------- void TcpProtocol::Socket::Client::sendBye() { out.send( Command::BYE ); disconnectFromHost(); emit finished(); } //}}} -------------------------------------------------------------------------- //{{{ ....void Server::execBye() ----------------------------------------------- void TcpProtocol::Socket::Server::execBye() { qDebug() << "server : <<" << cmdName( in.command ); disconnectFromHost(); emit finished(); } //}}} -------------------------------------------------------------------------- //{{{ .server : void Server::sendBadProtocol( Version remote ) ----------------- void TcpProtocol::Socket::Server::sendBadProtocol( Version remoteVersion ) { out << version << remoteVersion; out.send( Command::BAD_PROTOCOL ); disconnectFromHost(); } //}}} -------------------------------------------------------------------------- //{{{ ....void Client::execBadProtocol() --------------------------------------- void TcpProtocol::Socket::Client::execBadProtocol() { Version required; Version version; in >> required >> version; qDebug() << "client : <<" << cmdName( in.command ) << "server requires :" << required << "client has:" << version; disconnectFromHost(); } //}}} --------------------------------------------------------------------------
// tcpprotocol_listener.h #ifndef __TCPPROTOCOL_LISTENER_H__ #define __TCPPROTOCOL_LISTENER_H__ //{{{ includes ----------------------------------------------------------------- __IDENT__( tcpprotocol_listener_h, "@(#) $Id:$" ); #include "tcpprotocol_socket.h" #include <QtNetwork/QTcpServer> //}}} -------------------------------------------------------------------------- //{{{ structures --------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .TcpProtocol ------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ ..Listener --------------------------------------------------------------- struct TcpProtocol::Listener : public QTcpServer { Q_OBJECT; public: /**/ Listener( QObject * p = NULL ); void incomingConnection( int sd ); private slots: void on_disconnected(); private: QList<Socket::Server *> servers; }; //}}} -------------------------------------------------------------------------- #endif // __TCPPROTOCOL_LISTENER_H__
// tcpprotocol_listener.cpp //{{{ includes ----------------------------------------------------------------- __IDENT__( tcpprotocol_listener_cpp, "@(#) $Id:$" ); #include "tcpprotocol_listener.h" #include "moc_tcpprotocol_listener.cpp" #include <QtCore/QDebug> //}}} -------------------------------------------------------------------------- //{{{ TcpProtocol::Listener ---------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .Listener( QObject * p = NULL ) ------------------------------------------ TcpProtocol::Listener::Listener( QObject * p ) : QTcpServer( p ) { if( ! listen( QHostAddress::LocalHost, 55555 ) ) { qDebug() << __PRETTY_FUNCTION__ << ": can't listen !!!"; return; } qDebug() << "listener : listening"; } //}}} -------------------------------------------------------------------------- //{{{ .void incomingConnection( int socket ) ----------------------------------- void TcpProtocol::Listener::incomingConnection( int sd ) { qDebug() << "listener : connection"; Socket::Server * server = new Socket::Server( sd ); servers << server; connect( server, SIGNAL(disconnected()), SLOT(on_disconnected()) ); } //}}} -------------------------------------------------------------------------- //{{{ .void on_disconnected() -------------------------------------------------- void TcpProtocol::Listener::on_disconnected() { for( int i = 0; i < servers.count(); i++ ) { if( servers[i]->state() == QAbstractSocket::UnconnectedState ) { QTcpSocket * closed = servers.takeAt( i-- ); closed->deleteLater(); qDebug() << closed; } } } //}}} --------------------------------------------------------------------------

Nicolas SOUCHON · 27-04-2012 16:58:12

pour faire encore l'économie de récupération de tcpprotocol_socket.h et tcpprotocol_socket.cpp,
il me faut rendre les classe Socket dérivables proprement

j'ai besoin que leur méthodes retournent un status, un bool par exemple
pour pouvoir écrire dans une classe fille ClientFille:
bool ClientFille::execute() { if( Client::execute() ) return( true ); swicht( in.command ) { case SOME_COMMAND : execSomeCommand(); return( true ); // ... } return( false ); }
sans avoir à réimplémenter la base

// tcpprotocol_socket.h struct TcpProtocol::Socket : public QTcpSocket { Q_OBJECT; public: typedef TcpTransport::Buffer<CmdVal,DataSize,Socket,Command::NO_COMMAND> /**/ Buffer; struct Server; struct Client; public: /**/ Socket( QObject * p = NULL ); virtual ~Socket(); virtual bool execute() = 0; // **************** public slots: void on_readyRead(); signals: void finished(); private: Buffer::Input in; Buffer::Output out; }; struct TcpProtocol::Socket::Server : public Socket { Q_OBJECT; public: /**/ Server( int sd, QObject * p = NULL ); /**/ ~Server(); void sendHandshake( QString hello ); void sendBadProtocol( Version remoteVersion ); /**/ // add command from server bool execute(); // **************** void execHandshake(); void execBye(); /**/ // add command from client }; struct TcpProtocol::Socket::Client : public Socket { Q_OBJECT; public: /**/ Client( QObject * p = NULL ); /**/ ~Client(); void sendHandshake( QString hello ); void sendBye(); /**/ // add command from client bool execute(); // **************** void execHandshake(); void execBadProtocol(); /**/ // add command from server };
// tcpprotocol_socket.cpp bool TcpProtocol::Socket::Server::execute() // **************** { switch( in.command ) { case Command::HANDSHAKE : execHandshake(); return( true ); // **************** case Command::BYE : execBye(); return( true ); // **************** // add command from client } return( false ); // **************** } bool TcpProtocol::Socket::Client::execute() // **************** { switch( in.command ) { case Command::HANDSHAKE : execHandshake(); return( true ); // **************** case Command::BAD_PROTOCOL : execBadProtocol(); return( true ); // **************** // add command from server } return( false ); // **************** }
encore une fois la modif est simple et localisée

pour bien faire les méthodes execute() devraient purement virtuelles pour forcer la réimplementation
purement virtuelles mais implémentée, c'est tout à fait légitime !!!
mais pour mon exemple, ce n'est pas encore possible

Nicolas SOUCHON · 28-04-2012 10:12:53

on ne va pas toujours droit au but !

le quatrième paramtre du buffer de transport ne me satisfait pas
je le supprime
j'introduit une gestion par état
- attente de la commande
- attente de la taille des données
- attente des données
je "template" TcpTransport plutôt que TcpTransport::Buffer
// tcptransport.h #ifndef __TCPTRANSPORT_H__ #define __TCPTRANSPORT_H__ #include <QtCore/QDataStream> #define __TEMPLATE__ template<typename CV, typename DS, typename S> __TEMPLATE__ struct TcpTransport { struct Buffer; }; __TEMPLATE__ struct TcpTransport<CV,DS,S>::Buffer : // base class to manage protocol public QDataStream { public: struct Input; struct Output; /**/ Buffer( S & s ); // input : direct access to the socket /**/ Buffer( S & s, QByteArray & bytes ); // output : work on a buffer virtual ~Buffer() = 0; // make this class abstract protected: S & socket; // associated socket }; __TEMPLATE__ struct TcpTransport<CV,DS,S>::Buffer::Input : // input buffer public Buffer { public: struct Wait { enum Val { /**/ COMMAND, /**/ DATA_SIZE, /**/ DATA, }; }; /**/ Input( S & s ); /**/ ~Input() {} bool msgRead(); // read msg header return true if complete msg ready void clear(); // prepare for next msg CV command; // memorize received commande DS dataSize; // memorize received data length int state; // input waited }; __TEMPLATE__ struct TcpTransport<CV,DS,S>::Buffer::Output : // output buffer public Buffer { public: /**/ Output( S & s ); /**/ ~Output() {} void init(); // prepare for next command void send( CV command ); // send a prepared command QByteArray bytes; // buffer to prepare command }; // constructor to use for input buffer : direct access to the socket __TEMPLATE__ TcpTransport<CV,DS,S>::Buffer::Buffer( S & s ) : QDataStream( &s ), socket( s ) { } // constructor to use for output buffer : work on a buffer to prepare command __TEMPLATE__ TcpTransport<CV,DS,S>::Buffer::Buffer( S & s, QByteArray & bytes ) : QDataStream( &bytes, QIODevice::ReadWrite ), socket( s ) { } __TEMPLATE__ TcpTransport<CV,DS,S>::Buffer::~Buffer() { } __TEMPLATE__ TcpTransport<CV,DS,S>::Buffer::Input::Input( S & s ) : Buffer( s ), command( 0 ), dataSize( 0 ), state( Wait::COMMAND ) { } __TEMPLATE__ bool TcpTransport<CV,DS,S>::Buffer::Input::msgRead() { switch( state ) { case Wait::COMMAND : if( uint( socket.bytesAvailable() ) < sizeof(command) ) return( false ); *this >> command; state = Wait::DATA_SIZE; // fall in read data size case Wait::DATA_SIZE : if( uint( socket.bytesAvailable() ) < sizeof(dataSize) ) return( false ); *this >> dataSize; state = Wait::DATA; // fall in read data case Wait::DATA : if( socket.bytesAvailable() < dataSize ) return( false ); state = Wait::COMMAND; return( true ); default : Q_ASSERT( false ); // never reached return( true ); } // never reached return( true ); } __TEMPLATE__ void TcpTransport<CV,DS,S>::Buffer::Input::clear() { command = 0; dataSize = 0; } __TEMPLATE__ TcpTransport<CV,DS,S>::Buffer::Output::Output( S & s ) : Buffer( s, bytes ) { init(); } __TEMPLATE__ void TcpTransport<CV,DS,S>::Buffer::Output::init() { this->device()->seek( 0 ); bytes.clear(); *this << CV( 0 ) << DS( 0 ); } __TEMPLATE__ void TcpTransport<CV,DS,S>::Buffer::Output::send( CV command ) { this->device()->seek( 0 ); DS dataSize = this->device()->size() - sizeof(command) - sizeof(dataSize); *this << command << dataSize; socket.write( bytes.data(), bytes.size() ); init(); } #undef __TEMPLATE__ #endif // __TCPTRANSPORT_H__
une correction à apporter dans tcpprotocol_socket.h ... mais c'est évident !

Nicolas SOUCHON · 29-04-2012 12:31:54

roll roll roll certains se sont sans doute demandés:
pourquoi avoir "templaté" la structure TcpTransport, les structures de TcpProtocol n'en utilisent qu'une instance ???

smile smile smile réponse:
pour prévoir la suite

j'avais pensé (quelle présomption !) "templater" de la même façon TcpProtocol, la solution simple

hélas !!!
Q_OBJECT ne supporte pas les classes template, je le savais
mais de plus moc ne supporte pas les classes QObject imbriquées dans une classe template, j'aurais du m'en douter

hiérarchie "imbrication" actuelle des casses de transport:
TcpTransport<CV,DS>
Buffer
Input
Output

hiérarchie "heritage" actuelle des casses de transport:
TcpTransport<CV,DS>
TcpTransport<CV,DS>::Buffer
Input
Output

je décide
- d'utiliser des fonctions de création d'instance des classes buffer utilisées
- de créer des classes interface non "templatées" organisées comme suit

hiérarchie "imbrication" des classes interface:
AbsTcpTransport
Buffer
Input
Output

hiérarchie "heritage" des classes interface:
AbsTcpTransport
AbsTcpTransport::Buffer
Input
Output

>>>> organisation complète:

hiérarchie "imbrication":
AbsTcpTransport
Buffer
Input
Output
TcpTransport<CV,DS>
Buffer
Input
Output

hiérarchie "heritage":
AbsTcpTransport
TcpTransport<CV,DS>
AbsTcpTransport::Buffer
TcpTransport<CV,DS>::Buffer
Input
TcpTransport<CV,DS>::Buffer::Input
Output
TcpTransport<CV,DS>::Buffer:Outnput

les modifications de tcptransport.h sont relativement importantes:
// tcptransport.h #ifndef __TCPTRANSPORT_H__ #define __TCPTRANSPORT_H__ //{{{ includes ----------------------------------------------------------------- __IDENT__( tcp_buffer_h, "@(#) $Id:$" ); #include <QtCore/QDataStream> #include <QtNetwork/QTcpSocket> //}}} -------------------------------------------------------------------------- //{{{ structures --------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .AbsTcpTransport --------------------------------------------------------- struct AbsTcpTransport { typedef quint64 LargestCommandType; typedef quint64 LargestSizeType; struct Buffer; struct CreateBuffers; }; //}}} -------------------------------------------------------------------------- //{{{ ..Buffer ----------------------------------------------------------------- struct AbsTcpTransport::Buffer : // base class to manage protocol public QDataStream { struct Input; struct Output; /**/ Buffer( QTcpSocket & s ); // input : direct access to the socket /**/ Buffer( QTcpSocket & s, QByteArray & bytes ); // output : work on a buffer virtual ~Buffer() = 0; // make this class abstract protected: QTcpSocket & socket; // associated socket }; //}}} -------------------------------------------------------------------------- //{{{ ...Input ----------------------------------------------------------------- struct AbsTcpTransport::Buffer::Input : // input buffer public Buffer { typedef Input * (* FCreate) ( QTcpSocket & s ); /**/ Input( QTcpSocket & s ); /**/ ~Input() {} virtual bool msgRead() = 0; // read msg header return true if complete msg ready virtual void clear() = 0; // prepare for next msg LargestCommandType command; // memorize received commande LargestSizeType dataSize; // memorize received data length }; //}}} -------------------------------------------------------------------------- //{{{ ...Output ---------------------------------------------------------------- struct AbsTcpTransport::Buffer::Output : // output buffer public Buffer { typedef Output * (* FCreate) ( QTcpSocket & s ); /**/ Output( QTcpSocket & s ); /**/ ~Output() {} virtual void init() = 0; // prepare for next command virtual void send( LargestCommandType command ) = 0; // send a prepared command QByteArray bytes; // buffer to prepare command }; //}}} -------------------------------------------------------------------------- //{{{ ...CreateBuffers --------------------------------------------------------- struct AbsTcpTransport::CreateBuffers { Buffer::Input ::FCreate input; Buffer::Output::FCreate output; }; //}}} -------------------------------------------------------------------------- //{{{ .TcpTransport<CV,DS> ----------------------------------------------------- template<typename CV, typename DS> struct TcpTransport : public AbsTcpTransport { struct Buffer; static CreateBuffers create; }; //}}} -------------------------------------------------------------------------- //{{{ ..Buffer ----------------------------------------------------------------- template<typename CV, typename DS> struct TcpTransport<CV,DS>::Buffer { struct Input; struct Output; }; //}}} -------------------------------------------------------------------------- //{{{ ...Input ----------------------------------------------------------------- template<typename CV, typename DS> struct TcpTransport<CV,DS>::Buffer::Input : // input buffer public AbsTcpTransport::Buffer::Input { public: struct Wait { enum Val { /**/ COMMAND, /**/ DATA_SIZE, /**/ DATA, }; }; /**/ Input( QTcpSocket & s ); /**/ ~Input() {} bool msgRead(); // read msg header return true if complete msg ready void clear(); // prepare for next msg static AbsTcpTransport::Buffer::Input * create( QTcpSocket & s ); int state; // input waited }; //}}} -------------------------------------------------------------------------- //{{{ ...Output ---------------------------------------------------------------- template<typename CV, typename DS> struct TcpTransport<CV,DS>::Buffer::Output : // output buffer public AbsTcpTransport::Buffer::Output { public: /**/ Output( QTcpSocket & s ); /**/ ~Output() {} void init(); // prepare for next command void send( LargestCommandType command ); // send a prepared command static AbsTcpTransport::Buffer::Output * create( QTcpSocket & s ); }; //}}} -------------------------------------------------------------------------- //{{{ inlined / template functions --------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .AbsTcpTransPort::Buffer ------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ ..Buffer( QTcpSocket & s ) : --------------------------------------------- inline AbsTcpTransport::Buffer::Buffer( QTcpSocket & s ) : QDataStream( &s ), socket( s ) { } //}}} -------------------------------------------------------------------------- //{{{ ..Buffer( QTcpSocket & s, QByteArray & bytes ) --------------------------- inline AbsTcpTransport::Buffer::Buffer( QTcpSocket & s, QByteArray & bytes ) : QDataStream( &bytes, QIODevice::ReadWrite ), socket( s ) { } //}}} -------------------------------------------------------------------------- //{{{ ..~Buffer() -------------------------------------------------------------- inline AbsTcpTransport::Buffer::~Buffer() { } //}}} -------------------------------------------------------------------------- //{{{ .AbsTcpTransPort::Buffer::Input ------------------------------------------ //}}} -------------------------------------------------------------------------- //{{{ ..Input( QTcpSocket & s ) ------------------------------------------------ inline AbsTcpTransport::Buffer::Input::Input( QTcpSocket & s ) : Buffer( s ), command( 0 ), dataSize( 0 ) { } //}}} -------------------------------------------------------------------------- //{{{ .AbsTcpTransPort::Buffer::Output ----------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ ..Output( QTcpSocket & s ) ----------------------------------------------- inline AbsTcpTransport::Buffer::Output::Output( QTcpSocket & s ) : Buffer( s, bytes ) { } //}}} -------------------------------------------------------------------------- //{{{ .TcpTransPort<CV,DS>::Buffer::Input -------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ ..Input( QTcpSocket & s ) ------------------------------------------------ template<typename CV, typename DS> TcpTransport<CV,DS>::Buffer::Input::Input( QTcpSocket & s ) : AbsTcpTransport::Buffer::Input( s ), state( Wait::COMMAND ) { } //}}} -------------------------------------------------------------------------- //{{{ ..bool msgRead() ---------------------------------------------- template<typename CV, typename DS> bool TcpTransport<CV,DS>::Buffer::Input::msgRead() { CV tempCommand; DS tempDataSize; switch( state ) { case Wait::COMMAND : if( uint( socket.bytesAvailable() ) < sizeof(CV) ) return( false ); *this >> tempCommand; command = tempCommand; state = Wait::DATA_SIZE; // fall in read data size case Wait::DATA_SIZE : if( uint( socket.bytesAvailable() ) < sizeof(DS) ) return( false ); *this >> tempDataSize; dataSize = tempDataSize; state = Wait::DATA; // fall in read data case Wait::DATA : if( uint( socket.bytesAvailable() ) < dataSize ) return( false ); state = Wait::COMMAND; return( true ); default : Q_ASSERT( false ); // never reached return( true ); } // never reached return( true ); } //}}} -------------------------------------------------------------------------- //{{{ ..void clear() ------------------------------------------------ template<typename CV, typename DS> void TcpTransport<CV,DS>::Buffer::Input::clear() { command = 0; dataSize = 0; } //}}} -------------------------------------------------------------------------- //{{{ ..Abs...::Input * create( QTcpSocket & s ) ------------------------------- template<typename CV, typename DS> inline AbsTcpTransport::Buffer::Input * TcpTransport<CV,DS>::Buffer::Input::create( QTcpSocket & s ) { return( new Input( s ) ); } //}}} -------------------------------------------------------------------------- //{{{ .TcpTransPort<CV,DS>::Buffer::Output ------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ ..Output( QTcpSocket & s ) ----------------------------------------------- template<typename CV, typename DS> TcpTransport<CV,DS>::Buffer::Output::Output( QTcpSocket & s ) : AbsTcpTransport::Buffer::Output( s ) { init(); } //}}} -------------------------------------------------------------------------- //{{{ ..void init() ------------------------------------------------ template<typename CV, typename DS> void TcpTransport<CV,DS>::Buffer::Output::init() { this->device()->seek( 0 ); bytes.clear(); *this << CV( 0 ) << DS( 0 ); } //}}} -------------------------------------------------------------------------- //{{{ ..void send( CmdVal command ) -------------------------------- template<typename CV, typename DS> void TcpTransport<CV,DS>::Buffer::Output::send( LargestCommandType command ) { this->device()->seek( 0 ); DS dataSize = this->device()->size() - (sizeof(CV) + sizeof(dataSize)); *this << CV( command ) << dataSize; socket.write( bytes.data(), bytes.size() ); init(); } //}}} -------------------------------------------------------------------------- //{{{ ..Abs...::Output * create( QTcpSocket & s ) ------------------------------ template<typename CV, typename DS> inline AbsTcpTransport::Buffer::Output * TcpTransport<CV,DS>::Buffer::Output::create( QTcpSocket & s ) { return( new Output( s ) ); } //}}} -------------------------------------------------------------------------- //{{{ static variables --------------------------------------------------------- template<typename CV, typename DS> AbsTcpTransport::CreateBuffers TcpTransport<CV,DS>::create = { TcpTransport<CV,DS>::Buffer::Input ::create, TcpTransport<CV,DS>::Buffer::Output::create, }; //}}} -------------------------------------------------------------------------- #endif // __TCPTRANSPORT_H__
tcpprotocol.h se simplifie:
suppression des type concernant les commandes et la taille des données
tcpprotoclo.cpp
reste inchangé
// tcpprotocol.h #ifndef __TCPPROTOCOL_H__ #define __TCPPROTOCOL_H__ //{{{ includes ----------------------------------------------------------------- __IDENT__( tcpprotocol_h, "@(#) $Id:$" ); #include "map.h" //}}} -------------------------------------------------------------------------- //{{{ structures --------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .TcpProtocol ------------------------------------------------------------- struct TcpProtocol // to be changed { typedef quint16 Version; // define exchanged data types struct Listener; // the actual server is the socket struct Socket; // client / server struct Command // force use of Command::XXXX { enum Val { /**/ NO_COMMAND, /**/ HANDSHAKE, /**/ BYE, /**/ BAD_PROTOCOL, /**/ // add command }; }; struct Error // force use of Error::XXXX { enum Val { /**/ SUCCESS, /**/ BAD_PROTOCOL, }; }; static const Version version; // only speak with somebody who have same version static const MapName<int> cmdName; // command names for debug static const MapName<int> errName; // error / status names for debug }; //}}} -------------------------------------------------------------------------- #endif // __TCPPROTOCOL_H__
// tcpprotocol.cpp //{{{ includes ----------------------------------------------------------------- __IDENT__( tcpprotocol_cpp, "@(#) $Id:$" ); #include "tcpprotocol.h" #include <QtCore/QDebug> //}}} -------------------------------------------------------------------------- //{{{ static variables --------------------------------------------------------- #define __CMDNAME_ADD__(n) add( Command::n, #n ) // #n stringify n #define __ERRNAME_ADD__(n) add( Error::n, #n ) // #n stringify n const TcpProtocol::Version TcpProtocol::version = 1; const MapName<int> TcpProtocol::cmdName = MapName<int>( "Command" ) .__CMDNAME_ADD__( NO_COMMAND ) .__CMDNAME_ADD__( HANDSHAKE ) .__CMDNAME_ADD__( BYE ) .__CMDNAME_ADD__( BAD_PROTOCOL ); // add command const MapName<int> TcpProtocol::errName = MapName<int>( "Error" ) .__ERRNAME_ADD__( SUCCESS ) .__ERRNAME_ADD__( BAD_PROTOCOL ); #undef __CMDNAME_ADD__ #undef __ERRNAME_ADD__ //}}} --------------------------------------------------------------------------
toutes petites modifications dans tcpprotocol_socket.h et tcpprotocol_socket.cpp pour passer les fonctions de création des buffers
// tcpprotocol_socket.h #ifndef __TCPPROTOCOL_SOCKET_H__ #define __TCPPROTOCOL_SOCKET_H__ //{{{ includes ----------------------------------------------------------------- __IDENT__( tcpprotocol_socket_h, "@(#) $Id:$" ); #include "tcpprotocol.h" #include "tcptransport.h" #include <QtNetwork/QTcpSocket> //}}} -------------------------------------------------------------------------- //{{{ structures --------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .TcpProtocol ------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ ..Socket ----------------------------------------------------------------- struct TcpProtocol::Socket : public QTcpSocket { Q_OBJECT; public: typedef AbsTcpTransport::Buffer::Input Input; typedef AbsTcpTransport::Buffer::Output Output; typedef AbsTcpTransport::CreateBuffers CreateBuffers; struct Server; struct Client; public: /**/ Socket( CreateBuffers cb, QObject * p = NULL ); virtual ~Socket(); virtual bool execute() = 0; public slots: void on_readyRead(); signals: void finished(); private: Input * in; Output * out; }; //}}} -------------------------------------------------------------------------- //{{{ ...Server ---------------------------------------------------------------- struct TcpProtocol::Socket::Server : public Socket { Q_OBJECT; public: /**/ Server( CreateBuffers cb, int sd, QObject * p = NULL ); /**/ ~Server(); void sendHandshake( QString hello ); void sendBadProtocol( Version remoteVersion ); /**/ // add command from server bool execute(); void execHandshake(); void execBye(); /**/ // add command from client }; //}}} -------------------------------------------------------------------------- //{{{ ...Client ---------------------------------------------------------------- struct TcpProtocol::Socket::Client : public Socket { Q_OBJECT; public: /**/ Client( CreateBuffers cb, int port, QObject * p = NULL ); /**/ ~Client(); void sendHandshake( QString hello ); void sendBye(); /**/ // add command from client bool execute(); void execHandshake(); void execBadProtocol(); /**/ // add command from server }; //}}} -------------------------------------------------------------------------- #endif // __TCPPROTOCOL_SOCKET_H__
// tcpprotocol_socket.cpp //{{{ includes ----------------------------------------------------------------- __IDENT__( tcpprotocol_socket_cpp, "@(#) $Id:$" ); #include "tcpprotocol_socket.h" #include "moc_tcpprotocol_socket.cpp" #include <QtCore/QDebug> #include <QtNetwork/QHostAddress> //}}} -------------------------------------------------------------------------- //{{{ TcpProtocol::Socket ------------------------------------------------------ //}}} -------------------------------------------------------------------------- //{{{ .Socket( QObject * p = NULL ) -------------------------------------------- TcpProtocol::Socket::Socket( CreateBuffers cb, QObject * p ) : QTcpSocket( p ), in( cb.input( *this ) ), out( cb.output( *this ) ) { connect( this, SIGNAL(readyRead()), SLOT(on_readyRead()) ); } //}}} -------------------------------------------------------------------------- //{{{ .~Socket() --------------------------------------------------------------- TcpProtocol::Socket::~Socket() { delete in; delete out; } //}}} -------------------------------------------------------------------------- //{{{ .void on_readyRead() ----------------------------------------------------- void TcpProtocol::Socket::on_readyRead() { while( in->msgRead() ) { execute(); in->clear(); } } //}}} -------------------------------------------------------------------------- //{{{ TcpProtocol::Socket::Server ---------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .Server( QObject * p = NULL ) -------------------------------------------- TcpProtocol::Socket::Server::Server( CreateBuffers cb, int sd, QObject * p ) : Socket( cb, p ) { setSocketDescriptor( sd ); } //}}} -------------------------------------------------------------------------- //{{{ .~Server() --------------------------------------------------------------- TcpProtocol::Socket::Server::~Server() { } //}}} -------------------------------------------------------------------------- //{{{ .bool execute() ---------------------------------------------------------- bool TcpProtocol::Socket::Server::execute() { switch( in->command ) { case Command::HANDSHAKE : execHandshake(); return( true ); case Command::BYE : execBye(); return( true ); // add command from client } return( false ); } //}}} -------------------------------------------------------------------------- //{{{ TcpProtocol::Socket::Client ---------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .Client( QObject * p = NULL ) -------------------------------------------- TcpProtocol::Socket::Client::Client( CreateBuffers cb, int port, QObject * p ) : Socket( cb, p ) { connectToHost( QHostAddress::LocalHost, port ); if( ! waitForConnected() ) { qDebug() << "client : can't connect"; return; } qDebug() << "client : connected"; sendHandshake( "Hello from client" ); } //}}} -------------------------------------------------------------------------- //{{{ .~Client() --------------------------------------------------------------- TcpProtocol::Socket::Client::~Client() { } //}}} -------------------------------------------------------------------------- //{{{ .bool execute() ---------------------------------------------------------- bool TcpProtocol::Socket::Client::execute() { switch( in->command ) { case Command::HANDSHAKE : execHandshake(); return( true ); case Command::BAD_PROTOCOL : execBadProtocol(); return( true ); // add command from server } return( false ); } //}}} -------------------------------------------------------------------------- //{{{ from here keep pairs of functions ---------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .client : void Client::sendHandshake( QString hello ) -------------------- void TcpProtocol::Socket::Client::sendHandshake( QString hello ) { *out << hello << version; out->send( Command::HANDSHAKE ); } //}}} -------------------------------------------------------------------------- //{{{ ....void Server::execHandshake() ----------------------------------------- void TcpProtocol::Socket::Server::execHandshake() { QString hello; Version remoteVersion; *in >> hello >> remoteVersion; qDebug() << "server : <<" << cmdName( in->command ) << hello << ":" << remoteVersion; if( remoteVersion != version ) { sendBadProtocol( remoteVersion ); } else { sendHandshake( "Hello from server" ); } } //}}} -------------------------------------------------------------------------- //{{{ .server : void Server::sendHandshake( QString hello ) -------------------- void TcpProtocol::Socket::Server::sendHandshake( QString hello ) { *out << hello; out->send( Command::HANDSHAKE ); } //}}} -------------------------------------------------------------------------- //{{{ ....void Client::execHandshake() ----------------------------------------- void TcpProtocol::Socket::Client::execHandshake() { QString hello; *in >> hello; qDebug() << "client : <<" << cmdName( in->command ) << hello; out->send( Command::BYE ); } //}}} -------------------------------------------------------------------------- //{{{ .client : void Client::sendBye() ----------------------------------------- void TcpProtocol::Socket::Client::sendBye() { out->send( Command::BYE ); disconnectFromHost(); emit finished(); } //}}} -------------------------------------------------------------------------- //{{{ ....void Server::execBye() ----------------------------------------------- void TcpProtocol::Socket::Server::execBye() { qDebug() << "server : <<" << cmdName( in->command ); disconnectFromHost(); emit finished(); } //}}} -------------------------------------------------------------------------- //{{{ .server : void Server::sendBadProtocol( Version remote ) ----------------- void TcpProtocol::Socket::Server::sendBadProtocol( Version remoteVersion ) { *out << version << remoteVersion; out->send( Command::BAD_PROTOCOL ); disconnectFromHost(); } //}}} -------------------------------------------------------------------------- //{{{ ....void Client::execBadProtocol() --------------------------------------- void TcpProtocol::Socket::Client::execBadProtocol() { Version required; Version version; *in >> required >> version; qDebug() << "client : <<" << cmdName( in->command ) << "server requires :" << required << "client has:" << version; disconnectFromHost(); } //}}} --------------------------------------------------------------------------
toutes petites modifications dans tcpprotocol_listener.h et tcpprotocol_listener.cpp pour passer les fonctions de création des buffers
// tcpprotocol_listener.h #ifndef __TCPPROTOCOL_LISTENER_H__ #define __TCPPROTOCOL_LISTENER_H__ //{{{ includes ----------------------------------------------------------------- __IDENT__( tcpprotocol_listener_h, "@(#) $Id:$" ); #include "tcpprotocol_socket.h" #include <QtNetwork/QTcpServer> //}}} -------------------------------------------------------------------------- //{{{ structures --------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .TcpProtocol ------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ ..Listener --------------------------------------------------------------- struct TcpProtocol::Listener : public QTcpServer { Q_OBJECT; public: typedef AbsTcpTransport::Buffer::Input Input; typedef AbsTcpTransport::Buffer::Output Output; typedef AbsTcpTransport::CreateBuffers CreateBuffers; /**/ Listener( CreateBuffers cb, int port, QObject * p = NULL ); void incomingConnection( int sd ); private slots: void on_disconnected(); private: QList<Socket::Server *> servers; CreateBuffers createBuffers; }; //}}} -------------------------------------------------------------------------- #endif // __TCPPROTOCOL_LISTENER_H__
// tcpprotocol_listener.cpp //{{{ includes ----------------------------------------------------------------- __IDENT__( tcpprotocol_listener_cpp, "@(#) $Id:$" ); #include "tcpprotocol_listener.h" #include "moc_tcpprotocol_listener.cpp" #include <QtCore/QDebug> //}}} -------------------------------------------------------------------------- //{{{ TcpProtocol::Listener ---------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .Listener( QObject * p = NULL ) ------------------------------------------ TcpProtocol::Listener::Listener( CreateBuffers cb, int port, QObject * p ) : QTcpServer( p ), createBuffers( cb ) { if( ! listen( QHostAddress::LocalHost, port ) ) { qDebug() << __PRETTY_FUNCTION__ << ": can't listen !!!"; return; } qDebug() << "listener : listening"; } //}}} -------------------------------------------------------------------------- //{{{ .void incomingConnection( int socket ) ----------------------------------- void TcpProtocol::Listener::incomingConnection( int sd ) { qDebug() << "listener : connection"; Socket::Server * server = new Socket::Server( createBuffers, sd ); servers << server; connect( server, SIGNAL(disconnected()), SLOT(on_disconnected()) ); } //}}} -------------------------------------------------------------------------- //{{{ .void on_disconnected() -------------------------------------------------- void TcpProtocol::Listener::on_disconnected() { for( int i = 0; i < servers.count(); i++ ) { if( servers[i]->state() == QAbstractSocket::UnconnectedState ) { QTcpSocket * closed = servers.takeAt( i-- ); closed->deleteLater(); qDebug() << closed; } } } //}}} --------------------------------------------------------------------------
smile smile smile et enfin le programme de test
// main-server.cpp //{{{ includes ----------------------------------------------------------------- __IDENT__( main_cpp, "@(#) $Id:$" ); #include "tcpprotocol_listener.h" #include <QtGui/QApplication> //}}} -------------------------------------------------------------------------- //{{{ int main( int ac, char * * av ) ------------------------------------------ int main( int ac, char * * av ) { typedef TcpTransport<quint8,quint32> Transport_8_32; typedef TcpTransport<quint32,quint32> Transport_32_32; QApplication app( ac, av ); TcpProtocol::Listener listener_8_32( Transport_8_32::create, 55555 ); TcpProtocol::Listener listener_32_32( Transport_32_32::create, 55556 ); TcpProtocol::Socket::Client client_8_32( Transport_8_32::create, 55555 ); TcpProtocol::Socket::Client client_32_32( Transport_32_32::create, 55556 ); return( app.exec() ); } //}}} --------------------------------------------------------------------------

Nicolas SOUCHON · 29-04-2012 12:46:36

roll roll roll
comment se protéger de l'emploi de deux protocoles de transport incompatibles

(sic)
Pour fabriquer une bombe "A", mes enfants, croyez moi, c'est vraiment de la tarte!
La question du détonateur s'résout en un quart d'heure, c'est de cell' qu'on écarte!

d'accord sur tout, sauf de l'écarter !!!

je vous laisse réfléchir !!!

myrddin772 · 29-04-2012 13:15:47

[curieux=on][mémoire=off]
hmm
Je connais cette citation sur la bombe A... mais plus moyen de situer...
hmm hmm
[memoire=on] wink

Nicolas SOUCHON · 29-04-2012 13:43:58

Boris Vian : La java des bombes atomiques

Mon oncle, infâme bricoleur, fasait en amateur des bombes atomiques.
...

myrddin772 · 29-04-2012 13:49:08

[content=on]
Merci à toi et ta grande culture ! \o/
[content=pas tout à fait off][curieux=off]

Dernière modification par myrddin772 (29-04-2012 13:49:50)

Nicolas SOUCHON · 29-04-2012 13:56:50

myrddin772 a écrit :

[content=pas tout à fait off]

pourquoi ???

myrddin772 a écrit :

Merci à toi et ta grande culture ! \o/

n'éxagérons rien, but, as my sister says, "il y a une chanson pour chaque occasion"
inutile de dire qu'elle chante mieux que moi.

Nicolas SOUCHON · 01-05-2012 23:28:03

Nicolas SOUCHON a écrit :

Zanor84 a écrit :

Pour ton serveur, utilise tu les thread ?
Sinon un thread règle le problème, voila,

vachement péremptoire !!! sans avoir vu une ligne de code intéressante
d'une façon générale, les classe de QtNetwork sont asynchrones et ne nécessitent pas de thread

si certains ont essayé l'exemple précédent, ils ont pu constater que tout fonctionnait très bien sans thread

j'aurais pu ajouter: les threads sont "une vaste source d'emmerdements !!!" ... surtout avec les QTcpSocket

explications:
la création d'une QTcpSocket provoque la création d'un/plusieurs QSocketNotifier
ce/ces QSocketNotifier doit/doivent "être" dans le même thread que la QTcpSocket
impossible donc d'utiliser moveToThread avec une QTcpSocket

impossible, par exemple, d'écrire sur la socket sous-jascente à la QTcpSocket depuis un autre thread
--> communication par signal/slot impérative pour demander à la QTcpSocket d'écrire,
pas moyen d'appeler directement ses méthodes

résultat:
sad sad sad

smile smile smile mais restons zen:
tout problème à une solution !!!

j'ai modifié les structures protocole de transport
- pour résoudre ce problème de façon simple
AbsTcpTransport::Buffer::Output dispose d'un mutex et de methode lock/unlock
l'émission des données se fait par signal/slot
- pour prévoir des évolutions éventuelles, eg: ajout d'une checksum ...
les deux buffer travaillent sur un QByteArray interne qui remonte
de AbsTcpTransport::Buffer::Output dans AbsTcpTransport::Buffer
- j'ai déplacé la structure des fonction de creation des buffers dans AbsTcpTransport::Buffer
juste pour la logique (perso)

nouvelle structure globale #define __TCPTRANSPORT_H__ +--- 10 : includes +--- 2 : structures +--- 11 : AbsTcpTransport +--- 23 : Buffer +--- 21 : Input +--- 30 : Output +--- 9 : Create +--- 11 : TcpTransport<CV,DS> +--- 9 : Buffer +--- 29 : Input +--- 18 : Output +--- 2 : inlined / template functions +--- 2 : AbsTcpTransPort +--- 2 : Buffer +--- 9 : +--- 7 : ~Buffer() +--- 2 : Buffer::Input +--- 11 : +--- 7 : ~Input() +--- 2 : Buffer::Output +--- 8 : +--- 6 : ~Output() +--- 8 : +--- 8 : void lock() +--- 8 : void unlock() +--- 2 : TcpTransPort<CV,DS> +--- 2 : Buffer::Input +--- 9 : +--- 36 : bool +--- 9 : void +--- 8 : +--- 2 : Buffer::Output +--- 9 : +--- 10 : void +--- 15 : void +--- 8 : +--- 9 : static variables #endif // __TCPTRANSPORT_H__ ci-dessous, sources ici chat.gz
#ifndef __TCPTRANSPORT_H__ - - - - - - - - - - - - - - Buffer( QTcpSocket & s, QByteArray & bytes ) - - - Input( QTcpSocket & s ) - - - Output( QTcpSocket & s ) - - void on_sendData( QByteArray bytes ) - - - - - Input( QTcpSocket & s ) - msgRead() - clear() - Abs...::Input * create( QTcpSocket & s ) - - Output( QTcpSocket & s ) - init() - send( CmdVal command ) - Abs...::Output * create( QTcpSocket & s ) - -</p> </div> </div> </div> </div> <div class="inbox"> <div class="postfoot clearb"> <div class="postfootleft"><p><span>Hors ligne</span></p></div> </div> </div> </div> </div> <div id="p84966" class="blockpost rowodd"> <h2><span><span class="conr">#15</span> <a href="viewtopic.php?pid=84966#p84966">02-05-2012 00:01:54</a></span></h2> <div class="box"> <div class="inbox"> <div class="postbody"> <div class="postleft"> <dl> <dt><strong>myrddin772</strong></dt> <dd class="usertitle"><strong>Modérateur Qt</strong></dd> <dd><span>Inscription : 13-03-2010</span></dd> <dd><span>Messages : 682</span></dd> </dl> </div> <div class="postright"> <h3>Re : Un exemple client - serveur</h3> <div class="postmsg"> <div class="quotebox"><cite>Nicolas SOUCHON a écrit :</cite><blockquote><div><div class="quotebox"><cite>myrddin772 a écrit :</cite><blockquote><div><p>[content=pas tout à fait off]</p></div></blockquote></div><p>pourquoi ???</p></div></blockquote></div><p>Parce que les quelques chansons de Vian que je connaisse me font (sou)rire alors, tant que je l'avais en tête, j'etais encore un peu content <img src="http://www.qtfr.org/plugins/ezbbc/style/smilies/wink.png" alt="wink" /></p> </div> <div class="postsignature postmsg"><hr /><p>"L'informatique n'est pas plus la science des ordinateurs que l'astronomie n'est celle des télescopes." Michael R. Fellows et Ian Parberry<br /><strong><em>Si tu ne sais pas : demande, si tu sais : partage !</em></strong></p></div> </div> </div> </div> <div class="inbox"> <div class="postfoot clearb"> <div class="postfootleft"><p><span>Hors ligne</span></p></div> </div> </div> </div> </div> <div id="p85005" class="blockpost roweven"> <h2><span><span class="conr">#16</span> <a href="viewtopic.php?pid=85005#p85005">02-05-2012 18:11:57</a></span></h2> <div class="box"> <div class="inbox"> <div class="postbody"> <div class="postleft"> <dl> <dt><strong>Nicolas SOUCHON</strong></dt> <dd class="usertitle"><strong>Administrateur Qt</strong></dd> <dd><span>Inscription : 28-07-2007</span></dd> <dd><span>Messages : 3 154</span></dd> </dl> </div> <div class="postright"> <h3>Re : Un exemple client - serveur</h3> <div class="postmsg"> <p>il faut bien par une application: un petit chat par exemple</p><p>les structures s'inspireront de TcpProtocol::Listener précédentes, mais n'en hériteront pas, elles ne servaient qu'à la mise au point du principe</p><p>organisation des structures:</p><p> Chat // definitions communes<br /> Listener // écoute (listen) et accepte les connection entrantes, crée threads et serveurs<br /> Server // le serveur effectif <br /> List // liste vérouillable de serveurs <br /> Client // ça va de soi <br /> Thread // ça va de soi <br /> Widget // prévu pour un avenir "plus ou moins lointain" </p><p><img src="http://www.qtfr.org/plugins/ezbbc/style/smilies/roll.png" alt="roll" /> <img src="http://www.qtfr.org/plugins/ezbbc/style/smilies/roll.png" alt="roll" /> <img src="http://www.qtfr.org/plugins/ezbbc/style/smilies/roll.png" alt="roll" /> questions:<br /> c'est quoi ce Chat::Widget prévu pour un avenir "plus ou moins lointain" ?</p><p>il est vrai que: qui dit chat dit fenêtre à partir de laquelle on peut envoyer et recevoir des messages, mais ...</p><p>le principe que jai suivi jusqu'ici est "grosso modo":<br /> pourquoi se soucier d'afficher les données échangées avant d'avoir le moyen de les échanger ?<br /> pourquoi se soucier d'échanger des données avant d'avoir le moyen de controler leur transport ?<br /> pourquoi se soucier d'envoyer des données sur un réseau avant d'avoir un réseau ? <br /> <img src="http://www.qtfr.org/plugins/ezbbc/style/smilies/smile.png" alt="smile" /> <img src="http://www.qtfr.org/plugins/ezbbc/style/smilies/smile.png" alt="smile" /> <img src="http://www.qtfr.org/plugins/ezbbc/style/smilies/smile.png" alt="smile" /> heureusement, TCP existe déjà ! <br /> en bref, pourquoi mettre la charrue avant les boeufs ?</p><p>je développe donc, sur la base des classes de TcpProtocol, la partie réseau de mon chat, avec implémentation des threads<br />je valide le bon fonctionnement ( threads, mutex ...) à coup de qDebug() << ...<br />c'est souvent beaucoup plus simple que l'utilisation d'un debugger</p><p>sources <a href="http://www.qtfr.org/img/members/2024/chat1.gz" rel="nofollow">chat1.gz</a><br />répartition dans les fichiers<br /><textarea name="CppCode" class="cpp">#ifndef __CHAT_H__ #define __CHAT_H__ +--- 10 : includes +--- 2 : structures +--- 29 : Chat #endif // __CHAT_H__ #

#ifndef __CHAT_LISTENER_H__ #define __CHAT_LISTENER_H__ +--- 10 : includes +--- 2 : structures +--- 2 : Chat +--- 29 : Listener +--- 2 : inline / template +--- 8 : const Server::List serverList() #endif // __CHAT_LISTENER_H__ #

// keep client and server in the same files because of paralel treatment #ifndef __CHAT_SOCKET_H__ #define __CHAT_SOCKET_H__ +--- 8 : includes +--- 2 : structures +--- 2 : Chat +--- 34 : Server +--- 11 : List +--- 28 : Client +--- 2 : inline / template +--- 2 : Chat::Server::List +--- 8 : List() #endif // __CHAT_SOCKET_H__ #

#ifndef __CHAT_THREAD_H__ #define __CHAT_THREAD_H__ +--- 15 : includes +--- 2 : structures +--- 2 : Chat +--- 22 : Thread #endif // __CHAT_THREAD_H__ #
PS: j'allais oublier le petit programme de test
//{{{ includes ----------------------------------------------------------------- __IDENT__( main_cpp, "@(#) $Id:$" ); #include "chat_listener.h" #include "thread.h" #include <QtCore/QTimer> #include <QtGui/QApplication> //}}} -------------------------------------------------------------------------- //{{{ int main( int ac, char * * av ) ------------------------------------------ int main( int ac, char * * av ) { Thread::regMain(); QApplication app( ac, av ); Chat::Listener listener( 55555 ); Chat::Client c0( "client_0", 55555 ); Chat::Client c1( "client_1", 55555 ); Chat::Client c2( "client_2", 55555 ); Chat::Client c3( "client_3", 55555 ); Chat::Client c4( "client_4", 55555 ); Chat::Client c5( "client_5", 55555 ); Chat::Client c6( "client_6", 55555 ); Chat::Client c7( "client_7", 55555 ); Chat::Client c8( "client_8", 55555 ); Chat::Client c9( "client_9", 55555 ); QTimer::singleShot( 5000, &app, SLOT(quit()) ); return( app.exec() ); } //}}} --------------------------------------------------------------------------

Nicolas SOUCHON · 03-05-2012 13:44:54

n'oublions pas que les objectifs
- dans l'écriture des classes TcpTranport::* est la simplification des classes TcpProtocol::*
- dans l'écriture des classes TcpProtocol::* est la simplification des classes Xxxx::* (en l'occurence, Xxxx, c'est Chat)

actuellement, il faut
- (1) réimplementer TcpProtocol::Socket::Client::execute() et TcpProtocol::Socket::Server::execute() pour pas grand chose

pour ajouter une commande (client -> serveur par exemple), il faut
- (2) ajouter son nom à l'enum des commandes
- (3) ajouter son nom au mapping de noms pour mise au point
- (4) ajouter la méthode d'envoi au client
- (5) ajouter la méthode d'exécution au serveur
- (6) ajouter l'appel à la méthode d'exécution dans Xxxx::Server::execute()
- (7) roll roll roll ce que j'ai pu oublier

on peut remarquer que les méthodes d'exécution de commande ont toutes la même signature:
void execCommand();

avec un mapping de fonctions on doit pouvoir faire l'économie du points (1) et subséquemment du point (6)

on commence par valider le principe

modif dans tccprotocol_socket.h
struct TcpProtocol::Socket : public QTcpSocket { Q_OBJECT; public: typedef AbsTcpTransport::Buffer::Input Input; typedef AbsTcpTransport::Buffer::Output Output; typedef AbsTcpTransport::Buffer::Create CreateBuffers; typedef AbsTcpTransport::LargestCommandType LargestCommandType; // **************** struct Server; struct Client; public: /**/ Socket( CreateBuffers cb, QObject * p = NULL ); virtual ~Socket(); virtual bool execute() = 0; public slots: void on_readyRead(); signals: void finished(); protected: Input * in; Output * out_; }; struct TcpProtocol::Socket::Server : public Socket { Q_OBJECT; public: typedef void (Server::*FExecCommand) (); // **************** type of a command execution function typedef Map<LargestCommandType,FExecCommand> MapExec; // **************** self explaining public: /**/ Server( CreateBuffers cb, int sd, QObject * p = NULL ); /**/ ~Server(); void sendHandshake( QString hello ); void sendBadProtocol( Version remoteVersion ); /**/ // add command from server bool execute(); void execHandshake(); /**/ // add command from client protected: static MapExec execFunc; // **************** };
modif dans tccprotocol_socket.cpp
// **************** variables static TcpProtocol::Socket::Server::MapExec TcpProtocol::Socket::Server::execFunc = MapExec() .add( Command::HANDSHAKE, &Server::execHandshake ); bool TcpProtocol::Socket::Server::execute() { if( true ) // **************** keep old code until complete validation { if( FExecCommand fx = execFunc[in->command] ) { (this->*fx)(); // notice special syntax for non static member function call return( true ); } } else { switch( in->command ) { case Command::HANDSHAKE : execHandshake(); return( true ); } } return( false ); }
smile smile smile les modifs sont simples
smile smile smile on lance le test et on constate que "tout baigne !"

mais on s'arrête là !
un peu de réflexion avant de tout casser !
je me contente d'appliquer le même traitement à bool TcpProtocol::Socket::Client

Nicolas SOUCHON · 04-05-2012 12:13:55

sad sad sad cul de sac !!!
je ne peux pas appliquer la dernière modification pour simplifier comme je le voulais jusqu'au bout

tout au plus je mets en place la même chose dans le client et le serveur du chat
juste pour le plaisir de simplifier le "corps" des méthodes execute()

Nicolas SOUCHON · 04-05-2012 17:46:57

un chat !!! il va bien finir par envoyer un message, quand même !!!

OUI !!!

jusque là les commandes échangées étaient simple:
- le client envoie la commande, le serveur l'exécute
ou
- le serveur envoie la commande, le client l'exécute

pour les messages, c'est un peu plus complexe
- le client envoie la commande, du genre MESSAGE TO_LIST MSG_TEXT
- le serveur reçoit, emet un signal
- le listener (qui centralise) envoie une commande du genre MESSAGE FROM MSG_TEXT à tous les clients adressés

on choisit comme convention que TO_LIST vide adressele message à tout les clients connectés

on adapte un peu le petit programme de test

je donne la nouvelle version ci-joint, c'est moins visuel que des extraits de code
mais sans doute plus commode pour ceux que cela intéresse
et de plus ma souris a "la tremblote" et je "pète les plombs" avec les copier/coller

chat sources

notez que : toujours pas d'interface

notez aussi que même si c'est un peu plus complexe, cela se fait quand même assez facilement

Nicolas SOUCHON · 05-05-2012 16:52:37

un dernier test avant le gui

pour l'instant, tout fonctionne dans un même process, ça me gêne !

j'adapte un peu la structure de test
struct Test : // to test some commands not send at client creation public QObject { Q_OBJECT; public: Test( int n ); // Test( QString n ); // virtual ~Test(); // public slots: void send(); // private: int nb; // number of clients Chat::Client * client; // clients QStringList name; // client names }; Test::Test( int n ) : // create n clients with unique name QObject(), nb( n ), client( (Chat::Client *) malloc( nb * sizeof(*client) ) ) { for( int i = 0; i < nb; i++ ) { QString n = QString( "client_%1" ).arg( i ); name << n; new( client + i ) Chat::Client( n, port ); // **************** } QTimer::singleShot( 5000, this, SLOT(send()) ); } Test::Test( QString n ) : // create one client with name n QObject(), nb( 1 ), client( (Chat::Client *) malloc( sizeof(*client) ) ) { new( client ) Chat::Client( n, port ); // **************** name << n; QTimer::singleShot( 5000, this, SLOT(send()) ); } Test::~Test() // destroy clients { for( int i = 0; i < nb; i++ ) client[i].~Client(); free( client ); } void Test::send() // send messages { for( int i = 0; i < nb; i++ ) { client[i].sendMessage( QStringList(), QString( "this is a message from %1" ).arg( name[i] ) ); } }
et le main
int main( int ac, char * * av ) { Thread::regMain(); QApplication app( ac, av ); // single process test when launched without argument if( ac < 2 ) { Chat::Listener listener( port ); Test test( 10 ); QTimer::singleShot( 10000, &app, SLOT(quit()) ); return( app.exec() ); } // launched with -l : start listening, launch detached processes for clients if( (QString( av[1] ) == "-l") && (ac == 2) ) { Chat::Listener listener( port ); for( int i = 0; i < 10; i++ ) { QProcess * proc = new QProcess; proc->startDetached( *av, QStringList() << "-n" << QString( "client_%1" ).arg( i ) ); } QTimer::singleShot( 10000, &app, SLOT(quit()) ); return( app.exec() ); } // launched with -n name : launch client connection if( (QString( av[1] ) == "-n") && (ac == 3) ) { Test test( av[2] ); QTimer::singleShot( 10000, &app, SLOT(quit()) ); return( app.exec() ); } return( 0 ); }
je lance le test, smile smile smile tout baigne !

Nicolas SOUCHON · 06-05-2012 15:35:30

les attentifs vont dire : lol lol lol tout baigne, tout baigne, il va un peu vite !

les clients déjà connectés sont informés de l'arrivée d'un nouveau
mais les nouveaux ne savent pas qui est déja connecté

je m'empresse de rectifier le tir :
void Chat::Listener::on_name( QString newName ) { // possibly need to lock, but probably not // perhaps make slot private could ensure // send old users to new user // send new user to old users // I think we should always cast sender() // as it could be disastrous to use it having accidentally // connected some signal of another object to this slot if( Server * newServer = qobject_cast<Server *>( sender() ) ) { for( int i = 0; i < servers.count(); i++ ) { Server * oldServer = servers[i]; if( oldServer->name == "" ) continue; // has not yet received client name if( oldServer->name == newName ) continue; // do not send his own name to the client oldServer->sendUserConnected( newName ); newServer->sendUserConnected( oldServer->name ); } } }
smile je relance le test, tout a l'air de fonctionner

mad mais une fois de temps en temps un client reçoit deux fois l'information "nouveau client xxxx"

une fois de temps en temps >>>> délicat à diagnostiquer, mais on finit par trouver : le serveur est nommé trop tôt et de plus dans un autre thread
délicat à diagnostiquer, mais correction simple:
void Chat::Listener::on_name( QString newName ) { // possibly need to lock, but probably not // perhaps make slot private could ensure // send old users to new user // send new user to old users // I think we should always cast sender() // as it could be disastrous to use it having accidentally // connected some signal of another object to this slot if( Server * newServer = qobject_cast<Server *>( sender() ) ) { for( int i = 0; i < servers.count(); i++ ) { Server * oldServer = servers[i]; if( oldServer->name == "" ) continue; // has not yet received client name if( oldServer->name == newName ) continue; // do not send his own name to the client oldServer->sendUserConnected( newName ); newServer->sendUserConnected( oldServer->name ); } newServer->name = newName; // **************** } }
void Chat::Server::execName() { QString name; // **************** *in >> name; qDebug() << "server" << name << "<<" << cmdName( in->command ) << "in" << ::Thread::where(); emit sigName( name ); sendWelcome( name ); }
smile je relance le test, tout a l'air de fonctionner

Nicolas SOUCHON · 06-05-2012 16:09:20

à ce stade, j'introduis dans Chat une structure Chat::Message
// chat.h //{{{ ..Message ---------------------------------------------------------------- struct Chat::Message { struct To { To(); To( QString text, QStringList to = QStringList() ); QString text; QStringList to; }; struct FromTo { FromTo(); FromTo( const To & to, QString from ); QString text; QString from; QStringList to; }; struct From { QString text; QString from; }; }; inline Chat::Message::To::To() {} inline Chat::Message::FromTo::FromTo() {} inline Chat::Message::To::To( QString _text, QStringList _to ) : text( _text ), to( _to ) {} inline Chat::Message::FromTo::FromTo( const To & _to, QString _from ) : text( _to.text ), from( _from ), to( _to.to ) {} // lines are long, but paralxpellism is easy to verify inline QDataStream & operator << ( QDataStream & s, const Chat::Message::To & msg ) { return( s << msg.text << msg.to ); } inline QDataStream & operator >> ( QDataStream & s, Chat::Message::To & msg ) { return( s >> msg.text >> msg.to ); } inline QDataStream & operator << ( QDataStream & s, const Chat::Message::FromTo & msg ) { return( s << msg.text << msg.from << msg.to ); } inline QDataStream & operator >> ( QDataStream & s, Chat::Message::FromTo & msg ) { return( s >> msg.text >> msg.from >> msg.to ); } inline QDataStream & operator << ( QDataStream & s, const Chat::Message::From & msg ) { return( s << msg.text << msg.from ); } inline QDataStream & operator >> ( QDataStream & s, Chat::Message::From & msg ) { return( s >> msg.text >> msg.from ); } //}}} -------------------------------------------------------------------------- //{{{ declare metatypes -------------------------------------------------------- Q_DECLARE_METATYPE( Chat::Message::To ); Q_DECLARE_METATYPE( Chat::Message::FromTo ); Q_DECLARE_METATYPE( Chat::Message::From ); //}}} --------------------------------------------------------------------------
implémentation
// chat.cpp //{{{ statically register metatypes -------------------------------------------- // as metatypes will be registered at library load time // this avoid users of this module to have to do it // and potentially to forget // an example of the interest of anonymous namespaces // these variables are "local" to this "compilation unit", ie: not usable elsewhere // as they actually have external storage class, no warning telling something like : // statically defined but not used // ... namespace { static int Chat_Message_To = qRegisterMetaType<Chat::Message::To >(); static int Chat_Message_FromTo = qRegisterMetaType<Chat::Message::FromTo>(); static int Chat_Message_From = qRegisterMetaType<Chat::Message::From >(); }; //}}} --------------------------------------------------------------------------
à la compilation, ça fonctionne
je voulais montrer l'utilisation, mais mes archives ont un petit trou !!!

l'intérêt est que si mes messages évoluent, tout ce qui concernent les prototypes de signaux/slots n'auront pas à changer

Nicolas SOUCHON · 07-05-2012 12:22:29

je suis comme beaucoup de gens (sinon tout le monde !) j'ai voulu avoir un résultat tangible trop vite !
l'utilisation de la structure précédente est plus laborieuse que prévue !

pas difficile, mais la circulation d'un message est complexe, elle intervient souvent et il ne faut rien oublier, :
- le client envoie : "un peu de texte" adressé à ... : structure Chat::Message::To
- le serveur reçoit et s'empresse d'ajouter l'origine ; structure Chat::Message::FromTo et "émet" un signal
- le listener demande à tous les serveurs destinataires d'envoyer "un peu de texte" de ... : structure Chat::Message::From
- les clients reçoivent "un peu de texte" de ...

dans mes structures, il manquait le passage de Chat::Message::FromTo à Chat::Message::From
//{{{ ..Message ---------------------------------------------------------------- struct Chat::Message { struct To { /**/ To(); /**/ To( QString text, QStringList to = QStringList() ); QString text; QStringList to; }; struct FromTo { /**/ FromTo(); /**/ FromTo( const To & to, QString from ); QString text; QString from; QStringList to; }; struct From { /**/ From(); /**/ From( const FromTo & fromTo ); QString text; QString from; }; }; inline Chat::Message::To::To() {} inline Chat::Message::FromTo::FromTo() {} inline Chat::Message::From::From() {} inline Chat::Message::To::To( QString _text, QStringList _to ) : text( _text ), to( _to ) {} inline Chat::Message::FromTo::FromTo( const To & _to, QString _from ) : text( _to.text ), from( _from ), to( _to.to ) {} inline Chat::Message::From::From( const FromTo & fromTo ) : text( fromTo.text ), from( fromTo.from ) {} // lines are long, but paralellism is easy to verify inline QDataStream & operator << ( QDataStream & s, const Chat::Message::To & msg ) { return( s << msg.text << msg.to ); } inline QDataStream & operator >> ( QDataStream & s, Chat::Message::To & msg ) { return( s >> msg.text >> msg.to ); } inline QDataStream & operator << ( QDataStream & s, const Chat::Message::FromTo & msg ) { return( s << msg.text << msg.from << msg.to ); } inline QDataStream & operator >> ( QDataStream & s, Chat::Message::FromTo & msg ) { return( s >> msg.text >> msg.from >> msg.to ); } inline QDataStream & operator << ( QDataStream & s, const Chat::Message::From & msg ) { return( s << msg.text << msg.from ); } inline QDataStream & operator >> ( QDataStream & s, Chat::Message::From & msg ) { return( s >> msg.text >> msg.from ); } //}}} --------------------------------------------------------------------------
je ne montre pas l'utilisation ce serait trop fastidieux à rédiger !!!

la prochaine étape sera un gui minimum !!!

certains impatients diront: lol lol lol Il était temps !!!

Nicolas SOUCHON · 07-05-2012 15:21:08

comme tout me semble bien fonctionner je passe à l'étape finale: développement du "gui"

il sera "des plus rustiques" : un petit QWidget composé comme suit:
- un QPlainTextEdit (RO) d'affichage du fil du chat : ChatStreamWidget
- un QPlainTextEdit (RO) d'affichage des autres chatte(u)rs connectés : ChatUsersWidget
- un QWidget de saisie/envoi de message : ChatMessageWidget composé comme suit:
-- QPlainTextEdit (RW) de saisie du message
-- un QPushButton d'envoi
mais permettra de visualiser le bon fonctionnement plus commodément qu'avec les qDebug()
//chat_widget.h #ifndef __CHAT_WIDGET_H__ #define __CHAT_WIDGET_H__ //{{{ includes ----------------------------------------------------------------- __IDENT__( chat_widget_h, "@(#) $Id:$" ); #include "chat_socket.h" #include <QtGui/QWidget> #include <QtGui/QPlainTextEdit> //}}} -------------------------------------------------------------------------- //{{{ structures --------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .ChatWidget -------------------------------------------------------------- struct ChatWidget : public QWidget { Q_OBJECT; public: /**/ ChatWidget( QString name, int service, QWidget * parent = NULL ); public slots: void sendTest(); private: Chat::Client client; }; //}}} -------------------------------------------------------------------------- #endif // __CHAT_WIDGET_H__
//chat_widget.cpp //{{{ includes ----------------------------------------------------------------- __IDENT__( chat_widget_cpp, "@(#) $Id:$" ); #include "chat_widget.h" #include "moc_chat_widget.cpp" #include "chat_socket.h" #include <QtCore/QDebug> #include <QtCore/QTimer> #include <QtGui/QSplitter> #include <QtGui/QPushButton> #include <QtGui/QVBoxLayout> #include <QtGui/QHBoxLayout> //}}} -------------------------------------------------------------------------- //{{{ structures "perso" ------------------------------------------------------- // only ChatWidget will be visible // signals should be relayed // this is done because Qt stylesheet does not support structure imbrication //}}} -------------------------------------------------------------------------- //{{{ .ChatUsersWidget --------------------------------------------------------- struct ChatUsersWidget : public QPlainTextEdit // to be later changed to eg: be able to select { Q_OBJECT; public: /**/ ChatUsersWidget( const Chat::Client & client, QWidget * p = NULL ); public slots: void on_connected( QString other ); }; //}}} -------------------------------------------------------------------------- //{{{ .ChatMessageWidget ------------------------------------------------------- struct ChatMessageWidget : public QWidget { Q_OBJECT; public: /**/ ChatMessageWidget( Chat::Client & client, QWidget * p = NULL ); public slots: void on_send(); signals: void sigSend( Chat::Message::To msg ); // ******************** private: Chat::Client & client; QPlainTextEdit * teText; QPushButton * btSend; }; //}}} -------------------------------------------------------------------------- //{{{ .ChatStreamWidget -------------------------------------------------------- struct ChatStreamWidget : public QPlainTextEdit // to be later changed to eg: be beautifull { Q_OBJECT; public: /**/ ChatStreamWidget( const Chat::Client & client, ChatMessageWidget * mw, QWidget * p = NULL ); public slots: void on_message( Chat::Message::From msg ); // ******************** void on_send( Chat::Message::To msg ); // ******************** }; //}}} -------------------------------------------------------------------------- //{{{ includes moc ------------------------------------------------------------- #include "chat_widget.moc" //}}} -------------------------------------------------------------------------- //{{{ ChatWidget --------------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .ChatWidget( QWidget * p ) ----------------------------------------------- ChatWidget::ChatWidget( QString n, int srv, QWidget * p ) : QWidget( p ), client( n, srv, this ) { setWindowTitle( n ); resize( 400, 400 ); ChatUsersWidget * users = new ChatUsersWidget( client ); ChatMessageWidget * message = new ChatMessageWidget( client ); ChatStreamWidget * chat = new ChatStreamWidget( client, message ); QSplitter * vSplitter = new QSplitter( Qt::Vertical ); QSplitter * hSplitter = new QSplitter( Qt::Horizontal ); QVBoxLayout * layout = new QVBoxLayout( this ); hSplitter->addWidget( chat ); hSplitter->addWidget( users ); vSplitter->addWidget( hSplitter ); vSplitter->addWidget( message ); layout->addWidget( vSplitter ); QTimer::singleShot( 5000, this, SLOT(sendTest()) ); } //}}} -------------------------------------------------------------------------- //{{{ .void Test::sendTest() --------------------------------------------------- void ChatWidget::sendTest() { client.sendMessage( Chat::Message::To( QString( "this is a message from %1" ).arg( windowTitle() ) ) ); } //}}} -------------------------------------------------------------------------- //{{{ ChatStreamWidget --------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .ChatStreamWidget( const Client & client, QWidget * p ) ------------------ ChatStreamWidget::ChatStreamWidget( const Chat::Client & client, ChatMessageWidget * mw, QWidget * p ) : QPlainTextEdit( p ) { setReadOnly( true ); connect( &client, SIGNAL(sigMessage(Chat::Message::From)), SLOT(on_message(Chat::Message::From)) ); connect( mw, SIGNAL(sigSend(Chat::Message::To)), SLOT(on_send(Chat::Message::To)) ); } //}}} -------------------------------------------------------------------------- //{{{ .void on_message( Chat::Message::From msg ) ------------------------------ void ChatStreamWidget::on_message( Chat::Message::From msg ) { appendPlainText( QString( "**** %1\n%2" ).arg( msg.from ).arg( msg.text ) ); } //}}} -------------------------------------------------------------------------- //{{{ .void on_send( Chat::Message::To msg ) ----------------------------------- void ChatStreamWidget::on_send( Chat::Message::To msg ) { appendPlainText( QString( "---- \n%1" ).arg( msg.text ) ); } //}}} -------------------------------------------------------------------------- //{{{ ChatUsersWidget ---------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .ChatUsersWidget( QWidget * p ) ------------------------------------------ ChatUsersWidget::ChatUsersWidget( const Chat::Client & client, QWidget * p ) : QPlainTextEdit( p ) { setReadOnly( true ); connect( &client, SIGNAL(sigConnected(QString)), SLOT(on_connected(QString)) ); } //}}} -------------------------------------------------------------------------- //{{{ .void on_connected( QString other ) -------------------------------------- void ChatUsersWidget::on_connected( QString other ) { appendPlainText( other ); } //}}} -------------------------------------------------------------------------- //{{{ ChatMessageWidget -------------------------------------------------------- //}}} -------------------------------------------------------------------------- //{{{ .ChatMessageWidget( QWidget * p ) ---------------------------------------- ChatMessageWidget::ChatMessageWidget( Chat::Client & c, QWidget * p ) : QWidget( p ), client( c ) { teText = new QPlainTextEdit; btSend = new QPushButton( "Send" ); QHBoxLayout * hlo = new QHBoxLayout; hlo->addStretch(); hlo->addWidget( btSend ); QVBoxLayout * vlo = new QVBoxLayout( this ); vlo->setMargin( 0 ); vlo->addWidget( teText ); vlo->addLayout( hlo ); connect( btSend, SIGNAL(clicked()), SLOT(on_send()) ); } //}}} -------------------------------------------------------------------------- //{{{ void on_send() ----------------------------------------------------------- void ChatMessageWidget::on_send() { QString text = teText->document()->toPlainText(); if( text != "" ) { emit sigSend( text ); client.sendMessage( Chat::Message::To( text ) ); } } //}}} --------------------------------------------------------------------------
certains remarqueront que je n'utilise pas l'imbrication des structures pour les widgets

la raison en est que le système de feuille de style Qt ne le supporte pas !!!

je joint les sources complets : chat3.gz

Nicolas SOUCHON · 07-05-2012 16:59:02

Point final coté développement !!!
lol lol lol Ouf !!!

C'avait démarré dans les "trucs et astuces"
en "réponse indirecte" à une question posée
et à des trucs tordus ... (à mon humble avis) ... (pas si humble que ça en fait)
et ça s'est transformé en une espèce de tutoriel, d'où le déplacement

Pour clore, quelques petites remarques

Vous l'aurez constaté, je suis un "maniaque de l'alignement"
je trouve que ça participe beaucoup à la lisibilité
vous allez me dire: mais c'est pas aligné !
J'utilise des tabulations à 4 caractères

je mets des commentaires "bizarres"
//{{{ ...void QString ...... --------------------------- //}}} --------------------------------------------------
c'est que j'utilise vim et le folding par la méthode des markers + une "customization" de vim wink @babaOrums

Quelques remarques plus intéressantes

trop de gens ont tendance à réduire C++ à la POO, la structure à l'objet, mais c'est beaucoup plus que cela

- l'imbrication des structures est déjà une forme d'héritage (au sens structurel, pas objet), un petit exemple:
struct A { struct B; private: enum Enum { V0, V1, }; }; struct A::B { B() : x( V0 ) {} int x; };
A::Enum est privé à A, mais est accessible directement par A::B

si l'on voulais "sortir B de A, il faudrait
- (1) rendre A::Enum public ou (2) faire de B une classe amie de A
- dans B écrire B() : x( A::V0 ) {}
soit
- une sécurité affaiblie si l'on choisit la solution (1) : A::Enum devient accessible par tout le monde
- une écriture plus compliquée dans le créateur de B

pour ceux qui ont utilisé les classes QDesignerXxxxYyyyZzzzAaaaBbbb, wink imaginez le bonheur potentiel !

- un tout petit bémol lié au signaux/slots de Qt qui fonctionnent avec la chaine de caractère qui nomme un type d'argument
alors que pour une méthode classique j'ai pu écrire par exemple
struct Chat::Server : public Socket::Server { // ... public: void sendMessage( Message::From msg ); // as we are in Chat, abreviate Chat::Message::From };
pour un signal/slot il faut employer le nom de classe complètement préfixé
struct Chat::Server : public Socket::Server { // ... public slots: void sendMessage( Chat::Message::From msg ); };
- le C++ c'est encore la structure vide, magnifique, sublime invention

smile smile smile le namespace c'est bien, le namespace c'est génial
sad sad sad le namespace c'est extensible et je ne veux pas que mon Chat le soit
smile smile smile j'en fais une structure vide au lieu d'un namespace

autre exemple

TcpProtocol gère des commandes :
- HANDSHAKE
- BAD_PROTOCOL
...
des status
SUCCESS
BAD_PROTOCOL // pourquoi le nommer autrement
...
j'introduis des structures vides autour des enums correspondant
struct Command // force use of Command::XXXX { enum Val { /**/ NO_COMMAND = 0x00, /**/ HANDSHAKE, /**/ BAD_PROTOCOL, // add command // reserve some place /**/ FIRST_APP_COMMAND = 0x10, }; }; struct Error // force use of Error::XXXX { enum Val { /**/ SUCCESS, /**/ BAD_PROTOCOL, }; };
et là j'ajoute : je hais le using namespace xxxx;

la structure vide permet de déclarer fonctions locales (pour les nostalgiques de Pascal entre autres)
int main( int, char * * ) { struct A { static void f() { qDebug() << __PRETTY_FUNCTION__; } }; A::f(); return( 0 ); } // >> sur Linux // static void main(int, char**)::A::f()
roll roll roll elle est même instanciable !!!
int main( int, char * * ) { struct A { static void f() { qDebug() << __PRETTY_FUNCTION__; } static void g() { qDebug() << __PRETTY_FUNCTION__; } }; // size should be 1 qDebug() << sizeof(A); // if you're tired to write // SomeClass::SomeInnerClass::SomeMoreInnerClass::someFunction( ... ); // SomeClass::SomeInnerClass::SomeMoreInnerClass::someOtherFunction( ... ); A a; a.f(); a.g(); return( 0 ); } // >> sur Linux // 1 // static void main(int, char**)::A::f() // static void main(int, char**)::A::g()
Il est possible que certaines choses me semblent légales parce que mon compilateur les permet
si quelqu'un a un contre exemple, je suis ouvert à toute remarque

- un petit mot à propos de mes amis

on voit un peu partout:
j'aime pas les 'friend'
les 'friend' son à proscrire
...

je réponds:
mad mad mad conneries !!!

et je justifie quand même un peu avec un exemple

imaginons une structure
struct Point { int x; int y;}
dans certaines circonstances on peut avoir d'un d'un point "restreint", eg: coordonnés d'une case sur un échiquier, ...
on adapte
struct Point { void setX( int v ) { if( (0 <= v) && (v < 8) ) x = v; } void setY( int v ) { if( (0 <= v) && (v < 8) ) y = v; } private: int x; int y; }
on veut pouvoir sérialiser, eg: pour pouvoir interrompre une partie puis la reprendre
il nous faut des opérateurs de "streaming" et pour des raisons "techniques"
ils ne peuvent pas être membres de notre classe Point (ils sont évalués de gauche à droite)
on a donc besoin de "friend operators"
struct Point { friend Stream & operator << ( Stream & s, const Point & p ) { return( s << x << y ); } friend Stream & operator >> ( Stream & s, Point & p ) { return( s >> x >> y ); } void setX( int v ) { if( (0 <= v) && (v < 8) ) x = v; } void setY( int v ) { if( (0 <= v) && (v < 8) ) y = v; } private: int x; int y; }
il faut considérer que ces opérateurs font partie intégrante de l'interface de la structure Point
et non qu'ils constituent un défaut d'encapsulation

- les "setters / getters" c'est bien ... si on en a vraiment besoin !!!

mad mad mad ceci est une connerie (excusez la vulgarité)
struct Point { void setX( int v ) { x = v; } void setY( int v ) { y = v; } private: int x; int y; }
ça empêche un code simple
p.x = p.y = 0;
qui doit être remplacé par un autre plus complexe
p.setX( 0 ); p.setY( 0 );
sans rien gagner : x et y, quoique déclarés privés, sont de fait publiques du fait de l'existence du "setter"

tout ce qui rend l'utilisation finale plus complexe devrait être justifié par un réel besoin !!!

et Qt, me direz vous, quid de tous ses "setters / getters"

Qt en a besoin pour le système des "object's properties", c'est donc (au moins en grande partie) justifié !!!

Liens interne à QtFR	Les partenaires de QtFR	Liens pour les sites officiels Qt	Liens sur les ressources Qt
Communauté QtFR sur Google+	Monkey Studio	Télécharger Qt	Notre tutoriel
QtFR sur Twitter	ZeGrapher	Site officiel Qt	Documentation Qt
IRC box		Qt Blog	Qt Centre
Galeries		Qt Wiki	Qt Apps
Contactez-nous		Qt Quarterly

Forum QtFR

Annonce

#1 25-04-2012 19:08:37

Un exemple client - serveur

#2 27-04-2012 12:00:07

Re : Un exemple client - serveur

#3 27-04-2012 13:49:45

Re : Un exemple client - serveur

#4 27-04-2012 14:55:21

Re : Un exemple client - serveur

#5 27-04-2012 15:57:39

Re : Un exemple client - serveur

#6 27-04-2012 16:58:12

Re : Un exemple client - serveur

#7 28-04-2012 10:12:53

Re : Un exemple client - serveur

#8 29-04-2012 12:31:54

Re : Un exemple client - serveur

#9 29-04-2012 12:46:36

Re : Un exemple client - serveur

#10 29-04-2012 13:15:47

Re : Un exemple client - serveur

#11 29-04-2012 13:43:58

Re : Un exemple client - serveur

#12 29-04-2012 13:49:08

Re : Un exemple client - serveur

#13 29-04-2012 13:56:50

Re : Un exemple client - serveur

#14 01-05-2012 23:28:03

Re : Un exemple client - serveur

#17 03-05-2012 13:44:54

Re : Un exemple client - serveur

#18 04-05-2012 12:13:55

Re : Un exemple client - serveur

#19 04-05-2012 17:46:57

Re : Un exemple client - serveur

#20 05-05-2012 16:52:37

Re : Un exemple client - serveur

#21 06-05-2012 15:35:30

Re : Un exemple client - serveur

#22 06-05-2012 16:09:20

Re : Un exemple client - serveur

#23 07-05-2012 12:22:29

Re : Un exemple client - serveur

#24 07-05-2012 15:21:08

Re : Un exemple client - serveur

#25 07-05-2012 16:59:02

Re : Un exemple client - serveur

Pied de page des forums