NPL_TCPConnection.h

#pragma once

#include "ParaRingBuffer.h"

#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/thread.hpp>

// this is the gloox client
#include <gloox.h>
#include <connectionbase.h>
#include <logsink.h>

namespace ParaEngine
{
    using namespace gloox;
    using boost::asio::ip::tcp;

    class CNPLTCPConnection : public ConnectionBase
    {
    public:
        typedef CParaRingBuffer<std::string> RingBuffer_Type;

        CNPLTCPConnection( boost::asio::io_service& io_service, const LogSink& logInstance, const std::string& server, int port = -1 );

        CNPLTCPConnection( boost::asio::io_service& io_service, ConnectionDataHandler *cdh, const LogSink& logInstance,
            const std::string& server, int port = -1 );

        virtual ~CNPLTCPConnection();

        // reimplemented from ConnectionBase
        virtual bool send( const std::string& data );

        // reimplemented from ConnectionBase
        virtual ConnectionError receive();

        // reimplemented from ConnectionBase
        virtual void disconnect();

        // reimplemented from ConnectionBase
        virtual void cleanup();

        // reimplemented from ConnectionBase
        virtual void getStatistics( long int  &totalIn, long int &totalOut );


        // reimplemented from ConnectionBase
        virtual ConnectionError recv( int timeout = -1 );

        // reimplemented from ConnectionBase
        virtual ConnectionError connect();

        // reimplemented from ConnectionBase
        virtual ConnectionBase* newInstance() const;

        void NotifyDisconnect(ConnectionError error);

        bool HasNotification();

        int HandleNotification();

        void Reset( const std::string& server, int port );
    protected:
        // IO event handlers

        void handle_resolve(const boost::system::error_code& err, tcp::resolver::iterator endpoint_iterator);
        void handle_connect(const boost::system::error_code& error, tcp::resolver::iterator endpoint_iterator);
        void handle_read(const boost::system::error_code& error, std::size_t bytes_transferred);
        void handle_write(const boost::system::error_code& error);
        void handle_disconnect();

    protected:
        CNPLTCPConnection &operator=( const CNPLTCPConnection & );
        void init( const std::string& server, int port );
        
        const LogSink& m_logInstance;
        
        // the receive buffer
        char *m_buf;
        const int m_bufsize;
        long int m_totalBytesIn;
        long int m_totalBytesOut;
        std::string m_strPort;

        tcp::socket m_socket;
        tcp::resolver m_resolver;
        boost::asio::io_service * m_pIOService;

        bool m_bNotifyDisconnect;
        ConnectionError m_nDisconnectError;

        ParaEngine::mutex m_mutex;

        RingBuffer_Type m_queueOutput;

        RingBuffer_Type m_queueInput;
        
    };
}