LCOV - code coverage report
Current view: top level - HLT/ZDC - AliHLTZDCAgent.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 1 100.0 %
Date: 2016-06-14 17:26:59 Functions: 1 8 12.5 %

          Line data    Source code
       1             : //-*- Mode: C++ -*-
       2             : // $Id$
       3             : 
       4             : #ifndef ALIHLTZDCAGENT_H
       5             : #define ALIHLTZDCAGENT_H
       6             : 
       7             : /* This file is property of and copyright by the ALICE HLT Project        * 
       8             :  * ALICE Experiment at CERN, All rights reserved.                         *
       9             :  * See cxx source for full Copyright notice                               */
      10             : 
      11             : /** @file    AliHLTZDCAgent.h
      12             :     @author Chiara Oppedisano <Chiara.Oppedisano@to.infn.it>
      13             :     @brief   Agent of the libAliHLTZDC library
      14             : */
      15             : 
      16             : // see below for class documentation
      17             : // or
      18             : // refer to README to build package
      19             : // or
      20             : // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
      21             : 
      22             : #include "AliHLTModuleAgent.h"
      23             : 
      24             : /**
      25             :  * @class AliHLTZDCAgent
      26             :  * This is the agent for the AliHLTZDC library.<br>
      27             :  *
      28             :  * The sample agent implements all interface function provided by @ref
      29             :  * AliHLTModuleAgent :
      30             :  * - CreateConfigurations() <br>
      31             :  *   The method gets an instance of the AliHLTConfigurationHanler to add
      32             :  *   configurations, e.g. 
      33             :  *   <pre>
      34             :  *   handler->CreateConfiguration("my-puplisher"  , "FilePublisher", NULL , "data.bin");
      35             :  *   ...
      36             :  *   handler->CreateConfiguration("my-analysis-chain"  , "FileWriter", "my-processor" , "my arguments");
      37             :  *   </pre>
      38             :  * - GetReconstructionChains() <br>
      39             :  *   returns a string of blank separated configurations to be run during
      40             :  *   local event reconstruction.
      41             :  *   <pre>
      42             :  *   return "my-data-sink my-analysis-chain";
      43             :  *   </pre>
      44             :  * - GetRequiredComponentLibraries() <br>
      45             :  *   returns a string of blank separated libraries which have to be loaded
      46             :  *   in addition in order to load all required components. <br>
      47             :  *   @note Not the right place for library dependencies.
      48             :  *   <pre>
      49             :  *   return "libAliHLTUtil.so";
      50             :  *   </pre>
      51             :  * - RegisterComponents() <br>
      52             :  *   registers the components: AliHLTDummyComponent, AliHLTSampleComponent1,
      53             :  *   AliHLTSampleComponent2, and AliHLTSampleMonitoringComponent<br>
      54             :  * - GetHandlerDescription() <br>
      55             :  *   Handles HLTOUT data blocks of type {DDL_RAW,SMPL}
      56             :  *   <pre>
      57             :  *   if (dt==(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginSample)) {
      58             :  *     desc=AliHLTOUTHandlerDesc(kRawReader, dt, GetModuleId());
      59             :  *     return 1;
      60             :  *   }
      61             :  *   </pre>
      62             :  * - GetOutputHandler() <br>
      63             :  *   Returns handler AliHLTOUTHandlerEquId for HLTOUT data blocks of
      64             :  *   type {DDL_RAW,SMPL}
      65             :  *   <pre>
      66             :  *   if (dt==(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginSample)) {
      67             :  *     return new AliHLTOUTHandlerEquId;
      68             :  *   }
      69             :  *   </pre>
      70             :  * - DeleteOutputHandler() <br>
      71             :  *   Deletes the output handler. In this case there is no special handling
      72             :  *   needed.
      73             :  *
      74             :  * In order to hook the sample library up to the HLT system on global object
      75             :  * @ref gAliHLTZDCAgent of the agent is defined in the source code.
      76             :  * 
      77             :  * @ingroup alihlt_system
      78             :  */
      79             : class AliHLTZDCAgent : public AliHLTModuleAgent {
      80             :  public:
      81             : 
      82             :   /**
      83             :    * standard constructor. The agent is automatically registered in the
      84             :    * global agent manager
      85             :    */
      86             :   AliHLTZDCAgent();
      87             :   
      88             : /** destructor */
      89             :   virtual ~AliHLTZDCAgent();
      90             : 
      91             :   UInt_t GetDetectorMask() const;
      92             : 
      93             :   /**
      94             :    * Register all configurations belonging to the ZDC library with the
      95             :    * AliHLTConfigurationHandler. 
      96             :    * @param handler   [in] the configuration handler
      97             :    * @param rawReader [in] AliRoot RawReader instance 
      98             :    * @param runloader [in] AliRoot runloader
      99             :    * @return neg. error code if failed
     100             :    */
     101             :   int CreateConfigurations(AliHLTConfigurationHandler* handler,
     102             :                            AliRawReader* rawReader=NULL,
     103             :                            AliRunLoader* runloader=NULL) const;
     104             : 
     105             :   /**
     106             :    * Get the top configurations for local event reconstruction.
     107             :    * A top configuration describes a processing chain. It can simply be
     108             :    * described by the last configuration(s) in the chain. 
     109             :    * @param rawReader [in] AliRoot RawReader instance 
     110             :    * @param runloader [in] AliRoot runloader
     111             :    * @return string containing the top configurations separated by blanks
     112             :    */
     113             :   const char* GetReconstructionChains(AliRawReader* rawReader=NULL,
     114             :                                       AliRunLoader* runloader=NULL) const;
     115             : 
     116             :   /**
     117             :    * Component libraries which the configurations of this agent depend on.
     118             :    * @return list of component libraries as a blank-separated string.
     119             :    */
     120             :   const char* GetRequiredComponentLibraries() const;
     121             : 
     122             :   /**
     123             :    * Register components for the AliHLTZDC library.
     124             :    * @param pHandler  [in] instance of the component handler          
     125             :    */
     126             :   int RegisterComponents(AliHLTComponentHandler* pHandler) const;
     127             :   
     128             :   /** interface function, see @ref AliHLTModuleAgent for description */
     129             :   int GetHandlerDescription(AliHLTComponentDataType dt,
     130             :                             AliHLTUInt32_t spec,
     131             :                             AliHLTOUTHandlerDesc& desc) const;
     132             : 
     133             :   /** interface function, see @ref AliHLTModuleAgent for description */
     134             :   AliHLTOUTHandler* GetOutputHandler(AliHLTComponentDataType dt, AliHLTUInt32_t spec);
     135             :   
     136             :   /** interface function, see @ref AliHLTModuleAgent for description */                              
     137             :   int DeleteOutputHandler(AliHLTOUTHandler* pInstance);
     138             : 
     139             :   /** interface function, see @ref AliHLTModuleAgent for description */
     140             :   AliHLTModulePreprocessor* GetPreprocessor();
     141             : 
     142             :  private:
     143             :   /** copy constructor prohibited */
     144             :   AliHLTZDCAgent(const AliHLTZDCAgent&);
     145             : 
     146             :   /** assignment operator prohibited */
     147             :   AliHLTZDCAgent& operator=(const AliHLTZDCAgent&);
     148             : 
     149             :   /** ROOT specific member definition */
     150           6 :   ClassDef(AliHLTZDCAgent, 0);
     151             : };
     152             : 
     153             : #endif

Generated by: LCOV version 1.11