IndexIntoFile.h

Go to the documentation of this file.

#ifndef DataFormats_Provenance_IndexIntoFile_h
#define DataFormats_Provenance_IndexIntoFile_h

#include "DataFormats/Provenance/interface/EventID.h"
#include "DataFormats/Provenance/interface/ProcessHistoryID.h"
#include "DataFormats/Provenance/interface/RunID.h"
#include "FWCore/Utilities/interface/propagate_const.h"
#include "FWCore/Utilities/interface/value_ptr.h"

#include <memory>

#include <cassert>
#include <iosfwd>
#include <map>
#include <set>
#include <vector>

class TestIndexIntoFile;
class TestIndexIntoFile1;
class TestIndexIntoFile2;
class TestIndexIntoFile3;
class TestIndexIntoFile4;
class TestIndexIntoFile5;

namespace edm {

  class ProcessHistoryRegistry;
  class RootFile;

  class IndexIntoFile {
    public:
      class IndexIntoFileItr;
      class SortedRunOrLumiItr;
      class IndexRunLumiEventKey;

      using EntryNumber_t = long long ;
      static constexpr int invalidIndex = -1;
      static constexpr RunNumber_t invalidRun = 0U;
      static constexpr LuminosityBlockNumber_t invalidLumi = 0U;
      static constexpr EventNumber_t invalidEvent = 0U;
      static constexpr EntryNumber_t invalidEntry = -1LL;

      enum EntryType {kRun, kLumi, kEvent, kEnd};

      IndexIntoFile();
      ~IndexIntoFile();

      ProcessHistoryID const& processHistoryID(int i) const;
      std::vector<ProcessHistoryID> const& processHistoryIDs() const;

      enum SortOrder {numericalOrder, firstAppearanceOrder};

      IndexIntoFileItr begin(SortOrder sortOrder) const;

      IndexIntoFileItr end(SortOrder sortOrder) const;

      bool iterationWillBeInEntryOrder(SortOrder sortOrder) const;

      bool empty() const;

      IndexIntoFileItr
      findPosition(RunNumber_t run, LuminosityBlockNumber_t lumi = 0U, EventNumber_t event = 0U) const;

      IndexIntoFileItr
      findPosition(SortOrder sortOrder, RunNumber_t run, LuminosityBlockNumber_t lumi = 0U, EventNumber_t event = 0U) const;

      IndexIntoFileItr
      findEventPosition(RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event) const;

      IndexIntoFileItr
      findLumiPosition(RunNumber_t run, LuminosityBlockNumber_t lumi) const;

      IndexIntoFileItr
      findRunPosition(RunNumber_t run) const;

      bool containsItem(RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event) const;
      bool containsEvent(RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event) const;
      bool containsLumi(RunNumber_t run, LuminosityBlockNumber_t lumi) const;
      bool containsRun(RunNumber_t run) const;

      SortedRunOrLumiItr beginRunOrLumi() const;
      SortedRunOrLumiItr endRunOrLumi() const;

      void set_intersection(IndexIntoFile const& indexIntoFile, std::set<IndexRunLumiEventKey>& intersection) const;

      bool containsDuplicateEvents() const;

      //*****************************************************************************
      //*****************************************************************************

      class RunOrLumiEntry {
      public:

        RunOrLumiEntry();

        RunOrLumiEntry(EntryNumber_t orderPHIDRun,
                       EntryNumber_t orderPHIDRunLumi,
                       EntryNumber_t entry,
                       int processHistoryIDIndex,
                       RunNumber_t run,
                       LuminosityBlockNumber_t lumi,
                       EntryNumber_t beginEvents,
                       EntryNumber_t Event);

        EntryNumber_t orderPHIDRun() const {return orderPHIDRun_;}
        EntryNumber_t orderPHIDRunLumi() const {return orderPHIDRunLumi_;}
        EntryNumber_t entry() const {return entry_;}
        int processHistoryIDIndex() const {return processHistoryIDIndex_;}
        RunNumber_t run() const {return run_;}
        LuminosityBlockNumber_t lumi() const {return lumi_;}
        EntryNumber_t beginEvents() const {return beginEvents_;}
        EntryNumber_t endEvents() const {return endEvents_;}

