MeVis/Foundation/Sources/MLUtilities/mlErrorOutput.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
#ifndef __mlErrorOutput_H
#define __mlErrorOutput_H

#ifndef __mlUtilsSystem_H
#include "mlUtilsSystem.h"
#endif
#ifndef __mlUtilsAPI_H
#include "mlUtilsAPI.h"
#endif
#ifndef __mlMutex_H
#include "mlMutex.h"
#endif



//-----------------------------------------------------------------------------------
//   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  = NULL, 
                        const RuntimeType *dumpObjRT= NULL, 
                        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  = NULL, 
                        const RuntimeType *dumpObjRT= NULL
                        ) 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