StreamerInputSource.h

Go to the documentation of this file.

#ifndef IOPool_Streamer_StreamerInputSource_h
#define IOPool_Streamer_StreamerInputSource_h

#include "TBufferFile.h"

#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/InputSource.h"

#include "DataFormats/Streamer/interface/StreamedProducts.h"
#include "DataFormats/Common/interface/EDProductGetter.h"

#include "boost/shared_ptr.hpp"

#include <vector>

class InitMsgView;
class EventMsgView;

namespace edm {
  class ParameterSetDescription;
  class StreamerInputSource : public InputSource {
  public:  
    explicit StreamerInputSource(ParameterSet const& pset,
                 InputSourceDescription const& desc);
    virtual ~StreamerInputSource();
    static void fillDescription(ParameterSetDescription& description);

    static
    std::auto_ptr<SendJobHeader> deserializeRegistry(InitMsgView const& initView);

    void deserializeAndMergeWithRegistry(InitMsgView const& initView, bool subsequent = false);

    EventPrincipal* deserializeEvent(EventMsgView const& eventView);

    static
    void mergeIntoRegistry(SendJobHeader const& header, ProductRegistry&, bool subsequent);

    static unsigned int uncompressBuffer(unsigned char* inputBuffer,
                                         unsigned int inputSize,
                                         std::vector<unsigned char>& outputBuffer,
                                         unsigned int expectedFullSize);
  protected:
    static void declareStreamers(SendDescs const& descs);
    static void buildClassCache(SendDescs const& descs);
    void setEndRun() {runEndingFlag_ = true;}
    void resetAfterEndRun();

    bool inputFileTransitionsEachEvent_;

  private:

    class ProductGetter : public EDProductGetter {
    public:
      ProductGetter();
      virtual ~ProductGetter();

      virtual WrapperHolder getIt(edm::ProductID const& id) const;

      void setEventPrincipal(EventPrincipal *ep);

    private:
      // We don't own the principal.  The lifetime must be managed externally.
      EventPrincipal const* eventPrincipal_;
    };

    virtual EventPrincipal* read() = 0;

    virtual boost::shared_ptr<RunAuxiliary> readRunAuxiliary_();

    virtual boost::shared_ptr<LuminosityBlockAuxiliary> readLuminosityBlockAuxiliary_();

    virtual EventPrincipal*
    readEvent_();

    virtual ItemType getNextItemType();

    virtual void setRun(RunNumber_t r);

    virtual boost::shared_ptr<FileBlock> readFile_();

    bool newRun_;
    bool newLumi_;
    bool eventCached_;

    TClass* tc_;
    std::vector<unsigned char> dest_;
    TBufferFile xbuf_;
    bool runEndingFlag_;
    ProductGetter productGetter_;

    //Do not like these to be static, but no choice as deserializeRegistry() that sets it is a static memeber 
    static std::string processName_;
    static unsigned int protocolVersion_;
  }; //end-of-class-def
} // end of namespace-edm
  
#endif