/data/refman/pasoursint/CMSSW_5_3_10/src/FWCore/MessageService/interface/MessageLoggerScribe.h

Go to the documentation of this file.

#ifndef FWCore_MessageService_MessageLoggerScribe_h
#define FWCore_MessageService_MessageLoggerScribe_h

#include "FWCore/Utilities/interface/value_ptr.h"

#include "FWCore/MessageService/interface/ELdestControl.h"
#include "FWCore/MessageService/interface/MsgContext.h"
#include "FWCore/MessageService/interface/MessageLoggerDefaults.h"
#include "FWCore/MessageLogger/interface/MessageLoggerQ.h"
#include "FWCore/MessageLogger/interface/AbstractMLscribe.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "boost/shared_ptr.hpp"

#include <iosfwd>
#include <vector>
#include <map>

#include <iostream>

namespace edm {
namespace service {       

// ----------------------------------------------------------------------
//
// MessageLoggerScribe.h
//
// Changes:
//
//   1 - 2/6/07  mf     
//      Set up ability to get a remembered pointer to the ErrorLog of an
//      instance of MessageLoggerScribe, from a non-member function, via
//      getErrorLog_ptr(), and a corresponding routine to remember the pointer
//      as setStaticErrorLog_ptr().  Needed if we decide to send an explicit 
//      message from the scribe.
//
//   2 - ?/?/? before 3/1/07 jm
//       Modify parameter getting template so as not to catch tracked ones
//       (that is, to crash if user mistakenly does not say untracked)
//
//   3 - 3/13/07 mf
//       Added configure_ordinary_destinations, configure_fwkJobReports,
//       and configure_statistics to allow these to be broken out of 
//       configure_errorlog.    
//
//   4 - 3/26/07 mf
//       Added configure_default_fwkJobReport, which implements the config
//       originally placed in the .cfi file.
//
//   5 - 6/15/07 mf
//       Accommodations for use of MessageLoggerDefault structure 
//
//   6 - 7/24/07 mf
//       Instace variable indicating that we really are logging what is sent.
//       This is to be able to supress the <generator> info sent at exit by
//       the JobReport, in the case where no .cfg file was given.
//
//   7 - 4/8/08 mf
//       Modified getAparameter behavior when tracked parameter is found,
//       for nicer output message. 
//
//   8 - 6/19/08 mf
//       triggerFJRmessageSummary
//
//   9 - 10/21/08 mf
//       variables and routines in preparation for single-thread
//
//  10 - 10/22/08 mf
//       derivation from AbstractMLscribe to allow for single-thread calling
//       from MessageLoggerQ without introducing coupling to MessageService
//
//  11 - 5/26/09 mf
//       restore getAparameter behavior to NOT throw for tracked, since
//       now this will be caught when validating the PSet.
//
//  12 - 8/10/09 mf, cj
//       member data  to hold shared pointer to thread queue
//
// -----------------------------------------------------------------------

class ThreadQueue;
class ErrorLog;
class ELadministrator;

class MessageLoggerScribe : public AbstractMLscribe
{
public:
  // ---  birth/death:
  
  // ChangeLog 12
  explicit MessageLoggerScribe(boost::shared_ptr<ThreadQueue> queue);
  
  virtual ~MessageLoggerScribe();

  // --- receive and act on messages:
  virtual
  void  run();
  virtual                                                       // changelog 10
  void  runCommand(MessageLoggerQ::OpCode  opcode, void * operand);
                                                                // changeLog 9

  // --- obtain a pointer to the errorlog 
  static ErrorLog * getErrorLog_ptr() {return static_errorlog_p;}
  
private:
  // --- convenience typedefs
  typedef std::string          String;
  typedef std::vector<String>  vString;
  typedef ParameterSet         PSet;

  // --- log one consumed message
  void log(ErrorObj * errorobj_p);

  // --- cause statistics destinations to output
  void triggerStatisticsSummaries();
  void triggerFJRmessageSummary(std::map<std::string, double> & sm);
  
