BaseCommunication.h

#pragma once
#include <string>
#include <thread>
#include <iostream>
#include <future>
#include "BaseSettings.h"
#include "RawData.h"
#include "BaseDataExtractor.h"
#include "CommunicationStructures.h"
 
//#define MONITORING_ENABLED
 
using namespace std;
 
#ifdef STARFLEETTOOLBOX_EXPORTS
#define BASECOMM __declspec(dllexport)
#else
#define BASECOMM __declspec(dllimport)
#endif
 
#define MONITORING_TIMESLEEP 250        // Sets the loop period of the monitoring system
#define RECONNECT_TIMESLEEP 250         // Sets the reconnect timeout period in the monitoring system
 
 
#define MONITORING_MODE unsigned int
#define MONITORING_OFF 0                // Indicates that monitoring is OFF
#define MONITORING_ON 1                 // Indicates that monitoring is ON
#define AUTO_RECONNECT 2                // Indicates that monitoring is ON and auto reconnect mode is on
 
typedef void  (*MarshallingConnectionCheckerCallback)(CommunicationStatus*);
typedef std::function<void(CommunicationStatus*)> ConnectionCheckerCallback;
 
class BASECOMM BaseCommunication abstract
{
public: 
    BaseCommunication();
 
    BaseCommunication(MONITORING_MODE monitor);
 
    ~BaseCommunication();
 
    void SetSettings(BaseSettings* settings);
 
    BaseSettings* GetSettings();
 
 
    void SetDataExtractor(BaseDataExtractor* pDataExtractor);
 
    BaseDataExtractor* GetDataExtractor();
 
    virtual CommunicationStatus Connect() = 0;
 
    virtual void Disconnect() = 0;
 
    virtual CommunicationStatus GetConnectionStatus() = 0;
 
    bool IsConnected();
 
 
    virtual string SendCommand(string commandToSend) = 0;
 
    virtual RawData WaitForRawData(int waitTimeout, unsigned long* semStatus) = 0;  
 
    void StartMonitoring();
    
    void StopMonitoring();
 
    void SetCommunicationCallback(ConnectionCheckerCallback);
    void SetCommunicationCallback(void(* ConnectionCheckerCallbackMethod)(CommunicationStatus*));
 
protected:
    std::atomic<bool> _connected;
    std::atomic<bool> _reconnecting;
    bool _connectHasBeenCalled = false;
 
    MONITORING_MODE GetMonitoringMode();
    
    virtual CommunicationStatus Reconnect() = 0;
 
    void *_mutexMonitoring;                                     
    void* _mutexConnectState;                                   
    volatile int _connStatus = 0;                               
private:
    std::atomic<bool> _monitoringExit;                          
    thread _monitoringWorker;                                   
    MONITORING_MODE _monitoringMode = MONITORING_OFF;           
    ConnectionCheckerCallback _monitorinCallBack = NULL;        
    void AsyncWrapper(ConnectionCheckerCallback, CommunicationStatus*); // async wrapper for callback
    void MonitoringBusiness();                                  
    
    BaseSettings* _settings;
    BaseDataExtractor* _dataExtractor;
};