corrections to obey coding conventions
[u/mrichter/AliRoot.git] / RAW / AliRawReader.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 ///////////////////////////////////////////////////////////////////////////////
17 //
18 // This is the base class for reading raw data and providing
19 // information about digits
20 //
21 // The derived classes, which operate on concrete raw data formats,
22 // should implement
23 // - ReadMiniHeader to read the next mini header
24 // - ReadNextData to read the next raw data block (=1 DDL)
25 // - ReadNext to read a given number of bytes
26 // - several getters like GetType
27 //
28 // Sequential access to the raw data is provided by the methods
29 // ReadMiniHeader, ReadNextData, ReadNextInt, ReadNextShort, ReadNextChar
30 //
31 // If only data from a specific detector (and a given range of DDL numbers)
32 // should be read, this can be achieved by the Select method.
33 // Several getter provide information about the current event and the
34 // current type of raw data.
35 //
36 ///////////////////////////////////////////////////////////////////////////////
37
38 #include "AliRawReader.h"
39
40
41 ClassImp(AliRawReader)
42
43
44 AliRawReader::AliRawReader()
45 {
46 // default constructor: initialize data members
47
48   fMiniHeader = NULL;
49   fCount = 0;
50
51   fSelectDetectorID = -1;
52   fSelectMinDDLID = -1;
53   fSelectMaxDDLID = -1;
54 }
55
56 AliRawReader::AliRawReader(const AliRawReader& rawReader) :
57   TObject(rawReader)
58 {
59 // copy constructor
60
61   fMiniHeader = rawReader.fMiniHeader;
62   fCount = rawReader.fCount;
63
64   fSelectDetectorID = rawReader.fSelectDetectorID;
65   fSelectMinDDLID = rawReader.fSelectMinDDLID;
66   fSelectMaxDDLID = rawReader.fSelectMaxDDLID;
67 }
68
69 AliRawReader& AliRawReader::operator = (const AliRawReader& rawReader)
70 {
71 // assignment operator
72
73   fMiniHeader = rawReader.fMiniHeader;
74   fCount = rawReader.fCount;
75
76   fSelectDetectorID = rawReader.fSelectDetectorID;
77   fSelectMinDDLID = rawReader.fSelectMinDDLID;
78   fSelectMaxDDLID = rawReader.fSelectMaxDDLID;
79
80   return *this;
81 }
82
83
84 void AliRawReader::Select(Int_t detectorID, Int_t minDDLID, Int_t maxDDLID)
85 {
86 // read only data of the detector with the given ID and in the given
87 // range of DDLs (minDDLID <= DDLID < maxDDLID).
88 // no selection is applied if a value < 0 is used.
89
90   fSelectDetectorID = detectorID;
91   fSelectMinDDLID = minDDLID;
92   fSelectMaxDDLID = maxDDLID;
93 }
94
95 Bool_t AliRawReader::IsSelected() const
96 {
97 // apply the selection (if any)
98
99   if (fSelectDetectorID >= 0) {
100     if (fMiniHeader->fDetectorID != fSelectDetectorID) return kFALSE;
101     if ((fSelectMinDDLID >= 0) && (fMiniHeader->fDDLID < fSelectMinDDLID))
102       return kFALSE;
103     if ((fSelectMaxDDLID >= 0) && (fMiniHeader->fDDLID >= fSelectMaxDDLID))
104       return kFALSE;
105   }
106   return kTRUE;
107 }
108
109
110 Bool_t AliRawReader::CheckMiniHeader() const
111 {
112 // check the magic number of the mini header
113
114   if ((fMiniHeader->fMagicWord[2] != 0x12) ||
115       (fMiniHeader->fMagicWord[1] != 0x34) ||
116       (fMiniHeader->fMagicWord[0] != 0x56)) {
117     Error("CheckMiniHeader", "wrong magic word!");
118     return kFALSE;
119   }
120   return kTRUE;
121 }
122
123 Bool_t AliRawReader::ReadNextInt(UInt_t& data)
124 {
125 // reads the next 4 bytes at the current position
126 // returns kFALSE if the data could not be read
127
128   while (fCount == 0) {
129     if (!ReadMiniHeader()) return kFALSE;
130   }
131   if (fCount < (Int_t) sizeof(data)) {
132     Error("ReadNextInt", 
133           "too few data left (%d bytes) to read an UInt_t!", fCount);
134     return kFALSE;
135   }
136   if (!ReadNext((UChar_t*) &data, sizeof(data))) {
137     Error("ReadNextInt", "could not read data!");
138     return kFALSE;
139   }
140   return kTRUE;
141 }
142
143 Bool_t AliRawReader::ReadNextShort(UShort_t& data)
144 {
145 // reads the next 2 bytes at the current position
146 // returns kFALSE if the data could not be read
147
148   while (fCount == 0) {
149     if (!ReadMiniHeader()) return kFALSE;
150   }
151   if (fCount < (Int_t) sizeof(data)) {
152     Error("ReadNextShort", 
153           "too few data left (%d bytes) to read an UShort_t!", fCount);
154     return kFALSE;
155   }
156   if (!ReadNext((UChar_t*) &data, sizeof(data))) {
157     Error("ReadNextShort", "could not read data!");
158     return kFALSE;
159   }
160   return kTRUE;
161 }
162
163 Bool_t AliRawReader::ReadNextChar(UChar_t& data)
164 {
165 // reads the next 1 byte at the current stream position
166 // returns kFALSE if the data could not be read
167
168   while (fCount == 0) {
169     if (!ReadMiniHeader()) return kFALSE;
170   }
171   if (!ReadNext((UChar_t*) &data, sizeof(data))) {
172     Error("ReadNextChar", "could not read data!");
173     return kFALSE;
174   }
175   return kTRUE;
176 }
177