messageManager.h

#pragma once
 
#include <iostream>
#include <stdio.h>
#include <queue>
#include <list>
#include <boost/thread.hpp>
#include <boost/any.hpp>
#include <boost/asio.hpp>
#include <boost/bind/bind.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/chrono.hpp>
#include <boost/asio/basic_waitable_timer.hpp>
 
#ifdef TESTING
#include "gtest/gtest.h"
#endif
 
typedef boost::asio::basic_waitable_timer<boost::chrono::steady_clock> steady_timer; 
 
class Message
{
public:
    std::string content; 
    int timeout; 
    int retries; 
    std::string expectedInitResponse; 
    std::string expectedEndResponse; 
    std::string receivedResponse=""; 
    Message(std::string content="", int timeout = 100, int retries = 3, std::string expectedInitResponse = "", std::string expectedEndResponse="");
};
 
class Transaction
{
public:
    std::string id; 
    std::list<Message> messages; 
    int intervalMessage=0; 
 
    Transaction(){}
    explicit Transaction(std::list<Message> list):messages(list) {}
    explicit Transaction(std::initializer_list<Message> list): messages(list){}
};
 
enum Status
{
    IDLE, 
    SENDING 
};
 
class MessageManagerObserver
{
public:
    virtual std::list<std::string> getUnsolicitedInfoCodes(){
        std::list<std::string> list;
        return list;
    }
 
    virtual void transactionProcessed(boost::system::error_code error_code, Transaction transaction) = 0;
 
    virtual void unsolicitedInfo(const std::string& message) = 0;
 
    virtual ~MessageManagerObserver()
    {
    }
};
 
class MessageManager: public boost::enable_shared_from_this<MessageManager>
{
public:
    explicit MessageManager();
    virtual ~MessageManager();
    static std::string stringToHex(const std::string& input, bool printAsciiChar);
 
    boost::system::error_code subscribe(MessageManagerObserver* observer);
    boost::system::error_code unsubscribe(MessageManagerObserver* observer);
    
    virtual bool rebootCommunications() = 0;
#ifdef TESTING
    virtual boost::system::error_code sendAsync(const Transaction& transaction);
    virtual boost::system::error_code sendSync(Transaction& transaction);
#else
    boost::system::error_code sendAsync(const Transaction& transaction);
    boost::system::error_code sendSync(Transaction& transaction);
 
#endif
 
protected:
    
    virtual boost::system::error_code send(std::string message) = 0;
    
    void receivedMessage(const char* data, size_t size);
    virtual boost::system::error_code receiveUntil(int timeout, std::string& receivedResponse);
 
private:
    boost::asio::io_service mIoTimer; 
    boost::thread mBtTimer;
    steady_timer m_processQueueTimer;
    std::list<Transaction> mQueue; 
    Status mStatus;
    std::vector<MessageManagerObserver*> m_observersList;
    int mCounter = 0;
    std::string mDataReceived;
    std::string mResponse;
    int mConsecutiveErrors = 0;
    bool mWaiting;
    bool mWorking;
    Message mLastMessageSent;
    std::mutex mMuxCV, mMuxStatus, mMuxQueue; 
    std::condition_variable mConditionVar; 
    Status getStatus();
    void setStatus(Status status);
    void processQueue(const boost::system::error_code& ec);
    void processTransactions(std::list<Transaction>& queue);
    void processMessages(boost::system::error_code& ec, std::list<Message>& messages, int interval=0);
    void processSingleTransaction(boost::system::error_code& ec, Transaction transaction);
    boost::system::error_code sendAndReceive(Message& message);
 
#ifdef TESTING
public:
    FRIEND_TEST(MessageManager_test, Send_ASyncNoRetries);
    FRIEND_TEST(MessageManager_test, Send_ASyncRetries);
    FRIEND_TEST(MessageManager_test, Send_ReceiveOK);
    FRIEND_TEST(MessageManager_test, Send_ReceiveKO);
    FRIEND_TEST(MessageManager_test, UnsolicitedInfoIdle);
    FRIEND_TEST(MessageManager_test, UnsolicitedInfoBusy);
    FRIEND_TEST(MessageManager_test, receiveUntilTimeoutExpired);
    FRIEND_TEST(MessageManager_test, ReceiveMessageNoInitNoEnd);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitNoEnd);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitNoEndError);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitNoEndCoupled);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitNoEndDoubleMessage);
    FRIEND_TEST(MessageManager_test, ReceiveMessageNoInitEndCorrectly);
    FRIEND_TEST(MessageManager_test, ReceiveMessageNoInitEndCoupled);
    FRIEND_TEST(MessageManager_test, ReceiveMessageNoInitEndBroken);
    FRIEND_TEST(MessageManager_test, ReceiveMessageNoInitEndNotFound);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitEndCorrectly);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitEndDoubleMsg);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitEndCoupled);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitEndBroken);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitEndNotFoundInit);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitEndNotFoundEnd);
    FRIEND_TEST(MessageManager_test, BrokenUnsolicitedInfoMsg);
    FRIEND_TEST(MessageManager_test, BrokenRequestMsg);
    FRIEND_TEST(MessageManager_test, BrokenRequestEnd);
    FRIEND_TEST(MessageManager_test, CoupledMsg_RequestUnsolicited);
    FRIEND_TEST(MessageManager_test, CoupledMsg_UnsolicitedRequest);
    FRIEND_TEST(MessageManager_test, CoupledMsg_UnsolicitedRequestNoCode);
    FRIEND_TEST(MessageManager_test, CoupledMsg_RequestRequest);
    FRIEND_TEST(MessageManager_test, IncompleteUnsolicitedMsg);
    FRIEND_TEST(MessageManager_test, IncompleteRequestMsg);
    FRIEND_TEST(MessageManager_test, UnsolicitedMsgWhile_RequestInitAndEndMsg);
    FRIEND_TEST(MessageManager_test, UnsolicitedMsgWhile_RequestInit);
    FRIEND_TEST(MessageManager_test, UnsolicitedMsgWhile_RequestEnd);
    FRIEND_TEST(MessageManager_test, UnsolicitedMsgWhile_RequestNoInitNoEnd);
#endif
};