mlProgressLogger.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
#pragma once
 
// Local includes
#include "MLReleaseToolsSystem.h"
#include "mlModuleIncludes.h"
#include "mlTimeCounter.h"
#include <FMEThirdPartyWarningsDisable.h>
#include <string>
#include <sstream>
#include <FMEThirdPartyWarningsRestore.h>
 
ML_START_NAMESPACE
 
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
class MLRELEASE_TOOLS_EXPORT ProgressLogger {
 
  public:

    typedef bool (*InterruptCheckFunc)(void *userData);
    
    enum FormatFlags {
        NoFlags = 0,
        Bold    = 1,
        Green   = 2,
        Yellow  = 4,
        Red     = 8,
        Blue    = 16
    };
    
    ProgressLogger(std::stringstream *outputStream      = nullptr,
                   NotifyField       *intCheckField     = nullptr,
                   StringField       *statusField       = nullptr,
                   bool              useRichTextCoding  = true);

    virtual ~ProgressLogger();

    void setAutoNewLineTermination(bool on);
    
    bool isAutoNewLineTerminationOn() const;
    
    virtual bool messageHook(const ProgressLogger & /*this*/,
                             MLMessageType        /*msgType*/,
                             const std::string    * /*msg*/,
                             const std::string    * /*func*/, 
                             MLErrorCode          * /*err*/, 
                             const std::string    * /*reason*/, 
                             unsigned int         * /*formatFlags*/){ return true; }

    void logAnyMessage(std::string msg, unsigned int formatFlags=NoFlags);

    void logFatalError     (const std::string &func, MLErrorCode err, const std::string &reason);
    void logError          (const std::string &func, MLErrorCode err, const std::string &reason);
    void logWarning        (const std::string &func, MLErrorCode err, const std::string &reason);

    void logInfo           (const std::string &func,                  const std::string &reason="");

    void logFullFatalError (const std::string &func, MLErrorCode err, const std::string &reason);
    void logFullError      (const std::string &func, MLErrorCode err, const std::string &reason);
    void logFullWarning    (const std::string &func, MLErrorCode err, const std::string &reason);

    void logFullInfo       (const std::string &func,                  const std::string &reason);
    
    bool getRichTextCodingFlag() const;
    void setRichTextCodingFlag(bool useRichTextCoding);
    
    bool getUpdateProgressDuringInterruptChecksFlag() const;
    void setUpdateProgressDuringInterruptChecksFlag(bool callUpdateProgressDuringInterruptChecks);

    void setStatusUpdateTimeIntervalInSeconds(double checkIntervalInSeconds);

    double getStatusUpdateTimeIntervalInSeconds() const;

    void setCheckTimeIntervalInSeconds(double checkIntervalInSeconds);

    double getCheckTimeIntervalInSeconds() const;
    
    void setInterruptCheckFunction(InterruptCheckFunc checkFunc, void *userData);
    
    InterruptCheckFunc getInterruptCheckFunction() const;
    
    void *getInterruptCheckFunctionUserData() const;

    void setInterruptCheckField(NotifyField *interruptField = nullptr);

    NotifyField*  getInterruptCheckField() const;

    void setStatusField(StringField *statusField);

    StringField* getStatusField() const;

    virtual bool wasInterrupted();
    
    virtual bool getInterruptedFlag() const;

    virtual void setInterruptedFlag(bool wasInterrupted);

    virtual bool orToInterruptedFlag(bool wasInterrupted);

    virtual void updateProgressIndicator(const std::string &/*info*/, float /*percState*/){};

    inline void setFatalErrorMessagePrefix        (const std::string &msg){ _fatalErrorPrefix = msg; }
    inline void setErrorMessagePrefix             (const std::string &msg){ _errorPrefix      = msg; }
    inline void setWarningMessagePrefix           (const std::string &msg){ _warningPrefix    = msg; }
    inline void setInfoMessagePrefix              (const std::string &msg){ _infoPrefix       = msg; }
 
    inline std::string getFatalErrorMessagePrefix () const { return _fatalErrorPrefix; }
    inline std::string getErrorMessagePrefix      () const { return _errorPrefix     ; }
    inline std::string getWarningMessagePrefix    () const { return _warningPrefix   ; }
    inline std::string getInfoMessagePrefix       () const { return _infoPrefix      ; }

    bool hadFatalError() const;
    bool hadError() const;
    bool hadWarning() const;
    bool hadInfo() const;

    void setHadFlags(bool hadFlag);

    void setHadFatalErrorFlag(bool hadFatalErrorFlag);
    void setHadErrorFlag(bool hadErrorFlag);
    void setHadWarningFlag(bool hadWarningFlag);
    void setHadInfoFlag(bool hadInfoFlag);

    static bool isPressedField(NotifyField *fieldToCheck);
 
  protected:

    std::string                                      _doAutoNewLineTerminate(const std::string &msg) const;
    
    virtual bool                                     _isStopPressed() const;

    virtual void                                     _updateConsole(bool /*fullUpdate*/=true){}

    static void                                      _updateProgressIndicatorCB(void *userData,
                                                                                const std::string &info,
                                                                                float state);
 
  private:
    
    void              _sendMessage(std::string stringToSend);
    
    bool              _autoNewLineTerminate; 
    
    std::stringstream *_outputStream;

    NotifyField       *_interruptCheckField;

    StringField       *_statusField;
    
    bool               _useRichTextCodingFlag;

    bool               _updateProgressDuringInterruptChecksFlag;
    
    bool               _wasInterrupted;
    
    std::string        _fatalErrorPrefix;
    
    std::string        _errorPrefix;
    
    std::string        _warningPrefix;
    
    std::string        _infoPrefix;

    bool               _hadFatalError;

    bool               _hadError;

    bool               _hadWarning;

    bool               _hadInfo;
    
    TimeCounter        _stopTestTimeCounter;
    
    TimeCounter        _statusUpdateTimeCounter;
    
    double             _stopTestTimeIntervalInSeconds;
    
    double             _checkStatusUpdateTimeIntervalInSeconds;

    InterruptCheckFunc _checkFunc;
    
    void              *_checkFuncUserData;
};
 
ML_END_NAMESPACE