tcp.h

#pragma once
#include <winsock2.h>
#include <windows.h>
#include "wex.h"
#include "ctcp.h"
#include "await.h"
 
namespace wex
{
    class tcp : public gui
    {
    public:
        tcp(gui *parent) : gui(parent)
        {
            // Run asynchronous wait handler in its own thread
            run();
        }
 
        void RetryConnectServer(bool f)
        {
            myTCP.RetryConnectServer(f);
        }
 
        void client(
            const std::string &ipaddr = "127.0.0.1",
            const std::string &port = "27678")
        {
            myTCP.server(ipaddr, port);
 
            // wait for connection to server
            myWaiter(
                [&]
                {
                    myTCP.serverWait();
                },
                [this]
                {
                    // check that server succesfully was connected to
                    if (!myTCP.isConnected())
                    {
                        std::cout << "wex::tcp failed connection to server" << std::endl;
                        return;
                    }
                    else
                    {
                        std::cout << "wex::tcp connected to server" << std::endl;
                    }
 
                    // send message to parent window announcing success
                    if (!PostMessageA(
                            myParent->handle(),
                            WM_APP + 2,
                            myID,
                            0))
                    {
                        std::cout << "Post Message Error\n";
                    }
                });
        }
 
        void server(const std::string &port = "27654")
        {
            myTCP.server("", port);
 
            myWaiter(
                [&]
                { myTCP.acceptClient(); },
                [this]
                {
                    std::cout << "connected" << std::endl;
                    PostMessageA(
                        myParent->handle(),
                        WM_APP + 2,
                        myID,
                        0);
                });
        }
 
        bool isConnected()
        {
            return myTCP.isConnected();
        }
 
        void send(const std::string &msg)
        {
            std::cout << "wex::tcp::send " << msg << "\n";
            myTCP.send(msg);
        }
        void send(const std::vector<unsigned char> &msg)
        {
            myTCP.send(msg);
        }
 
        void read()
        {
            myWaiter(
                [this]
                { myTCP.read(); },
                [this]
                {
                    // post read complete message
                    PostMessageA(
                        myParent->handle(),
                        WM_APP + 3,
                        myID,
                        0);
                });
        }
 
        std::string readMsg() const
        {
            return myTCP.readMsg();
        }
        std::string serverPort() const
        {
            return myTCP.serverPort();
        }
 
    private:
        std::string myRemoteAddress;
 
        raven::set::cTCP myTCP;
        raven::await::cAwait myWaiter;
 
        void run()
        {
            std::thread t(
                raven::await::cAwait::run,
                &myWaiter);
            t.detach();
        }
    };
    class cSocket
    {
    public:
        cSocket() : myWindow(maker::make()),
                    myTCP(&myWindow),
                    myConnectHandler([](std::string port) {})
        {
            //  when a client connects, setup to read anything sent
            myWindow.events()
                .tcpServerAccept(
                    [this]
                    {
                        myConnectHandler(myPort);
                        myTCP.read();
                    });
 
            //  handle data received on input
            myWindow.events().tcpRead(
                [this]
                {
                    // check for connection closed
                    if (!myTCP.isConnected())
                    {
                        if (myIpaddr.empty())
                        {
                            // client disconnect
                            std::cout << "Input Connection closed, waiting for new client\n";
 
                            server(
                                myPort,
                                myConnectHandler,
                                myReadHandler);
                        }
                        else
                        {
                            // server disconnected
                            std::cout << "server disconnected\n";
                        }
                        return;
                    }
 
                    myReadHandler(
                        myPort,
                        myTCP.readMsg());
 
                    // setup for next message
                    myTCP.read();
                });
        }
        void server(
            const std::string &port,
            std::function<void(std::string & port)> connectHandler,
            std::function<void(std::string & port, const std::string &msg)> readHandler)
        {
            myPort = port;
            myIpaddr = "";
            myConnectHandler = connectHandler;
            myReadHandler = readHandler;
            myTCP.server(port);
        }
 
        void RetryConnectServer(bool f)
        {
            myTCP.RetryConnectServer(f);
        }
        
        void client(
            const std::string &ipaddr,
            const std::string &port,
            std::function<void(std::string & port, const std::string &msg)> readHandler)
        {
            myIpaddr = ipaddr;
            myPort = port;
            myReadHandler = readHandler;
 
            myTCP.client(ipaddr, port);
 
        }
 
        bool isConnected()
        {
            return myTCP.isConnected();
        }
 
        void send(const std::string &msg)
        {
            myTCP.send(msg);
        }
 
        void run()
        {
            myWindow.run();
        }
 
    private:
        gui &myWindow;
        tcp myTCP;
        std::function<void(std::string & port)> myConnectHandler;
        std::function<void(std::string & port, const std::string &msg)> myReadHandler;
        std::string myPort;
        std::string myIpaddr;
    };
 
}