        bool isRun() const {return lumi() == invalidLumi;}

        void setOrderPHIDRun(EntryNumber_t v) {orderPHIDRun_ = v;}
        void setOrderPHIDRunLumi(EntryNumber_t v) {orderPHIDRunLumi_ = v;}
        void setProcessHistoryIDIndex(int v) {processHistoryIDIndex_ = v;}

        bool operator<(RunOrLumiEntry const& right) const {
          if (orderPHIDRun_ == right.orderPHIDRun()) {
            if (orderPHIDRunLumi_ == right.orderPHIDRunLumi()) {
              return entry_ < right.entry();
            }
            return orderPHIDRunLumi_ < right.orderPHIDRunLumi();
          }
          return orderPHIDRun_ < right.orderPHIDRun();
        }

      private:

        // All Runs, Lumis, and Events associated with the same
        // ProcessHistory and Run in the same input file are processed
        // contiguously.  This parameter establishes the default order
        // of processing of these contiguous subsets of data.
        EntryNumber_t orderPHIDRun_;

        // All Lumis and Events associated with the same
        // ProcessHistory, Run, and Lumi in the same input file are
        // processed contiguously.  This parameter establishes the
        // default order of processing of these contiguous subsets
        // of data.
        EntryNumber_t orderPHIDRunLumi_; // -1 if a run

        // TTree entry number of Run or Lumi
        // Always will be valid except when the IndexIntoFile was
        // created while processing more than 1 luminosity block
        // at a time (multiple concurrent lumis). In that case
        // there can be multiple contiguous event ranges associated
        // with the same lumi TTree entry. Exactly one of those will
        // have a valid entry_ number and the rest will be set
        // to the invalid value (-1). For a particular lumi, the
        // invalid ones sort before the valid ones.
        EntryNumber_t entry_;

        int processHistoryIDIndex_;
        RunNumber_t run_;
        LuminosityBlockNumber_t lumi_;  // 0 indicates this is a run entry

        // These are entry numbers in the Events TTree
        // Each RunOrLumiEntry is associated with one contiguous range of events.
        // This is disjoint from the ranges associated with all other RunOrLumiEntry's
        EntryNumber_t beginEvents_;     // -1 if a run or a lumi with no events
        EntryNumber_t endEvents_;       // -1 if a run or a lumi with no events
      };

      //*****************************************************************************
      //*****************************************************************************

      class RunOrLumiIndexes {
      public:
        RunOrLumiIndexes(int processHistoryIDIndex, RunNumber_t run, LuminosityBlockNumber_t lumi, int indexToGetEntry);

        int processHistoryIDIndex() const {return processHistoryIDIndex_;}
        RunNumber_t run() const {return run_;}
        LuminosityBlockNumber_t lumi() const {return lumi_;}
        int indexToGetEntry() const {return indexToGetEntry_;}
        long long beginEventNumbers() const {return beginEventNumbers_;}
        long long endEventNumbers() const {return endEventNumbers_;}

        bool isRun() const {return lumi() == invalidLumi;}

        void setBeginEventNumbers(long long v) {beginEventNumbers_ = v;}
        void setEndEventNumbers(long long v) {endEventNumbers_ = v;}

        bool operator<(RunOrLumiIndexes const& right) const {
          if (processHistoryIDIndex_ == right.processHistoryIDIndex()) {
            if (run_ == right.run()) {
              return lumi_ < right.lumi();
            }
            return run_ < right.run();
          }
          return processHistoryIDIndex_ < right.processHistoryIDIndex();
        }

      private:

        int processHistoryIDIndex_;
        RunNumber_t run_;
        LuminosityBlockNumber_t lumi_;    // 0 indicates this is a run entry
        int indexToGetEntry_;

        // The next two data members are indexes into the vectors eventNumbers_ and
        // eventEntries_ (which both have the same number of entries in the same order,
        // the only difference being that one contains only events numbers and is
        // smaller in memory).

        // If there are no events, then the next two are equal (and the value is the
        // index where the first event would have gone if there had been one)

