#include "Source.h"

Inheritance diagram for art::Source< T >:

Public Types
using	Parameters = typename detail::maybe_has_Parameters< T >::Parameters

enum	ProcessingMode { Runs, RunsAndSubRuns, RunsSubRunsAndEvents }

Public Member Functions
template<typename U = Parameters>
	Source (std::enable_if_t< std::is_same_v< U, fhicl::ParameterSet >, fhicl::ParameterSet > const &p, InputSourceDescription &d)

template<typename U = Parameters>
	Source (std::enable_if_t<!std::is_same_v< U, fhicl::ParameterSet >, U > const &p, InputSourceDescription &d)

	Source (Source< T > const &)=delete

	Source (Source< T > &&)=delete

Source< T > &	operator= (Source< T > const &)=delete

Source< T > &	operator= (Source< T > &&)=delete

virtual void	doBeginJob ()

virtual void	doEndJob ()

virtual void	skipEvents (int n)

ModuleDescription const &	moduleDescription () const

ProcessConfiguration const &	processConfiguration () const

Static Public Member Functions
static ProcessingMode	mode (std::string const &modeString)

Private Member Functions
input::ItemType	nextItemType () override

std::unique_ptr< FileBlock >	readFile () override

void	closeFile () override

std::unique_ptr< RunPrincipal >	readRun () override

std::unique_ptr< SubRunPrincipal >	readSubRun (cet::exempt_ptr< RunPrincipal const > rp) override

std::unique_ptr< EventPrincipal >	readEvent (cet::exempt_ptr< SubRunPrincipal const > srp) override

std::unique_ptr< RangeSetHandler >	runRangeSetHandler () override

std::unique_ptr< RangeSetHandler >	subRunRangeSetHandler () override

void	finishProductRegistration_ (InputSourceDescription &d)

bool	readNext_ ()

void	checkForNextFile_ ()

void	readNextAndRequireRun_ ()

void	readNextAndRefuseEvent_ ()

void	throwIfInsane_ (bool result, RunPrincipal newR, SubRunPrincipal newSR, EventPrincipal *newE) const

Static Private Member Functions
static void	throwDataCorruption_ (const char *msg)

Private Attributes
ProductRegistryHelper	h_ {product_creation_mode::reconstitutes}

UpdateOutputCallbacks &	outputCallbacks_

ProductTables	presentProducts_ {ProductTables::invalid()}

SourceHelper	sourceHelper_

T	detail_

input::ItemType	state_ {input::IsInvalid}

detail::FileNamesHandler< Source_wantFileServices< T >::value >	fh_

std::string	currentFileName_ {}

std::unique_ptr< RunPrincipal >	newRP_ {}

std::unique_ptr< SubRunPrincipal >	newSRP_ {}

std::unique_ptr< EventPrincipal >	newE_ {}

cet::exempt_ptr< RunPrincipal >	cachedRP_ {nullptr}

cet::exempt_ptr< SubRunPrincipal >	cachedSRP_ {nullptr}

bool	pendingSubRun_ {false}

bool	pendingEvent_ {false}

bool	subRunIsNew_ {false}

SubRunNumber_t	remainingSubRuns_ {1}

bool	haveSRLimit_ {false}

EventNumber_t	remainingEvents_ {1}

bool	haveEventLimit_ {false}

Detailed Description

template<typename T>
class art::Source< T >

Definition at line 118 of file Source.h.

Member Typedef Documentation

template<typename T >

using art::Source< T >::Parameters = typename detail::maybe_has_Parameters<T>::Parameters

Definition at line 202 of file Source.h.

Member Enumeration Documentation

enum art::InputSource::ProcessingMode

inherited

Enumerator
Runs
RunsAndSubRuns
RunsSubRunsAndEvents

Definition at line 61 of file InputSource.h.

                         {
       Runs,                // 0
       RunsAndSubRuns,      // 1
       RunsSubRunsAndEvents // 2
     };

