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, ":" );
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();
*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++ )
}
-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);
* @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"
* @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.
* 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.
* @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.
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;
}
/**
- * 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 );
* 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.
* 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 */
*/
+#include <vector>
#include "TObject.h"
#include "AliHLTDataTypes.h"
#include "AliHLTLogging.h"
class AliHLTComponent;
struct AliHLTComponentEnvironment;
-struct AliHLTComponent_DataType;
+struct AliHLTComponentDataType;
typedef void* AliHLTLibHandle;
* 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;}
}
/* 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;
}
/* this function is most likely depricated
-int AliHLTTask::BuildBlockDataArray(AliHLTComponent_BlockData*& pBlockData)
+int AliHLTTask::BuildBlockDataArray(AliHLTComponentBlockData*& pBlockData)
{
int iResult=0;
return iResult;
//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 {
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 {
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) {
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) {
*/
#include <cerrno>
+#include <vector>
#include <TObject.h>
#include <TList.h>
#include "AliHLTDataTypes.h"
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) {
{
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);
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) {
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;
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;
}
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) {
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) {
*/
#include <cerrno>
+#include <vector>
#include "AliHLTLogging.h"
#include "AliHLTDataTypes.h"
#include "AliHLTDefinitions.h"
fSegmentSize(0),
fSpecification(0)
{
- memset(&fDataType, 0, sizeof(AliHLTComponent_DataType));
+ memset(&fDataType, 0, sizeof(AliHLTComponentDataType));
}
AliHLTDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size)
:
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 */
* 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.
* -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.
* -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.
* 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.
private:
/* lets see if this is needed
- AliHLTDataSegment* FindDataSegment(AliHLTComponent_DataType datatype);
+ AliHLTDataSegment* FindDataSegment(AliHLTComponentDataType datatype);
*/
/**
{
}
-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
&& 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;
}
* 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.
* @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)
};
{
}
-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");
}
* 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.
* @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)
};
@brief Data type declaration for the HLT module.
*/
-#include <vector>
using namespace std;
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;
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
{
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] )
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] )
return *this;
}
-AliHLTComponent_LogSeverity AliHLTLogging::fGlobalLogFilter=kHLTLogAll;
+AliHLTComponentLogSeverity AliHLTLogging::fGlobalLogFilter=kHLTLogAll;
AliHLTfctLogging AliHLTLogging::fLoggingFunc=NULL;
AliHLTLogging::~AliHLTLogging()
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"
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;
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) {
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;
// 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
// 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);
protected:
private:
- static AliHLTComponent_LogSeverity fGlobalLogFilter;
- AliHLTComponent_LogSeverity fLocalLogFilter;
+ static AliHLTComponentLogSeverity fGlobalLogFilter;
+ AliHLTComponentLogSeverity fLocalLogFilter;
static AliHLTfctLogging fLoggingFunc;
const char* fpDefaultKeyword;
const char* fpCurrentKeyword;
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);
* 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.
* <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)
};
#include "AliHLTLogging.h"
#include "AliHLTDataBuffer.h"
-struct AliHLTComponent_BlockData;
+struct AliHLTComponentBlockData;
class AliHLTComponent;
class AliHLTComponentHandler;
*/
/*
* this function is most likely depricated
- int InsertBlockData(AliHLTComponent_BlockData* pBlock, AliHLTTask* pSource);
+ int InsertBlockData(AliHLTComponentBlockData* pBlock, AliHLTTask* pSource);
*/
/**
// @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);
*/
/**
* @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.
* @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);
/**
* @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;
*/
#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" {
*
* @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,
+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
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.
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 )
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
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.
// 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();
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:
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()
{
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;
}
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
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)
};
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()
{
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;
}
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
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)
};
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 );
}
-AliHLTComponent_DataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
+AliHLTComponentDataType AliHLTTPCClusterFinderComponent::GetOutputDataType()
{
return AliHLTTPCDefinitions::gkClustersDataType;
}
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
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;
// 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();
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 */
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',' '}};;
{
public:
- static AliHLTUInt8_t GetMinSliceNr( const AliHLTComponent_BlockData& block )
+ static AliHLTUInt8_t GetMinSliceNr( const AliHLTComponentBlockData& block )
{
return (AliHLTUInt8_t)( (block.fSpecification & 0x00FF0000) >> 16 );
}
{
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 );
}
{
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) );
}
{
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 );
}
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)
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;
}
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;
tSize += sizeof(AliHLTTPCTrackletData);
- AliHLTComponent_BlockData bd;
+ AliHLTComponentBlockData bd;
FillBlockData( bd );
bd.fOffset = 0;
bd.fSize = tSize;
// 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();
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:
struct SliceData
{
int fSlice;
- const AliHLTComponent_BlockData* fVertexBlock;
+ const AliHLTComponentBlockData* fVertexBlock;
unsigned fVertexBlockIndex;
- const AliHLTComponent_BlockData* fTrackletBlock;
+ const AliHLTComponentBlockData* fTrackletBlock;
unsigned fTrackletBlockIndex;
};
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;
}
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;
sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData), currentRow->fNDigit );
}
- AliHLTComponent_BlockData bd;
+ AliHLTComponentBlockData bd;
FillBlockData( bd );
bd.fOffset = outputSize-blockOutputSize;
bd.fSize = blockOutputSize;
// 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();
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:
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;
}
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 )
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;
tSize += mysize+sizeof(AliHLTTPCTrackletData);
outBPtr += mysize+sizeof(AliHLTTPCTrackletData);
- AliHLTComponent_BlockData bd;
+ AliHLTComponentBlockData bd;
FillBlockData( bd );
bd.fOffset = offset;
bd.fSize = tSize;
// 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();
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:
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;
}
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;
mysize += sizeof(AliHLTTPCVertexData);
- AliHLTComponent_BlockData bd;
+ AliHLTComponentBlockData bd;
FillBlockData( bd );
bd.fOffset = offset;
bd.fSize = mysize;
// 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();
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:
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff