channel.hpp

Go to the documentation of this file.

#pragma once
#include <string>
#include <iostream>
#include <vector>
#include <map>
#include <future>

#include "message.hpp"
#include "hub.hpp"
#include "config.hpp"
#include "logging.hpp"

namespace channeling {
  using namespace messaging;

  class channel_error: public std::runtime_error {
  public:
    const std::string _name;   
    channel_error(std::string const& name, std::string const& message) :
      std::runtime_error(message),
      _name(name)
    {};
  };

  class activate_error: public channel_error  {
  public:
    activate_error(std::string const& name, std::string const& message) :
      channel_error(name, message) {};
  };

  class connection_error: public channel_error {
  public:
    connection_error(std::string const& name, std::string const& message) :
      channel_error(name, message) {};
  };

  class Channel {
    unsigned int _reconnect_attempt;                
    void reconnect();

    std::shared_ptr<std::atomic<bool> > _hub_alive; 
  protected:
    std::atomic_bool _active;                       
    /* Polling functions */
    std::unique_ptr<std::thread> _thread;           
    std::atomic_bool _pipeRunning;                  
    virtual void pollThread();                      
    int _fd;                                        
    const config::ConfigParser _config;             
    const std::string _name;                        
    const ChannelDirection _direction;              
    Hub::Hub * const _hub;                          
    virtual void incoming(const message_ptr&& msg) = 0;

    virtual const message_ptr parse(const char* line) const = 0;

    void startPolling();

    void stopPolling();

  public:
    const uint16_t _id;                             
    Channel(Hub::Hub * const hub, const std::string& config);

    virtual ~Channel();

    virtual std::string const& name() const;

    virtual std::string type() const = 0;

    ChannelDirection direction() const {return _direction; };

    virtual std::future<void> activate() = 0;

    friend Channel& operator>> (const message_ptr, Channel& channel);

    virtual int connect(const std::string& hostname, const uint32_t port) const;

    virtual int send(const uint32_t fd, const std::string& msg) const;

    virtual int send(const std::string& msg) const {return send(_fd, msg); };

    virtual int disconnect(const uint32_t fd) const;

    virtual int disconnect() const {return disconnect(_fd); };

    virtual void tick() { DEBUG << "Empty tick in " << _name; };
  };

  class ChannelCreator
  {
  public:
    ChannelCreator(const std::string& classname);
    virtual Channel * create(Hub::Hub * const hub, const std::string& config) = 0;
  };

  template <class T>
  class ChannelCreatorImpl: public ChannelCreator
  {
  public:
    ChannelCreatorImpl(const std::string& classname) : ChannelCreator(classname) {}

    virtual Channel * create(Hub::Hub * const hub, const std::string& config) { return new T(hub, config); }
  };

  class ChannelFactory
  {
  public:
    static Channel * create(const std::string& classname, Hub::Hub * const hub, const std::string& config);
    static void registerClass(const std::string& classname, ChannelCreator* creator);
    static uint16_t nextId() { return id++; }

  private:
    static std::atomic_int id;
    static std::map<std::string, ChannelCreator *>& get_table();
  };
}