ESPClient.h

Go to the documentation of this file.

#ifndef ESPCLIENT_H_
#define ESPCLIENT_H_

#include "ESPComm.h"


class ESPClient
{
public:

    ESPClient( ESPComm& espComm,
               Logger& logger,
               Timespan initialPromptTimeout,
               Timespan loadCartridgeTimeout,
               Timespan filterResultTimeout,
               Timespan filterCompleteTimeout,
               Timespan processResultTimeout,
               Timespan processCompleteTimeout,
               Timespan stopResultTimeout
             );

    ~ESPClient();

    enum SamplingState
    {
        S_NONE,
        S_WAITING_INITIAL_PROMPT,
        S_PREPARING_SHOW_LOG,
        S_PREPARING_SHOW_STATUS,
        S_LOADING_CARTRIDGE,
        S_FILTERING,
        S_WAITING_FOR_PAUSED,
        S_PROCESSING,
        S_WAITING_FOR_PROCESSED,
        S_STOPPING,
        S_IDLE,
        S_ERROR
    };

    const char* samplingStateName( SamplingState samplingState )
    {
        switch( samplingState )
        {
        case S_NONE:
            return "S_NONE";
        case S_WAITING_INITIAL_PROMPT:
            return "S_WAITING_INITIAL_PROMPT";
        case S_PREPARING_SHOW_LOG:
            return "S_PREPARING_SHOW_LOG";
        case S_PREPARING_SHOW_STATUS:
            return "S_PREPARING_SHOW_STATUS";
        case S_LOADING_CARTRIDGE:
            return "S_LOADING_CARTRIDGE";
        case S_FILTERING:
            return "S_FILTERING";
        case S_WAITING_FOR_PAUSED:
            return "S_WAITING_FOR_PAUSED";
        case S_PROCESSING:
            return "S_PROCESSING";
        case S_WAITING_FOR_PROCESSED:
            return "S_WAITING_FOR_PROCESSED";
        case S_STOPPING:
            return "S_STOPPING";
        case S_IDLE:
            return "S_IDLE";
        case S_ERROR:
            return "S_ERROR";
        default:
            return "(invalid SamplingState)";
        }
    }

    SamplingState currentSamplingState()
    {
        return samplingState_;
    }

    const char* currentSamplingStateName()
    {
        return samplingStateName( samplingState_ );
    }

    bool startSampling();

    bool isSampling();

    bool isSuccessfulSampling();

    Str getSamplingError();

    void setDebug( bool debugOn )
    {
        debug_ = debugOn;
    }

private:

    // disallow copy constructor
    ESPClient( const ESPClient& old );

    ESPComm& espComm_;

    Logger logger_;

    const Timespan initialPromptTimeout_;
    const Timespan loadCartridgeTimeout_;
    const Timespan filterResultTimeout_;
    const Timespan filterCompleteTimeout_;
    const Timespan processResultTimeout_;
    const Timespan processCompleteTimeout_;
    const Timespan stopResultTimeout_;

    bool debug_;

    SamplingState samplingState_;

    Timestamp startTimeForInitialPrompt_;

    Str issuedCmd_;
    Timestamp cmdIssueTime_;
    Timespan cmdResultTimeout_;
    Timespan cmdCompleteTimeout_;

    Str partialLine_;

    Str samplingError_;

    // the latest received complete result
    Str* latestResult_;

    // the latest received complete exception
    Str* latestException_;

    // advances the state machine
    void advanceInteraction();

    void issueCommand( Str cmd, Timespan resultTimeout, Timespan completionTimeout = 10 );

    void consumeResult();

    // for reception of result of command
    void checkCmdResultTimeout( bool issueStop = true );

    // for state transition indicating command completion
    void checkCmdCompleteTimeout( bool issueStop = true );

    void handleException( bool awaitingResult, bool issueStop = true );

    void issueStopCommand();

    void setError( Str error );

    int getLine( Str& line, ESPComm::EspStream& stream );

    // convenience methods to facilitate testing outside of the regular LRAUV framework
    void logDebug( Str msg );
    void logError( Str msg );
    void logFault( Str msg );

};

#endif /*ESPCLIENT_H_*/