hnetworkprocessor.h

#ifndef __HNETWORKPROCESSOR_H
#define __HNETWORKPROCESSOR_H
 
#include <netinet/in.h>
 
#include "hnetworkreader.h"
#include "hnetworkwriter.h"
 
template <class T>
class HNetworkProcessor : public HProcessor<T>
{
    private:
 
        int _dataPort;
        int _serverSocket;
        int _commandPort;
        int _commandSocket;
        int _clientSocket;
        struct sockaddr_in _address;
        const char* _server;
        HNetworkReader<T> _networkReader;
        HNetworkWriter<T> _networkWriter;
        bool* _terminated;
 
        bool _isServer;
        bool _isWriter;
 
        HReader<T>* _reader;
        HWriter<T>* _writer;
 
        void InitServer();
        void InitServerDataPort();
        void InitServerCommandPort();
        void InitClient();
        void RunServer(long unsigned int blocks);
        void RunClient(long unsigned int blocks);
        void RunProcessor(long unsigned int blocks);
 
        bool SendCommand(HCommand* command);
        void ReceiveCommands();
        void ReadCommand(int socket);
 
        bool Command(HCommand* cmd)
        {
            return true;
        }
 
    public:
 
        HNetworkProcessor(const char* address, int dataPort, int commandPort, HWriter<T>* writer, int blocksize, bool* terminationToken);
 
        HNetworkProcessor(const char* address, int dataPort, int commandPort, int blocksize, bool* terminationToken);
 
        HNetworkProcessor(const char* address, int dataPort, int commandPort, HReader<T>* reader, int blocksize, bool* terminationToken);
 
        HNetworkProcessor(int dataPort, int commandPort, HWriter<T>* writer, int blocksize, bool* terminationToken);
 
        HNetworkProcessor(int dataPort, int commandPort, int blocksize, bool* terminationToken);
 
        HNetworkProcessor(int dataPort, int commandPort, HReader<T>* reader, int blocksize, bool* terminationToken);
 
        ~HNetworkProcessor();
 
        void Run(long unsigned int blocks = 0);
 
        void Halt();
 
        bool Command(H_COMMAND_CLASS commandClass, H_COMMAND_OPCODE commandOpcode, int16_t length, HCommandData data)
        {
            // A processor acting as a server can not send any commands. Commands is always initiated at the client
            if( _isServer ) {
                HLog("Refusing to send command since we are a server networkprocessor");
                return false;
            }
 
            // Create the command
            HLog("Creating command with class %d and opcode %d with length %d", commandClass, commandOpcode, length);
            HCommand cmd = {static_cast<int16_t>(commandClass), static_cast<int16_t>(commandOpcode), length, data};
 
            // Send the command to the locally connected reader or writer
            if( HProcessor<T>::_reader != nullptr )
            {
                HLog("Sending command to reader chain");
                if( !HProcessor<T>::_reader->Command(&cmd) )
                {
                    HError("Error when sending command to reader chain");
                    return false;
                }
            }
            if( HProcessor<T>::_writer != nullptr )
            {
                HLog("Sending command to writer chain");
                if( !HProcessor<T>::_writer->Command(&cmd) )
                {
                    HError("Error when sending command to writer chain");
                    return false;
                }
            }
 
            // Send the command to the remote end (the server)
            HLog("Sending command to remote (server)");
            if( !SendCommand(&cmd) )
            {
                HError("ERror when sending command to rmote end (the server)");
                return false;
            }
 
            // Done
            HLog("Command sent successfully");
            return true;
        }
};
 
#endif