Constructor & Destructor Documentation

template<typename T >

template<typename U >

art::Source< T >::Source	(	std::enable_if_t< std::is_same_v< U, fhicl::ParameterSet >, fhicl::ParameterSet > const &	p,
		InputSourceDescription &	d
	)

explicit

Definition at line 298 of file Source.h.

References d, art::Source< T >::detail_, art::Source< T >::fh_, art::Source< T >::finishProductRegistration_(), art::Source< T >::h_, art::Source< T >::haveEventLimit_, art::Source< T >::haveSRLimit_, art::InputSourceDescription::moduleDescription, art::Source< T >::outputCallbacks_, art::Source< T >::remainingEvents_, art::Source< T >::remainingSubRuns_, and art::Source< T >::sourceHelper_.

     : InputSource{d.moduleDescription}
     , outputCallbacks_{d.productRegistry}
     , sourceHelper_{d.moduleDescription}
     , detail_{p, h_, sourceHelper_}
     , fh_{p.template get<std::vector<std::string>>("fileNames", {})}
   {
     int64_t const maxSubRuns_par = p.template get<int64_t>("maxSubRuns", -1);
     if (maxSubRuns_par > -1) {
       remainingSubRuns_ = maxSubRuns_par;
       haveSRLimit_ = true;
     }
     int64_t const maxEvents_par = p.template get<int64_t>("maxEvents", -1);
     if (maxEvents_par > -1) {
       remainingEvents_ = maxEvents_par;
       haveEventLimit_ = true;
     }
     finishProductRegistration_(d);
   }

template<typename T >

template<typename U >

art::Source< T >::Source	(	std::enable_if_t<!std::is_same_v< U, fhicl::ParameterSet >, U > const &	p,
		InputSourceDescription &	d
	)

explicit

Definition at line 322 of file Source.h.

References d, art::Source< T >::detail_, art::Source< T >::fh_, art::Source< T >::finishProductRegistration_(), art::Source< T >::h_, art::Source< T >::haveEventLimit_, art::Source< T >::haveSRLimit_, art::InputSourceDescription::moduleDescription, art::Source< T >::outputCallbacks_, art::Source< T >::remainingEvents_, and art::Source< T >::remainingSubRuns_.

     : InputSource{d.moduleDescription}
     , outputCallbacks_{d.productRegistry}
     , sourceHelper_{d.moduleDescription}
     , detail_{p().userConfig, h_, sourceHelper_}
     , fh_{p().sourceConfig().fileNames()}
   {
     if (int64_t const maxSubRuns_par = p().sourceConfig().maxSubRuns();
         maxSubRuns_par > -1) {
       remainingSubRuns_ = maxSubRuns_par;
       haveSRLimit_ = true;
     }
     if (int64_t const maxEvents_par = p().sourceConfig().maxEvents();
         maxEvents_par > -1) {
       remainingEvents_ = maxEvents_par;
       haveEventLimit_ = true;
     }
     finishProductRegistration_(d);
   }

template<typename T >

art::Source< T >::Source ( Source< T > const & )

delete

template<typename T >

art::Source< T >::Source ( Source< T > && )

delete

Member Function Documentation

template<typename T >

void art::Source< T >::checkForNextFile_ ( )

private

Definition at line 502 of file Source.h.

References art::Source< T >::currentFileName_, art::Source< T >::detail_, art::Source< T >::fh_, art::input::IsFile, art::input::IsStop, art::Source< T >::state_, and value.

Referenced by art::Source< T >::nextItemType(), art::Source< T >::readNextAndRefuseEvent_(), and art::Source< T >::readNextAndRequireRun_().

   {
     state_ = input::IsStop; // Default -- may change below.
     if (Source_generator<T>::value) {
       std::conditional_t<detail::has_hasMoreData<T>::value,
                          detail::do_call_hasMoreData<T>,
                          detail::do_not_call_hasMoreData<T>>
         generatorHasMoreData;
       if (generatorHasMoreData(detail_)) {
         state_ = input::IsFile;
       }
     } else {
       currentFileName_ = fh_.next();
       if (!currentFileName_.empty()) {
         state_ = input::IsFile;
       }
     }
   }

