Gaudi.Application Class Reference

Gaudi application entry point. More...

#include <Gaudi/Application.h>

Inheritance diagram for Gaudi.Application:

Collaboration diagram for Gaudi.Application:

Public Types
using	Options = std::map< std::string, std::string >
using	Factory = Gaudi::PluginService::Factory< Application(Options)>

Public Member Functions
def	__init__ (self, opts, appType="Gaudi::Application")
def	create (cls, appType, opts)
def	run (self)
def	__del__ (self)
	Application (Options opts)
	Construct and configure the application from the provided options. More...
virtual	~Application ()
virtual int	run ()
	Implement the application main logic: More...
int	run (std::function< int(SmartIF< IStateful > &)> action)
	Run a user provided implementation of the application main logic. More...

Static Public Member Functions
static Factory::ReturnType	create (std::string_view type, Options opts)
	Factory function to instantiate a derived class via GaudiPluginService. More...

Protected Attributes
SmartIF< IStateful >	app
	Handle to the ApplicationMgr instance. More...

Private Attributes
	_impl

Detailed Description

Gaudi application entry point.

Gaudi::Application can be used to bootstrap a standard Gaudi application or to implement custom applications, either via a specialization that overrides the method run (which can be instantiated either directly or via the GaudiPluginService, with the helper create) or by passing a callable object to the dedicated run method.

Definition at line 62 of file __init__.py.

Member Typedef Documentation

using Gaudi.Application::Factory = Gaudi::PluginService::Factory<Application( Options )>

Definition at line 20 of file Application.h.

using Gaudi.Application::Options = std::map<std::string, std::string>

Definition at line 19 of file Application.h.

Constructor & Destructor Documentation

def Gaudi.Application.__init__	(		self,
			opts,
			appType = "Gaudi::Application"
	)

Definition at line 63 of file __init__.py.

    def __init__(self, opts, appType="Gaudi::Application"):
        global _GaudiKernelLib
        if _GaudiKernelLib is None:
            # FIXME: note that we need PyDLL instead of CDLL if the calls to
            #        Python functions are not protected with the GIL.
            gkl = _GaudiKernelLib = ctypes.PyDLL(
                'libGaudiKernel.so', mode=ctypes.RTLD_GLOBAL)
            gkl._py_Gaudi__Application__create.restype = ctypes.c_void_p
            gkl._py_Gaudi__Application__run.argtypes = [ctypes.c_void_p]
            gkl._py_Gaudi__Application__run.restype = ctypes.c_int
            gkl._py_Gaudi__Application__delete.argtypes = [ctypes.c_void_p]

        c_opts = (c_opt_t * len(opts))()
        for idx, item in enumerate(opts.items()):
            c_opts[idx].key, c_opts[idx].value = item

        self._impl = _GaudiKernelLib._py_Gaudi__Application__create(
            appType, c_opts, ctypes.c_long(len(c_opts)))

def Gaudi.Application.__del__

(

self

)

Definition at line 89 of file __init__.py.

    def __del__(self):
        _GaudiKernelLib._py_Gaudi__Application__delete(self._impl)

Gaudi.Application::Application

(

Options

opts

)

Construct and configure the application from the provided options.

Definition at line 41 of file Application.cpp.

                                                               {
  // # Prepare the application
  // - instantiate
  app = Gaudi::createApplicationMgr();
  GAUDI_ASSERT_THROW_NAME( app, "failure instantiating ApplicationMgr", "Gaudi::Application" );

  // - main configuration
  consumeOptions( app.as<IProperty>(), options );
  // - start minimal services
  GAUDI_ASSERT_THROW_NAME( app->configure(), "failure creating basic services", "Gaudi::Application" );

  consumeOptions( SmartIF<IMessageSvc>{app}.as<IProperty>(), options );

  // - prepare job configuration
  {
    auto sloc = app.as<ISvcLocator>();
    auto jos  = sloc->service<IJobOptionsSvc>( "JobOptionsSvc" );
    std::for_each( begin( options ), end( options ), [&jos]( const auto& item ) {
      std::string_view name    = item.first;
      const auto       sep_pos = name.find_last_of( '.' );
      std::string_view client  = name.substr( 0, sep_pos );
      name.remove_prefix( sep_pos + 1 );
      jos->addPropertyToCatalogue( std::string{client}, Gaudi::Property<std::string>{std::string{name}, item.second} );
    } );
  }
}

Gaudi.Application::~Application ( )

virtual

Definition at line 68 of file Application.cpp.

{ app->terminate().ignore(); }

Member Function Documentation

Gaudi::Application::Factory::ReturnType Gaudi.Application::create ( std::string_view  type, Options  opts  )

static

Factory function to instantiate a derived class via GaudiPluginService.

Definition at line 36 of file Application.cpp.

                                                                                              {
  if ( type == "Gaudi::Application" ) { return std::make_unique<Application>( std::move( opts ) ); }
  return Factory::create( type, std::move( opts ) );
}

def Gaudi.Application.create	(		cls,
			appType,
			opts
	)

Definition at line 83 of file __init__.py.

    def create(cls, appType, opts):
        return cls(opts, appType=appType)

int Gaudi.Application::run ( )

virtual

Implement the application main logic:

• prepare for processing (initialize + start)
• loop over events
• terminate (stop + finalize)

Definition at line 70 of file Application.cpp.

                          {
  auto prop      = app.as<IProperty>();
  auto processor = app.as<IEventProcessor>();

  Gaudi::Property<int> evtMax;
  evtMax.assign( prop->getProperty( "EvtMax" ) );

  // - get ready to process events
  if ( app->initialize() ) {
    if ( app->start() ) {
      // - main processing loop
      if ( !processor->executeRun( evtMax ) ) setAppReturnCode( prop, Gaudi::ReturnCode::GenericFailure );

      app->stop().ignore();
    } else
      setAppReturnCode( prop, Gaudi::ReturnCode::GenericFailure );
    app->finalize().ignore();
  } else
    setAppReturnCode( prop, Gaudi::ReturnCode::GenericFailure );
  return getAppReturnCode( prop );
}

int Gaudi.Application.run ( std::function< int(SmartIF< IStateful > &)>  action )

inline

Run a user provided implementation of the application main logic.

Definition at line 36 of file Application.h.

{ return action( app ); }

def Gaudi.Application.run

(

self

)

Definition at line 86 of file __init__.py.

    def run(self):
        return _GaudiKernelLib._py_Gaudi__Application__run(self._impl)

Member Data Documentation

Gaudi.Application._impl

private

Definition at line 79 of file __init__.py.

SmartIF<IStateful> Gaudi.Application::app

protected

Handle to the ApplicationMgr instance.

Definition at line 40 of file Application.h.

---

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

• Gaudi/python/Gaudi/__init__.py
• GaudiKernel/Gaudi/Application.h
• GaudiKernel/src/Lib/Application.cpp