Line data    Source code

       1             : //-*- Mode: C++ -*-
       2             : // $Id$
       3             : 
       4             : #ifndef ALIHLTTRDAGENT_H
       5             : #define ALIHLTTRDAGENT_H
       6             : //* This file is property of and copyright by the ALICE HLT Project        * 
       7             : //* ALICE Experiment at CERN, All rights reserved.                         *
       8             : //* See cxx source for full Copyright notice                               *
       9             : 
      10             : /** @file   AliHLTTRDAgent.h
      11             :     @author Matthias Richter
      12             :     @date   
      13             :     @brief  Agent of the libAliHLTTRD library
      14             : */
      15             : 
      16             : #include "AliHLTModuleAgent.h"
      17             : #include "AliHLTOUTHandlerEquId.h"
      18             : 
      19             : class AliHLTOUTHandlerChain;
      20             : 
      21             : /**
      22             :  * @class AliHLTTRDAgent
      23             :  * This is the agent for the AliHLTTRD library.
      24             :  *
      25             :  * @ingroup alihlt_system
      26             :  */
      27             : class AliHLTTRDAgent : public AliHLTModuleAgent {
      28             :  public:
      29             :   /**
      30             :    * standard constructor. The agent is automatically registered in the
      31             :    * global agent manager
      32             :    */
      33             :   AliHLTTRDAgent();
      34             :   /** destructor */
      35             :   virtual ~AliHLTTRDAgent();
      36             : 
      37             :   UInt_t GetDetectorMask() const;
      38             : 
      39             :   /**
      40             :    * Register all configurations belonging to this module with the
      41             :    * AliHLTConfigurationHandler. The agent can adapt the configurations
      42             :    * to be registered to the current AliRoot setup by checking the
      43             :    * runloader.
      44             :    * @param handler      the configuration handler
      45             :    * @param rawReader    AliRawReader instance
      46             :    * @param runloader    AliRoot runloader
      47             :    * @return neg. error code if failed
      48             :    */
      49             :   int CreateConfigurations(AliHLTConfigurationHandler* handler,
      50             :                            AliRawReader* rawReader=NULL,
      51             :                            AliRunLoader* runloader=NULL) const;
      52             : 
      53             :   /**
      54             :    * Get the top configurations belonging to this module.
      55             :    * A top configuration describes a processing chain. It can simply be
      56             :    * described by the last configuration(s) in the chain. 
      57             :    * The agent can adapt the configurations to be registered to the current
      58             :    * AliRoot setup by checking the runloader.
      59             :    * @param rawReader    AliRawReader instance
      60             :    * @param runloader    AliRoot runloader
      61             :    * @return number of configurations, neg. error code if failed
      62             :    */
      63             :   const char* GetReconstructionChains(AliRawReader* rawReader=NULL,
      64             :                                       AliRunLoader* runloader=NULL) const;
      65             : 
      66             :   /**
      67             :    * Component libraries which the configurations of this agent depend on.
      68             :    * @return list of component libraries as a blank-separated string.
      69             :    */
      70             :   const char* GetRequiredComponentLibraries() const;
      71             : 
      72             :   /**
      73             :    * Register components for the AliHLTTRD library.
      74             :    * @param [in] pHandler  instance of the component handler          
      75             :    */
      76             :   int RegisterComponents(AliHLTComponentHandler* pHandler) const;
      77             : 
      78             :   /**
      79             :    * Get handler decription for TRD data in the HLTOUT data stream.
      80             :    * @param [in]  dt        data type of the block
      81             :    * @param [in]  spec      specification of the block
      82             :    * @param [out] desc      handler description
      83             :    * @return 1 if the agent can provide a handler, 0 if not
      84             :    */
      85             :   int GetHandlerDescription(AliHLTComponentDataType dt,
      86             :                             AliHLTUInt32_t spec,
      87             :                             AliHLTOUTHandlerDesc& desc) const;
      88             : 
      89             :   /**
      90             :    * Get specific handler for TRD data in the HLTOUT data stream.
      91             :    * @param [in] dt        data type of the block
      92             :    * @param [in] spec      specification of the block
      93             :    * @return pointer to handler
      94             :    */
      95             :   AliHLTOUTHandler* GetOutputHandler(AliHLTComponentDataType dt,
      96             :                                      AliHLTUInt32_t spec);
      97             : 
      98             :   /**
      99             :    * Delete an HLTOUT handler.
     100             :    * @param pInstance      pointer to handler
     101             :    */
     102             :   int DeleteOutputHandler(AliHLTOUTHandler* pInstance);
     103             : 
     104             :  protected:
     105             : 
     106             :  private:
     107             :   /** copy constructor prohibited */
     108             :   AliHLTTRDAgent(const AliHLTTRDAgent&);
     109             :   /** assignment operator prohibited */
     110             :   AliHLTTRDAgent& operator=(const AliHLTTRDAgent&);
     111             : 
     112             :   /** handler for TRD raw data in the HLTOUT stream */
     113             :   AliHLTOUTHandlerEquId* fRawDataHandler; //!transient
     114             : 
     115           6 :   ClassDef(AliHLTTRDAgent, 0);
     116             : };
     117             : 
     118             : #endif