        // Note that there can be many RunOrLumiIndexes objects where these two values are
        // the same if there are many noncontiguous ranges of events associated with the same
        // PHID-Run-Lumi (this one range in eventNumbers_ corresponds to the union of
        // all the noncontiguous ranges in the Events TTree).
        long long beginEventNumbers_;     // first event this PHID-Run-Lumi (-1 if a run or not set)
        long long endEventNumbers_;       // one past last event this PHID-Run-Lumi (-1 if a run or not set)
      };

      //*****************************************************************************
      //*****************************************************************************

      class EventEntry {
      public:
        EventEntry() : event_(invalidEvent), entry_(invalidEntry) {}
        EventEntry(EventNumber_t event, EntryNumber_t entry) : event_(event), entry_(entry) {}

        EventNumber_t event() const {return event_;}
        EntryNumber_t entry() const {return entry_;}

        bool operator<(EventEntry const& right) const {
          return event() < right.event();
        }

        bool operator==(EventEntry const& right) const {
          return event() == right.event();
        }

      private:
        EventNumber_t event_;
        EntryNumber_t entry_;
      };


      //*****************************************************************************
      //*****************************************************************************

      class SortedRunOrLumiItr {

      public:
        SortedRunOrLumiItr(IndexIntoFile const* indexIntoFile, unsigned runOrLumi);

        IndexIntoFile const* indexIntoFile() const {return indexIntoFile_;}
        unsigned runOrLumi() const {return runOrLumi_;}

        bool operator==(SortedRunOrLumiItr const& right) const;
        bool operator!=(SortedRunOrLumiItr const& right) const;
        SortedRunOrLumiItr& operator++();

        bool isRun();

        void getRange(long long& beginEventNumbers,
                      long long& endEventNumbers,
                      EntryNumber_t& beginEventEntry,
                      EntryNumber_t& endEventEntry);

        RunOrLumiIndexes const& runOrLumiIndexes() const;

      private:

        IndexIntoFile const* indexIntoFile_;

        // This is an index into runOrLumiIndexes_
        // which gives the current position of the iteration
        unsigned runOrLumi_;
      };


      //*****************************************************************************
      //*****************************************************************************

      class IndexIntoFileItrImpl {

      public:
        IndexIntoFileItrImpl(IndexIntoFile const* indexIntoFile,
                             EntryType entryType,
                             int indexToRun,
                             int indexToLumi,
                             int indexToEventRange,
                             long long indexToEvent,
                             long long nEvents);
         virtual ~IndexIntoFileItrImpl();

        virtual IndexIntoFileItrImpl* clone() const = 0;

        EntryType getEntryType() const {return type_;}

        void next ();

        void skipEventForward(int& phIndexOfSkippedEvent,
                              RunNumber_t& runOfSkippedEvent,
                              LuminosityBlockNumber_t& lumiOfSkippedEvent,
                              EntryNumber_t& skippedEventEntry);

        void skipEventBackward(int& phIndexOfEvent,
                               RunNumber_t& runOfEvent,
                               LuminosityBlockNumber_t& lumiOfEvent,
                               EntryNumber_t& eventEntry);

        virtual int processHistoryIDIndex() const  = 0;
        virtual RunNumber_t run() const = 0;
        virtual LuminosityBlockNumber_t lumi() const = 0;
        virtual EntryNumber_t entry() const = 0;
        virtual LuminosityBlockNumber_t peekAheadAtLumi() const = 0;
        virtual EntryNumber_t peekAheadAtEventEntry() const = 0;
        EntryNumber_t firstEventEntryThisRun();
        EntryNumber_t firstEventEntryThisLumi();
        virtual bool skipLumiInRun() = 0;
        virtual bool lumiEntryValid(int index) const = 0;

        void advanceToNextRun();
        void advanceToNextLumiOrRun();
        bool skipToNextEventInLumi();
        void initializeRun();

        void initializeLumi() ;

        bool operator==(IndexIntoFileItrImpl const& right) const;

        IndexIntoFile const* indexIntoFile() const { return indexIntoFile_; }
        int size() const { return size_; }

        EntryType type() const { return type_; }
        int indexToRun() const { return indexToRun_; }

        int indexToLumi() const { return indexToLumi_; }
        int indexToEventRange() const { return indexToEventRange_; }
        long long indexToEvent() const { return indexToEvent_; }
        long long nEvents() const { return nEvents_; }

        void copyPosition(IndexIntoFileItrImpl const& position);

      protected:

        void setInvalid();

        void setIndexToLumi(int value) { indexToLumi_ = value; }
        void setIndexToEventRange(int value) { indexToEventRange_ = value; }
        void setIndexToEvent(long long value) { indexToEvent_ = value; }
        void setNEvents(long long value) { nEvents_ = value; }

      private:

        virtual void initializeLumi_() = 0;
        virtual bool nextEventRange() = 0;
        virtual bool previousEventRange() = 0;
        bool previousLumiWithEvents();
        virtual bool setToLastEventInRange(int index) = 0;
        virtual EntryType getRunOrLumiEntryType(int index) const = 0;
        virtual bool isSameLumi(int index1, int index2) const = 0;
        virtual bool isSameRun(int index1, int index2) const = 0;

        IndexIntoFile const* indexIntoFile_;
        int size_;

        EntryType type_;
        int indexToRun_;
        int indexToLumi_;
        int indexToEventRange_;
        long long indexToEvent_;
        long long nEvents_;
      };

      //*****************************************************************************
      //*****************************************************************************

      class IndexIntoFileItrNoSort : public IndexIntoFileItrImpl {
      public:
        IndexIntoFileItrNoSort(IndexIntoFile const* indexIntoFile,
                               EntryType entryType,
                               int indexToRun,
                               int indexToLumi,
                               int indexToEventRange,
                               long long indexToEvent,
                               long long nEvents);

        IndexIntoFileItrImpl* clone() const override;

        int processHistoryIDIndex() const override;
        RunNumber_t run() const override;
        LuminosityBlockNumber_t lumi() const override;
        EntryNumber_t entry() const override;
        LuminosityBlockNumber_t peekAheadAtLumi() const override;
        EntryNumber_t peekAheadAtEventEntry() const override;
        bool skipLumiInRun() override;
        bool lumiEntryValid(int index) const override;

      private:

        void initializeLumi_() override;
        bool nextEventRange() override;
        bool previousEventRange() override;
        bool setToLastEventInRange(int index) override;
        EntryType getRunOrLumiEntryType(int index) const override;
        bool isSameLumi(int index1, int index2) const override;
        bool isSameRun(int index1, int index2) const override;
      };

      //*****************************************************************************
      //*****************************************************************************

      class IndexIntoFileItrSorted : public IndexIntoFileItrImpl {
      public:
        IndexIntoFileItrSorted(IndexIntoFile const* indexIntoFile,
                               EntryType entryType,
                               int indexToRun,
                               int indexToLumi,
                               int indexToEventRange,
                               long long indexToEvent,
                               long long nEvents);

        IndexIntoFileItrImpl* clone() const override;
        int processHistoryIDIndex() const override;
        RunNumber_t run() const override;
        LuminosityBlockNumber_t lumi() const override;
        EntryNumber_t entry() const override;
        LuminosityBlockNumber_t peekAheadAtLumi() const override;
        EntryNumber_t peekAheadAtEventEntry() const override;
        bool skipLumiInRun() override;
        bool lumiEntryValid(int index) const override;

      private:

        void initializeLumi_() override;
        bool nextEventRange() override;
        bool previousEventRange() override;
        bool setToLastEventInRange(int index) override;
        EntryType getRunOrLumiEntryType(int index) const override;
        bool isSameLumi(int index1, int index2) const override;
        bool isSameRun(int index1, int index2) const override;
      };

      //*****************************************************************************
      //*****************************************************************************

      class IndexIntoFileItr {
      public:
        IndexIntoFileItr(IndexIntoFile const* indexIntoFile,
                         SortOrder sortOrder,
                         EntryType entryType,
                         int indexToRun,
                         int indexToLumi,
                         int indexToEventRange,
                         long long indexToEvent,
                         long long nEvents);


        EntryType getEntryType() const {return impl_->getEntryType();}
        int processHistoryIDIndex() const {return impl_->processHistoryIDIndex();}
        RunNumber_t run() const {return impl_->run();}
        LuminosityBlockNumber_t lumi() const {return impl_->lumi();}
        EntryNumber_t entry() const {return impl_->entry();}

        LuminosityBlockNumber_t peekAheadAtLumi() const { return impl_->peekAheadAtLumi(); }

        EntryNumber_t peekAheadAtEventEntry() const { return impl_->peekAheadAtEventEntry(); }

        EntryNumber_t firstEventEntryThisRun() { return impl_->firstEventEntryThisRun(); }
        EntryNumber_t firstEventEntryThisLumi() { return impl_->firstEventEntryThisLumi(); }

        // This is intentionally not implemented.
        // It would be difficult to implement for the no sort mode,
        // either slow or using extra memory.
        // It would be easy to implement for the sorted iteration,
        // but I did not implement it so both cases would offer a
        // consistent interface.
        // It looks like in all cases where this would be needed
        // it would not be difficult to get the event number
        // directly from the event auxiliary.
        // We may need to revisit this decision in the future.
        // EventNumber_t event() const;


        IndexIntoFileItr&  operator++() {
          impl_->next();
          return *this;
        }

        void skipEventForward(int& phIndexOfSkippedEvent,
                              RunNumber_t& runOfSkippedEvent,
                              LuminosityBlockNumber_t& lumiOfSkippedEvent,
                              EntryNumber_t& skippedEventEntry) {
          impl_->skipEventForward(phIndexOfSkippedEvent, runOfSkippedEvent, lumiOfSkippedEvent, skippedEventEntry);
        }

        void skipEventBackward(int& phIndexOfEvent,
                               RunNumber_t& runOfEvent,
                               LuminosityBlockNumber_t& lumiOfEvent,
                               EntryNumber_t& eventEntry) {
          impl_->skipEventBackward(phIndexOfEvent, runOfEvent, lumiOfEvent, eventEntry);
        }

        bool skipLumiInRun() { return impl_->skipLumiInRun(); }

        bool skipToNextEventInLumi() { return impl_->skipToNextEventInLumi(); }

        void advanceToNextRun() {impl_->advanceToNextRun();}
        void advanceToNextLumiOrRun() {impl_->advanceToNextLumiOrRun();}

        void advanceToEvent();
        void advanceToLumi();

        bool operator==(IndexIntoFileItr const& right) const {
          return *impl_ == *right.impl_;
        }

        bool operator!=(IndexIntoFileItr const& right) const {
          return !(*this == right);
        }

        void initializeRun() {impl_->initializeRun();}

        void initializeLumi() {impl_->initializeLumi();}

        void copyPosition(IndexIntoFileItr const& position);

      private:
        //for testing
        friend class ::TestIndexIntoFile;
        friend class ::TestIndexIntoFile3;
        friend class ::TestIndexIntoFile4;
        friend class ::TestIndexIntoFile5;
        
        // The rest of these are intended to be used only by code which tests
        // this class.
        IndexIntoFile const* indexIntoFile() const { return impl_->indexIntoFile(); }
        int size() const { return impl_->size(); }
        EntryType type() const { return impl_->type(); }
        int indexToRun() const { return impl_->indexToRun(); }
        int indexToLumi() const { return impl_->indexToLumi(); }
        int indexToEventRange() const { return impl_->indexToEventRange(); }
        long long indexToEvent() const { return impl_->indexToEvent(); }
        long long nEvents() const { return impl_->nEvents(); }

        value_ptr<IndexIntoFileItrImpl> impl_;
      };

      //*****************************************************************************
      //*****************************************************************************

      class IndexRunKey {
      public:
        IndexRunKey(int index, RunNumber_t run) :
          processHistoryIDIndex_(index),
          run_(run) {
        }

        int processHistoryIDIndex() const {return processHistoryIDIndex_;}
        RunNumber_t run() const {return run_;}

        bool operator<(IndexRunKey const& right) const {
          if (processHistoryIDIndex_ == right.processHistoryIDIndex()) {
            return run_ < right.run();
          }
          return processHistoryIDIndex_ < right.processHistoryIDIndex();
        }

