io.hpp

Go to the documentation of this file.

// This file is part of playd.
// playd is licensed under the MIT licence: see LICENSE.txt.

#ifndef PLAYD_IO_CORE_HPP
#define PLAYD_IO_CORE_HPP

#include <ostream>
#include <set>

// Use the same ssize_t as libmpg123 on Windows.
#ifndef _MSC_VER
typedef long ssize_t;
#define _SSIZE_T_
#define _SSIZE_T_DEFINED
#endif
#include <uv.h>

#include "player.hpp"
#include "response.hpp"
#include "tokeniser.hpp"

class Player;
class Connection;

class IoCore : public ResponseSink
{
public:
    explicit IoCore(Player &player);

    IoCore(const IoCore &) = delete;

    IoCore &operator=(const IoCore &) = delete;

    void Run(const std::string &host, const std::string &port);

    //
    // Connection API
    //

    void Accept(uv_stream_t *server);

    void Remove(size_t id);

    void UpdatePlayer();

    void Respond(size_t id, const Response &response) const override;

    void Shutdown();

private:
    static const uint16_t PLAYER_UPDATE_PERIOD;

    uv_loop_t *loop;    
    uv_signal_t sigint; 
    uv_tcp_t server;    
    uv_timer_t updater; 

    Player &player; 

    std::vector<std::shared_ptr<Connection>> pool;

    std::vector<size_t> free_list;

    void InitAcceptor(const std::string &address, const std::string &port);

    void InitUpdateTimer();

    void InitSignals();

    //
    // Connection pool handling
    //

    size_t NextConnectionID();

    void ExpandPool();

    //
    // Response dispatch
    //

    void Broadcast(const Response &response) const;

    void Unicast(size_t id, const Response &response) const;
};

class Connection
{
public:
    Connection(IoCore &parent, uv_tcp_t *tcp, Player &player, size_t id);

    ~Connection();

    Connection(const Connection &) = delete;

    Connection &operator=(const Connection &) = delete;

    void Respond(const Response &response);

    void Read(ssize_t nread, const uv_buf_t *buf);

    void Shutdown();

    void Depool();

    std::string Name();

private:
    IoCore &parent;

    uv_tcp_t *tcp;

    Tokeniser tokeniser;

    Player &player;

    size_t id;

    Response RunCommand(const std::vector<std::string> &msg);
};

#endif // PLAYD_IO_CORE_HPP