The Application Manager class. More...

#include </builds/gaudi/Gaudi/GaudiCoreSvc/src/ApplicationMgr/ApplicationMgr.h>

Inheritance diagram for ApplicationMgr:

Collaboration diagram for ApplicationMgr:

Public Member Functions
	ApplicationMgr (IInterface *=nullptr)
void const *	i_cast (const InterfaceID &iid) const override
StatusCode	run () override
StatusCode	configure () override
StatusCode	terminate () override
StatusCode	initialize () override
StatusCode	start () override
StatusCode	stop () override
StatusCode	finalize () override
StatusCode	nextEvent (int maxevt) override
const std::string &	name () const override
EventContext	createEventContext () override
	implementation of IEventProcessor::createEventContext()
StatusCode	executeEvent (EventContext &&ctx) override
	implementation of IEventProcessor::executeEvent(void*)
StatusCode	executeRun (int evtmax) override
	implementation of IEventProcessor::executeRun(int)
StatusCode	stopRun () override
	implementation of IEventProcessor::stopRun()
Gaudi::StateMachine::State	FSMState () const override
Gaudi::StateMachine::State	targetFSMState () const override
StatusCode	reinitialize () override
StatusCode	restart () override
StatusCode	sysInitialize () override
StatusCode	sysStart () override
StatusCode	sysStop () override
StatusCode	sysFinalize () override
StatusCode	sysReinitialize () override
StatusCode	sysRestart () override

void	push (EventContext &&ctx) override
bool	empty () const override
std::optional< Gaudi::Interfaces::IQueueingEventProcessor::ResultType >	pop () override
Public Member Functions inherited from PropertyHolder< CommonMessaging< implements< IAppMgrUI, Gaudi::Interfaces::IQueueingEventProcessor, IService, IStateful, INamedInterface, IProperty > > >
StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property.
StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals.
StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string.
StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value
	PropertyHolder ()=default
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Details::PropertyBase &prop)
	Declare a property.
Gaudi::Details::PropertyBase *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
	Declare a remote property.
StatusCode	setPropertyRepr (const std::string &n, const std::string &r) override
	set the property from name and value string representation
StatusCode	getProperty (Gaudi::Details::PropertyBase *p) const override
	get the property
const std::vector< Gaudi::Details::PropertyBase * > &	getProperties () const override
	get all properties
bool	hasProperty (std::string_view name) const override
	Return true if we have a property with the given name.
Gaudi::Details::PropertyBase *	property (std::string_view name) const
	\fixme property and bindPropertiesTo should be protected
void	bindPropertiesTo (Gaudi::Interfaces::IOptionsSvc &optsSvc)
PropertyHolder &	operator= (const PropertyHolder &)=delete
Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor.
const SmartIF< IMessageSvc > &	msgSvc () const
	The standard message service.
MsgStream &	msgStream () const
	Return an uninitialized MsgStream.
MsgStream &	msgStream (const MSG::Level level) const
	Predefined configurable message stream for the efficient printouts.
MsgStream &	always () const
	shortcut for the method msgStream(MSG::ALWAYS)
MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL)
MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR)
MsgStream &	error () const
	shortcut for the method msgStream(MSG::ERROR)
MsgStream &	warning () const
	shortcut for the method msgStream(MSG::WARNING)
MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO)
MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG)
MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE)
MsgStream &	msg () const
	shortcut for the method msgStream(MSG::INFO)
MSG::Level	msgLevel () const
	get the cached level (originally extracted from the embedded MsgStream)
bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream

Gaudi::Details::PropertyBase handlers
typedef std::map< unsigned long, SmartIF< IComponentManager > >	ManagersMap
	Typedef for the map of component managers, the key is the "id" field of the basic InterfaceID of the managed components.
ManagersMap	m_managers
	Map of known component managers.
Gaudi::Property< std::vector< std::string > >	m_declaredManagers
	Property to declare the list of known managers.
SmartIF< ISvcManager >	m_svcManager
	Cached pointer to the manager of services.
SmartIF< IAlgManager >	m_algManager
	Cached pointer to the manager of algorithms.
SmartIF< ISvcLocator >	m_svcLocator
	Reference to its own service locator (must be instantiated prior to any service!).
SmartIF< DLLClassManager >	m_classManager
	Reference to the class manager.
Gaudi::Property< int >	m_SIGo
Gaudi::Property< int >	m_SIExit
Gaudi::Property< std::vector< std::string > >	m_topAlgNameList
Gaudi::Property< std::vector< std::string > >	m_outStreamNameList
Gaudi::Property< std::string >	m_messageSvcType
Gaudi::Property< std::string >	m_jobOptionsSvcType
std::string	m_name = "ApplicationMgr"
	Name.
Gaudi::StateMachine::State	m_state = Gaudi::StateMachine::OFFLINE
	Internal State.
Gaudi::StateMachine::State	m_targetState = Gaudi::StateMachine::OFFLINE
	Internal State.
Gaudi::Property< std::vector< std::string > >	m_svcMapping { this, "SvcMapping", {}, "Default mapping of services" }
Gaudi::Property< std::vector< std::string > >	m_svcOptMapping
SmartIF< IMessageSvc >	m_messageSvc
	Reference to the message service.
SmartIF< IRunable >	m_runable
	Reference to the runable object.
SmartIF< IEventProcessor >	m_processingMgr
	Reference to processing manager object.
SmartIF< IQueueingEventProcessor >	m_queueingProcessor
	Reference to a queueing processing manager object.
Gaudi::Monitoring::Hub	m_monitoringHub
Gaudi::Property< int >	m_evtMax { this, "EvtMax", -1, "Number of events to be processed (-1 means all events)" }
Gaudi::Property< std::vector< std::string > >	m_extSvcNameList
Gaudi::Property< bool >	m_extSvcCreates
Gaudi::Property< std::vector< std::string > >	m_dllNameList { this, "Dlls", {}, "List of DDL's names" }
Gaudi::Property< std::string >	m_jobOptionsType { this, "JobOptionsType", "FILE", "Source type (e.g. dbase, file...)" }
Gaudi::Property< std::string >	m_jobOptionsPath { this, "JobOptionsPath", {}, "The \"file\" to look for properties" }
Gaudi::Property< std::string >	m_jobOptionsPreAction
Gaudi::Property< std::string >	m_jobOptionsPostAction
Gaudi::Property< std::string >	m_runableType { this, "Runable", "AppMgrRunable", "Runable type", "Service:IRunable" }
Gaudi::Property< std::string >	m_eventLoopMgr
Gaudi::Property< std::string >	m_evtsel { this, "EvtSel", {}, "Event selection" }
Gaudi::Property< std::string >	m_histPersName { this, "HistogramPersistency", "NONE", "Name of the Hist Pers Svc" }
Gaudi::Property< int >	m_outputLevel { this, "OutputLevel", MSG::INFO, "Message output level" }
Gaudi::Property< std::string >	m_appName { this, "AppName", "ApplicationMgr", "The name of the application" }
Gaudi::Property< std::string >	m_appVersion { this, "AppVersion", {}, "The version of the application" }
Gaudi::Property< bool >	m_actHistory { this, "ActivateHistory", false, "Activate HistorySvc" }
Gaudi::Property< int >	m_pluginDebugLevel
Gaudi::Property< std::vector< std::string > >	m_createSvcNameList
Gaudi::Property< bool >	m_auditTools { this, "AuditTools", false }
	Defaults for auditors.
Gaudi::Property< bool >	m_auditSvcs { this, "AuditServices", false }
Gaudi::Property< bool >	m_auditAlgs { this, "AuditAlgorithms", false }
Gaudi::Property< std::map< std::string, std::string > >	m_environment
Gaudi::Property< bool >	m_loopCheck
Gaudi::Property< bool >	m_stopOnSignal
	Property to enable/disable the "stop on signal" service.
Gaudi::Property< bool >	m_propertiesPrint
Gaudi::Property< int >	m_returnCode
	Property to record the error conditions occurring during the running.
Gaudi::Property< bool >	m_printAlgsSequence
Gaudi::Property< bool >	m_useMessageSvcForROOTMessages
bool	m_useHiveAlgorithmManager
std::vector< std::string >	m_okDlls
	names of successfully loaded dlls
void	evtLoopPropertyHandler (Gaudi::Details::PropertyBase &theProp)
StatusCode	decodeExtSvcNameList ()
StatusCode	decodeCreateSvcNameList ()
void	createSvcNameListHandler (Gaudi::Details::PropertyBase &)
void	extSvcNameListHandler (Gaudi::Details::PropertyBase &theProp)
StatusCode	decodeDllNameList ()
void	dllNameListHandler (Gaudi::Details::PropertyBase &theProp)
void	pluginDebugPropertyHandler (Gaudi::Details::PropertyBase &theProp)
template<class I>
SmartIF< IComponentManager > &	getManager ()
SmartIF< ISvcManager > &	svcManager ()
SmartIF< IAlgManager > &	algManager ()
SmartIF< ISvcLocator > &	serviceLocator () const override
	Needed to locate the message service.
void	outputLevelUpdate () override
	Function to call to update the outputLevel of the components (after a change in MessageSvc).
Gaudi::Monitoring::Hub &	monitoringHub () override
void	printAlgsSequences ()
	Print the sequence of algorithms that have been loaded.
void	setServiceManager (ISvcManager *) override
StatusCode	i_startup ()
	Internal startup routine.
StatusCode	GoToState (Gaudi::StateMachine::State state, bool ignoreFailures=false)
	Reach a state from current state (whichever it is) going through the correct transitions.
template<typename SELF, typename PIMPL, typename METHOD, typename... ARGS>
static auto	i_delegateToEvtProc (SELF *self, PIMPL &member, std::string_view method_name, METHOD &&method, ARGS &&... args)
	Helper to delegate calls to event processor implementation.

