changes according to coding conventions
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 28 Dec 2006 11:18:37 +0000 (11:18 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 28 Dec 2006 11:18:37 +0000 (11:18 +0000)
- special characters in function names have been removed in the
  internal usage, the C interface still uses them in order to preserve
  backward compatibility

37 files changed:
HLT/BASE/AliHLTComponent.cxx
HLT/BASE/AliHLTComponent.h
HLT/BASE/AliHLTComponentHandler.h
HLT/BASE/AliHLTConfiguration.cxx
HLT/BASE/AliHLTConfiguration.h
HLT/BASE/AliHLTDataBuffer.cxx
HLT/BASE/AliHLTDataBuffer.h
HLT/BASE/AliHLTDataSink.cxx
HLT/BASE/AliHLTDataSink.h
HLT/BASE/AliHLTDataSource.cxx
HLT/BASE/AliHLTDataSource.h
HLT/BASE/AliHLTDataTypes.h
HLT/BASE/AliHLTLogging.cxx
HLT/BASE/AliHLTLogging.h
HLT/BASE/AliHLTProcessor.cxx
HLT/BASE/AliHLTProcessor.h
HLT/BASE/AliHLTTask.h
HLT/BASE/AliHLT_C_Component_WrapperInterface.h
HLT/ChangeLog
HLT/SampleLib/AliHLTDummyComponent.cxx
HLT/SampleLib/AliHLTDummyComponent.h
HLT/SampleLib/AliHLTSampleComponent1.cxx
HLT/SampleLib/AliHLTSampleComponent1.h
HLT/SampleLib/AliHLTSampleComponent2.cxx
HLT/SampleLib/AliHLTSampleComponent2.h
HLT/TPCLib/AliHLTTPCClusterFinderComponent.cxx
HLT/TPCLib/AliHLTTPCClusterFinderComponent.h
HLT/TPCLib/AliHLTTPCDefinitions.cxx
HLT/TPCLib/AliHLTTPCDefinitions.h
HLT/TPCLib/AliHLTTPCGlobalMergerComponent.cxx
HLT/TPCLib/AliHLTTPCGlobalMergerComponent.h
HLT/TPCLib/AliHLTTPCRawDataUnpackerComponent.cxx
HLT/TPCLib/AliHLTTPCRawDataUnpackerComponent.h
HLT/TPCLib/AliHLTTPCSliceTrackerComponent.cxx
HLT/TPCLib/AliHLTTPCSliceTrackerComponent.h
HLT/TPCLib/AliHLTTPCVertexFinderComponent.cxx
HLT/TPCLib/AliHLTTPCVertexFinderComponent.h

index 7ddeecd..2f1c3fc 100644 (file)
@@ -94,7 +94,7 @@ int AliHLTComponent::DoDeinit()
   return 0;
 }
 
-void AliHLTComponent::DataType2Text( const AliHLTComponent_DataType& type, char output[14] ) {
+void AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type, char output[14] ) {
 memset( output, 0, 14 );
 strncat( output, type.fOrigin, 4 );
 strcat( output, ":" );
@@ -107,8 +107,8 @@ void* AliHLTComponent::AllocMemory( unsigned long size ) {
   return NULL;
 }
 
-int AliHLTComponent::MakeOutputDataBlockList( const vector<AliHLTComponent_BlockData>& blocks, AliHLTUInt32_t* blockCount,
-                                             AliHLTComponent_BlockData** outputBlocks ) {
+int AliHLTComponent::MakeOutputDataBlockList( const vector<AliHLTComponentBlockData>& blocks, AliHLTUInt32_t* blockCount,
+                                             AliHLTComponentBlockData** outputBlocks ) {
     if ( !blockCount || !outputBlocks )
        return EFAULT;
     AliHLTUInt32_t count = blocks.size();
@@ -118,7 +118,7 @@ int AliHLTComponent::MakeOutputDataBlockList( const vector<AliHLTComponent_Block
        *outputBlocks = NULL;
        return 0;
        }
-    *outputBlocks = reinterpret_cast<AliHLTComponent_BlockData*>( AllocMemory( sizeof(AliHLTComponent_BlockData)*count ) );
+    *outputBlocks = reinterpret_cast<AliHLTComponentBlockData*>( AllocMemory( sizeof(AliHLTComponentBlockData)*count ) );
     if ( !*outputBlocks )
        return ENOMEM;
     for ( unsigned long i = 0; i < count; i++ )
@@ -128,19 +128,19 @@ int AliHLTComponent::MakeOutputDataBlockList( const vector<AliHLTComponent_Block
 
 }
 
-int AliHLTComponent::GetEventDoneData( unsigned long size, AliHLTComponent_EventDoneData** edd ) {
+int AliHLTComponent::GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd ) {
   if (fEnvironment.fGetEventDoneDataFunc)
     return (*fEnvironment.fGetEventDoneDataFunc)(fEnvironment.fParam, fCurrentEvent, size, edd );
   return -ENOSYS;
 }
 
-int AliHLTComponent::FindMatchingDataTypes(AliHLTComponent* pConsumer, vector<AliHLTComponent_DataType>* tgtList) 
+int AliHLTComponent::FindMatchingDataTypes(AliHLTComponent* pConsumer, vector<AliHLTComponentDataType>* tgtList) 
 {
   int iResult=0;
   if (pConsumer) {
-    vector<AliHLTComponent_DataType> ctlist;
+    vector<AliHLTComponentDataType> ctlist;
     ((AliHLTComponent*)pConsumer)->GetInputDataTypes(ctlist);
-    vector<AliHLTComponent_DataType>::iterator type=ctlist.begin();
+    vector<AliHLTComponentDataType>::iterator type=ctlist.begin();
     while (type!=ctlist.end() && iResult==0) {
       if ((*type)==GetOutputDataType()) {
        if (tgtList) tgtList->push_back(*type);
index c20410e..efe730e 100644 (file)
@@ -16,6 +16,8 @@
  * @defgroup alihlt_component Component handling of the HLT module
  * This section describes the the component handling for the HLT module.
  */
+
+#include <vector>
 #include "AliHLTLogging.h"
 #include "AliHLTDataTypes.h"
 #include "AliHLTDefinitions.h"
@@ -93,11 +95,11 @@ class AliHLTComponent : public AliHLTLogging {
    * @param edd
    * @return neg. error code if failed
    */
-  virtual int ProcessEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                           AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+  virtual int ProcessEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                           AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
                            AliHLTUInt32_t& size, AliHLTUInt32_t& outputBlockCnt, 
-                           AliHLTComponent_BlockData*& outputBlocks,
-                           AliHLTComponent_EventDoneData*& edd ) = 0;
+                           AliHLTComponentBlockData*& outputBlocks,
+                           AliHLTComponentEventDoneData*& edd ) = 0;
 
   // Information member functions for registration.
 
@@ -121,14 +123,14 @@ class AliHLTComponent : public AliHLTLogging {
    * The function is pure virtual and must be implemented by the child class.
    * @return list of data types in the vector reference
    */
-  virtual void GetInputDataTypes( vector<AliHLTComponent_DataType>& ) = 0;
+  virtual void GetInputDataTypes( vector<AliHLTComponentDataType>& ) = 0;
 
   /**
    * Get the output data type of the component.
    * The function is pure virtual and must be implemented by the child class.
    * @return output data type
    */
-  virtual AliHLTComponent_DataType GetOutputDataType() = 0;
+  virtual AliHLTComponentDataType GetOutputDataType() = 0;
 
   /**
    * Get a ratio by how much the data volume is shrinked or enhanced.
@@ -156,7 +158,7 @@ class AliHLTComponent : public AliHLTLogging {
    * @param tgtList   reference to a vector list to receive the matching data types.
    * @return >= 0 success, neg. error code if failed
    */ 
-  int FindMatchingDataTypes(AliHLTComponent* pConsumer, vector<AliHLTComponent_DataType>* tgtList);
+  int FindMatchingDataTypes(AliHLTComponent* pConsumer, vector<AliHLTComponentDataType>* tgtList);
  
   /**
    * Set the global component handler.
@@ -173,10 +175,10 @@ class AliHLTComponent : public AliHLTLogging {
  protected:
 
   /**
-   * Fill AliHLTComponent_BlockData structure with default values.
+   * Fill AliHLTComponentBlockData structure with default values.
    * @param blockData   reference to data structure
    */
-  void FillBlockData( AliHLTComponent_BlockData& blockData ) {
+  void FillBlockData( AliHLTComponentBlockData& blockData ) {
     blockData.fStructSize = sizeof(blockData);
     FillShmData( blockData.fShmKey );
     blockData.fOffset = ~(AliHLTUInt32_t)0;
@@ -187,20 +189,20 @@ class AliHLTComponent : public AliHLTLogging {
   }
 
   /**
-   * Fill AliHLTComponent_ShmData structure with default values.
+   * Fill AliHLTComponentShmData structure with default values.
    * @param shmData   reference to data structure
    */
-  void FillShmData( AliHLTComponent_ShmData& shmData ) {
+  void FillShmData( AliHLTComponentShmData& shmData ) {
     shmData.fStructSize = sizeof(shmData);
-    shmData.fShmType = gkAliHLTComponent_InvalidShmType;
-    shmData.fShmID = gkAliHLTComponent_InvalidShmID;
+    shmData.fShmType = gkAliHLTComponentInvalidShmType;
+    shmData.fShmID = gkAliHLTComponentInvalidShmID;
   }
 
   /**
-   * Fill AliHLTComponent_DataType structure with default values.
+   * Fill AliHLTComponentDataType structure with default values.
    * @param dataType   reference to data structure
    */
-  void FillDataType( AliHLTComponent_DataType& dataType ) {
+  void FillDataType( AliHLTComponentDataType& dataType ) {
     dataType.fStructSize = sizeof(dataType);
     memset( dataType.fID, '*', 8 );
     memset( dataType.fOrigin, '*', 4 );
@@ -237,8 +239,8 @@ class AliHLTComponent : public AliHLTLogging {
    * framework. Function pointers are transferred via the @ref
    * AliHLTComponentEnvironment structure.
    */
-  int MakeOutputDataBlockList( const vector<AliHLTComponent_BlockData>& blocks, AliHLTUInt32_t* blockCount,
-                              AliHLTComponent_BlockData** outputBlocks );
+  int MakeOutputDataBlockList( const vector<AliHLTComponentBlockData>& blocks, AliHLTUInt32_t* blockCount,
+                              AliHLTComponentBlockData** outputBlocks );
 
   /**
    * Fill the EventDoneData structure.
@@ -246,12 +248,12 @@ class AliHLTComponent : public AliHLTLogging {
    * framework. Function pointers are transferred via the @ref
    * AliHLTComponentEnvironment structure.
    */
-  int GetEventDoneData( unsigned long size, AliHLTComponent_EventDoneData** edd );
+  int GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd );
 
   /**
    * Helper function to convert the data type to a string.
    */
-  void DataType2Text( const AliHLTComponent_DataType& type, char output[14] );
+  void DataType2Text( const AliHLTComponentDataType& type, char output[14] );
 
  private:
   /** The global component handler instance */
index 12d4000..0124dab 100644 (file)
                                                                           */
    
 
+#include <vector>
 #include "TObject.h"
 #include "AliHLTDataTypes.h"
 #include "AliHLTLogging.h"
 
 class AliHLTComponent;
 struct AliHLTComponentEnvironment;
-struct AliHLTComponent_DataType;
+struct AliHLTComponentDataType;
 
 typedef void* AliHLTLibHandle;
 
@@ -101,7 +102,7 @@ class AliHLTComponentHandler : public AliHLTLogging {
    *                  with the same output data type.
    * @return component id
    */
-  //const char* FindComponentType( AliHLTComponent_DataType dtype,
+  //const char* FindComponentType( AliHLTComponentDataType dtype,
   //                               const char* prevType = NULL )
   //  { return NULL;}
 
index 2fc1734..9fe5c19 100644 (file)
@@ -541,7 +541,7 @@ void AliHLTTask::PrintDependencyTree(const char* id, int bFromConfiguration)
 }
 
 /* this function is most likely depricated
-int AliHLTTask::InsertBlockData(AliHLTComponent_BlockData* pBlock, AliHLTTask* pSource)
+int AliHLTTask::InsertBlockData(AliHLTComponentBlockData* pBlock, AliHLTTask* pSource)
 {
   int iResult=0;
   return iResult;
@@ -623,7 +623,7 @@ int AliHLTTask::SetTarget(AliHLTTask* pTgt)
 }
 
 /* this function is most likely depricated
-int AliHLTTask::BuildBlockDataArray(AliHLTComponent_BlockData*& pBlockData)
+int AliHLTTask::BuildBlockDataArray(AliHLTComponentBlockData*& pBlockData)
 {
   int iResult=0;
   return iResult;
@@ -664,7 +664,7 @@ int AliHLTTask::StartRun()
       //iResult=Init( AliHLTComponentEnvironment* environ, void* environ_param, int argc, const char** argv );
 
       // allocate internal task varables for bookkeeping aso.
-      fpBlockDataArray=new AliHLTComponent_BlockData[iNofInputDataBlocks];
+      fpBlockDataArray=new AliHLTComponentBlockData[iNofInputDataBlocks];
       if (fpBlockDataArray) {
        fBlockDataArraySize=iNofInputDataBlocks;
       } else {
@@ -746,12 +746,12 @@ int AliHLTTask::ProcessTask()
       fpComponent->GetOutputDataSize(iConstBase, fInputMultiplier);
       int iOutputDataSize=int(fInputMultiplier*iInputDataVolume) + iConstBase;
       AliHLTUInt8_t* pTgtBuffer=fpDataBuffer->GetTargetBuffer(iOutputDataSize);
-      AliHLTComponent_EventData evtData;
-      AliHLTComponent_TriggerData trigData;
+      AliHLTComponentEventData evtData;
+      AliHLTComponentTriggerData trigData;
       AliHLTUInt32_t size=iOutputDataSize;
       AliHLTUInt32_t outputBlockCnt=0;
-      AliHLTComponent_BlockData* outputBlocks=NULL;
-      AliHLTComponent_EventDoneData* edd;
+      AliHLTComponentBlockData* outputBlocks=NULL;
+      AliHLTComponentEventDoneData* edd;
       if (pTgtBuffer!=NULL || iOutputDataSize==0) {
        iResult=fpComponent->ProcessEvent(evtData, fpBlockDataArray, trigData, pTgtBuffer, size, outputBlockCnt, outputBlocks, edd);
       } else {
@@ -824,7 +824,7 @@ int AliHLTTask::GetNofMatchingDataTypes(const AliHLTTask* pConsumerTask)
   return iResult;
 }
 
-int AliHLTTask::Subscribe(const AliHLTTask* pConsumerTask, AliHLTComponent_BlockData* pBlockDesc, int iArraySize)
+int AliHLTTask::Subscribe(const AliHLTTask* pConsumerTask, AliHLTComponentBlockData* pBlockDesc, int iArraySize)
 {
   int iResult=0;
   if (pConsumerTask) {
@@ -840,7 +840,7 @@ int AliHLTTask::Subscribe(const AliHLTTask* pConsumerTask, AliHLTComponent_Block
   return iResult;
 }
 
-int AliHLTTask::Release(AliHLTComponent_BlockData* pBlockDesc, const AliHLTTask* pConsumerTask)
+int AliHLTTask::Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTTask* pConsumerTask)
 {
   int iResult=0;
   if (pConsumerTask && pBlockDesc) {
index 7102704..913f495 100644 (file)
@@ -13,6 +13,7 @@
 */
 
 #include <cerrno>
+#include <vector>
 #include <TObject.h>
 #include <TList.h>
 #include "AliHLTDataTypes.h"
index 7a4a773..fc1bb5f 100644 (file)
@@ -193,7 +193,7 @@ int AliHLTDataBuffer::SetConsumer(AliHLTComponent* pConsumer)
   return iResult;
 }
 
-int AliHLTDataBuffer::FindMatchingDataBlocks(const AliHLTComponent* pConsumer, vector<AliHLTComponent_DataType>* tgtList)
+int AliHLTDataBuffer::FindMatchingDataBlocks(const AliHLTComponent* pConsumer, vector<AliHLTComponentDataType>* tgtList)
 {
   int iResult=0;
   if (pConsumer) {
@@ -218,11 +218,11 @@ int AliHLTDataBuffer::FindMatchingDataSegments(const AliHLTComponent* pConsumer,
 {
   int iResult=0;
   if (pConsumer) {
-    vector<AliHLTComponent_DataType> dtlist;
+    vector<AliHLTComponentDataType> dtlist;
     ((AliHLTComponent*)pConsumer)->GetInputDataTypes(dtlist);
     vector<AliHLTDataSegment>::iterator segment=fSegments.begin();
     while (segment!=fSegments.end()) {
-      vector<AliHLTComponent_DataType>::iterator type=dtlist.begin();
+      vector<AliHLTComponentDataType>::iterator type=dtlist.begin();
       while (type!=dtlist.end()) {
        if ((*segment).fDataType==(*type)) {
          tgtList.push_back(*segment);
@@ -239,7 +239,7 @@ int AliHLTDataBuffer::FindMatchingDataSegments(const AliHLTComponent* pConsumer,
   return iResult;
 }
 
-int AliHLTDataBuffer::Subscribe(const AliHLTComponent* pConsumer, AliHLTComponent_BlockData* arrayBlockDesc, int iArraySize)
+int AliHLTDataBuffer::Subscribe(const AliHLTComponent* pConsumer, AliHLTComponentBlockData* arrayBlockDesc, int iArraySize)
 {
   int iResult=0;
   if (pConsumer && arrayBlockDesc) {
@@ -256,11 +256,11 @@ int AliHLTDataBuffer::Subscribe(const AliHLTComponent* pConsumer, AliHLTComponen
          vector<AliHLTDataSegment>::iterator segment=tgtList.begin();
          while (segment!=tgtList.end() && i<iArraySize) {
            // fill the block data descriptor
-           arrayBlockDesc[i].fStructSize=sizeof(AliHLTComponent_BlockData);
+           arrayBlockDesc[i].fStructSize=sizeof(AliHLTComponentBlockData);
            // the shared memory key is not used in AliRoot
-           arrayBlockDesc[i].fShmKey.fStructSize=sizeof(AliHLTComponent_ShmData);
-           arrayBlockDesc[i].fShmKey.fShmType=gkAliHLTComponent_InvalidShmType;
-           arrayBlockDesc[i].fShmKey.fShmID=gkAliHLTComponent_InvalidShmID;
+           arrayBlockDesc[i].fShmKey.fStructSize=sizeof(AliHLTComponentShmData);
+           arrayBlockDesc[i].fShmKey.fShmType=gkAliHLTComponentInvalidShmType;
+           arrayBlockDesc[i].fShmKey.fShmID=gkAliHLTComponentInvalidShmID;
            arrayBlockDesc[i].fOffset=(*segment).fSegmentOffset;
            arrayBlockDesc[i].fPtr=fpBuffer->fPtr;
            arrayBlockDesc[i].fSize=(*segment).fSegmentSize;
@@ -276,7 +276,7 @@ int AliHLTDataBuffer::Subscribe(const AliHLTComponent* pConsumer, AliHLTComponen
            HLTDebug("component %p (%s) subscribed to data buffer %p", pConsumer, ((AliHLTComponent*)pConsumer)->GetComponentID(), this);
          } else {
            // TODO: cleanup the consumer descriptor correctly
-           memset(arrayBlockDesc, 0, iArraySize*sizeof(AliHLTComponent_BlockData));
+           memset(arrayBlockDesc, 0, iArraySize*sizeof(AliHLTComponentBlockData));
            HLTError("can not activate consumer %p for data buffer %p", pConsumer, this);
            iResult=-EACCES;
          }
@@ -299,7 +299,7 @@ int AliHLTDataBuffer::Subscribe(const AliHLTComponent* pConsumer, AliHLTComponen
   return iResult;
 }
 
-int AliHLTDataBuffer::Release(AliHLTComponent_BlockData* pBlockDesc, const AliHLTComponent* pConsumer)
+int AliHLTDataBuffer::Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTComponent* pConsumer)
 {
   int iResult=0;
   if (pBlockDesc && pConsumer) {
@@ -345,7 +345,7 @@ AliHLTUInt8_t* AliHLTDataBuffer::GetTargetBuffer(int iMinSize)
   return pTargetBuffer;
 }
 
-int AliHLTDataBuffer::SetSegments(AliHLTUInt8_t* pTgt, AliHLTComponent_BlockData* arrayBlockData, int iSize)
+int AliHLTDataBuffer::SetSegments(AliHLTUInt8_t* pTgt, AliHLTComponentBlockData* arrayBlockData, int iSize)
 {
   int iResult=0;
   if (pTgt && arrayBlockData && iSize>=0) {
index 00e111b..90a0ebc 100644 (file)
@@ -13,6 +13,7 @@
 */
 
 #include <cerrno>
+#include <vector>
 #include "AliHLTLogging.h"
 #include "AliHLTDataTypes.h"
 #include "AliHLTDefinitions.h"
@@ -36,7 +37,7 @@ struct AliHLTDataSegment {
     fSegmentSize(0),
     fSpecification(0)
   {
-    memset(&fDataType, 0, sizeof(AliHLTComponent_DataType));
+    memset(&fDataType, 0, sizeof(AliHLTComponentDataType));
   }
   AliHLTDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size) 
     :
@@ -45,10 +46,10 @@ struct AliHLTDataSegment {
     fSegmentSize(size),
     fSpecification(0)
   {
-    memset(&fDataType, 0, sizeof(AliHLTComponent_DataType));
+    memset(&fDataType, 0, sizeof(AliHLTComponentDataType));
   }
   /** the data type of this segment */
-  AliHLTComponent_DataType fDataType;
+  AliHLTComponentDataType fDataType;
   /** offset in byte within the data buffer */
   AliHLTUInt32_t fSegmentOffset;
   /** size of the actual content */
@@ -200,7 +201,7 @@ class AliHLTDataBuffer : public TObject, public AliHLTLogging {
    *          of the consumer, neg. error code if failed <br>
    *          -EINVAL       invalid parameter <br>
    */
-  int FindMatchingDataBlocks(const AliHLTComponent* pConsumer, vector<AliHLTComponent_DataType>* tgtList=NULL);
+  int FindMatchingDataBlocks(const AliHLTComponent* pConsumer, vector<AliHLTComponentDataType>* tgtList=NULL);
 
   /**
    * Subscribe to a segment of the data buffer.
@@ -219,7 +220,7 @@ class AliHLTDataBuffer : public TObject, public AliHLTLogging {
    *          -ENODATA      data buffer does not have raw data <br>
    *          -EINVAL       invalid parameter <br>
    */
-  int Subscribe(const AliHLTComponent* pConsumer, AliHLTComponent_BlockData* arrayBlockDesc, int iArraySize);
+  int Subscribe(const AliHLTComponent* pConsumer, AliHLTComponentBlockData* arrayBlockDesc, int iArraySize);
 
   /**
    * Release an instance of the data buffer.
@@ -234,7 +235,7 @@ class AliHLTDataBuffer : public TObject, public AliHLTLogging {
    *          -ENOENT       consumer component has not subscribed to the buffer <br>
    *          -EINVAL       invalid parameter <br>
    */
-  int Release(AliHLTComponent_BlockData* pBlockDesc, const AliHLTComponent* pConsumer);
+  int Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTComponent* pConsumer);
 
   /**
    * Get a target buffer of minimum size iMinSize.
@@ -251,13 +252,13 @@ class AliHLTDataBuffer : public TObject, public AliHLTLogging {
    * which was requested by the @ref GetTargetBuffer method. The component might
    * produce different types of data, for each type a segment has to be defined
    * which describes the data inside the bauffer.<br>
-   * The @ref AliHLTComponent_BlockData segment descriptor comes directly from the
+   * The @ref AliHLTComponentBlockData segment descriptor comes directly from the
    * @ref AliHLTComponent::ProcessEvent method.
    * @param pTgt            the target buffer which the segments refer to
    * @param arraySegments   the output block descriptors of the component
    * @param iSize           size of the array
    */
-  int SetSegments(AliHLTUInt8_t* pTgt, AliHLTComponent_BlockData* arraySegments, int iSize);
+  int SetSegments(AliHLTUInt8_t* pTgt, AliHLTComponentBlockData* arraySegments, int iSize);
 
   /**
    * Check if the data buffer is empty.
@@ -291,7 +292,7 @@ class AliHLTDataBuffer : public TObject, public AliHLTLogging {
 
  private:
   /* lets see if this is needed
-  AliHLTDataSegment* FindDataSegment(AliHLTComponent_DataType datatype);
+  AliHLTDataSegment* FindDataSegment(AliHLTComponentDataType datatype);
   */
 
   /**
index e67b70e..6e93dd3 100644 (file)
@@ -37,14 +37,14 @@ AliHLTDataSink::~AliHLTDataSink()
 { 
 }
 
-int AliHLTDataSink::ProcessEvent( const AliHLTComponent_EventData& evtData,
-                                   const AliHLTComponent_BlockData* blocks, 
-                                   AliHLTComponent_TriggerData& trigData,
+int AliHLTDataSink::ProcessEvent( const AliHLTComponentEventData& evtData,
+                                   const AliHLTComponentBlockData* blocks, 
+                                   AliHLTComponentTriggerData& trigData,
                                    AliHLTUInt8_t* outputPtr, 
                                    AliHLTUInt32_t& size,
                                    AliHLTUInt32_t& outputBlockCnt, 
-                                   AliHLTComponent_BlockData*& outputBlocks,
-                                   AliHLTComponent_EventDoneData*& edd )
+                                   AliHLTComponentBlockData*& outputBlocks,
+                                   AliHLTComponentEventDoneData*& edd )
 {
   int iResult=0;
   if (outputPtr==NULL
@@ -54,7 +54,7 @@ int AliHLTDataSink::ProcessEvent( const AliHLTComponent_EventData& evtData,
       && edd==NULL) {
     // this is currently just to get rid of the warning "unused parameter"
   }
-  vector<AliHLTComponent_BlockData> blockData;
+  vector<AliHLTComponentBlockData> blockData;
   iResult=DumpEvent(evtData, blocks, trigData);
   return iResult;
 }
index 2852e0b..abf0177 100644 (file)
@@ -43,14 +43,14 @@ class AliHLTDataSink : public AliHLTComponent {
    * preparation of data structures. The call is redirected to DumpEvent.
    * @return neg. error code if failed
    */
-  int ProcessEvent( const AliHLTComponent_EventData& evtData,
-                   const AliHLTComponent_BlockData* blocks, 
-                   AliHLTComponent_TriggerData& trigData,
+  int ProcessEvent( const AliHLTComponentEventData& evtData,
+                   const AliHLTComponentBlockData* blocks, 
+                   AliHLTComponentTriggerData& trigData,
                    AliHLTUInt8_t* outputPtr, 
                    AliHLTUInt32_t& size,
                    AliHLTUInt32_t& outputBlockCnt, 
-                   AliHLTComponent_BlockData*& outputBlocks,
-                   AliHLTComponent_EventDoneData*& edd );
+                   AliHLTComponentBlockData*& outputBlocks,
+                   AliHLTComponentEventDoneData*& edd );
 
   // Information member functions for registration.
 
@@ -67,9 +67,9 @@ class AliHLTDataSink : public AliHLTComponent {
    * @param blocks        input data block descriptors
    * @param trigData     trigger data structure
    */
-  virtual int DumpEvent( const AliHLTComponent_EventData& evtData,
-                        const AliHLTComponent_BlockData* blocks, 
-                        AliHLTComponent_TriggerData& trigData ) = 0;
+  virtual int DumpEvent( const AliHLTComponentEventData& evtData,
+                        const AliHLTComponentBlockData* blocks, 
+                        AliHLTComponentTriggerData& trigData ) = 0;
 
   ClassDef(AliHLTDataSink, 0)
 };
index 3bf57c1..435206e 100644 (file)
@@ -37,20 +37,20 @@ AliHLTDataSource::~AliHLTDataSource()
 { 
 }
 
-int AliHLTDataSource::ProcessEvent( const AliHLTComponent_EventData& evtData,
-                                   const AliHLTComponent_BlockData* blocks, 
-                                   AliHLTComponent_TriggerData& trigData,
+int AliHLTDataSource::ProcessEvent( const AliHLTComponentEventData& evtData,
+                                   const AliHLTComponentBlockData* blocks, 
+                                   AliHLTComponentTriggerData& trigData,
                                    AliHLTUInt8_t* outputPtr, 
                                    AliHLTUInt32_t& size,
                                    AliHLTUInt32_t& outputBlockCnt, 
-                                   AliHLTComponent_BlockData*& outputBlocks,
-                                   AliHLTComponent_EventDoneData*& edd )
+                                   AliHLTComponentBlockData*& outputBlocks,
+                                   AliHLTComponentEventDoneData*& edd )
 {
   int iResult=0;
   if (blocks) {
     // this is currently just to get rid of the warning "unused parameter"
   }
-  vector<AliHLTComponent_BlockData> blockData;
+  vector<AliHLTComponentBlockData> blockData;
   if (evtData.fBlockCnt > 0) {
     HLTWarning("Data source component skips imput data blocks");
   }
index 97a2295..869183e 100644 (file)
@@ -43,14 +43,14 @@ class AliHLTDataSource : public AliHLTComponent {
    * preparation of data structures. The call is redirected to GetEvent.
    * @return neg. error code if failed
    */
-  int ProcessEvent( const AliHLTComponent_EventData& evtData,
-                   const AliHLTComponent_BlockData* blocks, 
-                   AliHLTComponent_TriggerData& trigData,
+  int ProcessEvent( const AliHLTComponentEventData& evtData,
+                   const AliHLTComponentBlockData* blocks, 
+                   AliHLTComponentTriggerData& trigData,
                    AliHLTUInt8_t* outputPtr, 
                    AliHLTUInt32_t& size,
                    AliHLTUInt32_t& outputBlockCnt, 
-                   AliHLTComponent_BlockData*& outputBlocks,
-                   AliHLTComponent_EventDoneData*& edd );
+                   AliHLTComponentBlockData*& outputBlocks,
+                   AliHLTComponentEventDoneData*& edd );
 
   // Information member functions for registration.
 
@@ -71,11 +71,11 @@ class AliHLTDataSource : public AliHLTComponent {
    * @param outputBlocks  list to receive output block descriptors
    * @return
    */
-  virtual int GetEvent( const AliHLTComponent_EventData& evtData,
-                       AliHLTComponent_TriggerData& trigData,
+  virtual int GetEvent( const AliHLTComponentEventData& evtData,
+                       AliHLTComponentTriggerData& trigData,
                        AliHLTUInt8_t* outputPtr, 
                        AliHLTUInt32_t& size,
-                       vector<AliHLTComponent_BlockData>& outputBlocks ) = 0;
+                       vector<AliHLTComponentBlockData>& outputBlocks ) = 0;
 
   ClassDef(AliHLTDataSource, 0)
 };
index b17e7e8..a6f331f 100644 (file)
@@ -11,7 +11,6 @@
     @brief  Data type declaration for the HLT module.
 */
 
-#include <vector>
 using namespace std;
 
 extern "C" {
@@ -26,9 +25,9 @@ extern "C" {
 
   typedef AliHLTUInt64_t AliHLTEventID_t;
 
-  enum AliHLTComponent_LogSeverity { kHLTLogNone=0, kHLTLogBenchmark=1, kHLTLogDebug=2, kHLTLogInfo=4, kHLTLogWarning=8, kHLTLogError=16, kHLTLogFatal=32, kHLTLogAll=0x3f, kHLTLogDefault=0x39 };
+  enum AliHLTComponentLogSeverity { kHLTLogNone=0, kHLTLogBenchmark=1, kHLTLogDebug=2, kHLTLogInfo=4, kHLTLogWarning=8, kHLTLogError=16, kHLTLogFatal=32, kHLTLogAll=0x3f, kHLTLogDefault=0x39 };
 
-  struct AliHLTComponent_EventData
+  struct AliHLTComponentEventData
   {
     AliHLTUInt32_t fStructSize;
     AliHLTEventID_t fEventID;
@@ -37,48 +36,49 @@ extern "C" {
     AliHLTUInt32_t fBlockCnt;
   };
 
-  struct AliHLTComponent_ShmData
+  struct AliHLTComponentShmData
   {
     AliHLTUInt32_t fStructSize;
     AliHLTUInt32_t fShmType;
     AliHLTUInt64_t fShmID;
   };
-    const AliHLTUInt32_t gkAliHLTComponent_InvalidShmType = 0;
-    const AliHLTUInt64_t gkAliHLTComponent_InvalidShmID = ~(AliHLTUInt64_t)0;
 
-  struct AliHLTComponent_DataType
+    const AliHLTUInt32_t gkAliHLTComponentInvalidShmType = 0;
+    const AliHLTUInt64_t gkAliHLTComponentInvalidShmID = ~(AliHLTUInt64_t)0;
+
+  struct AliHLTComponentDataType
   {
     AliHLTUInt32_t fStructSize;
     char fID[8];
     char fOrigin[4];
   };
   
-  struct AliHLTComponent_BlockData
+  struct AliHLTComponentBlockData
   {
     AliHLTUInt32_t fStructSize;
-    AliHLTComponent_ShmData fShmKey;
+    AliHLTComponentShmData fShmKey;
     AliHLTUInt32_t fOffset;
     void* fPtr;
     AliHLTUInt32_t fSize;
-    AliHLTComponent_DataType fDataType;
+    AliHLTComponentDataType fDataType;
     AliHLTUInt32_t fSpecification;
   };
 
-  struct AliHLTComponent_TriggerData
+  struct AliHLTComponentTriggerData
   {
     AliHLTUInt32_t fStructSize;
     AliHLTUInt32_t fDataSize;
     void* fData;
   };
   
-  struct AliHLTComponent_EventDoneData
+  struct AliHLTComponentEventDoneData
   {
     AliHLTUInt32_t fStructSize;
     AliHLTUInt32_t fDataSize;
     void* fData;
   };
 
-  typedef int (*AliHLTfctLogging)( void* param, AliHLTComponent_LogSeverity severity, const char* origin, const char* keyword, const char* message );
+  typedef int (*AliHLTfctLogging)( void* param, AliHLTComponentLogSeverity severity, const char* origin, const char* keyword, const char* message );
 
   struct AliHLTComponentEnvironment
   {
@@ -86,15 +86,14 @@ extern "C" {
     void* fParam;
     void* (*fAllocMemoryFunc)( void* param, unsigned long size );
 #if 0
-    int (*fAllocShmMemoryFunc)( void* param, unsigned long size, AliHLTComponent_BlockData* blockLocation ); // future addition already foreseen/envisioned
+    int (*fAllocShmMemoryFunc)( void* param, unsigned long size, AliHLTComponentBlockData* blockLocation ); // future addition already foreseen/envisioned
 #endif
-/*     int (*fMakeOutputDataBlockListFunc)( void* param, const vector<AliHLTComponent_BlockData>& blocks, AliHLTUInt32_t* blockCount, AliHLTComponent_BlockData** outputBlocks ); */
-    int (*fGetEventDoneDataFunc)( void* param, AliHLTEventID_t eventID, unsigned long size, AliHLTComponent_EventDoneData** edd );
+    int (*fGetEventDoneDataFunc)( void* param, AliHLTEventID_t eventID, unsigned long size, AliHLTComponentEventDoneData** edd );
     AliHLTfctLogging fLoggingFunc;
   };
 }
 
-inline bool operator==( const AliHLTComponent_DataType& dt1, const AliHLTComponent_DataType& dt2 )
+inline bool operator==( const AliHLTComponentDataType& dt1, const AliHLTComponentDataType& dt2 )
     {
     for ( unsigned i = 0; i < 8; i++ )
        if ( dt1.fID[i] != dt2.fID[i] )
@@ -105,7 +104,7 @@ inline bool operator==( const AliHLTComponent_DataType& dt1, const AliHLTCompone
     return true;
     }
 
-inline bool operator!=( const AliHLTComponent_DataType& dt1, const AliHLTComponent_DataType& dt2 )
+inline bool operator!=( const AliHLTComponentDataType& dt1, const AliHLTComponentDataType& dt2 )
     {
     for ( unsigned i = 0; i < 8; i++ )
        if ( dt1.fID[i] != dt2.fID[i] )
index 2650e6e..26dd337 100644 (file)
@@ -61,7 +61,7 @@ AliHLTLogging& AliHLTLogging::operator=(const AliHLTLogging&)
   return *this;
 }
 
-AliHLTComponent_LogSeverity AliHLTLogging::fGlobalLogFilter=kHLTLogAll;
+AliHLTComponentLogSeverity AliHLTLogging::fGlobalLogFilter=kHLTLogAll;
 AliHLTfctLogging AliHLTLogging::fLoggingFunc=NULL;
 
 AliHLTLogging::~AliHLTLogging()
@@ -77,7 +77,7 @@ int AliHLTLogging::Init(AliHLTfctLogging pFun)
   return 0;
 }
 
-int AliHLTLogging::Message(void *param, AliHLTComponent_LogSeverity severity, const char* origin, const char* keyword, const char* message) {
+int AliHLTLogging::Message(void *param, AliHLTComponentLogSeverity severity, const char* origin, const char* keyword, const char* message) {
   int iResult=0;
   if (param==NULL) {
     // this is currently just to get rid of the warning "unused parameter"
@@ -135,7 +135,7 @@ const char* AliHLTLogging::BuildLogString(const char *format, va_list ap) {
   return gAliHLTLoggingBuffer;
 }
 
-int AliHLTLogging::Logging(AliHLTComponent_LogSeverity severity, const char* origin, const char* keyword, const char* format, ... ) {
+int AliHLTLogging::Logging(AliHLTComponentLogSeverity severity, const char* origin, const char* keyword, const char* format, ... ) {
   int iResult=CheckFilter(severity);
   if (iResult>0) {
     va_list args;
@@ -149,7 +149,7 @@ int AliHLTLogging::Logging(AliHLTComponent_LogSeverity severity, const char* ori
   return iResult;
 }
 
-int AliHLTLogging::LoggingVarargs( AliHLTComponent_LogSeverity severity, const char* origin_class, const char* origin_func,  ... ) const
+int AliHLTLogging::LoggingVarargs( AliHLTComponentLogSeverity severity, const char* origin_class, const char* origin_func,  ... ) const
 {
   int iResult=CheckFilter(severity);
   if (iResult>0) {
@@ -191,7 +191,7 @@ int AliHLTLogging::LoggingVarargs( AliHLTComponent_LogSeverity severity, const c
   return iResult;
 }
 
-int AliHLTLogging::CheckFilter(AliHLTComponent_LogSeverity severity) const
+int AliHLTLogging::CheckFilter(AliHLTComponentLogSeverity severity) const
 {
   int iResult=severity==kHLTLogNone || (severity&fGlobalLogFilter)>0 && (severity&fLocalLogFilter)>0;
   return iResult;
index 7e1b7c6..539dd5f 100644 (file)
@@ -46,11 +46,11 @@ public:
 
   // logging filter for all objects
   //
-  static AliHLTComponent_LogSeverity SetGlobalLogLevel(AliHLTComponent_LogSeverity iLogFilter) {fGlobalLogFilter=iLogFilter; return fGlobalLogFilter;}
+  static AliHLTComponentLogSeverity SetGlobalLogLevel(AliHLTComponentLogSeverity iLogFilter) {fGlobalLogFilter=iLogFilter; return fGlobalLogFilter;}
 
   // logging filter for individual object
   //
-  AliHLTComponent_LogSeverity SetLocalLogLevel(AliHLTComponent_LogSeverity iLogFilter) {fLocalLogFilter=iLogFilter; return fLocalLogFilter;}
+  AliHLTComponentLogSeverity SetLocalLogLevel(AliHLTComponentLogSeverity iLogFilter) {fLocalLogFilter=iLogFilter; return fLocalLogFilter;}
 
   // set the default key word
   // the keyword is intended to simplify the use of logging macros
@@ -79,17 +79,17 @@ public:
 
   // genaral logging function
   //
-  int Logging( AliHLTComponent_LogSeverity severity, const char* origin, const char* keyword, const char* message, ... );
+  int Logging( AliHLTComponentLogSeverity severity, const char* origin, const char* keyword, const char* message, ... );
 
   // logging function with two origin parameters, used by the log macros
   //
-  int LoggingVarargs( AliHLTComponent_LogSeverity severity, const char* origin_class, const char* origin_func,  ... ) const;
+  int LoggingVarargs( AliHLTComponentLogSeverity severity, const char* origin_class, const char* origin_func,  ... ) const;
 
   // apply filter, return 1 if message should pass
   //
-  int CheckFilter(AliHLTComponent_LogSeverity severity) const;
+  int CheckFilter(AliHLTComponentLogSeverity severity) const;
 
-  static int Message(void * param, AliHLTComponent_LogSeverity severity, const char* origin, const char* keyword, const char* message);
+  static int Message(void * param, AliHLTComponentLogSeverity severity, const char* origin, const char* keyword, const char* message);
 
   static const char* BuildLogString(const char *format, va_list ap);
 
@@ -97,8 +97,8 @@ public:
 protected:
 
 private:
-  static  AliHLTComponent_LogSeverity fGlobalLogFilter;
-  AliHLTComponent_LogSeverity fLocalLogFilter;
+  static  AliHLTComponentLogSeverity fGlobalLogFilter;
+  AliHLTComponentLogSeverity fLocalLogFilter;
   static AliHLTfctLogging fLoggingFunc;
   const char* fpDefaultKeyword;
   const char* fpCurrentKeyword;
index a846e07..09d0601 100644 (file)
@@ -53,14 +53,14 @@ int AliHLTProcessor::Deinit()
   return iResult;
 }
 
-int AliHLTProcessor::ProcessEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                           AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+int AliHLTProcessor::ProcessEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                           AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
                            AliHLTUInt32_t& size, AliHLTUInt32_t& outputBlockCnt, 
-                           AliHLTComponent_BlockData*& outputBlocks,
-                           AliHLTComponent_EventDoneData*& edd )
+                           AliHLTComponentBlockData*& outputBlocks,
+                           AliHLTComponentEventDoneData*& edd )
 {
   int iResult=0;
-  vector<AliHLTComponent_BlockData> blockData;
+  vector<AliHLTComponentBlockData> blockData;
   iResult=DoEvent(evtData, blocks, trigData, outputPtr, size, blockData);
   if (iResult>=0) {
     iResult=MakeOutputDataBlockList(blockData, &outputBlockCnt, &outputBlocks);
index 992cb56..89efb58 100644 (file)
@@ -46,14 +46,14 @@ class AliHLTProcessor : public AliHLTComponent {
    * preparation of data structures. The call is redirected to DoEvent.
    * @return neg. error code if failed 
    */
-  int ProcessEvent( const AliHLTComponent_EventData& evtData,
-                   const AliHLTComponent_BlockData* blocks, 
-                   AliHLTComponent_TriggerData& trigData,
+  int ProcessEvent( const AliHLTComponentEventData& evtData,
+                   const AliHLTComponentBlockData* blocks, 
+                   AliHLTComponentTriggerData& trigData,
                    AliHLTUInt8_t* outputPtr, 
                    AliHLTUInt32_t& size,
                    AliHLTUInt32_t& outputBlockCnt, 
-                   AliHLTComponent_BlockData*& outputBlocks,
-                   AliHLTComponent_EventDoneData*& edd );
+                   AliHLTComponentBlockData*& outputBlocks,
+                   AliHLTComponentEventDoneData*& edd );
 
   // Information member functions for registration.
 
@@ -74,12 +74,12 @@ class AliHLTProcessor : public AliHLTComponent {
    *                     <i>output</i>:size of produced data
    * @param outputBlocks  list to receive output block descriptors
    */
-  virtual int DoEvent( const AliHLTComponent_EventData& evtData,
-                      const AliHLTComponent_BlockData* blocks, 
-                      AliHLTComponent_TriggerData& trigData,
+  virtual int DoEvent( const AliHLTComponentEventData& evtData,
+                      const AliHLTComponentBlockData* blocks, 
+                      AliHLTComponentTriggerData& trigData,
                       AliHLTUInt8_t* outputPtr, 
                       AliHLTUInt32_t& size,
-                      vector<AliHLTComponent_BlockData>& outputBlocks ) = 0;
+                      vector<AliHLTComponentBlockData>& outputBlocks ) = 0;
 
   ClassDef(AliHLTProcessor, 0)
 };
index 43898fc..e014888 100644 (file)
@@ -18,7 +18,7 @@
 #include "AliHLTLogging.h"
 #include "AliHLTDataBuffer.h"
 
-struct AliHLTComponent_BlockData;
+struct AliHLTComponentBlockData;
 class AliHLTComponent;
 class AliHLTComponentHandler;
 
@@ -114,7 +114,7 @@ class AliHLTTask : public TObject, public AliHLTLogging {
    */
   /*
    * this function is most likely depricated
-  int InsertBlockData(AliHLTComponent_BlockData* pBlock, AliHLTTask* pSource);
+  int InsertBlockData(AliHLTComponentBlockData* pBlock, AliHLTTask* pSource);
   */
 
   /**
@@ -165,7 +165,7 @@ class AliHLTTask : public TObject, public AliHLTLogging {
   // @return: array size, pointer to array in the target pTgt
   //
   /* this function is most likely depricated
-  int BuildBlockDataArray(AliHLTComponent_BlockData*& pBlockData);
+  int BuildBlockDataArray(AliHLTComponentBlockData*& pBlockData);
   */
 
   /**
@@ -233,7 +233,7 @@ class AliHLTTask : public TObject, public AliHLTLogging {
    * @return number of matching data blocks, negative error code if failed
    */
   int Subscribe(const AliHLTTask* pConsumerTask,
-               AliHLTComponent_BlockData* arrayBlockDesc, int iArraySize);
+               AliHLTComponentBlockData* arrayBlockDesc, int iArraySize);
 
   /**
    * Release a block descriptor.
@@ -242,7 +242,7 @@ class AliHLTTask : public TObject, public AliHLTLogging {
    * @param pConsumerTask   the task which subscribed to the data
    * @return: >0 if success, negative error code if failed
    */
-  int Release(AliHLTComponent_BlockData* pBlockDesc,
+  int Release(AliHLTComponentBlockData* pBlockDesc,
              const AliHLTTask* pConsumerTask);
 
   /**
@@ -295,7 +295,7 @@ class AliHLTTask : public TObject, public AliHLTLogging {
    * @ref AliHLTComponent::ProcessEvent method. 
    * Filled through subscription to source tasks (@ref Subscribe).
    */
-  AliHLTComponent_BlockData* fpBlockDataArray;
+  AliHLTComponentBlockData* fpBlockDataArray;
   /** size of the block data array */
   int fBlockDataArraySize;
 
index 6563d70..cd388be 100644 (file)
  */
 
 #include <AliHLTDataTypes.h>
+typedef AliHLTComponentLogSeverity AliHLTComponent_LogSeverity;
+typedef AliHLTComponentEventData AliHLTComponent_EventData;
+typedef AliHLTComponentShmData AliHLTComponent_ShmData;
+typedef AliHLTComponentDataType AliHLTComponent_DataType;
+typedef AliHLTComponentBlockData AliHLTComponent_BlockData;
+typedef AliHLTComponentTriggerData AliHLTComponent_TriggerData;
+typedef AliHLTComponentEventDoneData AliHLTComponent_EventDoneData;
 
 #ifdef __cplusplus
 extern "C" {
@@ -80,7 +87,7 @@ void AliHLT_C_DestroyComponent( AliHLTComponentHandle );
  * 
  * @ingroup alihlt_wrapper_interface
  */
-int AliHLT_C_ProcessEvent( AliHLTComponentHandle, const AliHLTComponent_EventData* evtData, const AliHLTComponent_BlockData* blocks, 
+int AliHLT_C_ProcessEvent( AliHLTComponentHandle handle, const AliHLTComponent_EventData* evtData, const AliHLTComponent_BlockData* blocks, 
                            AliHLTComponent_TriggerData* trigData, AliHLTUInt8_t* outputPtr,
                            AliHLTUInt32_t* size, AliHLTUInt32_t* outputBlockCnt, 
                            AliHLTComponent_BlockData** outputBlocks,
index 5ec84a6..2288491 100644 (file)
@@ -1,3 +1,7 @@
+2006-12-28 changes according to coding conventions
+       - special characters in function names have been removed in the
+         internal usage, the C interface still uses them in order to preserve
+         backward compatibility
 2006-12-18 commit from Jochen
        - TPCDisplay library version 2
          - library version for the AliHLTGUI v 1.5
@@ -27,7 +31,7 @@
            component dead lock
          - AliHLTTPCClusterFinder adapted to use occupancy level for suppression of 
            noisy pads
-         - AliHLTTPCClusterFinderComponent: new parameter 'occupancy-limit' which is effectice
+         - AliHLTTPCClusterFinderComponent: new parameter 'occupancy-limit' which is effective
            when pp-run option is set
          - AliHLTTPCDigitReaderRaw
            2 more rawreader modes ( 4, 5) are added by Timm.
index 858d2fb..2b1c5c3 100644 (file)
@@ -48,14 +48,14 @@ const char* AliHLTDummyComponent::GetComponentID()
     return "Dummy"; // The ID of this component
     }
 
-void AliHLTDummyComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
+void AliHLTDummyComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
     {
     list.clear(); // We do not have any requirements for our input data type(s).
     }
 
-AliHLTComponent_DataType AliHLTDummyComponent::GetOutputDataType()
+AliHLTComponentDataType AliHLTDummyComponent::GetOutputDataType()
     {
-    return (AliHLTComponent_DataType){ sizeof(AliHLTComponent_DataType), {'D','U','M','M','Y',' ',' ',' '},{'D','U','M','Y'}};
+    return (AliHLTComponentDataType){ sizeof(AliHLTComponentDataType), {'D','U','M','M','Y',' ',' ',' '},{'D','U','M','Y'}};
     }
 
 void AliHLTDummyComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
@@ -110,9 +110,9 @@ int AliHLTDummyComponent::DoDeinit()
     return 0;
     }
 
-int AliHLTDummyComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                                     AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                                     AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
+int AliHLTDummyComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                                     AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                                     AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
     {
     Logging( kHLTLogInfo, "HLT::Dummy::DoEvent", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
     // Process an event
@@ -153,7 +153,7 @@ int AliHLTDummyComponent::DoEvent( const AliHLTComponent_EventData& evtData, con
        Logging( kHLTLogInfo, "HLT::Dummy::DoEvent", "Copied", "Copied: %lu B - totalSize: %lu B", 
                 copied, totalSize );
        // Fill a block data structure for our output block.
-       AliHLTComponent_BlockData ob;
+       AliHLTComponentBlockData ob;
        // Let the structure be filled with the default values.
        // This takes care of setting the shared memory and data type values to default values,
        // so that they can be filled in by the calling code.
index cba1d58..9554941 100644 (file)
@@ -31,8 +31,8 @@ class AliHLTDummyComponent : public AliHLTProcessor
        // These functions are required for the registration process
 
        const char* GetComponentID();
-       void GetInputDataTypes( vector<AliHLTComponent_DataType>& list);
-       AliHLTComponent_DataType GetOutputDataType();
+       void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+       AliHLTComponentDataType GetOutputDataType();
        virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
        AliHLTComponent* Spawn();
        
@@ -44,9 +44,9 @@ class AliHLTDummyComponent : public AliHLTProcessor
 
        int DoInit( int argc, const char** argv );
        int DoDeinit();
-       int DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                    AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                    AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks );
+       int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                    AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
        
     private:
 
index 05f27c0..0f6fb7e 100644 (file)
@@ -35,8 +35,8 @@ AliHLTSampleComponent1 gAliHLTSampleComponent1;
 
 ClassImp(AliHLTSampleComponent1)
 
-const AliHLTComponent_DataType AliHLTSampleComponent1::inputDataTypes[]={{0,0}, {0,0}}; //'zero' terminated array
-const AliHLTComponent_DataType AliHLTSampleComponent1::outputDataType={0,0};
+const AliHLTComponentDataType AliHLTSampleComponent1::inputDataTypes[]={{0,0}, {0,0}}; //'zero' terminated array
+const AliHLTComponentDataType AliHLTSampleComponent1::outputDataType={0,0};
 
 AliHLTSampleComponent1::AliHLTSampleComponent1()
 {
@@ -56,9 +56,9 @@ int AliHLTSampleComponent1::DoDeinit(){
   return 0;
 }
 
-int AliHLTSampleComponent1::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                                     AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                                     AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks ) {
+int AliHLTSampleComponent1::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                                     AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                                     AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks ) {
   Logging(kHLTLogInfo, "HLT", "Sample", "Sample component1, DoEvent");
   return 0;
 }
index 72d89e8..5b63854 100644 (file)
@@ -23,14 +23,14 @@ public:
   virtual ~AliHLTSampleComponent1();
 
   const char* GetComponentID() { return "Sample-component1";}
-  void GetInputDataTypes( vector<AliHLTComponent_DataType>& list) {
-    const AliHLTComponent_DataType* pType=inputDataTypes;
+  void GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
+    const AliHLTComponentDataType* pType=inputDataTypes;
     while (pType->fID!=0) {
       list.push_back(*pType);
       pType++;
     }
   }
-  AliHLTComponent_DataType GetOutputDataType() {return outputDataType;}
+  AliHLTComponentDataType GetOutputDataType() {return outputDataType;}
   virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {constBase = 0;inputMultiplier = 0;};
 
   // Spawn function, return new class instance
@@ -40,13 +40,13 @@ public:
   
   int DoInit( int argc, const char** argv );
   int DoDeinit();
-  int DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                      AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                      AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks );
+  int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                      AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                      AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
 
 private:
-  static const AliHLTComponent_DataType inputDataTypes[];
-  static const AliHLTComponent_DataType outputDataType;
+  static const AliHLTComponentDataType inputDataTypes[];
+  static const AliHLTComponentDataType outputDataType;
 
   ClassDef(AliHLTSampleComponent1, 0)
 };
index 59858cd..5ae9f21 100644 (file)
@@ -35,8 +35,8 @@ AliHLTSampleComponent2 gAliHLTSampleComponent2;
 
 ClassImp(AliHLTSampleComponent2)
 
-const AliHLTComponent_DataType AliHLTSampleComponent2::inputDataTypes[]={{0,0}, {0,0}}; //'zero' terminated array
-const AliHLTComponent_DataType AliHLTSampleComponent2::outputDataType={0,0};
+const AliHLTComponentDataType AliHLTSampleComponent2::inputDataTypes[]={{0,0}, {0,0}}; //'zero' terminated array
+const AliHLTComponentDataType AliHLTSampleComponent2::outputDataType={0,0};
 
 AliHLTSampleComponent2::AliHLTSampleComponent2()
 {
@@ -56,9 +56,9 @@ int AliHLTSampleComponent2::DoDeinit(){
   return 0;
 }
 
-int AliHLTSampleComponent2::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                                     AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                                     AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks ) {
+int AliHLTSampleComponent2::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                                     AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                                     AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks ) {
   Logging(kHLTLogInfo, "HLT", "Sample", "Sample component2, DoEvent");
   return 0;
 }
index 1b9793a..2090ce8 100644 (file)
@@ -23,14 +23,14 @@ public:
   virtual ~AliHLTSampleComponent2();
 
   const char* GetComponentID() { return "Sample-component2";}
-  void GetInputDataTypes( vector<AliHLTComponent_DataType>& list) {
-    const AliHLTComponent_DataType* pType=inputDataTypes;
+  void GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
+    const AliHLTComponentDataType* pType=inputDataTypes;
     while (pType->fID!=0) {
       list.push_back(*pType);
       pType++;
     }
   }
-  AliHLTComponent_DataType GetOutputDataType() {return outputDataType;}
+  AliHLTComponentDataType GetOutputDataType() {return outputDataType;}
   virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {constBase = 0;inputMultiplier = 0;};
 
   // Spawn function, return new class instance
@@ -40,13 +40,13 @@ public:
   
   int DoInit( int argc, const char** argv );
   int DoDeinit();
-  int DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                      AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                      AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks );
+  int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                      AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                      AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
 
 private:
-  static const AliHLTComponent_DataType inputDataTypes[];
-  static const AliHLTComponent_DataType outputDataType;
+  static const AliHLTComponentDataType inputDataTypes[];
+  static const AliHLTComponentDataType outputDataType;
 
   ClassDef(AliHLTSampleComponent2, 0)
 };
index 1b84d34..ce3de4d 100644 (file)
@@ -92,7 +92,7 @@ const char* AliHLTTPCClusterFinderComponent::GetComponentID()
       else return "TPCClusterFinderUnpacked";
     }
 
-void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
+void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
     {
     list.clear(); 
     if (fPackedSwitch) list.push_back( AliHLTTPCDefinitions::gkDDLPackedRawDataType );
@@ -100,7 +100,7 @@ void AliHLTTPCClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponent_
    
     }
 
-AliHLTComponent_DataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
+AliHLTComponentDataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
     {
     return AliHLTTPCDefinitions::gkClustersDataType;
     }
@@ -259,15 +259,15 @@ int AliHLTTPCClusterFinderComponent::DoDeinit()
     return 0;
     }
 
-int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponent_EventData& evtData, 
-                                             const AliHLTComponent_BlockData* blocks, 
-                                             AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponentEventData& evtData, 
+                                             const AliHLTComponentBlockData* blocks, 
+                                             AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
                                              AliHLTUInt32_t& size, 
-                                             vector<AliHLTComponent_BlockData>& outputBlocks )
+                                             vector<AliHLTComponentBlockData>& outputBlocks )
     {
 
     //  == init iter (pointer to datablock)
-    const AliHLTComponent_BlockData* iter = NULL;
+    const AliHLTComponentBlockData* iter = NULL;
     unsigned long ndx;
 
     //  == OUTdatatype pointer
@@ -341,7 +341,7 @@ int AliHLTTPCClusterFinderComponent::DoEvent( const AliHLTComponent_EventData& e
        Logging( kHLTLogDebug, "HLT::TPCClusterFinder::DoEvent", "Input Spacepoints", 
                 "Number of spacepoints: %lu Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
                 realPoints, slice, patch, row[0], row[1] );
-       AliHLTComponent_BlockData bd;
+       AliHLTComponentBlockData bd;
        FillBlockData( bd );
        bd.fOffset = offset;
        bd.fSize = mysize;
index b24ddba..6567684 100644 (file)
@@ -51,8 +51,8 @@ class AliHLTTPCClusterFinderComponent : public AliHLTProcessor
        // These functions are required for the registration process
 
        const char* GetComponentID();
-       void GetInputDataTypes( vector<AliHLTComponent_DataType>& list);
-       AliHLTComponent_DataType GetOutputDataType();
+       void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+       AliHLTComponentDataType GetOutputDataType();
        virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
        AliHLTComponent* Spawn();
        
@@ -64,9 +64,9 @@ class AliHLTTPCClusterFinderComponent : public AliHLTProcessor
 
        int DoInit( int argc, const char** argv );
        int DoDeinit();
-       int DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                    AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                    AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks );
+       int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                    AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
        
     private:
        /** the cluster finder object */
index e80fb63..813e5a5 100644 (file)
 
 ClassImp(AliHLTTPCDefinitions)
 
-const AliHLTComponent_DataType AliHLTTPCDefinitions::gkDDLPackedRawDataType = { sizeof(AliHLTComponent_DataType), {'D','D','L','_','R','W','P','K'},{'T','P','C',' '}};;
-const AliHLTComponent_DataType AliHLTTPCDefinitions::gkPackedRawDataType = { sizeof(AliHLTComponent_DataType), {'R','A','W','P','A','K','E','D'},{'T','P','C',' '}};;
-const AliHLTComponent_DataType AliHLTTPCDefinitions::gkUnpackedRawDataType = { sizeof(AliHLTComponent_DataType), {'R','A','W','U','N','P','A','K'},{'T','P','C',' '}};;
-const AliHLTComponent_DataType AliHLTTPCDefinitions::gkClustersDataType = { sizeof(AliHLTComponent_DataType), {'C','L','U','S','T','E','R','S'},{'T','P','C',' '}};;
-const AliHLTComponent_DataType AliHLTTPCDefinitions::gkVertexDataType = { sizeof(AliHLTComponent_DataType), {'V','E','R','T','E','X',' ',' '},{'T','P','C',' '}};;
-const AliHLTComponent_DataType AliHLTTPCDefinitions::gkTrackSegmentsDataType = { sizeof(AliHLTComponent_DataType), {'T','R','A','K','S','E','G','S'},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::gkDDLPackedRawDataType = { sizeof(AliHLTComponentDataType), {'D','D','L','_','R','W','P','K'},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::gkPackedRawDataType = { sizeof(AliHLTComponentDataType), {'R','A','W','P','A','K','E','D'},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::gkUnpackedRawDataType = { sizeof(AliHLTComponentDataType), {'R','A','W','U','N','P','A','K'},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::gkClustersDataType = { sizeof(AliHLTComponentDataType), {'C','L','U','S','T','E','R','S'},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::gkVertexDataType = { sizeof(AliHLTComponentDataType), {'V','E','R','T','E','X',' ',' '},{'T','P','C',' '}};;
+const AliHLTComponentDataType AliHLTTPCDefinitions::gkTrackSegmentsDataType = { sizeof(AliHLTComponentDataType), {'T','R','A','K','S','E','G','S'},{'T','P','C',' '}};;
 
     
index f58852b..90bcafc 100644 (file)
@@ -16,7 +16,7 @@ class AliHLTTPCDefinitions
     {
     public:
 
-       static AliHLTUInt8_t GetMinSliceNr( const AliHLTComponent_BlockData& block )
+       static AliHLTUInt8_t GetMinSliceNr( const AliHLTComponentBlockData& block )
                {
                return (AliHLTUInt8_t)( (block.fSpecification & 0x00FF0000) >> 16 );
                }
@@ -24,7 +24,7 @@ class AliHLTTPCDefinitions
                {
                return (AliHLTUInt8_t)( (spec & 0x00FF0000) >> 16 );
                }
-       static AliHLTUInt8_t GetMaxSliceNr( const AliHLTComponent_BlockData& block )
+       static AliHLTUInt8_t GetMaxSliceNr( const AliHLTComponentBlockData& block )
                {
                return (AliHLTUInt8_t)( (block.fSpecification & 0xFF000000) >> 24 );
                }
@@ -32,7 +32,7 @@ class AliHLTTPCDefinitions
                {
                return (AliHLTUInt8_t)( (spec & 0xFF000000) >> 24 );
                }
-       static AliHLTUInt8_t GetMinPatchNr( const AliHLTComponent_BlockData& block )
+       static AliHLTUInt8_t GetMinPatchNr( const AliHLTComponentBlockData& block )
                {
                return (AliHLTUInt8_t)( (block.fSpecification & 0x000000FF) );
                }
@@ -40,7 +40,7 @@ class AliHLTTPCDefinitions
                {
                return (AliHLTUInt8_t)( (spec & 0x000000FF) );
                }
-       static AliHLTUInt8_t GetMaxPatchNr( const AliHLTComponent_BlockData& block )
+       static AliHLTUInt8_t GetMaxPatchNr( const AliHLTComponentBlockData& block )
                {
                return (AliHLTUInt8_t)( (block.fSpecification & 0x0000FF00) >> 8 );
                }
@@ -57,12 +57,12 @@ class AliHLTTPCDefinitions
                return ((maxSliceNr & 0xFF) << 24) | ((minSliceNr & 0xFF) << 16) | ((maxPatchNr & 0xFF) << 8) | ((minPatchNr & 0xFF));
                }
 
-       static const AliHLTComponent_DataType gkDDLPackedRawDataType;
-       static const AliHLTComponent_DataType gkPackedRawDataType;
-       static const AliHLTComponent_DataType gkUnpackedRawDataType;
-       static const AliHLTComponent_DataType gkClustersDataType;
-       static const AliHLTComponent_DataType gkTrackSegmentsDataType;
-       static const AliHLTComponent_DataType gkVertexDataType;
+       static const AliHLTComponentDataType gkDDLPackedRawDataType;
+       static const AliHLTComponentDataType gkPackedRawDataType;
+       static const AliHLTComponentDataType gkUnpackedRawDataType;
+       static const AliHLTComponentDataType gkClustersDataType;
+       static const AliHLTComponentDataType gkTrackSegmentsDataType;
+       static const AliHLTComponentDataType gkVertexDataType;
 
        ClassDef(AliHLTTPCDefinitions, 0)
 
index 94433db..249096d 100644 (file)
@@ -62,14 +62,14 @@ const char* AliHLTTPCGlobalMergerComponent::GetComponentID()
     return "TPCGlobalMerger";
     }
 
-void AliHLTTPCGlobalMergerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
+void AliHLTTPCGlobalMergerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
     {
     list.clear();
     list.push_back( AliHLTTPCDefinitions::gkTrackSegmentsDataType );
     list.push_back( AliHLTTPCDefinitions::gkVertexDataType );
     }
 
-AliHLTComponent_DataType AliHLTTPCGlobalMergerComponent::GetOutputDataType()
+AliHLTComponentDataType AliHLTTPCGlobalMergerComponent::GetOutputDataType()
     {
     return AliHLTTPCDefinitions::gkTrackSegmentsDataType;
     }
@@ -112,12 +112,12 @@ int AliHLTTPCGlobalMergerComponent::DoDeinit()
     return 0;
     }
 
-int AliHLTTPCGlobalMergerComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                                             AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                                             AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
+int AliHLTTPCGlobalMergerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                                             AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                                             AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
     {
-    const AliHLTComponent_BlockData* iter = NULL;
-    const AliHLTComponent_BlockData* lastVertexBlock = NULL;
+    const AliHLTComponentBlockData* iter = NULL;
+    const AliHLTComponentBlockData* lastVertexBlock = NULL;
     unsigned long ndx;
 
     std::vector<SliceData> slices;
@@ -249,7 +249,7 @@ int AliHLTTPCGlobalMergerComponent::DoEvent( const AliHLTComponent_EventData& ev
 
     tSize += sizeof(AliHLTTPCTrackletData);
 
-    AliHLTComponent_BlockData bd;
+    AliHLTComponentBlockData bd;
     FillBlockData( bd );
     bd.fOffset = 0;
     bd.fSize = tSize;
index 9ce9786..97722c9 100644 (file)
@@ -25,8 +25,8 @@ class AliHLTTPCGlobalMergerComponent : public AliHLTProcessor
        // These functions are required for the registration process
 
        const char* GetComponentID();
-       void GetInputDataTypes( vector<AliHLTComponent_DataType>& list);
-       AliHLTComponent_DataType GetOutputDataType();
+       void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+       AliHLTComponentDataType GetOutputDataType();
        virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
        AliHLTComponent* Spawn();
        
@@ -41,9 +41,9 @@ class AliHLTTPCGlobalMergerComponent : public AliHLTProcessor
 
        int DoInit( int argc, const char** argv );
        int DoDeinit();
-       int DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                    AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                    AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks );
+       int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                    AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
        
     private:
 
@@ -53,9 +53,9 @@ class AliHLTTPCGlobalMergerComponent : public AliHLTProcessor
        struct SliceData
            {
                int fSlice;
-               const AliHLTComponent_BlockData* fVertexBlock;
+               const AliHLTComponentBlockData* fVertexBlock;
                unsigned fVertexBlockIndex;
-               const AliHLTComponent_BlockData* fTrackletBlock;
+               const AliHLTComponentBlockData* fTrackletBlock;
                unsigned fTrackletBlockIndex;
            };
 
index f33f243..402dddc 100644 (file)
@@ -59,13 +59,13 @@ const char* AliHLTTPCRawDataUnpackerComponent::GetComponentID()
     return "TPCRawDataUnpacker";
     }
 
-void AliHLTTPCRawDataUnpackerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
+void AliHLTTPCRawDataUnpackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
     {
     list.clear();
     list.push_back( AliHLTTPCDefinitions::gkDDLPackedRawDataType );
     }
 
-AliHLTComponent_DataType AliHLTTPCRawDataUnpackerComponent::GetOutputDataType()
+AliHLTComponentDataType AliHLTTPCRawDataUnpackerComponent::GetOutputDataType()
     {
     return AliHLTTPCDefinitions::gkUnpackedRawDataType;
     }
@@ -131,11 +131,11 @@ int AliHLTTPCRawDataUnpackerComponent::DoDeinit()
     return 0;
     }
 
-int AliHLTTPCRawDataUnpackerComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                                             AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                                             AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
+int AliHLTTPCRawDataUnpackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                                             AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                                             AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
     {
-    const AliHLTComponent_BlockData* iter = NULL;
+    const AliHLTComponentBlockData* iter = NULL;
     unsigned long ndx;
 
     AliHLTUInt8_t* outBPtr;
@@ -237,7 +237,7 @@ int AliHLTTPCRawDataUnpackerComponent::DoEvent( const AliHLTComponent_EventData&
                     sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData), currentRow->fNDigit );
            }
 
-       AliHLTComponent_BlockData bd;
+       AliHLTComponentBlockData bd;
        FillBlockData( bd );
        bd.fOffset = outputSize-blockOutputSize;
        bd.fSize = blockOutputSize;
index cd0ac25..4e08c1f 100644 (file)
@@ -25,8 +25,8 @@ class AliHLTTPCRawDataUnpackerComponent : public AliHLTProcessor
        // These functions are required for the registration process
 
        const char* GetComponentID();
-       void GetInputDataTypes( vector<AliHLTComponent_DataType>& list);
-       AliHLTComponent_DataType GetOutputDataType();
+       void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+       AliHLTComponentDataType GetOutputDataType();
        virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
        AliHLTComponent* Spawn();
        
@@ -38,9 +38,9 @@ class AliHLTTPCRawDataUnpackerComponent : public AliHLTProcessor
 
        int DoInit( int argc, const char** argv );
        int DoDeinit();
-       int DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                    AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                    AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks );
+       int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                    AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
        
     private:
 
index 8b8ebea..d5277e4 100644 (file)
@@ -74,14 +74,14 @@ const char* AliHLTTPCSliceTrackerComponent::GetComponentID()
     return "TPCSliceTracker";
     }
 
-void AliHLTTPCSliceTrackerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
+void AliHLTTPCSliceTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
     {
     list.clear();
     list.push_back( AliHLTTPCDefinitions::gkClustersDataType );
     list.push_back( AliHLTTPCDefinitions::gkVertexDataType );
     }
 
-AliHLTComponent_DataType AliHLTTPCSliceTrackerComponent::GetOutputDataType()
+AliHLTComponentDataType AliHLTTPCSliceTrackerComponent::GetOutputDataType()
     {
     return AliHLTTPCDefinitions::gkTrackSegmentsDataType;
     }
@@ -419,9 +419,9 @@ int AliHLTTPCSliceTrackerComponent::DoDeinit()
     return 0;
     }
 
-int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                                             AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                                             AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
+int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                                             AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                                             AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
     {
     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "DoEvent()" );
     if ( evtData.fBlockCnt<=0 )
@@ -429,11 +429,11 @@ int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponent_EventData& ev
        Logging( kHLTLogWarning, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "no blocks in event" );
        return 0;
       }
-    const AliHLTComponent_BlockData* iter = NULL;
+    const AliHLTComponentBlockData* iter = NULL;
     unsigned long ndx;
     AliHLTTPCClusterData* inPtrSP;
     AliHLTTPCVertexData* inPtrV = NULL;
-    const AliHLTComponent_BlockData* vertexIter=NULL;
+    const AliHLTComponentBlockData* vertexIter=NULL;
     AliHLTTPCTrackletData* outPtr;
     AliHLTUInt8_t* outBPtr;
     AliHLTUInt32_t vSize = 0;
@@ -638,7 +638,7 @@ int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponent_EventData& ev
     tSize += mysize+sizeof(AliHLTTPCTrackletData);
     outBPtr += mysize+sizeof(AliHLTTPCTrackletData);
     
-    AliHLTComponent_BlockData bd;
+    AliHLTComponentBlockData bd;
     FillBlockData( bd );
     bd.fOffset = offset;
     bd.fSize = tSize;
index ea93cbd..eec35f5 100644 (file)
@@ -25,8 +25,8 @@ class AliHLTTPCSliceTrackerComponent : public AliHLTProcessor
        // These functions are required for the registration process
 
        const char* GetComponentID();
-       void GetInputDataTypes( vector<AliHLTComponent_DataType>& list);
-       AliHLTComponent_DataType GetOutputDataType();
+       void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+       AliHLTComponentDataType GetOutputDataType();
        virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
        AliHLTComponent* Spawn();
        
@@ -55,9 +55,9 @@ class AliHLTTPCSliceTrackerComponent : public AliHLTProcessor
 
        int DoInit( int argc, const char** argv );
        int DoDeinit();
-       int DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                    AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                    AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks );
+       int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                    AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
        
     private:
 
index 1351fb7..fe23aa8 100644 (file)
@@ -57,13 +57,13 @@ const char* AliHLTTPCVertexFinderComponent::GetComponentID()
     return "TPCVertexFinder";
     }
 
-void AliHLTTPCVertexFinderComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
+void AliHLTTPCVertexFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
     {
     list.clear();
     list.push_back( AliHLTTPCDefinitions::gkClustersDataType );
     }
 
-AliHLTComponent_DataType AliHLTTPCVertexFinderComponent::GetOutputDataType()
+AliHLTComponentDataType AliHLTTPCVertexFinderComponent::GetOutputDataType()
     {
     return AliHLTTPCDefinitions::gkVertexDataType;
     }
@@ -98,11 +98,11 @@ int AliHLTTPCVertexFinderComponent::DoDeinit()
     return 0;
     }
 
-int AliHLTTPCVertexFinderComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                                             AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                                             AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
+int AliHLTTPCVertexFinderComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                                             AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                                             AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
     {
-    const AliHLTComponent_BlockData* iter = NULL;
+    const AliHLTComponentBlockData* iter = NULL;
     unsigned long ndx;
 
     AliHLTTPCClusterData* inPtr;
@@ -146,7 +146,7 @@ int AliHLTTPCVertexFinderComponent::DoEvent( const AliHLTComponent_EventData& ev
 
        mysize += sizeof(AliHLTTPCVertexData);
        
-       AliHLTComponent_BlockData bd;
+       AliHLTComponentBlockData bd;
        FillBlockData( bd );
        bd.fOffset = offset;
        bd.fSize = mysize;
index d9cbd12..4a17f08 100644 (file)
@@ -24,8 +24,8 @@ class AliHLTTPCVertexFinderComponent : public AliHLTProcessor
        // These functions are required for the registration process
 
        const char* GetComponentID();
-       void GetInputDataTypes( vector<AliHLTComponent_DataType>& list);
-       AliHLTComponent_DataType GetOutputDataType();
+       void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+       AliHLTComponentDataType GetOutputDataType();
        virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
        AliHLTComponent* Spawn();
        
@@ -37,9 +37,9 @@ class AliHLTTPCVertexFinderComponent : public AliHLTProcessor
 
        int DoInit( int argc, const char** argv );
        int DoDeinit();
-       int DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
-                    AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
-                    AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks );
+       int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                    AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
        
     private: