dpyMwClient.h

Go to the documentation of this file.

#pragma once
#include <boost/shared_ptr.hpp>
#include <boost/asio.hpp>
#include <boost/make_shared.hpp>
#include <boost/any.hpp>
#include <boost/system/error_code.hpp>
#include <boost/function.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/chrono.hpp>
#include <boost/asio/waitable_timer_service.hpp>
#include <boost/thread.hpp>

#ifdef TESTING
#include "gtest/gtest.h"
#endif

// The forward reference.
class DpyMwDealer;
class DpyMwSubscriber;

enum class ServiceState {
    UNKNOWN , 
    ACTIVE , 
    DISCONNECTED 
};

typedef boost::function<void(const std::string&, boost::any, int)> f_proto_message_client;

typedef std::map<uint64_t, f_proto_message_client> map_proto_register_client;

typedef boost::function<void(const bool &alive)> f_hearbeat_handler;

typedef boost::asio::basic_waitable_timer<boost::chrono::steady_clock> steady_timer; 

class DpyMwClient: public boost::enable_shared_from_this<DpyMwClient>
{
    struct Global_config
    {
        int time_count; 
        boost::any handler; 
        int response_type; 
    };

private:
    std::condition_variable mCv;
    boost::asio::io_service mIo;
    bool m_working;
    steady_timer m_dealerTimer;
    steady_timer m_heartbeatTimer;
    int timerCounter;
    boost::shared_ptr<DpyMwSubscriber> m_subscriber;
    boost::shared_ptr<DpyMwDealer> m_dealer;
    int lastMessageID = 0;
    std::map<int, Global_config> m_map_dealerHandlers;
    std::map<int, std::vector<boost::any>> m_map_subscriberHandlers;
    ServiceState alive = ServiceState::UNKNOWN;
    f_hearbeat_handler mHeartbeatHandler;

    boost::thread bt;

protected:
    map_proto_register_client m_register_map;

    void sendRequest(int requestType, int responseType, std::string content, boost::any handler, int ms_timeout = 2000);
    virtual void RegisterCallbacks()=0;
    std::mutex m_map_mutex;
public:
    DpyMwClient(std::string& ip, int dport, int sport);
    virtual ~DpyMwClient();
    void start();
    void stop();
    void subscribe(int messageType, boost::any handler);
    void unsubscribe(int messageType);
    bool isAlive();
    void monitorServiceAvailability_S(const f_hearbeat_handler& handler);
    void monitorServiceAvailability_U();


private:
    void dealer_handler(const std::string &msg);
    void dealerTimer_handler(const boost::system::error_code& e);
    void heartbeatTimer_handler(const boost::system::error_code& e);
    void subscriber_handler(const std::string &msg);

#ifdef TESTING
public:
    FRIEND_TEST(Client_dealer_test, Request_timeout);
    FRIEND_TEST(Client_dealer_test, Request_answered);

#endif
};