logging class extended and macros for easy log messages introduced, code changed...
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTComponentHandler.cxx
1 // $Id$
2
3 /**************************************************************************
4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  *                                                                        *
6  * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
7  *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
8  *          Artur Szostak <artursz@iafrica.com>                           *
9  *          for The ALICE Off-line 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 ///////////////////////////////////////////////////////////////////////////////
21 //                                                                           //
22 // handler class for HLT analysis components                                 //
23 //                                                                           //
24 ///////////////////////////////////////////////////////////////////////////////
25
26 #if __GNUC__== 3
27 using namespace std;
28 #endif
29
30 #include <errno.h>
31 #include <string.h>
32 #include <dlfcn.h>
33 #include "AliL3StandardIncludes.h"
34 #include "AliHLTComponentHandler.h"
35 #include "AliHLTComponent.h"
36 #include "AliHLTDataTypes.h"
37 #include "AliHLTSystem.h"
38
39 ClassImp(AliHLTComponentHandler)
40
41 AliHLTComponentHandler::AliHLTComponentHandler()
42 {
43 }
44
45
46 AliHLTComponentHandler::~AliHLTComponentHandler()
47 {
48   UnloadLibraries();
49 }
50
51 Int_t AliHLTComponentHandler::RegisterComponent(AliHLTComponent* pSample)
52 {
53   Int_t iResult=0;
54   if (pSample) {
55     if (FindComponent(pSample->GetComponentID())==NULL) {
56       iResult=InsertComponent(pSample);
57       if (iResult>=0) {
58         HLTInfo("component %s registered", pSample->GetComponentID());
59       }
60     } else {
61       // component already registered
62       HLTInfo("component %s already registered, skipped", pSample->GetComponentID());
63       iResult=-EEXIST;
64     }
65   } else {
66     iResult=-EINVAL;
67   }
68   return iResult;
69 }
70
71 int AliHLTComponentHandler::DeregisterComponent( const char* componentID )
72 {
73   return 0;
74 }
75
76 Int_t AliHLTComponentHandler::ScheduleRegister(AliHLTComponent* pSample)
77 {
78   Int_t iResult=0;
79   if (pSample) {
80     fScheduleList.push_back(pSample);
81   } else {
82     iResult=-EINVAL;
83   }
84   return iResult;
85 }
86
87 int AliHLTComponentHandler::CreateComponent(const Char_t* componentID, void* environ_param, int argc, const char** argv, AliHLTComponent*& component )
88 {
89   int iResult=0;
90   if (componentID) {
91     AliHLTComponent* pSample=FindComponent(componentID);
92     if (pSample!=NULL) {
93       component=pSample->Spawn();
94       if (component) {
95         HLTDebug("component \"%s\" created (%p)", componentID, component);
96         component->Init(&fEnvironment, environ_param, argc, argv);
97       } else {
98         HLTError("can not spawn component \"%s\"", componentID);
99         iResult=-ENOENT;
100       }
101     } else {
102       HLTWarning("can not find component \"%s\"", componentID);
103       iResult=-ENOENT;
104     }
105   } else {
106     iResult=-EINVAL;
107   }
108   return iResult;
109 }
110
111 Int_t AliHLTComponentHandler::FindComponentIndex(const Char_t* componentID)
112 {
113   Int_t iResult=0;
114   if (componentID) {
115     vector<AliHLTComponent*>::iterator element=fComponentList.begin();
116     while (element!=fComponentList.end() && iResult>=0) {
117       if (strcmp(componentID, (*element)->GetComponentID())==0) {
118         break;
119       }
120       element++;
121       iResult++;
122     }
123     if (element==fComponentList.end()) iResult=-ENOENT;
124   } else {
125     iResult=-EINVAL;
126   }
127   return iResult;
128 }
129
130 AliHLTComponent* AliHLTComponentHandler::FindComponent(const Char_t* componentID)
131 {
132   AliHLTComponent* pSample=NULL;
133   Int_t index=FindComponentIndex(componentID);
134   if (index>=0) {
135     pSample=(AliHLTComponent*)fComponentList.at(index);
136   }
137   return pSample;
138 }
139
140 Int_t AliHLTComponentHandler::InsertComponent(AliHLTComponent* pSample)
141 {
142   Int_t iResult=0;
143   if (pSample!=NULL) {
144     fComponentList.push_back(pSample);
145   } else {
146     iResult=-EINVAL;
147   }
148   return iResult;
149 }
150
151 void AliHLTComponentHandler::List() {
152   vector<AliHLTComponent*>::iterator element=fComponentList.begin();
153   int index=0;
154   while (element!=fComponentList.end()) {
155     HLTInfo("%d. %s", index++, (*element++)->GetComponentID());
156   }
157 }
158
159 void AliHLTComponentHandler::SetEnvironment(AliHLTComponentEnvironment* pEnv) {
160   if (pEnv) {
161     memcpy(&fEnvironment, pEnv, sizeof(AliHLTComponentEnvironment));
162   }
163 }
164
165 int AliHLTComponentHandler::LoadLibrary( const char* libraryPath )
166 {
167   int iResult=0;
168   if (libraryPath) {
169     AliHLTComponent::SetGlobalComponentHandler(this);
170     AliHLTLibHandle hLib=dlopen(libraryPath, RTLD_NOW);
171     if (hLib) {
172       AliHLTComponent::UnsetGlobalComponentHandler();
173       HLTDebug("library %s loaded", libraryPath);
174       fLibraryList.push_back(hLib);
175       vector<AliHLTComponent*>::iterator element=fScheduleList.begin();
176       int iSize=fScheduleList.size();
177       int iLocalResult=0;
178       while (iSize-- > 0) {
179         element=fScheduleList.begin();
180         iLocalResult=RegisterComponent(*element);
181         if (iResult==0) iResult=iLocalResult;
182         fScheduleList.erase(element);
183       }
184     } else {
185       HLTError("can not load library %s", libraryPath);
186       HLTError("dlopen error: %s", dlerror());
187       iResult=-ELIBACC;
188     }
189   } else {
190     iResult=-EINVAL;
191   }
192   return iResult;
193 }
194
195 int AliHLTComponentHandler::UnloadLibrary( const char* libraryPath )
196 {
197   int iResult=0;
198   return iResult;
199 }
200
201 int AliHLTComponentHandler::UnloadLibraries()
202 {
203   int iResult=0;
204   vector<AliHLTLibHandle>::iterator element=fLibraryList.begin();
205   while (element!=fLibraryList.end()) {
206     dlclose(*element);
207     element++;
208   }
209   return iResult;
210 }