+
+AliHLTUInt32_t AliHLTComponent::GetRunNo() const
+{
+ // see header file for function documentation
+ if (fpRunDesc==NULL) return kAliHLTVoidRunNo;
+ return fpRunDesc->fRunNo;
+}
+
+AliHLTUInt32_t AliHLTComponent::GetRunType() const
+{
+ // see header file for function documentation
+ if (fpRunDesc==NULL) return kAliHLTVoidRunType;
+ return fpRunDesc->fRunType;
+}
+
+bool AliHLTComponent::IsDataEvent(AliHLTUInt32_t* pTgt)
+{
+ // see header file for function documentation
+ if (pTgt) *pTgt=fEventType;
+ return (fEventType==gkAliEventTypeData ||
+ fEventType==gkAliEventTypeDataReplay ||
+ fEventType==gkAliEventTypeCalibration);
+}
+
+int AliHLTComponent::CopyStruct(void* pStruct, unsigned int iStructSize, unsigned int iBlockNo,
+ const char* structname, const char* eventname)
+{
+ // see header file for function documentation
+ int iResult=0;
+ if (pStruct!=NULL && iStructSize>sizeof(AliHLTUInt32_t)) {
+ if (fpInputBlocks!=NULL && iBlockNo<fCurrentEventData.fBlockCnt) {
+ AliHLTUInt32_t* pTgt=(AliHLTUInt32_t*)pStruct;
+ if (fpInputBlocks[iBlockNo].fPtr && fpInputBlocks[iBlockNo].fSize) {
+ AliHLTUInt32_t copy=*((AliHLTUInt32_t*)fpInputBlocks[iBlockNo].fPtr);
+ if (fpInputBlocks[iBlockNo].fSize!=copy) {
+ HLTWarning("%s event: mismatch of block size (%d) and structure size (%d)", eventname, fpInputBlocks[iBlockNo].fSize, copy);
+ if (copy>fpInputBlocks[iBlockNo].fSize) copy=fpInputBlocks[iBlockNo].fSize;
+ }
+ if (copy!=iStructSize) {
+ HLTWarning("%s event: mismatch in %s version (data type version %d)", eventname, structname, ALIHLT_DATA_TYPES_VERSION);
+ if (copy>iStructSize) {
+ copy=iStructSize;
+ } else {
+ memset(pTgt, 0, iStructSize);
+ }
+ }
+ memcpy(pTgt, fpInputBlocks[iBlockNo].fPtr, copy);
+ *pTgt=iStructSize;
+ iResult=copy;
+ } else {
+ HLTWarning("%s event: missing data block", eventname);
+ }
+ } else {
+ iResult=-ENODATA;
+ }
+ } else {
+ HLTError("invalid struct");
+ iResult=-EINVAL;
+ }
+ return iResult;
+}
+
+void AliHLTComponent::SetDDLBit(AliHLTEventDDL &list, Int_t ddlId, Bool_t state ) const
+{
+ // see header file for function documentation
+
+ // -- Detector offset
+ Int_t ddlIdBase = TMath::FloorNint( (Double_t) ddlId / 256.0 );
+
+ // -- Word Base = 1. word of detector ( TPC has 8 words, TOF 3 )
+ Int_t wordBase = 0;
+
+ if ( ddlIdBase <= 3 )
+ wordBase = ddlIdBase;
+ else if ( ddlIdBase > 3 && ddlIdBase < 5 )
+ wordBase = ddlIdBase + 7;
+ else
+ wordBase = ddlIdBase + 9;
+
+ // -- Bit index in Word
+ Int_t bitIdx = ddlId % 32;
+
+ // -- Index of word
+ Int_t wordIdx = wordBase;
+
+ // -- if TPC (3) or TOD (5) add word idx
+ if ( ( ddlIdBase == 3 ) || ( ddlIdBase == 5 ) ) {
+ wordIdx += TMath::FloorNint( (Double_t) ( ddlId - ( ddlIdBase * 256 ) ) / 32.0 );
+ }
+
+ // -- Set -- 'OR' word with bit mask;
+ if ( state )
+ list.fList[wordIdx] |= ( 0x00000001 << bitIdx );
+ // -- Unset -- 'AND' word with bit mask;
+ else
+ list.fList[wordIdx] &= ( 0xFFFFFFFF ^ ( 0x00000001 << bitIdx ) );
+}
+
+Int_t AliHLTComponent::GetFirstUsedDDLWord(AliHLTEventDDL &list) const
+{
+ // see header file for function documentation
+
+ Int_t iResult = -1;
+
+ for ( Int_t wordNdx = 0 ; wordNdx < gkAliHLTDDLListSize ; wordNdx++ ) {
+
+ if ( list.fList[wordNdx] != 0 && iResult == -1 ) {
+ // check for special cases TPC and TOF
+ if ( wordNdx > 3 && wordNdx <= 10 ) {
+ wordNdx = 10;
+ iResult = 3;
+ }
+ else if ( wordNdx > 12 && wordNdx <= 14 ) {
+ wordNdx = 14;
+ iResult = 12;
+ }
+ else
+ iResult = wordNdx;
+ }
+ else if ( list.fList[wordNdx] != 0 && iResult >= 0 ) {
+ HLTError( "DDLIDs for minimum of TWO detectors ( %d, %d ) set, this function works only for ONE detector.", iResult, wordNdx );
+ iResult = -1;
+ break;
+ }
+ }
+
+ return iResult;
+}
+
+AliHLTUInt32_t AliHLTComponent::CalculateChecksum(const AliHLTUInt8_t* buffer, int size)
+{
+ // see header file for function documentation
+ AliHLTUInt32_t remainder = 0;
+ const AliHLTUInt8_t crcwidth=(8*sizeof(AliHLTUInt32_t));
+ const AliHLTUInt32_t topbit=1 << (crcwidth-1);
+ const AliHLTUInt32_t polynomial=0xD8; /* 11011 followed by 0's */
+
+ // code from
+ // http://www.netrino.com/Embedded-Systems/How-To/CRC-Calculation-C-Code
+
+ /*
+ * Perform modulo-2 division, a byte at a time.
+ */
+ for (int byte = 0; byte < size; ++byte)
+ {
+ /*
+ * Bring the next byte into the remainder.
+ */
+ remainder ^= (buffer[byte] << (crcwidth - 8));
+
+ /*
+ * Perform modulo-2 division, a bit at a time.
+ */
+ for (uint8_t bit = 8; bit > 0; --bit)
+ {
+ /*
+ * Try to divide the current data bit.
+ */
+ if (remainder & topbit)
+ {
+ remainder = (remainder << 1) ^ polynomial;
+ }
+ else
+ {
+ remainder = (remainder << 1);
+ }
+ }
+ }
+
+ /*
+ * The final remainder is the CRC result.
+ */
+ return (remainder);
+}
+
+int AliHLTComponent::ExtractComponentTableEntry(const AliHLTUInt8_t* pBuffer, AliHLTUInt32_t size,
+ string& retChainId, string& retCompId, string& retCompArgs,
+ vector<AliHLTUInt32_t>& parents)
+{
+ // see header file for function documentation
+ retChainId.clear();
+ retCompId.clear();
+ retCompArgs.clear();
+ parents.clear();
+ if (!pBuffer || size==0) return 0;
+
+ const AliHLTComponentTableEntry* pEntry=reinterpret_cast<const AliHLTComponentTableEntry*>(pBuffer);
+ if (size<8/* the initial size of the structure*/ ||
+ pEntry==NULL || pEntry->fStructSize<8) return -ENOMSG;
+ const AliHLTUInt32_t* pParents=reinterpret_cast<const AliHLTUInt32_t*>(pEntry->fBuffer);
+ const AliHLTUInt8_t* pEnd=pBuffer+size;
+
+ if (pParents+pEntry->fNofParents>=reinterpret_cast<const AliHLTUInt32_t*>(pEnd)) return -ENODEV;
+ for (unsigned int i=0; i<pEntry->fNofParents; i++, pParents++) {
+ parents.push_back(*pParents);
+ }
+
+ const char* pDescription=reinterpret_cast<const char*>(pParents);
+ if (pDescription+pEntry->fSizeDescription>=reinterpret_cast<const char*>(pEnd) ||
+ *(pDescription+pEntry->fSizeDescription)!=0) {
+ return -EBADF;
+ }
+
+ TString descriptor=reinterpret_cast<const char*>(pDescription);
+ TString chainId;
+ TString compId;
+ TString compArgs;
+ TObjArray* pTokens=descriptor.Tokenize("{");
+ if (pTokens) {
+ int n=0;
+ if (pTokens->GetEntries()>n) {
+ retChainId=((TObjString*)pTokens->At(n++))->GetString();
+ }
+ if (pTokens->GetEntries()>n) {
+ compId=((TObjString*)pTokens->At(n++))->GetString();
+ }
+ delete pTokens;
+ }
+ if (!compId.IsNull() && (pTokens=compId.Tokenize(":"))!=NULL) {
+ int n=0;
+ if (pTokens->GetEntries()>n) {
+ compId=((TObjString*)pTokens->At(n++))->GetString();
+ }
+ if (pTokens->GetEntries()>n) {
+ compArgs=((TObjString*)pTokens->At(n++))->GetString();
+ }
+ delete pTokens;
+ }
+ compId.ReplaceAll("}", "");
+ compArgs.ReplaceAll("}", "");
+
+ retCompId=compId;
+ retCompArgs=compArgs;
+
+ if (retChainId.size()==0) return -ENODATA;
+
+ return 1;
+}
+
+int AliHLTComponent::LoggingVarargs(AliHLTComponentLogSeverity severity,
+ const char* originClass, const char* originFunc,
+ const char* file, int line, ... ) const
+{
+ // see header file for function documentation
+ int iResult=0;
+
+ va_list args;
+ va_start(args, line);
+
+ // logging function needs to be const in order to be called from const member functions
+ // without problems. But at this point we face the problem with virtual members which
+ // are not necessarily const.
+ AliHLTComponent* nonconst=const_cast<AliHLTComponent*>(this);
+ AliHLTLogging::SetLogString("%s (%s, %p): ",
+ fChainId[0]!=0?fChainId.c_str():nonconst->GetComponentID(),
+ nonconst->GetComponentID(), this);
+ iResult=SendMessage(severity, originClass, originFunc, file, line, AliHLTLogging::BuildLogString(NULL, args, true /*append*/));
+ va_end(args);
+
+ return iResult;
+}