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