Jpp 19.3.0-rc.1
the software that should make you happy
Loading...
Searching...
No Matches
JDetectorVersion.hh
Go to the documentation of this file.
1#ifndef __JDETECTOR__JDETECTORVERSION__
2#define __JDETECTOR__JDETECTORVERSION__
3
4#include <istream>
5#include <ostream>
6#include <string>
7#include <vector>
8#include <map>
9
10#include "JIO/JSerialisable.hh"
11#include "JIO/JSTDIO.hh"
12#include "JLang/JType.hh"
13#include "JLang/JLangToolkit.hh"
14#include "JLang/JException.hh"
15#include "JLang/JVectorize.hh"
16#include "JDetector/JVersion.hh"
17#include "Jeep/JeepToolkit.hh"
18
19
20/**
21 * \file
22 *
23 * Data structure for detector version.
24 * \author mdejong
25 */
26namespace JDETECTOR {}
27namespace JPP { using namespace JDETECTOR; }
28
29namespace JDETECTOR {
30
31 using JLANG::JType;
34 using JIO::JReader;
35 using JIO::JWriter;
36
37
38 /**
39 * Detector version.
40 */
42 public JVersion
43 {
44 /**
45 * Enumeration of version types.\n
46 * Note that additional version types should be included in JGetDetectorVersion::JGetDetectorVersion.
47 */
49 V1 = 1, //!< First version
50 V2 = 2, //!< Version with UTC time and UTM position data
51 V3 = 3, //!< Version with PMT status field and comments
52 V4 = 4, //!< Version with quaternion and time offset per module
53 V5 = 5 //!< Version with module status field
54 };
55
56
57 /**
58 * Default constructor.
59 */
61 JVersion()
62 {}
63
64
65 /**
66 * Constructor.
67 *
68 * \param version version
69 */
73
74
75 /**
76 * Check validity of version.
77 *
78 * \return true if valid; else false
79 */
80 bool hasVersion() const
81 {
82 return (!this->version.empty() && (this->version[0] == 'v' || this->version[0] == 'V'));
83 }
84
85
86 /**
87 * Read version from input.
88 *
89 * \param in input stream
90 * \param version version
91 * \return input stream
92 */
93 friend inline std::istream& operator>>(std::istream& in, JDetectorVersion& version)
94 {
95 return in >> version.version;
96 }
97
98
99 /**
100 * Write version to output.
101 *
102 * \param out output stream
103 * \param version version
104 * \return output stream
105 */
106 friend inline std::ostream& operator<<(std::ostream& out, const JDetectorVersion& version)
107 {
108 return out << version.version;
109 }
110
111
112 /**
113 * Read version from input.
114 *
115 * \param in reader
116 * \param version version
117 * \return reader
118 */
120 {
121 return in >> version.version;
122 }
123
124
125 /**
126 * Write version to output.
127 *
128 * \param out writer
129 * \param version version
130 * \return writer
131 */
132 friend inline JWriter& operator<<(JWriter& out, const JDetectorVersion& version)
133 {
134 return out << version.version;
135 }
136 };
137
138
139 /**
140 * Auxiliary class to map detector version to numerical value.
141 */
143 public std::map<std::string, JDetectorVersion::JVersion_t>
144 {
145 /**
146 * Default constructor.
147 */
149 {
150 using namespace JPP;
151
152#define MAKE_ENTRY(A) std::make_pair(to_upper(getClassname(#A)), A)
153
154 this->insert(MAKE_ENTRY(JDetectorVersion::V1));
155 this->insert(MAKE_ENTRY(JDetectorVersion::V2));
156 this->insert(MAKE_ENTRY(JDetectorVersion::V3));
157 this->insert(MAKE_ENTRY(JDetectorVersion::V4));
158 this->insert(MAKE_ENTRY(JDetectorVersion::V5));
159
160#undef MAKE_ENTRY
161 }
162
163
164 /**
165 * Get numerical value.
166 *
167 * \param version version
168 * \return numerical value
169 */
170 JDetectorVersion::JVersion_t operator()(const std::string& version) const
171 {
172 using namespace JPP;
173
174 const_iterator i = this->find(to_upper(version));
175
176 if (i != this->end()) {
177 return i->second;
178 } else {
179 THROW(JTypeInformationException, "Invalid version <" << version << ">");
180 }
181 }
182
183
184 /**
185 * Get numerical value.
186 *
187 * \param version version
188 * \return numerical value
189 */
191 {
192 return (*this)(version.getVersion());
193 }
194
195
196 /**
197 * Get index of detector version.
198 *
199 * \param version version
200 * \return index
201 */
202 int operator[](const std::string& version) const
203 {
204 using namespace std;
205 using namespace JPP;
206
207 const_iterator i = this->find(to_upper(version));
208
209 if (i != this->end())
210 return distance(this->begin(), i);
211 else
212 return -1;
213 }
214
215
216 /**
217 * Get index of detector version.
218 *
219 * \param version version
220 * \return index
221 */
222 int operator[](const JDetectorVersion& version) const
223 {
224 return (*this)[version.getVersion()];
225 }
226
227
228 /**
229 * Get index of detector version.
230 *
231 * \param value numerical value
232 * \return index
233 */
235 {
236 using namespace std;
237
238 for (const_iterator i = this->begin(); i != this->end(); ++i) {
239 if (i->second == value) {
240 return distance(this->begin(), i);
241 }
242 }
243
244 return -1;
245 }
246 };
247
248
249 /**
250 * Auxiliary class to map numerical value to detector version.
251 */
253 public std::map<JDetectorVersion::JVersion_t, std::string>
254 {
255 /**
256 * Constructor.
257 *
258 * \param input detector versions
259 */
261 {
262 using namespace std;
263
264 for (JGetDetectorVersion::const_iterator i = input.begin(); i != input.end(); ++i) {
265 this->insert(make_pair(i->second, i->first));
266 }
267 }
268
269
270 /**
271 * Put detector version.
272 *
273 * \param value numerical value
274 * \return version
275 */
276 const std::string& operator()(const JDetectorVersion::JVersion_t& value) const
277 {
278 const_iterator i = this->find(value);
279
280 if (i != this->end()) {
281 return i->second;
282 } else {
283 THROW(JTypeInformationException, "Invalid value <" << value << ">");
284 }
285 }
286
287
288 /**
289 * Get index of version
290 *
291 * \param value numerical value
292 * \return index
293 */
295 {
296 using namespace std;
297
298 const_iterator i = this->find(value);
299
300 if (i != this->end())
301 return distance(this->begin(), i);
302 else
303 return -1;
304 }
305 };
306
307
308 /**
309 * Function object to map detector version to numerical value.
310 */
312
313
314 /**
315 * Function object to map numerical value to detector version.
316 */
318
319
320 /**
321 * Get detector versions.
322 *
323 * Note that the order of the versions is descending.
324 *
325 * \param type type
326 * \return versions
327 */
329 {
330 return JLANG::make_array(putDetectorVersion.rbegin(), putDetectorVersion.rend(), &JPutDetectorVersion::value_type::second);
331 }
332
333
334 /**
335 * Get detector versions.
336 *
337 * Note that the order of the versions is descending.
338 *
339 * \param type type
340 * \return numerical values
341 */
343 {
344 return JLANG::make_array(putDetectorVersion.rbegin(), putDetectorVersion.rend(), &JPutDetectorVersion::value_type::first);
345 }
346
347
348 /**
349 * Get detector versions.
350 *
351 * \return versions
352 */
353 template<class T>
358
359
360 /**
361 * Get latest detector version.
362 *
363 * \param type type
364 * \return version
365 */
366 inline std::string getLatestDetectorVersion(const JType<std::string>& type)
367 {
368 return putDetectorVersion.rbegin()->second;
369 }
370
371
372 /**
373 * Get latest detector version.
374 *
375 * \param type type
376 * \return version
377 */
379 {
380 return putDetectorVersion.rbegin()->second;
381 }
382
383
384 /**
385 * Get latest detector version.
386 *
387 * \param type type
388 * \return version
389 */
394
395
396 /**
397 * Get latest detector version.
398 *
399 * \return version
400 */
401 template<class T>
403 {
405 }
406}
407
408#endif
Exceptions.
#define THROW(JException_t, A)
Marco for throwing exception with std::ostream compatible message.
#define MAKE_ENTRY(A)
STD extensions for binary I/O.
Auxiliary methods to convert data members or return values of member methods of a set of objects to a...
Auxiliary methods for handling file names, type names and environment.
std::vector< T >::difference_type distance(typename std::vector< T >::const_iterator first, typename PhysicsEvent::const_iterator< T > second)
Specialisation of STL distance.
Interface for binary input.
Interface for binary output.
Exception for I/O.
Exception for absence of type information.
file Auxiliary data structures and methods for detector calibration.
Definition JAnchor.hh:12
static const JGetDetectorVersion getDetectorVersion
Function object to map detector version to numerical value.
T getLatestDetectorVersion()
Get latest detector version.
static const JPutDetectorVersion putDetectorVersion(getDetectorVersion)
Function object to map numerical value to detector version.
std::vector< T > getDetectorVersions()
Get detector versions.
const array_type< JValue_t > & make_array(const JValue_t(&array)[N])
Method to create array of values.
Definition JVectorize.hh:54
This name space includes all other name spaces (except KM3NETDAQ, KM3NET and ANTARES).
bool hasVersion() const
Check validity of version.
JDetectorVersion()
Default constructor.
friend std::ostream & operator<<(std::ostream &out, const JDetectorVersion &version)
Write version to output.
JDetectorVersion(const JVersion &version)
Constructor.
friend std::istream & operator>>(std::istream &in, JDetectorVersion &version)
Read version from input.
friend JReader & operator>>(JReader &in, JDetectorVersion &version)
Read version from input.
friend JWriter & operator<<(JWriter &out, const JDetectorVersion &version)
Write version to output.
JVersion_t
Enumeration of version types.
@ V2
Version with UTC time and UTM position data.
@ V5
Version with module status field.
@ V4
Version with quaternion and time offset per module.
@ V3
Version with PMT status field and comments.
Auxiliary class to map detector version to numerical value.
JDetectorVersion::JVersion_t operator()(const std::string &version) const
Get numerical value.
int operator[](const JDetectorVersion::JVersion_t &value) const
Get index of detector version.
JDetectorVersion::JVersion_t operator()(const JDetectorVersion &version) const
Get numerical value.
JGetDetectorVersion()
Default constructor.
int operator[](const std::string &version) const
Get index of detector version.
int operator[](const JDetectorVersion &version) const
Get index of detector version.
Auxiliary class to map numerical value to detector version.
const std::string & operator()(const JDetectorVersion::JVersion_t &value) const
Put detector version.
JPutDetectorVersion(const JGetDetectorVersion &input)
Constructor.
int operator[](const JDetectorVersion::JVersion_t &value) const
Get index of version.
Auxiliary class for version identifier.
const std::string & getVersion() const
Get version.
Auxiliary class for a type holder.
Definition JType.hh:19