Server.hxx

Go to the documentation of this file.

 
#ifndef _WITHROTTLE_SERVER_HXX_
#define _WITHROTTLE_SERVER_HXX_
 
#include <string>
#include <memory>
 
#include "executor/Dispatcher.hxx"
#include "executor/Service.hxx"
#include "openlcb/TractionThrottle.hxx"
#include "utils/socket_listener.hxx"
#include "withrottle/Defs.hxx"
#include "withrottle/ServerCommand.hxx"
#include "withrottle/ServerCommandLoco.hxx"
 
namespace withrottle
{
/* forward declaration */
class ThrottleFlow;
 
class Server : public Service
{
public:
    Server(const char *name, int port, openlcb::Node *node)
        : Service(&executor)
        , executor(name, 0, 2048)
        , node(node)
        , listener((port >= 0 || port <= UINT16_MAX) ? port : Defs::DEFAULT_PORT,
                   std::bind(&Server::on_new_connection, this,
                   std::placeholders::_1))
    {
    }
 
    ~Server()
    {
        listener.shutdown();
    }
 
    void start()
    {
    }
 
private:
    void on_new_connection(int fd);
 
    Executor<1> executor;
 
    openlcb::Node* node;
 
    SocketListener listener;
 
    friend class ThrottleFlow;
 
    DISALLOW_COPY_AND_ASSIGN(Server);
};
 
class ThrottleFlow : public StateFlowBase
{
public:
    ThrottleFlow(Server *server, int fd, openlcb::Node *node);
 
    ~ThrottleFlow()
    {
        close(fd);
        command->unref();
    }
 
    void start()
    {
        start_flow(STATE(entry));
    }
 
private:
    bool parse();
 
    void parse_command();
 
    void parse_multi_type();
 
    void parse_train();
 
    bool parse_subcommand();
 
    void parse_multi();
 
    StateFlowBase::Action entry();
 
    StateFlowBase::Action data_sent();
 
    StateFlowBase::Action data_received();
 
    openlcb::TractionThrottle olcbThrottle;
 
    Server *server;
 
    string name; 
    string id; 
    LocoAddress address; 
    LocoAddress secondaryAddress; 
    int fd;
 
    char readRaw[128];
 
    string data;
 
    size_t dataIndex;
 
    ServerState state;
 
    StateFlowSelectHelper selectHelper;
 
    typedef DispatchFlow<Buffer<ThrottleCommand>, 1> CommandDispatchFlow;
 
    CommandDispatchFlow dispatcher;
 
    Buffer<ThrottleCommand> *command;
 
    ServerCommandLoco serverCommandLoco;
 
    friend class ServerCommandBase;
 
    friend class ServerCommandLoco;
};
 
/*
 * Server::on_new_connection()
 */
inline void Server::on_new_connection(int fd)
{
    ThrottleFlow *flow = new ThrottleFlow(this, fd, node);
    flow->start();
}
 
} /* namespace withrottle */
 
#endif /* _WITHROTTLE_SERVER_HXX_ */