template<typename T >

void art::Source< T >::closeFile ( )

overrideprivatevirtual

Implements art::InputSource.

Definition at line 650 of file Source.h.

References art::Source< T >::cachedRP_, art::Source< T >::cachedSRP_, and art::Source< T >::detail_.

   {
     detail_.closeCurrentFile();
     // Cached pointers are no longer valid since the PrincipalCache is
     // cleared after file close.
     cachedRP_ = nullptr;
     cachedSRP_ = nullptr;
   }

void art::InputSource::doBeginJob ( )

virtualinherited

Reimplemented in art::EmptyEvent.

Definition at line 54 of file InputSource.cc.

55 {}

void art::InputSource::doEndJob ( )

virtualinherited

Reimplemented in art::EmptyEvent.

Definition at line 58 of file InputSource.cc.

59 {}

template<typename T >

void art::Source< T >::finishProductRegistration_ ( InputSourceDescription & d )

private

Definition at line 703 of file Source.h.

References art::Source< T >::h_, fhicl::ParameterSet::id(), art::UpdateOutputCallbacks::invoke(), art::legacy, art::InputSourceDescription::moduleDescription, art::Source< T >::outputCallbacks_, art::Source< T >::presentProducts_, art::ModuleDescription::processConfiguration(), and art::ProductRegistryHelper::registerProducts().

Referenced by art::Source< T >::Source().

   {
     // These _xERROR_ strings should never appear in branch names; they
     // are here as tracers to help identify any failures in coding.
     ProductDescriptions descriptions;
     h_.registerProducts(
       descriptions,
       ModuleDescription{fhicl::ParameterSet{}.id(), // Dummy
                         "_NAMEERROR_",
                         "_LABELERROR_",
                         ModuleThreadingType::legacy,
                         d.moduleDescription.processConfiguration(),
                         true /*isEmulated*/});
     presentProducts_ = ProductTables{descriptions};
     sourceHelper_.setPresentProducts(cet::make_exempt_ptr(&presentProducts_));
     outputCallbacks_.invoke(presentProducts_);
   }

InputSource::ProcessingMode art::InputSource::mode ( std::string const & modeString )

staticinherited

Definition at line 9 of file InputSource.cc.

References art::errors::Configuration, art::InputSource::Runs, art::InputSource::RunsAndSubRuns, and art::InputSource::RunsSubRunsAndEvents.

Referenced by art::ProcessingLimits::ProcessingLimits().

   {
     if (modeString == "Runs") {
       return Runs;
     }
     if (modeString == "RunsAndSubRuns") {
       return RunsAndSubRuns;
     }
     if (modeString == "RunsSubRunsAndEvents") {
       return RunsSubRunsAndEvents;
     }
     throw Exception(errors::Configuration)
       << "The 'processingMode' parameter for sources has an illegal value '"
       << modeString << "'\n"
       << "Legal values are 'Runs', 'RunsAndSubRuns', or "
          "'RunsSubRunsAndEvents'.\n";
   }

ModuleDescription const & art::InputSource::moduleDescription ( ) const

inherited

Definition at line 31 of file InputSource.cc.

References art::InputSource::moduleDescription_.

Referenced by art::EmptyEvent::readRun(), and art::EmptyEvent::readSubRun().

   {
     return moduleDescription_;
   }

template<typename T >

input::ItemType art::Source< T >::nextItemType ( )

overrideprivatevirtual

Implements art::InputSource.

Definition at line 523 of file Source.h.

References art::Source< T >::cachedSRP_, art::Source< T >::checkForNextFile_(), art::Source< T >::currentFileName_, art::errors::DataCorruption, art::Source< T >::fh_, art::input::IsEvent, art::input::IsFile, art::input::IsInvalid, art::input::IsRun, art::input::IsStop, art::input::IsSubRun, art::Source< T >::newE_, art::Source< T >::pendingEvent_, art::Source< T >::pendingSubRun_, art::Source< T >::readNext_(), art::Source< T >::readNextAndRefuseEvent_(), art::Source< T >::readNextAndRequireRun_(), art::Source< T >::remainingEvents_, art::Source< T >::remainingSubRuns_, and art::Source< T >::state_.

   {
     if (remainingEvents_ == 0) {
       state_ = input::IsStop;
     }
     switch (state_) {
     case input::IsInvalid:
       if (Source_generator<T>::value) {
         state_ = input::IsFile; // Once.
       } else {
         checkForNextFile_();
       }
       break;
     case input::IsFile:
       readNextAndRequireRun_();
       break;
     case input::IsRun:
       if (pendingSubRun_ || (pendingEvent_ && cachedSRP_)) {
         state_ = input::IsSubRun;
         pendingSubRun_ = false;
       } else if (pendingEvent_)
         throw Exception(errors::DataCorruption)
           << "Input file '" << currentFileName_ << "' contains an Event "
           << newE_->eventID() << " that belongs to no SubRun\n";
       else {
         readNextAndRequireRun_();
       }
       break;
     case input::IsSubRun:
       if (pendingEvent_) {
         state_ = input::IsEvent;
         pendingEvent_ = false;
       } else {
         readNextAndRefuseEvent_();
       }
       break;
     case input::IsEvent:
       if (!readNext_()) {
         checkForNextFile_();
       }
       break;
     case input::IsStop:
       break;
     }
     if ((state_ == input::IsRun || state_ == input::IsSubRun) &&
         remainingSubRuns_ == 0) {
       state_ = input::IsStop;
     }
     if (state_ == input::IsStop) {
       // FIXME: upon the advent of a catalog system which can do something
       // intelligent with the difference between whole-file success,
       // partial-file success, partial-file failure and whole-file failure
       // (such as file-open failure), we will need to communicate that
       // difference here. The file disposition options as they are now
       // (and the mapping to any concrete implementation we are are aware
       // of currently) are not sufficient to the task, so we deliberately
       // do not distinguish here between partial-file and whole-file
       // success in particular.
       fh_.finish();
     }
     return state_;
   }

template<typename T >

Source<T>& art::Source< T >::operator= ( Source< T > const & )

delete

template<typename T >

Source<T>& art::Source< T >::operator= ( Source< T > && )

delete

ProcessConfiguration const & art::InputSource::processConfiguration ( ) const

inherited

Definition at line 37 of file InputSource.cc.

References art::InputSource::moduleDescription_, and art::ModuleDescription::processConfiguration().

Referenced by art::EmptyEvent::readEvent(), art::EmptyEvent::readRun(), and art::EmptyEvent::readSubRun().

   {
     return moduleDescription_.processConfiguration();
   }

template<typename T >

std::unique_ptr< EventPrincipal > art::Source< T >::readEvent ( cet::exempt_ptr< SubRunPrincipal const > srp )

overrideprivatevirtual

Implements art::InputSource.

Definition at line 693 of file Source.h.

References art::Source< T >::haveEventLimit_, art::Source< T >::newE_, and art::Source< T >::remainingEvents_.

   {
     if (haveEventLimit_) {
       --remainingEvents_;
     }
     return std::move(newE_);
   }

template<typename T >

std::unique_ptr< FileBlock > art::Source< T >::readFile ( )

overrideprivatevirtual

Implements art::InputSource.

Definition at line 637 of file Source.h.

References art::Source< T >::currentFileName_, art::Source< T >::detail_, and art::errors::LogicError.

   {
     FileBlock* newF{nullptr};
     detail_.readFile(currentFileName_, newF);
     if (!newF) {
       throw Exception(errors::LogicError)
         << "detail_::readFile() failed to return a valid FileBlock object\n";
     }
     return std::unique_ptr<FileBlock>(newF);
   }

template<typename T >

bool art::Source< T >::readNext_ ( )

private

Definition at line 455 of file Source.h.

References art::Source< T >::cachedRP_, art::Source< T >::cachedSRP_, art::Source< T >::detail_, art::input::IsEvent, art::input::IsRun, art::input::IsSubRun, art::Source< T >::newE_, art::Source< T >::newRP_, art::Source< T >::newSRP_, art::Source< T >::pendingEvent_, art::Source< T >::pendingSubRun_, art::Source< T >::state_, art::Source< T >::subRunIsNew_, and art::Source< T >::throwIfInsane_().

Referenced by art::Source< T >::nextItemType(), art::Source< T >::readNextAndRefuseEvent_(), and art::Source< T >::readNextAndRequireRun_().

   {
     std::unique_ptr<RunPrincipal> newR{nullptr};
     std::unique_ptr<SubRunPrincipal> newSR{nullptr};
     std::unique_ptr<EventPrincipal> newE{nullptr};
     bool result{false};
     {
       RunPrincipal* nR{nullptr};
       SubRunPrincipal* nSR{nullptr};
       EventPrincipal* nE{nullptr};
       result = detail_.readNext(cachedRP_.get(), cachedSRP_.get(), nR, nSR, nE);
       newR.reset(nR);
       newSR.reset(nSR);
       newE.reset(nE);
       throwIfInsane_(result, newR.get(), newSR.get(), newE.get());
     }
     if (result) {
       subRunIsNew_ =
         newSR && ((!cachedSRP_) || newSR->subRunID() != cachedSRP_->subRunID());
       pendingSubRun_ = newSR.get() != nullptr;
       pendingEvent_ = newE.get() != nullptr;
       if (newR) {
         newRP_ = std::move(newR);
       }
       if (newSR) {
         auto rp = newRP_ ? newRP_.get() : cachedRP_.get();
         newSR->setRunPrincipal(rp);
         newSRP_ = std::move(newSR);
       }
       if (newE) {
         auto srp = newSRP_ ? newSRP_.get() : cachedSRP_.get();
         newE->setSubRunPrincipal(srp);
         newE_ = std::move(newE);
       }
       if (newRP_) {
         state_ = input::IsRun;
       } else if (newSRP_) {
         state_ = input::IsSubRun;
       } else if (newE_) {
         state_ = input::IsEvent;
       }
     }
     return result;
   }

template<typename T >

void art::Source< T >::readNextAndRefuseEvent_ ( )

private

Definition at line 608 of file Source.h.

References art::Source< T >::checkForNextFile_(), art::Source< T >::currentFileName_, art::errors::DataCorruption, art::input::IsEvent, art::Source< T >::readNext_(), and art::Source< T >::state_.

Referenced by art::Source< T >::nextItemType().

   {
     if (readNext_()) {
       if (state_ == input::IsEvent) {
         throw Exception(errors::DataCorruption)
           << "Input file '" << currentFileName_
           << "' has an Event where a Run or SubRun is expected\n";
       }
     } else {
       checkForNextFile_();
     }
   }

template<typename T >

void art::Source< T >::readNextAndRequireRun_ ( )

private

Definition at line 588 of file Source.h.

References art::Source< T >::cachedRP_, art::Source< T >::checkForNextFile_(), art::Source< T >::currentFileName_, art::errors::DataCorruption, art::input::IsRun, art::input::IsSubRun, art::Source< T >::readNext_(), and art::Source< T >::state_.

