get beam type

[u/mrichter/AliRoot.git] / HLT / MUON / AliHLTMUONDataBlockWriter.h

diff --git a/HLT/MUON/AliHLTMUONDataBlockWriter.h b/HLT/MUON/AliHLTMUONDataBlockWriter.h
index 16679cdd383ca1f9521b881f76e748a145e3c3c1..f254cb06cabd7870355927939049c23ef5605bb2 100644 (file)
--- a/HLT/MUON/AliHLTMUONDataBlockWriter.h
+++ b/HLT/MUON/AliHLTMUONDataBlockWriter.h
@@ -15,12 +15,12 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
+// $Id$
 
 /**
  * @file   AliHLTMUONDataBlockWriter.h
  * @author Artur Szostak <artursz@iafrica.com>
- * @date   
+ * @date   19 May 2007
  * @brief  Definition of a writer class for internal dimuon HLT raw data blocks.
  */
 
@@ -29,12 +29,12 @@
 
 #include "AliHLTMUONTriggerRecordsBlockStruct.h"
 #include "AliHLTMUONTrigRecsDebugBlockStruct.h"
-#include "AliHLTMUONTriggerChannelsBlockStruct.h"
 #include "AliHLTMUONRecHitsBlockStruct.h"
 #include "AliHLTMUONClustersBlockStruct.h"
 #include "AliHLTMUONChannelsBlockStruct.h"
 #include "AliHLTMUONMansoTracksBlockStruct.h"
 #include "AliHLTMUONMansoCandidatesBlockStruct.h"
+#include "AliHLTMUONTracksBlockStruct.h"
 #include "AliHLTMUONSinglesDecisionBlockStruct.h"
 #include "AliHLTMUONPairsDecisionBlockStruct.h"
 
@@ -45,7 +45,7 @@
  * variable 'size'. The data block is of type 'block_type', the data block entries
  * are of type 'entries_type' and the data block type code is 'type_code'.
  * The data block can be written in the following way:
- *
+ * \code
  *   void* buffer = somebuffer;
  *   AliHLTUInt32_t size = somebuffer_size;
  *   
@@ -54,7 +54,7 @@
  *   block(buffer, size);
  *   
  *   // Initialise the block header
- *   if (not block.InitHeader())
+ *   if (not block.InitCommonHeader())
  *   {
  *      // handle error and exit...
  *   }
@@ -72,12 +72,12 @@
  *      // fill the new entry...
  *      entry.somefield = somevalue;
  *   }
- *
+ * \endcode
  * The slightly slower but safer method is to do the following:
- *
+ * \code
  *   AliHLTMUONDataBlockWriter<block_type, entries_type, type_code>
  *   block(buffer, size);
- *   if (not block.InitHeader())
+ *   if (not block.InitCommonHeader())
  *   {
  *      // handle error and exit...
  *   }
@@ -86,9 +86,14 @@
  *   while (HaveMoreEntries())
  *   {
  *      entries_type* entry = block.AddEntry();
+ *      if (entry == NULL)
+ *      {
+ *         // handle buffer overflow and exit...
+ *      }
  *      // fill the new entry...
  *      entry->somefield = somevalue;
  *   }
+ * \endcode
  */
 template <
        class DataBlockType,
