---

InputSource.h

Go to the documentation of this file.

#ifndef FWCore_Framework_InputSource_h
#define FWCore_Framework_InputSource_h


/*----------------------------------------------------------------------
  
InputSource: Abstract interface for all input sources. Input
sources are responsible for creating an EventPrincipal, using data
controlled by the source, and external to the EventPrincipal itself.

The InputSource is also responsible for dealing with the "process
name list" contained within the EventPrincipal. Each InputSource has
to know what "process" (HLT, PROD, USER, USER1, etc.) the program is
part of. The InputSource is repsonsible for pushing this process name
onto the end of the process name list.

For now, we specify this process name to the constructor of the
InputSource. This should be improved.

 Some questions about this remain:

   1. What should happen if we "rerun" a process? i.e., if "USER1" is
   already last in our input file, and we run again a job which claims
   to be "USER1", what should happen? For now, we just quietly add
   this to the history.

   2. Do we need to detect a problem with a history like:
         HLT PROD USER1 PROD
   or is it up to the user not to do something silly? Right now, there
   is no protection against such sillyness.

Some examples of InputSource subclasses may be:

 1) EmptySource: creates EventPrincipals which contain no EDProducts.
 2) PoolSource: creates EventPrincipals which "contain" the data
    read from a POOL file. This source should provide for delayed loading
    of data, thus the quotation marks around contain.
 3) DAQInputSource: creats EventPrincipals which contain raw data, as
    delivered by the L1 trigger and event builder. 

$Id: InputSource.h,v 1.48 2008/10/20 19:38:21 wmtan Exp $

----------------------------------------------------------------------*/

#include <memory>
#include <string>

#include "boost/shared_ptr.hpp"
#include "boost/utility.hpp"
#include "sigc++/signal.h"

#include "DataFormats/Provenance/interface/RunID.h"
#include "DataFormats/Provenance/interface/LuminosityBlockID.h"
#include "DataFormats/Provenance/interface/ModuleDescription.h"
#include "DataFormats/Provenance/interface/Timestamp.h"
#include "FWCore/Framework/interface/ProductRegistryHelper.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"

namespace edm {
  class ParameterSet;
  class ActivityRegistry;

  class InputSource : private ProductRegistryHelper, private boost::noncopyable {
  public:
    enum ItemType {
        IsInvalid,
        IsStop,
        IsFile,
        IsRun,
        IsLumi,
        IsEvent,
        IsRepeat
    };

    enum ProcessingMode {
        Runs,
        RunsAndLumis,
        RunsLumisAndEvents
    };

    typedef ProductRegistryHelper::TypeLabelList TypeLabelList;
    explicit InputSource(ParameterSet const&, InputSourceDescription const&);

    virtual ~InputSource();

    ItemType nextItemType();

    std::auto_ptr<EventPrincipal> readEvent(boost::shared_ptr<LuminosityBlockPrincipal> lbp);

    std::auto_ptr<EventPrincipal> readEvent(EventID const&);

    boost::shared_ptr<LuminosityBlockPrincipal> readLuminosityBlock(boost::shared_ptr<RunPrincipal> rp);

    boost::shared_ptr<RunPrincipal> readRun();

    boost::shared_ptr<FileBlock> readFile();

    void closeFile();

    void skipEvents(int offset);

    void rewind() {
      doneReadAhead_ = false;
      state_ = IsInvalid;
      rewind_();
    }

    void wakeUp() {wakeUp_();}

    void setRunNumber(RunNumber_t r) {setRun(r);}

    void setLuminosityBlockNumber_t(LuminosityBlockNumber_t lb) {setLumi(lb);}

    void issueReports(EventID const& eventID, LuminosityBlockNumber_t const& lumi);

    void registerProducts();

    boost::shared_ptr<ProductRegistry const> productRegistry() const {return productRegistry_;}
    
    void repeat() {
      remainingEvents_ = maxEvents_;
      remainingLumis_ = maxLumis_;
      doneReadAhead_ = false;
    }

    int maxEvents() const {return maxEvents_;}

    int remainingEvents() const {return remainingEvents_;}

    int maxLuminosityBlocks() const {return maxLumis_;}

    int remainingLuminosityBlocks() const {return remainingLumis_;}

    ModuleDescription const& moduleDescription() const {return moduleDescription_;}

    ProcessConfiguration const& processConfiguration() const {return moduleDescription().processConfiguration();}

    bool const primary() const {return primary_;}

    std::string const& processGUID() const {return processGUID_;}

