Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
art Namespace Reference

Namespaces

 actions
 
 compatibility
 
 detail
 
 errors
 
 ExceptionDetail
 
 fp_detail
 
 friendlyname
 
 hlt
 
 input
 
 InputSourceFactory
 
 productstatus
 
 PtrRemapperDetail
 
 rootNames
 
 stats
 
 test
 

Classes

class  ActionTable
 
class  ActivityRegistry
 
class  AndHelper
 
class  Assns
 
class  Assns< L, R, void >
 
struct  AssnsNode
 
class  AutoInputSourceMutexSentryShutdown
 
class  BasicOptionsHandler
 
class  BasicOutputOptionsHandler
 
class  BasicPostProcessor
 
class  BasicSourceOptionsHandler
 
class  BlockingPrescaler
 
class  BoolCache
 
class  BranchChildren
 
class  BranchDescription
 
class  BranchID
 
struct  BranchKey
 
struct  CannotGetView
 
class  CatalogInterface
 
class  ClosedRangeSetHandler
 
class  ClosingCriteria
 
struct  Compare_Run_SubRun_EventEntry
 
class  ComparePtrs
 
class  ComposedSelectorWrapper
 
class  const_AssnsIter
 
class  ConstPtrCache
 
class  ConsumesCollector
 
class  ConsumesInfo
 
class  DatabaseConnection
 
class  DataFlow
 
class  DataViewImpl
 
class  debugging_allocator
 
class  DebugOptionsHandler
 
struct  DebugTasksValue
 
struct  DebugValue
 
class  DecrepitRelicInputSourceImplementation
 
class  DelayedReader
 
struct  DoMakePartner
 
struct  DoNotMakePartner
 
struct  DoNotSetPtr
 
struct  DoSetPtr
 
class  EDAnalyzer
 
class  EDFilter
 
class  EDProducer
 
class  EDProduct
 
class  EDProductGetter
 
class  EmptyEvent
 
class  EmptyEventTimestampPlugin
 
struct  enable_if_function_exists_t< void(T::*)(std::vector< void const * > &), &T::getView >
 
class  EndPathExecutor
 
class  Event
 
class  EventAuxiliary
 
class  EventID
 
class  EventIDFilter
 
class  EventIDMatcher
 
class  EventPrincipal
 
struct  EventProcessHistoryID
 
class  EventProcessor
 
class  EventRange
 
class  EventSelector
 
class  ExecutionCounts
 
class  FileBlock
 
class  FileCatalog
 
class  FileCatalogItem
 
class  FileCatalogMetadata
 
class  FileCatalogMetadataPlugin
 
class  FileCatalogOptionsHandler
 
class  FileDumperOutput
 
struct  FileFormatVersion
 
class  FileIndex
 
class  FileProperties
 
class  FileStatsCollector
 
class  FileTransfer
 
class  FloatingPointControl
 
struct  FragmentSemantic
 
struct  FullSemantic
 
class  Globals
 
class  GlobalSignal
 
class  GlobalSignal< SRTYPE, ResultType(Args...)>
 
class  GlobalTaskGroup
 
class  Granularity
 
class  Group
 
class  GroupQueryResult
 
class  GroupSelector
 
class  GroupSelectorRules
 
class  Handle
 
struct  has_getView
 
struct  has_mapped_type
 
struct  has_mapped_type< T, std::void_t< typename T::mapped_type > >
 
struct  has_setPtr
 
struct  has_setPtr< cet::map_vector< T > >
 
struct  has_setPtr< custom::collection< T > >
 
struct  has_setPtr< std::deque< T, A > >
 
struct  has_setPtr< std::list< T, A > >
 
struct  has_setPtr< std::set< T, A > >
 
struct  has_setPtr< std::vector< bool, A > >
 
struct  has_setPtr< std::vector< T, A > >
 
struct  has_value_type
 
struct  has_value_type< T, std::void_t< typename T::value_type > >
 
class  Hash
 
class  History
 
class  HLTGlobalStatus
 
class  HLTPathStatus
 
struct  IDNumber
 
struct  IDNumber< Level::Event >
 
struct  IDNumber< Level::Run >
 
struct  IDNumber< Level::SubRun >
 
class  InputFileCatalog
 
class  InputSource
 
struct  InputSourceDescription
 
class  InputSourceMutexSentry
 
class  InputTag
 
struct  key_traits
 
struct  key_traits< std::pair< U, V > >
 
struct  key_traits< std::string >
 
struct  LinuxProcData
 
class  LinuxProcMgr
 
class  LocalSignal
 
class  LocalSignal< STYPE, ResultType(Args...)>
 
class  MallocOptionSetter
 
struct  MallocOpts
 
class  MatchAllSelector
 
struct  MaybeGetView
 
struct  MaybeGetView< cet::map_vector< T > >
 
struct  MaybeGetView< std::deque< T, A > >
 
struct  MaybeGetView< std::list< T, A > >
 
struct  MaybeGetView< std::set< T, A > >
 
struct  MaybeGetView< std::vector< bool, A > >
 
struct  MaybeGetView< std::vector< T, A > >
 
struct  MaybeGetView< T, std::enable_if_t< has_getView< T >::value > >
 
class  MaybeIncrementCounts
 
class  MaybeIncrementCounts< Level::Event, T >
 
class  MemoryTracker
 
class  MFStatusUpdater
 
struct  MinimalToolConfig
 
class  MixFilter
 
class  MixFilterTable
 
class  MixHelper
 
class  MixIOPolicy
 
class  MixOp
 
class  MixOpBase
 
class  Modifier
 
class  ModuleBase
 
class  ModuleContext
 
class  ModuleDescription
 
class  ModuleLabelSelector
 
class  NoDelayedReader
 
class  NotHelper
 
class  Observer
 
class  OpenRangeSetHandler
 
class  OptionsHandler
 
class  OrHelper
 
class  OutputFileInfo
 
class  OutputHandle
 
class  OutputModule
 
struct  OutputModuleDescription
 
class  OutputWorker
 
struct  ParameterSetBlob
 
class  Parentage
 
class  Path
 
class  PathContext
 
class  PathID
 
class  PathManager
 
class  PathsInfo
 
struct  PathSpec
 
class  PerScheduleContainer
 
class  PostCloseFileRenamer
 
class  Prescaler
 
struct  prevent_recursion
 
struct  prevent_recursion< Sampled< T > >
 
class  Principal
 
class  PrincipalBase
 
class  ProcessConfiguration
 
class  ProcessHistory
 
class  ProcessingFrame
 
class  ProcessingOptionsHandler
 
class  ProcessNameSelector
 
class  ProcessTag
 
class  ProdToProdMapBuilder
 
class  ProducerTable
 
class  ProducesCollector
 
class  ProducingService
 
class  ProducingServiceSignals
 
class  ProductID
 
class  ProductInfo
 
class  ProductInstanceNameSelector
 
class  ProductProvenance
 
struct  ProductRegistry
 
class  ProductRegistryHelper
 
struct  ProductTable
 
class  ProductTables
 
class  ProductToken
 
class  Provenance
 
class  ProvenanceCheckerOutput
 
class  ProvenanceDumper
 
class  ProvenanceDumper< DETAIL, std::void_t< typename DETAIL::Config > >
 
struct  ProvenanceDumperConfig
 
struct  ProvenanceDumperConfig< DETAIL, std::void_t< typename DETAIL::Config > >
 
class  Ptr
 
class  PtrMaker
 
class  PtrRemapper
 
class  PtrVector
 
class  PtrVectorBase
 
class  RandomNumberGenerator
 
class  RandomNumberSaver
 
struct  RangedFragmentSemantic
 
class  RangeSet
 
class  RangeSetHandler
 
class  RefCore
 
class  ReplicatedAnalyzer
 
class  ReplicatedFilter
 
class  ReplicatedProducer
 
class  Results
 
class  ResultsAuxiliary
 
class  ResultsPrincipal
 
class  ResultsProducer
 
class  RNGsnapshot
 
class  RPManager
 
struct  RPParams
 
class  RPWorker
 
class  RPWorkerT
 
class  Run
 
class  RunAuxiliary
 
class  RunID
 
class  RunPrincipal
 
class  Sampled
 
struct  SampledEventInfo
 
struct  SampledInfo
 
class  Schedule
 
class  ScheduleContext
 
class  ScheduleID
 
class  ScheduleIteration
 
class  Scheduler
 
class  Selector
 
class  SelectorBase
 
class  ServiceHandle
 
struct  ServiceHandle< MyOtherService const, art::ServiceScope::LEGACY >
 
struct  ServiceHandle< MyOtherService, art::ServiceScope::LEGACY >
 
struct  ServiceHandle< MyService const, art::ServiceScope::LEGACY >
 
struct  ServiceHandle< MyService, art::ServiceScope::LEGACY >
 
struct  ServiceHandle< YetAnotherService const, art::ServiceScope::LEGACY >
 
struct  ServiceHandle< YetAnotherService, art::ServiceScope::LEGACY >
 
class  ServiceRegistry
 
class  ServicesManager
 
class  ServiceTable
 
class  ServiceToken
 
class  SharedAnalyzer
 
class  SharedException
 
class  SharedFilter
 
class  SharedProducer
 
class  SortInvalidFirst
 
class  Source
 
struct  Source_generator
 
struct  Source_generator< dune::PdspHDFFileReader >
 Specialize an art source trait to tell art that we don't care about source.fileNames and don't want the files services to be used. More...
 
struct  Source_wantFileServices
 
class  SourceHelper
 
class  SourceTable
 
class  SubRun
 
class  SubRunAuxiliary
 
class  SubRunID
 
class  SubRunPrincipal
 
class  Suffixes
 
class  SummedValue
 
struct  SupportsView
 
struct  SupportsView< T, std::enable_if_t< has_mapped_type< T >::value > >
 
class  thread_safe_registry_via_id
 
class  Timestamp
 
class  TimeTracker
 
class  ToolConfigTable
 
class  Tracer
 
class  Transient
 
class  TriggerNamesService
 
class  TriggerPathsExecutor
 
class  TriggerResultInserter
 
class  TriggerResults
 
class  TrivialFileDelivery
 
class  TrivialFileTransfer
 
struct  tuple_element
 
struct  tuple_element< I, AssnsNode< L, R, D > >
 
class  TypeID
 
class  TypeLabel
 
class  UpdateOutputCallbacks
 
class  ValidHandle
 
struct  value
 
class  View
 
class  ViewToken
 
class  Worker
 
class  WorkerInPath
 
struct  WorkerParams
 
class  WorkerT
 
struct  WrappedTypeID
 
class  Wrapper
 

Typedefs

using OptionsHandlers = std::vector< std::unique_ptr< art::OptionsHandler >>
 
using ProductListUpdatedCallback = std::function< void(ProductTables const &)>
 
using module_label_t = std::string
 
using WorkerMap = std::map< std::string, std::unique_ptr< Worker >>
 
using MixOpList = std::vector< std::unique_ptr< MixOpBase >>
 
template<typename PROD , typename OPROD = PROD>
using MixFunc = std::function< bool(std::vector< PROD const * > const &, OPROD &, PtrRemapper const &)>
 
using SpecProdList = std::vector< std::shared_ptr< EDProduct const >>
 
using EventIDIndex = std::map< FileIndex::EntryNumber_t, EventID >
 
using SubRunIDIndex = std::map< SubRunID, FileIndex::EntryNumber_t >
 
using RunIDIndex = std::map< SubRunID, FileIndex::EntryNumber_t >
 
using EventIDSequence = std::vector< EventID >
 
using EntryNumberSequence = std::vector< FileIndex::EntryNumber_t >
 
using EventAuxiliarySequence = std::vector< EventAuxiliary >
 
using DataFlowDumper = ProvenanceDumper< DataFlow >
 
using CountingStatistics = ExecutionCounts< stats::Visited, stats::Run, stats::Passed, stats::Failed, stats::ExceptionThrown >
 
using group_ptr_t = cet::exempt_ptr< Group const >
 
using exception_ptr_t = std::shared_ptr< art::Exception const >
 
using ProcessConfigurationRegistry = thread_safe_registry_via_id< ProcessConfigurationID, ProcessConfiguration >
 
using ProcessConfigurationMap = ProcessConfigurationRegistry::collection_type
 
using ProcessHistoryRegistry = thread_safe_registry_via_id< ProcessHistoryID, ProcessHistory >
 
using Selections = ProductDescriptionsByID
 
using SelectionsArray = std::array< Selections, NumBranchTypes >
 
template<typename T >
using tool_return_type = typename detail::tool_type< T >::return_type
 
template<std::size_t I, typename Node >
using tuple_element_t = typename tuple_element< I, Node >::type
 
using product_typeids_t = std::map< product_metatype, TypeID >
 
using ProductDescriptions = std::vector< BranchDescription >
 
using ProductDescriptionsByID = std::map< ProductID, BranchDescription >
 
typedef std::vector< BranchID::value_type > BranchIDList
 
typedef std::vector< BranchIDList > BranchIDLists
 
typedef fhicl::ParameterSetID EventSelectionID
 
typedef std::vector< EventSelectionID > EventSelectionIDVector
 
template<Level L>
using IDNumber_t = typename IDNumber< L >::type
 
using EventNumber_t = IDNumber_t< Level::Event >
 
using SubRunNumber_t = IDNumber_t< Level::SubRun >
 
using RunNumber_t = IDNumber_t< Level::Run >
 
typedef std::map< fhicl::ParameterSetID, ParameterSetBlob > ParameterSetMap
 
typedef Hash< ParentageType > ParentageID
 
typedef thread_safe_registry_via_id< ParentageID, Parentage > ParentageRegistry
 
using ProcessConfigurations = std::vector< ProcessConfiguration >
 
typedef Hash< ProcessConfigurationType > ProcessConfigurationID
 
typedef std::map< ProcessHistoryID const, ProcessHistory > ProcessHistoryMap
 
typedef Hash< ProcessHistoryType > ProcessHistoryID
 
typedef std::map< BranchKey, BranchDescription > ProductList
 
using ProductProvenances = std::vector< ProductProvenance >
 
using ProductStatus = unsigned char
 
typedef std::string ReleaseVersion
 
using SampledRunInfo = std::map< std::string, SampledInfo< RunID >>
 
using SampledSubRunInfo = std::map< std::string, SampledInfo< SubRunID >>
 
using TimeValue_t = std::uint64_t
 
using ProcessLookup = std::map< std::string, std::vector< ProductID >>
 
using ViewLookup_t = ProcessLookup
 
using TypeLabelLookup_t = std::map< TypeLabel, BranchDescription >
 
using ProductLookup_t = std::map< std::string, ProcessLookup >
 
using AvailableProducts_t = std::unordered_set< ProductID, ProductID::Hash >
 
using Exception = cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate >
 

Enumerations

enum  OutputFileStatus { OutputFileStatus::Open, OutputFileStatus::Switching, OutputFileStatus::Closed }
 
enum  product_creation_mode { product_creation_mode::produces, product_creation_mode::reconstitutes }
 
enum  FileCatalogStatus { FileCatalogStatus::SUCCESS, FileCatalogStatus::NO_MORE_FILES, FileCatalogStatus::DELIVERY_ERROR, FileCatalogStatus::TRANSFER_ERROR }
 
enum  BranchActionType { BranchActionBegin, BranchActionEnd, BranchActionProcess }
 
enum  FileDisposition {
  FileDisposition::PENDING = -1, FileDisposition::TRANSFERRED, FileDisposition::CONSUMED, FileDisposition::SKIPPED,
  FileDisposition::INCOMPLETE
}
 
enum  ServiceScope { ServiceScope::LEGACY, ServiceScope::SHARED }
 
enum  ModuleType {
  ModuleType::non_art, ModuleType::producer, ModuleType::filter, ModuleType::analyzer,
  ModuleType::output_module, ModuleType::producing_service
}
 
enum  ModuleThreadingType { ModuleThreadingType::illegal, ModuleThreadingType::legacy, ModuleThreadingType::shared, ModuleThreadingType::replicated }
 
enum  suffix_type : std::size_t {
  suffix_type::module, suffix_type::plugin, suffix_type::service, suffix_type::source,
  suffix_type::tool, suffix_type::mfPlugin, suffix_type::mfStatsPlugin
}
 
enum  Transition {
  Transition::BeginJob, Transition::EndJob, Transition::BeginFile, Transition::EndFile,
  Transition::BeginRun, Transition::EndRun, Transition::BeginSubRun, Transition::EndSubRun,
  Transition::BeginEvent, Transition::EndEvent
}
 
enum  Verbosity { Silent = 0, Concise = 2, Normal = 5, Detailed = 10 }
 
enum  Direction : int { Direction::Forward = 1, Direction::Reverse = -1 }
 
enum  BranchType {
  InEvent, InSubRun, InRun, InResults,
  NumBranchTypes
}
 
enum  HashedTypes {
  ModuleDescriptionType, ParameterSetType, ProcessHistoryType, ProcessConfigurationType,
  EntryDescriptionType, ParentageType
}
 
enum  Persistable { Persistable::Yes, Persistable::No }
 
enum  Level {
  Level::Job = 0, Level::InputFile, Level::Run, Level::SubRun,
  Level::Event, Level::NumNestingLevels, Level::ReadyToAdvance
}
 
enum  product_metatype {
  product_metatype::Normal, product_metatype::LeftRight = Normal, product_metatype::RightLeft, product_metatype::LeftRightData,
  product_metatype::RightLeftData
}
 

Functions

bool find_config (std::string const &filename, std::string const &search_path_spec, std::string &full_path)
 
int run_art (int argc, char **argv, bpo::options_description &all_desc, OptionsHandlers &&handlers)
 
int run_art_string_config (string const &config_string)
 
int run_art_common_ (fhicl::ParameterSet const &main_pset, detail::EnabledModules const &enabled_modules)
 
bool is_glob (std::string const &pattern)
 
std::string glob2reg (std::string pattern)
 
std::vector< std::vector< std::string >::const_iterator > regexMatch (std::vector< std::string > const &strings, std::string const &pattern)
 
std::ostream & operator<< (std::ostream &os, const GroupSelector &gs)
 
 MFSU_0_ARG_UPDATER_DEFN (PostBeginJob)
 
 MFSU_0_ARG_UPDATER_DEFN (PostEndJob)
 
 MFSU_1_ARG_UPDATER_DEFN (PostSourceConstruction)
 
 MFSU_1_ARG_UPDATER_DEFN (PreSourceEvent)
 
 MFSU_2_ARG_UPDATER_DEFN (PostSourceEvent)
 
 MFSU_0_ARG_UPDATER_DEFN (PreSourceSubRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PostSourceSubRun)
 
 MFSU_0_ARG_UPDATER_DEFN (PreSourceRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PostSourceRun)
 
 MFSU_0_ARG_UPDATER_DEFN (PreOpenFile)
 
 MFSU_1_ARG_UPDATER_DEFN (PostOpenFile)
 
 MFSU_0_ARG_UPDATER_DEFN (PreCloseFile)
 
 MFSU_0_ARG_UPDATER_DEFN (PostCloseFile)
 
 MFSU_2_ARG_UPDATER_DEFN (PreProcessEvent)
 
 MFSU_2_ARG_UPDATER_DEFN (PostProcessEvent)
 
 MFSU_1_ARG_UPDATER_DEFN (PreBeginRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PostBeginRun)
 
 MFSU_2_ARG_UPDATER_DEFN (PreEndRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PostEndRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PreBeginSubRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PostBeginSubRun)
 
 MFSU_2_ARG_UPDATER_DEFN (PreEndSubRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PostEndSubRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PreProcessPath)
 
 MFSU_2_ARG_UPDATER_DEFN (PostProcessPath)
 
 MFSU_1_ARG_UPDATER_DEFN (PrePathBeginRun)
 
 MFSU_2_ARG_UPDATER_DEFN (PostPathBeginRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PrePathEndRun)
 
 MFSU_2_ARG_UPDATER_DEFN (PostPathEndRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PrePathBeginSubRun)
 
 MFSU_2_ARG_UPDATER_DEFN (PostPathBeginSubRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PrePathEndSubRun)
 
 MFSU_2_ARG_UPDATER_DEFN (PostPathEndSubRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PreModuleConstruction)
 
 MFSU_1_ARG_UPDATER_DEFN (PostModuleConstruction)
 
 MFSU_2_ARG_UPDATER_DEFN (PostBeginJobWorkers)
 
 MFSU_1_ARG_UPDATER_DEFN (PreModuleBeginJob)
 
 MFSU_1_ARG_UPDATER_DEFN (PostModuleBeginJob)
 
 MFSU_1_ARG_UPDATER_DEFN (PreModuleEndJob)
 
 MFSU_1_ARG_UPDATER_DEFN (PostModuleEndJob)
 
 MFSU_1_ARG_UPDATER_DEFN (PreModule)
 
 MFSU_1_ARG_UPDATER_DEFN (PostModule)
 
 MFSU_1_ARG_UPDATER_DEFN (PreModuleBeginRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PostModuleBeginRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PreModuleEndRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PostModuleEndRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PreModuleBeginSubRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PostModuleBeginSubRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PreModuleEndSubRun)
 
 MFSU_1_ARG_UPDATER_DEFN (PostModuleEndSubRun)
 
std::ostream & operator<< (std::ostream &os, Granularity const &b)
 
std::ostream & operator<< (std::ostream &os, OutputFileStatus const ofs)
 
template<typename UserConfig , typename ImplicitConfig >
std::ostream & operator<< (std::ostream &os, ProducerTable< UserConfig, ImplicitConfig > const &t)
 
template<>
void EventProcessor::begin< Level::Job > ()
 
template<>
void EventProcessor::begin< Level::InputFile > ()
 
template<>
void EventProcessor::begin< Level::Run > ()
 
template<>
void EventProcessor::begin< Level::SubRun > ()
 
template<>
void EventProcessor::finalize< Level::SubRun > ()
 
template<>
void EventProcessor::finalize< Level::Run > ()
 
template<>
void EventProcessor::finalize< Level::InputFile > ()
 
template<>
void EventProcessor::finalize< Level::Job > ()
 
template<>
void EventProcessor::finalizeContainingLevels< Level::SubRun > ()
 
template<>
void EventProcessor::finalizeContainingLevels< Level::Event > ()
 
template<>
void EventProcessor::recordOutputModuleClosureRequests< Level::Run > ()
 
template<>
void EventProcessor::recordOutputModuleClosureRequests< Level::SubRun > ()
 
template<>
void EventProcessor::recordOutputModuleClosureRequests< Level::Event > ()
 
ostream & operator<< (ostream &os, FileProperties const &fp)
 
std::ostream & operator<< (std::ostream &, MixHelper::Mode)
 
RangeSet rangeSetFor (RunPrincipal const &rp)
 
RangeSet rangeSetFor (SubRunPrincipal const &srp)
 
template<typename T , typename P >
std::enable_if_t<!detail::range_sets_supported(P::branch_type)> put_product_in_principal (std::unique_ptr< T > &&product, P &principal, std::string const &module_label, std::string const &instance_name={})
 
template<typename T , typename P >
std::enable_if_t< detail::range_sets_supported(P::branch_type)> put_product_in_principal (std::unique_ptr< T > &&product, P &principal, std::string const &module_label, std::string const &instance_name={}, RangeSet &&rs=RangeSet::invalid())
 
static void markAncestors (ProductProvenance const &iInfo, EventPrincipal &e, std::map< ProductID, bool > &oMap, std::set< ProductID > &oMapperMissing)
 
template<typename PROD >
std::ostream & operator<< (std::ostream &os, Handle< PROD > const &h)
 
std::optional< GroupQueryResult > resolve_unique_product (std::vector< cet::exempt_ptr< art::Group >> const &product_groups, art::WrappedTypeID const &wrapped)
 
std::vector< GroupQueryResult > resolve_products (std::vector< cet::exempt_ptr< art::Group >> const &groups, art::TypeID const &wrapped_type)
 
template<class T >
void swap (Handle< T > &a, Handle< T > &b)
 
template<class T >
void swap (ValidHandle< T > &a, ValidHandle< T > &b)
 
template<class T >
void convert_handle (GroupQueryResult const &, Handle< T > &)
 
template<class T >
std::enable_if_t< detail::is_handle< T >::value, RangeSet const & > range_of_validity (T const &h)
 
