bugfix: correct range of DDL for specified detector
[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  Old C interface to the AliRoot HLT component handler
24 //  @note   This interface is deprecated, the new interface is defined
25 //          in HLT/BASE/AliHLTExternalInterface
26
27 #if __GNUC__>= 3
28 using namespace std;
29 #endif
30
31 #include "AliHLT_C_Component_WrapperInterface.h"
32 #include "AliHLTComponentHandler.h"
33 #include "AliHLTComponent.h"
34 #include "AliHLTMisc.h"
35 #include <errno.h>
36
37 static AliHLTComponentHandler *gComponentHandler_C = NULL;
38 static AliHLTRunDesc gRunDesc=kAliHLTVoidRunDesc;
39 static char* gRunType=NULL;
40
41 int AliHLT_C_Component_InitSystem( AliHLTComponentEnvironment* comenv )
42 {
43   // init the HLT system
44   if ( gComponentHandler_C )
45     {
46       return EINPROGRESS;
47     }
48
49   // July 2008  
50   // Due to a bug in the SimpleComponentWrapper and AliRootWrapperSubscriber
51   // the fStructSize member was never initialized and we can not use this
52   // method of synchronizing different versions.
53   // This interface is now deprecated, only kept for backward compatibility.
54   // All function pointers are explicitely mapped to the new structure.
55
56   AliHLTAnalysisEnvironment mappedEnv;
57   memset(&mappedEnv, 0, sizeof(mappedEnv));
58   mappedEnv.fStructSize=sizeof(mappedEnv);
59   if (comenv) {
60     mappedEnv.fParam               = comenv->fParam;
61     mappedEnv.fAllocMemoryFunc     = comenv->fAllocMemoryFunc;
62     mappedEnv.fGetEventDoneDataFunc= comenv->fGetEventDoneDataFunc;
63     mappedEnv.fLoggingFunc         = comenv->fLoggingFunc;
64   }
65
66   gComponentHandler_C = new AliHLTComponentHandler(&mappedEnv);
67   if ( !gComponentHandler_C )
68     return EFAULT;
69   gComponentHandler_C->InitAliLogTrap(gComponentHandler_C);
70   gComponentHandler_C->AnnounceVersion();
71   return 0;
72 }
73
74 int AliHLT_C_Component_DeinitSystem()
75 {
76   // De-init the HLT system and clean-up internal memory
77   if ( gComponentHandler_C )
78     {
79       delete gComponentHandler_C;
80       gComponentHandler_C = NULL;
81     }
82   return 0;
83 }
84
85 int AliHLT_C_Component_LoadLibrary( const char* libraryPath )
86 {
87   // load a component library
88   if ( !gComponentHandler_C )
89     return ENXIO;
90   return gComponentHandler_C->LoadLibrary( libraryPath );
91 }
92
93 int AliHLT_C_Component_UnloadLibrary( const char* /*libraryPath*/ )
94 {
95   // unload a component library
96   if ( !gComponentHandler_C )
97     return ENXIO;
98   // Matthias 26.10.2007
99   // Unloading of libraries has to be re-worked. It has been commented out here
100   // since the libraries will be unloaded at the destruction of the component
101   // handler instance anyway. So it has no effect to the operation in PubSub.
102   // With the introduction of the dynamic component registration via module
103   // agents we run into trouble when cleaning up the samples managed by the
104   // component handler. Destruction of the sample objects is done AFTER
105   // unloading of the library and thus the destructor is not present any 
106   // more.
107   //return gComponentHandler_C->UnloadLibrary( libraryPath );
108   return 0;
109 }
110
111 int AliHLT_C_CreateComponent( const char* componentType, void* environParam, int argc, const char** argv, AliHLTComponentHandle* handle )
112 {
113   // create a component
114   if ( !gComponentHandler_C )
115     return ENXIO;
116   if ( !handle ) return EINVAL;
117   AliHLTComponent* comp=NULL;
118   const char* cdbPath = getenv("ALIHLT_HCDBDIR");
119   if (!cdbPath) cdbPath = getenv("ALICE_ROOT");
120   int ret = gComponentHandler_C->CreateComponent( componentType, comp);
121   if (ret>=0 && comp) {
122     AliHLTMisc::Instance().InitCDB(cdbPath);
123     AliHLTMisc::Instance().SetCDBRunNo(gRunDesc.fRunNo);
124     comp->SetRunDescription(&gRunDesc, gRunType);
125     const AliHLTAnalysisEnvironment* comenv=gComponentHandler_C->GetEnvironment();
126     ret=comp->Init(comenv, environParam, argc, argv);
127   }
128   *handle = reinterpret_cast<AliHLTComponentHandle>( comp );
129
130   return ret;
131 }
132
133 void AliHLT_C_DestroyComponent( AliHLTComponentHandle handle )
134 {
135   // destroy a component
136   if ( !handle )
137     return;
138   
139   AliHLTComponent* pComp=reinterpret_cast<AliHLTComponent*>( handle );
140   pComp->Deinit();
141   delete pComp;
142 }
143
144 int AliHLT_C_SetRunDescription(const AliHLTRunDesc* desc, const char* runType)
145 {
146   // set run description
147   if (!desc) return -EINVAL;
148   if (desc->fStructSize<sizeof(AliHLTUInt32_t)) return -EINVAL;
149   if (!gComponentHandler_C) return ENXIO;
150
151   memcpy(&gRunDesc, desc, desc->fStructSize<sizeof(gRunDesc)?desc->fStructSize:sizeof(gRunDesc));
152   gRunDesc.fStructSize=sizeof(gRunDesc);
153   if (gRunType) delete [] gRunType;
154   gRunType=NULL;
155   if (runType) {
156     gRunType=new char[strlen(runType)+1];
157     if (gRunType) strcpy(gRunType, runType);
158   }
159   return 0;
160 }
161
162 int AliHLT_C_ProcessEvent( AliHLTComponentHandle handle, const AliHLTComponentEventData* evtData, const AliHLTComponentBlockData* blocks, 
163                            AliHLTComponentTriggerData* trigData, AliHLTUInt8_t* outputPtr,
164                            AliHLTUInt32_t* size, AliHLTUInt32_t* outputBlockCnt, 
165                            AliHLTComponentBlockData** outputBlocks,
166                            AliHLTComponentEventDoneData** edd )
167 {
168   // process one event
169   if ( !handle )
170     return ENXIO;
171   AliHLTComponent* comp = reinterpret_cast<AliHLTComponent*>( handle );
172   return comp->ProcessEvent( *evtData, blocks, *trigData, outputPtr, *size, *outputBlockCnt, *outputBlocks, *edd );
173 }
174
175 int AliHLT_C_GetOutputDataType( AliHLTComponentHandle handle, AliHLTComponentDataType* dataType )
176 {
177   // get output data type of a component
178   if ( !handle )
179     return ENXIO;
180   AliHLTComponent* comp = reinterpret_cast<AliHLTComponent*>( handle );
181   *dataType = comp->GetOutputDataType();
182   return 0;
183 }
184
185 int AliHLT_C_GetOutputSize( AliHLTComponentHandle handle, unsigned long* constBase, double* inputMultiplier )
186 {
187   // get output data size of a component
188   if ( !handle )
189     return ENXIO;
190   AliHLTComponent* comp = reinterpret_cast<AliHLTComponent*>( handle );
191   comp->GetOutputDataSize( *constBase, *inputMultiplier );
192   return 0;
193 }