@@ -98,6 +103,8 @@ template <
 class AliHLTMUONDataBlockWriter
 {
 public:
+       typedef DataBlockType HeaderType;
+       typedef DataElementType ElementType;
 
        /**
         * Constructor that sets the internal pointer to the start of the buffer
@@ -107,7 +114,7 @@ public:
         */
        AliHLTMUONDataBlockWriter(void* buffer, AliHLTUInt32_t size) :
                fSize(size),
-               fMaxArraySize(size - sizeof(DataBlockType)),
+               fMaxArraySize(size > sizeof(DataBlockType) ? size - sizeof(DataBlockType) : 0),
                fBlock(reinterpret_cast<DataBlockType*>(buffer)),
                fData(reinterpret_cast<DataElementType*>(
                       reinterpret_cast<DataBlockType*>(buffer) + 1
@@ -115,6 +122,33 @@ public:
        {
                assert( buffer != NULL );
        }
+       
+       /**
+        * Copy constructor that performs a shallow copy.
+        * Since this class does not take direct ownership of the buffer, never
+        * allocates or deallocates memory, this can be allowed.
+        */
+       AliHLTMUONDataBlockWriter(const AliHLTMUONDataBlockWriter& writer)
+       {
+               fSize = writer.fSize;
+               fMaxArraySize = writer.fMaxArraySize;
+               fBlock = writer.fBlock;
+               fData = writer.fData;
+       }
+       
+       /**
+        * Assignment operator performs a shallow copy.
+        * This is OK because this class does not take direct ownership of the
+        * output memory buffer.
+        */
+       AliHLTMUONDataBlockWriter& operator = (const AliHLTMUONDataBlockWriter& writer)
+       {
+               fSize = writer.fSize;
+               fMaxArraySize = writer.fMaxArraySize;
+               fBlock = writer.fBlock;
+               fData = writer.fData;
+               return *this;
+       }
 
        /**
         * Initialises the common data block header by setting the type and record
@@ -146,12 +180,12 @@ public:
         */
        DataBlockType& BlockHeader()
        {
-               return fBlock;
+               return *fBlock;
        }
        
        const DataBlockType& BlockHeader() const
        {
-               return fBlock;
+               return *fBlock;
        }
        
        /**
@@ -178,6 +212,7 @@ public:
        {
                if (n * sizeof(DataElementType) > fMaxArraySize) return false;
                fBlock->fHeader.fNrecords = n;
+               return true;
        }
 
        /**
@@ -230,15 +265,12 @@ public:
        
        /**
         * Calculates the number of bytes used for the data block in the buffer.
-        * This value will only make sense if a call to InitHeader() was made
-        * and it returned true.
+        * This value will only make sense if a call to InitCommonHeader() was
+        * made and it returned true.
         */
        AliHLTUInt32_t BytesUsed() const
        {
-               assert( Nentries() * sizeof(DataElementType)
-                       == Nentries() * fBlock->fHeader.fRecordWidth
-               );
-               
+               assert( sizeof(DataElementType) == fBlock->fHeader.fRecordWidth);
                return sizeof(DataBlockType) + Nentries() * sizeof(DataElementType);
        }
        
@@ -251,6 +283,8 @@ public:
                return fMaxArraySize / sizeof(DataElementType);
        }
        
+       AliHLTUInt32_t BufferSize() { return fSize; }
+       
 private:
 
        AliHLTUInt32_t fSize;   // Size of the buffer in bytes.
@@ -275,12 +309,6 @@ typedef AliHLTMUONDataBlockWriter<
                kTrigRecsDebugDataBlock
        > AliHLTMUONTrigRecsDebugBlockWriter;
 
-typedef AliHLTMUONDataBlockWriter<
-               AliHLTMUONTriggerChannelsBlockStruct,
-               AliHLTMUONTriggerChannelStruct,
-               kTriggerChannelsDataBlock
-       > AliHLTMUONTriggerChannelsBlockWriter;
-
 typedef AliHLTMUONDataBlockWriter<
                AliHLTMUONRecHitsBlockStruct,
                AliHLTMUONRecHitStruct,
@@ -310,6 +338,12 @@ typedef AliHLTMUONDataBlockWriter<
                AliHLTMUONMansoCandidateStruct,
                kMansoCandidatesDataBlock
        > AliHLTMUONMansoCandidatesBlockWriter;
+
+typedef AliHLTMUONDataBlockWriter<
+               AliHLTMUONTracksBlockStruct,
+               AliHLTMUONTrackStruct,
+               kTracksDataBlock
+       > AliHLTMUONTracksBlockWriter;
        
 typedef AliHLTMUONDataBlockWriter<
                AliHLTMUONSinglesDecisionBlockStruct,
@@ -319,7 +353,7 @@ typedef AliHLTMUONDataBlockWriter<
        
 typedef AliHLTMUONDataBlockWriter<
                AliHLTMUONPairsDecisionBlockStruct,
-               AliHLTMUONPairDecisionBlockStruct,
+               AliHLTMUONPairDecisionStruct,
                kPairsDecisionDataBlock
        > AliHLTMUONPairsDecisionBlockWriter;