OBTTrace.h

Go to the documentation of this file.

#ifndef TRACE_H
#define TRACE_H

#include <set>
#include <map>
#include <string>
#include <sstream>
#include <fstream>

#include "OBT.h"
#include "OBTSingleton.h"
#include "OBT_Exception.h"

namespace OBT
{
class OBT_API TracerOutput 
{
        friend class Tracer ;

protected:

        virtual ~TracerOutput() {}

  virtual void trace( const char* id,
                      const char* fct, 
                      const char* file, 
                      const int line, 
                      const char* msg ) 
  {
    std::ostringstream stream ;
#ifdef _MSC_VER
    // The debug message is set for the visual studio format
    stream << "[" << id << "] in \"" << fct << "\" of " <<  file << "@" << line << std::endl << msg << std::endl ;
#else
    // The debug message is set for the vim format
    stream << "[" << id << "] in \"" << fct << "\" of " <<  file << " +" << line <<     " : " <<msg << std::endl ;
#endif
    trace( stream.str() ) ; 
  }
  virtual void trace( const std::string& msg ) {} ;
} ;

class OBT_API Tracer 
{
        friend class Singleton< Tracer > ;

public:

        unsigned int registerId( const char* id ) ;

  void unregisterId( const char* id ) ;

        void traceAll( bool b = true ) ;

        void traceNone( bool b = true ) ;

        void setFile( const char* file = 0 ) ;

        void setOutput( TracerOutput* output, bool disable ) ;

        void trace(     const char* id, 
                                const char* fct, 
                                const char* file, 
                                const int line, 
                                const char* msg ) { if ( test( id ) )   { traceWithoutTest( id, fct, file, line, msg ) ; } }
        void trace(     unsigned int id, 
                                const char* fct, 
                                const char* file, 
                                const int line, 
                                const char* msg ) { if ( test( id ) )   { traceWithoutTest( _tracedIds[ id ].c_str(), fct, file, line, msg ) ; } }
  bool test( const char* id ) ;
        bool test( unsigned int id ) ;

        ~Tracer() ;

protected:
        Tracer() ;

        std::ofstream _fileOut ;        

        bool _traceAll ;
        bool _traceNone ;

        bool _disable ;

  std::map< unsigned int, std::string > _tracedIds ;

        TracerOutput* _output ;

        void traceWithoutTest( const char* id,
              const char* fct, 
                                      const char* file, 
                                      const int line, 
                                      const char* msg ) ;
  unsigned int getHashId( const std::string& id ) ;
} ; 
template class OBT_API Singleton< Tracer > ;
} // namespace OBT
//-------------------------------------------------------------------------
// UTILITY TRACE MESSAGE IDS
//-------------------------------------------------------------------------
extern OBT_API const unsigned int OBT_TRACE_CRITICAL ;
extern OBT_API const unsigned int OBT_TRACE_ERROR ;
extern OBT_API const unsigned int OBT_TRACE_WARNING ;
extern OBT_API const unsigned int OBT_TRACE_NOTICE ;
extern OBT_API const unsigned int OBT_TRACE_INFO ;
extern OBT_API const unsigned int OBT_TRACE_DEBUG ;
//-------------------------------------------------------------------------
// UTILITY TRACE MACROS
//-------------------------------------------------------------------------
#define TRACE( ID, MSG ) \
{ \
  OBT::Tracer& tracer = OBT::Singleton< OBT::Tracer >::getInstance() ; \
        try \
        { \
    if( tracer.test( ID ) ) \
    { \
                  std::ostringstream msgForDebugTRACE ; \
                  msgForDebugTRACE << MSG ; \
                  tracer.trace( ID, __FUNCTION__, __FILE__, __LINE__, msgForDebugTRACE.str().c_str() ); \
    } \
        } \
        catch ( OBT::OBT_Exception& exception ) \
        { \
                tracer.trace( ID, __FUNCTION__, __FILE__, __LINE__, exception.what() ); \
        } \
}

#define TRACE_CRITICAL( MSG ) TRACE( OBT_TRACE_CRITICAL, MSG )

#define TRACE_ERROR( MSG ) TRACE( OBT_TRACE_ERROR, MSG )

#define TRACE_WARNING( MSG ) TRACE( OBT_TRACE_WARNING, MSG )

#define TRACE_NOTICE( MSG ) TRACE( OBT_TRACE_NOTICE, MSG )

#define TRACE_INFO( MSG ) TRACE( OBT_TRACE_INFO, MSG )

#define TRACE_DEBUG( MSG ) TRACE( OBT_TRACE_DEBUG, MSG )

#endif // TRACE_H

---