template<class T , class U >
std::enable_if_t< detail::are_handles< T, U >::value, bool > same_ranges (T const &a, U const &b)
 
template<class T , class U >
std::enable_if_t< detail::are_handles< T, U >::value, bool > disjoint_ranges (T const &a, U const &b)
 
template<class T , class U >
std::enable_if_t< detail::are_handles< T, U >::value, bool > overlapping_ranges (T const &a, U const &b)
 
void swap (OutputHandle &a, OutputHandle &b)
 
bool operator< (ProductInfo const &a, ProductInfo const &b)
 
ostream & operator<< (ostream &os, ProductInfo::ConsumableType const ct)
 
ostream & operator<< (ostream &os, ProductInfo const &info)
 
bool operator== (Provenance const &a, Provenance const &b) noexcept
 
ostream & operator<< (ostream &os, Provenance const &p)
 
template<typename A , typename B >
std::enable_if_t< is_selector< A > &&is_selector< B >, AndHelper< A, B > > operator&& (A const &a, B const &b)
 
template<typename A , typename B >
std::enable_if_t< is_selector< A > &&is_selector< B >, OrHelper< A, B > > operator|| (A const &a, B const &b)
 
template<typename A >
std::enable_if_t< is_selector< A >, NotHelper< A > > operator! (A const &a)
 
template<class T , class U >
bool same_ranges (SummedValue< T > const &a, SummedValue< U > const &b)
 
template<class T , class U >
bool disjoint_ranges (SummedValue< T > const &a, SummedValue< U > const &b)
 
template<class T , class U >
bool overlapping_ranges (SummedValue< T > const &a, SummedValue< U > const &b)
 
std::string translateFileDeliveryStatus (FileDeliveryStatus stat)
 
std::string translateFileDisposition (FileDisposition fd)
 
std::string translateFileTransferStatus (FileTransferStatus stat)
 
constexpr bool is_legacy (ServiceScope const scope) noexcept
 
constexpr bool is_shared (ServiceScope const scope) noexcept
 
template<typename T >
std::ostream & operator<< (std::ostream &os, ServiceTable< T > const &t)
 
template<typename CONTAINER >
std::enable_if_t< detail::has_two_arg_insert< CONTAINER >::value > concatContainers (CONTAINER &out, CONTAINER const &in)
 
template<typename CONTAINER >
std::enable_if_t< detail::has_three_arg_insert< CONTAINER >::value > concatContainers (CONTAINER &out, CONTAINER const &in)
 
template<typename COLLECTION >
void flattenCollections (std::vector< COLLECTION const * > const &in, COLLECTION &out)
 
template<typename COLLECTION , typename OFFSETS >
void flattenCollections (std::vector< COLLECTION const * > const &in, COLLECTION &out, OFFSETS &offsets)
 
template<typename T >
void flattenCollections (std::vector< PtrVector< T > const * > const &in, PtrVector< T > &out)
 
template<typename T , typename OFFSETS >
void flattenCollections (std::vector< PtrVector< T > const * > const &in, PtrVector< T > &out, OFFSETS &offsets)
 
template<class X , class Y >
bool operator== (debugging_allocator< X > const &, debugging_allocator< Y > const &) throw ()
 
template<class X , class Y >
bool operator!= (debugging_allocator< X > const &, debugging_allocator< Y > const &) throw ()
 
bool operator< (EventProcessHistoryID const &lh, EventProcessHistoryID const &rh)
 
std::ostream & operator<< (std::ostream &os, ModuleDescription const &p)
 
bool is_modifier (ModuleType const mt)
 
bool is_observer (ModuleType const mt)
 
std::string to_string (ModuleType const mt)
 
std::pair< std::string, std::string > split_process_and_path_names (std::string path_spec)
 
PathSpec path_spec (std::string const &path_spec)
 
std::vector< PathSpec > path_specs (std::vector< std::string > const &path_spec_strs)
 
std::string to_string (PathID const id)
 
std::string to_string (PathSpec const &spec)
 
std::ostream & operator<< (std::ostream &os, PathSpec const &spec)
 
auto to_tuple (PathSpec const &spec) noexcept
 
bool operator== (PathSpec const &a, PathSpec const &b)
 
bool operator< (PathSpec const &a, PathSpec const &b)
 
std::ostream & boost_test_print_type (std::ostream &os, Timestamp const timestamp)
 
std::ostream & boost_test_print_type (std::ostream &os, cet::exempt_ptr< BranchDescription const > const pd)
 
void ensureTable (fhicl::intermediate_table &table, std::string const &fhicl_spec)
 
void printArtException (cet::exception const &e, char const *prog)
 
void printBadAllocException (char const *prog)
 
void printStdException (std::exception const &e, char const *prog)
 
void printUnknownException (char const *prog)
 
template<typename T >
std::enable_if_t< std::is_class< T >::value, tool_return_type< T > > make_tool (fhicl::ParameterSet const &pset)
 
template<typename T >
std::enable_if_t< std::is_function< T >::value, tool_return_type< T > > make_tool (fhicl::ParameterSet const &pset, std::string const &function_tool_type)
 
template<typename T , typename TableConfig >
tool_return_type< T > make_tool (TableConfig const &tc, std::string const &function_tool_type)
 
std::ostream & operator<< (std::ostream &ost, const MallocOpts &opts)
 
std::string parent_path (std::string const &path)
 
std::ostream & operator<< (std::ostream &os, suffix_type const st)
 
template<typename T1 , typename T2 >
std::enable_if_t< std::is_same< T1, T2 >::value||std::is_base_of< T1, T2 >::value||std::is_base_of< T2, T1 >::value, bool > pointersEqual (T1 *t1, T2 *t2)
 
template<typename T1 , typename T2 >
std::enable_if_t<!std::is_same< T1, T2 >::value &&!std::is_base_of< T1, T2 >::value &&!std::is_base_of< T2, T1 >::value, bool > pointersEqual (T1 *, T2 *)
 
constexpr auto fullRun ()
 
constexpr auto fullSubRun ()
 
constexpr auto runFragment ()
 
constexpr auto subRunFragment ()
 
auto runFragment (RangeSet const &rs)
 
auto subRunFragment (RangeSet const &rs)
 
bool operator!= (ScheduleID const left, ScheduleID const right) noexcept
 
bool operator<= (ScheduleID const left, ScheduleID const right) noexcept
 
bool operator> (ScheduleID const left, ScheduleID const right) noexcept
 
bool operator>= (ScheduleID const left, ScheduleID const right) noexcept
 
ostream & operator<< (ostream &os, ScheduleID const sid)
 
std::string unique_filename (std::string stem, std::string extension=".root")
 
void setupSignals (bool want_sigint_enabled)
 
std::string const & getReleaseVersion ()
 
template<typename A , typename B , typename D , typename F >
void for_each_group (art::Assns< A, B, D > const &assns, F func)
 Helper functions to access associations in order. More...
 
template<typename A , typename B , typename D , typename F >
void for_each_group_with_left (art::Assns< A, B, D > const &assns, F func)
 
template<typename A , typename B , typename D , typename F >
void for_each_pair (art::Assns< A, B, D > const &assns, F func)
 
template<Direction Dir>
constexpr int signed_one ()
 
template<Direction Dir>
constexpr auto index_for_dereferencing (std::size_t const i)
 
template<typename L , typename R , typename D , Direction Dir>
constexpr auto const & left (const_AssnsIter< L, R, D, Dir > const &a, const_AssnsIter< L, R, D, Dir > const &b)
 
template<typename L , typename R , typename D , Direction Dir>
constexpr auto const & right (const_AssnsIter< L, R, D, Dir > const &a, const_AssnsIter< L, R, D, Dir > const &b)
 
template<typename T , typename L , typename R , typename D >
auto const & get (AssnsNode< L, R, D > const &r)
 
template<typename Collection >
void getElementAddresses (Collection const &coll, std::type_info const &iToType, std::vector< unsigned long > const &indices, std::vector< void const * > &oPtr)
 
template<typename T >
void getElementAddresses (cet::map_vector< T > const &obj, std::type_info const &iToType, std::vector< unsigned long > const &indices, std::vector< void const * > &oPtr)
 
ostream & operator<< (ostream &ost, const HLTGlobalStatus &hlt)
 
std::ostream & operator<< (std::ostream &ost, HLTGlobalStatus const &hlt)
 
template<typename T , typename U >
std::enable_if_t< std::is_same_v< T, U >||std::is_base_of_v< T, U >||std::is_base_of_v< U, T >, bool > operator== (Ptr< T > const &lhs, Ptr< U > const &rhs)
 
template<typename T , typename U >
std::enable_if_t< std::is_same_v< T, U >||std::is_base_of_v< T, U >||std::is_base_of_v< U, T >, bool > operator!= (Ptr< T > const &lhs, Ptr< U > const &rhs)
 
template<typename T , typename U >
std::enable_if_t< std::is_same_v< T, U >||std::is_base_of_v< T, U >||std::is_base_of_v< U, T >, bool > operator< (Ptr< T > const &lhs, Ptr< U > const &rhs)
 
template<typename T , typename H >
void fill_ptr_vector (std::vector< Ptr< T >> &ptrs, H const &h)
 
template<typename T , typename H >
void fill_ptr_list (std::list< Ptr< T >> &ptrs, H const &h)
 
template<typename T >
std::ostream & operator<< (std::ostream &os, Ptr< T > const &p)
 
template<typename T >
void swap (PtrVector< T > &, PtrVector< T > &)
 
void swap (RefCore &lhs, RefCore &rhs)
 
constexpr bool operator== (RefCore const &lhs, RefCore const &rhs) noexcept
 
constexpr bool operator!= (RefCore const &lhs, RefCore const &rhs) noexcept
 
constexpr bool operator< (RefCore const &lhs, RefCore const &rhs) noexcept
 
auto sampled_from (std::string process_name)
 
