ErrLog.cc

//--------------------------------------------------------------------------
//
// Description:
//
//  Error & logging abstract base class
//
// Environment:
//	Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//	Bob Jacobsen
//      $Id: ErrLog.cc,v 1.1.1.1 2005/03/29 17:04:19 steinke Exp $
//
// Copyright Information:
//	Copyright (C) 1998	Lawrence Berkeley Laboratory
//
//------------------------------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------
#include "ErrLogger/ErrLog.hh"

//-----------------
// C/C++ Headers --
//-----------------
#include <string.h>
#include <assert.h>

#include <iostream>
#include <sstream>
#include <string>
#include <cstdlib>

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "ErrLogger/ErrStreamWrapper.hh"
#include "ErrLogger/ErrOpt.hh"
#include "ErrLogger/ErrOptParser.hh"
using std::cerr;
using std::cout;
using std::ios;
using std::ostream;
using std::ostringstream;
using std::stringstream;


//		--------------------------------
// 		-- Local Variable Definitions --
//		--------------------------------
static ostringstream devnull;

//		---------------------------------
// 		-- Global Variable Definitions --
//		---------------------------------

//		---------------------------------
// 		-- Global Function Definitions --
//		---------------------------------


// static size_t
// strnlen( const char* string, size_t maximum )
// {
//   for ( size_t length = 0; length < maximum; length++ ) {
//     if (string[length] == '\0') return length;
//   }
//   return maximum;
// }



ErrLog::ErrLog( ErrLog::Severity minSeverity )
  : _useStdio(true)
  , _useStdioOpt( new ErrOptRef<bool>("stdio", ErrOpt::Optional, _useStdio) )
  , _itsErrOptParser( new ErrOptParser )
{
  // It is assumed that any subclass constructor calling this protected
  // constructor will be establishing itself as the active ErrLog instance.
  // So we allow it to set the default minimum severity in the static front
  // end to ErrLog.
  _minSeverity = minSeverity;
}


ErrLog::~ErrLog()
{
  delete _itsErrOptParser;
  delete _useStdioOpt;
}


ostream& 
ErrLog::msg( ErrLog::Severity severity, 
	     const char* facility, 
	     int code )
{
  if ( ErrStream::activeStream() != 0 
       && ErrStream::activeStream()->inUse() ) {
    // A new message is being started before the last one has been
    // completed with endmsg.

    // 1) Flush what has come of the original message so far.
    // 2) Optionally write a warning about this.
    // 3) Continue on to establish the new message.

    // 1) We complete the previous pending message.  This is important so
    //    that, if it's buffered, it will be written with its original
    //    severity and other parameters.
    ErrStream* prevStream = ErrStream::activeStream();

    if ( _nestedWarnings ) {
      static_cast<ostream&>(*prevStream) 
	<< " [interrupted by nested message from " << facility << "]";
    }
    endmsg( *prevStream );

    if ( _nestedWarnings ) {
      // 2) Warn about this usage.
      
      // Need to trap the facility and code, because they will be 
      // overwritten by the ErrMsg call itself.
      std::string prevFacility( prevStream->facility() );
      int prevCode = prevStream->code();

      ErrMsg(warning) << "\n *** ErrLogger Warning *** \n"
		      << "The ErrStream was previously used without\n"
		      << "endmsg being called to end the error message.\n"
		      << "Please see ErrLogger/ErrStream.hh for more\n"
		      << "information.\n\n"
		      << " Error Location/Facility: " << prevFacility
		      << " [code " << prevCode << "]\n"
		      << " *** ErrLogger Warning Finished ***\n"
		      << endmsg;
    }

    // 3) Now we can proceed.
  }

  // initialize result
  ErrStream* resultPtr = 0;

  if (_implementation() != 0) {
    resultPtr = & ( _implementation()->doMsg( severity, facility, code ) );
  }
  else {
    resultPtr = _getDefaultStream( severity, facility, code );
  } // end else

  // check that resultPtr is set
  assert( resultPtr!=0 );

  // Save the message parameters.
  _setParameters( *resultPtr, severity, facility, code );

  resultPtr->activate();

  // mark this stream as in use
  resultPtr->setInUse(true);
      
  return static_cast<ostream&>( *resultPtr );
}



ostream& 
ErrLog::msg( ErrLog::Severity severity, 
	     const char* facility, 
	     const char* code )
{
  // This implementation is provided for backward compatibility with the
  // old, misunderstanding-derived notion that the "const char* code"
  // form of msg() should be the primary one.  Now (June 2002) that we
  // have switched to the original intent, where "int code" is the 
  // primary interface, we still provide this interface, in a way which
  // does almost exactly what the old one did in practice in all the
  // existing ErrLog implementations: append "(" + code + ")" to the
  // facility.

  std::string newfac( facility );
  newfac += "(";
  newfac += code;
  newfac += ")";

  return ErrLog::msg( severity, newfac.c_str(), 0 );
}


bool
ErrLog::logging( ErrLog::Severity severity, 
		 const char* facility, 
		 const char* code )
{
  // See msg( ErrLog::Severity severity, const char* facility, 
  //          const char* code ) above.  Note that these string
  // manipulations are a lot of work to do if you just want to check 
  // to see whether a particular class of message is being logged!

  std::string newfac( facility );
  newfac += "(";
  newfac += code;
  newfac += ")";

  return ErrLog::logging( severity, newfac.c_str(), 0 );
}



const char*
ErrLog::severityName( ErrLog::Severity severity )
{
  switch ( severity ) {
  case ErrLog::debugging:
    return "debugging";
  case ErrLog::trace:
    return "trace";
  case ErrLog::routine:
    return "routine";
  case ErrLog::warning:
    return "warning";
  case ErrLog::error:
    return "error";
  case ErrLog::severe:
    return "severe";
  case ErrLog::fatal:
    return "fatal";
  }

  return "?invalid-severity?";
}



char
ErrLog::severityLetter( ErrLog::Severity severity )
{
  switch ( severity ) {
  case ErrLog::debugging:
    return 'D';
  case ErrLog::trace:
    return 'T';
  case ErrLog::routine:
    return 'R';
  case ErrLog::warning:
    return 'W';
  case ErrLog::error:
    return 'E';
  case ErrLog::severe:
    return 'S';
  case ErrLog::fatal:
    return 'F';
  }

  return '?';
}



bool 
ErrLog::doLogging( ErrLog::Severity severity,
		   const char* facility,
		   int code )
{
  return ErrLog::_getDefaultLogging( severity, facility, code );
}


ErrStream* 
ErrLog::_getDefaultStream( ErrLog::Severity severity,
			   const char* facility,
			   int code )
{
  // initialize result
  ErrStream* result = 0;

  // here use the default implementation
  if ( _myStreamCerr==0 )
    _myStreamCerr = new ErrStreamWrapper(cerr);
  if ( _myStreamCout==0 )
    _myStreamCout = new ErrStreamWrapper(cout);
  if ( _myDevnull==0 )
    _myDevnull    = new ErrStreamWrapper(devnull);

  // select which stream to write to
  if ( logging( severity, facility, code ) ) {
    // pick the correct stream
    if ( severity>=warning )
      result = _myStreamCerr;
    else
      result = _myStreamCout;
  } // end if logging
  else { // not logging
    // send to local char stream after resetting to start over
    devnull.rdbuf()->pubseekoff(0, ios::beg,ios::out);
    result = _myDevnull;
  } // end if

  return result;
}


void
ErrLog::_setParameters( ErrStream& es,
			ErrLog::Severity severity,
			const char* facility,
			int code )
{
  es.setParameters( severity, facility, code );
}

void
ErrLog::_defaultTermination( ErrLog::Severity severity, 
			     int code )
{
  _executeDefaultTermination( _getDefaultTermination( severity, code ) );
}

int
ErrLog::_getDefaultTermination( ErrLog::Severity severity, 
				int code )
{
  int result = 0;
  if ( severity == ErrLog::severe ) {
    // Default behavior for this level is to exit with a non-zero status.
    // That status is determined based on the "code".  For a code of zero,
    // the default exit code is used.
    if ( code == 0 ) {
      result = DefaultExitCode;
    }
    else {
      // Otherwise we take the low-order seven bits of the "code", so
      // that we stay in the range shells understand as exit()-driven
      // process terminations.
      result = code & 0x7f;

      // Except we never allow that to be zero, either.  We assign a
      // special code as a warning.
      if ( result == 0 ) result = DefaultExitCode - 1;
    }
  }
  else if ( severity == ErrLog::fatal ) {
    // Return the value that indicates "abort".
    result = -1;
  }

  return result;
}

void
ErrLog::_executeDefaultTermination( int value )
{
  if ( value == -1 ) ::abort();
  else if ( value > 0 ) ::exit( value );
}

void
ErrLog::turnOffWarnings()
{
  _nestedWarnings = false;
}

bool
ErrLog::_configureOptions()
{
  bool ok = true;
  ok = ok && _errOptParser().registerNegatableOption( *_useStdioOpt );
  return ok;
}

bool 
ErrLog::parseOpts( const char* optarg ) 
{
  return _errOptParser().parseOpts(optarg);
}


// Protected static member initializers.

ErrStream*       ErrLog::_myStreamCerr = 0;
ErrStream*       ErrLog::_myStreamCout = 0;
ErrStream*       ErrLog::_myDevnull = 0;
ErrLog::Severity ErrLog::_minSeverity = ErrLog::debugging;


// Private static member initializers.

ErrLog*          ErrLog::_implInstance   = 0;
bool             ErrLog::_nestedWarnings = true;