#include "WebSocket.h"

// ... and somewhere in your code:

// create the to-be-wrapped socket (this is the real socket)
QTcpSocket *sock = new QTcpSocket(this);

connect(sock, &QTcpSocket::connected, this, [this, sock]{
    // create the socket wrapper
    auto websock = new WebSocket::Wrapper(sock, this);
    // 'sock' is now a child of 'websock' ('websock' wraps 'sock').
    // (do not use 'sock' directly anymore, instead use 'websock').

    // We will start the handshake process below:

    // register the success signal (emitted if the handshake succeeds)
    connect(websock, &WebSocket::Wrapper::handshakeSuccess, this, [this, websock]{
       // save the active socket here and use it...
       // At this point the conneciton is "speaking" the web socket protocol
       // You can call websock->write(), to send.
       // Use the `messagesReady()` or `readyRead()` signals to receive framed
       // messages.
       this->connectedSock = websock;
       // use it.... emit a signal here, etc...
    });
    // we need to also handle failures
    connect(websock, &WebSocket::Wrapper::handshakeFailed, this, [this, websock](const QString & reason){
        // handle failure, delete the socket, etc
        qWarning() << "WebSocket handshake failed:" << reason;
        // below will also delete child wrapped socket...
        websock->deleteLater();
    });
    auto res = websock->startClientHandshake("/", "somehost.com");
    // ^ some time later either handshakeSuccess() or handshakeFailed() will be emitted by 'websock'

    if (!res)
        // this should not normally happen, but it pays to be careful
        websock->deleteLater();
});

sock->connectToHost(someHost, somePort);

// be sure to add code to handle connection failures here too (omitted from this example).

#include <QTcpServer>
#include "WebSocket.h"

// You must inherit QTcpServer and override incomingConnection(qintptr)
void MyTcpServer::incomingConnection(qintptr socketDescriptor)
{
    QTcpSocket *socket = new QTcpSocket(this);
    socket->setSocketDescriptor(socketDescriptor);
    // the below wrapper `ws` becomes parent of the socket,
    // and `this` is now parent of the wrapper.
    auto ws = new WebSocket::Wrapper(socket, this);

    // do not access `socket` below this line, use `ws` instead.

    connect(ws, &WebSocket::Wrapper::handshakeSuccess, this, [this, ws] {
        addPendingConnection(ws);
        // We must emit newConnection() here because we went asynch and are doing this 'some time later', and the calling code emitted a spurous newConnection() on our behalf previously.. and this is the *real* newConnection()
        emit newConnection();
    });
    // handle handshake failure as well
    connect(ws, &WebSocket::Wrapper::handshakeFailed, this, [ws](const QString &reason) {
        qWarning() << "WebSocket handshake failed:" <<  reason;
        ws->deleteLater();
    });

    auto res = ws->startServerHandshake();
    // ^ some time later either handshakeSuccess() or handshakeFailed() will be emitted by 'ws'

    if (!res)
        // this should not normally happen
        ws->deleteLater();
}