template<class COLLECTION >
void setPtr (COLLECTION const &coll, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
 
template<typename T >
void setPtr (cet::map_vector< T > const &obj, std::type_info const &iToType, unsigned long iIndex, void const *&oPtr)
 
template<typename T >
void const * address_of (T const &t) noexcept
 
template<typename T >
void const * address_of_second (typename cet::map_vector< T >::value_type const &t) noexcept
 
void swap (TriggerResults &lhs, TriggerResults &rhs)
 
bool operator< (BranchDescription const &a, BranchDescription const &b)
 
bool combinable (BranchDescription const &a, BranchDescription const &b)
 
bool operator== (BranchDescription const &a, BranchDescription const &b)
 
std::ostream & operator<< (std::ostream &os, BranchDescription const &p)
 
std::ostream & operator<< (std::ostream &os, BranchKey const &bk)
 
bool operator< (BranchKey const &a, BranchKey const &b)
 
bool operator== (BranchKey const &a, BranchKey const &b)
 
bool operator!= (BranchKey const &a, BranchKey const &b)
 
std::string const & BranchTypeToString (BranchType const bt)
 
std::string const & BranchTypeToProductTreeName (BranchType const bt)
 
std::string const & BranchTypeToMetaDataTreeName (BranchType const bt)
 
std::string const & BranchTypeToAuxiliaryBranchName (BranchType const bt)
 
std::string const & productProvenanceBranchName (BranchType const bt)
 
std::string const & BranchTypeToMajorIndexName (BranchType const bt)
 
std::string const & BranchTypeToMinorIndexName (BranchType const bt)
 
std::ostream & operator<< (std::ostream &os, BranchType const branchType)
 
template<typename F >
void for_each_branch_type (F f)
 
std::string canonicalProductName (std::string const &friendlyClassName, std::string const &moduleLabel, std::string const &productInstanceName, std::string const &processName)
 
std::ostream & operator<< (std::ostream &os, BranchID const &id)
 
ostream & operator<< (ostream &os, const EventAuxiliary &p)
 
std::ostream & operator<< (std::ostream &os, EventID const &iID)
 
ostream & operator<< (ostream &os, EventRange const &r)
 
bool operator== (FileFormatVersion const &a, FileFormatVersion const &b)
 
bool operator!= (FileFormatVersion const &a, FileFormatVersion const &b)
 
std::ostream & operator<< (std::ostream &os, FileFormatVersion const &ff)
 
bool operator< (FileIndex::Element const &lh, FileIndex::Element const &rh)
 
bool operator> (FileIndex::Element const &lh, FileIndex::Element const &rh)
 
bool operator>= (FileIndex::Element const &lh, FileIndex::Element const &rh)
 
bool operator<= (FileIndex::Element const &lh, FileIndex::Element const &rh)
 
bool operator== (FileIndex::Element const &lh, FileIndex::Element const &rh)
 
bool operator!= (FileIndex::Element const &lh, FileIndex::Element const &rh)
 
bool operator== (FileIndex const &lh, FileIndex const &rh)
 
bool operator!= (FileIndex const &lh, FileIndex const &rh)
 
ostream & operator<< (ostream &os, FileIndex::Element const &el)
 
ostream & operator<< (ostream &os, FileIndex const &fileIndex)
 
template<int I>
void swap (Hash< I > &a, Hash< I > &b)
 
template<int I>
std::ostream & operator<< (std::ostream &os, Hash< I > const &h)
 
template<Level L = Level::Event>
constexpr bool is_valid (IDNumber_t< L > const id) noexcept
 
std::ostream & operator<< (std::ostream &os, ParameterSetBlob const &blob)
 
ostream & operator<< (ostream &os, Parentage const &)
 
bool operator== (Parentage const &a, Parentage const &b)
 
bool operator!= (Parentage const &a, Parentage const &b)
 
bool operator!= (ProcessConfiguration const &a, ProcessConfiguration const &b)
 
bool operator< (ProcessConfiguration const &a, ProcessConfiguration const &b)
 
bool operator== (ProcessConfiguration const &a, ProcessConfiguration const &b)
 
std::ostream & operator<< (std::ostream &os, ProcessConfiguration const &pc)
 
void swap (ProcessHistory &a, ProcessHistory &b)
 
bool operator== (ProcessHistory const &a, ProcessHistory const &b)
 
bool operator!= (ProcessHistory const &a, ProcessHistory const &b)
 
bool isAncestor (ProcessHistory const &a, ProcessHistory const &b)
 
bool isDescendant (ProcessHistory const &a, ProcessHistory const &b)
 
ostream & operator<< (ostream &ost, ProcessHistory const &ph)
 
std::ostream & operator<< (std::ostream &os, ProductID const id)
 
auto make_product_descriptions (ProductList const &productList)
 
ostream & operator<< (ostream &os, ProductProvenance const &p)
 
bool operator== (ProductProvenance const &a, ProductProvenance const &b) noexcept
 
bool operator!= (ProductProvenance const &a, ProductProvenance const &b) noexcept
 
bool operator< (ProductProvenance const &a, ProductProvenance const &b) noexcept
 
bool operator== (RangeSet const &l, RangeSet const &r)
 
bool same_ranges (RangeSet const &l, RangeSet const &r)
 
bool disjoint_ranges (RangeSet const &l, RangeSet const &r)
 
void throw_if_not_disjoint (RunNumber_t const rn, EventRange const &left, EventRange const &right) noexcept(false)
 
bool overlapping_ranges (RangeSet const &l, RangeSet const &r)
 
ostream & operator<< (ostream &os, RangeSet const &rs)
 
ostream & operator<< (ostream &os, const RunAuxiliary &p)
 
std::ostream & operator<< (std::ostream &os, art::RunID const &iID)
 
std::ostream & operator<< (std::ostream &os, SampledEventInfo const &eventInfo)
 
ostream & operator<< (ostream &os, SubRunAuxiliary const &p)
 
std::ostream & operator<< (std::ostream &os, SubRunID const &iID)
 
std::string to_iso_string_assuming_unix_epoch (Timestamp const &ts)
 
bool operator< (TypeLabel const &a, TypeLabel const &b)
 
std::ostream & operator<< (std::ostream &os, TypeLabel const &tl)
 
std::ostream & boost_test_print_type (std::ostream &os, FileIndex::iterator it)
 
std::ostream & boost_test_print_type (std::ostream &os, FileIndex::const_iterator it)
 
template<typename WANTED_POINTER , typename InputIterator >
WANTED_POINTER ensurePointer (InputIterator it)
 
bool operator!= (InputTag const &left, InputTag const &right)
 
void decode (std::any const &a, InputTag &tag)
 
ostream & operator<< (ostream &os, InputTag const &tag)
 
constexpr auto underlying_value (Level const l) noexcept
 
constexpr auto highest_level () noexcept
 
constexpr auto level_up (Level const l) noexcept
 
constexpr auto most_deeply_nested_level () noexcept
 
constexpr auto level_down (Level const l) noexcept
 
constexpr bool is_above_most_deeply_nested_level (Level const l) noexcept
 
constexpr bool is_most_deeply_nested_level (Level const l) noexcept
 
constexpr bool is_highest_level (Level const l) noexcept
 
constexpr bool is_level_contained_by (Level const l1, Level const l2) noexcept
 
std::ostream & operator<< (std::ostream &os, Level const l)
 
bool operator> (TypeID const &a, TypeID const &b)
 
bool operator!= (TypeID const &a, TypeID const &b)
 
void swap (TypeID &left, TypeID &right)
 
ostream & operator<< (ostream &os, TypeID const &tid)
 
string name_of_template_arg (string const &template_instance, size_t desired_arg)
 
string name_of_assns_partner (string assns_type_name)
 
string name_of_assns_base (string assns_type_name)
 
string name_of_unwrapped_product (string const &wrapped_name)
 
bool is_instantiation_of (std::string const &type_name, std::string const &template_name)
 
bool is_instantiation_of (TypeID const &tid, std::string const &template_name)
 
bool is_assns (std::string const &type_name)
 
bool is_assns (TypeID const &tid)
 
std::string uniform_type_name (std::type_info const &tid)
 
std::string uniform_type_name (std::string name)
 
std::string wrappedClassName (std::string const &className)
 
std::string const & getCanvasReleaseVersion ()
 

Variables

AutoInputSourceMutexSentryShutdown autoInputSourceMutexSentryShutdown
 
template<typename T >
constexpr bool is_selector
 
template<typename T >
detail::SharedResource_t SharedResource {typeid(T).name(), true}
 
DebugTasksValue debugTasks
 
std::atomic< int > shutdown_flag {0}
 
DebugValue debugit
 

Detailed Description

An art event visitor component takes a reference to an art::Event object. Components with this interface will typically implement a sink or a source WCT interface.

Note, this is a Wire Cell Toolkit Interface class which depends on external types so is not kept in wire-cell-iface. See that package for in-toolkit WCT interfaces.

https://github.com/WireCell/wire-cell-iface/tree/master/inc/WireCellIface

A wcls::MainTool is a main entry point to the WCT from LS

See the WCLS_tool as the likely only implementation.

Fixme: maybe need to pick a less generic name for this tool?

Typedef Documentation

using art::AvailableProducts_t = typedef std::unordered_set<ProductID, ProductID::Hash>

Definition at line 24 of file type_aliases.h.

typedef std::vector<BranchID::value_type> art::BranchIDList

Definition at line 17 of file BranchIDList.h.

typedef std::vector<BranchIDList> art::BranchIDLists

Definition at line 18 of file BranchIDList.h.

using art::CountingStatistics = typedef ExecutionCounts<stats::Visited, stats::Run, stats::Passed, stats::Failed, stats::ExceptionThrown>

Definition at line 85 of file ExecutionCounts.h.

using art::DataFlowDumper = typedef ProvenanceDumper<DataFlow>

Definition at line 26 of file DataFlowDumper_module.cc.

using art::EntryNumberSequence = typedef std::vector<FileIndex::EntryNumber_t>

Definition at line 27 of file MixTypes.h.

using art::EventAuxiliarySequence = typedef std::vector<EventAuxiliary>

Definition at line 28 of file MixTypes.h.

using art::EventIDIndex = typedef std::map<FileIndex::EntryNumber_t, EventID>

Definition at line 23 of file MixTypes.h.

using art::EventIDSequence = typedef std::vector<EventID>

Definition at line 26 of file MixTypes.h.

using art::EventNumber_t = typedef IDNumber_t<Level::Event>

Definition at line 118 of file IDNumber.h.

typedef fhicl::ParameterSetID art::EventSelectionID

Definition at line 17 of file EventSelectionID.h.

typedef std::vector<EventSelectionID> art::EventSelectionIDVector

Definition at line 18 of file EventSelectionID.h.

using art::Exception = typedef cet::coded_exception<errors::ErrorCodes, ExceptionDetail::translate>

Definition at line 66 of file Exception.h.

using art::exception_ptr_t = typedef std::shared_ptr<art::Exception const>

Definition at line 22 of file GroupQueryResult.h.

using art::group_ptr_t = typedef cet::exempt_ptr<Group const>

Definition at line 21 of file GroupQueryResult.h.

template<Level L>
using art::IDNumber_t = typedef typename IDNumber<L>::type

Definition at line 109 of file IDNumber.h.

template<typename PROD , typename OPROD = PROD>
using art::MixFunc = typedef std::function< bool(std::vector<PROD const*> const&, OPROD&, PtrRemapper const&)>

Definition at line 19 of file MixTypes.h.

using art::MixOpList = typedef std::vector<std::unique_ptr<MixOpBase>>

Definition at line 22 of file MixIOPolicy.h.

using art::module_label_t = typedef std::string

Definition at line 26 of file WorkerInPath.h.

using art::OptionsHandlers = typedef std::vector<std::unique_ptr<art::OptionsHandler>>

Definition at line 10 of file OptionsHandlers.h.

typedef std::map<fhicl::ParameterSetID, ParameterSetBlob> art::ParameterSetMap

Definition at line 8 of file ParameterSetMap.h.

typedef Hash<ParentageType> art::ParentageID

Definition at line 8 of file ParentageID.h.

typedef thread_safe_registry_via_id<ParentageID, Parentage> art::ParentageRegistry

Definition at line 9 of file ParentageRegistry.h.

typedef Hash<ProcessConfigurationType> art::ProcessConfigurationID

Definition at line 8 of file ProcessConfigurationID.h.

using art::ProcessConfigurationMap = typedef ProcessConfigurationRegistry::collection_type

Definition at line 18 of file ProcessConfigurationRegistry.h.

using art::ProcessConfigurationRegistry = typedef thread_safe_registry_via_id<ProcessConfigurationID, ProcessConfiguration>

Definition at line 17 of file ProcessConfigurationRegistry.h.

using art::ProcessConfigurations = typedef std::vector<ProcessConfiguration>

Definition at line 49 of file ProcessConfiguration.h.

typedef Hash<ProcessHistoryType> art::ProcessHistoryID

Definition at line 8 of file ProcessHistoryID.h.

typedef std::map<ProcessHistoryID const, ProcessHistory> art::ProcessHistoryMap

Definition at line 143 of file ProcessHistory.h.

using art::ProcessHistoryRegistry = typedef thread_safe_registry_via_id<ProcessHistoryID, ProcessHistory>

Definition at line 23 of file ProcessHistoryRegistry.h.

using art::ProcessLookup = typedef std::map<std::string, std::vector<ProductID>>

Definition at line 17 of file type_aliases.h.

using art::product_typeids_t = typedef std::map<product_metatype, TypeID>

Definition at line 43 of file fwd.h.

using art::ProductDescriptions = typedef std::vector<BranchDescription>

Definition at line 284 of file BranchDescription.h.

using art::ProductDescriptionsByID = typedef std::map<ProductID, BranchDescription>

Definition at line 285 of file BranchDescription.h.

typedef std::map<BranchKey, BranchDescription> art::ProductList

Definition at line 15 of file ProductList.h.

using art::ProductListUpdatedCallback = typedef std::function<void(ProductTables const&)>

Definition at line 54 of file UpdateOutputCallbacks.h.

using art::ProductLookup_t = typedef std::map<std::string, ProcessLookup>

Definition at line 23 of file type_aliases.h.

using art::ProductProvenances = typedef std::vector<ProductProvenance>

Definition at line 52 of file ProductProvenance.h.

using art::ProductStatus = typedef unsigned char

Definition at line 6 of file ProductStatus.h.

typedef std::string art::ReleaseVersion

Definition at line 6 of file ReleaseVersion.h.

using art::RunIDIndex = typedef std::map<SubRunID, FileIndex::EntryNumber_t>

Definition at line 25 of file MixTypes.h.

using art::RunNumber_t = typedef IDNumber_t<Level::Run>

Definition at line 120 of file IDNumber.h.

using art::SampledRunInfo = typedef std::map<std::string, SampledInfo<RunID>>

Definition at line 38 of file SampledInfo.h.

using art::SampledSubRunInfo = typedef std::map<std::string, SampledInfo<SubRunID>>

Definition at line 39 of file SampledInfo.h.

using art::Selections = typedef ProductDescriptionsByID

Definition at line 11 of file Selections.h.

using art::SelectionsArray = typedef std::array<Selections, NumBranchTypes>

Definition at line 12 of file Selections.h.

using art::SpecProdList = typedef std::vector<std::shared_ptr<EDProduct const>>

Definition at line 21 of file MixTypes.h.

using art::SubRunIDIndex = typedef std::map<SubRunID, FileIndex::EntryNumber_t>

Definition at line 24 of file MixTypes.h.

using art::SubRunNumber_t = typedef IDNumber_t<Level::SubRun>

Definition at line 119 of file IDNumber.h.

using art::TimeValue_t = typedef std::uint64_t

Definition at line 8 of file Timestamp.h.

template<typename T >
using art::tool_return_type = typedef typename detail::tool_type<T>::return_type

Definition at line 14 of file make_tool.h.

template<std::size_t I, typename Node >
using art::tuple_element_t = typedef typename tuple_element<I, Node>::type

Definition at line 56 of file AssnsNode.h.

using art::TypeLabelLookup_t = typedef std::map<TypeLabel, BranchDescription>

Definition at line 20 of file type_aliases.h.

using art::ViewLookup_t = typedef ProcessLookup

Definition at line 18 of file type_aliases.h.

using art::WorkerMap = typedef std::map<std::string, std::unique_ptr<Worker>>

Definition at line 11 of file WorkerMap.h.

Enumeration Type Documentation

enum art::BranchActionType
Enumerator
BranchActionBegin 
BranchActionEnd 
BranchActionProcess 

Definition at line 7 of file BranchActionType.h.

7  {
8  BranchActionBegin, // 0
9  BranchActionEnd, // 1
10  BranchActionProcess // 2
11  };
enum art::BranchType
Enumerator
InEvent 
InSubRun 
InRun 
InResults 
NumBranchTypes 

Definition at line 20 of file BranchType.h.

20 { InEvent, InSubRun, InRun, InResults, NumBranchTypes };
enum art::Direction : int
strong
Enumerator
Forward 
Reverse 

Definition at line 13 of file AssnsIter.h.

13 : int { Forward = 1, Reverse = -1 };
tca::Reverse
void Reverse(TCSlice &slc, PFPStruct &pfp)
Definition: PFPUtils.cxx:2359
enum art::FileCatalogStatus
strong
Enumerator
SUCCESS 
NO_MORE_FILES 
DELIVERY_ERROR 
TRANSFER_ERROR 

Definition at line 23 of file InputFileCatalog.h.

23  {
24  SUCCESS,
25  NO_MORE_FILES,
26  DELIVERY_ERROR,
27  TRANSFER_ERROR
28  };
SUCCESS
#define SUCCESS
Definition: DBScan3DAlg.h:39
enum art::FileDisposition
strong
Enumerator
PENDING 
TRANSFERRED 
CONSUMED 
SKIPPED 
INCOMPLETE 

Definition at line 14 of file FileDisposition.h.

14  {
15  PENDING = -1,
16  TRANSFERRED,
17  CONSUMED,
18  SKIPPED,
19  INCOMPLETE
20 };
enum art::HashedTypes
Enumerator
ModuleDescriptionType 
ParameterSetType 
ProcessHistoryType 
ProcessConfigurationType 
EntryDescriptionType 
ParentageType 

Definition at line 11 of file HashedTypes.h.

11  {
12  ModuleDescriptionType, // Obsolete
13  ParameterSetType,
14  ProcessHistoryType,
15  ProcessConfigurationType,
16  EntryDescriptionType, // Obsolete
17  ParentageType
18  };
enum art::Level
strong
Enumerator
Job 
InputFile 
Run 
SubRun 
Event 
NumNestingLevels 
ReadyToAdvance 

Definition at line 13 of file Level.h.

13  {
14  Job = 0,
15  InputFile,
16  Run,
17  SubRun,
18  Event,
19  NumNestingLevels,
20  ReadyToAdvance
21  };
Event
Definition: types.h:32
enum art::ModuleThreadingType
strong
Enumerator
illegal 
legacy 
shared 
replicated 

Definition at line 19 of file ModuleType.h.

19 { illegal, legacy, shared, replicated };
enum art::ModuleType
strong
Enumerator
non_art 
producer 
filter 
analyzer 
output_module 
producing_service 

Definition at line 11 of file ModuleType.h.

11  {
12  non_art,
13  producer,
14  filter,
15  analyzer,
16  output_module,
17  producing_service
18  };
filter
static unsigned filter(unsigned char *out, const unsigned char *in, unsigned w, unsigned h, const LodePNG_InfoColor *info)
Definition: lodepng.cpp:3576
enum art::OutputFileStatus
strong
Enumerator
Open 
Switching 
Closed 

Definition at line 8 of file OutputFileStatus.h.

8 { Open, Switching, Closed };
enum art::Persistable
strong
Enumerator
Yes 
No 

Definition at line 5 of file Persistable.h.

5 { Yes, No };
enum art::product_creation_mode
strong
Enumerator
produces 
reconstitutes 

Definition at line 38 of file ProductRegistryHelper.h.

38 { produces, reconstitutes };
enum art::product_metatype
strong
Enumerator
Normal 
LeftRight 
RightLeft 
LeftRightData 
RightLeftData 

Definition at line 5 of file product_metatype.h.

5  {
6  Normal,
7  LeftRight = Normal,
8  RightLeft,
9  LeftRightData,
10  RightLeftData
11  };
Normal
Definition: types.h:29
enum art::ServiceScope
strong
Enumerator
LEGACY 
SHARED 

Definition at line 7 of file ServiceScope.h.

7 { LEGACY, SHARED };
enum art::suffix_type : std::size_t
strong
Enumerator
module 
plugin 
service 
source 
tool 
mfPlugin 
mfStatsPlugin 

Definition at line 59 of file PluginSuffixes.h.

59  : std::size_t {
60  module,
61  plugin,
62  service,
63  source,
64  tool,
65  mfPlugin,
66  mfStatsPlugin
67  };
enum art::Transition
strong
Enumerator
BeginJob 
EndJob 
BeginFile 
EndFile 
BeginRun 
EndRun 
BeginSubRun 
EndSubRun 
BeginEvent 
EndEvent 

Definition at line 7 of file Transition.h.

7  {
8  BeginJob,
9  EndJob,
10  BeginFile,
11  EndFile,
12  BeginRun,
13  EndRun,
14  BeginSubRun,
15  EndSubRun,
16  BeginEvent,
17  EndEvent
18  };
enum art::Verbosity
Enumerator
Silent 
Concise 
Normal 
Detailed 

Definition at line 5 of file Verbosity.h.

5 { Silent = 0, Concise = 2, Normal = 5, Detailed = 10 };
Normal
Definition: types.h:29

Function Documentation

template<typename T >
void const* art::address_of ( T const &  t)
noexcept

Definition at line 123 of file traits.h.

124  {
125  return &t;
126  }
reco_momentum_tuples.t
t
Definition: reco_momentum_tuples.py:25
template<typename T >
void const* art::address_of_second ( typename cet::map_vector< T >::value_type const &  t)
noexcept

Definition at line 130 of file traits.h.

131  {
132  return &t.second;
133  }
reco_momentum_tuples.t
t
Definition: reco_momentum_tuples.py:25
std::ostream& art::boost_test_print_type ( std::ostream &  os,
FileIndex::iterator  it 
)

Definition at line 7 of file FileIndex_t.cc.

8  {
9  return os << &it;
10  }
std::ostream& art::boost_test_print_type ( std::ostream &  os,
FileIndex::const_iterator  it 
)

Definition at line 12 of file FileIndex_t.cc.

13  {
14  return os << &it;
15  }
std::ostream& art::boost_test_print_type ( std::ostream &  os,
cet::exempt_ptr< BranchDescription const > const  pd 
)

Definition at line 42 of file EventPrincipal_t.cc.

44  {
45  return os << pd.get();
46  }
cet::exempt_ptr::get
constexpr pointer get() const noexcept
Definition: exempt_ptr.h:148
std::ostream& art::boost_test_print_type ( std::ostream &  os,
Timestamp const  timestamp 
)

Definition at line 96 of file Event_t.cc.

97  {
98  return os << timestamp.value();
99  }
std::string const & art::BranchTypeToAuxiliaryBranchName ( BranchType const  bt)

Definition at line 83 of file BranchType.cc.

84  {
85  return select(
86  bt,
87  {&eventAuxiliary, &subRunAuxiliary, &runAuxiliary, &resultsAuxiliary});
88  }
tracks.bt
bt
Definition: tracks.py:83
cet::sqlite::select
auto select(T const &...t)
Definition: select.h:146
std::string const & art::BranchTypeToMajorIndexName ( BranchType const  bt)

Definition at line 101 of file BranchType.cc.

102  {
103  return select(bt, {&eventMajorIndex, &subRunMajorIndex, &runMajorIndex});
104  }
tracks.bt
bt
Definition: tracks.py:83
cet::sqlite::select
auto select(T const &...t)
Definition: select.h:146
std::string const & art::BranchTypeToMetaDataTreeName ( BranchType const  bt)

Definition at line 77 of file BranchType.cc.

78  {
79  return select(bt, {&eventMeta, &subRunMeta, &runMeta, &resultsMeta});
80  }
tracks.bt
bt
Definition: tracks.py:83
cet::sqlite::select
auto select(T const &...t)
Definition: select.h:146
std::string const & art::BranchTypeToMinorIndexName ( BranchType const  bt)

Definition at line 107 of file BranchType.cc.

108  {
109  return select(bt, {&eventMinorIndex, &subRunMinorIndex, &runMinorIndex});
110  }
tracks.bt
bt
Definition: tracks.py:83
cet::sqlite::select
auto select(T const &...t)
Definition: select.h:146
std::string const & art::BranchTypeToProductTreeName ( BranchType const  bt)

Definition at line 71 of file BranchType.cc.

72  {
73  return select(bt, {&events, &subRuns, &runs, &resultsTree});
74  }
make_norm_csv.runs
runs
Definition: make_norm_csv.py:21
tracks.bt
bt
Definition: tracks.py:83
cet::sqlite::select
auto select(T const &...t)
Definition: select.h:146
std::string const & art::BranchTypeToString ( BranchType const  bt)

Definition at line 65 of file BranchType.cc.

66  {
67  return select(bt, {&event, &subRun, &run, &results});
68  }
tracks.bt
bt
Definition: tracks.py:83
cet::sqlite::select
auto select(T const &...t)
Definition: select.h:146
std::string art::canonicalProductName ( std::string const &  friendlyClassName,
std::string const &  moduleLabel,
std::string const &  productInstanceName,
std::string const &  processName 
)

Definition at line 9 of file canonicalProductName.cc.

13 {
14  std::string result;
15  result.reserve(friendlyClassName.size() + moduleLabel.size() +
16  productInstanceName.size() + processName.size() + 4);
17  result += friendlyClassName;
18  result += underscore;
19  result += moduleLabel;
20  result += underscore;
21  result += productInstanceName;
22  result += underscore;
23  result += processName;
24  result += period;
25  // It is *absolutely* needed to have the trailing period on the branch
26  // name, as this gives instruction to ROOT to split this branch in the
27  // modern (v4+) way vs the old way (v3-).
28 
29  return result;
30 }
result
static QCString result
Definition: fortranscanner.cpp:56614
string
std::string string
Definition: nybbler.cc:12
bool art::combinable ( BranchDescription const &  a,
BranchDescription const &  b 
)

Definition at line 306 of file BranchDescription.cc.

307  {
308  return (a.branchType() == b.branchType()) &&
309  (a.processName() == b.processName()) &&
310  (a.producedClassName() == b.producedClassName()) &&
311  (a.friendlyClassName() == b.friendlyClassName()) &&
312  (a.productInstanceName() == b.productInstanceName()) &&
313  (a.moduleLabel() == b.moduleLabel()) &&
314  (a.productID() == b.productID());
315  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
template<typename CONTAINER >
std::enable_if_t<detail::has_two_arg_insert<CONTAINER>::value> art::concatContainers ( CONTAINER &  out,
CONTAINER const &  in 
)
template<typename CONTAINER >
std::enable_if_t<detail::has_three_arg_insert<CONTAINER>::value> art::concatContainers ( CONTAINER &  out,
CONTAINER const &  in 
)
template<class T >
void art::convert_handle ( GroupQueryResult const &  orig,
Handle< T > &  result 
)

Definition at line 248 of file Handle.h.

249 {
250  Handle<T> h{orig};
251  result.swap(h);
252 }
result
static QCString result
Definition: fortranscanner.cpp:56614
reco_momentum_tuples.h
h
Definition: reco_momentum_tuples.py:66
void art::decode ( std::any const &  a,
InputTag &  tag 
)

Definition at line 117 of file InputTag.cc.

118  {
119  if (fhicl::detail::is_sequence(a)) {
120  vector<string> tmp;
121  fhicl::detail::decode(a, tmp);
122  if (tmp.size() == 2) {
123  tag = {tmp[0], tmp[1]};
124  } else if (tmp.size() == 3) {
125  tag = {tmp[0], tmp[1], tmp[2]};
126  } else {
127  ostringstream errmsg;
128  errmsg << "When converting to InputTag by a sequence, FHiCL entries "
129  "must follow the convention:\n\n"
130  << " [ label, instance ], or\n"
131  << " [ label, instance, process_name ].\n\n";
132  errmsg << "FHiCL entries provided: [ ";
133  for (auto ca = tmp.begin(); ca != tmp.cend(); ++ca) {
134  errmsg << *ca;
135  if (ca != tmp.cend() - 1) {
136  errmsg << ", ";
137  }
138  }
139  errmsg << " ]";
140  throw length_error(errmsg.str());
141  }
142  } else {
143  string tmp;
144  fhicl::detail::decode(a, tmp);
145  tag = tmp;
146  }
147  }
fhicl::detail::decode
void decode(std::any const &, std::string &)
a
const double a
Definition: gUpMuFluxGen.cxx:164
languages.tmp
string tmp
Definition: languages.py:63
fhicl::detail::is_sequence
bool is_sequence(std::any const &val)
Definition: coding.h:49
template<class T , class U >
std::enable_if_t<detail::are_handles<T, U>::value, bool> art::disjoint_ranges ( T const &  a,
U const &  b 
)
template<class T , class U >
bool art::disjoint_ranges ( SummedValue< T > const &  a,
SummedValue< U > const &  b 
)

Definition at line 194 of file SummedValue.h.

195  {
196  return disjoint_ranges(a.rangeOfValidity(), b.rangeOfValidity());
197  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
art::disjoint_ranges
bool disjoint_ranges(SummedValue< T > const &a, SummedValue< U > const &b)
Definition: SummedValue.h:194
b
static bool * b
Definition: config.cpp:1043
bool art::disjoint_ranges ( RangeSet const &  l,
RangeSet const &  r 
)

Definition at line 414 of file RangeSet.cc.

415  {
416  if (!(l.is_valid() && r.is_valid())) {
417  return false;
418  }
419  if (!l.has_disjoint_ranges() || !r.has_disjoint_ranges())
420  return false;
421 
422  if (l.run() != r.run())
423  return true;
424 
425  // If we get here, the run numbers of both ranges are guaranteed to
426  // be the same.
427 
428  // Empty RangeSets are disjoint wrt. other RangeSets. Must handle
429  // this case separately than l == r case.
430  if (l.empty() || r.empty())
431  return true;
432 
433  // If we get this far, then neither RangeSet is empty.
434  if (l == r)
435  return false;
436 
437  RangeSet ltmp{l};
438  RangeSet rtmp{r};
439  auto const& lranges = ltmp.collapse().ranges();
440  auto const& rranges = rtmp.collapse().ranges();
441 
442  std::vector<EventRange> merged;
443  std::merge(lranges.begin(),
444  lranges.end(),
445  rranges.begin(),
446  rranges.end(),
447  back_inserter(merged));
448 
449  return disjoint(merged);
450  }
l
static QStrList * l
Definition: config.cpp:1044
plot_model.r
r
Definition: plot_model.py:57
template<typename WANTED_POINTER , typename InputIterator >
WANTED_POINTER art::ensurePointer ( InputIterator  it)
inline

Definition at line 77 of file ensurePointer.h.

77  {
78  static_assert(std::is_pointer_v<WANTED_POINTER>,
79  "Supplied template argument is not a pointer.");
80  return detail::EnsurePointer<
81  WANTED_POINTER,
82  typename std::iterator_traits<InputIterator>::value_type>{}(*it);
83 }
84 catch (std::bad_cast&) {
85  throw Exception(errors::LogicError, "ensurePointer")
86  << "Iterator value type "
87  << cet::demangle_symbol(
88  typeid(typename std::iterator_traits<InputIterator>::value_type)
89  .name())
90  << " and wanted pointer type "
91  << cet::demangle_symbol(typeid(WANTED_POINTER).name())
92  << " are incompatible.\n";
93 }
name
static QCString name
Definition: declinfo.cpp:673
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
void art::ensureTable ( fhicl::intermediate_table &  table,
std::string const &  fhicl_spec 
)

Definition at line 6 of file ensureTable.cc.

7 {
8  if (!table.exists(name)) {
9  table.putEmptyTable(name);
10  }
11 }
name
static QCString name
Definition: declinfo.cpp:673
fhicl::intermediate_table::exists
bool exists(std::string const &key) const
Definition: intermediate_table.cc:143
fhicl::intermediate_table::putEmptyTable
bool putEmptyTable(std::string const &name, bool in_prolog=false)
Definition: intermediate_table.h:351
template<>
void art::EventProcessor::begin< Level::InputFile > ( )
inline

Definition at line 341 of file EventProcessor.cc.

342  {
343  openInputFile();
344  }
template<>
void art::EventProcessor::begin< Level::Job > ( )
inline

Definition at line 333 of file EventProcessor.cc.

334  {
335  timer_->start();
336  beginJob();
337  }
breakpoints::beginJob
void beginJob()
Definition: Breakpoints.cc:14
template<>
void art::EventProcessor::begin< Level::Run > ( )

Definition at line 348 of file EventProcessor.cc.

349  {
350  readRun();
351 
352  // We only enable run finalization if reading was successful.
353  // This appears to be a design weakness.
354  finalizeRunEnabled_ = true;
355  if (handleEmptyRuns_) {
356  beginRun();
357  }
358  }
template<>
void art::EventProcessor::begin< Level::SubRun > ( )

Definition at line 362 of file EventProcessor.cc.

363  {
364  assert(runPrincipal_);
365  assert(runPrincipal_->runID().isValid());
366  readSubRun();
367 
368  // We only enable subrun finalization if reading was successful.
369  // This appears to be a design weakness.
370  finalizeSubRunEnabled_ = true;
371  if (handleEmptySubRuns_) {
372  beginRunIfNotDoneAlready();
373  beginSubRun();
374  }
375  }
template<>
void art::EventProcessor::finalize< Level::InputFile > ( )

Definition at line 423 of file EventProcessor.cc.

424  {
425  if (nextLevel_.load() == Level::Job) {
426  closeAllFiles();
427  } else {
428  closeInputFile();
429  }
430  }
template<>
void art::EventProcessor::finalize< Level::Job > ( )

Definition at line 434 of file EventProcessor.cc.

435  {
436  endJob();
437  timer_->stop();
438  }
template<>
void art::EventProcessor::finalize< Level::Run > ( )

Definition at line 401 of file EventProcessor.cc.

402  {
403  if (!finalizeRunEnabled_) {
404  return;
405  }
406 
407  assert(runPrincipal_);
408  if (runPrincipal_->runID().isFlush()) {
409  return;
410  }
411 
412  openSomeOutputFiles();
413  setRunAuxiliaryRangeSetID();
414  if (beginRunCalled_) {
415  endRun();
416  }
417  writeRun();
418  finalizeRunEnabled_ = false;
419  }
template<>
void art::EventProcessor::finalize< Level::SubRun > ( )

Definition at line 379 of file EventProcessor.cc.

380  {
381  if (!finalizeSubRunEnabled_) {
382  return;
383  }
384 
385  assert(subRunPrincipal_);
386  if (subRunPrincipal_->subRunID().isFlush()) {
387  return;
388  }
389 
390  openSomeOutputFiles();
391  setSubRunAuxiliaryRangeSetID();
392  if (beginSubRunCalled_) {
393  endSubRun();
394  }
395  writeSubRun();
396  finalizeSubRunEnabled_ = false;
397  }
template<>
void art::EventProcessor::finalizeContainingLevels< Level::Event > ( )

Definition at line 449 of file EventProcessor.cc.

450  {
451  finalize<Level::SubRun>();
452  finalize<Level::Run>();
453  }
template<>
void art::EventProcessor::finalizeContainingLevels< Level::SubRun > ( )

Definition at line 442 of file EventProcessor.cc.

443  {
444  finalize<Level::Run>();
445  }
template<>
void art::EventProcessor::recordOutputModuleClosureRequests< Level::Event > ( )

Definition at line 471 of file EventProcessor.cc.

472  {
473  main_schedule().recordOutputClosureRequests(Granularity::Event);
474  }
Event
Definition: types.h:32
template<>
void art::EventProcessor::recordOutputModuleClosureRequests< Level::Run > ( )

Definition at line 457 of file EventProcessor.cc.

458  {
459  main_schedule().recordOutputClosureRequests(Granularity::Run);
460  }
template<>
void art::EventProcessor::recordOutputModuleClosureRequests< Level::SubRun > ( )

Definition at line 464 of file EventProcessor.cc.

465  {
466  main_schedule().recordOutputClosureRequests(Granularity::SubRun);
467  }
template<typename T , typename H >
void art::fill_ptr_list ( std::list< Ptr< T >> &  ptrs,
H const &  h 
)

Definition at line 307 of file Ptr.h.

308  {
309  for (std::size_t i = 0, sz = h->size(); i != sz; ++i) {
310  ptrs.emplace_back(h, i);
311  }
312  }
reco_momentum_tuples.h
h
Definition: reco_momentum_tuples.py:66
template<typename T , typename H >
void art::fill_ptr_vector ( std::vector< Ptr< T >> &  ptrs,
H const &  h 
)

Definition at line 297 of file Ptr.h.

298  {
299  for (std::size_t i = 0, sz = h->size(); i != sz; ++i) {
300  ptrs.emplace_back(h, i);
301  }
302  }
reco_momentum_tuples.h
h
Definition: reco_momentum_tuples.py:66
bool art::find_config ( std::string const &  filename,
std::string const &  search_path_spec,
std::string &  full_path 
)

Definition at line 13 of file find_config.cc.

16 {
17  try {
18  cet::search_path sp(search_path_spec);
19  if (!sp.find_file(filename, full_path)) {
20  return false;
21  }
22  }
23  catch (cet::exception const& e) {
24  if (e.root_cause() == "getenv") {
25  // Assume file is findable as specified.
26  full_path = filename;
27  } else {
28  throw;
29  }
30  }
31  return true;
32 }
train.filename
string filename
Definition: train.py:213
e
const double e
Definition: gUpMuFluxGen.cxx:165
cet::search_path
Definition: search_path.h:36
fhicl::exception
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<typename COLLECTION >
void art::flattenCollections ( std::vector< COLLECTION const * > const &  in,
COLLECTION &  out 
)

Definition at line 286 of file CollectionUtilities.h.

288 {
289  typename COLLECTION::size_type total_size = 0;
290  for (auto collptr : in) {
291  if (collptr != nullptr) {
292  total_size += collptr->size();
293  }
294  }
295  out.reserve(total_size);
296  for (auto collptr : in) {
297  if (collptr != nullptr) {
298  concatContainers(out, *collptr);
299  }
300  }
301 }
art::concatContainers
std::enable_if_t< detail::has_three_arg_insert< CONTAINER >::value > concatContainers(CONTAINER &out, CONTAINER const &in)
template<typename COLLECTION , typename OFFSETS >
void art::flattenCollections ( std::vector< COLLECTION const * > const &  in,
COLLECTION &  out,
OFFSETS &  offsets 
)

Definition at line 306 of file CollectionUtilities.h.

309 {
310  offsets.clear();
311  offsets.reserve(in.size());
312  typename COLLECTION::size_type current_offset{};
313  for (auto collptr : in) {
314  if (collptr == nullptr)
315  continue;
316 
317  auto const delta = detail::mix_offset<COLLECTION>::offset(*collptr);
318  offsets.push_back(current_offset);
319  current_offset += delta;
320  }
321  flattenCollections<COLLECTION>(in, out); // 1.
322 }
template<typename T >
void art::flattenCollections ( std::vector< PtrVector< T > const * > const &  in,
PtrVector< T > &  out 
)

Definition at line 327 of file CollectionUtilities.h.

329 {
330  // Extra checks are required to verify that the PtrVectors are
331  // compatible.
332  if (!detail::verifyPtrCollection(in)) {
333  throw Exception(errors::LogicError)
334  << "Attempt to flatten incompatible PtrVectors "
335  << "referring to different ProductIDs.\n";
336  }
337  flattenCollections<PtrVector<T>>(in, out); // 1
338 }
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
art::detail::verifyPtrCollection
bool verifyPtrCollection(iterator beg, iterator end, art::ProductID id={}, art::EDProductGetter const *getter=nullptr)
Definition: CollectionUtilities.h:211
template<typename T , typename OFFSETS >
void art::flattenCollections ( std::vector< PtrVector< T > const * > const &  in,
PtrVector< T > &  out,
OFFSETS &  offsets 
)

Definition at line 343 of file CollectionUtilities.h.

346 {
347  // Extra checks are required to verify that the PtrVectors are
348  // compatible.
349  if (!detail::verifyPtrCollection(in)) {
350  throw Exception(errors::LogicError)
351  << "Attempt to flatten incompatible PtrVectors "
352  << "referring to different ProductIDs.\n";
353  }
354  flattenCollections<PtrVector<T>>(in, out, offsets); // 2.
355 }
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
art::detail::verifyPtrCollection
bool verifyPtrCollection(iterator beg, iterator end, art::ProductID id={}, art::EDProductGetter const *getter=nullptr)
Definition: CollectionUtilities.h:211
template<typename F >
void art::for_each_branch_type ( F  f)

Definition at line 38 of file BranchType.h.

39  {
40  for (std::underlying_type<BranchType>::type i{InEvent}; i < NumBranchTypes;
41  ++i) {
42  auto const bt = static_cast<BranchType>(i);
43  f(bt);
44  }
45  }
keras_to_tensorflow.f
f
Definition: keras_to_tensorflow.py:162
tracks.bt
bt
Definition: tracks.py:83
type
static QCString type
Definition: declinfo.cpp:672
art::BranchType
BranchType
Definition: BranchType.h:20
template<typename A , typename B , typename D , typename F >
void art::for_each_group ( art::Assns< A, B, D > const &  assns,
F  func 
)

Helper functions to access associations in order.

Template Parameters
Atype of association being read
Ftype of functor to be called on each associated group
Parameters
assnsthe association being read
funcfunctor to be called on each associated group

This function takes two input arguments, a constant reference to the association data product itself (assns), and the function (func) to be operated on each of the group of associated objects. This function represents the association data product as a range of ranges representing the right hand side in the collection, hence the function provided as the second argument should assume that it will be operating on a range of art::Ptr to the associated data products grouped by the data product they are associated with.

Example: assuming that a module with input tag stored in fTrackTag has created associations of each track to its hits, the total charge for each track can be extracted by:

auto assns = art::getValidHandle<art::Assns<recob::Track, recob::Hit>>
(fTrackTag);
std::vector<double> totalCharge;
art::for_each_group(*assns,
[&totalCharge](auto hits)
{
double total = 0.;
for (auto iHit = begin(hits); iHit != end(hits); ++iHit)
total += (*iHit)->Integral();
totalCharge.push_back(total);
}
);

A number of important points need to be realised about this example:

  • the requirements of this function translate, for this example, into:
    • at the creation of the associations data product, for each track the complete sequence of hits must be associated, one hit after the other (via addSingle); if the order of the hits is relevant (it is not in this specific example), hits must be associated in that order
    • each track must have at least one associated hit;
    • the original association has to be stored with recob::Track as left key and recob::Hit as right key;
  • we use here a lambda function as func; any object behaving as a function and able to accept the range of hits as its only argument will work just as well;
  • func will be called once for every track (but if a track has no associated hit, that track will be skipped, and if a track appears in more than one association sequence, like in (T1,H1) (T1,H2) (T2,H4) (T1,H3), then that track will appear as many times);
  • func does not return any value: the results are accumulated in a new sequence;
  • func receives a range of art pointers (art::Ptr<recob::Hit>) which needs to be navigated with the begin()/end() free functions (don't specify their namespace: C++ will figure out!); double dereferencing is needed: the first (*iHit) will turn the range iterator into the pointed art::Ptr<recob::Hit>, and the second ((...)->Integral()) accesses the recob::Hit pointed by the art pointer;
  • func does not know which track the hits are associated to, and it assumes that the first sequence of hits is associated to the first track (so that its total charge will be available in totalCharge[0]), the second sequence to the second track (totalCharge[1]) and so on.

Therefore, for a assns sequence like 

(T1,H1) (T1,H2) (T2,H4) (T2,H6) (T1,H5)

the function for_each_group() will execute two calls: 

func({ H1, H2 })
func({ H4, H6, H5 })

dealing with the hits associated to T1 first, and T2 next.

Definition at line 111 of file AssnsAlgorithms.h.

112  {
113  ranges::for_each(assns | ranges::views::all |
114  ranges::views::group_by([](auto a1, auto a2) {
115  return a1.first == a2.first;
116  }) |
117  ranges::views::transform([](auto pairs) {
118  return pairs | ranges::views::values;
119  }),
120  func);
121  }
a2
#define a2
Definition: HoughBaseAlg.cxx:64
values
Q_UINT16 values[128]
Definition: qtextcodec.cpp:1352
all
static QInternalList< QTextCodec > * all
Definition: qtextcodec.cpp:63
docstring.func
def func()
Definition: docstring.py:7
wirecell.sigproc.response.group_by
def group_by(rflist, field)
Definition: __init__.py:162
a1
#define a1
Definition: HoughBaseAlg.cxx:63
template<typename A , typename B , typename D , typename F >
void art::for_each_group_with_left ( art::Assns< A, B, D > const &  assns,
F  func 
)

Definition at line 141 of file AssnsAlgorithms.h.

142  {
143  for_each_pair(assns, [&func](auto rng) {
144  auto rights = rng | ranges::views::values;
145  auto lefts = rng | ranges::views::keys;
146  auto const& left = **ranges::begin(lefts);
147  func(left, rights);
148  });
149  }
test_gpu_visible.rng
rng
Definition: test_gpu_visible.py:9
values
Q_UINT16 values[128]
Definition: qtextcodec.cpp:1352
art::for_each_pair
void for_each_pair(art::Assns< A, B, D > const &assns, F func)
Definition: AssnsAlgorithms.h:153
docstring.func
def func()
Definition: docstring.py:7
util::begin
decltype(auto) constexpr begin(T &&obj)
ADL-aware version of std::begin.
Definition: StdUtils.h:72
template<typename A , typename B , typename D , typename F >
void art::for_each_pair ( art::Assns< A, B, D > const &  assns,
F  func 
)

Definition at line 153 of file AssnsAlgorithms.h.

154  {
155  ranges::for_each(assns | ranges::views::all |
156  ranges::views::group_by(
157  [](auto a1, auto a2) { return a1.first == a2.first; }),
158  func);
159  }
a2
#define a2
Definition: HoughBaseAlg.cxx:64
all
static QInternalList< QTextCodec > * all
Definition: qtextcodec.cpp:63
docstring.func
def func()
Definition: docstring.py:7
wirecell.sigproc.response.group_by
def group_by(rflist, field)
Definition: __init__.py:162
a1
#define a1
Definition: HoughBaseAlg.cxx:63
constexpr auto art::fullRun ( )

Definition at line 22 of file ProductSemantics.h.

23  {
24  return FullSemantic<Level::Run>{};
25  }
constexpr auto art::fullSubRun ( )

Definition at line 27 of file ProductSemantics.h.

28  {
29  return FullSemantic<Level::SubRun>{};
30  }
template<typename T , typename L , typename R , typename D >
auto const & art::get ( AssnsNode< L, R, D > const &  r)

Definition at line 115 of file AssnsNode.h.

116  {
117  return detail::get_helper<L, R, D>::template get_element<T>(r);
118  }
plot_model.r
r
Definition: plot_model.py:57
std::string const& art::getCanvasReleaseVersion ( )
template<typename Collection >
void art::getElementAddresses ( Collection const &  coll,
std::type_info const &  iToType,
std::vector< unsigned long > const &  indices,
std::vector< void const * > &  oPtr 
)

Definition at line 67 of file getElementAddresses.h.

71 {
72  oPtr.reserve(indices.size());
73  for (auto const index : indices) {
74  auto it = coll.cbegin();
75  advance(it, index);
76  oPtr.push_back(detail::maybeCastObj(
77  detail::GetProduct<Collection>::address(it), iToType));
78  }
79 }
art::detail::maybeCastObj
void const * maybeCastObj(void const *address, std::type_info const &tiFrom, std::type_info const &tiTo)
template<typename T >
void art::getElementAddresses ( cet::map_vector< T > const &  obj,
std::type_info const &  iToType,
std::vector< unsigned long > const &  indices,
std::vector< void const * > &  oPtr 
)

Definition at line 83 of file getElementAddresses.h.

87 {
88  detail::value_type_helper vh;
89  std::string const wanted_type =
90  uniform_type_name(cet::demangle_symbol(iToType.name()));
91  static size_t const pos = vh.look_past_pair<T>();
92  oPtr.reserve(indices.size());
93  if ((pos < wanted_type.size()) && vh.starts_with_pair(wanted_type, pos)) {
94  // Want value_type.
95  for (auto const index : indices) {
96  auto it = obj.find(cet::map_vector_key{index});
97  auto ptr = (it == obj.cend()) ? nullptr : &*it;
98  oPtr.push_back(detail::maybeCastObj(ptr, iToType));
99  }
100  } else {
101  // Want mapped_type.
102  for (auto const index : indices) {
103  auto ptr = obj.getOrNull(cet::map_vector_key{index});
104  oPtr.push_back(detail::maybeCastObj(ptr, iToType));
105  }
106  }
107 }
cet::map_vector::cend
const_iterator cend() const noexcept
Definition: map_vector.h:228
string
std::string string
Definition: nybbler.cc:12
cet::map_vector::find
iterator find(key_type key)
Definition: map_vector.h:381
cet::map_vector_key
Definition: map_vector.h:34
art::uniform_type_name
std::string uniform_type_name(std::type_info const &tid)
Definition: uniform_type_name.h:36
art::detail::maybeCastObj
void const * maybeCastObj(void const *address, std::type_info const &tiFrom, std::type_info const &tiTo)
cet::map_vector::getOrNull
mapped_type * getOrNull(key_type key)
Definition: map_vector.h:417
std::string const& art::getReleaseVersion ( )
std::string art::glob2reg ( std::string  pattern)

Definition at line 17 of file RegexMatch.cc.

18  {
19  cet::replace_all(pattern, "*", ".*");
20  cet::replace_all(pattern, "?", ".");
21  return pattern;
22  }
cet::replace_all
bool replace_all(std::string &in, std::string const &from, std::string const &to)
Replace all occurrences of from in string with to.
Definition: replace_all.cc:4
pattern
std::string pattern
Definition: regex_t.cc:35
constexpr auto art::highest_level ( )
noexcept

Definition at line 32 of file Level.h.

33  {
34  return Level{0};
35  }
art::Level
Level
Definition: Level.h:13
template<Direction Dir>
constexpr auto art::index_for_dereferencing ( std::size_t const  i)

Definition at line 85 of file AssnsIter.h.

86  {
87  return (Dir == Direction::Forward) ? i : i - 1;
88  }
constexpr bool art::is_above_most_deeply_nested_level ( Level const  l)
noexcept

Definition at line 56 of file Level.h.

57  {
58  return underlying_value(l) < underlying_value(most_deeply_nested_level());
59  }
art::most_deeply_nested_level
constexpr auto most_deeply_nested_level() noexcept
Definition: Level.h:44
art::underlying_value
constexpr auto underlying_value(Level const l) noexcept
Definition: Level.h:26
l
static QStrList * l
Definition: config.cpp:1044
bool art::is_assns ( std::string const &  type_name)
inline

Definition at line 66 of file TypeID.h.

67  {
68  using namespace std::string_literals;
69  return is_instantiation_of(type_name, "art::Assns"s);
70  }
string_literals
art::is_instantiation_of
bool is_instantiation_of(TypeID const &tid, std::string const &template_name)
Definition: TypeID.h:60
s
static QCString * s
Definition: config.cpp:1042
bool art::is_assns ( TypeID const &  tid)
inline

Definition at line 73 of file TypeID.h.

74  {
75  return is_assns(tid.className());
76  }
art::is_assns
bool is_assns(TypeID const &tid)
Definition: TypeID.h:73
bool art::is_glob ( std::string const &  pattern)

Definition at line 11 of file RegexMatch.cc.

12  {
13  return pattern.find_first_of("*?") != std::string::npos;
14  }
pattern
std::string pattern
Definition: regex_t.cc:35
constexpr bool art::is_highest_level ( Level const  l)
noexcept

Definition at line 68 of file Level.h.

69  {
70  return l == highest_level();
71  }
l
static QStrList * l
Definition: config.cpp:1044
art::highest_level
constexpr auto highest_level() noexcept
Definition: Level.h:32
bool art::is_instantiation_of ( std::string const &  type_name,
std::string const &  template_name 
)
inline

Definition at line 53 of file TypeID.h.

55  {
56  return type_name.find(template_name + '<') == 0ull;
57  }
bool art::is_instantiation_of ( TypeID const &  tid,
std::string const &  template_name 
)
inline

Definition at line 60 of file TypeID.h.

61  {
62  return is_instantiation_of(tid.className(), template_name);
63  }
art::is_instantiation_of
bool is_instantiation_of(TypeID const &tid, std::string const &template_name)
Definition: TypeID.h:60
constexpr bool art::is_legacy ( ServiceScope const  scope)
noexcept

Definition at line 10 of file ServiceScope.h.

11  {
12  return scope == ServiceScope::LEGACY;
13  }
scope
static QCString scope
Definition: declinfo.cpp:668
constexpr bool art::is_level_contained_by ( Level const  l1,
Level const  l2 
)
noexcept

Definition at line 74 of file Level.h.

75  {
76  return underlying_value(l1) > underlying_value(l2);
77  }
art::underlying_value
constexpr auto underlying_value(Level const l) noexcept
Definition: Level.h:26
bool art::is_modifier ( ModuleType const  mt)
inline

Definition at line 22 of file ModuleType.h.

23  {
24  return (mt == ModuleType::producer) || (mt == ModuleType::filter);
25  }
filter
static unsigned filter(unsigned char *out, const unsigned char *in, unsigned w, unsigned h, const LodePNG_InfoColor *info)
Definition: lodepng.cpp:3576
constexpr bool art::is_most_deeply_nested_level ( Level const  l)
noexcept

Definition at line 62 of file Level.h.

63  {
64  return l == most_deeply_nested_level();
65  }
art::most_deeply_nested_level
constexpr auto most_deeply_nested_level() noexcept
Definition: Level.h:44
l
static QStrList * l
Definition: config.cpp:1044
bool art::is_observer ( ModuleType const  mt)
inline

Definition at line 28 of file ModuleType.h.

29  {
30  return (mt == ModuleType::analyzer) || (mt == ModuleType::output_module);
31  }
constexpr bool art::is_shared ( ServiceScope const  scope)
noexcept

Definition at line 15 of file ServiceScope.h.

16  {
17  return scope == ServiceScope::SHARED;
18  }
scope
static QCString scope
Definition: declinfo.cpp:668
template<Level L = Level::Event>
constexpr bool art::is_valid ( IDNumber_t< L > const  id)
noexcept

Definition at line 113 of file IDNumber.h.

114  {
115  return id != IDNumber<L>::invalid();
116  }
bool art::isAncestor ( ProcessHistory const &  a,
ProcessHistory const &  b 
)

Definition at line 253 of file ProcessHistory.cc.

254  {
255  if (a.size() >= b.size()) {
256  return false;
257  }
258  typedef ProcessHistory::collection_type::const_iterator const_iterator;
259  for (const_iterator itA = a.data().begin(),
260  itB = b.data().begin(),
261  itAEnd = a.data().end();
262  itA != itAEnd;
263  ++itA, ++itB) {
264  if (*itA != *itB) {
265  return false;
266  }
267  }
268  return true;
269  }
const_iterator
intermediate_table::const_iterator const_iterator
Definition: intermediate_table.cc:28
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::isDescendant ( ProcessHistory const &  a,
ProcessHistory const &  b 
)

Definition at line 272 of file ProcessHistory.cc.

273  {
274  return isAncestor(b, a);
275  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
art::isAncestor
bool isAncestor(ProcessHistory const &a, ProcessHistory const &b)
Definition: ProcessHistory.cc:253
b
static bool * b
Definition: config.cpp:1043
template<typename L , typename R , typename D , Direction Dir>
constexpr auto const& art::left ( const_AssnsIter< L, R, D, Dir > const &  a,
const_AssnsIter< L, R, D, Dir > const &  b 
)

Definition at line 94 of file AssnsIter.h.

96  {
97  return (Dir == Direction::Forward) ? a : b;
98  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
constexpr auto art::level_down ( Level const  l)
noexcept

Definition at line 50 of file Level.h.

51  {
52  return Level{underlying_value(l) + 1};
53  }
art::underlying_value
constexpr auto underlying_value(Level const l) noexcept
Definition: Level.h:26
art::Level
Level
Definition: Level.h:13
l
static QStrList * l
Definition: config.cpp:1044
constexpr auto art::level_up ( Level const  l)
noexcept

Definition at line 38 of file Level.h.

39  {
40  return Level{underlying_value(l) - 1};
41  }
art::underlying_value
constexpr auto underlying_value(Level const l) noexcept
Definition: Level.h:26
art::Level
Level
Definition: Level.h:13
l
static QStrList * l
Definition: config.cpp:1044
auto art::make_product_descriptions ( ProductList const &  productList)
inline

Definition at line 19 of file ProductList.h.

20  {
21  ProductDescriptions result;
22  cet::transform_all(productList, back_inserter(result), [](auto const& pr) {
23  return pr.second;
24  });
25  return result;
26  }
result
static QCString result
Definition: fortranscanner.cpp:56614
art::ProductDescriptions
std::vector< BranchDescription > ProductDescriptions
Definition: BranchDescription.h:284
cet::transform_all
auto transform_all(Container &, OutputIt, UnaryOp)
Definition: container_algorithms.h:284
template<typename T >
std::enable_if_t<std::is_class<T>::value, tool_return_type<T> > art::make_tool ( fhicl::ParameterSet const &  pset)

Definition at line 18 of file make_tool.h.

19  {
20  cet::BasicPluginFactory factory{Suffixes::tool(), "makeTool"};
21  std::string const libspec{pset.get<std::string>("tool_type")};
22  tool_return_type<T> result;
23  try {
24  result = detail::tool_type<T>::make_plugin(factory, libspec, pset);
25  }
26  catch (cet::exception const& e) {
27  throw Exception(errors::Configuration, "make_tool: ", e)
28  << "Exception caught while processing plugin spec: " << libspec << '\n';
29  }
30  return result;
31  }
result
static QCString result
Definition: fortranscanner.cpp:56614
string
std::string string
Definition: nybbler.cc:12
e
const double e
Definition: gUpMuFluxGen.cxx:165
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
fhicl::exception
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<typename T >
std::enable_if_t<std::is_function<T>::value, tool_return_type<T> > art::make_tool ( fhicl::ParameterSet const &  pset,
std::string const &  function_tool_type 
)

Definition at line 35 of file make_tool.h.

37  {
38  cet::BasicPluginFactory factory{
39  Suffixes::tool(), "toolFunction", "toolType"};
40  std::string const libspec{pset.get<std::string>("tool_type")};
41  tool_return_type<T> result;
42  try {
43  result = detail::tool_type<T>::make_plugin(
44  factory, libspec, pset, function_tool_type);
45  }
46  catch (cet::exception const& e) {
47  throw Exception(errors::Configuration, "make_tool: ", e)
48  << "Exception caught while processing plugin spec: " << libspec << '\n';
49  }
50  return result;
51  }
result
static QCString result
Definition: fortranscanner.cpp:56614
string
std::string string
Definition: nybbler.cc:12
e
const double e
Definition: gUpMuFluxGen.cxx:165
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
fhicl::exception
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
template<typename T , typename TableConfig >
tool_return_type<T> art::make_tool ( TableConfig const &  tc,
std::string const &  function_tool_type 
)

Definition at line 55 of file make_tool.h.

56  {
57  if constexpr (std::is_class_v<T>) {
58  return make_tool<T>(tc.get_PSet());
59  } else if (std::is_function_v<T>) {
60  return make_tool<T>(tc.get_PSet(), function_tool_type);
61  }
62  }
static void art::markAncestors ( ProductProvenance const &  iInfo,
EventPrincipal &  e,
std::map< ProductID, bool > &  oMap,
std::set< ProductID > &  oMapperMissing 
)
static

Definition at line 52 of file ProvenanceCheckerOutput_module.cc.

56  {
57  for (art::ProductID const parent : iInfo.parentage().parents()) {
58  // Don't look for parents if we've previously looked at the parents
59  if (oMap.find(parent) == oMap.end()) {
60  // use side effect of calling operator[] which is if the item isn't
61  // there it will add it as 'false'
62  oMap[parent];
63  cet::exempt_ptr<ProductProvenance const> pInfo =
64  e.branchToProductProvenance(parent);
65  if (pInfo.get()) {
66  markAncestors(*pInfo, e, oMap, oMapperMissing);
67  } else {
68  oMapperMissing.insert(parent);
69  }
70  }
71  }
72  }
art::markAncestors
static void markAncestors(ProductProvenance const &iInfo, EventPrincipal &e, std::map< ProductID, bool > &oMap, std::set< ProductID > &oMapperMissing)
Definition: ProvenanceCheckerOutput_module.cc:52
cet::exempt_ptr::get
constexpr pointer get() const noexcept
Definition: exempt_ptr.h:148
e
const double e
Definition: gUpMuFluxGen.cxx:165
cet::exempt_ptr
Definition: exempt_ptr.h:38
wirecell.util.wires.graph.parent
def parent(G, child, parent_type)
Definition: graph.py:67
art::MFSU_0_ARG_UPDATER_DEFN ( PostBeginJob  )

Definition at line 83 of file MFStatusUpdater.cc.

84  {
85  mf::SetModuleName("PostBeginJob"s);
86  mf::SetIteration("BeforeEvents"s);
87  }
mf::SetIteration
void SetIteration(string const &val)
Definition: MessageLogger.cc:574
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_0_ARG_UPDATER_DEFN ( PostEndJob  )

Definition at line 89 of file MFStatusUpdater.cc.

89 { mf::SetModuleName("PostEndJob"s); }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_0_ARG_UPDATER_DEFN ( PreSourceSubRun  )

Definition at line 104 of file MFStatusUpdater.cc.

105  {
106  mf::SetModuleName("SourceSubRun"s);
107  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_0_ARG_UPDATER_DEFN ( PreSourceRun  )

Definition at line 114 of file MFStatusUpdater.cc.

114 { mf::SetModuleName("SourceRun"s); }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_0_ARG_UPDATER_DEFN ( PreOpenFile  )

Definition at line 121 of file MFStatusUpdater.cc.

121 { mf::SetModuleName("OpenFile"s); }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_0_ARG_UPDATER_DEFN ( PreCloseFile  )

Definition at line 125 of file MFStatusUpdater.cc.

125 { mf::SetModuleName("CloseFile"s); }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_0_ARG_UPDATER_DEFN ( PostCloseFile  )

Definition at line 127 of file MFStatusUpdater.cc.

128  {
129  mf::SetModuleName("PostCloseFile"s);
130  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostSourceConstruction  )

Definition at line 91 of file MFStatusUpdater.cc.

92  {
93  mf::SetModuleName("PostSourceConstruction"s);
94  mf::SetIteration("SourceConstruction"s);
95  }
mf::SetIteration
void SetIteration(string const &val)
Definition: MessageLogger.cc:574
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PreSourceEvent  )

Definition at line 97 of file MFStatusUpdater.cc.

97 { mf::SetModuleName("SourceEvent"s); }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostSourceSubRun  )

Definition at line 109 of file MFStatusUpdater.cc.

110  {
111  mf::SetModuleName("PostSourceSubRun"s);
112  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostSourceRun  )

Definition at line 116 of file MFStatusUpdater.cc.

117  {
118  mf::SetModuleName("PostSourceRun"s);
119  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostOpenFile  )

Definition at line 123 of file MFStatusUpdater.cc.

123 { mf::SetModuleName("PostOpenFile"s); }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PreBeginRun  )

Definition at line 145 of file MFStatusUpdater.cc.

146  {
147  mf::SetModuleName("BeginRun"s);
148  std::ostringstream os;
149  os << arg1.id();
150  mf::SetIteration(os.str());
151  }
mf::SetIteration
void SetIteration(string const &val)
Definition: MessageLogger.cc:574
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostBeginRun  )

Definition at line 153 of file MFStatusUpdater.cc.

153 { mf::SetModuleName("PostBeginRun"s); }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostEndRun  )

Definition at line 163 of file MFStatusUpdater.cc.

163 { mf::SetModuleName("PostEndRun"s); }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PreBeginSubRun  )

Definition at line 165 of file MFStatusUpdater.cc.

166  {
167  mf::SetModuleName("BeginSubRun"s);
168  std::ostringstream os;
169  os << arg1.id();
170  mf::SetIteration(os.str());
171  }
mf::SetIteration
void SetIteration(string const &val)
Definition: MessageLogger.cc:574
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostBeginSubRun  )

Definition at line 173 of file MFStatusUpdater.cc.

174  {
175  mf::SetModuleName("PostBeginSubRun"s);
176  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostEndSubRun  )

Definition at line 186 of file MFStatusUpdater.cc.

187  {
188  mf::SetModuleName("PostEndSubRun"s);
189  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PreProcessPath  )

Definition at line 191 of file MFStatusUpdater.cc.

192  {
193  mf::SetModuleName("ProcessPath "s + arg1.pathName());
194  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PrePathBeginRun  )

Definition at line 201 of file MFStatusUpdater.cc.

202  {
203  mf::SetModuleName("PathBeginRun "s + arg1);
204  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PrePathEndRun  )

Definition at line 211 of file MFStatusUpdater.cc.

212  {
213  mf::SetModuleName("PathEndRun "s + arg1);
214  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PrePathBeginSubRun  )

Definition at line 221 of file MFStatusUpdater.cc.

222  {
223  mf::SetModuleName("PathBeginSubRun "s + arg1);
224  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PrePathEndSubRun  )

Definition at line 231 of file MFStatusUpdater.cc.

232  {
233  mf::SetModuleName("PathEndSubRun "s + arg1);
234  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleConstruction  )

Definition at line 241 of file MFStatusUpdater.cc.

242  {
243  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
244  "@Construction"s);
245  mf::SetIteration("ModuleConstruction"s);
246  }
mf::SetIteration
void SetIteration(string const &val)
Definition: MessageLogger.cc:574
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleConstruction  )

