+//-*- Mode: C++ -*-
// @(#) $Id$
#ifndef ALIHLTCOMPONENTHANDLER_H
@note The handler is part of the interface and both used in the
Online (PubSub) and Offline (AliRoot) context.
*/
-
+
+// see below for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
#include <vector>
//#include "TObject.h"
#include "AliHLTLogging.h"
class AliHLTComponent;
+class AliHLTModuleAgent;
struct AliHLTComponentEnvironment;
struct AliHLTComponentDataType;
AliHLTComponentHandler();
/** constructor */
AliHLTComponentHandler(AliHLTComponentEnvironment* pEnv);
- /** not a valid copy constructor, defined according to effective C++ style */
- AliHLTComponentHandler(const AliHLTComponentHandler&);
- /** not a valid assignment op, but defined according to effective C++ style */
- AliHLTComponentHandler& operator=(const AliHLTComponentHandler&);
/** destructor */
virtual ~AliHLTComponentHandler();
+ /**
+ * Library mode.
+ * - kDynamic: library can be unloaded (unload forced at termination of the
+ * handler
+ * - kStatic: library persistent, once loaded it stays
+ */
+ enum TLibraryMode {kDynamic, kStatic};
+
/**
* Set the environment for the HLT framework.
* The environment mainly consists of function pointers for the integration
*/
void SetEnvironment(AliHLTComponentEnvironment* pEnv);
+ /**
+ * Set library mode.
+ * The mode effects all loaded libraries until another mode is set.
+ * @param mode persistent library or not
+ * @return previous mode
+ */
+ TLibraryMode SetLibraryMode(TLibraryMode mode);
+
/**
* Load a component shared library.
* The component library needs to be loaded from the ComponentHanler in order
* handler. The object has to be valid during the whole runtime and should
* thus be a global object which is ONLY used for the purpose of registration.
* This also ensures automatically registration at library load time.
- * @param libraryPath const char string containing the library name/path
+ * @param libraryPath const char string containing the library name/path
+ * @param bActivateAgents activate agents after loading (@ref ActivateAgents)
* @return 0 if succeeded, neg. error code if failed
*/
- int LoadLibrary( const char* libraryPath );
+ int LoadLibrary( const char* libraryPath, int bActivateAgents=1);
/**
* Find a symbol in a dynamically loaded library.
* Registration is done by passing a sample object of the component to the
* handler. The object has to be valid during the whole runtime and should
* thus be a global object which is ONLY used for the purpose of registration.
- * @param pSample a sample object of the component
+ * @param pSample a sample object of the component
* @return neg. error code if failed
*/
- int RegisterComponent(AliHLTComponent* pSample );
+ int RegisterComponent(AliHLTComponent* pSample);
+
+ /**
+ * Add a component and leave control of the sample object to the handler.
+ * Exactly the same functionality as @ref RegisterComponent but deletes
+ * the sample object at clean-up of the handler.
+ * @param pSample a sample object of the component
+ * @return neg. error code if failed
+ */
+ int AddComponent(AliHLTComponent* pSample);
/**
* Registers all scheduled components.
/**
*/
- int DeleteStandardComponents();
+ int DeleteOwnedComponents();
/**
* Find the ID of a component with the given output data.
return CreateComponent( componentID, pEnvParam, 0, NULL, component );
}
+ /**
+ * Check if a registered component has output data, e.g. is of type
+ * kSource or kProcessor (see @ref AliHLTComponent::TComponentType).
+ * @param componentID ID of the component to create
+ * @return 1 if component has output data, 0 if not <br>
+ * -ENOENT if component does not exist
+ */
+ int HasOutputData( const char* componentID);
+
/**
* Print registered components to stdout.
* @return none
*/
int AnnounceVersion();
- protected:
-
- private:
/**
* Find a component.
* @param componentID ID of the component to find
*/
int FindComponentIndex(const char* componentID);
+ protected:
+
+ private:
+ /** copy constructor prohibited */
+ AliHLTComponentHandler(const AliHLTComponentHandler&);
+ /** assignment operator prohibited */
+ AliHLTComponentHandler& operator=(const AliHLTComponentHandler&);
+
/**
* Find a component.
* @param componentID ID of the component to find
int UnloadLibraries();
/**
- * Compount descriptor for component libraries
+ * Activate all module agents with this component handler.
+ * The function loops over all available module agents and activates
+ * each agent with this component handler. During activation, the
+ * dynamic component registration is carried out by the agents version
+ * of @ref AliHLTModuleAgent::RegisterComponents
+ * @param blackList array of agents which should be excluded
+ * @param size array size
+ */
+ int ActivateAgents(const AliHLTModuleAgent** blackList=NULL, int size=0);
+
+ /**
+ * Compound descriptor for component libraries
*/
struct AliHLTLibHandle {
- AliHLTLibHandle() : fHandle(NULL), fName(NULL) {}
+ AliHLTLibHandle() : fHandle(NULL), fName(NULL), fMode(kDynamic) {}
/** dlopen handle */
void* fHandle; //! transient
/** name of the library, casted to TString* before use */
void* fName; //! transient
+ /** library mode: kStatic means never unloaded */
+ TLibraryMode fMode; //! transient
};
/**
vector<AliHLTLibHandle> fLibraryList; // see above
/** running environment for the component */
AliHLTComponentEnvironment fEnvironment; // see above
- /** list of standard components */
- vector<AliHLTComponent*> fStandardList; // see above
+ /** list of owned components, deleted at termination of the handler */
+ vector<AliHLTComponent*> fOwnedComponents; // see above
+ /** library mode effects all loaded libraries until a new mode is set */
+ TLibraryMode fLibraryMode; // see above
ClassDef(AliHLTComponentHandler, 0);