/data/refman/pasoursint/CMSSW_5_3_3/src/FWCore/MessageService/interface/ELcollected.h

Go to the documentation of this file.

#ifndef FWCore_MessageService_ELcollected_h
#define FWCore_MessageService_ELcollected_h


// ----------------------------------------------------------------------
//
// ELcollected  is a subclass of ELdestination representing a
//              destination designed for collection of messages
//              from multiple processes.
//
// Usage:
//
// (0)  Define "clients" and "server" such that multiple clients each run
//      user code which will issue ErrorLogger messages, and a single server
//      is to amalgamated those messages into a single flow with unified
//      statistics output.
//
// (1)  Each client connects (one or more) ELcollected destinations to the
//      ELadministrator.  These can be controlled in terms of filtering,
//      throttling and so forth.  The semantics are like those for ELoutput.
//
// (2)  When a ELcollected destination is instantiated, the constructor
//      takes as an argument an object of a type derived from ELsender.
//      ELsender is an abstract class containing a pure virtual method
//      send (int n, const char* data).  The derived class provides a definition
//      of send(n, data) which moves n bytes of data to the server.
//                      ELsender also has a pure virtual clone() method;
//                      provision of this follows a boiler-plate we provide.
//      One advantage of setting up an ELsender object, rather than making
//      the user provide a global-scope function ELsend, is flexibility:
//      It makes it trivial to set up two ELcollecteds that send their data to
//      two different places or even use two distinct transport mechanisms.
//
// (3)  The server process must set up its own ELadministrator, and attach
//      whatever destinations it wants to have, such as ELoutput and
//      ELstatistics destinations, in the usual manner.
//
// (4a) The server can be set up such that it has an ErrorLog errlog and
//      whenever one of these chunks of data is moved to it, it does
//      errlog (n, data).
//              This is a natural syntax for a framework used to using
//              errlog to log messages.  If the server process is also doing
//              other things that might issue error messages, this syntax
//              has the advantageous feature that whatever module name is
//              assinged to this errlog, will be prepended to the module name
//              sent as part of the message.
//
// (4b) Alternatively, the server cam be set up such that whenever one of these
//      chunks of data is moved to it, it calls ELrecv (n, data).
//              This may be marginally more convenient.
//
// (*)  The effect of an error message on the client is that when the data
//      is moved to the server, and that causes ELrecv (or errlog(nbytes,data))
//      to be called, the data is unraveled into the individual items that were
//      supplied, and an error message is issued which is identical to the
//      error message that was issued on the client.  Thus all these messages
//      end up amalgamated on the server destination(s).
//
// 2/22/00 mf   Created file, based mainly on ELoutput.h
// 3/16/00 mf   Mods to support ELsender operation.
// 6/7/00 web   Reflect consolidation of ELdestination/X and ELoutput/X
//              and consolidate ELcollected/X.
// 6/14/00 web  Declare classes before granting friendship.
//
// ----------------------------------------------------------------------

#include "FWCore/MessageService/interface/ELoutput.h"
#include "FWCore/MessageService/interface/ELsender.h"

#include "FWCore/MessageLogger/interface/ELstring.h"
#include "FWCore/MessageLogger/interface/ELextendedID.h"

#include "boost/shared_ptr.hpp"

namespace edm {       
namespace service {       


// ----------------------------------------------------------------------
// prerequisite classes:
// ----------------------------------------------------------------------

class ELoutput;
class ELdestControl;


// ----------------------------------------------------------------------
// ELcollected:
// ----------------------------------------------------------------------

class ELcollected : public ELoutput  {

  friend class ELdestControl;

public:

  // -----  Birth/death:
  //
  ELcollected( const ELsender & sender );
  ELcollected( const ELcollected & orig );
  ELcollected( ELoutput * d);
  virtual ~ELcollected();

  // -----  Methods invoked by the ELadministrator:
  //
public:
  virtual
  ELcollected *
  clone() const;
  // Used by attach() to put the destination on the ELadministrators list
                //-| There is a note in Design Notes about semantics
                //-| of copying a destination onto the list:  ofstream
                //-| ownership is passed to the new copy.

  virtual bool log( const edm::ErrorObj & msg );

  // -----  Methods invoked through the ELdestControl handle:
  //
protected:
    // trivial clearSummary(), wipe(), zero() from base class
    // trivial three summary(..) from base class

  // -----  Data fundamental to the ELcollected destination:
  //

  // -----  Data affected by methods of specific ELdestControl handle:
  //
protected:
    // ELcollected uses the generic ELdestControl handle

  // -----  Internal Methods -- Users should not invoke these:
  //
protected:
  void emitToken( const ELstring & s, bool nl=false );

  boost::shared_ptr<ELsender> sender;

  void intoBuf ( const ELstring & s );
  void emitXid ( const ELextendedID & xid  );

  ELstring buf;

private:
  ELcollected & operator=( const ELcollected & orig );  // verboten

};  // ELcollected


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


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


#endif // MessageService_ELcollected_h