1 #ifndef ALIHLTMUONDATABLOCKWRITER_H
2 #define ALIHLTMUONDATABLOCKWRITER_H
3 /**************************************************************************
4 * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
6 * Author: The ALICE Off-line Project. *
7 * Contributors are mentioned in the code where appropriate. *
9 * Permission to use, copy, modify and distribute this software and its *
10 * documentation strictly for non-commercial purposes is hereby granted *
11 * without fee, provided that the above copyright notice appears in all *
12 * copies and that both the copyright notice and this permission notice *
13 * appear in the supporting documentation. The authors make no claims *
14 * about the suitability of this software for any purpose. It is *
15 * provided "as is" without express or implied warranty. *
16 **************************************************************************/
21 * @file AliHLTMUONDataBlockWriter.h
22 * @author Artur Szostak <artursz@iafrica.com>
24 * @brief Definition of a writer class for internal dimuon HLT raw data blocks.
27 #include "AliHLTMUONDataTypes.h"
30 #include "AliHLTMUONTriggerRecordsBlockStruct.h"
31 #include "AliHLTMUONTrigRecsDebugBlockStruct.h"
32 #include "AliHLTMUONTriggerChannelsBlockStruct.h"
33 #include "AliHLTMUONRecHitsBlockStruct.h"
34 #include "AliHLTMUONClustersBlockStruct.h"
35 #include "AliHLTMUONChannelsBlockStruct.h"
36 #include "AliHLTMUONMansoTracksBlockStruct.h"
37 #include "AliHLTMUONMansoCandidatesBlockStruct.h"
38 #include "AliHLTMUONSinglesDecisionBlockStruct.h"
39 #include "AliHLTMUONPairsDecisionBlockStruct.h"
42 * A light weight class for writing an internal dimuon HLT data block.
43 * Suppose we are given a pointer 'buffer' to some empty memory buffer where we
44 * can store our new data block and the size of the data block is given by the
45 * variable 'size'. The data block is of type 'block_type', the data block entries
46 * are of type 'entries_type' and the data block type code is 'type_code'.
47 * The data block can be written in the following way:
49 * void* buffer = somebuffer;
50 * AliHLTUInt32_t size = somebuffer_size;
52 * // Initialise the data block writer.
53 * AliHLTMUONDataBlockWriter<block_type, entries_type, type_code>
54 * block(buffer, size);
56 * // Initialise the block header
57 * if (not block.InitCommonHeader())
59 * // handle error and exit...
62 * // Tell the writer how many entries we are going to use.
63 * if (not block.SetNumberOfEntries(somevalue))
65 * // handle error and exit...
68 * // Add all the entries to the data block.
69 * for (AliHLTUInt32_t i = 0; i < block.Nentries(); i++)
71 * entries_type& entry = block[i];
72 * // fill the new entry...
73 * entry.somefield = somevalue;
76 * The slightly slower but safer method is to do the following:
78 * AliHLTMUONDataBlockWriter<block_type, entries_type, type_code>
79 * block(buffer, size);
80 * if (not block.InitCommonHeader())
82 * // handle error and exit...
85 * // For each new entry add it to the data block.
86 * while (HaveMoreEntries())
88 * entries_type* entry = block.AddEntry();
91 * // handle buffer overflow and exit...
93 * // fill the new entry...
94 * entry->somefield = somevalue;
99 class DataElementType,
100 AliHLTMUONDataBlockType blockTypeCode
102 class AliHLTMUONDataBlockWriter
105 typedef DataBlockType HeaderType;
106 typedef DataElementType ElementType;
109 * Constructor that sets the internal pointer to the start of the buffer
110 * space to write to and the total size of the buffer in bytes.
111 * @param buffer The pointer to the first byte of the memory buffer.
112 * @param size The total size of the buffer in bytes.
114 AliHLTMUONDataBlockWriter(void* buffer, AliHLTUInt32_t size) :
116 fMaxArraySize(size - sizeof(DataBlockType)),
117 fBlock(reinterpret_cast<DataBlockType*>(buffer)),
118 fData(reinterpret_cast<DataElementType*>(
119 reinterpret_cast<DataBlockType*>(buffer) + 1
122 assert( buffer != NULL );
126 * Initialises the common data block header by setting the type and record
127 * width fields. If the buffer size was to small to create the header then
128 * this method returns false, otherwise true on success.
130 bool InitCommonHeader() const
132 // The block size must be at least sizeof(DataBlockType) bytes.
133 if (fSize < sizeof(DataBlockType)) return false;
135 // Now fill the fields in the header.
136 fBlock->fHeader.fType = blockTypeCode;
137 fBlock->fHeader.fRecordWidth = sizeof(DataElementType);
138 fBlock->fHeader.fNrecords = 0;
143 * Returns the common data block header.
145 const AliHLTMUONDataBlockHeader& CommonBlockHeader() const
147 return fBlock->fHeader;
151 * Returns the whole data block header.
153 DataBlockType& BlockHeader()
158 const DataBlockType& BlockHeader() const
164 * Returns a pointer to the next location where a data entry can be
165 * written and increments the number of entries.
166 * If the buffer is already full then NULL is returned and the number of
167 * entries is not changed.
169 DataElementType* AddEntry() const
171 if ( (Nentries() + 1) * sizeof(DataElementType) > fMaxArraySize )
173 DataElementType* newentry = &fData[fBlock->fHeader.fNrecords];
174 fBlock->fHeader.fNrecords++;
179 * Sets the number of entries that will be filled into the buffer.
180 * If the number of entries is to many to fit into the buffer then this
181 * method returns false, otherwise true.
183 bool SetNumberOfEntries(AliHLTUInt32_t n) const
185 if (n * sizeof(DataElementType) > fMaxArraySize) return false;
186 fBlock->fHeader.fNrecords = n;
191 * Returns the total number of entries already added to the data block.
193 AliHLTUInt32_t Nentries() const { return fBlock->fHeader.fNrecords; }
196 * Returns a pointer to the i'th entry.
197 * If the index 'i' is out of bounds then NULL is returned.
198 * This is a safe access method because it does bounds checking but is
199 * a little slower than the array operators.
200 * @param i The index number of the entry to be returned.
201 * @return A pointer to the entry or NULL.
203 DataElementType* Entry(AliHLTUInt32_t i)
205 return (i < Nentries()) ? &fData[i] : NULL;
208 const DataElementType* Entry(AliHLTUInt32_t i) const
210 return (i < Nentries()) ? &fData[i] : NULL;
214 * Array operator for accessing the data entries directly.
215 * The index variable 'i' is not checked (except in debug compilations)
216 * so one should make sure they are within the valid range.
218 DataElementType& operator [] (AliHLTUInt32_t i)
220 assert( i < Nentries() );
224 const DataElementType& operator [] (AliHLTUInt32_t i) const
226 assert( i < Nentries() );
231 * Returns a pointer to the array of elements in the data block.
232 * Care must be taken not to read beyond the array limits given by
235 DataElementType* GetArray() { return fData; }
236 const DataElementType* GetArray() const { return fData; }
239 * Calculates the number of bytes used for the data block in the buffer.
240 * This value will only make sense if a call to InitCommonHeader() was
241 * made and it returned true.
243 AliHLTUInt32_t BytesUsed() const
245 assert( sizeof(DataElementType) == fBlock->fHeader.fRecordWidth);
246 return sizeof(DataBlockType) + Nentries() * sizeof(DataElementType);
250 * Calculates the maximum number of entries that will fit into the
253 AliHLTUInt32_t MaxNumberOfEntries() const
255 return fMaxArraySize / sizeof(DataElementType);
258 AliHLTUInt32_t BufferSize() { return fSize; }
262 AliHLTUInt32_t fSize; // Size of the buffer in bytes.
263 AliHLTUInt32_t fMaxArraySize; // Maximum size of the fData array in bytes.
264 DataBlockType* fBlock; // Pointer to the start of the data block.
265 DataElementType* fData; // Pointer to the start of the data array.
269 // We now define the writer classes for the various data block types from the
270 // template class AliHLTMUONDataBlockWriter.
272 typedef AliHLTMUONDataBlockWriter<
273 AliHLTMUONTriggerRecordsBlockStruct,
274 AliHLTMUONTriggerRecordStruct,
275 kTriggerRecordsDataBlock
276 > AliHLTMUONTriggerRecordsBlockWriter;
278 typedef AliHLTMUONDataBlockWriter<
279 AliHLTMUONTrigRecsDebugBlockStruct,
280 AliHLTMUONTrigRecInfoStruct,
281 kTrigRecsDebugDataBlock
282 > AliHLTMUONTrigRecsDebugBlockWriter;
284 typedef AliHLTMUONDataBlockWriter<
285 AliHLTMUONTriggerChannelsBlockStruct,
286 AliHLTMUONTriggerChannelStruct,
287 kTriggerChannelsDataBlock
288 > AliHLTMUONTriggerChannelsBlockWriter;
290 typedef AliHLTMUONDataBlockWriter<
291 AliHLTMUONRecHitsBlockStruct,
292 AliHLTMUONRecHitStruct,
294 > AliHLTMUONRecHitsBlockWriter;
296 typedef AliHLTMUONDataBlockWriter<
297 AliHLTMUONClustersBlockStruct,
298 AliHLTMUONClusterStruct,
300 > AliHLTMUONClustersBlockWriter;
302 typedef AliHLTMUONDataBlockWriter<
303 AliHLTMUONChannelsBlockStruct,
304 AliHLTMUONChannelStruct,
306 > AliHLTMUONChannelsBlockWriter;
308 typedef AliHLTMUONDataBlockWriter<
309 AliHLTMUONMansoTracksBlockStruct,
310 AliHLTMUONMansoTrackStruct,
311 kMansoTracksDataBlock
312 > AliHLTMUONMansoTracksBlockWriter;
314 typedef AliHLTMUONDataBlockWriter<
315 AliHLTMUONMansoCandidatesBlockStruct,
316 AliHLTMUONMansoCandidateStruct,
317 kMansoCandidatesDataBlock
318 > AliHLTMUONMansoCandidatesBlockWriter;
320 typedef AliHLTMUONDataBlockWriter<
321 AliHLTMUONSinglesDecisionBlockStruct,
322 AliHLTMUONTrackDecisionStruct,
323 kSinglesDecisionDataBlock
324 > AliHLTMUONSinglesDecisionBlockWriter;
326 typedef AliHLTMUONDataBlockWriter<
327 AliHLTMUONPairsDecisionBlockStruct,
328 AliHLTMUONPairDecisionStruct,
329 kPairsDecisionDataBlock
330 > AliHLTMUONPairsDecisionBlockWriter;
332 #endif // ALIHLTMUONDATABLOCKWRITER_H