mlErrorOutput.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_ERROR_OUTPUT_H
#define ML_ERROR_OUTPUT_H

 
#include "mlUtilsSystem.h"
#include "mlUtilsAPI.h"
#include "mlMutex.h"
#include "mlTrace.h"
 
 
//-----------------------------------------------------------------------------------
//   Forward declarations.
//-----------------------------------------------------------------------------------
ML_UTILS_START_NAMESPACE

  class ErrorOutput;
 
ML_UTILS_END_NAMESPACE
 
 
ML_START_NAMESPACE
  class State;
ML_END_NAMESPACE
 
 
 
//-----------------------------------------------------------------------------------
//   Stream output for std::ostream
//-----------------------------------------------------------------------------------
namespace std {

  ML_UTILS_EXPORT ostream& operator<<(ostream& s, const ML_UTILS_NAMESPACE::ErrorOutput &errorOutput);
}
 
 
 
 
ML_UTILS_START_NAMESPACE
 
  //---------------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------------
  class ErrorOutputInfos;
 
  //---------------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------------
  class RuntimeType;
 
  //---------------------------------------------------------------------------------------------

  //---------------------------------------------------------------------------------------------
  class ML_UTILS_EXPORT ErrorOutput{
 
  public:
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------
    typedef void ErrorOutputCB(void *usrData,
                               const char* errStr,
                               const ErrorOutputInfos &infos);
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------
    typedef char *DumpCB(const void *dumpObj, const RuntimeType *dumpObjRT);
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------
    ErrorOutput();
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------
    ~ErrorOutput();
 
    //-----------------------------------------------------------------------------------
    //-----------------------------------------------------------------------------------
    void reset();
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------
    void init();

    void destroy();
 
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------

    void         setTerminationType(MLMessageType level, MLTerminator term);

    MLTerminator getTerminationType(MLMessageType level) const;
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------
    void         setMessageFilter(MLuint32 messageType);

    MLuint32     getMessageFilter();
 
 
    //-----------------------------------------------------------------------------------
    //-----------------------------------------------------------------------------------
    void          setDumpCB(DumpCB *dumpCB);

    DumpCB       *getDumpCB() const;
 
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------
    void setFullDebuggingOn(bool on);

    bool isFullDebuggingOn() const;
 
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------
    void addErrorOutputCB(void *userData, ErrorOutputCB *callback);

    void removeErrorOutputCB(void *userData, ErrorOutputCB *callback);

    bool hasErrorOutputCB(void *userData, ErrorOutputCB *callback) const;

    void removeAllErrorOutputCBs();

    size_t getNumOutputCBs() const { return _errorOutputCBList.size(); }
 
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------
    void addDebugEnvName(const std::string &envName);

    void removeDebugEnvName(const std::string &envName);

    bool hasDebugEnvName(const std::string &envName) const;

    const std::vector<std::string> &getDebugEnvNames() const;

    void removeAllDebugEnvNames();

    size_t getNumDebugEnvNames() const;
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------

    void setOutputMessagesInVisualStudio(bool flag) { _outputMessagesInVisualStudio = flag; }

    bool shouldOutputMessagesInVisualStudio() const { return _outputMessagesInVisualStudio; }

 
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------
    bool areMessagesSentToCout() const { return _sendToCout; }

    void sendMessagesToCout(bool on);

    bool areMessagesSentToCerr() const { return _sendToCerr; }

    void sendMessagesToCerr(bool on);
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------
    MLuint32       getMaxNumTraceListDumps() const                       { return _maxNumTraceListDumps; }

    void           setMaxNumTraceListDumps(MLGlobalTraceBufferType num);

    MLuint32       getMaxNumTraceStackDumps() const                      { return _maxNumTraceStackDumps; }

    void           setMaxNumTraceStackDumps(MLGlobalTraceBufferType num);

    MLuint32       getTraceDumpMessageBits() const                       { return _traceDumpMessageBits; }

    void           setTraceDumpMessageBits(MLuint32  bitMask);
 
 
    // -------------------------------------------------------------------------------------------
    // -------------------------------------------------------------------------------------------

    //      ErrorOutput::printAndNotify(ML_WARNING,                        // message type
    //                                  "ML_",                             // Library prefix
    //                                  "Function=",                       // function prefix
    //                                  "MyFunction",                      // functionName
    //                                  "MyFunction had an overflow",      // reason
    //                                  "I will do nothing to handle it",  // handling
    //                                  __FILE__,                          // file
    //                                  __LINE__);                         // line
    //                                  NULL,                              // no runtime object to be dumped
    //                                  NULL,                              // no runtime type of any object
    //                                  ML_CALCULATION_ERROR);             // line
    void printAndNotify(MLMessageType      messageType,
                        const std::string &libraryPrefix,
                        const std::string &fPrefix,
                        const std::string &functionName,
                        const std::string &reason,
                        const std::string &handling = "",
                        const std::string &file     = "",
                        int                line     = -1,
                        const void        *dumpObj  = nullptr,
                        const RuntimeType *dumpObjRT= nullptr,
                        MLErrorCode        errCode  = ML_RESULT_OK) const;

    void printAndNotify(MLMessageType      messageType,
                        const std::string &libraryPrefix,
                        const std::string &fPrefix,
                        const std::string &functionName,
                        MLErrorCode        reason,
                        const std::string &handling = "",
                        const std::string &file     = "",
                        int                line     = -1,
                        const void        *dumpObj  = nullptr,
                        const RuntimeType *dumpObjRT= nullptr
                        ) const;

    void handleDebugPrint(const std::string &envVar,
                          const std::string &libraryPrefix,
                          std::stringstream &reason,
                          const char *       file,
                          int                line) const;

    void handleDebugPrint(const std::string &envVar,
                          const std::string &libraryPrefix,
                          const char *       reason,
                          const char *       file,
                          int                line) const;

 
 
  protected:

    friend class ML_NAMESPACE::State;

    ErrorOutput(const ErrorOutput &errorOutput);

    ErrorOutput& operator=(const ErrorOutput &errorOutput);
 
  private:

    friend std::ostream& std::operator<<(std::ostream& s, const ErrorOutput &errorOutput);

    void _init();

    void _printConsole(const std::string &errStr, const ErrorOutputInfos &infos) const;

    std::string getTraceDump() const;

    std::streambuf             *_defaultCoutBuffer;

    std::streambuf             *_defaultCerrBuffer;

    bool                        _sendToCout;

    bool                        _sendToCerr;
 
    //---------------------------------------------------------------------------------------------
    //---------------------------------------------------------------------------------------------

    bool                        _isFullDebuggingOn;

    MLuint32                    _messageTypeBits;

    DumpCB                     *_dumpCB;
 

    MLTerminator                _infoTerm;

    MLTerminator                _warnTerm;

    MLTerminator                _errorTerm;

    MLTerminator                _fatalTerm;

    MLTerminator                _debugTerm;

    MLTerminator                _coutTerm;

    MLTerminator                _cerrTerm;

    MLTerminator                _otherTerm;

    MLGlobalTraceBufferType     _maxNumTraceListDumps;

    MLGlobalTraceBufferType     _maxNumTraceStackDumps;

    MLuint32                    _traceDumpMessageBits;

    std::vector<void*>          _errorUserDataList;

    std::vector<ErrorOutputCB*> _errorOutputCBList;

    std::vector<std::string>    _debugEnvStrings;

    mutable RecursiveMutex               _mutex;

    bool _outputMessagesInVisualStudio;

  };

  extern ML_UTILS_EXPORT ErrorOutput MLErrorOutput;
 
ML_UTILS_END_NAMESPACE
 
#endif // End of __mlErrorOutput_H