Line data    Source code

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