      private:
        int processHistoryIDIndex_;
        RunNumber_t run_;
      };

      //*****************************************************************************
      //*****************************************************************************

      class IndexRunLumiKey {
      public:
        IndexRunLumiKey(int index, RunNumber_t run, LuminosityBlockNumber_t lumi) :
          processHistoryIDIndex_(index),
          run_(run),
          lumi_(lumi) {
        }

        int processHistoryIDIndex() const {return processHistoryIDIndex_;}
        RunNumber_t run() const {return run_;}
        LuminosityBlockNumber_t lumi() const {return lumi_;}

        bool operator<(IndexRunLumiKey const& right) const {
          if (processHistoryIDIndex_ == right.processHistoryIDIndex()) {
            if (run_ == right.run()) {
              return lumi_ < right.lumi();
            }
            return run_ < right.run();
          }
          return processHistoryIDIndex_ < right.processHistoryIDIndex();
        }

      private:
        int processHistoryIDIndex_;
        RunNumber_t run_;
        LuminosityBlockNumber_t lumi_;
      };

      //*****************************************************************************
      //*****************************************************************************

      class IndexRunLumiEventKey {
      public:
        IndexRunLumiEventKey(int index, RunNumber_t run, LuminosityBlockNumber_t lumi, EventNumber_t event) :
          processHistoryIDIndex_(index),
          run_(run),
          lumi_(lumi),
          event_(event) {
        }

        int processHistoryIDIndex() const {return processHistoryIDIndex_;}
        RunNumber_t run() const {return run_;}
        LuminosityBlockNumber_t lumi() const {return lumi_;}
        EventNumber_t event() const {return event_;}

        bool operator<(IndexRunLumiEventKey const& right) const {
          if (processHistoryIDIndex_ == right.processHistoryIDIndex()) {
            if (run_ == right.run()) {
              if (lumi_ == right.lumi()) {
                return event_ < right.event();
              }
              return lumi_ < right.lumi();
            }
            return run_ < right.run();
          }
          return processHistoryIDIndex_ < right.processHistoryIDIndex();
        }

      private:
        int processHistoryIDIndex_;
        RunNumber_t run_;
        LuminosityBlockNumber_t lumi_;
        EventNumber_t event_;
      };

      //*****************************************************************************
      //*****************************************************************************

      class EventFinder {
      public:
        virtual ~EventFinder() {}
        virtual EventNumber_t getEventNumberOfEntry(EntryNumber_t entry) const = 0;
      };

      //*****************************************************************************
      //*****************************************************************************

      // The next two functions are used by the output module to fill the
      // persistent data members.

      void addEntry(ProcessHistoryID const& processHistoryID,
                    RunNumber_t run,
                    LuminosityBlockNumber_t lumi,
                    EventNumber_t event,
                    EntryNumber_t entry);

      void sortVector_Run_Or_Lumi_Entries();

      //used internally by addEntry
      void addLumi(int index, RunNumber_t run, LuminosityBlockNumber_t lumi, EntryNumber_t entry);
      //*****************************************************************************
      //*****************************************************************************

      // The next group of functions is used by the PoolSource (or other
      // input related code) to fill the IndexIntoFile.

      void fixIndexes(std::vector<ProcessHistoryID>& processHistoryIDs);

      void setNumberOfEvents(EntryNumber_t nevents) const {
        transient_.numberOfEvents_ = nevents;
      }

      void setEventFinder(std::shared_ptr<EventFinder> ptr) const {transient_.eventFinder_ = ptr;}

      void fillEventNumbers() const;

      void fillEventEntries() const;

      void fillEventNumbersOrEntries(bool needEventNumbers, bool needEventEntries) const;

      std::vector<EventNumber_t>& unsortedEventNumbers() const {return transient_.unsortedEventNumbers_;}

      void inputFileClosed() const;

      void doneFileInitialization() const;

      std::vector<RunOrLumiEntry>& setRunOrLumiEntries() {return runOrLumiEntries_;}

