ELseverityLevel.h

Go to the documentation of this file.

#ifndef MessageLogger_ELseverityLevel_h
#define MessageLogger_ELseverityLevel_h

// ----------------------------------------------------------------------
//
// ELseverityLevel.h - declare objects that encode a message's urgency
//
//  Both frameworker and user will often pass one of the
//  instantiated severity levels to logger methods.
//
//  The only other methods of ELseverityLevel a frameworker
//  might use is to check the relative level of two severities
//  using operator< or the like.
//
// 30-Jun-1998 mf   Created file.
// 26-Aug-1998 WEB  Made ELseverityLevel object less weighty.
// 16-Jun-1999 mf   Added constructor from string.
// 23-Jun-1999 mf   Additional ELsev_noValueAssigned to allow constructor
//          from string to give ELunspecified when not found, while
//          still allowing finding zero severity.
// 23-Jun-1999 mf   Corrections for subtleties in initialization of
//          global symbols:
//              Added ELsevLevGlobals array
//              Changed extern consts of SLseverityLevels into
//                const ELseverityLevel & 's
//              Inserted class ELinitializeGlobalSeverityObjects
//                in place of the
//                initializeGlobalSeverityObjects() function.
//              Changed globalSeverityObjectsGuarantor to an
//                ELinitializeGlobalSeverityObjects instance.
// 30-Jun-1999 mf   Modifications to eliminate problems with order of
//                      globals initializations:
//              translate(), getInputStr(), getVarName()
// 12-Jun-2000 web  Final fix to global static initialization problem
// 14-Jun-2000 web  Declare classes before granting friendship.
// 27-Jun-2000 web  Fix order-of-static-destruction problem
//
// ----------------------------------------------------------------------

#ifndef ELSTRING_H
#include "FWCore/MessageLogger/interface/ELstring.h"
#endif

namespace edm {

  // ----------------------------------------------------------------------
  // Forward declaration:
  // ----------------------------------------------------------------------

  class ELseverityLevel;

#ifndef __ROOTCLING__
  // ----------------------------------------------------------------------
  // Synonym for type of ELseverityLevel-generating function:
  // ----------------------------------------------------------------------

  typedef ELseverityLevel const ELslGen();

  // ----------------------------------------------------------------------
  // ELslProxy class template:
  // ----------------------------------------------------------------------

  template <ELslGen ELgen>
  struct ELslProxy {
    // --- birth/death:
    //
    ELslProxy();
    ~ELslProxy();

    // --- copying:
    //
    ELslProxy(ELslProxy const&);
    ELslProxy const& operator=(ELslProxy const&);

    // --- conversion::
    //
    operator ELseverityLevel const() const;

    // --- forwarding:
    //
    int getLevel() const;
    const ELstring getSymbol() const;
    const ELstring getName() const;
    const ELstring getInputStr() const;
    const ELstring getVarName() const;

  };  // ELslProxy<ELslGen>
#endif

  // ----------------------------------------------------------------------

  // ----------------------------------------------------------------------
  // ELseverityLevel:
  // ----------------------------------------------------------------------

  class ELseverityLevel {
  public:
    // ---  One ELseverityLevel is globally instantiated (see below)
    // ---  for each of the following levels:
    //
    enum ELsev_ {
      ELsev_noValueAssigned = 0  // default returned by map when not found
      ,
      ELsev_zeroSeverity  // threshold use only
      ,
      ELsev_success  // report reaching a milestone
      ,
      ELsev_info  // information
      ,
      ELsev_warning  // warning
      ,
      ELsev_error  // error detected
      ,
      ELsev_unspecified  // severity was not specified
      ,
      ELsev_severe  // future results are suspect
      ,
      ELsev_highestSeverity  // threshold use only
      // -----
      ,
      nLevels  // how many levels?
    };         // ELsev_

    // -----  Birth/death:
    //
    ELseverityLevel(ELsev_ lev = ELsev_unspecified);
    ELseverityLevel(ELstring const& str);
    // str may match getSymbol, getName, getInputStr,
    // or getVarName -- see accessors
    ~ELseverityLevel();

    // -----  Comparator:
    //
    int cmp(ELseverityLevel const& e) const;

    // -----  Accessors:
    //
    int getLevel() const;
    const ELstring getSymbol() const;    // example: "-e"
    const ELstring getName() const;      // example: "Error"
    const ELstring getInputStr() const;  // example: "ERROR"
    const ELstring getVarName() const;   // example: "ELerror"

    // -----  Emitter:
    //
    friend std::ostream& operator<<(std::ostream& os, const ELseverityLevel& sev);

  private:
    // Data per ELseverityLevel object:
    //
    int myLevel;

  };  // ELseverityLevel

#ifndef __ROOTCLING__
  // ----------------------------------------------------------------------
  // Declare the globally available severity objects,
  // one generator function and one proxy per non-default ELsev_:
  // ----------------------------------------------------------------------

  extern ELslGen ELzeroSeverityGen;
  extern ELslProxy<ELzeroSeverityGen> const ELzeroSeverity;

  extern ELslGen ELdebugGen;
  extern ELslProxy<ELdebugGen> const ELdebug;

  extern ELslGen ELinfoGen;
  extern ELslProxy<ELinfoGen> const ELinfo;

  extern ELslGen ELwarningGen;
  extern ELslProxy<ELwarningGen> const ELwarning;

  extern ELslGen ELerrorGen;
  extern ELslProxy<ELerrorGen> const ELerror;

  extern ELslGen ELunspecifiedGen;
  extern ELslProxy<ELunspecifiedGen> const ELunspecified;

  extern ELslGen ELsevereGen;
  extern ELslProxy<ELsevereGen> const ELsevere;

  extern ELslGen ELhighestSeverityGen;
  extern ELslProxy<ELhighestSeverityGen> const ELhighestSeverity;
#else
  ELseverityLevel const ELzeroSeverity;
  ELseverityLevel const ELdebug;
  ELseverityLevel const ELinfo;
  ELseverityLevel const ELwarning;
  ELseverityLevel const ELerror;
  ELseverityLevel const ELunspecified;
  ELseverityLevel const ELsevere;
  ELseverityLevel const ELhighestSeverity;
#endif

  // ----------------------------------------------------------------------
  // Comparators:
  // ----------------------------------------------------------------------

  extern bool operator==(ELseverityLevel const& e1, ELseverityLevel const& e2);
  extern bool operator!=(ELseverityLevel const& e1, ELseverityLevel const& e2);
  extern bool operator<(ELseverityLevel const& e1, ELseverityLevel const& e2);
  extern bool operator<=(ELseverityLevel const& e1, ELseverityLevel const& e2);
  extern bool operator>(ELseverityLevel const& e1, ELseverityLevel const& e2);
  extern bool operator>=(ELseverityLevel const& e1, ELseverityLevel const& e2);

  // ----------------------------------------------------------------------

}  // end of namespace edm

// ----------------------------------------------------------------------

#ifndef __ROOTCLING__
#define ELSEVERITYLEVEL_ICC
#include "FWCore/MessageLogger/interface/ELseverityLevel.icc"
#undef ELSEVERITYLEVEL_ICC
#endif

// ----------------------------------------------------------------------

#endif  // MessageLogger_ELseverityLevel_h