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/basic_waitable_timer.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
};