  // --- handle details of configuring via a ParameterSet:
  void  configure_errorlog( );
  void  configure_fwkJobReports( );                             // Change Log 3
  void  configure_ordinary_destinations( );                     // Change Log 3
  void  configure_statistics( );                                // Change Log 3
  void  configure_dest( ELdestControl & dest_ctrl               
                      , String const &  filename
                      );
  void  configure_default_fwkJobReport( ELdestControl & dest_ctrl); //ChangeLog 4
  void  configure_external_dests( );

#define VALIDATE_ELSEWHERE                                      // ChangeLog 11

#ifdef OLDSTYLE
  template <class T>
  T getAparameter ( PSet const& p, std::string const & id, T const & def ) 
  {
    T t;
    try { 
      t = p.template getUntrackedParameter<T>(id, def);
    } catch (...) {
      t = p.template getParameter<T>(id);
      std::cerr << "Tracked parameter " << id 
                << " used in MessageLogger configuration.\n"
                << "Use of tracked parameters for the message service "
                << "is deprecated.\n"
                << "The .cfg file should be modified to make this untracked.\n";
    }
    return t;
  }
#else
#ifdef SIMPLESTYLE
  template <class T>
  T getAparameter ( PSet const& p, std::string const & id, T const & def ) 
  {
    T t;
    t = p.template getUntrackedParameter<T>(id, def);
    return t;
  }                                                             // changelog 2
#else
#ifdef VALIDATE_ELSEWHERE
  template <class T>                                            // ChangeLog 11
  T getAparameter ( PSet const& p, std::string const & id, T const & def ) 
  {
    T t = def;
    try { 
      t = p.template getUntrackedParameter<T>(id, def);
    } catch (...) {
      try {
        t = p.template getParameter<T>(id);
      } catch (...) {
        // Since PSetValidation will catch such errors, we simply proceed as
        // best we can in case we are setting up the logger just to contain the 
        // validation-caught error messages. 
      }
    }
    return t;
  }
#else  // Do not tolerate errors
  template <class T>
  T  getAparameter ( PSet const& p, std::string const & id, T const & def ) 
  {                                                             // changelog 7
    T t;
    try { 
      t = p.template getUntrackedParameter<T>(id, def);
    } catch (cms::Exception& e) {
      try {
        t = p.template getParameter<T>(id);
      } catch (...) {
        // if we get here, this was NOT a simple tracked parameter goof.
        // we should just rethrow the ORIGINAL error
        e.raise();
      } 
      std::cerr << "Tracked parameter " << id 
                << " used in MessageLogger configuration.\n"
                << "Use of tracked parameters for the message service "
                << "is not allowed.\n"
                << "The .cfg file should be modified to make this untracked.\n";
      e.raise();                
    } catch (...) {
      // This is not the usual tracked/untracked error; we can't add useful info
      throw;
    }
    return t;
     }

#endif // VALIDATE_ELSEWHERE
#endif // SIMPLESTYLE
#endif // OLD_STYLE and the else Do not tolerate errors

#ifdef REMOVE
  template <class T>
  T  getCategoryDefault ( PSet * p, 
                          std::string const & id, 
                          std::string const & def  ) 
  {
    T t;
    t = p->template getUntrackedParameter<T>(id, def);
    return t;
  }                                                             
#endif


  // --- other helpers
  void parseCategories (std::string const & s, std::vector<std::string> & cats);
  void setStaticErrorLog_ptr() {static_errorlog_p = errorlog_p.get();}
  
  // --- data:
  ELadministrator                   * admin_p;
  ELdestControl                       early_dest;
  boost::shared_ptr<ErrorLog>         errorlog_p;
  std::vector<boost::shared_ptr<std::ofstream> > file_ps;
  MsgContext                          msg_context;
  boost::shared_ptr<PSet>             job_pset_p;
  std::vector<NamedDestination     *> extern_dests;
  std::map<String,std::ostream     *> stream_ps;
  std::vector<String>                 ordinary_destination_filenames;
  std::vector<ELdestControl>          statisticsDestControls;
  std::vector<bool>                   statisticsResets;
  std::string                         jobReportOption;
  static ErrorLog                   * static_errorlog_p;
  bool                                clean_slate_configuration;
  value_ptr<MessageLoggerDefaults>    messageLoggerDefaults;
  bool                                active;
  bool                                singleThread;             // changeLog 9
  bool                                done;                     // changeLog 9
  bool                                purge_mode;               // changeLog 9
  int                                 count;                    // changeLog 9
  boost::shared_ptr<ThreadQueue>      m_queue;                  // changeLog 12
      
};  // MessageLoggerScribe


}   // end of namespace service
}  // namespace edm


#endif  // FWCore_MessageService_MessageLoggerScribe_h