art::Source< T > Class Template Reference

#include <Source.h>

Inheritance diagram for art::Source< T >:

Public Types
using	Parameters = typename detail::maybe_has_Parameters< T >::Parameters
Public Types inherited from art::InputSource
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
Public Member Functions inherited from art::InputSource
virtual	~InputSource () noexcept
	InputSource (ModuleDescription const &)
	InputSource (InputSource const &)=delete
	InputSource (InputSource &&)=delete
InputSource &	operator= (InputSource const &)=delete
InputSource &	operator= (InputSource &&)=delete
virtual void	doBeginJob ()
virtual void	doEndJob ()
virtual void	skipEvents (int n)
virtual void	rewind ()
ModuleDescription const &	moduleDescription () const
ProcessConfiguration const &	processConfiguration () const

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.

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.

    : 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;
    }
    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 321 of file Source.h.

    : 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;
    }
    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 508 of file Source.h.

  {
    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 656 of file Source.h.

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

template<typename T >

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

private

Definition at line 709 of file Source.h.

  {
    // 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_);
  }

template<typename T >

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

overrideprivatevirtual

Implements art::InputSource.

Definition at line 529 of file Source.h.

  {
    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

template<typename T >

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

overrideprivatevirtual

Implements art::InputSource.

Definition at line 699 of file Source.h.

  {
    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 643 of file Source.h.

  {
    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 461 of file Source.h.

  {
    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 614 of file Source.h.

  {
    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 594 of file Source.h.

  {
    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 667 of file Source.h.

  {
    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 680 of file Source.h.

  {
    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 629 of file Source.h.

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

template<typename T >

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

overrideprivatevirtual

Implements art::InputSource.

Definition at line 636 of file Source.h.

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

template<typename T >

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

staticprivate

Definition at line 344 of file Source.h.

  {
    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 351 of file Source.h.

  {
    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");
        }
        if (newSR->runPrincipalExemptPtr()) {
          throwDataCorruption_(
            "readNext returned a SubRun with a non-null embedded Run.\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");
        }
        if (newE->subRunPrincipalPtr()) {
          throwDataCorruption_(
            "readNext returned an Event with a non-null embedded SubRun.\n");
        }
      }
    } else {
      if (newR || newSR || newE)
        throw Exception(errors::LogicError)
          << "readNext returned false but created new data\n";
    }
  }

Member Data Documentation

template<typename T >

cet::exempt_ptr<RunPrincipal> art::Source< T >::cachedRP_ {nullptr}

private

Definition at line 284 of file Source.h.

template<typename T >

cet::exempt_ptr<SubRunPrincipal> art::Source< T >::cachedSRP_ {nullptr}

private

Definition at line 285 of file Source.h.

template<typename T >

std::string art::Source< T >::currentFileName_ {}

private

Definition at line 276 of file Source.h.

template<typename T >

T art::Source< T >::detail_

private

Definition at line 273 of file Source.h.

template<typename T >

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

private

Definition at line 275 of file Source.h.

template<typename T >

ProductRegistryHelper art::Source< T >::h_ {product_creation_mode::reconstitutes}

private

Definition at line 267 of file Source.h.

template<typename T >

bool art::Source< T >::haveEventLimit_ {false}

private

Definition at line 293 of file Source.h.

template<typename T >

bool art::Source< T >::haveSRLimit_ {false}

private

Definition at line 291 of file Source.h.

template<typename T >

std::unique_ptr<EventPrincipal> art::Source< T >::newE_ {}

private

Definition at line 280 of file Source.h.

template<typename T >

std::unique_ptr<RunPrincipal> art::Source< T >::newRP_ {}

private

Definition at line 278 of file Source.h.

template<typename T >

std::unique_ptr<SubRunPrincipal> art::Source< T >::newSRP_ {}

private

Definition at line 279 of file Source.h.

template<typename T >

UpdateOutputCallbacks& art::Source< T >::outputCallbacks_

private

Definition at line 268 of file Source.h.

template<typename T >

bool art::Source< T >::pendingEvent_ {false}

private

Definition at line 288 of file Source.h.

template<typename T >

bool art::Source< T >::pendingSubRun_ {false}

private

Definition at line 287 of file Source.h.

template<typename T >

ProductTables art::Source< T >::presentProducts_ {ProductTables::invalid()}

private

Definition at line 269 of file Source.h.

template<typename T >

EventNumber_t art::Source< T >::remainingEvents_ {1}

private

Definition at line 292 of file Source.h.

template<typename T >

SubRunNumber_t art::Source< T >::remainingSubRuns_ {1}

private

Definition at line 290 of file Source.h.

template<typename T >

SourceHelper art::Source< T >::sourceHelper_

private

Definition at line 272 of file Source.h.

template<typename T >

input::ItemType art::Source< T >::state_ {input::IsInvalid}

private

Definition at line 274 of file Source.h.

template<typename T >

bool art::Source< T >::subRunIsNew_ {false}

private

Definition at line 289 of file Source.h.

---

The documentation for this class was generated from the following file:

• art/art/Framework/IO/Sources/Source.h