e4329d96659bcdba214ff22cafaa387ba9f040b8
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLT_C_Component_WrapperInterface.cxx
1 // $Id$
2
3 /**************************************************************************
4  * This file is property of and copyright by the ALICE HLT Project        * 
5  * ALICE Experiment at CERN, All rights reserved.                         *
6  *                                                                        *
7  * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
8  *                  Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
9  *                  for The ALICE HLT Project.                            *
10  *                                                                        *
11  * Permission to use, copy, modify and distribute this software and its   *
12  * documentation strictly for non-commercial purposes is hereby granted   *
13  * without fee, provided that the above copyright notice appears in all   *
14  * copies and that both the copyright notice and this permission notice   *
15  * appear in the supporting documentation. The authors make no claims     *
16  * about the suitability of this software for any purpose. It is          *
17  * provided "as is" without express or implied warranty.                  *
18  **************************************************************************/
19
20 /** @file   AliHLT_C_Component_WrapperInterface.cxx
21     @author Matthias Richter, Timm Steinbeck
22     @date   
23     @brief  Pure C interface to the AliRoot HLT component handler
24 */
25
26 #if __GNUC__>= 3
27 using namespace std;
28 #endif
29
30 #include "AliHLT_C_Component_WrapperInterface.h"
31 #include "AliHLTComponentHandler.h"
32 #include "AliHLTComponent.h"
33 #include <errno.h>
34
35 static AliHLTComponentHandler *gComponentHandler_C = NULL;
36
37
38 int AliHLT_C_Component_InitSystem( AliHLTComponentEnvironment* environ )
39 {
40   if ( gComponentHandler_C )
41     {
42       return EINPROGRESS;
43     }
44   gComponentHandler_C = new AliHLTComponentHandler(environ);
45   if ( !gComponentHandler_C )
46     return EFAULT;
47   gComponentHandler_C->InitAliLogTrap(gComponentHandler_C);
48   gComponentHandler_C->AnnounceVersion();
49   return 0;
50 }
51
52 int AliHLT_C_Component_DeinitSystem()
53 {
54   if ( gComponentHandler_C )
55     {
56       delete gComponentHandler_C;
57       gComponentHandler_C = NULL;
58     }
59   return 0;
60 }
61
62 int AliHLT_C_Component_LoadLibrary( const char* libraryPath )
63 {
64   if ( !gComponentHandler_C )
65     return ENXIO;
66   return gComponentHandler_C->LoadLibrary( libraryPath );
67 }
68
69 int AliHLT_C_Component_UnloadLibrary( const char* /*libraryPath*/ )
70 {
71   if ( !gComponentHandler_C )
72     return ENXIO;
73   // Matthias 26.10.2007
74   // Unloading of libraries has to be re-worked. It has been commented out here
75   // since the libraries will be unloaded at the destruction of the component
76   // handler instance anyway. So it has no effect to the operation in PubSub.
77   // With the introduction of the dynamic component registration via module
78   // agents we run into trouble when cleaning up the samples managed by the
79   // component handler. Destruction of the sample objects is done AFTER
80   // unloading of the library and thus the destructor is not present any 
81   // more.
82   //return gComponentHandler_C->UnloadLibrary( libraryPath );
83   return 0;
84 }
85
86 int AliHLT_C_CreateComponent( const char* componentType, void* environ_param, int argc, const char** argv, AliHLTComponentHandle* handle )
87 {
88   if ( !gComponentHandler_C )
89     return ENXIO;
90   if ( !handle ) return EINVAL;
91   AliHLTComponent* comp;
92   int ret = gComponentHandler_C->CreateComponent( componentType, environ_param, argc, argv, comp );
93   if (comp) {
94     const char* cdbPath = getenv("ALIHLT_HCDBDIR");
95     if (!cdbPath) cdbPath = getenv("ALICE_ROOT");
96     if (cdbPath) comp->InitCDB(cdbPath);
97   }
98   *handle = reinterpret_cast<AliHLTComponentHandle>( comp );
99
100   return ret;
101 }
102
103 void AliHLT_C_DestroyComponent( AliHLTComponentHandle handle )
104 {
105   if ( !handle )
106     return;
107   
108   AliHLTComponent* pComp=reinterpret_cast<AliHLTComponent*>( handle );
109   pComp->Deinit();
110   delete pComp;
111 }
112
113 int AliHLT_C_ProcessEvent( AliHLTComponentHandle handle, const AliHLTComponent_EventData* evtData, const AliHLTComponent_BlockData* blocks, 
114                            AliHLTComponent_TriggerData* trigData, AliHLTUInt8_t* outputPtr,
115                            AliHLTUInt32_t* size, AliHLTUInt32_t* outputBlockCnt, 
116                            AliHLTComponent_BlockData** outputBlocks,
117                            AliHLTComponent_EventDoneData** edd )
118 {
119   if ( !handle )
120     return ENXIO;
121   AliHLTComponent* comp = reinterpret_cast<AliHLTComponent*>( handle );
122   return comp->ProcessEvent( *evtData, blocks, *trigData, outputPtr, *size, *outputBlockCnt, *outputBlocks, *edd );
123 }
124
125 int AliHLT_C_GetOutputDataType( AliHLTComponentHandle handle, AliHLTComponent_DataType* dataType )
126 {
127   if ( !handle )
128     return ENXIO;
129   AliHLTComponent* comp = reinterpret_cast<AliHLTComponent*>( handle );
130   *dataType = comp->GetOutputDataType();
131   return 0;
132 }
133
134 int AliHLT_C_GetOutputSize( AliHLTComponentHandle handle, unsigned long* constBase, double* inputMultiplier )
135 {
136   if ( !handle )
137     return ENXIO;
138   AliHLTComponent* comp = reinterpret_cast<AliHLTComponent*>( handle );
139   comp->GetOutputDataSize( *constBase, *inputMultiplier );
140   return 0;
141 }