coding conventions and compilation warnings
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Mar 2008 15:24:03 +0000 (15:24 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Mar 2008 15:24:03 +0000 (15:24 +0000)
17 files changed:
HLT/BASE/AliHLTComponent.cxx
HLT/BASE/AliHLTComponentHandler.cxx
HLT/BASE/AliHLTModuleAgent.cxx
HLT/BASE/AliHLTModuleAgent.h
HLT/BASE/AliHLTOUT.cxx
HLT/BASE/AliHLTOUT.h
HLT/BASE/AliHLTOUTHomerBuffer.cxx
HLT/BASE/AliHLTOUTHomerBuffer.h
HLT/RCU/AliHLTAltroChannelSelectorComponent.cxx
HLT/TPCLib/AliHLTTPCConfMapper.cxx
HLT/TPCLib/AliHLTTPCDefinitions.h
HLT/TPCLib/AliHLTTPCDigitReaderPacked.cxx
HLT/TPCLib/AliHLTTPCDigitReaderPacked.h
HLT/TPCLib/mapping2array.cxx.in
HLT/configure.ac
HLT/sim/AliHLTOUTComponent.cxx
HLT/sim/AliHLTOUTComponent.h

index 24b96ac..9f68abb 100644 (file)
@@ -817,7 +817,7 @@ const AliHLTComponentBlockData* AliHLTComponent::GetInputBlock(int index)
 {
   // see header file for function documentation
   ALIHLTCOMPONENT_BASE_STOPWATCH();
-  assert( 0 <= index and index < fCurrentEventData.fBlockCnt );
+  assert( 0 <= index and index < (int)fCurrentEventData.fBlockCnt );
   return &fpInputBlocks[index];
 }
 
index 411b2ba..486d513 100644 (file)
@@ -319,19 +319,25 @@ int AliHLTComponentHandler::LoadLibrary( const char* libraryPath, int bActivateA
     const char* loadtype="";
 #ifdef HAVE_DLFCN_H
     // use interface to the dynamic linking loader
-    try {
+
+    // exeption does not help in Root context, the Root exeption
+    // handler always catches the exeption before. Have to find out
+    // how exeptions can be used in Root
+    /*try*/ {
       hLib.fHandle=dlopen(libraryPath, RTLD_NOW);
       loadtype="dlopen";
     }
+    /*
     catch (...) {
       // error message printed further down
       loadtype="dlopen exeption";
     }
+    */
 #else
     // use ROOT dynamic loader
     // check if the library was already loaded, as Load returns
     // 'failure' if the library was already loaded
-    try {
+    /*try*/ {
     AliHLTLibHandle* pLib=FindLibrary(libraryPath);
     if (pLib) {
        int* pRootHandle=reinterpret_cast<int*>(pLib->fHandle);
@@ -348,10 +354,12 @@ int AliHLTComponentHandler::LoadLibrary( const char* libraryPath, int bActivateA
     }
     loadtype="gSystem";
     }
+    /*
     catch (...) {
       // error message printed further down
       loadtype="gSystem exeption";
     }
+    */
 #endif //HAVE_DLFCN_H
     if (hLib.fHandle!=NULL) {
       // create TString object to store library path and use pointer as handle 
@@ -429,12 +437,18 @@ int AliHLTComponentHandler::UnloadLibrary(AliHLTComponentHandler::AliHLTLibHandl
   TString* pName=reinterpret_cast<TString*>(handle.fName);
   if (handle.fMode!=kStatic) {
 #ifdef HAVE_DLFCN_H
-  try {
+  // exeption does not help in Root context, the Root exeption
+  // handler always catches the exeption before. Have to find out
+  // how exeptions can be used in Root
+
+  /*try*/ {
     dlclose(handle.fHandle);
   }
+  /*
   catch (...) {
     HLTError("exeption caught during dlclose of library %s", pName!=NULL?pName->Data():"");
   }
+  */
 #else
   int* pCount=reinterpret_cast<int*>(handle.fHandle);
   if (--(*pCount)==0) {
@@ -579,12 +593,17 @@ int AliHLTComponentHandler::DeleteOwnedComponents()
   AliHLTComponentPList::iterator element=fOwnedComponents.begin();
   while (element!=fOwnedComponents.end()) {
     //DeregisterComponent((*element)->GetComponentID());
-    try {
+    // exeption does not help in Root context, the Root exeption
+    // handler always catches the exeption before. Have to find out
+    // how exeptions can be used in Root
+    /*try*/ {
       delete *element;
     }
+    /*
     catch (...) {
       HLTError("delete managed sample %p", *element);
     }
+    */
     fOwnedComponents.erase(element);
     element=fOwnedComponents.begin();
   }
index a4a18ce..c9e8316 100644 (file)
     @note   The class is used in Offline (AliRoot) context
 */
 
+// see header file for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+
 #include "AliHLTModuleAgent.h"
 #include "AliHLTOUTHandler.h"
 
@@ -60,7 +66,7 @@ void AliHLTModuleAgent::PrintStatus(const char* agent)
   // see header file for function documentation
   AliHLTLogging log;
  if (agent) {
-   AliHLTModuleAgent* pCurrent=fAnchor;
+   AliHLTModuleAgent* pCurrent=fgAnchor;
    while (pCurrent!=NULL && strcmp(pCurrent->GetName(), agent)!=0) pCurrent=pCurrent->fpNext;
    if (pCurrent) {
      log.Logging(kHLTLogInfo, "AliHLTModuleAgent::PrintStatus", "module agents", 
@@ -70,7 +76,7 @@ void AliHLTModuleAgent::PrintStatus(const char* agent)
                 "agent %s not found", agent);
    }
   } else {
-   AliHLTModuleAgent* pCurrent=fAnchor;
+   AliHLTModuleAgent* pCurrent=fgAnchor;
    log.Logging(kHLTLogInfo, "AliHLT", "", "-----------------------");
    log.Logging(kHLTLogInfo, "AliHLT", "", "available module agents");
    if (pCurrent==NULL)
@@ -141,6 +147,7 @@ int AliHLTModuleAgent::DeleteOutputHandler(AliHLTOUTHandler* pInstance)
 
 int AliHLTModuleAgent::ActivateComponentHandler(AliHLTComponentHandler* pHandler)
 {
+  // see header file for function documentation
   int iResult=0;
   if (pHandler==NULL) {
     if (fpComponentHandler!=NULL) {
@@ -175,22 +182,22 @@ AliHLTModulePreprocessor* AliHLTModuleAgent::GetPreprocessor()
   return NULL;
 }
 
-AliHLTModuleAgent* AliHLTModuleAgent::fAnchor=NULL;
-AliHLTModuleAgent* AliHLTModuleAgent::fCurrent=NULL;
-int AliHLTModuleAgent::fCount=0;
+AliHLTModuleAgent* AliHLTModuleAgent::fgAnchor=NULL;
+AliHLTModuleAgent* AliHLTModuleAgent::fgCurrent=NULL;
+int AliHLTModuleAgent::fgCount=0;
 
 AliHLTModuleAgent* AliHLTModuleAgent::GetFirstAgent()
 {
   // see header file for function documentation
-  fCurrent=fAnchor;
-  return fAnchor;
+  fgCurrent=fgAnchor;
+  return fgAnchor;
 }
 
 AliHLTModuleAgent* AliHLTModuleAgent::GetNextAgent()
 {
   // see header file for function documentation
-  if (fCurrent!=NULL) fCurrent=fCurrent->fpNext;
-  return fCurrent;
+  if (fgCurrent!=NULL) fgCurrent=fgCurrent->fpNext;
+  return fgCurrent;
 }
 
 int AliHLTModuleAgent::Register(AliHLTModuleAgent* pAgent)
@@ -198,14 +205,14 @@ int AliHLTModuleAgent::Register(AliHLTModuleAgent* pAgent)
   // see header file for function documentation
   AliHLTLogging log;
   if (!pAgent) return -EINVAL;
-  if (fAnchor==NULL) {
-    fAnchor=pAgent;
+  if (fgAnchor==NULL) {
+    fgAnchor=pAgent;
   } else {
-    pAgent->fpNext=fAnchor;
-    fAnchor=pAgent;
+    pAgent->fpNext=fgAnchor;
+    fgAnchor=pAgent;
   }
   //  log.Logging(kHLTLogDebug, "AliHLTModuleAgent::Register", "", "module agent %p registered", pAgent);
-  fCount++;
+  fgCount++;
   return 0;    
 }
 
@@ -214,21 +221,21 @@ int AliHLTModuleAgent::Unregister(AliHLTModuleAgent* pAgent)
   // see header file for function documentation
   AliHLTLogging log;
   if (!pAgent) return -EINVAL;
-  fCurrent=NULL;
+  fgCurrent=NULL;
   AliHLTModuleAgent* prev=NULL;
-  AliHLTModuleAgent* handler=fAnchor;
+  AliHLTModuleAgent* handler=fgAnchor;
   while (handler!=NULL && handler!=pAgent) {
     prev=handler;
     handler=handler->fpNext;
   }
   if (handler) {
     if (prev==NULL) {
-      fAnchor=handler->fpNext;
+      fgAnchor=handler->fpNext;
     } else {
       prev->fpNext=handler->fpNext;
     }
     //log.Logging(kHLTLogDebug, "AliHLTModuleAgent::Unregister", "", "module agent %p removed", pAgent);
-    fCount--;
+    fgCount--;
   }
   return 0;
 }
index 85645c3..3de3006 100644 (file)
@@ -271,11 +271,11 @@ class AliHLTModuleAgent : public TObject, public AliHLTLogging {
 
   private:
     /** type of the handler */
-    AliHLTOUTHandlerType    fHType;
+    AliHLTOUTHandlerType    fHType;                          //!transient
     /** data type treated by the handler */
-    AliHLTComponentDataType fDt;
+    AliHLTComponentDataType fDt;                             //!transient
     /** class or chain name */
-    TString                 fModule;
+    TString                 fModule;                         //!transient
   };
 
   /**
@@ -367,16 +367,16 @@ class AliHLTModuleAgent : public TObject, public AliHLTLogging {
   static int Unregister(AliHLTModuleAgent* pAgent);
 
   /** the list of active agents */
-  static AliHLTModuleAgent* fAnchor;                               //! transient
+  static AliHLTModuleAgent* fgAnchor;                               //! transient
 
   /** next element in the list */
   AliHLTModuleAgent* fpNext;                                       //! transient
 
   /** the current object link (list position) */
-  static AliHLTModuleAgent* fCurrent;                              //! transient
+  static AliHLTModuleAgent* fgCurrent;                              //! transient
 
   /** number of agents */
-  static int fCount;                                               //! transient
+  static int fgCount;                                               //! transient
 
   /** instance of the active component handler */
   AliHLTComponentHandler* fpComponentHandler;                      //! transient
index 2f50930..7c66804 100644 (file)
@@ -51,14 +51,6 @@ AliHLTOUT::AliHLTOUT()
   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
 }
 
-// definitions from ALICE internal note ALICE-INT-2002-010
-const unsigned char AliHLTOUT::fgkCDHStatusWord=4;
-const unsigned char AliHLTOUT::fgkCDHStatusFlagsOffset=12;
-
-// definitions from ALICE internal note ALICE-INT-2006-XXX
-const unsigned char AliHLTOUT::fgkCDHFlagsHLTDecision=6;
-const unsigned char AliHLTOUT::fgkCDHFlagsHLTPayload=7;
-
 AliHLTOUT::~AliHLTOUT()
 {
   // see header file for class documentation
@@ -116,7 +108,7 @@ int AliHLTOUT::FindAndSelectDataBlock()
       iResult=fCurrent->GetIndex();
       // TODO: check the byte order on the current system and the byte order of the
       // data block, print warning when missmatch and user did not check
-      //AliHLTOUTByteOrder_t blockBO=CheckByteOrder();
+      //AliHLTOUTByteOrder blockBO=CheckByteOrder();
       CheckByteOrder();
       /*
        if (blockBO!=fByteOrder) {
@@ -199,18 +191,18 @@ int AliHLTOUT::AddBlockDescriptor(const AliHLTOUTBlockDescriptor desc)
   return iResult;  
 }
 
-AliHLTOUT::AliHLTOUTByteOrder_t AliHLTOUT::CheckByteOrder()
+AliHLTOUT::AliHLTOUTByteOrder AliHLTOUT::CheckByteOrder()
 {
   // see header file for class documentation
   if (fCurrent!=fBlockDescList.end()) {
     SetStatusFlag(kByteOrderChecked);
-    AliHLTOUT::AliHLTOUTByteOrder_t order=CheckBlockByteOrder((*fCurrent).GetIndex());
+    AliHLTOUT::AliHLTOUTByteOrder order=CheckBlockByteOrder((*fCurrent).GetIndex());
     return order;
   }
   return kInvalidByteOrder;
 }
 
-int AliHLTOUT::CheckAlignment(AliHLTOUT::AliHLTOUTDataType_t type)
+int AliHLTOUT::CheckAlignment(AliHLTOUT::AliHLTOUTDataType type)
 {
   // see header file for class documentation
   if (fCurrent!=fBlockDescList.end()) {
@@ -243,7 +235,7 @@ int AliHLTOUT::InitHandlers()
   }
   if (remnants.size()>0) {
     HLTWarning("no handlers found for %d data blocks out of %d", remnants.size(), GetNofDataBlocks());
-    vector<AliHLTOUTBlockDescriptor>::iterator block=fBlockDescList.begin();
+    AliHLTOUTBlockDescriptorVector::iterator block=fBlockDescList.begin();
     for (AliHLTOUTIndexList::iterator element=remnants.begin(); element!=remnants.end(); element++) {
       for (int trials=0; trials<2; trials++) {
        do {
@@ -268,7 +260,7 @@ int AliHLTOUT::InsertHandler(const AliHLTOUTHandlerListEntry &entry)
 {
   // see header file for class documentation
   int iResult=0;
-  vector<AliHLTOUTHandlerListEntry>::iterator element=fDataHandlers.begin();
+  AliHLTOUTHandlerListEntryVector::iterator element=fDataHandlers.begin();
   while (element!=fDataHandlers.end()) {
     if (entry==(*element)) break;
     element++;
@@ -284,7 +276,7 @@ int AliHLTOUT::InsertHandler(const AliHLTOUTHandlerListEntry &entry)
 AliHLTOUT::AliHLTOUTHandlerListEntry AliHLTOUT::FindHandlerDesc(AliHLTUInt32_t blockIndex)
 {
   // see header file for class documentation
-  vector<AliHLTOUTHandlerListEntry>::iterator element=fDataHandlers.begin();
+  AliHLTOUTHandlerListEntryVector::iterator element=fDataHandlers.begin();
   while (element!=fDataHandlers.end()) {
     if (element->HasIndex(blockIndex)) {
       return *element;
index d844b07..f5cb32a 100644 (file)
@@ -150,14 +150,16 @@ class AliHLTOUT : public AliHLTLogging {
 
   // definitions from ALICE internal notes ALICE-INT-2002-010 and
   // ALICE-INT-2006-XXX
-  /** the 32bit word in the CDH containing the status flags */
-  static const unsigned char fgkCDHStatusWord; //! see above
-  /** start of the flags in word fgkCDHStatusWord */
-  static const unsigned char fgkCDHStatusFlagsOffset; //! see above
-  /** bit indicating HLT decision in the HLTOUT*/
-  static const unsigned char fgkCDHFlagsHLTDecision; //! see above
-  /** bit indicating HLT payload in the HLTOUT*/
-  static const unsigned char fgkCDHFlagsHLTPayload; //! see above
+  enum {
+    /** the 32bit word in the CDH containing the status flags */
+    kCDHStatusWord=4, //! see above
+    /** start of the flags in word fgkCDHStatusWord */
+    kCDHStatusFlagsOffset=12, //! see above
+    /** bit indicating HLT decision in the HLTOUT*/
+    kCDHFlagsHLTDecision=6, //! see above
+    /** bit indicating HLT payload in the HLTOUT*/
+    kCDHFlagsHLTPayload=7 //! see above
+  };
 
   /**
    * Block descriptor.
@@ -183,7 +185,7 @@ class AliHLTOUT : public AliHLTLogging {
     AliHLTUInt32_t          fIndex; //!transient
   };
 
-  enum AliHLTOUTByteOrder_t {
+  enum AliHLTOUTByteOrder {
     /** no data block selected */
     kInvalidByteOrder=-1,
     kUnknownByteOrder=0,
@@ -191,7 +193,7 @@ class AliHLTOUT : public AliHLTLogging {
     kBigEndian
   };
 
-  enum AliHLTOUTDataType_t {
+  enum AliHLTOUTDataType {
     kUint64 = 0,
     kUint32 = 1,
     kUint16 = 2,
@@ -203,12 +205,12 @@ class AliHLTOUT : public AliHLTLogging {
   /**
    * Check byte order of selected block
    */
-  AliHLTOUTByteOrder_t CheckByteOrder();
+  AliHLTOUTByteOrder CheckByteOrder();
 
   /**
    * Check alignment of selected block
    */
-  int CheckAlignment(AliHLTOUT::AliHLTOUTDataType_t type);
+  int CheckAlignment(AliHLTOUT::AliHLTOUTDataType type);
 
  protected:
   /**
@@ -259,10 +261,10 @@ class AliHLTOUT : public AliHLTLogging {
 
     ~AliHLTOUTHandlerListEntry();
 
-    static const AliHLTOUTHandlerListEntry fgkVoidHandlerListEntry;
+    static const AliHLTOUTHandlerListEntry fgkVoidHandlerListEntry; //! initializer
 
     operator AliHLTOUTHandler*() const {return fpHandler;}
-    operator AliHLTModuleAgent::AliHLTOUTHandlerDesc&() {return *fpHandlerDesc;}
+    operator AliHLTModuleAgent::AliHLTOUTHandlerDesc&() const {return *fpHandlerDesc;}
     operator AliHLTModuleAgent*() const {return fpAgent;}
 
     /**
@@ -334,12 +336,12 @@ class AliHLTOUT : public AliHLTLogging {
   /**
    * Check byte order of data block
    */
-  virtual AliHLTOUTByteOrder_t CheckBlockByteOrder(AliHLTUInt32_t index)=0;
+  virtual AliHLTOUTByteOrder CheckBlockByteOrder(AliHLTUInt32_t index)=0;
 
   /**
    * Check alignment of data block
    */
-  virtual int CheckBlockAlignment(AliHLTUInt32_t index, AliHLTOUT::AliHLTOUTDataType_t type)=0;
+  virtual int CheckBlockAlignment(AliHLTUInt32_t index, AliHLTOUT::AliHLTOUTDataType type)=0;
 
   /**
    * Select the data block of data type and specification of the previous
@@ -398,17 +400,20 @@ class AliHLTOUT : public AliHLTLogging {
   /** instance flags: locked, collecting, ... */
   unsigned int fFlags; //!transient
 
+  typedef vector<AliHLTOUTHandlerListEntry> AliHLTOUTHandlerListEntryVector;
+  typedef vector<AliHLTOUTBlockDescriptor>  AliHLTOUTBlockDescriptorVector;
+
   /** list of block descriptors */
-  vector<AliHLTOUTBlockDescriptor> fBlockDescList; //!transient
+  AliHLTOUTBlockDescriptorVector fBlockDescList; //!transient
 
   /** current position in the list */
-  vector<AliHLTOUTBlockDescriptor>::iterator fCurrent; //!transient
+  AliHLTOUTBlockDescriptorVector::iterator fCurrent; //!transient
 
   /** data buffer under processing */
   const AliHLTUInt8_t* fpBuffer; //!transient
 
   /** list of AliHLTOUTHandlers */
-  vector<AliHLTOUTHandlerListEntry> fDataHandlers; // !transient
+  AliHLTOUTHandlerListEntryVector fDataHandlers; // !transient
 
   ClassDef(AliHLTOUT, 1)
 };
index a0555c9..d57a0ee 100644 (file)
@@ -99,15 +99,15 @@ int AliHLTOUTHomerBuffer::GetDataBuffer(AliHLTUInt32_t index, const AliHLTUInt8_
   return iResult;
 }
 
-AliHLTOUT::AliHLTOUTByteOrder_t AliHLTOUTHomerBuffer::CheckBlockByteOrder(AliHLTUInt32_t index)
+AliHLTOUT::AliHLTOUTByteOrder AliHLTOUTHomerBuffer::CheckBlockByteOrder(AliHLTUInt32_t index)
 {
   if (fpReader) {
-    return static_cast<AliHLTOUTByteOrder_t>(fpReader->GetBlockByteOrder(index));
+    return static_cast<AliHLTOUTByteOrder>(fpReader->GetBlockByteOrder(index));
   }
   return kInvalidByteOrder;
 }
 
-int AliHLTOUTHomerBuffer::CheckBlockAlignment(AliHLTUInt32_t index, AliHLTOUT::AliHLTOUTDataType_t type)
+int AliHLTOUTHomerBuffer::CheckBlockAlignment(AliHLTUInt32_t index, AliHLTOUT::AliHLTOUTDataType type)
 {
   if (fpReader) {
     return fpReader->GetBlockTypeAlignment(index, static_cast<homer_uint8>(type));
index 075325d..dcd8ff4 100644 (file)
@@ -69,12 +69,12 @@ class AliHLTOUTHomerBuffer : public AliHLTOUT {
   /**
    * Check byte order of data block
    */
-  virtual AliHLTOUTByteOrder_t CheckBlockByteOrder(AliHLTUInt32_t index);
+  virtual AliHLTOUTByteOrder CheckBlockByteOrder(AliHLTUInt32_t index);
 
   /**
    * Check alignment of data block
    */
-  virtual int CheckBlockAlignment(AliHLTUInt32_t index, AliHLTOUT::AliHLTOUTDataType_t type);
+  virtual int CheckBlockAlignment(AliHLTUInt32_t index, AliHLTOUT::AliHLTOUTDataType type);
 
   /** data buffer */
   const AliHLTUInt8_t* fpBuffer; //! transient
index 7f31cad..23e0e8b 100644 (file)
@@ -1,25 +1,26 @@
 // $Id$
 
-/**************************************************************************
- * This file is property of and copyright by the ALICE HLT Project        * 
- * ALICE Experiment at CERN, All rights reserved.                         *
- *                                                                        *
- * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
- *                  for The ALICE HLT Project.                            *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//*                                                                        *
+//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
+//*                  for The ALICE HLT Project.                            *
+//*                                                                        *
+//* Permission to use, copy, modify and distribute this software and its   *
+//* documentation strictly for non-commercial purposes is hereby granted   *
+//* without fee, provided that the above copyright notice appears in all   *
+//* copies and that both the copyright notice and this permission notice   *
+//* appear in the supporting documentation. The authors make no claims     *
+//* about the suitability of this software for any purpose. It is          *
+//* provided "as is" without express or implied warranty.                  *
+//**************************************************************************
 
 /** @file   AliHLTAltroChannelSelectorComponent.cxx
     @author Matthias Richter
     @date   
-    @brief  A filter/selective readout component for Altro data. */
+    @brief  A filter/selective readout component for Altro data.
+*/
 
 // see header file for class documentation
 // or
index 53b67d5..417ddd4 100644 (file)
@@ -207,7 +207,7 @@ void AliHLTTPCConfMapper::SetPointers()
 
   Int_t volumeIndex;
   Int_t localcounter=0;
-  assert(fHit.size()>=fClustersUnused);
+  assert((int)fHit.size()>=fClustersUnused);
   for(Int_t j=0; j<fClustersUnused; j++)
     {
       AliHLTTPCConfMapPoint *thisHit = &(fHit[j]);
index 07f5b49..c8a66b7 100644 (file)
@@ -3,16 +3,17 @@
 
 #ifndef ALIHLTTPCDEFINITIONS_H
 #define ALIHLTTPCDEFINITIONS_H
-/* This file is property of and copyright by the ALICE HLT Project        * 
- * ALICE Experiment at CERN, All rights reserved.                         *
- * See cxx source for full Copyright notice                               */
-
-/* AliHLTTPCDefinitions
- */
+//* This file is property of and copyright by the ALICE HLT Project        * 
+//* ALICE Experiment at CERN, All rights reserved.                         *
+//* See cxx source for full Copyright notice                               *
 
 #include "AliHLTDataTypes.h"
 #include "Rtypes.h"
 
+/**
+ * @class AliHLTTPCDefinitions
+ * Data type definitions for the libAliHLTTPC library.
+ */
 class AliHLTTPCDefinitions
 {
 public:
index 39ecafd..021d85e 100644 (file)
@@ -43,19 +43,19 @@ ClassImp(AliHLTTPCDigitReaderPacked)
 
 AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked()
   :
+  fRawMemoryReader(NULL),
+  fTPCRawStream(NULL),
   //#if ENABLE_PAD_SORTING
   fCurrentRow(0),
   fCurrentPad(0),
   fCurrentBin(-1),
-  fNRows(0),
   fRowOffset(0),
+  fNRows(0),
   fNMaxRows(0),
   fNMaxPads(0),
   fNTimeBins(0),
   fData(NULL),
   //#endif // ENABLE_PAD_SORTING  
-  fRawMemoryReader(NULL),
-  fTPCRawStream(NULL),
   fOldRCUFormat(kFALSE),
   fUnsorted(kFALSE)
 {
index b4d6e3a..54587de 100644 (file)
@@ -80,7 +80,7 @@ private:
   Int_t fNMaxPads; //!transient
   Int_t fNTimeBins; //!transient
 
-  Int_t *fData;
+  Int_t *fData; //!transient
   //#endif // ENABLE_PAD_SORTING
 
   Bool_t fOldRCUFormat; //!transient
index 67858a6..d264277 100644 (file)
@@ -10,10 +10,8 @@ using namespace std;
 int main(){
     ifstream inFile[6];
     ofstream outFile;
-    int ofile;
-   
     
-    char * mappingpath="@TPC_PAD_MAPPING_PATH@/";
+    //char * mappingpath="@TPC_PAD_MAPPING_PATH@/";
     char * mappingfiles[6]= {"@TPC_PAD_MAPPING_PATH@/Patch0.data",
                             "@TPC_PAD_MAPPING_PATH@/Patch1.data",
                             "@TPC_PAD_MAPPING_PATH@/Patch2.data",
index 2c6e714..485cbc3 100644 (file)
@@ -449,7 +449,7 @@ AC_ARG_ENABLE(strict,
       [disable coding convention checks ])],
   [],[enable_strict=yes])
 if test "x$enable_strict" = "xyes" ; then
-   CPPFLAGS="$CPPFLAGS -Weffc++"
+   CPPFLAGS="$CPPFLAGS -Weffc++ -Wall"
 fi
 AC_MSG_RESULT([$enable_strict])
 
index 7ed944d..965b885 100644 (file)
@@ -19,7 +19,8 @@
 /** @file   AliHLTOUTComponent.cxx
     @author Matthias Richter
     @date   
-    @brief  The HLTOUT data sink component similar to HLTOUT nodes */
+    @brief  The HLTOUT data sink component similar to HLTOUT nodes
+*/
 
 // see header file for class documentation
 // or
@@ -32,7 +33,7 @@ using namespace std;
 #endif
 
 #include <cassert>
-#include <iostream>
+//#include <iostream>
 #include "AliHLTOUTComponent.h"
 #include "AliHLTOUT.h"
 #include "AliHLTHOMERLibManager.h"
@@ -188,7 +189,7 @@ int AliHLTOUTComponent::DumpEvent( const AliHLTComponentEventData& evtData,
       homerDescriptor.SetSubType2(static_cast<homer_uint64>(blocks[n].fSpecification));
       homerDescriptor.SetBlockSize(blocks[n].fSize);
       int writerNo=ShuffleWriters(fWriters, blocks[n].fSize);
-      assert(writerNo>=0 && writerNo<fWriters.size());
+      assert(writerNo>=0 && writerNo<(int)fWriters.size());
       // I'm puzzled by the different headers, buffers etc. used in the
       // HOMER writer/data. In additional, there is no type check as there
       // are void pointers used and names mixed.
@@ -301,7 +302,7 @@ int AliHLTOUTComponent::FillOutputBuffer(int eventNo, AliHLTMonitoringWriter* pW
       pWriter->Copy(&fBuffer[sizeof(AliRawDataHeader)+sizeof(AliHLTOUT::AliHLTOUTEventHeader)], 0, 0, 0, 0);
       pHLTH->fLength=pWriter->GetTotalMemorySize();
       // set status bit to indicate HLT payload
-      pCDH->fStatusMiniEventID|=0x1<<(AliHLTOUT::fgkCDHStatusFlagsOffset+AliHLTOUT::fgkCDHFlagsHLTPayload);
+      pCDH->fStatusMiniEventID|=0x1<<(AliHLTOUT::kCDHStatusFlagsOffset+AliHLTOUT::kCDHFlagsHLTPayload);
     }
     pHLTH->fLength+=sizeof(AliHLTOUT::AliHLTOUTEventHeader);
     pHLTH->fEventID=eventNo;
index 9fa807c..7fd8ff8 100644 (file)
@@ -18,7 +18,6 @@
 // or
 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
 
-#include <vector>
 #include "AliHLTOfflineDataSink.h"
 
 class AliHLTHOMERLibManager;