Definition at line 248 of file MFStatusUpdater.cc.

249  {
250  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
251  "@Construction"s);
252  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleBeginJob  )

Definition at line 259 of file MFStatusUpdater.cc.

260  {
261  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
262  "@BeginJob"s);
263  mf::SetIteration("ModuleBeginJob"s);
264  }
mf::SetIteration
void SetIteration(string const &val)
Definition: MessageLogger.cc:574
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleBeginJob  )

Definition at line 266 of file MFStatusUpdater.cc.

267  {
268  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
269  "@BeginJob"s);
270  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleEndJob  )

Definition at line 272 of file MFStatusUpdater.cc.

273  {
274  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
275  "@EndJob"s);
276  mf::SetIteration("ModuleEndJob"s);
277  }
mf::SetIteration
void SetIteration(string const &val)
Definition: MessageLogger.cc:574
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleEndJob  )

Definition at line 279 of file MFStatusUpdater.cc.

280  {
281  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
282  "@EndJob"s);
283  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PreModule  )

Definition at line 285 of file MFStatusUpdater.cc.

286  {
287  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
288  "@BeginModule"s);
289  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostModule  )

Definition at line 291 of file MFStatusUpdater.cc.

292  {
293  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
294  "@EndModule"s);
295  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleBeginRun  )

Definition at line 297 of file MFStatusUpdater.cc.

298  {
299  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
300  "@BeginRun"s);
301  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleBeginRun  )

Definition at line 303 of file MFStatusUpdater.cc.

304  {
305  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
306  "@BeginRun"s);
307  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleEndRun  )

Definition at line 309 of file MFStatusUpdater.cc.

310  {
311  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
312  "@EndRun"s);
313  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleEndRun  )

Definition at line 315 of file MFStatusUpdater.cc.

316  {
317  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
318  "@EndRun"s);
319  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleBeginSubRun  )

Definition at line 321 of file MFStatusUpdater.cc.

322  {
323  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
324  "@BeginSubRun"s);
325  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleBeginSubRun  )

Definition at line 327 of file MFStatusUpdater.cc.

328  {
329  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
330  "@BeginSubRun"s);
331  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PreModuleEndSubRun  )

Definition at line 333 of file MFStatusUpdater.cc.

334  {
335  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
336  "@EndSubRun"s);
337  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_1_ARG_UPDATER_DEFN ( PostModuleEndSubRun  )

Definition at line 339 of file MFStatusUpdater.cc.

