OBTTrace.cpp

Go to the documentation of this file.

#include <iostream>
#include <fstream>

#include "OBTTrace.h"
#include "OBTSingleton.h"

using namespace std ;
using namespace OBT ;

const unsigned int OBT_TRACE_CRITICAL = 
  OBT::Singleton< OBT::Tracer >::getInstance().registerId( "TRACE CRITICAL" ) ;
const unsigned int OBT_TRACE_ERROR = 
  OBT::Singleton< OBT::Tracer >::getInstance().registerId( "TRACE ERROR" ) ;
const unsigned int OBT_TRACE_WARNING = 
  OBT::Singleton< OBT::Tracer >::getInstance().registerId( "TRACE WARNING" ) ;
const unsigned int OBT_TRACE_NOTICE = 
  OBT::Singleton< OBT::Tracer >::getInstance().registerId( "TRACE NOTICE" ) ;
const unsigned int OBT_TRACE_INFO = 
  OBT::Singleton< OBT::Tracer >::getInstance().registerId( "TRACE INFO" ) ;
const unsigned int OBT_TRACE_DEBUG = 
  OBT::Singleton< OBT::Tracer >::getInstance().registerId( "TRACE DEBUG" ) ;

//-------------------------------------------------------------------------
// constructor
//-------------------------------------------------------------------------
Tracer::Tracer() 
: 
_traceAll( false ),
_traceNone( false ),
_disable( false ),
_tracedIds(),
_output( 0 )
{
}

//-------------------------------------------------------------------------
// destructor
//-------------------------------------------------------------------------
Tracer::~Tracer() 
{
        delete _output ;
    if ( _fileOut.is_open() )
    {
      _fileOut.close() ;
    }

} 

//-------------------------------------------------------------------------
// test()
//-------------------------------------------------------------------------
bool Tracer::test( const char* id) 
{
        return !_traceNone && ( _traceAll || _tracedIds.find( getHashId( id ) ) != _tracedIds.end() ) ;
}

//-------------------------------------------------------------------------
// test()
//-------------------------------------------------------------------------
bool Tracer::test( unsigned int id )
{
        return !_traceNone && ( _traceAll || _tracedIds.find( id ) != _tracedIds.end() ) ;
}

//-------------------------------------------------------------------------
// trace()
//-------------------------------------------------------------------------
void Tracer::traceWithoutTest( const char* id,
                               const char* fct, 
                                                       const char* file, 
                                                       const int line, 
                                                       const char* msg ) 
{
        // must be traced
        ostringstream stream ;
#ifdef _MSC_VER
  // The debug message is set for the visual studio format
        stream << "[" << id << "] in \"" << fct << "\" of " <<  file << "@" << line << endl <<  msg << endl ;
#else
  // The debug message is set for the vim format
        stream << "[" << id << "] in \"" << fct << "\" of " <<  file << " +" << line << " : " <<msg << endl ;
#endif
        // Traces the message on cerr
        if( !_disable )
        {
                cerr << stream.str() << endl ;
        }

        // Traces the message on the file, if it is defined 
        if( _fileOut.is_open() )
        {
                _fileOut << stream.str() << endl ;
                _fileOut.flush() ;
        }

        if( _output )
        {
                _output->trace( id, fct, file, line, msg ) ;
        }
}

//-------------------------------------------------------------------------
// registerId()
//-------------------------------------------------------------------------
unsigned int Tracer::registerId( const char* id ) 
{ 
  int intId = getHashId( id ) ;
  bool isNewId = _tracedIds[ intId ] != id ;
        // inserts the new id or update the values
  _tracedIds[ intId ] = id ;

  return isNewId ? intId : 0 ;
}

//-------------------------------------------------------------------------
// unregisterId()
//-------------------------------------------------------------------------
void Tracer::unregisterId( const char* id ) 
{ 
  int intId = getHashId( id ) ;
  _tracedIds.erase( intId ) ;
}

//-------------------------------------------------------------------------
// getHashId()
//-------------------------------------------------------------------------
unsigned int Tracer::getHashId( const std::string& id )
{
  unsigned int a = 64187 ;
  unsigned int b = 378533 ;
  unsigned int hashId = 0 ;
  for( std::size_t i = 0; i < id.length() ; i++ )
  {
    hashId = hashId * a + id[i] ;
    a = a * b;
  }
  return hashId ;
}
//-------------------------------------------------------------------------
// traceAll()
//-------------------------------------------------------------------------
void Tracer::traceAll( bool b ) 
{ 
        // sets the flag
        _traceAll = b ; 
}

//-------------------------------------------------------------------------
// traceNone()
//-------------------------------------------------------------------------
void Tracer::traceNone( bool b ) 
{ 
        // sets the flag
  _traceNone = b ;
}

//-------------------------------------------------------------------------
// setFile()
//-------------------------------------------------------------------------
void 
Tracer::setFile( const char* file ) 
{
        if( file )
        {
                // First close the previous file
                if ( _fileOut.is_open() )
                {
                        _fileOut.close() ;
                }

                // Open the new one
                _fileOut.open( file, ios_base::trunc ) ;
        }
}

//-------------------------------------------------------------------------
// setOutput()
//-------------------------------------------------------------------------
void 
Tracer::setOutput( TracerOutput* output, bool disable ) 
{
        // First delete the previous output
        delete _output ;
        // set the new one
        _output = output ;
        // set the disable flag
        _disable = disable && output ; // if(output == null) then enable the cerr output even if disable is true
}

---