HLT/BASE/AliHLTDataTypes.h

   1 // @(#) $Id$
   2
   3 #ifndef ALIHLTDATATYPES_H
   4 #define ALIHLTDATATYPES_H
   5 /* This file is property of and copyright by the ALICE HLT Project        *
   6  * ALICE Experiment at CERN, All rights reserved.                         *
   7  * See cxx source for full Copyright notice                               */
   8
   9 /** @file   AliHLTDataTypes.h
  10     @author Matthias Richter, Timm Steinbeck, Jochen Thaeder
  11     @date
  12     @brief  Data type declaration for the HLT module.
  13 */
  14
  15 //////////////////////////////////////////////////////////////////////////
  16 //
  17 // version no of HLT data types
  18 //
  19 //////////////////////////////////////////////////////////////////////////
  20
  21 /* Version   Description
  22  *   1       first version until June 07; implicite, not tagged
  23  *   2       introduced June 07, enhanced/cleaned/arranged structure
  24  *   3       2007-11-15 RAW DDL data type added; some inconsistencies fixed
  25  *           ('void' and 'any' origins); added signed HLT basic data types
  26  *           2007-11-23 origin defines have become variables in conjunction
  27  *           to be used with the operator| (AliHLTComponentDataType)
  28  *           2007-11-24 added trigger structs and ESD tree data type
  29  *   4       Component configuration and DCS update events added
  30  *           gkAliHLTDDLListSize set from 29 to 30 according to new PubSub
  31  *           specs
  32  *   5       Data types for Run and Event summary, and for monitoring added
  33  */
  34 #define ALIHLT_DATA_TYPES_VERSION 5
  35
  36 //////////////////////////////////////////////////////////////////////////
  37 //
  38 // HLT data origin variables.
  39 //
  40 // By converting from defines to variables, the origins can be used with
  41 // the operator|
  42 //
  43 // AliHLTComponentDataType dt;
  44 // dt = kAliHLTDataTypeDDLRaw | gkAliHLTDataOriginTPC;
  45 //
  46 //////////////////////////////////////////////////////////////////////////
  47
  48 /** field size of datat type origin */
  49 const int kAliHLTComponentDataTypefOriginSize=4;
  50
  51
  52 /** invalid data origin */
  53 # define kAliHLTDataOriginVoid "\0\0\0"
  54 /** old invalid data origin, kept for backward compatibility */
  55 # define kAliHLTVoidDataOrigin "\0\0\0"
  56
  57 /** wildcard data type origin */
  58 # define kAliHLTDataOriginAny "***"
  59 /** old wildcard data type origin, kept for backward compatibility */
  60 # define kAliHLTAnyDataOrigin "***"
  61
  62 /** HLT out */
  63 extern const char kAliHLTDataOriginOut[kAliHLTComponentDataTypefOriginSize];
  64
  65 /** HLT/PubSub private internal */
  66 extern const char kAliHLTDataOriginPrivate[kAliHLTComponentDataTypefOriginSize];
  67
  68 /** TPC */
  69 extern const char kAliHLTDataOriginTPC[kAliHLTComponentDataTypefOriginSize];
  70
  71 /** PHOS */
  72 extern const char kAliHLTDataOriginPHOS[kAliHLTComponentDataTypefOriginSize];
  73
  74 /** MUON */
  75 extern const char kAliHLTDataOriginMUON[kAliHLTComponentDataTypefOriginSize];
  76
  77 /** TRD */
  78 extern const char kAliHLTDataOriginTRD[kAliHLTComponentDataTypefOriginSize];
  79
  80 /** ITS */
  81 extern const char kAliHLTDataOriginITS[kAliHLTComponentDataTypefOriginSize];
  82
  83 //////////////////////////////////////////////////////////////////////////
  84 //
  85 // HLT common data type defines
  86 //
  87 //////////////////////////////////////////////////////////////////////////
  88
  89 /** field size of data type id */
  90 const int kAliHLTComponentDataTypefIDsize=8;
  91
  92
  93 /** invalid data type id */
  94 # define kAliHLTVoidDataTypeID "\0\0\0\0\0\0\0"
  95
  96 /** special id for any data type id */
  97 # define kAliHLTAnyDataTypeID "*******"
  98
  99 /** DDL RAW data */
 100 # define kAliHLTDDLRawDataTypeID   {'D','D','L','_','R','A','W',' '}
 101
 102 /** calibration data for file exchange subscriber */
 103 # define kAliHLTFXSCalibDataTypeID {'F','X','S','_','C','A','L',' '}
 104
 105 /** start of run (SOR) event
 106  * @ref AliHLTRunDesc
 107  */
 108 # define kAliHLTSORDataTypeID      {'S','T','A','R','T','O','F','R'}
 109
 110 /** end of run (EOR) event
 111  * @ref AliHLTRunDesc
 112  */
 113 # define kAliHLTEORDataTypeID      {'E','N','D','O','F','R','U','N'}
 114
 115 /** DDL list event
 116  * @ref AliHLTEventDDL
 117  */
 118 # define kAliHLTDDLDataTypeID      {'D','D','L','L','I','S','T',' '}
 119
 120 /** EventType event
 121  * - empty payload, specification gives eventType
 122  */
 123 # define kAliHLTEventDataTypeID    {'E','V','E','N','T','T','Y','P'}
 124
 125 /** ComponentConfiguration event
 126  * - payload contains the CDB path as string
 127  */
 128 # define kAliHLTComConfDataTypeID  {'C','O','M','_','C','O','N','F'}
 129
 130 /** DCS value update event
 131  * - payload contains string of relevant detectors
 132  */
 133 # define kAliHLTUpdtDCSDataTypeID  {'U','P','D','T','_','D','C','S'}
 134
 135 /** ESD data block
 136  * an AliESD object of varying origin
 137  * The 'V0' at the end allows a versioning
 138  */
 139 # define kAliHLTESDObjectDataTypeID    {'A','L','I','E','S','D','V','0'}
 140
 141 /** ESD tree data block
 142  * TTree with an AliESD object of varying origin
 143  */
 144 # define kAliHLTESDTreeDataTypeID      {'E','S','D','_','T','R','E','E'}
 145
 146 /** HW Address selection data block
 147  * - a selection list for 16 bit HW addresses
 148  * - varying origin
 149  */
 150 # define kAliHLTHwAddr16DataTypeID     {'H','W','A','D','D','R','1','6'}
 151
 152 /** Event Statistics
 153  * - event statistics for given detectors
 154  * - varying origin
 155  */
 156 # define kAliHLTEventStatisticsDataTypeID     {'E','V','_','S','T','A','T','I'}
 157
 158 /** Event Summary
 159  * - event summary
 160  * - origin : kAliHLTDataOriginOut ( HLT )
 161  */
 162 # define kAliHLTEventSummaryDataTypeID        {'E','V','_','S','U','M','M','A'}
 163
 164 /** Run Statistics
 165  * - run statistics for given detectors
 166  * - varying origin
 167  */
 168 # define kAliHLTRunStatisticsDataTypeID       {'R','U','N','S','T','A','T','I'}
 169
 170 /** Run Summary
 171  * - run summary
 172  * - origin : kAliHLTDataOriginOut ( HLT )
 173  */
 174 # define kAliHLTRunSummaryDataTypeID          {'R','U','N','S','U','M','M','A'}
 175
 176 /** general ROOT TObject
 177  * - a general TObject exported from the HLT analysis
 178  * - varying origin
 179  */
 180 #define kAliHLTTObjectDataTypeID              {'R','O','O','T','T','O','B','J'}
 181
 182 /** ROOT TObjArray
 183  * - a TObjArray exported from the HLT analysis
 184  * - varying origin
 185  */
 186 #define kAliHLTTObjArrayDataTypeID            {'R','O','O','T','O','B','A','R'}
 187
 188 /** ROOT TTree
 189  * - a TTree object exported from the HLT analysis
 190  * - varying origin
 191  */
 192 #define kAliHLTTTreeDataTypeID                {'R','O','O','T','T','R','E','E'}
 193
 194 /** ROOT histogram
 195  * - a histogram object exported from the HLT analysis
 196  * - class derives from TH1 (directly or indirectly) and inherits all common functionality
 197  * - varying origin
 198  */
 199 #define kAliHLTHistogramDataTypeID            {'R','O','O','T','H','I','S','T'}
 200
 201 /** ROOT TNtuple
 202  * - a TNtupl object exported from the HLT analysis
 203  * - varying origin
 204  */
 205 #define kAliHLTTNtupleDataTypeID              {'R','O','O','T','T','U','P','L'}
 206
 207 using namespace std;
 208
 209 extern "C" {
 210   //////////////////////////////////////////////////////////////////////////
 211   //
 212   // Basic HLT data types
 213   //
 214   //////////////////////////////////////////////////////////////////////////
 215
 216   typedef unsigned char AliHLTUInt8_t;
 217
 218   typedef signed char AliHLTInt8_t;
 219
 220   typedef unsigned short AliHLTUInt16_t;
 221
 222   typedef signed short AliHLTInt16_t;
 223
 224   typedef unsigned int AliHLTUInt32_t;
 225
 226   typedef signed int AliHLTInt32_t;
 227
 228   typedef unsigned long long AliHLTUInt64_t;
 229
 230   typedef signed long long AliHLTInt64_t;
 231
 232   typedef float AliHLTFloat32_t;
 233
 234   typedef double AliHLTFloat64_t;
 235
 236   typedef AliHLTUInt64_t AliHLTEventID_t;
 237
 238   //////////////////////////////////////////////////////////////////////////
 239   //
 240   // HLT logging levels
 241   //
 242   //////////////////////////////////////////////////////////////////////////
 243
 244   /**
 245    * Logging severities of the HLT
 246    */
 247   enum AliHLTComponentLogSeverity {
 248     /** no logging */
 249     kHLTLogNone      = 0,
 250     /** benchmark messages */
 251     kHLTLogBenchmark = 0x1,
 252     /** debug messages */
 253     kHLTLogDebug     = 0x2,
 254     /** info messages */
 255     kHLTLogInfo      = 0x4,
 256     /** warning messages */
 257     kHLTLogWarning   = 0x8,
 258     /** error messages */
 259     kHLTLogError     = 0x10,
 260     /** fatal error messages */
 261     kHLTLogFatal     = 0x20,
 262     /** few important messages not to be filtered out.
 263      * redirected to kHLTLogInfo in AliRoot
 264      */
 265     kHLTLogImportant = 0x40,
 266     /** special value to enable all messages */
 267     kHLTLogAll       = 0x7f,
 268     /** the default logging filter */
 269     kHLTLogDefault   = 0x7d
 270 };
 271
 272   //////////////////////////////////////////////////////////////////////////
 273   //
 274   // HLT data structures for data exchange and external interface
 275   //
 276   //////////////////////////////////////////////////////////////////////////
 277
 278   /**
 279    * @struct AliHLTComponentEventData
 280    * Event descriptor
 281    */
 282   struct AliHLTComponentEventData
 283   {
 284     AliHLTUInt32_t fStructSize;
 285     AliHLTEventID_t fEventID;
 286     AliHLTUInt32_t fEventCreation_s;
 287     AliHLTUInt32_t fEventCreation_us;
 288     AliHLTUInt32_t fBlockCnt;
 289   };
 290
 291   /**
 292    * @struct AliHLTComponentShmData
 293    * Shared memory descriptor.
 294    * Irrelevant for analysis components.
 295    */
 296   struct AliHLTComponentShmData
 297   {
 298     AliHLTUInt32_t fStructSize;
 299     AliHLTUInt32_t fShmType;
 300     AliHLTUInt64_t fShmID;
 301   };
 302
 303   /**
 304    * @struct AliHLTComponentDataType
 305    * Data type descriptor for data blocks transferred through the processing
 306    * chain.
 307    */
 308   struct AliHLTComponentDataType
 309   {
 310     AliHLTUInt32_t fStructSize;
 311     char fID[kAliHLTComponentDataTypefIDsize];                      //!
 312     char fOrigin[kAliHLTComponentDataTypefOriginSize];              //!
 313   };
 314
 315   /**
 316    * @struct AliHLTComponentBlockData
 317    * This is the decription of data blocks exchanged between components.
 318    * \b IMPORTANT: The validity of fPtr and fOffset is different for input and
 319    * output blocks:
 320    * - input blocks: The \em fPtr member always points to the beginning of the data
 321    *                 of size \em fSize. fOffset is ignored and should be in most
 322    *                 case 0.
 323    * - output blocks: The \em fPtr member is ignored by the framework. \em fOffset
 324    *                  must specify the start of the data relative to the output
 325    *                  buffer. The data block has size \em fSize.
 326    */
 327   struct AliHLTComponentBlockData
 328   {
 329     /* size and version of the struct */
 330     AliHLTUInt32_t fStructSize;
 331     /* shared memory key, ignored by processing components */
 332     AliHLTComponentShmData fShmKey;
 333     /* offset of output data relative to the output buffer */
 334     AliHLTUInt32_t fOffset;
 335     /* start of the data for input data blocks, fOffset to be ignored*/
 336     void* fPtr;
 337     /* size of the data block */
 338     AliHLTUInt32_t fSize;
 339     /* data type of the data block */
 340     AliHLTComponentDataType fDataType;
 341     /* data specification of the data block */
 342     AliHLTUInt32_t fSpecification;
 343   };
 344
 345   /**
 346    * @struct AliHLTComponentEventDoneData
 347    *
 348    */
 349   struct AliHLTComponentEventDoneData
 350   {
 351     AliHLTUInt32_t fStructSize;
 352     AliHLTUInt32_t fDataSize;
 353     void* fData;
 354   };
 355
 356   /**
 357    * @struct AliHLTRunDesc
 358    * Event descriptor.
 359    * The struct is send with the SOR and EOR events.
 360    */
 361   struct AliHLTRunDesc
 362   {
 363     AliHLTUInt32_t fStructSize;
 364     AliHLTUInt32_t fRunNo;
 365     AliHLTUInt32_t fRunType;
 366   };
 367
 368   //////////////////////////////////////////////////////////////////////////
 369   //
 370   // Trigger meta information
 371   //
 372   //////////////////////////////////////////////////////////////////////////
 373
 374   /** field size of fAttribute */
 375   const int gkAliHLTBlockDAttributeCount = 8;
 376
 377   /** field size of fCommonHeader */
 378    const int gkAliHLTCommonHeaderCount = 8;
 379
 380   /** size of the DDL list */
 381   const int gkAliHLTDDLListSize = 30;
 382
 383   /** Number of Trigger Classes of CTP in CDH */
 384   const int gkNCTPTriggerClasses = 50;
 385
 386   /**
 387    * @struct AliHLTEventDDL
 388    * DDL list event.
 389    * The struct is send with the DDLLIST event.
 390    * Used in the trigger structure for internal apperance of
 391    * the DLLs as well as for the HLT readout list send to DAQ
 392    * ( as DataType : kAliHLTDataTypeDDL )
 393    */
 394   struct AliHLTEventDDL
 395   {
 396     AliHLTUInt32_t fCount;
 397     AliHLTUInt32_t fList[gkAliHLTDDLListSize];
 398   };
 399
 400   /**
 401    * @struct AliHLTEventTriggerData
 402    */
 403   struct AliHLTEventTriggerData
 404   {
 405     AliHLTUInt8_t  fAttributes[gkAliHLTBlockDAttributeCount];
 406     AliHLTUInt64_t fHLTStatus; // Bit field
 407     AliHLTUInt32_t fCommonHeaderWordCnt;
 408     AliHLTUInt32_t fCommonHeader[gkAliHLTCommonHeaderCount];
 409     AliHLTEventDDL fReadoutList;
 410   };
 411
 412   /**
 413    * @struct AliHLTComponentTriggerData
 414    * Trigger data
 415    */
 416   struct AliHLTComponentTriggerData
 417   {
 418     AliHLTUInt32_t fStructSize;
 419     AliHLTUInt32_t fDataSize;
 420     void* fData;
 421   };
 422
 423   //////////////////////////////////////////////////////////////////////////
 424   //
 425   // HLT Event Type Specification
 426   //
 427   //////////////////////////////////////////////////////////////////////////
 428
 429   /** Unknown eventType specification */
 430   const AliHLTUInt32_t gkAliEventTypeUnknown = ~(AliHLTUInt32_t)0;
 431   /** SOR eventType specification */
 432   const AliHLTUInt32_t gkAliEventTypeStartOfRun=1;
 433   /** Data eventType specification */
 434   const AliHLTUInt32_t gkAliEventTypeData=2;
 435   /** EOR eventType specification */
 436   const AliHLTUInt32_t gkAliEventTypeEndOfRun=4;
 437   /** Corrupt eventType specification */
 438   const AliHLTUInt32_t gkAliEventTypeCorruptID=8;
 439   /** Calibration eventType specification */
 440   const AliHLTUInt32_t gkAliEventTypeCalibration=16;
 441   /** DataReplay eventType specification */
 442   const AliHLTUInt32_t gkAliEventTypeDataReplay=32;
 443   /** Configuration eventType specification */
 444   const AliHLTUInt32_t gkAliEventTypeConfiguration=34;
 445   /** Update DCS eventType specification */
 446   const AliHLTUInt32_t gkAliEventTypeReadPreprocessor=35;
 447   /** Tick eventType specification */
 448   const AliHLTUInt32_t gkAliEventTypeTick=64;
 449   /** Max eventType specification */
 450   const AliHLTUInt32_t gkAliEventTypeMax=64;
 451
 452   //////////////////////////////////////////////////////////////////////////
 453   //
 454   // HLT defines and defaults
 455   //
 456   //////////////////////////////////////////////////////////////////////////
 457
 458   /** invalid event id */
 459   const AliHLTEventID_t kAliHLTVoidEventID=~(AliHLTEventID_t)0;
 460
 461   /** invalid data specification */
 462   const AliHLTUInt32_t kAliHLTVoidDataSpec = ~(AliHLTUInt32_t)0;
 463
 464   /** invalid shared memory type */
 465   const AliHLTUInt32_t gkAliHLTComponentInvalidShmType = 0;
 466
 467   /** invalid shared memory id */
 468   const AliHLTUInt64_t gkAliHLTComponentInvalidShmID = ~(AliHLTUInt64_t)0;
 469
 470   /** invalid data type */
 471   const AliHLTComponentDataType kAliHLTVoidDataType = {
 472     sizeof(AliHLTComponentDataType),
 473     kAliHLTVoidDataTypeID,
 474     kAliHLTDataOriginVoid
 475   };
 476
 477   // there is currently a problem with rootcint if the predefined ids
 478   // (commented below) are used. rootcint does not find the id if they
 479   // are char arrays defined with {} and individual chars. If strings
 480   // are used it works fine
 481   /** any data type */
 482   const AliHLTComponentDataType kAliHLTAnyDataType = {
 483     sizeof(AliHLTComponentDataType),
 484     kAliHLTAnyDataTypeID,
 485     kAliHLTDataOriginAny
 486   };
 487
 488   /** multiple output data types */
 489   extern const AliHLTComponentDataType kAliHLTMultipleDataType;
 490
 491   /** data to file exchange subscriber */
 492   extern const AliHLTComponentDataType kAliHLTDataTypeFXSCalib;
 493
 494   /** DDL list data type */
 495   extern const AliHLTComponentDataType kAliHLTDataTypeDDL;
 496
 497   /** SOR data type */
 498   extern const AliHLTComponentDataType kAliHLTDataTypeSOR;
 499
 500   /** EOR data type */
 501   extern const AliHLTComponentDataType kAliHLTDataTypeEOR;
 502
 503   /** Event type specification */
 504   extern const AliHLTComponentDataType kAliHLTDataTypeEvent;
 505
 506   /** Configuration event data type */
 507   extern const AliHLTComponentDataType kAliHLTDataTypeComConf;
 508
 509   /** DCS value update event */
 510   extern const AliHLTComponentDataType kAliHLTDataTypeUpdtDCS;
 511
 512   /** RAW DDL data specification, origin is 'any', data publisher origin correctly */
 513   extern const AliHLTComponentDataType kAliHLTDataTypeDDLRaw;
 514
 515   /** ESD object data specification, origin is 'any' */
 516   extern const AliHLTComponentDataType kAliHLTDataTypeESDObject;
 517
 518   /** ESD Tree data specification, origin is 'any' */
 519   extern const AliHLTComponentDataType kAliHLTDataTypeESDTree;
 520
 521   /** 16 bit Hardware address selection data specification, origin is 'any' */
 522   extern const AliHLTComponentDataType kAliHLTDataTypeHwAddr16;
 523
 524   /** Event statistics */
 525   extern const AliHLTComponentDataType kAliHLTDataTypeEventStatistics;
 526
 527   /** Event summary */
 528   extern const AliHLTComponentDataType kAliHLTDataTypeEventSummary;
 529
 530   /** Event statistics */
 531   extern const AliHLTComponentDataType kAliHLTDataTypeRunStatistics;
 532
 533   /** Event summary */
 534   extern const AliHLTComponentDataType kAliHLTDataTypeRunSummary;
 535
 536   //////////////////////////////////////////////////////////////////////////
 537   //
 538   // Data Types for Monitoring objects
 539   //
 540   //////////////////////////////////////////////////////////////////////////
 541
 542   /** general ROOT TObject */
 543   extern const AliHLTComponentDataType kAliHLTDataTypeTObject;            // {ROOTTOBJ,"***"}
 544
 545   /** ROOT TObjArray */
 546   extern const AliHLTComponentDataType kAliHLTDataTypeTObjArray;          // {ROOTOBAR,"***"}
 547
 548   /** ROOT TTree */
 549   extern const AliHLTComponentDataType kAliHLTDataTypeTTree;              // {ROOTTREE,"***"}
 550
 551   /** ROOT TH1 (can be used for all histograms, they derive from TH1) */
 552   extern const AliHLTComponentDataType kAliHLTDataTypeHistogram;          // {ROOTHIST,"***"}
 553
 554   /** ROOT TNtuple */
 555   extern const AliHLTComponentDataType kAliHLTDataTypeTNtuple;            // {ROOTTUPL,"***"}
 556
 557   //////////////////////////////////////////////////////////////////////////
 558   //
 559   // FXS subscriber meta information
 560   //
 561   //////////////////////////////////////////////////////////////////////////
 562
 563   const int gkAliHLTFXSHeaderfOriginSize = 4;
 564   const int gkAliHLTFXSHeaderfFileIDSize = 128;
 565   const int gkAliHLTFXSHeaderfDDLNumberSize = 64;
 566
 567   /** Header in front of the data payload, in order to sent data to the FXS. */
 568   struct AliHLTFXSHeader
 569   {
 570     AliHLTUInt32_t fHeaderVersion;
 571     AliHLTUInt32_t fRunNumber;
 572     char fOrigin[gkAliHLTFXSHeaderfOriginSize];
 573     char fFileID[gkAliHLTFXSHeaderfFileIDSize];
 574     char fDDLNumber[gkAliHLTFXSHeaderfDDLNumberSize];
 575   };
 576
 577   //////////////////////////////////////////////////////////////////////////
 578   //
 579   // Component running environment
 580   //
 581   //////////////////////////////////////////////////////////////////////////
 582
 583   /** logging function */
 584   typedef int (*AliHLTfctLogging)( void* param,
 585                                    AliHLTComponentLogSeverity severity,
 586                                    const char* origin,
 587                                    const char* keyword,
 588                                    const char* message);
 589
 590   /**
 591    * @struct AliHLTComponentEnvironment
 592    * Running environment for analysis components.
 593    * The struct describes function callbacks for
 594    */
 595   struct AliHLTComponentEnvironment
 596   {
 597     AliHLTUInt32_t fStructSize;
 598     void* fParam;
 599     void* (*fAllocMemoryFunc)( void* param, unsigned long size );
 600 #if 0
 601     // future addition already foreseen/envisioned
 602     // IMPORTANT: don not just remove the defines as this breaks the binary
 603     // compatibility
 604     int (*fAllocShmMemoryFunc)( void* param, unsigned long size, AliHLTComponentBlockData* blockLocation );
 605 #endif
 606     int (*fGetEventDoneDataFunc)( void* param, AliHLTEventID_t eventID, unsigned long size, AliHLTComponentEventDoneData** edd );
 607     AliHLTfctLogging fLoggingFunc;
 608   };
 609 }
 610
 611 //////////////////////////////////////////////////////////////////////////
 612 //
 613 // Data type helper functions
 614 //
 615 //////////////////////////////////////////////////////////////////////////
 616
 617 inline bool operator==( const AliHLTComponentDataType& dt1, const AliHLTComponentDataType& dt2 )
 618 {
 619   bool any1=true, any2=true, void1=true, void2=true, match=true;
 620   for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ ) {
 621     any1&=(dt1.fOrigin[i]==kAliHLTDataOriginAny[i]);
 622     any2&=(dt2.fOrigin[i]==kAliHLTDataOriginAny[i]);
 623     void1&=(dt1.fOrigin[i]==kAliHLTDataOriginVoid[i]);
 624     void2&=(dt2.fOrigin[i]==kAliHLTDataOriginVoid[i]);
 625     match&=dt1.fOrigin[i]==dt2.fOrigin[i];
 626     if (!(match || (any2 && !void1) || (any1 && !void2)))
 627       return false;
 628   }
 629
 630   any1=true, any2=true, match=true;
 631   for ( int i = 0; i < kAliHLTComponentDataTypefIDsize; i++ ) {
 632     any1&=(dt1.fID[i]==kAliHLTAnyDataTypeID[i]);
 633     any2&=(dt2.fID[i]==kAliHLTAnyDataTypeID[i]);
 634     void1&=(dt1.fID[i]==kAliHLTVoidDataTypeID[i]);
 635     void2&=(dt2.fID[i]==kAliHLTVoidDataTypeID[i]);
 636     match&=dt1.fID[i]==dt2.fID[i];
 637     if (!(match || (any2 && !void1) || (any1 && !void2)))
 638       return false;
 639   }
 640   return true;
 641 }
 642
 643 inline bool operator!=( const AliHLTComponentDataType& dt1, const AliHLTComponentDataType& dt2 )
 644 {
 645   return !(dt1==dt2);
 646 }
 647
 648 inline bool MatchExactly( const AliHLTComponentDataType& dt1, const AliHLTComponentDataType& dt2 )
 649 {
 650   for ( int i = 0; i < kAliHLTComponentDataTypefIDsize; i++ )
 651     if ( dt1.fID[i] != dt2.fID[i] )
 652       return false;
 653   for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ )
 654     if ( dt1.fOrigin[i] != dt2.fOrigin[i] )
 655       return false;
 656   return true;
 657 }
 658
 659 inline AliHLTComponentDataType operator|(const AliHLTComponentDataType srcdt, const char origin[kAliHLTComponentDataTypefOriginSize])
 660 {
 661   AliHLTComponentDataType dt=srcdt;
 662   for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ )
 663     dt.fOrigin[i]=origin[i];
 664   return dt;
 665 }
 666
 667 #endif