Additional Inherited Members
Public Types inherited from PropertyHolder< CommonMessaging< implements< IAppMgrUI, Gaudi::Interfaces::IQueueingEventProcessor, IService, IStateful, INamedInterface, IProperty > > >
using	PropertyHolderImpl
	Typedef used to refer to this class from derived classes, as in.
Public Types inherited from CommonMessaging< implements< IAppMgrUI, Gaudi::Interfaces::IQueueingEventProcessor, IService, IStateful, INamedInterface, IProperty > >
using	base_class
Protected Member Functions inherited from CommonMessaging< implements< IAppMgrUI, Gaudi::Interfaces::IQueueingEventProcessor, IService, IStateful, INamedInterface, IProperty > >
MSG::Level	setUpMessaging () const override final
	Set up local caches.
MSG::Level	resetMessaging ()
	Reinitialize internal states.
void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream.

Detailed Description

The Application Manager class.

The main purpose of the Application Manager is to steer any data processing application. This includes all data processing applications for LHCb data in all stages: simulation, reconstruction, analysis, high level triggers, etc. Specific implementations of the ApplicationMgr will be developed to cope with the different environments (on-line, off-line, interactive, batch, etc.).

Author: Pere Mato

Definition at line 52 of file ApplicationMgr.h.

Member Typedef Documentation

◆ ManagersMap

typedef std::map<unsigned long, SmartIF<IComponentManager> > ApplicationMgr::ManagersMap

protected

Typedef for the map of component managers, the key is the "id" field of the basic InterfaceID of the managed components.

Definition at line 171 of file ApplicationMgr.h.

Constructor & Destructor Documentation

◆ ApplicationMgr()

ApplicationMgr::ApplicationMgr ( IInterface * = nullptr )

Definition at line 83 of file ApplicationMgr.cpp.

                                            {
  // IInterface initialization
  addRef(); // Initial count set to 1
 
  // Instantiate component managers
  m_managers[IService::interfaceID().id()] = new ServiceManager( this );
 
  m_svcLocator = svcManager();
 
  // Instantiate internal services
  // SvcLocator/Factory HAS to be already instantiated
  m_classManager = new DLLClassManager( this );
 
  AlgorithmManager* algMgr                   = new AlgorithmManager( this );
  m_managers[IAlgorithm::interfaceID().id()] = algMgr;
  //  m_managers[IAlgorithm::interfaceID().id()] = new HiveAlgorithmManager(this);
 
  // This property is not hosted in the ApplicationMgr instance
  declareProperty( "AlgTypeAliases", algMgr->typeAliases(),
                   "Aliases of algorithm types, to replace an algorithm type for every instance" );
 
  // ServiceMgr Initialization loop checking
  svcManager()->setLoopCheckEnabled( m_loopCheck );
 
  m_svcMapping = { "EvtDataSvc/EventDataSvc",
                   "DetDataSvc/DetectorDataSvc",
                   "HistogramSvc/HistogramDataSvc",
                   "HbookCnv::PersSvc/HbookHistSvc",
                   "RootHistCnv::PersSvc/RootHistSvc",
                   "EvtPersistencySvc/EventPersistencySvc",
                   "DetPersistencySvc/DetectorPersistencySvc",
                   "HistogramPersistencySvc/HistogramPersistencySvc" };
}

Member Function Documentation

◆ algManager()

SmartIF< IAlgManager > & ApplicationMgr::algManager ( )

inline

Definition at line 139 of file ApplicationMgr.h.

                                            {
    // Cache the casted pointer to IAlgManager
    if ( !m_algManager ) { m_algManager = getManager<IAlgorithm>(); }
    return m_algManager;
  }

◆ configure()

StatusCode ApplicationMgr::configure ( )

override

Definition at line 255 of file ApplicationMgr.cpp.

                                     {
 
  // Check if the state is compatible with the transition
  MsgStream tlog( m_messageSvc, name() );
  if ( Gaudi::StateMachine::CONFIGURED == m_state ) {
    tlog << MSG::INFO << "Already Configured" << endmsg;
    return StatusCode::SUCCESS;
  }
  if ( Gaudi::StateMachine::OFFLINE != m_state ) {
    tlog << MSG::FATAL << "configure: Invalid state \"" << m_state << "\"" << endmsg;
    return StatusCode::FAILURE;
  }
  m_targetState = Gaudi::StateMachine::CONFIGURED;
 
  // Reset application return code.
  m_returnCode = Gaudi::ReturnCode::Success;
 
  StatusCode sc;
  sc = i_startup();
  if ( !sc.isSuccess() ) { return sc; }
 
  {
    MsgStream log( m_messageSvc, name() );
    // Get my own options using the Job options service
    if ( log.level() <= MSG::DEBUG ) log << MSG::DEBUG << "Getting my own properties" << endmsg;
    bindPropertiesTo( serviceLocator()->getOptsSvc() );
  }
 
  // Make sure that the OutputLevel is in sync
  if ( m_outputLevel != MSG::NIL && m_messageSvc ) m_messageSvc->setOutputLevel( name(), m_outputLevel );
  MsgStream log( m_messageSvc, name() );
 
  // Check current outputLevel to eventually inform the MessageSvc
  if ( m_outputLevel != MSG::NIL && !m_appName.empty() ) {
    // Print a welcome message
    log << MSG::ALWAYS << std::endl
        << "=================================================================="
        << "==================================================================" << std::endl
        << "                                "
        << "                   Welcome to " << m_appName.value();
 
    if ( !m_appVersion.empty() ) {
      log << MSG::ALWAYS << " version " << m_appVersion.value();
    } else {
      log << MSG::ALWAYS << " (GaudiCoreSvc "
          << "v" << GAUDI_MAJOR_VERSION << "r" << GAUDI_MINOR_VERSION
#if GAUDI_PATCH_VERSION
          << "p" << GAUDI_PATCH_VERSION
#endif
          << ")";
    }
 
    // Add the host name and current time to the message
    log << MSG::ALWAYS << std::endl
        << "                                "
        << "          running on " << System::hostName() << " on " << Gaudi::Time::current().format( true ) << std::endl
        << "=================================================================="
        << "==================================================================" << endmsg;
  }
 
  // print all own properties if the options "PropertiesPrint" is set to true
  if ( m_propertiesPrint ) {
    const auto& properties = getProperties();
    log << MSG::ALWAYS << "List of ALL properties of " << System::typeinfoName( typeid( *this ) ) << "/" << this->name()
        << "  #properties = " << properties.size() << endmsg;
    for ( const auto& property : properties ) { log << "Property ['Name': Value] = " << *property << endmsg; }
  }
 
  // set the requested environment variables
  for ( auto& var : m_environment ) {
    const std::string& name  = var.first;
    const std::string& value = var.second;
    std::string        old   = System::getEnv( name.c_str() );
    const MSG::Level   lvl   = ( !old.empty() && ( old != "UNKNOWN" ) ) ? MSG::WARNING : MSG::DEBUG;
    if ( m_outputLevel <= lvl ) log << lvl << "Setting " << name << " = " << value << endmsg;
    System::setEnv( name, value );
  }
 
  // Declare Service Types
  for ( auto& j : m_svcMapping ) {
    Gaudi::Utils::TypeNameString itm( j );
    if ( svcManager()->declareSvcType( itm.name(), itm.type() ).isFailure() ) {
      log << MSG::ERROR << "configure: declaring svc type:'" << j << "' failed." << endmsg;
      return StatusCode::FAILURE;
    } else {
      ON_VERBOSE
      log << MSG::VERBOSE << "declared service " << j << endmsg;
    }
  }
  for ( auto& j : m_svcOptMapping ) {
    Gaudi::Utils::TypeNameString itm( j );
    if ( svcManager()->declareSvcType( itm.name(), itm.type() ).isFailure() ) {
      log << MSG::ERROR << "declaring svc type:'" << j << "' failed." << endmsg;
      return StatusCode::FAILURE;
    }
  }
 
  //--------------------------------------------------------------------------
  // Declare other Services and Algorithms by loading DLL's
  sc = decodeDllNameList();
  if ( sc.isFailure() ) {
    log << MSG::ERROR << "Failure loading declared DLL's" << endmsg;
    return sc;
  }
 
  //--------------------------------------------------------------------------
  // Deal with the services explicitly declared by the user.
  sc = decodeExtSvcNameList();
  if ( sc.isFailure() ) {
    log << MSG::ERROR << "Failure during external service association" << endmsg;
    return sc;
  }
 
  sc = decodeCreateSvcNameList();
  if ( sc.isFailure() ) {
    log << MSG::ERROR << "Failure during external service creation" << endmsg;
    return sc;
  }
 
  //--------------------------------------------------------------------------
  // Retrieve intrinsic services. If needed configure them.
  //--------------------------------------------------------------------------
  const Gaudi::Utils::TypeNameString evtloop_item( m_eventLoopMgr );
  sc = svcManager()->addService( evtloop_item, ServiceManager::DEFAULT_SVC_PRIORITY * 10 );
  if ( !sc.isSuccess() ) {
    log << MSG::FATAL << "Error adding :" << m_eventLoopMgr << endmsg;
    return sc;
  } else {
    ON_VERBOSE
    log << MSG::VERBOSE << "added service " << evtloop_item << endmsg;
  }
 
  m_runable = m_svcLocator->service( m_runableType );
  if ( !m_runable ) {
    log << MSG::FATAL << "Error retrieving Runable: " << m_runableType.value() << "\n Check option ApplicationMgr."
        << m_runableType.name() << endmsg;
    return sc;
  }
  m_processingMgr = m_svcLocator->service( evtloop_item );
  if ( !m_processingMgr ) {
    log << MSG::FATAL << "Error retrieving Processing manager: " << m_eventLoopMgr.value()
        << "\n Check option ApplicationMgr." << m_eventLoopMgr.name() << "\n No events will be processed." << endmsg;
    return sc;
  }
  // The IEventProcessor might also be an IQueueingEventProcessor
  m_queueingProcessor = m_processingMgr;
 
  // Establish Update Handlers for ExtSvc and DLLs Properties
  m_extSvcNameList.declareUpdateHandler( &ApplicationMgr::extSvcNameListHandler, this );
  m_createSvcNameList.declareUpdateHandler( &ApplicationMgr::createSvcNameListHandler, this );
  m_dllNameList.declareUpdateHandler( &ApplicationMgr::dllNameListHandler, this );
 
  if ( m_actHistory ) {
    // Create HistorySvc with a priority to ensure it's initialized last, finalized first
    sc = svcManager()->addService( "HistorySvc", std::numeric_limits<int>::max() );
    if ( sc.isFailure() ) {
      log << MSG::FATAL << "Error adding HistorySvc" << endmsg;
      return StatusCode::FAILURE;
    }
  }
 
  log << MSG::INFO << "Application Manager Configured successfully" << endmsg;
  m_state = m_targetState;
  return StatusCode::SUCCESS;
}

