Gaudi.Application Class Reference

Gaudi application entry point. More...

#include </builds/gaudi/Gaudi/GaudiKernel/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 87 of file __init__.py.

Member Typedef Documentation

Factory

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

Definition at line 30 of file Application.h.

Options

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

Definition at line 29 of file Application.h.

Constructor & Destructor Documentation

__init__()

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

Definition at line 88 of file __init__.py.

    def __init__(self, opts, appType="Gaudi::Application"):
        global _GaudiKernelLib
        if _GaudiKernelLib is None:
            # Note: using CDLL instead of PyDLL means that every call to the Python C
            #       API must be protected acquiring the GIL
            #
            if sys.platform == "darwin":
                # LD_LIBRARY_PATH cannot be used for dlopen on macos;
                # use custom variable GAUDI_PLUGIN_PATH instead
                _libpaths = os.environ.get("GAUDI_PLUGIN_PATH")
                if not _libpaths:
                    print("WARNING: GAUDI_PLUGIN_PATH is empty!")
                for _path in _libpaths.split(":"):
                    _lib = os.path.join(_path, "libGaudiKernel.dylib")
                    if os.path.isfile(_lib):
                        gkl = _GaudiKernelLib = ctypes.CDLL(
                            _lib,
                            mode=ctypes.RTLD_GLOBAL,
                        )
            else:
                gkl = _GaudiKernelLib = ctypes.CDLL(
                    "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 = item[0].encode("ascii")
            c_opts[idx].value = item[1].encode("ascii")
 
        self._impl = _GaudiKernelLib._py_Gaudi__Application__create(
            appType.encode("ascii"), c_opts, ctypes.c_ulong(len(c_opts))
        )
 

__del__()

def Gaudi.Application.__del__

(

self

)

Definition at line 133 of file __init__.py.

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

Application()

Gaudi.Application::Application

(

Options

opts

)

Construct and configure the application from the provided options.

Definition at line 52 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->getOptsSvc();
    for ( const auto& [name, value] : options ) jos.set( name, value );
  }
}

~Application()

Gaudi.Application::~Application ( )

virtual

Definition at line 73 of file Application.cpp.

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

Member Function Documentation

create() [1/2]

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

Definition at line 127 of file __init__.py.

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

create() [2/2]

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 47 of file Application.cpp.

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

run() [1/3]

int Gaudi.Application::run ( )

virtual

Implement the application main logic:

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

Reimplemented in Gaudi::TestSuite::QueueingApplication.

Definition at line 75 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 ).ignore();
 
      app->stop().ignore();
    } else
      setAppReturnCode( prop, Gaudi::ReturnCode::GenericFailure ).ignore();
    app->finalize().ignore();
  } else
    setAppReturnCode( prop, Gaudi::ReturnCode::GenericFailure ).ignore();
  return getAppReturnCode( prop );
}

run() [2/3]

def Gaudi.Application.run

(

self

)

Definition at line 130 of file __init__.py.

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

run() [3/3]

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

inline

Run a user provided implementation of the application main logic.

Definition at line 46 of file Application.h.

{ return action( app ); }

Member Data Documentation

_impl

Gaudi.Application._impl

private

Definition at line 122 of file __init__.py.

app

SmartIF<IStateful> Gaudi.Application::app

protected

Handle to the ApplicationMgr instance.

Definition at line 50 of file Application.h.

---

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

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