Referenced by art::Source< T >::nextItemType().

   {
     if (readNext_()) {
       if (state_ != input::IsRun) {
         if (cachedRP_) {
           state_ = input::IsRun; // Regurgitate existing cached run.
         } else {
           throw Exception(errors::DataCorruption)
             << "Input file '" << currentFileName_ << "' has a"
             << (state_ == input::IsSubRun ? " SubRun" : "n Event")
             << " where a Run is expected\n";
         }
       }
     } else {
       checkForNextFile_();
     }
   }

template<typename T >

std::unique_ptr< RunPrincipal > art::Source< T >::readRun ( )

overrideprivatevirtual

Implements art::InputSource.

Definition at line 661 of file Source.h.

References art::Source< T >::cachedRP_, art::errors::LogicError, and art::Source< T >::newRP_.

   {
     if (!newRP_)
       throw Exception(errors::LogicError)
         << "Error in Source<T>\n"
         << "readRun() called when no RunPrincipal exists\n"
         << "Please report this to the art developers\n";
     cachedRP_ = newRP_.get();
     return std::move(newRP_);
   }

template<typename T >

std::unique_ptr< SubRunPrincipal > art::Source< T >::readSubRun ( cet::exempt_ptr< RunPrincipal const > rp )

overrideprivatevirtual

Implements art::InputSource.

Definition at line 674 of file Source.h.

References art::Source< T >::cachedSRP_, art::Source< T >::haveSRLimit_, art::errors::LogicError, art::Source< T >::newSRP_, art::Source< T >::remainingSubRuns_, and art::Source< T >::subRunIsNew_.

   {
     if (!newSRP_)
       throw Exception(errors::LogicError)
         << "Error in Source<T>\n"
         << "readSubRun() called when no SubRunPrincipal exists\n"
         << "Please report this to the art developers\n";
     if (subRunIsNew_) {
       if (haveSRLimit_) {
         --remainingSubRuns_;
       }
       subRunIsNew_ = false;
     }
     cachedSRP_ = newSRP_.get();
     return std::move(newSRP_);
   }

template<typename T >

std::unique_ptr< RangeSetHandler > art::Source< T >::runRangeSetHandler ( )

overrideprivatevirtual

Implements art::InputSource.

Definition at line 623 of file Source.h.

References art::Source< T >::cachedRP_.

   {
     return std::make_unique<OpenRangeSetHandler>(cachedRP_->run());
   }

void art::InputSource::skipEvents ( int n )

virtualinherited

Reimplemented in art::EmptyEvent.

Definition at line 43 of file InputSource.cc.

References art::errors::Configuration.

   {
     throw Exception(errors::Configuration)
       << "The application has tried to peform random access on an input "
          "source\n"
       << "that does not support random access. Please reconfigure the program\n"
       << "to use an input source that supports random access (e.g. "
          "RootInput)\n";
   }

template<typename T >

std::unique_ptr< RangeSetHandler > art::Source< T >::subRunRangeSetHandler ( )

overrideprivatevirtual

Implements art::InputSource.

Definition at line 630 of file Source.h.

References art::Source< T >::cachedSRP_.

   {
     return std::make_unique<OpenRangeSetHandler>(cachedSRP_->run());
   }

template<typename T >

void art::Source< T >::throwDataCorruption_ ( const char * msg )

staticprivate

Definition at line 346 of file Source.h.

References art::errors::DataCorruption.

Referenced by art::Source< T >::throwIfInsane_().

   {
     throw Exception(errors::DataCorruption) << msg;
   }

template<typename T >

void art::Source< T >::throwIfInsane_	(	bool	result,
		RunPrincipal *	newR,
		SubRunPrincipal *	newSR,
		EventPrincipal *	newE
	)		const

private

Definition at line 353 of file Source.h.

References art::Source< T >::cachedRP_, art::Source< T >::cachedSRP_, art::EventPrincipal::eventID(), art::RunID::isValid(), art::SubRunID::isValid(), art::EventID::isValid(), art::errors::LogicError, art::SubRunID::runID(), art::RunPrincipal::runID(), art::EventID::subRunID(), art::SubRunPrincipal::subRunID(), and art::Source< T >::throwDataCorruption_().

