ZMexLogger.h

Go to the documentation of this file.

#ifndef ZMEXLOGGER_H
#define ZMEXLOGGER_H
 
 
// ----------------------------------------------------------------------
//
// ZMexLogger.h - class declaration for the ZOOM Exception Logger base class
//               and the basic logger ZMexLogger, the base class 
//       ZMexLogBehavior, and behaviors supplied with the package:
//          ZMexLogNever
//          ZMexLogAlways
//          ZMexLogTwice
//          ZMexLogViaParent
//          ZMexValidationStyle
//
// Revision History:
//  970917  WEB Updated per code review 2
//  970919  WEB Updated per code review 4
//  971007  WEB Removed limiting logger; all loggers now
//          optionally limit by exception severity
//  971008  WEB ZMutility is the new name for the Utility package
//      971112  WEB Updated for conformance to standard and the zoom
//          compatability headers
//  971211  WEB Updated per code walkthrough
//      971215  WEB     Removed unused 2nd parm to ZMexLogger constructor
//  980615  WEB Added namespace support
//  010410  MF  Added ZMexValidationStyle
//
// ----------------------------------------------------------------------
 
#ifndef STRING_INCLUDED
  #define STRING_INCLUDED
  #include <string>
#endif
 
#include <iostream>
 
#ifndef ZMEXLOGRESULT_H
  #include "CLHEP/Exceptions/ZMexLogResult.h"
#endif
 
#ifndef ZMHANDLETO_H
  #include "CLHEP/RefCount/ZMhandleTo.h"
#endif
 
 
// ----------------------------------------------------------------------
 
 
namespace zmex  {
 
 
// ----------------------------------------------------------------------
 
 
class ZMexLogger;
class ZMexception;
 
 
// ----------------------------------------------------------------------
 
 
// ---------------
// ZMexLogBehavior
// ---------------
 
class ZMexLogBehavior  {
  // Logger behavior interface class
 
public:
 
  ZMexLogBehavior();
    // Construct this behavior
 
  virtual ~ZMexLogBehavior();
    // Destroy this behavior
 
  virtual ZMexLogBehavior *  clone() const;
    // Duplicate this logger object
 
  virtual ZMexLogResult  emit( const ZMexception & x );
    // Extract the formatted message, then
    // carry out this logger's basic logging behavior
 
  virtual ZMexLogResult  emit( const std::string & s );
    // Carry out this logger's basic logging behavior
    // Do nothing with s; this base class function ought never be called
 
  virtual bool isTimeDesired()     const;
  virtual bool isFilePathDesired() const;
 
};  // ZMexLogBehavior
 
 
␌
// ------------
// ZMexLogNever
// ------------
 
class ZMexLogNever  :  public ZMexLogBehavior  {
 
public:
 
  ZMexLogNever();
    // Construct this behavior
 
  virtual ~ZMexLogNever();
    // Destroy this behavior
 
  virtual ZMexLogResult  emit( const ZMexception & x );
    // Extract the formatted message, then
    // carry out this logger's basic logging behavior
 
  virtual ZMexLogNever *  clone() const;
    // Duplicate this logger object
 
  virtual ZMexLogResult  emit( const std::string & s );
    // Carry out this logger's basic logging behavior: do nothing with s
 
};  // ZMexLogNever
 
 
// -------------
// ZMexLogAlways
// -------------
 
class ZMexLogAlways  :  public ZMexLogBehavior  {
 
public:
 
  ZMexLogAlways();
  ZMexLogAlways( std::ostream & os );
    // Construct this behavior with given destination
 
  virtual ~ZMexLogAlways();
    // Destroy this behavior
 
  virtual ZMexLogAlways *  clone() const;
    // Duplicate this logger object
 
  virtual ZMexLogResult  emit( const ZMexception & x );
    // Extract the formatted message, then
    // carry out this logger's basic logging behavior
 
  virtual ZMexLogResult  emit( const std::string & s );
    // Carry out this logger's basic logging behavior: myOs << s
 
private:
 
  std::ostream &  myOs;
    // This logger's destination for messages to be logged
 
};  // ZMexLogAlways
 
 
// -------------
// ZMexLogTwice
// -------------
 
class ZMexLogTwice  :  public ZMexLogBehavior  {
 
public:
 
  ZMexLogTwice( std::ostream & os1 );
  ZMexLogTwice( std::ostream & os1, std::ostream & os2 );
    // Construct this behavior with given destinations
 
  virtual ~ZMexLogTwice();
    // Destroy this behavior
 
  virtual ZMexLogTwice *  clone() const;
    // Duplicate this logger object
 
  virtual ZMexLogResult  emit( const ZMexception & x );
    // Extract the formatted message, then
    // carry out this logger's basic logging behavior
 
  virtual ZMexLogResult  emit( const std::string & s );
    // Carry out this logger's basic logging behavior: os_ << s, os2_ << s
 
private:
 
  std::ostream &  myOs1;
  std::ostream &  myOs2;
 
};  // ZMexLogTwice
 
 
// ----------------
// ZMexLogViaParent
// ----------------
 
class ZMexLogViaParent  :  public ZMexLogBehavior  {
 
public:
 
  ZMexLogViaParent();
    // Construct this behavior
 
  virtual ~ZMexLogViaParent();
    // Destroy this behavior
 
  virtual ZMexLogViaParent *  clone() const;
    // Duplicate this logger object
 
  virtual ZMexLogResult  emit( const ZMexception & x );
    // Extract the formatted message, then
    // carry out this logger's basic logging behavior
 
  virtual ZMexLogResult  emit( const std::string & s );
    // Carry out this logger's basic logging behavior: defer elsewhere
 
};  // ZMexLogViaParent
 
 
// -----------------
// ZMexValidationStyle
// -----------------
 
class ZMexValidationStyle  :  public ZMexLogBehavior  {
 
public:
 
  ZMexValidationStyle();
  ZMexValidationStyle( std::ostream & os );
    // Construct this behavior with given destination
 
  virtual ~ZMexValidationStyle();
    // Destroy this behavior
 
  virtual ZMexValidationStyle * clone() const;
    // Duplicate this logger object
 
  virtual ZMexLogResult  emit( const ZMexception & x );
    // Extract the formatted message, then
    // carry out this logger's basic logging behavior
 
  virtual ZMexLogResult  emit( const std::string & s );
    // Carry out this logger's basic logging behavior: myOs << s
 
  virtual bool isTimeDesired()     const;
  virtual bool isFilePathDesired() const;
 
private:
 
  std::ostream &  myOs;
    // This logger's destination for messages to be logged
 
};  // ZMexValidationStyle
 
//************
// ZMexLogger
//************
 
 
class ZMexLogger  :  public ZMhandleTo< ZMexLogBehavior >  {
  // Class defining logger interface
 
public:
 
  ZMexLogger( const ZMexLogBehavior & desiredBehavior );
    // Construct logger with specified behavior
 
  ~ZMexLogger();
    // Destroy logger with its behavior
 
  ZMexLogResult  emit( const ZMexception & exc );
    // Hand over the exception for formatting and log entry
 
  ZMexLogResult  emit( const std::string & message );
    // Hand over the given string (or char*) for log entry
 
  ZMexLogBehavior *  control();
    // Grant access to the representation
    // to permit calling specialized behavior functions
 
};  // ZMexLogger
 
 
// ----------------------------------------------------------------------
 
 
}  // namespace zmex
 
 
// ----------------------------------------------------------------------
 
 
#endif  // ZMEXLOGGER_H