    void doBeginJob(EventSetup const&);

    void doEndJob();

    void doEndLumi(LuminosityBlockPrincipal& lbp);
    void doEndRun(RunPrincipal& rp);

    Timestamp const& timestamp() const {return time_;}

    RunNumber_t run() const;

    LuminosityBlockNumber_t luminosityBlock() const;

    ProcessingMode processingMode() const {return processingMode_;}

    boost::shared_ptr<ActivityRegistry> actReg() const {return actReg_;}

    using ProductRegistryHelper::produces;
    using ProductRegistryHelper::typeLabelList;

    class SourceSentry : private boost::noncopyable {
    public:
      typedef sigc::signal<void> Sig;
      SourceSentry(Sig& pre, Sig& post);
      ~SourceSentry();
    private:
      Sig& post_;
    };

    class EventSourceSentry {
    public:
      explicit EventSourceSentry(InputSource const& source);
    private:
      SourceSentry sentry_;
    };

    class LumiSourceSentry {
    public:
      explicit LumiSourceSentry(InputSource const& source);
    private:
      SourceSentry sentry_;
    };

    class RunSourceSentry {
    public:
      explicit RunSourceSentry(InputSource const& source);
    private:
      SourceSentry sentry_;
    };

    class FileOpenSentry {
    public:
      explicit FileOpenSentry(InputSource const& source);
    private:
      SourceSentry sentry_;
    };

    class FileCloseSentry {
    public:
      explicit FileCloseSentry(InputSource const& source);
    private:
      SourceSentry sentry_;
    };

  protected:
    void setTimestamp(Timestamp const& theTime) {time_ = theTime;}

    ProductRegistry & productRegistryUpdate() const {return const_cast<ProductRegistry &>(*productRegistry_);}
    ItemType state() const{return state_;}
    boost::shared_ptr<RunPrincipal> runPrincipal() const {return runPrincipal_;}
    boost::shared_ptr<LuminosityBlockPrincipal> luminosityBlockPrincipal() const {return lumiPrincipal_;}
    void setRunPrincipal(boost::shared_ptr<RunPrincipal> rp) {runPrincipal_ = rp;}
    void setLuminosityBlockPrincipal(boost::shared_ptr<LuminosityBlockPrincipal> lbp) {lumiPrincipal_ = lbp;}
    void resetRunPrincipal() {runPrincipal_.reset();}
    void resetLuminosityBlockPrincipal() {lumiPrincipal_.reset();}
    void reset() const {
      doneReadAhead_ = false;
      state_ = IsInvalid;
    }

  private:
    bool eventLimitReached() const {return remainingEvents_ == 0;}
    bool lumiLimitReached() const {return remainingLumis_ == 0;}
    bool limitReached() const {return eventLimitReached() || lumiLimitReached();}
    virtual ItemType getNextItemType() = 0;
    ItemType nextItemType_();
    virtual boost::shared_ptr<RunPrincipal> readRun_() = 0;
    virtual boost::shared_ptr<LuminosityBlockPrincipal> readLuminosityBlock_() = 0;
    virtual std::auto_ptr<EventPrincipal> readEvent_() = 0;
    virtual std::auto_ptr<EventPrincipal> readIt(EventID const&);
    virtual boost::shared_ptr<FileBlock> readFile_();
    virtual void closeFile_() {}
    virtual void skip(int);
    virtual void setRun(RunNumber_t r);
    virtual void setLumi(LuminosityBlockNumber_t lb);
    virtual void rewind_();
    virtual void wakeUp_();
    void preRead();
    void postRead(Event& event);
    virtual void endLuminosityBlock(LuminosityBlock &);
    virtual void endRun(Run &);
    virtual void beginJob(EventSetup const&);
    virtual void endJob();

  private:

    boost::shared_ptr<ActivityRegistry> actReg_;
    int maxEvents_;
    int remainingEvents_;
    int maxLumis_;
    int remainingLumis_;
    int readCount_;
    ProcessingMode processingMode_;
    ModuleDescription const moduleDescription_;
    boost::shared_ptr<ProductRegistry const> productRegistry_;
    bool const primary_;
    std::string processGUID_;
    Timestamp time_;
    mutable bool doneReadAhead_;
    mutable ItemType state_;
    mutable boost::shared_ptr<RunPrincipal>  runPrincipal_;
    mutable boost::shared_ptr<LuminosityBlockPrincipal>  lumiPrincipal_;
  };
}

#endif

---