◆ createEventContext()

EventContext ApplicationMgr::createEventContext ( )

override

implementation of IEventProcessor::createEventContext()

Definition at line 781 of file ApplicationMgr.cpp.

                                                {
  if ( m_state == Gaudi::StateMachine::RUNNING ) {
    if ( m_processingMgr ) { return m_processingMgr->createEventContext(); }
  }
  std::stringstream ss;
  ss << "createEventContext: Invalid state \"" << FSMState() << '"';
  throw GaudiException( ss.str(), name(), StatusCode::FAILURE );
}

◆ createSvcNameListHandler()

void ApplicationMgr::createSvcNameListHandler ( Gaudi::Details::PropertyBase & )

Definition at line 867 of file ApplicationMgr.cpp.

                                                                           {
  if ( !( decodeCreateSvcNameList() ).isSuccess() ) {
    throw GaudiException( "Failed to create ext services", "MinimalEventLoopMgr::createSvcNameListHandler",
                          StatusCode::FAILURE );
  }
}

◆ decodeCreateSvcNameList()

StatusCode ApplicationMgr::decodeCreateSvcNameList ( )

Definition at line 873 of file ApplicationMgr.cpp.

                                                   {
  StatusCode  result   = StatusCode::SUCCESS;
  const auto& theNames = m_createSvcNameList.value();
  auto        it       = theNames.begin();
  auto        et       = theNames.end();
  while ( result.isSuccess() && it != et ) {
    Gaudi::Utils::TypeNameString item( *it++ );
    if ( ( result = svcManager()->addService( item, ServiceManager::DEFAULT_SVC_PRIORITY ) ).isFailure() ) {
      MsgStream log( m_messageSvc, m_name );
      log << MSG::ERROR << "decodeCreateSvcNameList: Cannot create service " << item.type() << "/" << item.name()
          << endmsg;
    } else {
      ON_DEBUG {
        MsgStream log( m_messageSvc, m_name );
        log << MSG::DEBUG << "decodeCreateSvcNameList: Created service " << item.type() << "/" << item.name() << endmsg;
      }
    }
  }
  return result;
}

◆ decodeDllNameList()

StatusCode ApplicationMgr::decodeDllNameList ( )

Definition at line 933 of file ApplicationMgr.cpp.

                                             {
 
  MsgStream  log( m_messageSvc, m_name );
  StatusCode result = StatusCode::SUCCESS;
 
  // Clean up multiple entries from DLL list
  std::vector<std::string>            newList;
  std::map<std::string, unsigned int> dllInList, duplicateList;
  {
    for ( const auto& it : m_dllNameList ) {
      if ( 0 == dllInList[it] ) {
        newList.push_back( it ); // first instance of this module
      } else {
        ++duplicateList[it];
      }                // module listed multiple times
      ++dllInList[it]; // increment count for this module
    }
  }
  // m_dllNameList = newList; // update primary list to new, filtered list (do not use the
  // property itself otherwise we get called again infinitely)
  // List modules that were in there twice..
  ON_DEBUG if ( !duplicateList.empty() ) {
    log << MSG::DEBUG << "Removed duplicate entries for modules : ";
    for ( auto it = duplicateList.begin(); it != duplicateList.end(); ++it ) {
      log << it->first << "(" << 1 + it->second << ")";
      if ( it != --duplicateList.end() ) log << ", ";
    }
    log << endmsg;
  }
 
  const std::vector<std::string>& theNames = newList;
 
  // only load the new dlls or previously failed dlls
  ON_DEBUG log << MSG::DEBUG << "Loading declared DLL's" << endmsg;
 
  std::vector<std::string> successNames, failNames;
  for ( const auto& it : theNames ) {
    if ( std::find( m_okDlls.rbegin(), m_okDlls.rend(), it ) == m_okDlls.rend() ) {
      // found a new module name
      StatusCode status = m_classManager->loadModule( it );
      if ( status.isFailure() ) {
        failNames.push_back( it );
        result = StatusCode::FAILURE;
      } else {
        successNames.push_back( it );
      }
    }
  }
 
  // report back to the user and store the names of the succesfully loaded dlls
  if ( !successNames.empty() ) {
    log << MSG::INFO << "Successfully loaded modules : ";
    for ( auto it = successNames.begin(); it != successNames.end(); it++ ) {
      log << ( *it );
      if ( ( it + 1 ) != successNames.end() ) log << ", ";
      // save name
      m_okDlls.push_back( *it );
    }
    log << endmsg;
  }
 
  if ( result == StatusCode::FAILURE ) {
    log << MSG::WARNING << "Failed to load modules: ";
    for ( auto it = failNames.begin(); it != failNames.end(); it++ ) {
      log << ( *it );
      if ( ( it + 1 ) != failNames.end() ) log << ", ";
    }
    log << endmsg;
  }
  return result;
}

◆ decodeExtSvcNameList()

StatusCode ApplicationMgr::decodeExtSvcNameList ( )

Definition at line 901 of file ApplicationMgr.cpp.

                                                {
  StatusCode result = StatusCode::SUCCESS;
 
  const auto& theNames = m_extSvcNameList.value();
 
  auto it = theNames.begin();
  auto et = theNames.end();
  while ( result.isSuccess() && it != et ) {
    Gaudi::Utils::TypeNameString item( *it++ );
    if ( m_extSvcCreates ) {
      if ( ( result = svcManager()->addService( item, ServiceManager::DEFAULT_SVC_PRIORITY ) ).isFailure() ) {
        MsgStream log( m_messageSvc, m_name );
        log << MSG::ERROR << "decodeExtSvcNameList: Cannot create service " << item.type() << "/" << item.name()
            << endmsg;
      }
    } else {
      if ( ( result = svcManager()->declareSvcType( item.name(), item.type() ) ).isFailure() ) {
        MsgStream log( m_messageSvc, m_name );
        log << MSG::ERROR << "decodeExtSvcNameList: Cannot declare service " << item.type() << "/" << item.name()
            << endmsg;
      }
    }
  }
  return result;
}

◆ dllNameListHandler()

void ApplicationMgr::dllNameListHandler ( Gaudi::Details::PropertyBase & theProp )

Definition at line 927 of file ApplicationMgr.cpp.

                                                                     {
  if ( !( decodeDllNameList() ).isSuccess() ) {
    throw GaudiException( "Failed to load DLLs.", "MinimalEventLoopMgr::dllNameListHandler", StatusCode::FAILURE );
  }
}

◆ empty()

bool ApplicationMgr::empty ( ) const

override

Definition at line 773 of file ApplicationMgr.cpp.

                                 {
  return i_delegateToEvtProc( this, m_queueingProcessor, "empty", &Gaudi::Interfaces::IQueueingEventProcessor::empty );
}

◆ evtLoopPropertyHandler()

void ApplicationMgr::evtLoopPropertyHandler ( Gaudi::Details::PropertyBase & theProp )

Definition at line 860 of file ApplicationMgr.cpp.

                                                                         {
  if ( m_processingMgr ) {
    auto props = m_processingMgr.as<IProperty>();
    if ( props ) props->setProperty( p ).ignore();
  }
}

◆ executeEvent()

StatusCode ApplicationMgr::executeEvent ( EventContext && ctx )

override

implementation of IEventProcessor::executeEvent(void*)

Definition at line 759 of file ApplicationMgr.cpp.

                                                            {
  if ( m_state == Gaudi::StateMachine::RUNNING ) {
    if ( m_processingMgr ) { return m_processingMgr->executeEvent( std::move( ctx ) ); }
  }
  MsgStream log( m_messageSvc, name() );
  log << MSG::FATAL << "executeEvent: Invalid state \"" << FSMState() << "\"" << endmsg;
  return StatusCode::FAILURE;
}

◆ executeRun()

StatusCode ApplicationMgr::executeRun ( int evtmax )

override

implementation of IEventProcessor::executeRun(int)

Definition at line 790 of file ApplicationMgr.cpp.

                                                  {
  MsgStream log( m_messageSvc, name() );
  if ( m_state == Gaudi::StateMachine::RUNNING ) {
    if ( m_processingMgr ) { return m_processingMgr->executeRun( evtmax ); }
    log << MSG::WARNING << "No EventLoop Manager specified " << endmsg;
    return StatusCode::SUCCESS;
  }
  log << MSG::FATAL << "executeRun: Invalid state \"" << FSMState() << "\"" << endmsg;
  return StatusCode::FAILURE;
}

◆ extSvcNameListHandler()

void ApplicationMgr::extSvcNameListHandler ( Gaudi::Details::PropertyBase & theProp )

Definition at line 894 of file ApplicationMgr.cpp.

                                                                        {
  if ( !( decodeExtSvcNameList() ).isSuccess() ) {
    throw GaudiException( "Failed to declare ext services", "MinimalEventLoopMgr::extSvcNameListHandler",
                          StatusCode::FAILURE );
  }
}

◆ finalize()

StatusCode ApplicationMgr::finalize ( )

override

