Adding new component name for Manso tracker (Finite State Machine) implementation.
[u/mrichter/AliRoot.git] / HLT / MUON / AliHLTMUONDataBlockReader.h
CommitLineData
b3eef24e 1#ifndef ALIHLTMUONDATABLOCKREADER_H
2#define ALIHLTMUONDATABLOCKREADER_H
3/**************************************************************************
4 * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
5 * *
6 * Author: The ALICE Off-line Project. *
7 * Contributors are mentioned in the code where appropriate. *
8 * *
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 **************************************************************************/
17
18/* $Id$ */
19
20/**
21 * @file AliHLTMUONDataBlockReader.h
22 * @author Artur Szostak <artursz@iafrica.com>
23 * @date
24 * @brief Definition of a reader class for internal dimuon HLT raw data blocks.
25 */
26
27#include "AliHLTMUONDataTypes.h"
28#include <cassert>
29
30#include "AliHLTMUONTriggerRecordsBlockStruct.h"
31#include "AliHLTMUONTrigRecsDebugBlockStruct.h"
32#include "AliHLTMUONTriggerChannelsBlockStruct.h"
33#include "AliHLTMUONRecHitsBlockStruct.h"
34#include "AliHLTMUONClustersBlockStruct.h"
35#include "AliHLTMUONChannelsBlockStruct.h"
90a74d7a 36#include "AliHLTMUONMansoTracksBlockStruct.h"
37#include "AliHLTMUONMansoCandidatesBlockStruct.h"
38#include "AliHLTMUONSinglesDecisionBlockStruct.h"
39#include "AliHLTMUONPairsDecisionBlockStruct.h"
b3eef24e 40
41/**
42 * A light weight class for reading the contents of an internal dimuon HLT
43 * data block.
44 * Suppose we are given a pointer 'buffer' to the buffer where a data block is
45 * stored in memory and the size of the data block is given by the variable 'size'.
46 * The data block is of type 'block_type' and the data block entries are of type
47 * 'entries_type'. The data block can be accessed in the following way:
48 *
49 * void* buffer = somebuffer;
50 * AliHLTUInt32_t size = somebuffer_size;
51 *
52 * // Initialise the data block reader.
53 * AliHLTMUONDataBlockReader<block_type, entries_type> block(buffer, size);
54 *
55 * // Check that the buffer has the expected size.
56 * if (not block.BufferSizeOk())
57 * {
58 * // handle error...
59 * }
60 *
61 * // Find the number of entries in the data block.
62 * AliHLTUInt32_t nentries = block.Nentries();
63 *
64 * // Loop over all entries in the data block.
65 * for (AliHLTUInt32_t i = 0; i < nentries; i++)
66 * {
67 * const entries_type& entry = block[i];
68 * // Do something with the entry...
69 * }
70 */
71template <class DataBlockType, class DataElementType>
72class AliHLTMUONDataBlockReader
73{
74public:
b12fe461 75 typedef DataBlockType HeaderType;
76 typedef DataElementType ElementType;
b3eef24e 77
78 /**
79 * Constructor that sets the internal pointer to the start of the data
80 * block and the total size of the block in bytes.
81 * @param buffer The pointer to the first byte of the block in memory.
82 * @param size The total size of the data block in bytes.
83 */
84 AliHLTMUONDataBlockReader(const void* buffer, AliHLTUInt32_t size) :
85 fSize(size),
86 fBlock(reinterpret_cast<const DataBlockType*>(buffer)),
87 fData(reinterpret_cast<const DataElementType*>(
88 reinterpret_cast<const DataBlockType*>(buffer) + 1
89 ))
90 {
91 assert( buffer != NULL );
92 }
93
94 /**
95 * Checks that the size of the buffer storing the data block is correct.
96 * Basic sanity checks are performed such as seeing if the data block
97 * size corresponds to the number of reconstructed hits stored and that
98 * the size of the buffer is at least sizeof(DataBlockType) bytes big.
99 */
100 bool BufferSizeOk() const
101 {
102 // The block size must be at least sizeof(DataBlockType) bytes.
103 if (fSize < sizeof(DataBlockType)) return false;
104
105 // Now check if the size of the data block corresponds to the
106 // number of entries it claims to contain.
107 AliHLTUInt32_t arraysize = fSize - sizeof(DataBlockType);
108 return arraysize == Nentries() * sizeof(DataElementType);
109 }
110
111 /**
112 * Returns the common data block header.
113 */
90a74d7a 114 const AliHLTMUONDataBlockHeader& CommonBlockHeader() const
b3eef24e 115 {
116 return fBlock->fHeader;
117 }
90a74d7a 118
119 /**
120 * Returns the whole data block header.
121 */
122 const DataBlockType& BlockHeader() const
123 {
124 return fBlock;
125 }
b3eef24e 126
127 /**
128 * Returns the total number of entries in the data block.
129 */
130 AliHLTUInt32_t Nentries() const { return fBlock->fHeader.fNrecords; }
131
132 /**
133 * Returns a pointer to the i'th entry.
134 * If the index 'i' is out of bounds then NULL is returned.
135 * This is a safe access method because it does bounds checking but is
136 * a little slower than the array operator.
137 * @param i The index number of the entry to be returned.
138 * @return A pointer to the entry or NULL.
139 */
140 const DataElementType* Entry(AliHLTUInt32_t i) const
141 {
142 return (i < Nentries()) ? &fData[i] : NULL;
143 }
144
145 /**
146 * Array operator for accessing the data entries directly.
147 * The index variable 'i' is not checked (except in debug compilations)
148 * so one should make sure they are within the valid range.
149 */
150 const DataElementType& operator [] (AliHLTUInt32_t i) const
151 {
152 assert( i < Nentries() );
153 return fData[i];
154 }
155
156 /**
157 * Returns a pointer to the array of elements in the data block.
158 * Care must be taken not to read beyond the array limits given by
159 * Nentries().
160 */
161 const DataElementType* GetArray() const { return fData; }
162
b12fe461 163 AliHLTUInt32_t BufferSize() { return fSize; }
164
b3eef24e 165private:
166
167 AliHLTUInt32_t fSize; // Size of the data block in bytes.
168 const DataBlockType* fBlock; // Pointer to the data block buffer.
169 const DataElementType* fData; // Pointer to the data array.
170};
171
172
173// We now define the reader classes for the various data block types from the
174// template class AliHLTMUONDataBlockReader.
175
176typedef AliHLTMUONDataBlockReader<
177 AliHLTMUONTriggerRecordsBlockStruct,
178 AliHLTMUONTriggerRecordStruct
179 > AliHLTMUONTriggerRecordsBlockReader;
180
181typedef AliHLTMUONDataBlockReader<
182 AliHLTMUONTrigRecsDebugBlockStruct,
183 AliHLTMUONTrigRecInfoStruct
184 > AliHLTMUONTrigRecsDebugBlockReader;
185
186typedef AliHLTMUONDataBlockReader<
187 AliHLTMUONTriggerChannelsBlockStruct,
188 AliHLTMUONTriggerChannelStruct
189 > AliHLTMUONTriggerChannelsBlockReader;
190
191typedef AliHLTMUONDataBlockReader<
192 AliHLTMUONRecHitsBlockStruct,
193 AliHLTMUONRecHitStruct
194 > AliHLTMUONRecHitsBlockReader;
195
196typedef AliHLTMUONDataBlockReader<
197 AliHLTMUONClustersBlockStruct,
198 AliHLTMUONClusterStruct
199 > AliHLTMUONClustersBlockReader;
200
201typedef AliHLTMUONDataBlockReader<
202 AliHLTMUONChannelsBlockStruct,
203 AliHLTMUONChannelStruct
204 > AliHLTMUONChannelsBlockReader;
205
90a74d7a 206typedef AliHLTMUONDataBlockReader<
207 AliHLTMUONMansoTracksBlockStruct,
208 AliHLTMUONMansoTrackStruct
209 > AliHLTMUONMansoTracksBlockReader;
210
211typedef AliHLTMUONDataBlockReader<
212 AliHLTMUONMansoCandidatesBlockStruct,
213 AliHLTMUONMansoCandidateStruct
214 > AliHLTMUONMansoCandidatesBlockReader;
215
216typedef AliHLTMUONDataBlockReader<
217 AliHLTMUONSinglesDecisionBlockStruct,
218 AliHLTMUONTrackDecisionStruct
219 > AliHLTMUONSinglesDecisionBlockReader;
220
221typedef AliHLTMUONDataBlockReader<
222 AliHLTMUONPairsDecisionBlockStruct,
223 AliHLTMUONPairDecisionStruct
224 > AliHLTMUONPairsDecisionBlockReader;
225
b3eef24e 226#endif // ALIHLTMUONDATABLOCKREADER_H