Referenced by art::Source< T >::readNext_().

   {
     std::ostringstream errMsg;
     if (result) {
       if (!newR && !newSR && !newE) {
         throw Exception{errors::LogicError}
           << "readNext returned true but created no new data\n";
       }
       if (!cachedRP_ && !newR) {
         throw Exception(errors::LogicError)
           << "readNext returned true but no RunPrincipal has been set, and no "
              "cached RunPrincipal exists.\n"
              "This can happen if a new input file has been opened and the "
              "RunPrincipal has not been appropriately assigned.";
       }
       if (!cachedSRP_ && !newSR) {
         throw Exception(errors::LogicError)
           << "readNext returned true but no SubRunPrincipal has been set, and "
              "no cached SubRunPrincipal exists.\n"
              "This can happen if a new input file has been opened and the "
              "SubRunPrincipal has not been appropriately assigned.";
       }
       if (cachedRP_ && newR && cachedRP_.get() == newR) {
         errMsg << "readNext returned a new Run which is the old Run for "
                << cachedRP_->runID()
                << ".\nIf you don't have a new run, don't return one!\n";
       }
       if (cachedSRP_ && newSR && cachedSRP_.get() == newSR) {
         errMsg << "readNext returned a new SubRun which is the old SubRun for "
                << cachedSRP_->subRunID()
                << ".\nIf you don't have a new subRun, don't return one!\n";
       }
       // Either or both of the above cases could be true and we need
       // to make both of them safe before we throw:
       if (!errMsg.str().empty())
         throw Exception(errors::LogicError) << errMsg.str();
       if (cachedRP_ && cachedSRP_) {
         if (!newR && newSR && newSR->subRunID() == cachedSRP_->subRunID())
           throwDataCorruption_("readNext returned a 'new' SubRun "
                                "that was the same as the previous "
                                "SubRun\n");
         if (newR && newR->runID() == cachedRP_->runID())
           throwDataCorruption_("readNext returned a 'new' Run "
                                "that was the same as the previous "
                                "Run\n");
         if (newR && !newSR && newE)
           throwDataCorruption_("readNext returned a new Run and "
                                "Event without a SubRun\n");
         if (newR && newSR && newSR->subRunID() == cachedSRP_->subRunID())
           throwDataCorruption_("readNext returned a new Run with "
                                "a SubRun from the wrong Run\n");
       }
       RunID rID;
       SubRunID srID;
       EventID eID;
       if (newR) {
         rID = newR->runID();
         if (!rID.isValid()) {
           throwDataCorruption_(
             "readNext returned a Run with an invalid RunID.\n");
         }
       } else if (cachedRP_) {
         rID = cachedRP_->runID();
       }
       if (newSR) {
         srID = newSR->subRunID();
         if (rID != srID.runID()) {
           errMsg << "readNext returned a SubRun " << srID
                  << " which is a mismatch to " << rID << '\n';
           throwDataCorruption_(errMsg.str().c_str());
         }
         if (!srID.isValid()) {
           throwDataCorruption_(
             "readNext returned a SubRun with an invalid SubRunID.\n");
         }
       } else if (cachedSRP_) {
         srID = cachedSRP_->subRunID();
       }
       if (newE) {
         eID = newE->eventID();
         if (srID != eID.subRunID()) {
           errMsg << "readNext returned an Event " << eID
                  << " which is a mismatch to " << srID << '\n';
           throwDataCorruption_(errMsg.str().c_str());
         }
         if (!eID.isValid()) {
           throwDataCorruption_(
             "readNext returned an Event with an invalid EventID.\n");
         }
       }
     } else {
       if (newR || newSR || newE)
         throw Exception(errors::LogicError)
           << "readNext returned false but created new data\n";
     }
   }