MessageLoggerDefaults.h

Go to the documentation of this file.

#ifndef MessageLogger_MessageLoggerDefaults_h
#define MessageLogger_MessageLoggerDefaults_h
 
// -*- C++ -*-
//
// Package:     MessageLogger
// Class  :     MessageLoggerDefaults
//
//
// Original Author:  M. Fischler
//         Created:  Tues Jun 14 10:38:19 CST 2007
//
 
// Framework include files
 
#include "FWCore/Utilities/interface/JobMode.h"
 
// system include files
 
#include <string>
#include <vector>
#include <map>
#include <cassert>
 
// Change log
//
// 6/15/07 mf   Original version
//
// -------------------------------------------------------
 
// user include files
 
// ----------------
// Maintenance Tips
// ----------------
//
// When default values change for one job mode of operation or another,
// implement that change in the appropriate member function implemented
// in HardwiredDefaults.cc.  For example, hardwireGridJobMode().
//
// When a new default is needed, add the item to the struct, and then place
// the default value into the appropriate sections of the various member
// functions in HardwiredDefaults.cc.
// It may be necessary to supply values of that default for each of the modes,
// even though the ErrorLogger default is suitable for all the modes but one.
//
// When the new default is of a type not already being accessed, also add
// the accessor method in this header, and implement it in
// MessageLoggerDefaults.cc following the pattern shown for existing items
 
namespace edm {
  namespace service {
 
    struct MessageLoggerDefaults {
    public:
      static const int NO_VALUE_SET = -45654;
 
      struct Category {
        std::string threshold;
        int limit;
        int reportEvery;
        int timespan;
        Category() : threshold(""), limit(NO_VALUE_SET), reportEvery(NO_VALUE_SET), timespan(NO_VALUE_SET) {}
      };
 
      struct Destination {
        std::string threshold;
        std::map<std::string, Category> category;
        std::map<std::string, Category> sev;
        std::string output;
      };
 
      // publicly available collections and structures
 
      std::vector<std::string> categories;
      std::vector<std::string> destinations;
      std::vector<std::string> fwkJobReports;
      std::vector<std::string> statistics;
      std::map<std::string, Destination> destination;
 
      // access to values set
 
      std::string threshold(std::string const& dest);
      std::string output(std::string const& dest);
 
      int limit(std::string const& dest, std::string const& cat);
      int reportEvery(std::string const& dest, std::string const& cat);
      int timespan(std::string const& dest, std::string const& cat);
 
      int sev_limit(std::string const& dest, std::string const& sev);
      int sev_reportEvery(std::string const& dest, std::string const& sev);
      int sev_timespan(std::string const& dest, std::string const& sev);
 
      // Modes with hardwired defaults
 
      void hardwireGridJobMode();
      void hardwireReleaseValidationJobMode();
      void hardwireAnalysisJobMode();
      void hardwireNilJobMode();
 
      static edm::JobMode mode(std::string const& jm);
 
      // ctor
 
      explicit MessageLoggerDefaults(edm::JobMode mode = GridJobMode) {
        // mode-independent defaults
 
        // mode-dependent defaults
        switch (mode) {
          // GridJobMode:   Intended for automated batch-like processing, in which
          //                the output stream for cerr is routed to an apropro
          //                file.  LogInfo messages are enabled, and at least
          //            one such message is delivered from the framework per
          //        event, so this mode is not suitable for many-Hz light
          //        event processing.
          case GridJobMode:
            hardwireGridJobMode();
            break;
          case ReleaseValidationJobMode:
            hardwireReleaseValidationJobMode();
            break;
          case AnalysisJobMode:
            hardwireAnalysisJobMode();
            break;
          case NilJobMode:
            hardwireNilJobMode();
            break;
          default:
            // this should never happen!  No user error can get here.
            bool Invalid_JobMode_in_ctor_of_MessageLoggerDefaults = false;
            assert(Invalid_JobMode_in_ctor_of_MessageLoggerDefaults);
        }  // end of switch on mode
      }
    };
 
  }  // end of namespace service
}  // end of namespace edm
 
#endif  // MessageLogger_MessageLoggerDefaults_h