JobCPath.h

Go to the documentation of this file.

// $Id: JobCPath.h,v 1.38 2007/10/25 17:21:25 bckhouse Exp $
//
// A reconstruction path
//
// messier@huhepl.harvard.edu
#ifndef JOBCPATH_H
#define JOBCPATH_H
#ifndef STRING
#include <string>
#define STRING
#endif
#ifndef LIST
#include <list>
#define LIST
#endif
#ifndef __CINT__
# ifdef SITE_HAS_SIGC
#  ifndef SIGNAL_H
#   include "sigc++/signal.h"
#   define SIGNAL_H
#  endif
# endif
#endif
#ifndef JOBCRESULT_H
#include "JobControl/JobCResult.h"
#endif
#ifndef JOBCGRAPHVTX_H
#include "JobControl/JobCGraphVtx.h"
#endif
#ifndef JOBCNODE_H
#include "JobControl/JobCNode.h"
#endif
#ifndef ROOT_Rtypes
#if !defined(__CINT__) || defined(__MAKECINT__)
#include "Rtypes.h" // Needed for ClassDef and ClassImp macros
#endif
#endif

class MomNavigator;
class JobCModule;
class JobCInputModule;
class JobCNode;

// Set a limit to prevent jobs from spiraling off to infinity
#define JOBCPATH_RUN_LIMIT (1000000000)

class JobCPath : public JobCGraphVtx
{
  friend ostream& operator<<(ostream& os, const JobCPath& p);
public:
  typedef enum ERunMode {
    kRunAll,
    kRunNin,
    kRunNpass,
    kRunNfail
  } RunMode_t;

  typedef list<JobCModule*>::const_iterator ModuleIterator;
  typedef list<JobCNode*>::const_iterator   NodeIterator;

public:
  JobCPath();
  JobCPath(const char *name, MomNavigator* mom, JobCInputModule* input);
  virtual ~JobCPath();

public:
  // The set of commands I expect people to use in macros
  JobCModule& Mod(const char *moduleName);
  JobCNode&   Node(const char* nodeName);
  void        Report();
  void        Run(int n=JOBCPATH_RUN_LIMIT, RunMode_t mode=JobCPath::kRunNin);
  void        RunNin(int n);   // Run until n events have been read in
  void        RunNpass(int n); // Run until n events have passed cuts
  void        RunNfail(int n); // Run until n events have failed cuts
  void        SetAllFilters(bool onOff);
  void        ReverseAllFilters();

  JobCResult  LastResult() const { return fResult; }

  // Commands I expect will only be used internally
  const char*    GetName()          const;
  void           Print(ostream& os) const;

  JobCModule* GetModule(const char* moduleName, bool create=false);
  JobCNode*   FindNode(const char* module, const char* method);
  JobCInputModule* GetInputModule();

  JobCNode* PushFront( const char *moduleName, const char *methodName);
  JobCNode* PushBack(  const char *moduleName, const char *methodName);
  JobCNode* AddAt(     const char *moduleName, const char *methodName, int n);
  JobCNode* AddBetween(const char *moduleName, const char *methodName,
                       const char *afterNodeName, const char *beforeNodeName);
  void      Remove(    const char *moduleName, const char *methodName);

  // JobCGraphVtx interface
  void       Attach(JobCGraphVtx *p);
  void       Detach(JobCGraphVtx *p) ;
  bool       EvalInput(JobCRecord* rec);
  JobCResult Execute(JobCRecord* rec);
  void       BeginJob() const;

  ModuleIterator GetModuleBegin() { return fModuleList.begin(); }
  ModuleIterator GetModuleEnd()   { return fModuleList.end(); }
  NodeIterator   GetNodeBegin()   { return fNodeList.begin(); }
  NodeIterator   GetNodeEnd()     { return fNodeList.end(); }
  void           HandleResult(const JobCResult& r) const;
  void           SetRefreshMode(bool onOff)        const;

#ifndef __CINT__
#ifdef SITE_HAS_SIGC
public:
  // Emit signals when state changes
  typedef enum EUpdateCodes {
    kAddNode,          // Node added
    kRemoveNode,       // Node removed
    kAddConnection,    // New path attached
    kRemoveConnection, // New path attached
    kFilters,          // Node filters changed
    kGeneral           // Can't tell you exactly, assume everything...
  } Update_t;
  SigC::Signal1<void,JobCPath*>                    SigDelete;
  SigC::Signal2<void,JobCPath*,JobCPath::Update_t> SigUpdate;
  SigC::Signal1<void,JobCPath*>                    SigStartRun;
  SigC::Signal1<void,JobCPath*>                    SigEndRun;

  // Provide a call-back to handle node reconfiguration
  void NodeUpdateCB(JobCNode* n, JobCNode::Update_t u);
#endif
private:
 public: //rwh for ROOT 2007-01-26
  // SigC::Signal1/2 derives from SignalBase which has a private operator=
  // CINT attempts to generate explicit assignment unless told not to do so
  JobCPath& operator= (const JobCPath&) { abort(); return *this; } // no assignment
#endif

private:
  bool        AtJobStart() const;
  void        CheckResult(const JobCResult& r);
  JobCNode*   CreateNode(const char* modName, const char* metName);
  bool        HandleError(const JobCResult& r, const JobCNode* n);
  static void PropagateResult(const JobCResult& r, JobCPath* p);
  void        PropagateRefreshMode(bool onOff);
  void        SetUniquePaths(const char* base="");

private:
  mutable bool fIsRefreshRun;    // In the process of a refresh run command?
  mutable bool fAtJobStart;      // At the start of a job?
  string       fName;            // The name of this path
  int          fNin;             // Number of events to enter this path
  int          fNpass;           // Number of events passed
  int          fNfail;           // Number of events failed

  MomNavigator*     fMom;        // Pointer to "the event" data
  JobCInputModule*  fInput;      // Input module
  list<JobCModule*> fModuleList; // The list of modules used in this path
  list<JobCNode*>   fNodeList;   // The list of nodes in this path
  JobCResult        fResult;     // The most recent result returned from a node

  mutable JobCModule* fDummyModule; // An empty module used for failed lookups
  mutable JobCNode*   fDummyNode;   // An empty node used for failed lookups

  ClassDef(JobCPath,0) // a reconstruction path
};

#endif // JOBCPATH_H

---