bugfix: correct range of DDL for specified detector
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTDomainEntry.cxx
1 // $Id$
2 /**************************************************************************
3  * This file is property of and copyright by the ALICE HLT Project        *
4  * ALICE Experiment at CERN, All rights reserved.                         *
5  *                                                                        *
6  * Primary Authors: Artur Szostak <artursz@iafrica.com>                   *
7  *                  for The ALICE HLT Project.                            *
8  *                                                                        *
9  * Permission to use, copy, modify and distribute this software and its   *
10  * documentation strictly for non-commercial purposes is hereby granted   *
11  * without fee, provided that the above copyright notice appears in all   *
12  * copies and that both the copyright notice and this permission notice   *
13  * appear in the supporting documentation. The authors make no claims     *
14  * about the suitability of this software for any purpose. It is          *
15  * provided "as is" without express or implied warranty.                  *
16  **************************************************************************/
17
18 /// @file   AliHLTDomainEntry.cxx
19 /// @author Artur Szostak <artursz@iafrica.com>
20 /// @date   20 Nov 2008
21 /// @brief  Implementation of the AliHLTDomainEntry class.
22 ///
23 /// The AliHLTDomainEntry class is used to store information identifying a particular
24 /// HLT internal data block, or set of data blocks using wild card values. This
25 /// class is used by AliHLTTriggerDomain to store a list of data block classes
26 /// that should be readout by the HLT. The information identifying a data block is
27 /// the following:
28 ///  - the data block type
29 ///  - the data block's origin (detector name)
30 ///  - the data block's specification (detector specific bits)
31 /// Several useful operators and methods are defined to help manipulate this
32 /// information in the AliHLTTriggerDomain class.
33
34 #include "AliHLTDomainEntry.h"
35 #include "Riostream.h"
36 #include "TString.h"
37 #include <cstring>
38 #include <cerrno>
39
40 ClassImp(AliHLTDomainEntry)
41
42
43 AliHLTDomainEntry::AliHLTDomainEntry() :
44   TObject(),
45   fExclude(kFALSE),
46   fUseSpec(kFALSE),
47   fType(kAliHLTVoidDataType),
48   fSpecification(kAliHLTVoidDataSpec)
49 {
50   // Default constructor.
51 }
52
53 AliHLTDomainEntry::AliHLTDomainEntry(const AliHLTDomainEntry& domain) :
54   TObject(domain),
55   fExclude(domain.fExclude),
56   fUseSpec(domain.fUseSpec),
57   fType(domain.fType),
58   fSpecification(domain.fSpecification)
59 {
60   // Copy constructor performs a deep copy.
61 }
62
63
64 AliHLTDomainEntry::AliHLTDomainEntry(const AliHLTComponentDataType& type) :
65   TObject(),
66   fExclude(kFALSE),
67   fUseSpec(kFALSE),
68   fType(type),
69   fSpecification(kAliHLTVoidDataSpec)
70 {
71   // Constructs a domain entry with a particular data type and any specification.
72   // See header file for more information.
73 }
74
75
76 AliHLTDomainEntry::AliHLTDomainEntry(const char* blocktype, const char* origin) :
77   TObject(),
78   fExclude(kFALSE),
79   fUseSpec(kFALSE),
80   fType(),
81   fSpecification(kAliHLTVoidDataSpec)
82 {
83   // Constructs a domain entry with a particular data type and any specification.
84   // See header file for more information.
85   
86   char id[kAliHLTComponentDataTypefIDsize];
87   memset(&id, 0x0, sizeof(id));
88   for (int i = 0; i < kAliHLTComponentDataTypefIDsize && blocktype[i] != '\0'; i++)
89   {
90     id[i] = blocktype[i];
91   }
92   fType = AliHLTComponentDataTypeInitializer(id, origin);
93 }
94
95
96 AliHLTDomainEntry::AliHLTDomainEntry(const AliHLTComponentDataType& type, UInt_t spec) :
97   TObject(),
98   fExclude(kFALSE),
99   fUseSpec(kTRUE),
100   fType(type),
101   fSpecification(spec)
102 {
103   // Constructs a domain entry with a particular data type and specification.
104   // See header file for more information.
105 }
106
107
108 AliHLTDomainEntry::AliHLTDomainEntry(const char* blocktype, const char* origin, UInt_t spec) :
109   TObject(),
110   fExclude(kFALSE),
111   fUseSpec(kTRUE),
112   fType(),
113   fSpecification(spec)
114 {
115   // Constructs a domain entry with a particular data type and specification.
116   // See header file for more information.
117   
118   char id[kAliHLTComponentDataTypefIDsize];
119   memset(&id, 0x0, sizeof(id));
120   for (int i = 0; i < kAliHLTComponentDataTypefIDsize && blocktype[i] != '\0'; i++)
121   {
122     id[i] = blocktype[i];
123   }
124   fType = AliHLTComponentDataTypeInitializer(id, origin);
125 }
126
127
128 AliHLTDomainEntry::AliHLTDomainEntry(Bool_t exclude, const AliHLTDomainEntry& domain) :
129   TObject(domain),
130   fExclude(exclude),
131   fUseSpec(domain.fUseSpec),
132   fType(domain.fType),
133   fSpecification(domain.fSpecification)
134 {
135   // Constructs a domain entry from an existing one but with the exclude flag set.
136   // See header file for more information.
137 }
138
139
140 AliHLTDomainEntry::AliHLTDomainEntry(Bool_t exclude, const AliHLTComponentDataType& type) :
141   TObject(),
142   fExclude(exclude),
143   fUseSpec(kFALSE),
144   fType(type),
145   fSpecification(kAliHLTVoidDataSpec)
146 {
147   // Constructs a domain entry with the given data type, any specification
148   // and the exclude flag set.
149   // See header file for more information.
150 }
151
152
153 AliHLTDomainEntry::AliHLTDomainEntry(Bool_t exclude, const char* blocktype, const char* origin) :
154   TObject(),
155   fExclude(exclude),
156   fUseSpec(kFALSE),
157   fType(),
158   fSpecification(kAliHLTVoidDataSpec)
159 {
160   // Constructs a domain entry with a particular data type, any specification
161   // and the exclude flag set.
162   // See header file for more information.
163   
164   char id[kAliHLTComponentDataTypefIDsize];
165   memset(&id, 0x0, sizeof(id));
166   for (int i = 0; i < kAliHLTComponentDataTypefIDsize && blocktype[i] != '\0'; i++)
167   {
168     id[i] = blocktype[i];
169   }
170   fType = AliHLTComponentDataTypeInitializer(id, origin);
171 }
172
173
174 AliHLTDomainEntry::AliHLTDomainEntry(Bool_t exclude, const AliHLTComponentDataType& type, UInt_t spec) :
175   TObject(),
176   fExclude(exclude),
177   fUseSpec(kTRUE),
178   fType(type),
179   fSpecification(spec)
180 {
181   // Constructs a domain entry with a particular data type and specification,
182   // and the exclude flag is set.
183   // See header file for more information.
184 }
185
186
187 AliHLTDomainEntry::AliHLTDomainEntry(Bool_t exclude, const char* blocktype, const char* origin, UInt_t spec) :
188   TObject(),
189   fExclude(exclude),
190   fUseSpec(kTRUE),
191   fType(),
192   fSpecification(spec)
193 {
194   // Constructs a domain entry with a particular data type and specification,
195   // and the exclude flag is set.
196   // See header file for more information.
197   
198   char id[kAliHLTComponentDataTypefIDsize];
199   memset(&id, 0x0, sizeof(id));
200   for (int i = 0; i < kAliHLTComponentDataTypefIDsize && blocktype[i] != '\0'; i++)
201   {
202     id[i] = blocktype[i];
203   }
204   fType = AliHLTComponentDataTypeInitializer(id, origin);
205 }
206
207
208 AliHLTDomainEntry::~AliHLTDomainEntry()
209 {
210   // Default destructor.
211 }
212
213
214 AliHLTDomainEntry& AliHLTDomainEntry::operator = (const AliHLTDomainEntry& domain)
215 {
216   // The copy operator performs a deep copy.
217
218   if (this==&domain) return *this;
219   TObject::operator = (domain);
220   fType = domain.fType;
221   fUseSpec = domain.fUseSpec;
222   fSpecification = domain.fSpecification;
223   return *this;
224 }
225
226
227 bool AliHLTDomainEntry::IdenticalTo(const AliHLTDomainEntry& rhs) const
228 {
229   // Checks if this domain entry is identical to 'rhs' and do not just have a
230   // set intersection.
231   // See header file for more information.
232   
233   if (not MatchExactly(fType, rhs.fType)) return false;
234   return (fUseSpec == rhs.fUseSpec) and (fSpecification == rhs.fSpecification);
235 }
236
237
238 bool AliHLTDomainEntry::SubsetOf(const AliHLTDomainEntry& rhs) const
239 {
240   // Checks if this domain entry is a subset of 'rhs'.
241   // See header file for more information.
242
243   if (*this != rhs) return false;
244   bool thisTypeIsAny = strncmp(&fType.fID[0], kAliHLTAnyDataTypeID, kAliHLTComponentDataTypefIDsize) == 0;
245   bool rhsTypeIsAny = strncmp(&rhs.fType.fID[0], kAliHLTAnyDataTypeID, kAliHLTComponentDataTypefIDsize) == 0;
246   if (thisTypeIsAny and not rhsTypeIsAny) return false;
247   bool thisOriginIsAny = strncmp(&fType.fOrigin[0], kAliHLTDataOriginAny, kAliHLTComponentDataTypefOriginSize) == 0;
248   bool rhsOriginIsAny = strncmp(&rhs.fType.fOrigin[0], kAliHLTDataOriginAny, kAliHLTComponentDataTypefOriginSize) == 0;
249   if (thisOriginIsAny and not rhsOriginIsAny) return false;
250   bool thisSpecIsAny = not fUseSpec;
251   bool rhsSpecIsAny = not rhs.fUseSpec;
252   if (thisSpecIsAny and not rhsSpecIsAny) return false;
253   return true;
254 }
255
256
257 bool AliHLTDomainEntry::IntersectWith(const AliHLTDomainEntry& rhs, AliHLTDomainEntry& result) const
258 {
259   // Finds the set intersection between this domain entry and 'rhs'.
260   // See header file for more information.
261
262   if (*this != rhs) return false;
263   bool thisTypeIsAny = strncmp(&fType.fID[0], kAliHLTAnyDataTypeID, kAliHLTComponentDataTypefIDsize) == 0;
264   bool thisOriginIsAny = strncmp(&fType.fOrigin[0], kAliHLTDataOriginAny, kAliHLTComponentDataTypefOriginSize) == 0;
265   bool thisSpecIsAny = not fUseSpec;
266   const AliHLTComponentDataType& type = (not thisTypeIsAny) ? fType : rhs.fType;
267   const AliHLTComponentDataType& origin = (not thisOriginIsAny) ? fType : rhs.fType;
268   Bool_t useSpec;
269   UInt_t spec;
270   if (not thisSpecIsAny)
271   {
272     useSpec = fUseSpec;
273     spec = fSpecification;
274   }
275   else
276   {
277     useSpec = rhs.fUseSpec;
278     spec = rhs.fSpecification;
279   }
280   if (useSpec)
281   {
282     result = AliHLTDomainEntry(type | origin.fOrigin, spec);
283   }
284   else
285   {
286     result = AliHLTDomainEntry(type | origin.fOrigin);
287   }
288   return true;
289 }
290
291
292 void AliHLTDomainEntry::Print(Option_t* option) const
293 {
294   // Inherited from TObject. Prints the domain entry contents.
295   // See header file for more information.
296   
297   cout << AsString().Data();
298   TString opt(option);
299   if (opt.Contains("noendl")) return;
300   cout << endl;
301 }
302
303
304 TString AliHLTDomainEntry::AsString() const
305 {
306   // Returns a string representation of the domain entry.
307   // See header file for more information.
308   
309   TString str;
310   if (strncmp(&fType.fID[0], kAliHLTAnyDataTypeID, kAliHLTComponentDataTypefIDsize) == 0)
311   {
312     for (int i = 0; i < kAliHLTComponentDataTypefIDsize; i++) str += "*";
313   }
314   else
315   {
316     for (int i = 0; i < kAliHLTComponentDataTypefIDsize; i++)
317     {
318       if (fType.fID[i] != '\0')
319         str += fType.fID[i];
320       else
321         str += "\\0";
322     }
323   }
324   str += ":";
325   if (strncmp(&fType.fOrigin[0], kAliHLTDataOriginAny, kAliHLTComponentDataTypefOriginSize) == 0)
326   {
327     for (int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++) str += "*";
328   }
329   else
330   {
331     for (int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++)
332     {
333       if (fType.fOrigin[i] != '\0')
334         str += fType.fOrigin[i];
335       else
336         str += "\\0";
337     }
338   }
339   str += ":";
340   if (fUseSpec)
341   {
342     char num[16];
343     sprintf(num, "0x%8.8X", fSpecification);
344     str += num;
345   }
346   else
347   {
348     str += "**********";
349   }
350   return str;
351 }
352
353 int AliHLTDomainEntry::AsBinary(AliHLTUInt32_t buffer[4]) const
354 {
355   // convert the data type and specification to a 32 byte buffer
356   if (!buffer) return -EINVAL;
357
358   AliHLTUInt32_t* tgt=buffer; 
359   unsigned ii=0;
360
361   // lower part of the data type id
362   *tgt=0;
363   for ( ii=0; ii<4; ii++ ) {
364     *tgt |= ((AliHLTUInt32_t)(fType.fID[8-1-ii])) << (ii*8);
365   }
366   tgt++;
367           
368   // upper part of the data type id
369   *tgt=0;
370   for ( ii=0; ii<4; ii++ ) {
371     *tgt |= ((AliHLTUInt32_t)(fType.fID[8-5-ii])) << (ii*8);
372   }
373   tgt++;
374   
375   // data type origin
376   *tgt=0;
377   for ( ii=0; ii<4; ii++ ) {
378     *tgt |= ((AliHLTUInt32_t)(fType.fOrigin[4-1-ii])) << (ii*8);
379   }
380   tgt++;
381   
382   // specification
383   if (fUseSpec)
384     *tgt = fSpecification;
385   else
386     *tgt = kAliHLTVoidDataSpec;
387
388   return 0;
389 }