      std::vector<ProcessHistoryID>& setProcessHistoryIDs() {return processHistoryIDs_;}

      void reduceProcessHistoryIDs(ProcessHistoryRegistry const& processHistoryRegistry);

      //*****************************************************************************
      //*****************************************************************************

      std::vector<RunOrLumiEntry> const& runOrLumiEntries() const {return runOrLumiEntries_;}

      //*****************************************************************************
      //*****************************************************************************

      void initializeTransients() const {transient_.reset();}

      struct Transients {
        Transients();
        void reset();
        int previousAddedIndex_;
        std::map<IndexRunKey, EntryNumber_t> runToOrder_;
        std::map<IndexRunLumiKey, EntryNumber_t> lumiToOrder_;
        EntryNumber_t beginEvents_;
        EntryNumber_t endEvents_;
        int currentIndex_;
        RunNumber_t currentRun_;
        LuminosityBlockNumber_t currentLumi_;
        EntryNumber_t numberOfEvents_;
        edm::propagate_const<std::shared_ptr<EventFinder>> eventFinder_;
        std::vector<RunOrLumiIndexes> runOrLumiIndexes_;
        std::vector<EventNumber_t> eventNumbers_;
        std::vector<EventEntry> eventEntries_;
        std::vector<EventNumber_t> unsortedEventNumbers_;
      };

    private:

      //for testing
      friend class ::TestIndexIntoFile;
      friend class ::TestIndexIntoFile1;
      friend class ::TestIndexIntoFile2;
      friend class ::TestIndexIntoFile3;
      friend class ::TestIndexIntoFile4;
      friend class ::TestIndexIntoFile5;

      void fillRunOrLumiIndexes() const;

      void fillUnsortedEventNumbers() const;
      void resetEventFinder() const {transient_.eventFinder_ = nullptr;} // propagate_const<T> has no reset() function
      std::vector<EventEntry>& eventEntries() const {return transient_.eventEntries_;}
      std::vector<EventNumber_t>& eventNumbers() const {return transient_.eventNumbers_;}
      void sortEvents() const;
      void sortEventEntries() const;
      int& previousAddedIndex() const {return transient_.previousAddedIndex_;}
      std::map<IndexRunKey, EntryNumber_t>& runToOrder() const {return transient_.runToOrder_;}
      std::map<IndexRunLumiKey, EntryNumber_t>& lumiToOrder() const {return transient_.lumiToOrder_;}
      EntryNumber_t& beginEvents() const {return transient_.beginEvents_;}
      EntryNumber_t& endEvents() const {return transient_.endEvents_;}
      int& currentIndex() const {return transient_.currentIndex_;}
      RunNumber_t& currentRun() const {return transient_.currentRun_;}
      LuminosityBlockNumber_t& currentLumi() const {return transient_.currentLumi_;}
      std::vector<RunOrLumiIndexes>& runOrLumiIndexes() const {return transient_.runOrLumiIndexes_;}
      size_t numberOfEvents() const {return transient_.numberOfEvents_;}
      EventNumber_t getEventNumberOfEntry(EntryNumber_t entry) const {
        return transient_.eventFinder_->getEventNumberOfEntry(entry);
      }

      mutable Transients transient_;

      std::vector<ProcessHistoryID> processHistoryIDs_; // of reduced process histories
      std::vector<RunOrLumiEntry> runOrLumiEntries_;
  };

  template <>
  struct value_ptr_traits<IndexIntoFile::IndexIntoFileItrImpl> {
    static IndexIntoFile::IndexIntoFileItrImpl* clone(IndexIntoFile::IndexIntoFileItrImpl const* p) {return p->clone();}
    static void destroy(IndexIntoFile::IndexIntoFileItrImpl* p) { delete p; }
  };


  class Compare_Index_Run {
  public:
    bool operator()(IndexIntoFile::RunOrLumiIndexes const& lh, IndexIntoFile::RunOrLumiIndexes const& rh);
  };

  class Compare_Index {
  public:
    bool operator()(IndexIntoFile::RunOrLumiIndexes const& lh, IndexIntoFile::RunOrLumiIndexes const& rh);
  };
}

#endif