340  {
341  mf::SetModuleName(arg1.moduleName() + ":"s + arg1.moduleLabel() +
342  "@EndSubRun"s);
343  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_2_ARG_UPDATER_DEFN ( PostSourceEvent  )

Definition at line 99 of file MFStatusUpdater.cc.

100  {
101  mf::SetModuleName("PostSourceEvent"s);
102  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_2_ARG_UPDATER_DEFN ( PreProcessEvent  )

Definition at line 132 of file MFStatusUpdater.cc.

133  {
134  mf::SetModuleName("ProcessEvent"s);
135  std::ostringstream os;
136  os << arg1.id();
137  mf::SetIteration(os.str());
138  }
mf::SetIteration
void SetIteration(string const &val)
Definition: MessageLogger.cc:574
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_2_ARG_UPDATER_DEFN ( PostProcessEvent  )

Definition at line 140 of file MFStatusUpdater.cc.

141  {
142  mf::SetModuleName("PostProcessEvent"s);
143  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_2_ARG_UPDATER_DEFN ( PreEndRun  )

Definition at line 155 of file MFStatusUpdater.cc.

156  {
157  mf::SetModuleName("EndRun"s);
158  std::stringstream os;
159  os << arg1;
160  mf::SetIteration(os.str());
161  }
mf::SetIteration
void SetIteration(string const &val)
Definition: MessageLogger.cc:574
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_2_ARG_UPDATER_DEFN ( PreEndSubRun  )

Definition at line 178 of file MFStatusUpdater.cc.

179  {
180  mf::SetModuleName("EndSubRun"s);
181  std::ostringstream os;
182  os << arg1;
183  mf::SetIteration(os.str());
184  }
mf::SetIteration
void SetIteration(string const &val)
Definition: MessageLogger.cc:574
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_2_ARG_UPDATER_DEFN ( PostProcessPath  )

Definition at line 196 of file MFStatusUpdater.cc.

197  {
198  mf::SetModuleName("PostProcessPath "s + arg1.pathName());
199  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_2_ARG_UPDATER_DEFN ( PostPathBeginRun  )

Definition at line 206 of file MFStatusUpdater.cc.

207  {
208  mf::SetModuleName("PostPathBeginRun "s + arg1);
209  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_2_ARG_UPDATER_DEFN ( PostPathEndRun  )

Definition at line 216 of file MFStatusUpdater.cc.

217  {
218  mf::SetModuleName("PostPathEndRun "s + arg1);
219  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_2_ARG_UPDATER_DEFN ( PostPathBeginSubRun  )

Definition at line 226 of file MFStatusUpdater.cc.

227  {
228  mf::SetModuleName("PostPathBeginSubRun "s + arg1);
229  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_2_ARG_UPDATER_DEFN ( PostPathEndSubRun  )

Definition at line 236 of file MFStatusUpdater.cc.

237  {
238  mf::SetModuleName("PostPathEndSubRun "s + arg1);
239  }
mf::SetModuleName
void SetModuleName(string const &val)
Definition: MessageLogger.cc:595
s
static QCString * s
Definition: config.cpp:1042
art::MFSU_2_ARG_UPDATER_DEFN ( PostBeginJobWorkers  )

Definition at line 254 of file MFStatusUpdater.cc.

255  {
256  throw cet::exception("InternalError"s) << "NOP: do not call";
257  }
s
static QCString * s
Definition: config.cpp:1042
fhicl::exception
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
constexpr auto art::most_deeply_nested_level ( )
noexcept

Definition at line 44 of file Level.h.

45  {
46  return level_up(Level::NumNestingLevels);
47  }
art::level_up
constexpr auto level_up(Level const l) noexcept
Definition: Level.h:38
std::string art::name_of_assns_base ( string  assns_type_name)

Definition at line 185 of file TypeID.cc.

186  {
187  string result;
188  if (!is_assns(assns_type_name)) {
189  return result;
190  }
191  using namespace std::string_literals;
192  static string const assns_start = "art::Assns<"s;
193  if (name_of_template_arg(assns_type_name, 2) == "void"s) {
194  // Doesn't have the base we're looking for.
195  return result;
196  }
197  result = assns_start + name_of_template_arg(assns_type_name, 0) + ',' +
198  name_of_template_arg(assns_type_name, 1) + ",void>";
199  return result;
200  }
result
static QCString result
Definition: fortranscanner.cpp:56614
string_literals
art::name_of_template_arg
string name_of_template_arg(string const &template_instance, size_t desired_arg)
Definition: TypeID.cc:118
s
static QCString * s
Definition: config.cpp:1042
art::is_assns
bool is_assns(std::string const &type_name)
Definition: TypeID.h:66
std::string art::name_of_assns_partner ( string  assns_type_name)

Definition at line 170 of file TypeID.cc.

171  {
172  string result;
173  if (!is_assns(assns_type_name)) {
174  return result;
175  }
176  static string const assns_start = "art::Assns<"s;
177  auto const arg0 = name_of_template_arg(assns_type_name, 0);
178  auto const arg1 = name_of_template_arg(assns_type_name, 1);
179  auto const arg2 = name_of_template_arg(assns_type_name, 2);
180  result = assns_start + arg1 + ',' + arg0 + ',' + arg2 + '>';
181  return result;
182  }
result
static QCString result
Definition: fortranscanner.cpp:56614
art::name_of_template_arg
string name_of_template_arg(string const &template_instance, size_t desired_arg)
Definition: TypeID.cc:118
s
static QCString * s
Definition: config.cpp:1042
art::is_assns
bool is_assns(std::string const &type_name)
Definition: TypeID.h:66
std::string art::name_of_template_arg ( string const &  template_instance,
size_t  desired_arg 
)

Definition at line 118 of file TypeID.cc.

119  {
120  string result;
121  auto comma_count = 0ul;
122  auto template_level = 0ul;
123  auto arg_start = string::npos;
124  auto pos = 0ul;
125  pos = template_instance.find_first_of("<>,", pos);
126  while (pos != string::npos) {
127  switch (template_instance[pos]) {
128  case '<':
129  ++template_level;
130  if ((desired_arg == 0ul) && (template_level == 1ul)) {
131  // Found the begin of the desired template arg.
132  arg_start = pos + 1;
133  }
134  break;
135  case '>':
136  --template_level;
137  if ((desired_arg == comma_count) && (template_level == 0ul)) {
138  // Found the end of the desired template arg -- trim trailing
139  // whitespace
140  auto const arg_end =
141  template_instance.find_last_not_of(" \t", pos - 1) + 1;
142  result = template_instance.substr(arg_start, arg_end - arg_start);
143  return result;
144  }
145  break;
146  case ',':
147  if (template_level != 1ul) {
148  // Ignore arguments not at the first level.
149  break;
150  }
151  if (comma_count == desired_arg) {
152  // Found the end of the desired template arg.
153  result = template_instance.substr(arg_start, pos - arg_start);
154  return result;
155  }
156  ++comma_count;
157  if (comma_count == desired_arg) {
158  // Found the begin of the desired template arg.
159  arg_start = pos + 1;
160  }
161  break;
162  }
163  ++pos;
164  pos = template_instance.find_first_of("<>,", pos);
165  }
166  return result;
167  }
result
static QCString result
Definition: fortranscanner.cpp:56614
std::string art::name_of_unwrapped_product ( string const &  wrapped_name)

Definition at line 203 of file TypeID.cc.

204  {
205  using namespace std::string_literals;
206  if (!is_instantiation_of(wrapped_name, "art::Wrapper"s)) {
207  throw Exception(errors::LogicError, "Can't unwrap"s)
208  << "-- attempted to get unwrapped product from non-instance of art::Wrapper."s;
209  }
210  return name_of_template_arg(wrapped_name, 0);
211  }
string_literals
art::is_instantiation_of
bool is_instantiation_of(std::string const &type_name, std::string const &template_name)
Definition: TypeID.h:53
art::name_of_template_arg
string name_of_template_arg(string const &template_instance, size_t desired_arg)
Definition: TypeID.cc:118
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
s
static QCString * s
Definition: config.cpp:1042
template<typename A >
std::enable_if_t<is_selector<A>, NotHelper<A> > art::operator! ( A const &  a)

Definition at line 259 of file Selector.h.

260  {
261  return NotHelper<A>{a};
262  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
bool art::operator!= ( BranchKey const &  a,
BranchKey const &  b 
)
inline

Definition at line 83 of file BranchKey.h.

84 {
85  return !(a == b);
86 }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator!= ( FileFormatVersion const &  a,
FileFormatVersion const &  b 
)
inline

Definition at line 34 of file FileFormatVersion.h.

35  {
36  return !(a == b);
37  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator!= ( ScheduleID const  left,
ScheduleID const  right 
)
noexcept

Definition at line 41 of file ScheduleID.cc.

42  {
43  return !(left == right);
44  }
bool art::operator!= ( Parentage const &  a,
Parentage const &  b 
)

Definition at line 55 of file Parentage.cc.

56  {
57  return !(a == b);
58  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator!= ( ProcessConfiguration const &  a,
ProcessConfiguration const &  b 
)

Definition at line 65 of file ProcessConfiguration.cc.

66  {
67  return !(a == b);
68  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
constexpr bool art::operator!= ( RefCore const &  lhs,
RefCore const &  rhs 
)
noexcept

Definition at line 77 of file RefCore.h.

78  {
79  return !(lhs == rhs);
80  }
bool art::operator!= ( TypeID const &  a,
TypeID const &  b 
)

Definition at line 99 of file TypeID.cc.

100  {
101  return !(a == b);
102  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator!= ( ProductProvenance const &  a,
ProductProvenance const &  b 
)
noexcept

Definition at line 107 of file ProductProvenance.cc.

108  {
109  return !(a == b);
110  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
template<class X , class Y >
bool art::operator!= ( debugging_allocator< X > const &  ,
debugging_allocator< Y > const &   
)
throw (
)

Definition at line 108 of file debugging_allocator.h.

110  {
111  return false;
112  }
bool art::operator!= ( InputTag const &  left,
InputTag const &  right 
)

Definition at line 111 of file InputTag.cc.

112  {
113  return !(left == right);
114  }
bool art::operator!= ( ProcessHistory const &  a,
ProcessHistory const &  b 
)

Definition at line 247 of file ProcessHistory.cc.

248  {
249  return !(a == b);
250  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
template<typename T , typename U >
std::enable_if_t<std::is_same_v<T, U> || std::is_base_of_v<T, U> || std::is_base_of_v<U, T>, bool> art::operator!= ( Ptr< T > const &  lhs,
Ptr< U > const &  rhs 
)

Definition at line 275 of file Ptr.h.

276  {
277  return !(lhs == rhs);
278  }
bool art::operator!= ( FileIndex::Element const &  lh,
FileIndex::Element const &  rh 
)

Definition at line 445 of file FileIndex.cc.

446  {
447  return !(lh == rh);
448  }
bool art::operator!= ( FileIndex const &  lh,
FileIndex const &  rh 
)

Definition at line 457 of file FileIndex.cc.

458  {
459  return !(lh == rh);
460  }
template<typename A , typename B >
std::enable_if_t<is_selector<A> && is_selector<B>, AndHelper<A, B> > art::operator&& ( A const &  a,
B const &  b 
)

Definition at line 186 of file Selector.h.

187  {
188  return AndHelper<A, B>{a, b};
189  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator< ( EventProcessHistoryID const &  lh,
EventProcessHistoryID const &  rh 
)
inline

Definition at line 17 of file EventProcessHistoryID.h.

18  {
19  return lh.eventID_ < rh.eventID_;
20  }
bool art::operator< ( BranchKey const &  a,
BranchKey const &  b 
)
inline

Definition at line 63 of file BranchKey.h.

64 {
65  return std::tie(a.friendlyClassName_,
66  a.moduleLabel_,
67  a.productInstanceName_,
68  a.processName_,
69  a.branchType_) < std::tie(b.friendlyClassName_,
70  b.moduleLabel_,
71  b.productInstanceName_,
72  b.processName_,
73  b.branchType_);
74 }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator< ( TypeLabel const &  a,
TypeLabel const &  b 
)

Definition at line 45 of file TypeLabel.cc.

46  {
47  auto const& a_class_name = a.className();
48  auto const& b_class_name = b.className();
49  auto const& a_emulated_module =
50  a.hasEmulatedModule() ? *a.emulatedModule_ : "<none>";
51  auto const& b_emulated_module =
52  b.hasEmulatedModule() ? *b.emulatedModule_ : "<none>";
53  return std::tie(a_emulated_module, a.productInstanceName_, a_class_name) <
54  std::tie(b_emulated_module, b.productInstanceName_, b_class_name);
55  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator< ( ProductInfo const &  a,
ProductInfo const &  b 
)

Definition at line 51 of file ProductInfo.cc.

52  {
53  auto const& boundA = tie(a.consumableType,
54  a.friendlyClassName,
55  a.label,
56  a.instance,
57  a.process.name());
58  auto const& boundB = tie(b.consumableType,
59  b.friendlyClassName,
60  b.label,
61  b.instance,
62  b.process.name());
63  return boundA < boundB;
64  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator< ( PathSpec const &  a,
PathSpec const &  b 
)
inline

Definition at line 65 of file PathSpec.h.

66  {
67  return to_tuple(a) < to_tuple(b);
68  }
art::to_tuple
auto to_tuple(PathSpec const &spec) noexcept
Definition: PathSpec.h:53
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator< ( ProcessConfiguration const &  a,
ProcessConfiguration const &  b 
)

Definition at line 71 of file ProcessConfiguration.cc.

72  {
73  return std::tie(a.processName(), a.parameterSetID(), a.releaseVersion()) <
74  std::tie(b.processName(), b.parameterSetID(), b.releaseVersion());
75  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
constexpr bool art::operator< ( RefCore const &  lhs,
RefCore const &  rhs 
)
noexcept

Definition at line 83 of file RefCore.h.

84  {
85  return lhs.id() < rhs.id();
86  }
bool art::operator< ( ProductProvenance const &  a,
ProductProvenance const &  b 
)
noexcept

Definition at line 115 of file ProductProvenance.cc.

116  {
117  return a.productID() < b.productID();
118  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator< ( BranchDescription const &  a,
BranchDescription const &  b 
)

Definition at line 246 of file BranchDescription.cc.

247  {
248  if (a.processName() < b.processName()) {
249  return true;
250  }
251  if (b.processName() < a.processName()) {
252  return false;
253  }
254  if (a.producedClassName() < b.producedClassName()) {
255  return true;
256  }
257  if (b.producedClassName() < a.producedClassName()) {
258  return false;
259  }
260  if (a.friendlyClassName() < b.friendlyClassName()) {
261  return true;
262  }
263  if (b.friendlyClassName() < a.friendlyClassName()) {
264  return false;
265  }
266  if (a.productInstanceName() < b.productInstanceName()) {
267  return true;
268  }
269  if (b.productInstanceName() < a.productInstanceName()) {
270  return false;
271  }
272  if (a.moduleLabel() < b.moduleLabel()) {
273  return true;
274  }
275  if (b.moduleLabel() < a.moduleLabel()) {
276  return false;
277  }
278  if (a.branchType() < b.branchType()) {
279  return true;
280  }
281  if (b.branchType() < a.branchType()) {
282  return false;
283  }
284  if (a.productID() < b.productID()) {
285  return true;
286  }
287  if (b.productID() < a.productID()) {
288  return false;
289  }
290  if (a.psetIDs() < b.psetIDs()) {
291  return true;
292  }
293  if (b.psetIDs() < a.psetIDs()) {
294  return false;
295  }
296  if (a.processConfigurationIDs() < b.processConfigurationIDs()) {
297  return true;
298  }
299  if (b.processConfigurationIDs() < a.processConfigurationIDs()) {
300  return false;
301  }
302  return false;
303  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
template<typename T , typename U >
std::enable_if_t<std::is_same_v<T, U> || std::is_base_of_v<T, U> || std::is_base_of_v<U, T>, bool> art::operator< ( Ptr< T > const &  lhs,
Ptr< U > const &  rhs 
)

Definition at line 284 of file Ptr.h.

285  {
286  // The ordering of integer keys guarantees that the ordering of Ptrs within
287  // a collection will be identical to the ordering of the referenced objects
288  // in the collection.
289  return lhs.refCore() == rhs.refCore() ? lhs.key() < rhs.key() :
290  lhs.refCore() < rhs.refCore();
291  }
bool art::operator< ( FileIndex::Element const &  lh,
FileIndex::Element const &  rh 
)

Definition at line 415 of file FileIndex.cc.

416  {
417  return lh.eventID < rh.eventID;
418  }
std::ostream & art::operator<< ( std::ostream &  os,
ParameterSetBlob const &  blob 
)

Definition at line 8 of file ParameterSetBlob.cc.

9  {
10  os << blob.pset_;
11  return os;
12  }
std::ostream& art::operator<< ( std::ostream &  os,
OutputFileStatus const  ofs 
)
inline

Definition at line 11 of file OutputFileStatus.h.

12  {
13  switch (ofs) {
14  case OutputFileStatus::Open:
15  return os << "Open";
16  case OutputFileStatus::Switching:
17  return os << "Switching";
18  case OutputFileStatus::Closed:
19  return os << "Closed";
20  default:
21  throw art::Exception{art::errors::LogicError,
22  "Unknown output file status."};
23  }
24  }
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
std::ostream & art::operator<< ( std::ostream &  os,
SubRunID const &  iID 
)

Definition at line 6 of file SubRunID.cc.

7 {
8  os << iID.run_ << " subRun: ";
9  if (iID.isFlush()) {
10  os << "FLUSH";
11  } else if (iID.isValid()) {
12  os << iID.subRun_;
13  } else {
14  os << "INVALID";
15  }
16  return os;
17 }
std::ostream & art::operator<< ( std::ostream &  os,
EventID const &  iID 
)

Definition at line 6 of file EventID.cc.

7 {
8  os << iID.subRun_ << " event: ";
9  if (iID.isFlush()) {
10  os << "FLUSH";
11  } else if (iID.isValid()) {
12  os << iID.event_;
13  } else {
14  os << "INVALID";
15  }
16  return os;
17 }
ostream & art::operator<< ( std::ostream &  os,
const GroupSelector &  gs 
)

Definition at line 62 of file GroupSelector.cc.

63 {
64  gs.print(os);
65  return os;
66 }
art::GroupSelector::print
void print(std::ostream &os) const
Definition: GroupSelector.cc:49
std::ostream & art::operator<< ( std::ostream &  os,
art::RunID const &  iID 
)

Definition at line 6 of file RunID.cc.

7 {
8  os << "run: ";
9  if (iID.isFlush()) {
10  os << "FLUSH";
11  } else if (iID.isValid()) {
12  os << iID.run_;
13  } else {
14  os << "INVALID";
15  }
16  return os;
17 }
std::ostream & art::operator<< ( std::ostream &  os,
BranchID const &  id 
)

Definition at line 20 of file BranchID.cc.

21  {
22  os << id.id();
23  return os;
24  }
std::ostream & art::operator<< ( std::ostream &  ost,
const MallocOpts &  opts 
)

Definition at line 24 of file MallocOpts.cc.

25  {
26  ost << "mmap_max=" << opts.mmap_max_ << " trim_threshold=" << opts.trim_thr_
27  << " top_padding=" << opts.top_pad_
28  << " mmap_threshold=" << opts.mmap_thr_;
29  return ost;
30  }
ECLAPI.opts
opts
Definition: ECLAPI.py:241
std::ostream & art::operator<< ( std::ostream &  os,
ProductID const  id 
)

Definition at line 25 of file ProductID.cc.

26  {
27  os << id.value();
28  return os;
29  }
std::ostream & art::operator<< ( std::ostream &  os,
BranchKey const &  bk 
)

Definition at line 30 of file BranchKey.cc.

31  {
32  os << "BranchKey(" << bk.friendlyClassName_ << ", " << bk.moduleLabel_
33  << ", " << bk.productInstanceName_ << ", " << bk.processName_ << ", "
34  << static_cast<BranchType>(bk.branchType_) << ')';
35  return os;
36  }
art::BranchType
BranchType
Definition: BranchType.h:20
std::ostream& art::operator<< ( std::ostream &  os,
BranchType const  branchType 
)
inline

Definition at line 31 of file BranchType.h.

32  {
33  return os << BranchTypeToString(branchType);
34  }
art::BranchTypeToString
std::string const & BranchTypeToString(BranchType const bt)
Definition: BranchType.cc:65
std::ostream & art::operator<< ( std::ostream &  os,
FileFormatVersion const &  ff 
)

Definition at line 5 of file FileFormatVersion.cc.

6 {
7  os << (ff.era_.empty() ? "" : (ff.era_ + ": ")) << ff.value_;
8  return os;
9 }
std::ostream& art::operator<< ( std::ostream &  os,
SampledEventInfo const &  eventInfo 
)
inline

Definition at line 42 of file SampledInfo.h.

43  {
44  os << "Sampled EventID: '" << eventInfo.id << "' Dataset: '"
45  << eventInfo.dataset << "' Weight: " << eventInfo.weight
46  << " Probability: " << eventInfo.probability;
47  return os;
48  }
std::ostream& art::operator<< ( std::ostream &  ost,
HLTGlobalStatus const &  hlt 
)
std::ostream & art::operator<< ( ostream &  os,
Parentage const &   
)

Definition at line 42 of file Parentage.cc.

43  {
44  // Unimplemented
45  return os;
46  }
std::ostream & art::operator<< ( std::ostream &  os,
TypeLabel const &  tl 
)

Definition at line 58 of file TypeLabel.cc.

59  {
60  os << "Emulated module: '"
61  << (tl.hasEmulatedModule() ? tl.emulatedModule() : "<none>") << "'\n"
62  << "Product instance name: '" << tl.productInstanceName() << "'\n"
63  << "Class name: '" << tl.className() << "'\n"
64  << "Supports views: '" << std::boolalpha << tl.supportsView()
65  << '\n'
66  << "Transient: '" << tl.transient();
67  return os;
68  }
std::ostream & art::operator<< ( std::ostream &  os,
PathSpec const &  spec 
)

Definition at line 61 of file PathSpec.cc.

62  {
63  return os << to_string(spec);
64  }
art::to_string
std::string to_string(PathSpec const &spec)
Definition: PathSpec.cc:55
std::ostream & art::operator<< ( ostream &  os,
ScheduleID const  sid 
)

Definition at line 65 of file ScheduleID.cc.

66  {
67  return os << sid.id();
68  }
std::ostream & art::operator<< ( ostream &  os,
ProductInfo::ConsumableType const  ct 
)

Definition at line 67 of file ProductInfo.cc.

68  {
69  switch (ct) {
70  case ProductInfo::ConsumableType::Product:
71  os << "Product";
72  break;
73  case ProductInfo::ConsumableType::ViewElement:
74  os << "ViewElement";
75  break;
76  case ProductInfo::ConsumableType::Many:
77  os << "Many";
78  break;
79  }
80  return os;
81  }
std::ostream& art::operator<< ( std::ostream &  os,
suffix_type const  st 
)
inline

Definition at line 70 of file PluginSuffixes.h.

71  {
72  return os << static_cast<std::underlying_type_t<suffix_type>>(st);
73  }
template<typename T >
std::ostream& art::operator<< ( std::ostream &  os,
ServiceTable< T > const &  t 
)
inline

Definition at line 71 of file ServiceTable.h.

72  {
73  std::ostringstream config;
74  t.print_allowed_configuration(config, std::string(3, ' '));
75  return os << config.str();
76  }
string
std::string string
Definition: nybbler.cc:12
config
static Config * config
Definition: config.cpp:1054
reco_momentum_tuples.t
t
Definition: reco_momentum_tuples.py:25
template<typename UserConfig , typename ImplicitConfig >
std::ostream& art::operator<< ( std::ostream &  os,
ProducerTable< UserConfig, ImplicitConfig > const &  t 
)
inline

Definition at line 73 of file ProducerTable.h.

75  {
76  std::ostringstream config;
77  t.print_allowed_configuration(config, std::string(3, ' '));
78  return os << config.str();
79  }
string
std::string string
Definition: nybbler.cc:12
config
static Config * config
Definition: config.cpp:1054
reco_momentum_tuples.t
t
Definition: reco_momentum_tuples.py:25
std::ostream& art::operator<< ( std::ostream &  os,
Level const  l 
)
inline

Definition at line 80 of file Level.h.

81  {
82  switch (l) {
83  case Level::Job:
84  os << "Job";
85  break;
86  case Level::InputFile:
87  os << "InputFile";
88  break;
89  case Level::Run:
90  os << "Run";
91  break;
92  case Level::SubRun:
93  os << "SubRun";
94  break;
95  case Level::Event:
96  os << "Event";
97  break;
98  case Level::NumNestingLevels:
99  os << underlying_value(Level::NumNestingLevels);
100  break;
101  case Level::ReadyToAdvance:
102  os << "ReadyToAdvance";
103  break;
104  }
105  return os;
106  }
art::underlying_value
constexpr auto underlying_value(Level const l) noexcept
Definition: Level.h:26
l
static QStrList * l
Definition: config.cpp:1044
Event
Definition: types.h:32
std::ostream & art::operator<< ( ostream &  os,
ProductInfo const &  info 
)

Definition at line 84 of file ProductInfo.cc.

85  {
86  os << "Consumable type: " << info.consumableType << '\n'
87  << "Friendly class name: " << info.friendlyClassName << '\n'
88  << "Module label: " << info.label << '\n'
89  << "Instance name: " << info.instance << '\n'
90  << "Process name: " << info.process.name() << '\n';
91  return os;
92  }
generate_datataset.info
info
Definition: generate_datataset.py:142
std::ostream & art::operator<< ( std::ostream &  os,
ProcessConfiguration const &  pc 
)

Definition at line 85 of file ProcessConfiguration.cc.

86  {
87  os << pc.processName() << ' ' << pc.parameterSetID() << ' '
88  << pc.releaseVersion()
89  << ' '; // Retain the last space for backwards compatibility
90  return os;
91  }
std::ostream& art::operator<< ( std::ostream &  os,
Granularity const &  b 
)
inline

Definition at line 85 of file OutputFileGranularity.h.

86  {
87  std::string token{"Unset"};
88  switch (b()) {
89  case Granularity::Event:
90  token = "Event";
91  break;
92  case Granularity::SubRun:
93  token = "SubRun";
94  break;
95  case Granularity::Run:
96  token = "Run";
97  break;
98  case Granularity::InputFile:
99  token = "InputFile";
100  break;
101  case Granularity::Job:
102  token = "Job";
103  break;
104  case Granularity::Unset:;
105  }
106  os << token;
107  return os;
108  }
string
std::string string
Definition: nybbler.cc:12
Event
Definition: types.h:32
b
static bool * b
Definition: config.cpp:1043
util::flags::Unset
constexpr BitMask< Storage > Unset(Flag_t< Storage > flag)
Returns a bit mask which unsets the specified flag.
std::ostream & art::operator<< ( ostream &  os,
ProductProvenance const &  p 
)

Definition at line 85 of file ProductProvenance.cc.

86  {
87  p.write(os);
88  return os;
89  }
test.p
p
Definition: test.py:223
std::ostream & art::operator<< ( ostream &  os,
const EventAuxiliary &  p 
)

Definition at line 101 of file EventAuxiliary.cc.

102  {
103  p.write(os);
104  return os;
105  }
test.p
p
Definition: test.py:223
std::ostream & art::operator<< ( ostream &  os,
TypeID const &  tid 
)

Definition at line 111 of file TypeID.cc.

112  {
113  tid.print(os);
114  return os;
115  }
ostream& art::operator<< ( ostream &  ost,
const HLTGlobalStatus &  hlt 
)

Definition at line 134 of file HLTGlobalStatus.cc.

135  {
136  vector<string> text{"n"s, "1"s, "0"s, "e"s};
137  unsigned const n(hlt.size());
138  for (auto i = 0U; i < n; ++i) {
139  ost << text.at(hlt.state(i));
140  }
141  return ost;
142  }
cet::n
std::void_t< T > n
Definition: metaprogramming.h:28
s
static QCString * s
Definition: config.cpp:1042
std::ostream & art::operator<< ( std::ostream &  os,
ModuleDescription const &  p 
)

Definition at line 148 of file ModuleDescription.cc.

149  {
150  p.write(os);
151  return os;
152  }
test.p
p
Definition: test.py:223
std::ostream & art::operator<< ( ostream &  os,
InputTag const &  tag 
)

Definition at line 150 of file InputTag.cc.

151  {
152  static string const process("', process = '");
153  os << "InputTag: label = '" << tag.label() << "', instance = '"
154  << tag.instance()
155  << (tag.process().empty() ? string() : (process + tag.process())) << "'";
156  return os;
157  }
string
std::string string
Definition: nybbler.cc:12
search.process
def process(f, kind)
Definition: search.py:254
std::ostream & art::operator<< ( ostream &  os,
Provenance const &  p 
)

Definition at line 157 of file Provenance.cc.

158  {
159  return p.write(os);
160  }
test.p
p
Definition: test.py:223
std::ostream & art::operator<< ( ostream &  os,
const RunAuxiliary &  p 
)

Definition at line 185 of file RunAuxiliary.cc.

186  {
187  p.write(os);
188  return os;
189  }
test.p
p
Definition: test.py:223
std::ostream & art::operator<< ( ostream &  os,
SubRunAuxiliary const &  p 
)

Definition at line 188 of file SubRunAuxiliary.cc.

189  {
190  p.write(os);
191  return os;
192  }
test.p
p
Definition: test.py:223
std::ostream & art::operator<< ( ostream &  os,
FileProperties const &  fp 
)

Definition at line 222 of file ClosingCriteria.cc.

223  {
224  os << "[nEvents: " << fp.nEvents() << ", nSubRuns: " << fp.nSubRuns()
225  << ", nRuns: " << fp.nRuns() << ", nInputFiles: " << fp.nInputFiles()
226  << ", size: " << fp.size() << ", age: " << fp.age().count() << "]";
227  return os;
228  }
wirecell.gen.test.plot_impactzipper.fp
fp
Definition: plot_impactzipper.py:64
std::ostream & art::operator<< ( ostream &  os,
EventRange const &  r 
)

Definition at line 231 of file EventRange.cc.

232  {
233  os << "SubRun: " << r.subRun();
234  if (r.is_full_subRun()) {
235  os << " (full sub-run)";
236  } else {
237  os << " Event range: [" << r.begin() << ',' << r.end() << ')';
238  }
239  return os;
240  }
plot_model.r
r
Definition: plot_model.py:57
template<int I>
std::ostream& art::operator<< ( std::ostream &  os,
Hash< I > const &  h 
)

Definition at line 245 of file Hash.h.

246  {
247  return h.print(os);
248  }
reco_momentum_tuples.h
h
Definition: reco_momentum_tuples.py:66
std::ostream & art::operator<< ( ostream &  ost,
ProcessHistory const &  ph 
)

Definition at line 278 of file ProcessHistory.cc.

279  {
280  ost << "Process History = ";
281  copy_all(ph, ostream_iterator<ProcessHistory::value_type>(ost, ";"));
282  return ost;
283  }
cet::copy_all
auto copy_all(FwdCont &, FwdIter)
Definition: container_algorithms.h:132
template<typename T >
std::ostream& art::operator<< ( std::ostream &  os,
Ptr< T > const &  p 
)

Definition at line 316 of file Ptr.h.

317  {
318  os << "(" << p.id() << ", " << p.key() << ")";
319  return os;
320  }
test.p
p
Definition: test.py:223
std::ostream & art::operator<< ( std::ostream &  os,
BranchDescription const &  p 
)

Definition at line 325 of file BranchDescription.cc.

326  {
327  p.write(os);
328  return os;
329  }
test.p
p
Definition: test.py:223
std::ostream & art::operator<< ( std::ostream &  os,
MixHelper::Mode  mode 
)

Definition at line 118 of file MixHelper.cc.

119 {
120  switch (mode) {
121  case MixHelper::Mode::SEQUENTIAL:
122  return os << "SEQUENTIAL";
123  case MixHelper::Mode::RANDOM_REPLACE:
124  return os << "RANDOM_REPLACE";
125  case MixHelper::Mode::RANDOM_LIM_REPLACE:
126  return os << "RANDOM_LIM_REPLACE";
127  case MixHelper::Mode::RANDOM_NO_REPLACE:
128  return os << "RANDOM_NO_REPLACE";
129  case MixHelper::Mode::UNKNOWN:
130  return os << "UNKNOWN";
131  // No default so compiler can warn.
132  }
133  return os;
134 }
std::ostream & art::operator<< ( ostream &  os,
RangeSet const &  rs 
)

Definition at line 477 of file RangeSet.cc.

478  {
479  os << " Run: " << rs.run();
480  if (rs.is_full_run()) {
481  os << " (full run)";
482  return os;
483  }
484  for (auto const& er : rs.ranges()) {
485  os << "\n " << er;
486  }
487  return os;
488  }
make_pion_angle.rs
list rs
Definition: make_pion_angle.py:22
std::ostream & art::operator<< ( ostream &  os,
FileIndex::Element const &  el 
)

Definition at line 480 of file FileIndex.cc.

481  {
482  os << el.eventID << ": entry# " << el.entry;
483  return os;
484  }
std::ostream & art::operator<< ( ostream &  os,
FileIndex const &  fileIndex 
)

Definition at line 487 of file FileIndex.cc.

488  {
489  os << "\nPrinting FileIndex contents. This includes a list of all Runs, "
490  "SubRuns\n"
491  << "and Events stored in the root file.\n\n";
492  os << setw(15) << "Run" << setw(15) << "SubRun" << setw(15) << "Event"
493  << setw(15) << "TTree Entry"
494  << "\n";
495  for (auto const& e : fileIndex) {
496  if (e.getEntryType() == FileIndex::kEvent) {
497  os << setw(15) << e.eventID.run() << setw(15) << e.eventID.subRun()
498  << setw(15) << e.eventID.event() << setw(15) << e.entry << "\n";
499  } else if (e.getEntryType() == FileIndex::kSubRun) {
500  os << setw(15) << e.eventID.run() << setw(15) << e.eventID.subRun()
501  << setw(15) << " " << setw(15) << e.entry << " (SubRun)"
502  << "\n";
503  } else if (e.getEntryType() == FileIndex::kRun) {
504  os << setw(15) << e.eventID.run() << setw(15) << " " << setw(15) << " "
505  << setw(15) << e.entry << " (Run)"
506  << "\n";
507  }
508  }
509  return os;
510  }
e
const double e
Definition: gUpMuFluxGen.cxx:165
setw
Q_EXPORT QTSManip setw(int w)
Definition: qtextstream.h:331
template<typename PROD >
std::ostream& art::operator<< ( std::ostream &  os,
Handle< PROD > const &  h 
)

Definition at line 941 of file DataViewImpl.h.

942  {
943  os << h.product() << " " << h.provenance() << " " << h.id();
944  return os;
945  }
reco_momentum_tuples.h
h
Definition: reco_momentum_tuples.py:66
bool art::operator<= ( ScheduleID const  left,
ScheduleID const  right 
)
noexcept

Definition at line 47 of file ScheduleID.cc.

48  {
49  return ((left < right) || (left == right));
50  }
bool art::operator<= ( FileIndex::Element const &  lh,
FileIndex::Element const &  rh 
)

Definition at line 433 of file FileIndex.cc.

434  {
435  return !(rh < lh);
436  }
bool art::operator== ( BranchKey const &  a,
BranchKey const &  b 
)
inline

Definition at line 77 of file BranchKey.h.

78 {
79  return !(a < b || b < a);
80 }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator== ( FileFormatVersion const &  a,
FileFormatVersion const &  b 
)
inline

Definition at line 28 of file FileFormatVersion.h.

29  {
30  return a.value_ == b.value_;
31  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator== ( Parentage const &  a,
Parentage const &  b 
)

Definition at line 49 of file Parentage.cc.

50  {
51  return a.parents() == b.parents();
52  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator== ( PathSpec const &  a,
PathSpec const &  b 
)
inline

Definition at line 59 of file PathSpec.h.

60  {
61  return to_tuple(a) == to_tuple(b);
62  }
art::to_tuple
auto to_tuple(PathSpec const &spec) noexcept
Definition: PathSpec.h:53
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
constexpr bool art::operator== ( RefCore const &  lhs,
RefCore const &  rhs 
)
noexcept

Definition at line 71 of file RefCore.h.

72  {
73  return lhs.id() == rhs.id();
74  }
bool art::operator== ( ProcessConfiguration const &  a,
ProcessConfiguration const &  b 
)

Definition at line 78 of file ProcessConfiguration.cc.

79  {
80  return std::tie(a.processName(), a.parameterSetID(), a.releaseVersion()) ==
81  std::tie(b.processName(), b.parameterSetID(), b.releaseVersion());
82  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator== ( ProductProvenance const &  a,
ProductProvenance const &  b 
)
noexcept

Definition at line 92 of file ProductProvenance.cc.

93  {
94  if (a.noParentage() != b.noParentage()) {
95  return false;
96  }
97  if (a.noParentage()) {
98  return (a.productID() == b.productID()) &&
99  (a.productStatus() == b.productStatus());
100  }
101  return (a.productID() == b.productID()) &&
102  (a.productStatus() == b.productStatus()) &&
103  (a.parentageID() == b.parentageID());
104  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
template<class X , class Y >
bool art::operator== ( debugging_allocator< X > const &  ,
debugging_allocator< Y > const &   
)
throw (
)

Definition at line 100 of file debugging_allocator.h.

102  {
103  return true;
104  }
bool art::operator== ( Provenance const &  a,
Provenance const &  b 
)
noexcept

Definition at line 141 of file Provenance.cc.

142  {
143  return a.equals(b);
144  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator== ( ProcessHistory const &  a,
ProcessHistory const &  b 
)

Definition at line 241 of file ProcessHistory.cc.

242  {
243  return a.data() == b.data();
244  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
template<typename T , typename U >
std::enable_if_t<std::is_same_v<T, U> || std::is_base_of_v<T, U> || std::is_base_of_v<U, T>, bool> art::operator== ( Ptr< T > const &  lhs,
Ptr< U > const &  rhs 
)

Definition at line 266 of file Ptr.h.

267  {
268  return lhs.refCore() == rhs.refCore() and lhs.key() == rhs.key();
269  }
bool art::operator== ( BranchDescription const &  a,
BranchDescription const &  b 
)

Definition at line 318 of file BranchDescription.cc.

319  {
320  return combinable(a, b) && (a.psetIDs() == b.psetIDs()) &&
321  (a.processConfigurationIDs() == b.processConfigurationIDs());
322  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
art::combinable
bool combinable(BranchDescription const &a, BranchDescription const &b)
Definition: BranchDescription.cc:306
b
static bool * b
Definition: config.cpp:1043
bool art::operator== ( RangeSet const &  l,
RangeSet const &  r 
)

Definition at line 399 of file RangeSet.cc.

400  {
401  if (!(l.is_valid() && r.is_valid())) {
402  return false;
403  }
404  return (l.run() == r.run()) && (l.ranges() == r.ranges());
405  }
l
static QStrList * l
Definition: config.cpp:1044
plot_model.r
r
Definition: plot_model.py:57
bool art::operator== ( FileIndex::Element const &  lh,
FileIndex::Element const &  rh 
)

Definition at line 439 of file FileIndex.cc.

440  {
441  return !(lh < rh || rh < lh);
442  }
bool art::operator== ( FileIndex const &  lh,
FileIndex const &  rh 
)

Definition at line 451 of file FileIndex.cc.

452  {
453  return lh.entries_ == rh.entries_;
454  }
bool art::operator> ( ScheduleID const  left,
ScheduleID const  right 
)
noexcept

Definition at line 53 of file ScheduleID.cc.

54  {
55  return !(left <= right);
56  }
bool art::operator> ( TypeID const &  a,
TypeID const &  b 
)

Definition at line 93 of file TypeID.cc.

94  {
95  return b < a;
96  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::operator> ( FileIndex::Element const &  lh,
FileIndex::Element const &  rh 
)

Definition at line 421 of file FileIndex.cc.

422  {
423  return rh < lh;
424  }
bool art::operator>= ( ScheduleID const  left,
ScheduleID const  right 
)
noexcept

Definition at line 59 of file ScheduleID.cc.

60  {
61  return !(left < right);
62  }
bool art::operator>= ( FileIndex::Element const &  lh,
FileIndex::Element const &  rh 
)

Definition at line 427 of file FileIndex.cc.

428  {
429  return !(lh < rh);
430  }
template<typename A , typename B >
std::enable_if_t<is_selector<A> && is_selector<B>, OrHelper<A, B> > art::operator|| ( A const &  a,
B const &  b 
)

Definition at line 225 of file Selector.h.

226  {
227  return OrHelper<A, B>{a, b};
228  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
template<class T , class U >
std::enable_if_t<detail::are_handles<T, U>::value, bool> art::overlapping_ranges ( T const &  a,
U const &  b 
)
template<class T , class U >
bool art::overlapping_ranges ( SummedValue< T > const &  a,
SummedValue< U > const &  b 
)

Definition at line 201 of file SummedValue.h.

202  {
203  return overlapping_ranges(a.rangeOfValidity(), b.rangeOfValidity());
204  }
art::overlapping_ranges
bool overlapping_ranges(SummedValue< T > const &a, SummedValue< U > const &b)
Definition: SummedValue.h:201
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::overlapping_ranges ( RangeSet const &  l,
RangeSet const &  r 
)

Definition at line 468 of file RangeSet.cc.

469  {
470  if (!(l.is_valid() && r.is_valid())) {
471  return false;
472  }
473  return !disjoint_ranges(l, r);
474  }
l
static QStrList * l
Definition: config.cpp:1044
art::disjoint_ranges
bool disjoint_ranges(RangeSet const &l, RangeSet const &r)
Definition: RangeSet.cc:414
plot_model.r
r
Definition: plot_model.py:57
std::string art::parent_path ( std::string const &  path)

Definition at line 15 of file parent_path.cc.

16 {
17  std::string result;
18  boost::filesystem::path parent_path(
19  boost::filesystem::path(in_path).parent_path());
20  if (parent_path.empty()) {
21  result = ".";
22  } else {
23  result = parent_path.native();
24  }
25  return result;
26 }
result
static QCString result
Definition: fortranscanner.cpp:56614
string
std::string string
Definition: nybbler.cc:12
art::parent_path
std::string parent_path(std::string const &path)
Definition: parent_path.cc:15
PathSpec art::path_spec ( std::string const &  path_spec)

Definition at line 22 of file PathSpec.cc.

23  {
24  auto const colon_position = path_spec.find(":");
25  if (colon_position == std::string::npos) {
26  return PathSpec{path_spec, PathID::invalid()};
27  }
28  auto name = path_spec.substr(colon_position + 1);
29  auto const id = std::stoull(path_spec.substr(0, colon_position));
30  return PathSpec{move(name), PathID{id}};
31  }
name
static QCString name
Definition: declinfo.cpp:673
wirecell.gen.depos.move
def move(depos, offset)
Definition: depos.py:107
art::path_spec
PathSpec path_spec(std::string const &path_spec)
Definition: PathSpec.cc:22
std::vector< PathSpec > art::path_specs ( std::vector< std::string > const &  path_spec_strs)

Definition at line 34 of file PathSpec.cc.

35  {
36  std::vector<PathSpec> result;
37  cet::for_all_with_index(path_spec_strs,
38  [&result](size_t const i, auto const& str) {
39  auto spec = path_spec(str);
40  if (spec.path_id == PathID::invalid()) {
41  spec.path_id = PathID{i};
42  }
43  result.push_back(std::move(spec));
44  });
45  return result;
46  }
result
static QCString result
Definition: fortranscanner.cpp:56614
cet::for_all_with_index
void for_all_with_index(FwdCont &, Func)
Definition: container_algorithms.h:109
wirecell.gen.depos.move
def move(depos, offset)
Definition: depos.py:107
art::path_spec
PathSpec path_spec(std::string const &path_spec)
Definition: PathSpec.cc:22
str
static QCString str
Definition: fortrancode.cpp:27098
template<typename T1 , typename T2 >
std::enable_if_t<std::is_same<T1, T2>::value || std::is_base_of<T1, T2>::value || std::is_base_of<T2, T1>::value, bool> art::pointersEqual ( T1 *  t1,
T2 *  t2 
)
inline

Definition at line 15 of file pointersEqual.h.

16  {
17  return t1 == t2;
18  }
template<typename T1 , typename T2 >
std::enable_if_t<!std::is_same<T1, T2>::value && !std::is_base_of<T1, T2>::value && !std::is_base_of<T2, T1>::value, bool> art::pointersEqual ( T1 *  ,
T2 *   
)

Definition at line 26 of file pointersEqual.h.

27  {
28  throw art::Exception(art::errors::LogicError)
29  << "Tried to compare two incompatible pointers.\n";
30  }
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
void art::printArtException ( cet::exception const &  e,
char const *  prog 
)

Definition at line 13 of file ExceptionMessages.cc.

13  {
14  std::string programName(prog ? prog : "program");
15  std::string shortDesc("ArtException");
16  std::ostringstream longDesc;
17  longDesc << "cet::exception caught in " << programName << "\n"
18  << cet::trim_right_copy(e.explain_self(), " \n");
19  LogSystem(shortDesc) << longDesc.str();
20  }
21  catch (...) {
22  }
string
std::string string
Definition: nybbler.cc:12
cet::trim_right_copy
std::string trim_right_copy(std::string source, std::string const &t=" ")
Definition: trim.h:54
e
const double e
Definition: gUpMuFluxGen.cxx:165
mf::LogSystem
MaybeLogger_< ELseverityLevel::ELsev_severe, false > LogSystem
Definition: MessageLogger.h:212
void art::printBadAllocException ( char const *  prog)

Definition at line 25 of file ExceptionMessages.cc.

25  {
26  std::string programName(prog ? prog : "program");
27  std::string shortDesc("std::bad_allocException");
28  std::ostringstream longDesc;
29  longDesc
30  << "std::bad_alloc exception caught in " << programName << "\n"
31  << "The job has probably exhausted the virtual memory available to "
32  "the process.";
33  LogSystem(shortDesc) << longDesc.str();
34  }
35  catch (...) {
36  }
string
std::string string
Definition: nybbler.cc:12
mf::LogSystem
MaybeLogger_< ELseverityLevel::ELsev_severe, false > LogSystem
Definition: MessageLogger.h:212
void art::printStdException ( std::exception const &  e,
char const *  prog 
)

Definition at line 39 of file ExceptionMessages.cc.

39  {
40  std::string programName(prog ? prog : "program");
41  std::string shortDesc("StdLibException");
42  std::ostringstream longDesc;
43  longDesc << "Standard library exception caught in " << programName << "\n"
44  << cet::trim_right_copy(e.what(), " \n");
45  LogSystem(shortDesc) << longDesc.str();
46  }
47  catch (...) {
48  }
string
std::string string
Definition: nybbler.cc:12
cet::trim_right_copy
std::string trim_right_copy(std::string source, std::string const &t=" ")
Definition: trim.h:54
e
const double e
Definition: gUpMuFluxGen.cxx:165
mf::LogSystem
MaybeLogger_< ELseverityLevel::ELsev_severe, false > LogSystem
Definition: MessageLogger.h:212
void art::printUnknownException ( char const *  prog)

Definition at line 51 of file ExceptionMessages.cc.

51  {
52  std::string programName(prog ? prog : "program");
53  std::string shortDesc("UnknownException");
54  std::ostringstream longDesc;
55  longDesc << "Unknown exception caught in " << programName;
56  LogSystem(shortDesc) << longDesc.str();
57  }
58  catch (...) {
59  }
string
std::string string
Definition: nybbler.cc:12
mf::LogSystem
MaybeLogger_< ELseverityLevel::ELsev_severe, false > LogSystem
Definition: MessageLogger.h:212
std::string const & art::productProvenanceBranchName ( BranchType const  bt)

Definition at line 91 of file BranchType.cc.

92  {
93  return select(bt,
94  {&eventProductProvenance,
95  &subRunProductProvenance,
96  &runProductProvenance,
97  &resultsProductProvenance});
98  }
tracks.bt
bt
Definition: tracks.py:83
cet::sqlite::select
auto select(T const &...t)
Definition: select.h:146
template<typename T , typename P >
std::enable_if_t<!detail::range_sets_supported(P::branch_type)> art::put_product_in_principal ( std::unique_ptr< T > &&  product,
P &  principal,
std::string const &  module_label,
std::string const &  instance_name = {} 
)

Definition at line 44 of file put_product_in_principal.h.

47  {})
48  {
49  TypeID const typeID{typeid(T)};
50  if (product.get() == nullptr) {
51  throw Exception(errors::NullPointerError)
52  << "put_product_in_principal: A null unique_ptr was passed to 'put'.\n"
53  << "The pointer is of type " << typeID << ".\n"
54  << "The specified product instance name was '" << instance_name
55  << "'.\n";
56  }
57 
58  auto const& process_name = principal.processConfiguration().processName();
59  auto const& product_name = canonicalProductName(
60  typeID.friendlyClassName(), module_label, instance_name, process_name);
61  ProductID const pid{product_name};
62  auto desc = principal.getProductDescription(pid);
63  if (!desc) {
64  throw art::Exception(art::errors::ProductPutFailure,
65  "put_product_in_principal: error while trying to "
66  "retrieve product description:\n")
67  << "No product is registered for\n"
68  << " process name: '" << process_name << "'\n"
69  << " module label: '" << module_label << "'\n"
70  << " product friendly class name: '" << typeID.friendlyClassName()
71  << "'\n"
72  << " product instance name: '" << instance_name << "'\n"
73  << " branch type: '" << principal.branchType()
74  << "'\n";
75  }
76 
77  std::unique_ptr<EDProduct> wp = std::make_unique<Wrapper<T>>(move(product));
78  principal.put(
79  *desc,
80  std::make_unique<ProductProvenance const>(pid, productstatus::present()),
81  move(wp),
82  std::make_unique<RangeSet>());
83  }
test_wireplots.desc
desc
Definition: test_wireplots.py:10
wirecell.gen.depos.move
def move(depos, offset)
Definition: depos.py:107
art::canonicalProductName
std::string canonicalProductName(std::string const &friendlyClassName, std::string const &moduleLabel, std::string const &productInstanceName, std::string const &processName)
Definition: canonicalProductName.cc:9
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
art::productstatus::present
constexpr ProductStatus present() noexcept
Definition: ProductStatus.h:10
template<typename T , typename P >
std::enable_if_t<detail::range_sets_supported(P::branch_type)> art::put_product_in_principal ( std::unique_ptr< T > &&  product,
P &  principal,
std::string const &  module_label,
std::string const &  instance_name = {},
RangeSet &&  rs = RangeSet::invalid() 
)

Definition at line 87 of file put_product_in_principal.h.

90  {},
91  RangeSet&& rs = RangeSet::invalid())
92  {
93  TypeID const typeID{typeid(T)};
94  if (product.get() == nullptr) {
95  throw Exception(errors::NullPointerError)
96  << "put_product_in_principal: A null unique_ptr was passed to 'put'.\n"
97  << "The pointer is of type " << typeID << ".\n"
98  << "The specified product instance name was '" << instance_name
99  << "'.\n";
100  }
101 
102  auto const& process_name = principal.processConfiguration().processName();
103  auto const& product_name = canonicalProductName(
104  typeID.friendlyClassName(), module_label, instance_name, process_name);
105  ProductID const pid{product_name};
106  auto desc = principal.getProductDescription(pid);
107  if (!desc) {
108  throw art::Exception(art::errors::ProductPutFailure,
109  "put_product_in_principal: error while trying to "
110  "retrieve product description:\n")
111  << "No product is registered for\n"
112  << " process name: '" << process_name << "'\n"
113  << " module label: '" << module_label << "'\n"
114  << " product friendly class name: '" << typeID.friendlyClassName()
115  << "'\n"
116  << " product instance name: '" << instance_name << "'\n"
117  << " branch type: '" << principal.branchType()
118  << "'\n";
119  }
120 
121  // If the provided RangeSet is invalid, assign it a RangeSet
122  // corresponding to the full (Sub)Run.
123  if (!rs.is_valid()) {
124  rs = rangeSetFor(principal);
125  }
126  std::unique_ptr<EDProduct> wp = std::make_unique<Wrapper<T>>(move(product));
127  principal.put(
128  *desc,
129  std::make_unique<ProductProvenance const>(pid, productstatus::present()),
130  move(wp),
131  std::make_unique<RangeSet>(rs));
132  }
test_wireplots.desc
desc
Definition: test_wireplots.py:10
art::rangeSetFor
RangeSet rangeSetFor(SubRunPrincipal const &srp)
Definition: put_product_in_principal.h:37
wirecell.gen.depos.move
def move(depos, offset)
Definition: depos.py:107
art::canonicalProductName
std::string canonicalProductName(std::string const &friendlyClassName, std::string const &moduleLabel, std::string const &productInstanceName, std::string const &processName)
Definition: canonicalProductName.cc:9
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
make_pion_angle.rs
list rs
Definition: make_pion_angle.py:22
art::productstatus::present
constexpr ProductStatus present() noexcept
Definition: ProductStatus.h:10
template<class T >
std::enable_if_t<detail::is_handle<T>::value, RangeSet const&> art::range_of_validity ( T const &  h)
RangeSet art::rangeSetFor ( RunPrincipal const &  rp)
inline

Definition at line 31 of file put_product_in_principal.h.

32  {
33  return RangeSet::forRun(rp.runID());
34  }
RangeSet art::rangeSetFor ( SubRunPrincipal const &  srp)
inline

Definition at line 37 of file put_product_in_principal.h.

38  {
39  return RangeSet::forSubRun(srp.subRunID());
40  }
std::vector< std::vector< std::string >::const_iterator > art::regexMatch ( std::vector< std::string > const &  strings,
std::string const &  pattern 
)

Definition at line 25 of file RegexMatch.cc.

27  {
28  auto const reg_str = glob2reg(pattern);
29  // We allow for a trigger-bit to lead the trigger path name.
30  std::regex const regexp{"(\\d+:)?" + glob2reg(pattern)};
31  std::vector<std::vector<std::string>::const_iterator> result;
32  for (auto it = strings.begin(), e = strings.end(); it != e; ++it) {
33  if (std::regex_match(*it, regexp)) {
34  result.push_back(it);
35  }
36  }
37  return result;
38  }
result
static QCString result
Definition: fortranscanner.cpp:56614
const_iterator
intermediate_table::const_iterator const_iterator
Definition: intermediate_table.cc:28
e
const double e
Definition: gUpMuFluxGen.cxx:165
art::glob2reg
std::string glob2reg(std::string pattern)
Definition: RegexMatch.cc:17
pattern
std::string pattern
Definition: regex_t.cc:35
std::vector< GroupQueryResult > art::resolve_products ( std::vector< cet::exempt_ptr< art::Group >> const &  groups,
art::TypeID const &  wrapped_type 
)

Definition at line 428 of file Group.cc.

430  {
431  std::vector<GroupQueryResult> results;
432  for (auto group : groups) {
433  if (group->tryToResolveProduct(wrapped_type)) {
434  results.emplace_back(group.get());
435  }
436  }
437  return results;
438  }
std::optional< GroupQueryResult > art::resolve_unique_product ( std::vector< cet::exempt_ptr< art::Group >> const &  product_groups,
art::WrappedTypeID const &  wrapped 
)

Definition at line 387 of file Group.cc.

390  {
391  auto by_process_name = [](auto const ga, auto const gb) {
392  return ga->productDescription().processName() ==
393  gb->productDescription().processName();
394  };
395 
396  // We group product groups according to their process names. The
397  // product groups have already been assembled in reverse-process
398  // history. The first process with a match wins. Note that it is
399  // an error for there to be multiple matches per process.
400  for (auto const groups_per_process :
401  ranges::views::group_by(product_groups, by_process_name)) {
402  // Keep track of all matched groups so that a helpful error
403  // message can be reported.
404  std::vector<cet::exempt_ptr<art::Group>> matched_groups;
405  for (auto const group : groups_per_process) {
406  if (group->tryToResolveProduct(wrapped.wrapped_product_type)) {
407  matched_groups.emplace_back(group.get());
408  }
409  }
410 
411  if (auto const num_matches = matched_groups.size(); num_matches == 1) {
412  return std::make_optional(GroupQueryResult{matched_groups[0]});
413  } else if (num_matches > 1) {
414  Exception e{errors::ProductNotFound};
415  e << "Found " << num_matches
416  << " products rather than one that match all criteria\n"
417  << " C++ type: " << wrapped.product_type << "\n";
418  for (auto group : matched_groups) {
419  e << " " << group->productDescription().inputTag() << '\n';
420  }
421  throw e;
422  }
423  }
424  return std::nullopt;
425  }
e
const double e
Definition: gUpMuFluxGen.cxx:165
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
wirecell.sigproc.response.group_by
def group_by(rflist, field)
Definition: __init__.py:162
template<typename L , typename R , typename D , Direction Dir>
constexpr auto const& art::right ( const_AssnsIter< L, R, D, Dir > const &  a,
const_AssnsIter< L, R, D, Dir > const &  b 
)

Definition at line 102 of file AssnsIter.h.

104  {
105  return (Dir == Direction::Forward) ? b : a;
106  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
int art::run_art ( int  argc,
char **  argv,
bpo::options_description &  all_desc,
OptionsHandlers &&  handlers 
)

Definition at line 142 of file run_art.cc.

146  {
147  // This must be added separately: how to deal with any non-option arguments.
148  bpo::positional_options_description pd;
149  // A single non-option argument will be taken to be the source data file.
150  pd.add("source", -1);
151  // Parse the command line.
152  bpo::variables_map vm;
153  try {
154  bpo::store(bpo::command_line_parser(argc, argv)
155  .options(all_desc)
156  .style(bpo::command_line_style::default_style &
157  ~bpo::command_line_style::allow_guessing)
158  .positional(pd)
159  .run(),
160  vm);
161  bpo::notify(vm);
162  }
163  catch (bpo::error const& e) {
164  cerr << "Exception from command line processing in " << argv[0] << ": "
165  << e.what() << "\n";
166  return 88;
167  }
168  // Preliminary argument checking.
169  for (auto& handler : handlers) {
170  auto const result = handler->checkOptions(vm);
171  if (result != 0) {
172  return result;
173  }
174  }
175  // Processing of arguments and post-processing of config.
176  fhicl::intermediate_table raw_config;
177  for (auto& handler : handlers) {
178  auto const result = handler->processOptions(vm, raw_config);
179  if (result != 0) {
180  return result;
181  }
182  }
183 
184  // If configuration pruning has been enabled, remove unused module
185  // configurations.
186  using detail::exists_outside_prolog;
187  auto const scheduler_key = fhicl_key("services", "scheduler");
188  auto enabled_modules = detail::EnabledModules::none();
189  assert(exists_outside_prolog(raw_config, scheduler_key));
190  try {
191  auto const pruneConfigKey = fhicl_key(scheduler_key, "pruneConfig");
192  auto const reportUnusedKey = fhicl_key(scheduler_key, "reportUnused");
193  assert(exists_outside_prolog(raw_config, pruneConfigKey));
194  assert(exists_outside_prolog(raw_config, reportUnusedKey));
195  bool const prune_config = raw_config.get<bool>(pruneConfigKey);
196  bool const report_unused = raw_config.get<bool>(reportUnusedKey);
197  enabled_modules = detail::prune_config_if_enabled(
198  prune_config, report_unused, raw_config);
199  }
200  catch (Exception const& e) {
201  printArtException(e, "art");
202  return e.returnCode();
203  }
204  catch (cet::exception const& e) {
205  printArtException(e, "art");
206  return 65;
207  }
208  catch (std::bad_alloc const& bda) {
209  printBadAllocException("art");
210  return 68;
211  }
212  catch (std::exception const& e) {
213  printStdException(e, "art");
214  return 66;
215  }
216  catch (...) {
217  printUnknownException("art");
218  return 67;
219  }
220 
221  //
222  // Make the parameter set from the intermediate table.
223  //
224  fhicl::ParameterSet main_pset;
225  try {
226  main_pset = fhicl::ParameterSet::make(raw_config);
227  }
228  catch (cet::exception const& e) {
229  constexpr cet::HorizontalRule rule{36};
230  cerr << "ERROR: Failed to create a parameter set from parsed "
231  "configuration with exception "
232  << e.what() << ".\n";
233  cerr << " Intermediate configuration state follows:\n"
234  << rule('-') << '\n'
235  << rule('-') << '\n';
236  for (auto const& [key, value] : raw_config) {
237  cerr << key << ": " << value.to_string() << '\n';
238  }
239  cerr << rule('-') << '\n' << rule('-') << '\n';
240  return 91;
241  }
242  // Main parameter set must be placed in registry manually.
243  try {
244  fhicl::ParameterSetRegistry::put(main_pset);
245  }
246  catch (...) {
247  cerr << "Uncaught exception while inserting main parameter set into "
248  "registry.\n";
249  throw;
250  }
251  return run_art_common_(main_pset, enabled_modules);
252  }
fhicl::ParameterSetRegistry::put
static ParameterSetID const & put(ParameterSet const &ps)
Definition: ParameterSetRegistry.h:125
result
static QCString result
Definition: fortranscanner.cpp:56614
art::detail::exists_outside_prolog
bool exists_outside_prolog(fhicl::intermediate_table const &config, std::string const &key)
Definition: exists_outside_prolog.h:9
art::run_art_common_
int run_art_common_(fhicl::ParameterSet const &main_pset, detail::EnabledModules const &enabled_modules)
Definition: run_art.cc:298
fhicl::ParameterSet::make
static ParameterSet make(intermediate_table const &tbl)
Definition: ParameterSet.cc:68
error
error
Definition: include.cc:26
art::printStdException
void printStdException(std::exception const &e, char const *prog)
Definition: ExceptionMessages.cc:39
freeze_graph.argv
argv
Definition: freeze_graph.py:218
art::printUnknownException
void printUnknownException(char const *prog)
Definition: ExceptionMessages.cc:51
art::detail::prune_config_if_enabled
EnabledModules prune_config_if_enabled(bool prune_config, bool report_enabled, fhicl::intermediate_table &config)
Definition: prune_configuration.cc:575
e
const double e
Definition: gUpMuFluxGen.cxx:165
wirecell.dfp.graph.key
def key(type, name=None)
Definition: graph.py:13
art::detail::fhicl_key
std::enable_if_t< std::is_convertible_v< T, std::string >, std::string > fhicl_key(T const &name)
Definition: fhicl_key.h:12
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
fhicl::intermediate_table::get
T get(std::string const &name)
Definition: intermediate_table.h:274
art::printArtException
void printArtException(cet::exception const &e, char const *prog)
Definition: ExceptionMessages.cc:13
handler
static msg_handler handler
Definition: qglobal.cpp:234
art::printBadAllocException
void printBadAllocException(char const *prog)
Definition: ExceptionMessages.cc:25
submit_mcc.value
value
Definition: submit_mcc.py:159
fhicl::exception
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
fhicl::intermediate_table
Definition: intermediate_table.h:65
int art::run_art_common_ ( fhicl::ParameterSet const &  main_pset,
detail::EnabledModules const &  enabled_modules 
)

Definition at line 298 of file run_art.cc.

300  {
301 #ifdef __linux__
302  // Tell the system memory allocator to only use one arena: they
303  // are 64 MiB in size, and the default is 8 * num_of_cores. Using
304  // the default means that when using 40 threads we get 40 arenas,
305  // which means we have 40 * 64 MiB = 2560 MiB of virtual address
306  // space devoted to per-thread heaps!!!
307  mallopt(M_ARENA_MAX, 1);
308 #endif // __linux__
309 
310  auto const services_pset =
311  main_pset.get<fhicl::ParameterSet>("services", {});
312  auto const scheduler_pset =
313  services_pset.get<fhicl::ParameterSet>("scheduler", {});
314 
315  // Handle early configuration-debugging
316  auto const debug_mode = debug_processing_mode(scheduler_pset);
317  if (debug_mode != debug_processing::none) {
318  auto const debug_pset = scheduler_pset.get<fhicl::ParameterSet>("debug");
319  auto const filename = debug_pset.get<std::string>("fileName");
320  auto const mode = debug_pset.get<std::string>("printMode");
321 
322  switch (debug_mode) {
323  case debug_processing::validate_config: {
324  [[fallthrough]];
325  }
326  case debug_processing::config_out: {
327  print_config(main_pset, filename, mode);
328  break;
329  }
330  case debug_processing::debug_config: {
331  print_config(main_pset, filename, mode);
332  return detail::info_success();
333  }
334  case debug_processing::config_summary: {
335  detail::print_config_summary(main_pset, mode, enabled_modules);
336  return detail::info_success();
337  }
338  case debug_processing::none:
339  break;
340  }
341  }
342  //
343  // Start the messagefacility
344  //
345  mf::SetIteration("JobSetup");
346  try {
347  mf::StartMessageFacility(
348  services_pset.get<fhicl::ParameterSet>("message", {}));
349  }
350  catch (cet::exception const& e) {
351  cerr << e.what() << '\n';
352  return 69;
353  }
354  catch (exception const& e) {
355  cerr << e.what() << '\n';
356  return 70;
357  }
358  catch (...) {
359  cerr << "Caught unknown exception while initializing the message "
360  "facility.\n";
361  return 71;
362  }
363  mf::LogInfo("MF_INIT_OK") << "Messagelogger initialization complete.";
364  //
365  // Start the EventProcessor
366  //
367  int rc{0};
368  try {
369  EventProcessor ep{main_pset, enabled_modules};
370  // Behavior of validate_config is to validate FHiCL syntax *and*
371  // user-specified configurations of paths, modules, services,
372  // etc. It is thus possible that an exception thrown during
373  // construction of the EventProcessor object can have nothing to
374  // do with a configuration error.
375  if (debug_mode == debug_processing::validate_config) {
376  return detail::info_success();
377  }
378  if (scheduler_pset.has_key("dataDependencyGraph")) {
379  return detail::info_success();
380  }
381  auto ep_rc = ep.runToCompletion();
382  if (ep_rc == EventProcessor::epSignal) {
383  cerr << "Art has handled signal " << art::shutdown_flag << ".\n";
384  if (scheduler_pset.get<bool>("errorOnSIGINT")) {
385  rc = 128 + art::shutdown_flag;
386  }
387  }
388  }
389  catch (Exception const& e) {
390  rc = e.returnCode();
391  printArtException(e, "art");
392  }
393  catch (cet::exception const& e) {
394  rc = 65;
395  printArtException(e, "art");
396  }
397  catch (detail::collected_exception const& e) {
398  rc = 1;
399  // LogSystem already adds a newline, so trim the one that's
400  // already in the exception message.
401  std::string const msg{e.what()};
402  mf::LogSystem("ArtException") << msg.substr(0, msg.find_last_of("\n"));
403  }
404  catch (bad_alloc const& bda) {
405  rc = 68;
406  printBadAllocException("art");
407  }
408  catch (exception const& e) {
409  rc = 66;
410  printStdException(e, "art");
411  }
412  catch (...) {
413  rc = 67;
414  printUnknownException("art");
415  }
416  return rc;
417  }
mf::SetIteration
void SetIteration(string const &val)
Definition: MessageLogger.cc:574
msg
void msg(const char *fmt,...)
Definition: message.cpp:107
art::detail::print_config_summary
void print_config_summary(fhicl::ParameterSet const &pset, std::string const &verbosity, EnabledModules const &enabled_modules)
Definition: print_config_summary.cc:184
string
std::string string
Definition: nybbler.cc:12
mf::LogInfo
MaybeLogger_< ELseverityLevel::ELsev_info, false > LogInfo
Definition: MessageLogger.h:209
art::printStdException
void printStdException(std::exception const &e, char const *prog)
Definition: ExceptionMessages.cc:39
train.filename
string filename
Definition: train.py:213
art::shutdown_flag
std::atomic< int > shutdown_flag
Definition: UnixSignalHandlers.cc:19
art::printUnknownException
void printUnknownException(char const *prog)
Definition: ExceptionMessages.cc:51
mf::StartMessageFacility
void StartMessageFacility(fhicl::ParameterSet const &pset, string const &applicationName)
Definition: MessageLogger.cc:460
e
const double e
Definition: gUpMuFluxGen.cxx:165
fhicl::ParameterSet::get
T get(std::string const &key) const
Definition: ParameterSet.h:271
mf::LogSystem
MaybeLogger_< ELseverityLevel::ELsev_severe, false > LogSystem
Definition: MessageLogger.h:212
fhicl::ParameterSet::has_key
bool has_key(std::string const &key) const
Definition: ParameterSet.cc:247
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
art::printArtException
void printArtException(cet::exception const &e, char const *prog)
Definition: ExceptionMessages.cc:13
art::detail::info_success
constexpr int info_success()
Definition: info_success.h:8
art::printBadAllocException
void printBadAllocException(char const *prog)
Definition: ExceptionMessages.cc:25
fhicl::exception
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
int art::run_art_string_config ( string const &  config_string)

Definition at line 255 of file run_art.cc.

256  {
257  //
258  // Make the parameter set from the configuration string:
259  //
260  auto enabled_modules = detail::EnabledModules::none();
261  fhicl::ParameterSet main_pset;
262  try {
263  // create an intermediate table from the input string
264  auto raw_config = fhicl::parse_document(config_string);
265  enabled_modules =
266  detail::prune_config_if_enabled(false, true, raw_config);
267  // run post-processing
268  bpo::variables_map vm;
269  BasicPostProcessor bpp;
270  bpp.processOptions(vm, raw_config);
271  // create the parameter set
272  main_pset = fhicl::ParameterSet::make(raw_config);
273  }
274  catch (cet::exception& e) {
275  constexpr cet::HorizontalRule rule{36};
276  cerr << "ERROR: Failed to create a parameter set from an input "
277  "configuration string with exception "
278  << e.what() << ".\n";
279  cerr << " Input configuration string follows:\n"
280  << rule('-') << rule('-') << "\n";
281  cerr << config_string << "\n";
282  cerr << rule('-') << rule('-') << '\n';
283  return 91;
284  }
285  // Main parameter set must be placed in registry manually.
286  try {
287  fhicl::ParameterSetRegistry::put(main_pset);
288  }
289  catch (...) {
290  cerr << "Uncaught exception while inserting main parameter set into "
291  "registry.\n";
292  throw;
293  }
294  return run_art_common_(main_pset, enabled_modules);
295  }
fhicl::ParameterSetRegistry::put
static ParameterSetID const & put(ParameterSet const &ps)
Definition: ParameterSetRegistry.h:125
art::run_art_common_
int run_art_common_(fhicl::ParameterSet const &main_pset, detail::EnabledModules const &enabled_modules)
Definition: run_art.cc:298
fhicl::ParameterSet::make
static ParameterSet make(intermediate_table const &tbl)
Definition: ParameterSet.cc:68
art::detail::prune_config_if_enabled
EnabledModules prune_config_if_enabled(bool prune_config, bool report_enabled, fhicl::intermediate_table &config)
Definition: prune_configuration.cc:575
e
const double e
Definition: gUpMuFluxGen.cxx:165
fhicl::parse_document
intermediate_table parse_document(std::string const &filename, cet::filepath_maker &maker)
Definition: parse.cc:720
fhicl::exception
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
constexpr auto art::runFragment ( )

Definition at line 33 of file ProductSemantics.h.

34  {
35  return FragmentSemantic<Level::Run>{};
36  }
auto art::runFragment ( RangeSet const &  rs)
inline

Definition at line 44 of file ProductSemantics.h.

45  {
46  return RangedFragmentSemantic<Level::Run>{rs};
47  }
make_pion_angle.rs
list rs
Definition: make_pion_angle.py:22
template<class T , class U >
std::enable_if_t<detail::are_handles<T, U>::value, bool> art::same_ranges ( T const &  a,
U const &  b 
)
template<class T , class U >
bool art::same_ranges ( SummedValue< T > const &  a,
SummedValue< U > const &  b 
)

Definition at line 187 of file SummedValue.h.

188  {
189  return same_ranges(a.rangeOfValidity(), b.rangeOfValidity());
190  }
art::same_ranges
bool same_ranges(SummedValue< T > const &a, SummedValue< U > const &b)
Definition: SummedValue.h:187
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
bool art::same_ranges ( RangeSet const &  l,
RangeSet const &  r 
)

Definition at line 408 of file RangeSet.cc.

409  {
410  return l == r;
411  }
l
static QStrList * l
Definition: config.cpp:1044
plot_model.r
r
Definition: plot_model.py:57
auto art::sampled_from ( std::string  process_name)
inline

Definition at line 110 of file Sampled.h.

111  {
112  return process_name.insert(0, "SampledFrom");
113  }
template<class COLLECTION >
void art::setPtr ( COLLECTION const &  coll,
std::type_info const &  iToType,
unsigned long  iIndex,
void const *&  oPtr 
)
template<typename T >
void art::setPtr ( cet::map_vector< T > const &  obj,
std::type_info const &  iToType,
unsigned long  iIndex,
void const *&  oPtr 
)

Definition at line 52 of file setPtr.h.

56 {
57  detail::value_type_helper vh;
58  std::string const wanted_type =
59  uniform_type_name(cet::demangle_symbol(iToType.name()));
60  static size_t pos = vh.look_past_pair<T>();
61  auto const it = obj.findOrThrow(cet::map_vector_key{iIndex});
62  assert(it != obj.end());
63  if (pos < wanted_type.size() and vh.starts_with_pair(wanted_type, pos)) {
64  // Want value_type, not mapped_type;
65  oPtr = detail::maybeCastObj(&*it, iToType);
66  } else {
67  oPtr = detail::maybeCastObj(&it->second, iToType);
68  }
69 }
string
std::string string
Definition: nybbler.cc:12
cet::map_vector::end
iterator end() noexcept
Definition: map_vector.h:190
cet::map_vector_key
Definition: map_vector.h:34
art::uniform_type_name
std::string uniform_type_name(std::type_info const &tid)
Definition: uniform_type_name.h:36
cet::map_vector::findOrThrow
const_iterator findOrThrow(key_type key) const
Definition: map_vector.h:405
art::detail::maybeCastObj
void const * maybeCastObj(void const *address, std::type_info const &tiFrom, std::type_info const &tiTo)
void art::setupSignals ( bool  want_sigint_enabled)

Definition at line 117 of file UnixSignalHandlers.cc.

118  {
119  installCustomHandler(SIGUSR2, handle_sigusr2);
120  installCustomHandler(SIGTERM, handle_sigusr2);
121  installCustomHandler(SIGQUIT, handle_sigusr2);
122  if (want_sigint_enabled) {
123  installCustomHandler(SIGINT, handle_sigusr2);
124  }
125  }
handle_sigusr2
static void handle_sigusr2(int which, siginfo_t *, void *)
Definition: UnixSignalHandlers.cc:24
template<Direction Dir>
constexpr int art::signed_one ( )

Definition at line 17 of file AssnsIter.h.

18  {
19  return static_cast<std::underlying_type_t<Direction>>(Dir);
20  }
std::pair< std::string, std::string > art::split_process_and_path_names ( std::string  path_spec)

Definition at line 11 of file PathSpec.cc.

12  {
13  detail::remove_whitespace(path_spec);
14  auto const pos = path_spec.find(":");
15  if (pos == std::string::npos) {
16  return std::make_pair("", path_spec);
17  }
18  return std::make_pair(path_spec.substr(0, pos), path_spec.substr(pos + 1));
19  }
art::detail::remove_whitespace
void remove_whitespace(std::string &str)
Definition: remove_whitespace.cc:11
art::path_spec
PathSpec path_spec(std::string const &path_spec)
Definition: PathSpec.cc:22
constexpr auto art::subRunFragment ( )

Definition at line 38 of file ProductSemantics.h.

39  {
40  return FragmentSemantic<Level::SubRun>{};
41  }
auto art::subRunFragment ( RangeSet const &  rs)
inline

Definition at line 49 of file ProductSemantics.h.

50  {
51  return RangedFragmentSemantic<Level::SubRun>{rs};
52  }
make_pion_angle.rs
list rs
Definition: make_pion_angle.py:22
template<typename T >
void art::swap ( PtrVector< T > &  lhs,
PtrVector< T > &  rhs 
)
inline

Definition at line 595 of file PtrVector.h.

596 {
597  lhs.swap(rhs);
598 }
void art::swap ( TriggerResults &  lhs,
TriggerResults &  rhs 
)
template<class T >
void art::swap ( Handle< T > &  a,
Handle< T > &  b 
)
template<class T >
void art::swap ( ValidHandle< T > &  a,
ValidHandle< T > &  b 
)
void art::swap ( RefCore &  lhs,
RefCore &  rhs 
)

Definition at line 70 of file RefCore.cc.

71  {
72  lhs.swap(rhs);
73  }
void art::swap ( OutputHandle &  a,
OutputHandle &  b 
)

Definition at line 71 of file OutputHandle.cc.

72  {
73  a.swap(b);
74  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
void art::swap ( TypeID &  left,
TypeID &  right 
)

Definition at line 105 of file TypeID.cc.

106  {
107  left.swap(right);
108  }
void art::swap ( ProcessHistory &  a,
ProcessHistory &  b 
)

Definition at line 235 of file ProcessHistory.cc.

236  {
237  a.swap(b);
238  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
template<int I>
void art::swap ( Hash< I > &  a,
Hash< I > &  b 
)

Definition at line 238 of file Hash.h.

239  {
240  a.swap(b);
241  }
a
const double a
Definition: gUpMuFluxGen.cxx:164
b
static bool * b
Definition: config.cpp:1043
void art::throw_if_not_disjoint ( RunNumber_t const  rn,
EventRange const &  left,
EventRange const &  right 
)
noexcept

Definition at line 453 of file RangeSet.cc.

456  {
457  if (left.is_disjoint(right))
458  return;
459  throw art::Exception(art::errors::EventRangeOverlap)
460  << "Attempt to merge event ranges that both contain one or more of the "
461  "same events\n"
462  << " Run: " << rn << '\n'
463  << " " << left << " vs.\n"
464  << " " << right << '\n';
465  }
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
std::string art::to_iso_string_assuming_unix_epoch ( Timestamp const &  ts)

Definition at line 8 of file Timestamp.cc.

9  {
10  auto const t = static_cast<time_t>(ts.value());
11  auto const p = boost::posix_time::from_time_t(t);
12  return boost::posix_time::to_iso_string(p);
13  }
reco_momentum_tuples.t
t
Definition: reco_momentum_tuples.py:25
test.p
p
Definition: test.py:223
std::string art::to_string ( ModuleType const  mt)
inline

Definition at line 34 of file ModuleType.h.

35  {
36  switch (mt) {
37  case ModuleType::non_art:
38  return "non-art";
39  case ModuleType::producer:
40  return "producer";
41  case ModuleType::filter:
42  return "filter";
43  case ModuleType::analyzer:
44  return "analyzer";
45  case ModuleType::output_module:
46  return "output module";
47  default:
48  throw Exception(errors::LogicError)
49  << "Unable to find string for unrecognized ModuleType value "
50  << static_cast<int>(mt) << ".\n";
51  }
52  }
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
filter
static unsigned filter(unsigned char *out, const unsigned char *in, unsigned w, unsigned h, const LodePNG_InfoColor *info)
Definition: lodepng.cpp:3576
std::string art::to_string ( PathID const  id)

Definition at line 49 of file PathSpec.cc.

50  {
51  return std::to_string(id.id_);
52  }
art::to_string
std::string to_string(PathSpec const &spec)
Definition: PathSpec.cc:55
std::string art::to_string ( PathSpec const &  spec)

Definition at line 55 of file PathSpec.cc.

56  {
57  return to_string(spec.path_id) + ':' + spec.name;
58  }
art::to_string
std::string to_string(PathSpec const &spec)
Definition: PathSpec.cc:55
auto art::to_tuple ( PathSpec const &  spec)
inlinenoexcept

Definition at line 53 of file PathSpec.h.

54  {
55  return std::tie(spec.name, spec.path_id);
56  }
std::string art::translateFileDeliveryStatus ( FileDeliveryStatus  stat)

Definition at line 8 of file FileDeliveryStatus.cc.

9 {
10  switch (stat) {
11  default: {
12  std::ostringstream os;
13  os << "UNKNOWN" << std::setfill('0') << std::setw(3)
14  << static_cast<int>(stat);
15  return os.str();
16  }
17  case FileDeliveryStatus::PENDING:
18  return "PENDING";
19  case FileDeliveryStatus::SUCCESS:
20  return "SUCCESS";
21  case FileDeliveryStatus::TRY_AGAIN_LATER:
22  return "TRY_AGAIN_LATER";
23  case FileDeliveryStatus::NO_MORE_FILES:
24  return "NO_MORE_FILES";
25  case FileDeliveryStatus::BAD_REQUEST:
26  return "BAD_REQUEST";
27  case FileDeliveryStatus::FORBIDDEN:
28  return "FORBIDDEN";
29  case FileDeliveryStatus::NOT_FOUND:
30  return "NOT_FOUND";
31  case FileDeliveryStatus::CONFLICT:
32  return "CONFLICT";
33  case FileDeliveryStatus::SERVER_EXCEPTION:
34  return "SERVER_EXCEPTION";
35  case FileDeliveryStatus::BAD_GATEWAY:
36  return "BAD_GATEWAY";
37  case FileDeliveryStatus::UNAVAILABLE:
38  return "UNAVAILABLE";
39  case FileDeliveryStatus::SPECIFIC_ERRORS:
40  return "SPECIFIC_ERRORS";
41  }
42 }
python.larbatch_posix.stat
def stat(path)
Definition: larbatch_posix.py:482
setw
Q_EXPORT QTSManip setw(int w)
Definition: qtextstream.h:331
setfill
Q_EXPORT QTSManip setfill(int f)
Definition: qtextstream.h:337
SUCCESS
#define SUCCESS
Definition: DBScan3DAlg.h:39
std::string art::translateFileDisposition ( FileDisposition  fd)

Definition at line 8 of file FileDisposition.cc.

9 {
10  switch (fd) {
11  default: {
12  std::ostringstream os;
13  os << "UNKNOWN" << std::setfill('0') << std::setw(3)
14  << static_cast<int>(fd);
15  return os.str();
16  }
17  case FileDisposition::PENDING:
18  return "PENDING";
19  case FileDisposition::TRANSFERRED:
20  return "TRANSFERED";
21  case FileDisposition::CONSUMED:
22  return "CONSUMED";
23  case FileDisposition::SKIPPED:
24  return "SKIPPED";
25  case FileDisposition::INCOMPLETE:
26  return "INCOMPLETE";
27  }
28 }
setw
Q_EXPORT QTSManip setw(int w)
Definition: qtextstream.h:331
setfill
Q_EXPORT QTSManip setfill(int f)
Definition: qtextstream.h:337
std::string art::translateFileTransferStatus ( FileTransferStatus  stat)

Definition at line 8 of file FileTransferStatus.cc.

9 {
10  switch (stat) {
11  default: {
12  std::ostringstream os;
13  os << "UNKNOWN" << std::setfill('0') << std::setw(3)
14  << static_cast<int>(stat);
15  return os.str();
16  }
17  case FileTransferStatus::PENDING:
18  return "PENDING";
19  case FileTransferStatus::SUCCESS:
20  return "SUCCESS";
21  case FileTransferStatus::BAD_REQUEST:
22  return "BAD_REQUEST";
23  case FileTransferStatus::UNAUTHORIZED:
24  return "UNAUTHORIZED";
25  case FileTransferStatus::PAYMENT_REQUIRED:
26  return "PAYMENT_REQUIRED";
27  case FileTransferStatus::FORBIDDEN:
28  return "FORBIDDEN";
29  case FileTransferStatus::NOT_FOUND:
30  return "NOT_FOUND";
31  case FileTransferStatus::GONE:
32  return "GONE";
33  case FileTransferStatus::TOO_LARGE:
34  return "TOO_LARGE";
35  case FileTransferStatus::URI_TOO_LONG:
36  return "URI_TOO_LONG";
37  case FileTransferStatus::SERVER_ERROR:
38  return "SERVER_ERROR";
39  case FileTransferStatus::UNAVAILABLE:
40  return "UNAVAILABLE";
41  }
42 }
python.larbatch_posix.stat
def stat(path)
Definition: larbatch_posix.py:482
setw
Q_EXPORT QTSManip setw(int w)
Definition: qtextstream.h:331
setfill
Q_EXPORT QTSManip setfill(int f)
Definition: qtextstream.h:337
SUCCESS
#define SUCCESS
Definition: DBScan3DAlg.h:39
constexpr auto art::underlying_value ( Level const  l)
noexcept

Definition at line 26 of file Level.h.

27  {
28  return static_cast<std::underlying_type_t<Level>>(l);
29  }
l
static QStrList * l
Definition: config.cpp:1044
std::string art::uniform_type_name ( std::type_info const &  tid)
inline

Definition at line 36 of file uniform_type_name.h.

37 {
38  return uniform_type_name(cet::demangle_symbol(tid.name()));
39 }
art::uniform_type_name
std::string uniform_type_name(std::string name)
Definition: uniform_type_name.cc:158
std::string art::uniform_type_name ( std::string  name)
Parameters
[in]nameThe already-demangled name for a type.

Definition at line 158 of file uniform_type_name.cc.

159 {
160  using namespace std::string_literals;
161  // We must use the same conventions previously used by Reflex.
162  // The order is important.
163 
164  // Translate any inlined namespace
165  translateInlineNamespace(name);
166 
167  // We must change std::__cxx11:: -> std:: for all type names. This
168  // should not have implications for I/O because ROOT stores the data
169  // that STL objects represent rather than doing a "dumb serialization"
170  // of the class.
171  cet::replace_all(name, "std::__cxx11::"s, "std::"s);
172  // According to a report from Chris Jones, Apple Clang has a similar
173  // issue with std::__1.
174  cet::replace_all(name, "std::__1::"s, "std::"s);
175 
176  // No space after comma.
177  cet::replace_all(name, ", "s, ","s);
178  // No space before opening square bracket.
179  cet::replace_all(name, " ["s, "["s);
180  // Strip default allocator.
181  removeParameter(name, ",std::allocator<"s);
182  // Strip default comparator.
183  removeParameter(name, ",std::less<"s);
184  // Strip char traits.
185  removeParameter(name, ",std::char_traits<"s);
186  // std::basic_string<char> -> std::string
187  {
188  static std::regex const bs_regex("std::basic_string<char>\\s*"s);
189  reformat(name, bs_regex, "std::string"s);
190  }
191  // Put const qualifier before identifier.
192  constBeforeIdentifier(name);
193 
194  // No spaces between template brakets and arguments
195  // FIXME?: need a regex because just stripping the spaces
196  // can cause subsequent ">>" removal fail...
197  {
198  static std::regex const bk_regex("([_a-zA-Z0-9])( +)>");
199  static std::string const bk_format("$1>");
200  reformat(name, bk_regex, bk_format);
201  }
202 
203  // No consecutive '>'.
204  //
205  // FIXME: The first time we see a type with e.g. operator>> as a
206  // template argument, we could have a problem.
207  cet::replace_all(name, ">>"s, "> >"s);
208  // No u or l qualifiers for integers.
209  {
210  static std::regex const ul_regex("(.*[<,][0-9]+)[ul]l*([,>].*)"s);
211  reformat(name, ul_regex, "$1$2"s);
212  }
213  // For ROOT 6 and beyond.
214  cet::replace_all(name, "unsigned long long"s, "ULong64_t"s);
215  cet::replace_all(name, "long long"s, "Long64_t"s);
216  // Done.
217  return name;
218 }
name
static QCString name
Definition: declinfo.cpp:673
string
std::string string
Definition: nybbler.cc:12
string_literals
cet::replace_all
bool replace_all(std::string &in, std::string const &from, std::string const &to)
Replace all occurrences of from in string with to.
Definition: replace_all.cc:4
s
static QCString * s
Definition: config.cpp:1042
std::string art::unique_filename ( std::string  stem,
std::string  extension = ".root" 
)

Definition at line 18 of file unique_filename.cc.

19 {
20  boost::filesystem::path const p(stem + "-%%%%-%%%%-%%%%-%%%%" + extension);
21  boost::filesystem::path outpath;
22  boost::system::error_code ec;
23  int tmp_fd = -1, error = 0;
24  do {
25  outpath = boost::filesystem::unique_path(p, ec);
26  } while (!ec && (tmp_fd = creat(outpath.c_str(), S_IRUSR | S_IWUSR)) == -1 &&
27  (error = errno) == EEXIST);
28  if (tmp_fd != -1) {
29  close(tmp_fd);
30  } else {
31  art::Exception e(art::errors::FileOpenError);
32  e << "RootOutput cannot ascertain a unique temporary filename for output "
33  "based on stem\n\""
34  << stem << "\": ";
35  if (ec) {
36  e << ec;
37  } else {
38  e << strerror(error);
39  }
40  e << ".\n";
41  throw e;
42  }
43  return outpath.native();
44 }
error
error
Definition: include.cc:26
errno
int errno
Contains the last error code.
Definition: structcmd.h:53
close
int close(int)
Closes the file descriptor fd.
e
const double e
Definition: gUpMuFluxGen.cxx:165
test.p
p
Definition: test.py:223
art::Exception
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
std::string art::wrappedClassName ( std::string const &  className)

Definition at line 5 of file WrappedClassName.cc.

6  {
7  static std::string const wrapperBegin("art::Wrapper<");
8  static std::string const wrapperEnd1(">");
9  static std::string const wrapperEnd2(" >");
10  std::string const& wrapperEnd =
11  (className[className.size() - 1] == '>' ? wrapperEnd2 : wrapperEnd1);
12  std::string wrapped;
13  wrapped.reserve(wrapperBegin.size() + className.size() + wrapperEnd.size());
14  wrapped += wrapperBegin;
15  wrapped += className;
16  wrapped += wrapperEnd;
17  return wrapped;
18  }
string
std::string string
Definition: nybbler.cc:12
className
static QCString className
Definition: declinfo.cpp:669
QCString::size
uint size() const
Definition: qcstring.h:201

Variable Documentation

AutoInputSourceMutexSentryShutdown art::autoInputSourceMutexSentryShutdown

Definition at line 52 of file InputSourceMutex.cc.

DebugValue art::debugit

Definition at line 14 of file DebugMacros.cc.

DebugTasksValue art::debugTasks

Definition at line 75 of file TaskDebugMacros.cc.

template<typename T >
constexpr bool art::is_selector
Initial value:
=
std::is_base_of_v<SelectorBase, std::remove_reference_t<T>>

Definition at line 41 of file Selector.h.

template<typename T >
detail::SharedResource_t art::SharedResource {typeid(T).name(), true}

Definition at line 24 of file SharedResource.h.

atomic< int > art::shutdown_flag {0}

Definition at line 19 of file UnixSignalHandlers.cc.

Generated by   doxygen 1.8.11