Definition at line 550 of file ApplicationMgr.cpp.

                                    {
  MsgStream log( m_messageSvc, name() );
  if ( m_state == Gaudi::StateMachine::CONFIGURED ) {
    log << MSG::INFO << "Already Finalized" << endmsg;
    return StatusCode::SUCCESS;
  }
  if ( m_state != Gaudi::StateMachine::INITIALIZED ) {
    log << MSG::FATAL << "finalize: Invalid state \"" << m_state << "\"" << endmsg;
    return StatusCode::FAILURE;
  }
  m_targetState = Gaudi::StateMachine::CONFIGURED;
 
  // disable message suppression in finalize
  m_svcLocator->service<IProperty>( "MessageSvc" )
      ->setProperty( Gaudi::Property<bool>( "enableSuppression", false ) )
      .ignore();
 
  // Finalize independently managed Algorithms
  StatusCode sc = algManager()->finalize();
  if ( sc.isFailure() ) {
    log << MSG::WARNING << "Failed to finalize an algorithm." << endmsg;
    m_returnCode = Gaudi::ReturnCode::FinalizationFailure;
  }
 
  // Finalize all Services
  sc = svcManager()->finalize();
  if ( sc.isFailure() ) {
    log << MSG::WARNING << "Failed to finalize a service." << endmsg;
    m_returnCode = Gaudi::ReturnCode::FinalizationFailure;
  }
 
  // svcManager()->removeService( (IService*) m_processingMgr.get() );
  // svcManager()->removeService( (IService*) m_runable.get() );
 
  if ( sc.isSuccess() ) {
    log << MSG::INFO << "Application Manager Finalized successfully" << endmsg;
  } else {
    log << MSG::ERROR << "Application Manager failed to finalize" << endmsg;
  }
 
  m_state = m_targetState;
  return sc;
}

◆ FSMState()

Gaudi::StateMachine::State ApplicationMgr::FSMState ( ) const

override

Definition at line 813 of file ApplicationMgr.cpp.

813{ return m_state; }

◆ getManager()

template<class I>

SmartIF< IComponentManager > & ApplicationMgr::getManager ( )

inline

Definition at line 129 of file ApplicationMgr.h.

                                           {
    return m_managers[I::interfaceID().id()];
  }

◆ GoToState()

StatusCode ApplicationMgr::GoToState	(	Gaudi::StateMachine::State	state,
		bool	ignoreFailures = false )

protected

Reach a state from current state (whichever it is) going through the correct transitions.

By default, if a transition fails, the chain is interrupted, but the behavior can be changed with the parameter "gnoreFailures"

Definition at line 653 of file ApplicationMgr.cpp.

                                                                                        {
  StatusCode sc = StatusCode::SUCCESS;
 
  switch ( state ) {
 
  case Gaudi::StateMachine::OFFLINE:
    switch ( m_state ) {
    case Gaudi::StateMachine::OFFLINE:
      return StatusCode::SUCCESS;
      break;
    case Gaudi::StateMachine::CONFIGURED:
      return terminate();
      break;
    default: // Gaudi::StateMachine::INITIALIZED or Gaudi::StateMachine::RUNNING
      sc = GoToState( Gaudi::StateMachine::CONFIGURED );
      if ( sc.isSuccess() ) { return terminate(); }
      break;
    }
    break;
 
  case Gaudi::StateMachine::CONFIGURED:
    switch ( m_state ) {
    case Gaudi::StateMachine::CONFIGURED:
      return StatusCode::SUCCESS;
      break;
    case Gaudi::StateMachine::OFFLINE:
      return configure();
      break;
    case Gaudi::StateMachine::INITIALIZED:
      return finalize();
      break;
    default: // Gaudi::StateMachine::RUNNING
      sc = GoToState( Gaudi::StateMachine::INITIALIZED );
      if ( sc.isSuccess() ) { return finalize(); }
      break;
    }
    break;
 
  case Gaudi::StateMachine::INITIALIZED:
    switch ( m_state ) {
    case Gaudi::StateMachine::INITIALIZED:
      return StatusCode::SUCCESS;
      break;
    case Gaudi::StateMachine::CONFIGURED:
      return initialize();
      break;
    case Gaudi::StateMachine::RUNNING:
      return stop();
      break;
    default: // Gaudi::StateMachine::OFFLINE
      sc = GoToState( Gaudi::StateMachine::CONFIGURED );
      if ( sc.isSuccess() ) { return initialize(); }
      break;
    }
    break;
 
  case Gaudi::StateMachine::RUNNING:
    switch ( m_state ) {
    case Gaudi::StateMachine::RUNNING:
      return StatusCode::SUCCESS;
      break;
    case Gaudi::StateMachine::INITIALIZED:
      return start();
      break;
    default: // Gaudi::StateMachine::OFFLINE or Gaudi::StateMachine::CONFIGURED
      sc = GoToState( Gaudi::StateMachine::INITIALIZED );
      if ( sc.isSuccess() ) { return start(); }
      break;
    }
    break;
  }
 
  // If I get here, there has been a problem in the recursion
 
  if ( ignoreFailures ) {
    // force the new state
    m_state = state;
    return StatusCode::SUCCESS;
  }
 
  return sc;
}

◆ i_cast()

void const * ApplicationMgr::i_cast ( const InterfaceID & iid ) const

override

Definition at line 117 of file ApplicationMgr.cpp.

                                                                 {
  // try our own interfaces
  if ( auto output = base_class::i_cast( iid ) ) { return output; }
  // delegate to other instances
  if ( ISvcLocator::interfaceID().versionMatch( iid ) ) { return serviceLocator().get(); }
  if ( ISvcManager::interfaceID().versionMatch( iid ) ) {
    return const_cast<ApplicationMgr*>( this )->svcManager().get();
  }
  if ( IAlgManager::interfaceID().versionMatch( iid ) ) {
    return const_cast<ApplicationMgr*>( this )->algManager().get();
  }
  if ( IClassManager::interfaceID().versionMatch( iid ) ) { return m_classManager.get(); }
  if ( IMessageSvc::interfaceID().versionMatch( iid ) ) {
    // Note that 0 can be a valid IMessageSvc pointer value (when used for
    // MsgStream).
    return m_messageSvc.get();
  }
  return nullptr;
}

◆ i_delegateToEvtProc()

template<typename SELF, typename PIMPL, typename METHOD, typename... ARGS>

auto ApplicationMgr::i_delegateToEvtProc	(	SELF *	self,
		PIMPL &	member,
		std::string_view	method_name,
		METHOD &&	method,
		ARGS &&...	args )

inlinestaticprivate

Helper to delegate calls to event processor implementation.

Definition at line 314 of file ApplicationMgr.h.

                                                    {
    if ( self->m_state == Gaudi::StateMachine::RUNNING ) {
      if ( bool( member ) ) {
        return std::invoke( method, *member.get(), std::forward<ARGS>( args )... );
      } else {
        std::stringstream s;
        s << method_name << ": event processor is not a \""
          << System::typeinfoName( typeid( decltype( *member.get() ) ) ) << '"';
        throw GaudiException{ s.str(), self->name(), StatusCode::FAILURE };
      }
    }
    std::stringstream s;
    s << method_name << ": Invalid state \"" << self->FSMState() << '"';
    throw GaudiException{ s.str(), self->name(), StatusCode::FAILURE };
  }

◆ i_startup()

StatusCode ApplicationMgr::i_startup ( )

protected

Internal startup routine.

Definition at line 137 of file ApplicationMgr.cpp.

                                     {
 
  StatusCode sc;
 
  // declare factories in current module
  m_classManager->loadModule( "" ).ignore();
 
  // Note: we cannot use CommonMessaging methods here because MessageSvc is not there yet
  MsgStream log( nullptr, name() );
 
  // Create the Message service
  auto msgsvc = svcManager()->createService( Gaudi::Utils::TypeNameString( "MessageSvc", m_messageSvcType ) );
  if ( !msgsvc ) {
    log << MSG::FATAL << "Error creating MessageSvc of type " << m_messageSvcType << endmsg;
    return StatusCode::FAILURE;
  }
  // Get the useful interface from Message services
  m_messageSvc = m_svcLocator->service( "MessageSvc" );
  if ( !m_messageSvc ) {
    log << MSG::FATAL << "Error retrieving MessageSvc." << endmsg;
    return StatusCode::FAILURE;
  }
  sc = m_messageSvc.as<IProperty>()->setProperty( "OutputLevel", m_outputLevel );
  if ( !sc ) {
    log << MSG::FATAL << "Error setting OutputLevel option of MessageSvc" << endmsg;
    return sc;
  }
  if ( m_useMessageSvcForROOTMessages ) {
    if ( gROOT ) {
      // if ROOT is already initialized (usually it is the case) we redirect messages to MessageSvc.
      s_messageSvcInstance       = m_messageSvc.get();
      s_originalRootErrorHandler = SetErrorHandler( ROOTErrorHandlerAdapter );
    } else {
      log << MSG::WARNING
          << "ROOT not yet initialized, we cannot override the error handler are requested "
             "(UseMessageSvcForROOTMessages==true)"
          << endmsg;
    }
  }
 
  auto jobsvc = svcManager()->createService( Gaudi::Utils::TypeNameString( "JobOptionsSvc", m_jobOptionsSvcType ) );
  // Create the Job Options service
  if ( !jobsvc ) {
    log << MSG::FATAL << "Error creating JobOptionsSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  auto jobOptsIProp = jobsvc.as<IProperty>();
  if ( !jobOptsIProp ) {
    log << MSG::FATAL << "Error locating JobOptionsSvc" << endmsg;
    return StatusCode::FAILURE;
  }
  sc = jobOptsIProp->setProperty( Gaudi::Property<std::string>( "TYPE", m_jobOptionsType ) );
  if ( !sc.isSuccess() ) {
    log << MSG::FATAL << "Error setting TYPE option in JobOptionsSvc" << endmsg;
    return sc;
  }
 
  if ( !m_jobOptionsPreAction.empty() ) {
    sc = jobOptsIProp->setProperty( Gaudi::Property<std::string>( "PYTHONPARAMS", m_jobOptionsPreAction ) );
    if ( !sc.isSuccess() ) {
      log << MSG::FATAL << "Error setting JobOptionsPreAction option in JobOptionsSvc" << endmsg;
      return sc;
    }
  }
 
  if ( !m_jobOptionsPostAction.empty() ) {
    sc = jobOptsIProp->setProperty( Gaudi::Property<std::string>( "PYTHONACTION", m_jobOptionsPostAction ) );
    if ( !sc.isSuccess() ) {
      log << MSG::FATAL << "Error setting JobOptionsPostAction option in JobOptionsSvc" << endmsg;
      return sc;
    }
  }
 
  if ( !m_jobOptionsPath.empty() ) { // The command line takes precedence
    sc = jobOptsIProp->setProperty( Gaudi::Property<std::string>( "PATH", m_jobOptionsPath ) );
    if ( !sc.isSuccess() ) {
      log << MSG::FATAL << "Error setting PATH option in JobOptionsSvc" << endmsg;
      return sc;
    }
  } else if ( isEnvSet( "JOBOPTPATH" ) ) { // Otherwise the Environment JOBOPTPATH
    sc = jobOptsIProp->setProperty( Gaudi::Property<std::string>( "PATH", getEnv( "JOBOPTPATH" ) ) );
    if ( !sc.isSuccess() ) {
      log << MSG::FATAL << "Error setting PATH option in JobOptionsSvc from env" << endmsg;
      return sc;
    }
  } else { // Otherwise the default
    sc = jobOptsIProp->setProperty( Gaudi::Property<std::string>( "PATH", "../options/job.opts" ) );
    if ( !sc.isSuccess() ) {
      log << MSG::FATAL << "Error setting PATH option in JobOptionsSvc to default" << endmsg;
      return sc;
    }
  }
  jobOptsIProp.reset();
 
  // Sets my default the Output Level of the Message service to be
  // the same as this
  auto msgSvcIProp = msgsvc.as<IProperty>();
  msgSvcIProp->setProperty( Gaudi::Property<int>( "OutputLevel", m_outputLevel ) ).ignore();
  msgSvcIProp.reset();
 
  sc = jobsvc->sysInitialize();
  if ( !sc.isSuccess() ) {
    log << MSG::FATAL << "Error initializing JobOptionsSvc" << endmsg;
    return sc;
  }
  sc = msgsvc->sysInitialize();
  if ( !sc.isSuccess() ) {
    log << MSG::FATAL << "Error initializing MessageSvc" << endmsg;
    return sc;
  }
 
  // Make sure output level caches are up to date.
  outputLevelUpdate();
 
  return sc;
}

◆ initialize()

StatusCode ApplicationMgr::initialize ( )

override

Definition at line 421 of file ApplicationMgr.cpp.

                                      {
  StatusCode sc;
 
  MsgStream log( m_messageSvc, name() );
 
  // Make sure output level caches are up to date.
  outputLevelUpdate();
 
  // I cannot add these services in configure() because they are coming from GaudiUtils
  // and it messes up genconf when rebuilding it.
  if ( m_stopOnSignal ) {
    // Instantiate the service that schedules a stop when a signal is received
    std::string svcname( "Gaudi::Utils::StopSignalHandler" );
    sc = svcManager()->addService( svcname );
    if ( sc.isFailure() ) {
      log << MSG::INFO << "Cannot instantiate " << svcname << "signals will be ignored" << endmsg;
    }
  }
 
  if ( m_state == Gaudi::StateMachine::INITIALIZED ) {
    log << MSG::INFO << "Already Initialized!" << endmsg;
    return StatusCode::SUCCESS;
  }
  if ( m_state != Gaudi::StateMachine::CONFIGURED ) {
    log << MSG::FATAL << "initialize: Invalid state \"" << m_state << "\"" << endmsg;
    return StatusCode::FAILURE;
  }
  m_targetState = Gaudi::StateMachine::INITIALIZED;
 
  //--------------------------------------------------------------------------
  // Initialize the list of top Services
  //--------------------------------------------------------------------------
  sc = svcManager()->initialize();
  if ( !sc.isSuccess() ) return sc;
 
  sc = algManager()->initialize();
  if ( !sc.isSuccess() ) return sc;
 
  //--------------------------------------------------------------------------
  // Final steps: Inform user and change internal state
  //--------------------------------------------------------------------------
  log << MSG::INFO << "Application Manager Initialized successfully" << endmsg;
  m_state = m_targetState;
 
  if ( m_printAlgsSequence ) printAlgsSequences();
 
  return sc;
}

◆ monitoringHub()

Gaudi::Monitoring::Hub & ApplicationMgr::monitoringHub ( )

inlineoverride

Definition at line 151 of file ApplicationMgr.h.

151{ return m_monitoringHub; }

ApplicationMgr::m_monitoringHub

Gaudi::Monitoring::Hub m_monitoringHub

Definition ApplicationMgr.h:232

◆ name()

const std::string & ApplicationMgr::name ( ) const

override

Definition at line 811 of file ApplicationMgr.cpp.

811{ return m_name; }

◆ nextEvent()

StatusCode ApplicationMgr::nextEvent ( int maxevt )

override

Definition at line 501 of file ApplicationMgr.cpp.

                                                 {
  if ( m_state != Gaudi::StateMachine::RUNNING ) {
    MsgStream log( m_messageSvc, name() );
    log << MSG::FATAL << "nextEvent: Invalid state \"" << m_state << "\"" << endmsg;
    return StatusCode::FAILURE;
  }
  if ( !m_processingMgr ) {
    MsgStream log( m_messageSvc, name() );
    log << MSG::FATAL << "No event processing manager specified. Check option: " << m_eventLoopMgr.name() << endmsg;
    return StatusCode::FAILURE;
  }
  return m_processingMgr->nextEvent( maxevt );
}

◆ outputLevelUpdate()

void ApplicationMgr::outputLevelUpdate ( )

override

Function to call to update the outputLevel of the components (after a change in MessageSvc).

Definition at line 1005 of file ApplicationMgr.cpp.

                                       {
  resetMessaging();
  for ( auto& mgrItem : m_managers ) { mgrItem.second->outputLevelUpdate(); }
}

◆ pluginDebugPropertyHandler()

void ApplicationMgr::pluginDebugPropertyHandler ( Gaudi::Details::PropertyBase & theProp )

◆ pop()

std::optional< Gaudi::Interfaces::IQueueingEventProcessor::ResultType > ApplicationMgr::pop ( )

override

Definition at line 777 of file ApplicationMgr.cpp.

                                                                                  {
  return i_delegateToEvtProc( this, m_queueingProcessor, "pop", &Gaudi::Interfaces::IQueueingEventProcessor::pop );
}

◆ printAlgsSequences()

void ApplicationMgr::printAlgsSequences ( )

Print the sequence of algorithms that have been loaded.

Definition at line 1031 of file ApplicationMgr.cpp.

                                        {
  MsgStream log( m_messageSvc, m_name );
  log << MSG::ALWAYS << "****************************** Algorithm Sequence ****************************" << endmsg;
  for ( auto& algname : m_topAlgNameList ) { printAlgsSequencesHelper( algManager(), algname, log, 0 ); }
  log << MSG::ALWAYS << "******************************************************************************" << endmsg;
}

◆ push()

void ApplicationMgr::push ( EventContext && ctx )

override

Definition at line 768 of file ApplicationMgr.cpp.

                                              {
  return i_delegateToEvtProc( this, m_queueingProcessor, "push", &Gaudi::Interfaces::IQueueingEventProcessor::push,
                              std::move( ctx ) );
}

◆ reinitialize()

StatusCode ApplicationMgr::reinitialize ( )

override

Definition at line 816 of file ApplicationMgr.cpp.

                                        {
  MsgStream  log( m_messageSvc, name() );
  StatusCode retval = StatusCode::SUCCESS;
  StatusCode sc;
  if ( m_state < Gaudi::StateMachine::INITIALIZED ) {
    throw GaudiException( "Cannot reinitialize application if not INITIALIZED or RUNNING",
                          "ApplicationMgr::reinitialize", StatusCode::FAILURE );
  }
  if ( m_state == Gaudi::StateMachine::RUNNING ) { retval = GoToState( Gaudi::StateMachine::INITIALIZED ); }
  sc = svcManager()->reinitialize();
  if ( sc.isFailure() ) retval = sc;
  sc = algManager()->reinitialize();
  if ( sc.isFailure() ) retval = sc;
 
  sc = m_messageSvc.as<IService>()->sysReinitialize();
  if ( sc.isFailure() ) retval = sc;
  sc = m_svcLocator->service( "JobOptionsSvc" )->sysReinitialize();
  if ( sc.isFailure() ) retval = sc;
 
  log << MSG::INFO << "Application Manager Reinitialized successfully" << endmsg;
 
  return retval;
}

◆ restart()

StatusCode ApplicationMgr::restart ( )

override

Definition at line 840 of file ApplicationMgr.cpp.

                                   {
  StatusCode retval = StatusCode::SUCCESS;
  StatusCode sc;
  if ( m_state != Gaudi::StateMachine::RUNNING ) {
    throw GaudiException( "Cannot restart application if not RUNNING", "ApplicationMgr::restart", StatusCode::FAILURE );
  }
 
  sc = svcManager()->restart();
  if ( sc.isFailure() ) retval = sc;
  sc = algManager()->restart();
  if ( sc.isFailure() ) retval = sc;
 
  sc = m_messageSvc.as<IService>()->sysRestart();
  if ( sc.isFailure() ) retval = sc;
  sc = m_svcLocator->service( "JobOptionsSvc" )->sysRestart();
  if ( sc.isFailure() ) retval = sc;
 
  return retval;
}

◆ run()

StatusCode ApplicationMgr::run ( )

override

Definition at line 736 of file ApplicationMgr.cpp.

                               {
  StatusCode sc = StatusCode::SUCCESS;
 
  sc = GoToState( Gaudi::StateMachine::RUNNING );
  if ( sc.isSuccess() ) {
    MsgStream log( m_messageSvc, name() );
    if ( m_runable != 0 ) { // loop over the events
      sc = m_runable->run();
      if ( !sc.isSuccess() ) { log << MSG::FATAL << "Application execution failed. Ending the job." << endmsg; }
    } else {
      log << MSG::FATAL << "Application has no runable object. Check option:" << m_runableType.name() << endmsg;
    }
  }
  if ( sc.isSuccess() ) { // try to close cleanly
    sc = GoToState( Gaudi::StateMachine::OFFLINE );
  }
  // either the runable failed of the stut-down
  if ( sc.isFailure() ) { // try to close anyway (but keep the StatusCode unchanged)
    GoToState( Gaudi::StateMachine::OFFLINE, true ).ignore();
  }
  return sc;
}

◆ serviceLocator()

SmartIF< ISvcLocator > & ApplicationMgr::serviceLocator ( ) const

inlineoverride

Needed to locate the message service.

Definition at line 146 of file ApplicationMgr.h.

146{ return m_svcLocator; }

◆ setServiceManager()

void ApplicationMgr::setServiceManager ( ISvcManager * )

inlineoverrideprotected

Definition at line 158 of file ApplicationMgr.h.

158{}

◆ start()

StatusCode ApplicationMgr::start ( )

override

Definition at line 470 of file ApplicationMgr.cpp.

                                 {
 
  MsgStream log( m_messageSvc, name() );
 
  if ( m_state == Gaudi::StateMachine::RUNNING ) {
    log << MSG::INFO << "Already Initialized!" << endmsg;
    return StatusCode::SUCCESS;
  }
  if ( m_state != Gaudi::StateMachine::INITIALIZED ) {
    log << MSG::FATAL << "start: Invalid state \"" << m_state << "\"" << endmsg;
    return StatusCode::FAILURE;
  }
  m_targetState = Gaudi::StateMachine::RUNNING;
 
  //--------------------------------------------------------------------------
  // Initialize the list of top Services
  //--------------------------------------------------------------------------
  return m_svcLocator->service( "JobOptionsSvc" )
      ->sysStart()
      .andThen( [&]() { return m_messageSvc.as<IService>()->sysStart(); } )
      .andThen( [&]() { return svcManager()->start(); } )
      .andThen( [&]() { return algManager()->start(); } )
      .andThen( [&]() {
        //--------------------------------------------------------------------------
        // Final steps: Inform user and change internal state
        //--------------------------------------------------------------------------
        log << MSG::INFO << "Application Manager Started successfully" << endmsg;
        m_state = m_targetState;
      } );
}

◆ stop()

StatusCode ApplicationMgr::stop ( )

override

Definition at line 515 of file ApplicationMgr.cpp.

                                {
 
  MsgStream log( m_messageSvc, name() );
 
  if ( m_state == Gaudi::StateMachine::INITIALIZED ) {
    log << MSG::INFO << "Already Initialized!" << endmsg;
    return StatusCode::SUCCESS;
  }
  if ( m_state != Gaudi::StateMachine::RUNNING ) {
    log << MSG::FATAL << "stop: Invalid state \"" << m_state << "\"" << endmsg;
    return StatusCode::FAILURE;
  }
  m_targetState = Gaudi::StateMachine::INITIALIZED;
 
  // Stop independently managed Algorithms
  return algManager()
      ->stop()
      //--------------------------------------------------------------------------
      // Stop the list of top Services
      //--------------------------------------------------------------------------
      .andThen( [&]() { return svcManager()->stop(); } )
      .andThen( [&]() { return m_messageSvc.as<IService>()->sysStop(); } )
      .andThen( [&]() { return m_svcLocator->service( "JobOptionsSvc" )->sysStop(); } )
      //--------------------------------------------------------------------------
      // Final steps: Inform user and change internal state
      //--------------------------------------------------------------------------
      .andThen( [&]() {
        log << MSG::INFO << "Application Manager Stopped successfully" << endmsg;
        m_state = m_targetState;
      } );
}

◆ stopRun()

StatusCode ApplicationMgr::stopRun ( )

override

implementation of IEventProcessor::stopRun()

Definition at line 801 of file ApplicationMgr.cpp.

                                   {
  MsgStream log( m_messageSvc, name() );
  if ( m_state == Gaudi::StateMachine::RUNNING ) {
    if ( m_processingMgr ) { return m_processingMgr->stopRun(); }
    log << MSG::WARNING << "No EventLoop Manager specified " << endmsg;
    return StatusCode::SUCCESS;
  }
  log << MSG::FATAL << "stopRun: Invalid state \"" << FSMState() << "\"" << endmsg;
  return StatusCode::FAILURE;
}

◆ svcManager()

SmartIF< ISvcManager > & ApplicationMgr::svcManager ( )

inline

Definition at line 133 of file ApplicationMgr.h.

                                            {
    // Cache the casted pointer to ISvcManager
    if ( !m_svcManager ) { m_svcManager = getManager<IService>(); }
    return m_svcManager;
  }

◆ sysFinalize()

StatusCode ApplicationMgr::sysFinalize ( )

inlineoverride

Definition at line 104 of file ApplicationMgr.h.

104{ return StatusCode::SUCCESS; }

◆ sysInitialize()

StatusCode ApplicationMgr::sysInitialize ( )

inlineoverride

Definition at line 98 of file ApplicationMgr.h.

98{ return StatusCode::SUCCESS; }

◆ sysReinitialize()

StatusCode ApplicationMgr::sysReinitialize ( )

inlineoverride

Definition at line 106 of file ApplicationMgr.h.

106{ return StatusCode::SUCCESS; }

◆ sysRestart()

StatusCode ApplicationMgr::sysRestart ( )

inlineoverride

Definition at line 108 of file ApplicationMgr.h.

108{ return StatusCode::SUCCESS; }

◆ sysStart()

StatusCode ApplicationMgr::sysStart ( )

inlineoverride

Definition at line 100 of file ApplicationMgr.h.

100{ return StatusCode::SUCCESS; }

◆ sysStop()

StatusCode ApplicationMgr::sysStop ( )

inlineoverride

Definition at line 102 of file ApplicationMgr.h.

102{ return StatusCode::SUCCESS; }

◆ targetFSMState()

Gaudi::StateMachine::State ApplicationMgr::targetFSMState ( ) const

override

Definition at line 814 of file ApplicationMgr.cpp.

814{ return m_targetState; }

◆ terminate()

StatusCode ApplicationMgr::terminate ( )

override

Definition at line 594 of file ApplicationMgr.cpp.

                                     {
  MsgStream log( m_messageSvc, name() );
 
  if ( m_state == Gaudi::StateMachine::OFFLINE ) {
    log << MSG::INFO << "Already Offline" << endmsg;
    return StatusCode::SUCCESS;
  }
  if ( m_state != Gaudi::StateMachine::CONFIGURED ) {
    log << MSG::FATAL << "terminate: Invalid state \"" << m_state << "\"" << endmsg;
    return StatusCode::FAILURE;
  }
  // release all Services
  m_targetState = Gaudi::StateMachine::OFFLINE;
 
  if ( m_returnCode.value() == Gaudi::ReturnCode::Success ) {
    log << MSG::INFO << "Application Manager Terminated successfully" << endmsg;
  } else if ( m_returnCode.value() == Gaudi::ReturnCode::ScheduledStop ) {
    log << MSG::INFO << "Application Manager Terminated successfully with a user requested ScheduledStop" << endmsg;
  } else {
    log << MSG::ERROR << "Application Manager Terminated with error code " << m_returnCode.value() << endmsg;
  }
 
  {
    auto& opts = m_svcLocator->getOptsSvc();
    // Force a disable the auditing of finalize for MessageSvc
    opts.set( "MessageSvc.AuditFinalize", "false" );
    // Force a disable the auditing of finalize for JobOptionsSvc
    opts.set( "JobOptionsSvc.AuditFinalize", "false" );
  }
 
  // if we have overriden it, restore the original ROOT error handler
  if ( s_originalRootErrorHandler ) {
    SetErrorHandler( s_originalRootErrorHandler );
    s_originalRootErrorHandler = nullptr;
  }
  // make sure ROOTErrorHandlerAdapter (if in use) does not try to use the MessageSvc we are about to delete
  s_messageSvcInstance = nullptr;
  // finalize MessageSvc
  auto svc = m_messageSvc.as<IService>();
  if ( !svc ) {
    log << MSG::ERROR << "Could not get the IService interface of the MessageSvc" << endmsg;
  } else {
    svc->sysFinalize().ignore();
    svcManager()->removeService( svc ).ignore();
  }
 
  // finalize JobOptionsSvc
  svc = m_svcLocator->service( "JobOptionsSvc" );
  if ( !svc ) {
    log << MSG::ERROR << "Could not get the IService interface of the JobOptionsSvc" << endmsg;
  } else {
    svc->sysFinalize().ignore();
    svcManager()->removeService( svc ).ignore();
  }
 
  m_state = m_targetState;
  return StatusCode::SUCCESS;
}

Member Data Documentation

◆ m_actHistory

Gaudi::Property<bool> ApplicationMgr::m_actHistory { this, "ActivateHistory", false, "Activate HistorySvc" }

protected

Definition at line 259 of file ApplicationMgr.h.

259{ this, "ActivateHistory", false, "Activate HistorySvc" };

◆ m_algManager

SmartIF<IAlgManager> ApplicationMgr::m_algManager

protected

Cached pointer to the manager of algorithms.

Definition at line 183 of file ApplicationMgr.h.

◆ m_appName

Gaudi::Property<std::string> ApplicationMgr::m_appName { this, "AppName", "ApplicationMgr", "The name of the application" }

protected

Definition at line 257 of file ApplicationMgr.h.

257{ this, "AppName", "ApplicationMgr", "The name of the application" };

◆ m_appVersion

Gaudi::Property<std::string> ApplicationMgr::m_appVersion { this, "AppVersion", {}, "The version of the application" }

protected

Definition at line 258 of file ApplicationMgr.h.

258{ this, "AppVersion", {}, "The version of the application" };

◆ m_auditAlgs

Gaudi::Property<bool> ApplicationMgr::m_auditAlgs { this, "AuditAlgorithms", false }

protected

Definition at line 279 of file ApplicationMgr.h.

279{ this, "AuditAlgorithms", false };

◆ m_auditSvcs

Gaudi::Property<bool> ApplicationMgr::m_auditSvcs { this, "AuditServices", false }

protected

Definition at line 278 of file ApplicationMgr.h.

278{ this, "AuditServices", false };

◆ m_auditTools

Gaudi::Property<bool> ApplicationMgr::m_auditTools { this, "AuditTools", false }

protected

Defaults for auditors.

Definition at line 277 of file ApplicationMgr.h.

277{ this, "AuditTools", false };

◆ m_classManager

SmartIF<DLLClassManager> ApplicationMgr::m_classManager

protected

Reference to the class manager.

Definition at line 188 of file ApplicationMgr.h.

◆ m_createSvcNameList

Gaudi::Property<std::vector<std::string> > ApplicationMgr::m_createSvcNameList

protected

Initial value:

{

this, "CreateSvc", {}, "List of extra services to be created" }

Definition at line 273 of file ApplicationMgr.h.

273 {

274 this, "CreateSvc", {}, "List of extra services to be created" };

◆ m_declaredManagers

Gaudi::Property<std::vector<std::string> > ApplicationMgr::m_declaredManagers

protected

Property to declare the list of known managers.

Definition at line 177 of file ApplicationMgr.h.

◆ m_dllNameList

Gaudi::Property<std::vector<std::string> > ApplicationMgr::m_dllNameList { this, "Dlls", {}, "List of DDL's names" }

protected

Definition at line 244 of file ApplicationMgr.h.

244{ this, "Dlls", {}, "List of DDL's names" };

◆ m_environment

Gaudi::Property<std::map<std::string, std::string> > ApplicationMgr::m_environment

protected

Initial value:

{

this, "Environment", {}, "Environment variables to set" }

Definition at line 281 of file ApplicationMgr.h.

281 {

282 this, "Environment", {}, "Environment variables to set" };

◆ m_eventLoopMgr

Gaudi::Property<std::string> ApplicationMgr::m_eventLoopMgr

protected

Initial value:

{ this, "EventLoop", "EventLoopMgr", "Processing manager type",

"Service:IEventProcessor" }

Definition at line 252 of file ApplicationMgr.h.

252 { this, "EventLoop", "EventLoopMgr", "Processing manager type",

253 "Service:IEventProcessor" };

◆ m_evtMax

Gaudi::Property<int> ApplicationMgr::m_evtMax { this, "EvtMax", -1, "Number of events to be processed (-1 means all events)" }

protected

Definition at line 238 of file ApplicationMgr.h.

238{ this, "EvtMax", -1, "Number of events to be processed (-1 means all events)" };

◆ m_evtsel

Gaudi::Property<std::string> ApplicationMgr::m_evtsel { this, "EvtSel", {}, "Event selection" }

protected

Definition at line 254 of file ApplicationMgr.h.

254{ this, "EvtSel", {}, "Event selection" };

◆ m_extSvcCreates

Gaudi::Property<bool> ApplicationMgr::m_extSvcCreates

protected

Initial value:

{ this, "ExtSvcCreates", true,

"LHCb (default) or ATLAS definition of \"ExtSvc\"" }

Definition at line 241 of file ApplicationMgr.h.

241 { this, "ExtSvcCreates", true,

242 "LHCb (default) or ATLAS definition of \"ExtSvc\"" };

◆ m_extSvcNameList

Gaudi::Property<std::vector<std::string> > ApplicationMgr::m_extSvcNameList

protected

Initial value:

{

this, "ExtSvc", {}, "List of external services names", "vector<Service>" }

Definition at line 239 of file ApplicationMgr.h.

239 {

240 this, "ExtSvc", {}, "List of external services names", "vector<Service>" };

◆ m_histPersName

Gaudi::Property<std::string> ApplicationMgr::m_histPersName { this, "HistogramPersistency", "NONE", "Name of the Hist Pers Svc" }

protected

Definition at line 255 of file ApplicationMgr.h.

255{ this, "HistogramPersistency", "NONE", "Name of the Hist Pers Svc" };

◆ m_jobOptionsPath

Gaudi::Property<std::string> ApplicationMgr::m_jobOptionsPath { this, "JobOptionsPath", {}, "The \"file\" to look for properties" }

protected

Definition at line 246 of file ApplicationMgr.h.

246{ this, "JobOptionsPath", {}, "The \"file\" to look for properties" };

◆ m_jobOptionsPostAction

Gaudi::Property<std::string> ApplicationMgr::m_jobOptionsPostAction

protected

Initial value:

{

this, "JobOptionsPreAction", {}, "additional command to run on config" }

Definition at line 249 of file ApplicationMgr.h.

249 {

250 this, "JobOptionsPreAction", {}, "additional command to run on config" };

◆ m_jobOptionsPreAction

Gaudi::Property<std::string> ApplicationMgr::m_jobOptionsPreAction

protected

Initial value:

{

this, "JobOptionsPostAction", {}, "additional command to run on config" }

Definition at line 247 of file ApplicationMgr.h.

247 {

248 this, "JobOptionsPostAction", {}, "additional command to run on config" };

◆ m_jobOptionsSvcType

Gaudi::Property<std::string> ApplicationMgr::m_jobOptionsSvcType

protected

Initial value:

{ this, "JobOptionsSvcType", "JobOptionsSvc", "JobOptionsSvc type",

"Service:Gaudi::Interfaces::IOptionsSvc" }

Definition at line 215 of file ApplicationMgr.h.

215 { this, "JobOptionsSvcType", "JobOptionsSvc", "JobOptionsSvc type",

216 "Service:Gaudi::Interfaces::IOptionsSvc" };

◆ m_jobOptionsType

Gaudi::Property<std::string> ApplicationMgr::m_jobOptionsType { this, "JobOptionsType", "FILE", "Source type (e.g. dbase, file...)" }

protected

Definition at line 245 of file ApplicationMgr.h.

245{ this, "JobOptionsType", "FILE", "Source type (e.g. dbase, file...)" };

◆ m_loopCheck

Gaudi::Property<bool> ApplicationMgr::m_loopCheck

protected

Initial value:

{ this, "InitializationLoopCheck", true,
                                     [this]( auto& ) { this->svcManager()->setLoopCheckEnabled( m_loopCheck ); },
                                     "For ServiceMgr initialization loop checking" }

Definition at line 284 of file ApplicationMgr.h.

                                 { this, "InitializationLoopCheck", true,
                                     [this]( auto& ) { this->svcManager()->setLoopCheckEnabled( m_loopCheck ); },
                                     "For ServiceMgr initialization loop checking" };

◆ m_managers

ManagersMap ApplicationMgr::m_managers

protected

Map of known component managers.

It contains (at least) the managers for IService and IAlgorithm. IAlgTool and IAuditor are not mandatory (but a missing manager for IAlgTool will probably not allow any job to run).

Definition at line 175 of file ApplicationMgr.h.

◆ m_messageSvc

SmartIF<IMessageSvc> ApplicationMgr::m_messageSvc

protected

Reference to the message service.

Definition at line 226 of file ApplicationMgr.h.

◆ m_messageSvcType

Gaudi::Property<std::string> ApplicationMgr::m_messageSvcType

protected

Initial value:

{ this, "MessageSvcType", "MessageSvc", "MessageSvc type",

"Service:IMessageSvc" }

Definition at line 213 of file ApplicationMgr.h.

213 { this, "MessageSvcType", "MessageSvc", "MessageSvc type",

214 "Service:IMessageSvc" };

◆ m_monitoringHub

Gaudi::Monitoring::Hub ApplicationMgr::m_monitoringHub

protected

Definition at line 232 of file ApplicationMgr.h.

◆ m_name

std::string ApplicationMgr::m_name = "ApplicationMgr"

protected

Name.

Definition at line 218 of file ApplicationMgr.h.

◆ m_okDlls

std::vector<std::string> ApplicationMgr::m_okDlls

private

names of successfully loaded dlls

Definition at line 310 of file ApplicationMgr.h.

◆ m_outputLevel

Gaudi::Property<int> ApplicationMgr::m_outputLevel { this, "OutputLevel", MSG::INFO, "Message output level" }

protected

Definition at line 256 of file ApplicationMgr.h.

256{ this, "OutputLevel", MSG::INFO, "Message output level" };

◆ m_outStreamNameList

Gaudi::Property<std::vector<std::string> > ApplicationMgr::m_outStreamNameList

protected

Initial value:

{

this, "OutStream", {}, &ApplicationMgr::evtLoopPropertyHandler, "List of output stream names" }

ApplicationMgr::evtLoopPropertyHandler

void evtLoopPropertyHandler(Gaudi::Details::PropertyBase &theProp)

Definition ApplicationMgr.cpp:860

Definition at line 211 of file ApplicationMgr.h.

211 {

212 this, "OutStream", {}, &ApplicationMgr::evtLoopPropertyHandler, "List of output stream names" };

◆ m_pluginDebugLevel

Gaudi::Property<int> ApplicationMgr::m_pluginDebugLevel

protected

Initial value:

{ this, "PluginDebugLevel", 0,
                                           [this]( auto& ) {
                                             
                                             if ( m_pluginDebugLevel.value() ) {
                                               MsgStream log( m_messageSvc, this->name() );
                                               log << MSG::INFO
                                                   << "Updating Gaudi::PluginService::SetDebug(level) to level="
                                                   << m_pluginDebugLevel.value() << endmsg;
                                             }
                                             Gaudi::PluginService::SetDebug( m_pluginDebugLevel );
                                           },
                                           "Debug level for the plugin system" }

Definition at line 260 of file ApplicationMgr.h.

                                               { this, "PluginDebugLevel", 0,
                                           [this]( auto& ) {
                                             // Setup debug level for the plugin system
                                             if ( m_pluginDebugLevel.value() ) {
                                               MsgStream log( m_messageSvc, this->name() );
                                               log << MSG::INFO
                                                   << "Updating Gaudi::PluginService::SetDebug(level) to level="
                                                   << m_pluginDebugLevel.value() << endmsg;
                                             }
                                             Gaudi::PluginService::SetDebug( m_pluginDebugLevel );
                                           },
                                           "Debug level for the plugin system" };

◆ m_printAlgsSequence

Gaudi::Property<bool> ApplicationMgr::m_printAlgsSequence

protected

Initial value:

{ this, "PrintAlgsSequence", false,

"Print the sequence of algorithms that have been loaded." }

Definition at line 300 of file ApplicationMgr.h.

300 { this, "PrintAlgsSequence", false,

301 "Print the sequence of algorithms that have been loaded." };

◆ m_processingMgr

SmartIF<IEventProcessor> ApplicationMgr::m_processingMgr

protected

Reference to processing manager object.

Definition at line 228 of file ApplicationMgr.h.

◆ m_propertiesPrint

Gaudi::Property<bool> ApplicationMgr::m_propertiesPrint

protected

Initial value:

{ this, "PropertiesPrint", false,

"Flag to activate the printout of properties" }

Definition at line 293 of file ApplicationMgr.h.

293 { this, "PropertiesPrint", false,

294 "Flag to activate the printout of properties" };

◆ m_queueingProcessor

SmartIF<IQueueingEventProcessor> ApplicationMgr::m_queueingProcessor

protected

Reference to a queueing processing manager object.

Definition at line 230 of file ApplicationMgr.h.

◆ m_returnCode

Gaudi::Property<int> ApplicationMgr::m_returnCode

protected

Initial value:

{ this, "ReturnCode", Gaudi::ReturnCode::Success,

"Return code of the application. Set internally in case of error conditions." }

Property to record the error conditions occurring during the running.

Definition at line 297 of file ApplicationMgr.h.

297 { this, "ReturnCode", Gaudi::ReturnCode::Success,

298 "Return code of the application. Set internally in case of error conditions." };

◆ m_runable

SmartIF<IRunable> ApplicationMgr::m_runable

protected

Reference to the runable object.

Definition at line 227 of file ApplicationMgr.h.

◆ m_runableType

Gaudi::Property<std::string> ApplicationMgr::m_runableType { this, "Runable", "AppMgrRunable", "Runable type", "Service:IRunable" }

protected

Definition at line 251 of file ApplicationMgr.h.

251{ this, "Runable", "AppMgrRunable", "Runable type", "Service:IRunable" };

◆ m_SIExit

Gaudi::Property<int> ApplicationMgr::m_SIExit

protected

Initial value:

{ this, "Exit", 0,
                                 [this]( auto& ) {
                                   finalize().ignore();
                                   terminate().ignore();
                                   ::exit( 0 );
                                 },
                                 "For SI's \"Exit\" command via callback" }

Definition at line 198 of file ApplicationMgr.h.

                                                  { this, "Exit", 0,
                                 [this]( auto& ) {
                                   finalize().ignore();
                                   terminate().ignore();
                                   ::exit( 0 );
                                 },
                                 "For SI's \"Exit\" command via callback" };

◆ m_SIGo

Gaudi::Property<int> ApplicationMgr::m_SIGo

protected

Initial value:

{ this, "Go", 0,
                               [this]( auto& ) {
                                 
                                 this->reinitialize().ignore();
                                 
                                 this->executeRun( m_evtMax ).ignore();
                               },
                               "For SI's \"Go\" command via callback" }

Definition at line 190 of file ApplicationMgr.h.

                                                { this, "Go", 0,
                               [this]( auto& ) {
                                 // Re-initialize everything
                                 this->reinitialize().ignore();
                                 // Execute a number of events
                                 this->executeRun( m_evtMax ).ignore();
                               },
                               "For SI's \"Go\" command via callback" };

◆ m_state

Gaudi::StateMachine::State ApplicationMgr::m_state = Gaudi::StateMachine::OFFLINE

protected

Internal State.

Definition at line 219 of file ApplicationMgr.h.

◆ m_stopOnSignal

Gaudi::Property<bool> ApplicationMgr::m_stopOnSignal

protected

Initial value:

{

this, "StopOnSignal", false, "Flag to enable/disable the signal handler that schedule a stop of the event loop" }

Property to enable/disable the "stop on signal" service.

See also: Gaudi::Utils::StopSignalHandler

Definition at line 290 of file ApplicationMgr.h.

290 {

291 this, "StopOnSignal", false, "Flag to enable/disable the signal handler that schedule a stop of the event loop" };

◆ m_svcLocator

SmartIF<ISvcLocator> ApplicationMgr::m_svcLocator

mutableprotected

Reference to its own service locator (must be instantiated prior to any service!).

Definition at line 186 of file ApplicationMgr.h.

◆ m_svcManager

SmartIF<ISvcManager> ApplicationMgr::m_svcManager

protected

Cached pointer to the manager of services.

Definition at line 180 of file ApplicationMgr.h.

◆ m_svcMapping

Gaudi::Property<std::vector<std::string> > ApplicationMgr::m_svcMapping { this, "SvcMapping", {}, "Default mapping of services" }

protected

Definition at line 222 of file ApplicationMgr.h.

222{ this, "SvcMapping", {}, "Default mapping of services" };

◆ m_svcOptMapping

Gaudi::Property<std::vector<std::string> > ApplicationMgr::m_svcOptMapping

protected

Initial value:

{

this, "SvcOptMapping", {}, "Default mapping of optional services" }

Definition at line 223 of file ApplicationMgr.h.

223 {

224 this, "SvcOptMapping", {}, "Default mapping of optional services" };

◆ m_targetState

Gaudi::StateMachine::State ApplicationMgr::m_targetState = Gaudi::StateMachine::OFFLINE

protected

Internal State.

Definition at line 220 of file ApplicationMgr.h.

◆ m_topAlgNameList

Gaudi::Property<std::vector<std::string> > ApplicationMgr::m_topAlgNameList

protected

Initial value:

{ this,
                                                              "TopAlg",
                                                              {},
                                                              &ApplicationMgr::evtLoopPropertyHandler,
                                                              "List of top level algorithms names",
                                                              "vector<Algorithm>" }

Definition at line 205 of file ApplicationMgr.h.

                                                      { this,
                                                              "TopAlg",
                                                              {},
                                                              &ApplicationMgr::evtLoopPropertyHandler,
                                                              "List of top level algorithms names",
                                                              "vector<Algorithm>" };

◆ m_useHiveAlgorithmManager

bool ApplicationMgr::m_useHiveAlgorithmManager

protected

Definition at line 307 of file ApplicationMgr.h.

◆ m_useMessageSvcForROOTMessages

Gaudi::Property<bool> ApplicationMgr::m_useMessageSvcForROOTMessages

protected

Initial value:

{ this, "UseMessageSvcForROOTMessages", true,

"Replace ROOT error handler with MessageSvc." }

Definition at line 303 of file ApplicationMgr.h.

303 { this, "UseMessageSvcForROOTMessages", true,

304 "Replace ROOT error handler with MessageSvc." };

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

GaudiCoreSvc/src/ApplicationMgr/ApplicationMgr.h
GaudiCoreSvc/src/ApplicationMgr/ApplicationMgr.cpp

Public Member Functions

Gaudi::Details::PropertyBase handlers

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ManagersMap

Constructor & Destructor Documentation

◆ ApplicationMgr()

Member Function Documentation

◆ algManager()

◆ configure()

◆ createEventContext()

◆ createSvcNameListHandler()

◆ decodeCreateSvcNameList()

◆ decodeDllNameList()

◆ decodeExtSvcNameList()

◆ dllNameListHandler()

◆ empty()

◆ evtLoopPropertyHandler()

◆ executeEvent()

◆ executeRun()

◆ extSvcNameListHandler()

◆ finalize()

◆ FSMState()

◆ getManager()

◆ GoToState()

◆ i_cast()

◆ i_delegateToEvtProc()

◆ i_startup()

◆ initialize()

◆ monitoringHub()

◆ name()

◆ nextEvent()

◆ outputLevelUpdate()

◆ pluginDebugPropertyHandler()

◆ pop()

◆ printAlgsSequences()

◆ push()

◆ reinitialize()

◆ restart()

◆ run()

◆ serviceLocator()

◆ setServiceManager()

◆ start()

◆ stop()

◆ stopRun()

◆ svcManager()

◆ sysFinalize()

◆ sysInitialize()

◆ sysReinitialize()

◆ sysRestart()

◆ sysStart()

◆ sysStop()

◆ targetFSMState()

◆ terminate()

Member Data Documentation

◆ m_actHistory

◆ m_algManager

◆ m_appName

◆ m_appVersion

◆ m_auditAlgs

◆ m_auditSvcs

◆ m_auditTools

◆ m_classManager

◆ m_createSvcNameList

◆ m_declaredManagers

◆ m_dllNameList

◆ m_environment

◆ m_eventLoopMgr

◆ m_evtMax

◆ m_evtsel

◆ m_extSvcCreates

◆ m_extSvcNameList

◆ m_histPersName

◆ m_jobOptionsPath

◆ m_jobOptionsPostAction

◆ m_jobOptionsPreAction

◆ m_jobOptionsSvcType

◆ m_jobOptionsType

◆ m_loopCheck