Line data Source code
1 :
2 : /*
3 : * ALMA - Atacama Large Millimeter Array
4 : * (c) European Southern Observatory, 2002
5 : * (c) Associated Universities Inc., 2002
6 : * Copyright by ESO (in the framework of the ALMA collaboration),
7 : * Copyright by AUI (in the framework of the ALMA collaboration),
8 : * All rights reserved.
9 : *
10 : * This library is free software; you can redistribute it and/or
11 : * modify it under the terms of the GNU Lesser General Public
12 : * License as published by the Free software Foundation; either
13 : * version 2.1 of the License, or (at your option) any later version.
14 : *
15 : * This library is distributed in the hope that it will be useful,
16 : * but WITHOUT ANY WARRANTY, without even the implied warranty of
17 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 : * Lesser General Public License for more details.
19 : *
20 : * You should have received a copy of the GNU Lesser General Public
21 : * License along with this library; if not, write to the Free Software
22 : * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23 : * MA 02111-1307 USA
24 : *
25 : * /////////////////////////////////////////////////////////////////
26 : * // WARNING! DO NOT MODIFY THIS FILE! //
27 : * // --------------------------------------------------------- //
28 : * // | This is generated code! Do not modify this file. | //
29 : * // | Any changes will be lost when the file is re-generated. | //
30 : * // --------------------------------------------------------- //
31 : * /////////////////////////////////////////////////////////////////
32 : *
33 : * File CBinaryDataFlags.cpp
34 : */
35 : #include <sstream>
36 : #include <alma/Enumerations/CBinaryDataFlags.h>
37 : #include <string>
38 : using namespace std;
39 :
40 0 : int CBinaryDataFlags::version() {
41 0 : return BinaryDataFlagsMod::version;
42 : }
43 :
44 0 : string CBinaryDataFlags::revision () {
45 0 : return BinaryDataFlagsMod::revision;
46 : }
47 :
48 0 : unsigned int CBinaryDataFlags::size() {
49 0 : return 32;
50 : }
51 :
52 :
53 : const std::string& CBinaryDataFlags::sINTEGRATION_FULLY_BLANKED = "INTEGRATION_FULLY_BLANKED";
54 :
55 : const std::string& CBinaryDataFlags::sWVR_APC = "WVR_APC";
56 :
57 : const std::string& CBinaryDataFlags::sCORRELATOR_MISSING_STATUS = "CORRELATOR_MISSING_STATUS";
58 :
59 : const std::string& CBinaryDataFlags::sMISSING_ANTENNA_EVENT = "MISSING_ANTENNA_EVENT";
60 :
61 : const std::string& CBinaryDataFlags::sDELTA_SIGMA_OVERFLOW = "DELTA_SIGMA_OVERFLOW";
62 :
63 : const std::string& CBinaryDataFlags::sDELAY_CORRECTION_NOT_APPLIED = "DELAY_CORRECTION_NOT_APPLIED";
64 :
65 : const std::string& CBinaryDataFlags::sSYNCRONIZATION_ERROR = "SYNCRONIZATION_ERROR";
66 :
67 : const std::string& CBinaryDataFlags::sFFT_OVERFLOW = "FFT_OVERFLOW";
68 :
69 : const std::string& CBinaryDataFlags::sTFB_SCALING_FACTOR_NOT_RETRIEVED = "TFB_SCALING_FACTOR_NOT_RETRIEVED";
70 :
71 : const std::string& CBinaryDataFlags::sZERO_LAG_NOT_RECEIVED = "ZERO_LAG_NOT_RECEIVED";
72 :
73 : const std::string& CBinaryDataFlags::sSIGMA_OVERFLOW = "SIGMA_OVERFLOW";
74 :
75 : const std::string& CBinaryDataFlags::sUNUSABLE_CAI_OUTPUT = "UNUSABLE_CAI_OUTPUT";
76 :
77 : const std::string& CBinaryDataFlags::sQC_FAILED = "QC_FAILED";
78 :
79 : const std::string& CBinaryDataFlags::sNOISY_TDM_CHANNELS = "NOISY_TDM_CHANNELS";
80 :
81 : const std::string& CBinaryDataFlags::sSPECTRAL_NORMALIZATION_FAILED = "SPECTRAL_NORMALIZATION_FAILED";
82 :
83 : const std::string& CBinaryDataFlags::sDROPPED_PACKETS = "DROPPED_PACKETS";
84 :
85 : const std::string& CBinaryDataFlags::sDETECTOR_SATURATED = "DETECTOR_SATURATED";
86 :
87 : const std::string& CBinaryDataFlags::sNO_DATA_FROM_DIGITAL_POWER_METER = "NO_DATA_FROM_DIGITAL_POWER_METER";
88 :
89 : const std::string& CBinaryDataFlags::sRESERVED_18 = "RESERVED_18";
90 :
91 : const std::string& CBinaryDataFlags::sRESERVED_19 = "RESERVED_19";
92 :
93 : const std::string& CBinaryDataFlags::sRESERVED_20 = "RESERVED_20";
94 :
95 : const std::string& CBinaryDataFlags::sRESERVED_21 = "RESERVED_21";
96 :
97 : const std::string& CBinaryDataFlags::sRESERVED_22 = "RESERVED_22";
98 :
99 : const std::string& CBinaryDataFlags::sRESERVED_23 = "RESERVED_23";
100 :
101 : const std::string& CBinaryDataFlags::sRESERVED_24 = "RESERVED_24";
102 :
103 : const std::string& CBinaryDataFlags::sRESERVED_25 = "RESERVED_25";
104 :
105 : const std::string& CBinaryDataFlags::sRESERVED_26 = "RESERVED_26";
106 :
107 : const std::string& CBinaryDataFlags::sRESERVED_27 = "RESERVED_27";
108 :
109 : const std::string& CBinaryDataFlags::sRESERVED_28 = "RESERVED_28";
110 :
111 : const std::string& CBinaryDataFlags::sRESERVED_29 = "RESERVED_29";
112 :
113 : const std::string& CBinaryDataFlags::sRESERVED_30 = "RESERVED_30";
114 :
115 : const std::string& CBinaryDataFlags::sALL_PURPOSE_ERROR = "ALL_PURPOSE_ERROR";
116 :
117 0 : const std::vector<std::string> CBinaryDataFlags::names() {
118 0 : std::vector<std::string> enumSet;
119 :
120 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sINTEGRATION_FULLY_BLANKED);
121 :
122 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sWVR_APC);
123 :
124 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sCORRELATOR_MISSING_STATUS);
125 :
126 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sMISSING_ANTENNA_EVENT);
127 :
128 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sDELTA_SIGMA_OVERFLOW);
129 :
130 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sDELAY_CORRECTION_NOT_APPLIED);
131 :
132 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sSYNCRONIZATION_ERROR);
133 :
134 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sFFT_OVERFLOW);
135 :
136 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sTFB_SCALING_FACTOR_NOT_RETRIEVED);
137 :
138 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sZERO_LAG_NOT_RECEIVED);
139 :
140 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sSIGMA_OVERFLOW);
141 :
142 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sUNUSABLE_CAI_OUTPUT);
143 :
144 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sQC_FAILED);
145 :
146 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sNOISY_TDM_CHANNELS);
147 :
148 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sSPECTRAL_NORMALIZATION_FAILED);
149 :
150 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sDROPPED_PACKETS);
151 :
152 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sDETECTOR_SATURATED);
153 :
154 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sNO_DATA_FROM_DIGITAL_POWER_METER);
155 :
156 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_18);
157 :
158 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_19);
159 :
160 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_20);
161 :
162 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_21);
163 :
164 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_22);
165 :
166 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_23);
167 :
168 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_24);
169 :
170 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_25);
171 :
172 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_26);
173 :
174 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_27);
175 :
176 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_28);
177 :
178 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_29);
179 :
180 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sRESERVED_30);
181 :
182 0 : enumSet.insert(enumSet.end(), CBinaryDataFlags::sALL_PURPOSE_ERROR);
183 :
184 0 : return enumSet;
185 0 : }
186 :
187 0 : std::string CBinaryDataFlags::name(const BinaryDataFlagsMod::BinaryDataFlags& f) {
188 0 : switch (f) {
189 :
190 0 : case BinaryDataFlagsMod::INTEGRATION_FULLY_BLANKED:
191 0 : return CBinaryDataFlags::sINTEGRATION_FULLY_BLANKED;
192 :
193 0 : case BinaryDataFlagsMod::WVR_APC:
194 0 : return CBinaryDataFlags::sWVR_APC;
195 :
196 0 : case BinaryDataFlagsMod::CORRELATOR_MISSING_STATUS:
197 0 : return CBinaryDataFlags::sCORRELATOR_MISSING_STATUS;
198 :
199 0 : case BinaryDataFlagsMod::MISSING_ANTENNA_EVENT:
200 0 : return CBinaryDataFlags::sMISSING_ANTENNA_EVENT;
201 :
202 0 : case BinaryDataFlagsMod::DELTA_SIGMA_OVERFLOW:
203 0 : return CBinaryDataFlags::sDELTA_SIGMA_OVERFLOW;
204 :
205 0 : case BinaryDataFlagsMod::DELAY_CORRECTION_NOT_APPLIED:
206 0 : return CBinaryDataFlags::sDELAY_CORRECTION_NOT_APPLIED;
207 :
208 0 : case BinaryDataFlagsMod::SYNCRONIZATION_ERROR:
209 0 : return CBinaryDataFlags::sSYNCRONIZATION_ERROR;
210 :
211 0 : case BinaryDataFlagsMod::FFT_OVERFLOW:
212 0 : return CBinaryDataFlags::sFFT_OVERFLOW;
213 :
214 0 : case BinaryDataFlagsMod::TFB_SCALING_FACTOR_NOT_RETRIEVED:
215 0 : return CBinaryDataFlags::sTFB_SCALING_FACTOR_NOT_RETRIEVED;
216 :
217 0 : case BinaryDataFlagsMod::ZERO_LAG_NOT_RECEIVED:
218 0 : return CBinaryDataFlags::sZERO_LAG_NOT_RECEIVED;
219 :
220 0 : case BinaryDataFlagsMod::SIGMA_OVERFLOW:
221 0 : return CBinaryDataFlags::sSIGMA_OVERFLOW;
222 :
223 0 : case BinaryDataFlagsMod::UNUSABLE_CAI_OUTPUT:
224 0 : return CBinaryDataFlags::sUNUSABLE_CAI_OUTPUT;
225 :
226 0 : case BinaryDataFlagsMod::QC_FAILED:
227 0 : return CBinaryDataFlags::sQC_FAILED;
228 :
229 0 : case BinaryDataFlagsMod::NOISY_TDM_CHANNELS:
230 0 : return CBinaryDataFlags::sNOISY_TDM_CHANNELS;
231 :
232 0 : case BinaryDataFlagsMod::SPECTRAL_NORMALIZATION_FAILED:
233 0 : return CBinaryDataFlags::sSPECTRAL_NORMALIZATION_FAILED;
234 :
235 0 : case BinaryDataFlagsMod::DROPPED_PACKETS:
236 0 : return CBinaryDataFlags::sDROPPED_PACKETS;
237 :
238 0 : case BinaryDataFlagsMod::DETECTOR_SATURATED:
239 0 : return CBinaryDataFlags::sDETECTOR_SATURATED;
240 :
241 0 : case BinaryDataFlagsMod::NO_DATA_FROM_DIGITAL_POWER_METER:
242 0 : return CBinaryDataFlags::sNO_DATA_FROM_DIGITAL_POWER_METER;
243 :
244 0 : case BinaryDataFlagsMod::RESERVED_18:
245 0 : return CBinaryDataFlags::sRESERVED_18;
246 :
247 0 : case BinaryDataFlagsMod::RESERVED_19:
248 0 : return CBinaryDataFlags::sRESERVED_19;
249 :
250 0 : case BinaryDataFlagsMod::RESERVED_20:
251 0 : return CBinaryDataFlags::sRESERVED_20;
252 :
253 0 : case BinaryDataFlagsMod::RESERVED_21:
254 0 : return CBinaryDataFlags::sRESERVED_21;
255 :
256 0 : case BinaryDataFlagsMod::RESERVED_22:
257 0 : return CBinaryDataFlags::sRESERVED_22;
258 :
259 0 : case BinaryDataFlagsMod::RESERVED_23:
260 0 : return CBinaryDataFlags::sRESERVED_23;
261 :
262 0 : case BinaryDataFlagsMod::RESERVED_24:
263 0 : return CBinaryDataFlags::sRESERVED_24;
264 :
265 0 : case BinaryDataFlagsMod::RESERVED_25:
266 0 : return CBinaryDataFlags::sRESERVED_25;
267 :
268 0 : case BinaryDataFlagsMod::RESERVED_26:
269 0 : return CBinaryDataFlags::sRESERVED_26;
270 :
271 0 : case BinaryDataFlagsMod::RESERVED_27:
272 0 : return CBinaryDataFlags::sRESERVED_27;
273 :
274 0 : case BinaryDataFlagsMod::RESERVED_28:
275 0 : return CBinaryDataFlags::sRESERVED_28;
276 :
277 0 : case BinaryDataFlagsMod::RESERVED_29:
278 0 : return CBinaryDataFlags::sRESERVED_29;
279 :
280 0 : case BinaryDataFlagsMod::RESERVED_30:
281 0 : return CBinaryDataFlags::sRESERVED_30;
282 :
283 0 : case BinaryDataFlagsMod::ALL_PURPOSE_ERROR:
284 0 : return CBinaryDataFlags::sALL_PURPOSE_ERROR;
285 :
286 : }
287 : // Impossible siutation but....who knows with C++ enums
288 0 : throw badInt((int) f);
289 : }
290 :
291 0 : BinaryDataFlagsMod::BinaryDataFlags CBinaryDataFlags::newBinaryDataFlags(const std::string& name) {
292 :
293 0 : if (name == CBinaryDataFlags::sINTEGRATION_FULLY_BLANKED) {
294 0 : return BinaryDataFlagsMod::INTEGRATION_FULLY_BLANKED;
295 : }
296 :
297 0 : if (name == CBinaryDataFlags::sWVR_APC) {
298 0 : return BinaryDataFlagsMod::WVR_APC;
299 : }
300 :
301 0 : if (name == CBinaryDataFlags::sCORRELATOR_MISSING_STATUS) {
302 0 : return BinaryDataFlagsMod::CORRELATOR_MISSING_STATUS;
303 : }
304 :
305 0 : if (name == CBinaryDataFlags::sMISSING_ANTENNA_EVENT) {
306 0 : return BinaryDataFlagsMod::MISSING_ANTENNA_EVENT;
307 : }
308 :
309 0 : if (name == CBinaryDataFlags::sDELTA_SIGMA_OVERFLOW) {
310 0 : return BinaryDataFlagsMod::DELTA_SIGMA_OVERFLOW;
311 : }
312 :
313 0 : if (name == CBinaryDataFlags::sDELAY_CORRECTION_NOT_APPLIED) {
314 0 : return BinaryDataFlagsMod::DELAY_CORRECTION_NOT_APPLIED;
315 : }
316 :
317 0 : if (name == CBinaryDataFlags::sSYNCRONIZATION_ERROR) {
318 0 : return BinaryDataFlagsMod::SYNCRONIZATION_ERROR;
319 : }
320 :
321 0 : if (name == CBinaryDataFlags::sFFT_OVERFLOW) {
322 0 : return BinaryDataFlagsMod::FFT_OVERFLOW;
323 : }
324 :
325 0 : if (name == CBinaryDataFlags::sTFB_SCALING_FACTOR_NOT_RETRIEVED) {
326 0 : return BinaryDataFlagsMod::TFB_SCALING_FACTOR_NOT_RETRIEVED;
327 : }
328 :
329 0 : if (name == CBinaryDataFlags::sZERO_LAG_NOT_RECEIVED) {
330 0 : return BinaryDataFlagsMod::ZERO_LAG_NOT_RECEIVED;
331 : }
332 :
333 0 : if (name == CBinaryDataFlags::sSIGMA_OVERFLOW) {
334 0 : return BinaryDataFlagsMod::SIGMA_OVERFLOW;
335 : }
336 :
337 0 : if (name == CBinaryDataFlags::sUNUSABLE_CAI_OUTPUT) {
338 0 : return BinaryDataFlagsMod::UNUSABLE_CAI_OUTPUT;
339 : }
340 :
341 0 : if (name == CBinaryDataFlags::sQC_FAILED) {
342 0 : return BinaryDataFlagsMod::QC_FAILED;
343 : }
344 :
345 0 : if (name == CBinaryDataFlags::sNOISY_TDM_CHANNELS) {
346 0 : return BinaryDataFlagsMod::NOISY_TDM_CHANNELS;
347 : }
348 :
349 0 : if (name == CBinaryDataFlags::sSPECTRAL_NORMALIZATION_FAILED) {
350 0 : return BinaryDataFlagsMod::SPECTRAL_NORMALIZATION_FAILED;
351 : }
352 :
353 0 : if (name == CBinaryDataFlags::sDROPPED_PACKETS) {
354 0 : return BinaryDataFlagsMod::DROPPED_PACKETS;
355 : }
356 :
357 0 : if (name == CBinaryDataFlags::sDETECTOR_SATURATED) {
358 0 : return BinaryDataFlagsMod::DETECTOR_SATURATED;
359 : }
360 :
361 0 : if (name == CBinaryDataFlags::sNO_DATA_FROM_DIGITAL_POWER_METER) {
362 0 : return BinaryDataFlagsMod::NO_DATA_FROM_DIGITAL_POWER_METER;
363 : }
364 :
365 0 : if (name == CBinaryDataFlags::sRESERVED_18) {
366 0 : return BinaryDataFlagsMod::RESERVED_18;
367 : }
368 :
369 0 : if (name == CBinaryDataFlags::sRESERVED_19) {
370 0 : return BinaryDataFlagsMod::RESERVED_19;
371 : }
372 :
373 0 : if (name == CBinaryDataFlags::sRESERVED_20) {
374 0 : return BinaryDataFlagsMod::RESERVED_20;
375 : }
376 :
377 0 : if (name == CBinaryDataFlags::sRESERVED_21) {
378 0 : return BinaryDataFlagsMod::RESERVED_21;
379 : }
380 :
381 0 : if (name == CBinaryDataFlags::sRESERVED_22) {
382 0 : return BinaryDataFlagsMod::RESERVED_22;
383 : }
384 :
385 0 : if (name == CBinaryDataFlags::sRESERVED_23) {
386 0 : return BinaryDataFlagsMod::RESERVED_23;
387 : }
388 :
389 0 : if (name == CBinaryDataFlags::sRESERVED_24) {
390 0 : return BinaryDataFlagsMod::RESERVED_24;
391 : }
392 :
393 0 : if (name == CBinaryDataFlags::sRESERVED_25) {
394 0 : return BinaryDataFlagsMod::RESERVED_25;
395 : }
396 :
397 0 : if (name == CBinaryDataFlags::sRESERVED_26) {
398 0 : return BinaryDataFlagsMod::RESERVED_26;
399 : }
400 :
401 0 : if (name == CBinaryDataFlags::sRESERVED_27) {
402 0 : return BinaryDataFlagsMod::RESERVED_27;
403 : }
404 :
405 0 : if (name == CBinaryDataFlags::sRESERVED_28) {
406 0 : return BinaryDataFlagsMod::RESERVED_28;
407 : }
408 :
409 0 : if (name == CBinaryDataFlags::sRESERVED_29) {
410 0 : return BinaryDataFlagsMod::RESERVED_29;
411 : }
412 :
413 0 : if (name == CBinaryDataFlags::sRESERVED_30) {
414 0 : return BinaryDataFlagsMod::RESERVED_30;
415 : }
416 :
417 0 : if (name == CBinaryDataFlags::sALL_PURPOSE_ERROR) {
418 0 : return BinaryDataFlagsMod::ALL_PURPOSE_ERROR;
419 : }
420 :
421 0 : throw badString(name);
422 : }
423 :
424 0 : BinaryDataFlagsMod::BinaryDataFlags CBinaryDataFlags::literal(const std::string& name) {
425 :
426 0 : if (name == CBinaryDataFlags::sINTEGRATION_FULLY_BLANKED) {
427 0 : return BinaryDataFlagsMod::INTEGRATION_FULLY_BLANKED;
428 : }
429 :
430 0 : if (name == CBinaryDataFlags::sWVR_APC) {
431 0 : return BinaryDataFlagsMod::WVR_APC;
432 : }
433 :
434 0 : if (name == CBinaryDataFlags::sCORRELATOR_MISSING_STATUS) {
435 0 : return BinaryDataFlagsMod::CORRELATOR_MISSING_STATUS;
436 : }
437 :
438 0 : if (name == CBinaryDataFlags::sMISSING_ANTENNA_EVENT) {
439 0 : return BinaryDataFlagsMod::MISSING_ANTENNA_EVENT;
440 : }
441 :
442 0 : if (name == CBinaryDataFlags::sDELTA_SIGMA_OVERFLOW) {
443 0 : return BinaryDataFlagsMod::DELTA_SIGMA_OVERFLOW;
444 : }
445 :
446 0 : if (name == CBinaryDataFlags::sDELAY_CORRECTION_NOT_APPLIED) {
447 0 : return BinaryDataFlagsMod::DELAY_CORRECTION_NOT_APPLIED;
448 : }
449 :
450 0 : if (name == CBinaryDataFlags::sSYNCRONIZATION_ERROR) {
451 0 : return BinaryDataFlagsMod::SYNCRONIZATION_ERROR;
452 : }
453 :
454 0 : if (name == CBinaryDataFlags::sFFT_OVERFLOW) {
455 0 : return BinaryDataFlagsMod::FFT_OVERFLOW;
456 : }
457 :
458 0 : if (name == CBinaryDataFlags::sTFB_SCALING_FACTOR_NOT_RETRIEVED) {
459 0 : return BinaryDataFlagsMod::TFB_SCALING_FACTOR_NOT_RETRIEVED;
460 : }
461 :
462 0 : if (name == CBinaryDataFlags::sZERO_LAG_NOT_RECEIVED) {
463 0 : return BinaryDataFlagsMod::ZERO_LAG_NOT_RECEIVED;
464 : }
465 :
466 0 : if (name == CBinaryDataFlags::sSIGMA_OVERFLOW) {
467 0 : return BinaryDataFlagsMod::SIGMA_OVERFLOW;
468 : }
469 :
470 0 : if (name == CBinaryDataFlags::sUNUSABLE_CAI_OUTPUT) {
471 0 : return BinaryDataFlagsMod::UNUSABLE_CAI_OUTPUT;
472 : }
473 :
474 0 : if (name == CBinaryDataFlags::sQC_FAILED) {
475 0 : return BinaryDataFlagsMod::QC_FAILED;
476 : }
477 :
478 0 : if (name == CBinaryDataFlags::sNOISY_TDM_CHANNELS) {
479 0 : return BinaryDataFlagsMod::NOISY_TDM_CHANNELS;
480 : }
481 :
482 0 : if (name == CBinaryDataFlags::sSPECTRAL_NORMALIZATION_FAILED) {
483 0 : return BinaryDataFlagsMod::SPECTRAL_NORMALIZATION_FAILED;
484 : }
485 :
486 0 : if (name == CBinaryDataFlags::sDROPPED_PACKETS) {
487 0 : return BinaryDataFlagsMod::DROPPED_PACKETS;
488 : }
489 :
490 0 : if (name == CBinaryDataFlags::sDETECTOR_SATURATED) {
491 0 : return BinaryDataFlagsMod::DETECTOR_SATURATED;
492 : }
493 :
494 0 : if (name == CBinaryDataFlags::sNO_DATA_FROM_DIGITAL_POWER_METER) {
495 0 : return BinaryDataFlagsMod::NO_DATA_FROM_DIGITAL_POWER_METER;
496 : }
497 :
498 0 : if (name == CBinaryDataFlags::sRESERVED_18) {
499 0 : return BinaryDataFlagsMod::RESERVED_18;
500 : }
501 :
502 0 : if (name == CBinaryDataFlags::sRESERVED_19) {
503 0 : return BinaryDataFlagsMod::RESERVED_19;
504 : }
505 :
506 0 : if (name == CBinaryDataFlags::sRESERVED_20) {
507 0 : return BinaryDataFlagsMod::RESERVED_20;
508 : }
509 :
510 0 : if (name == CBinaryDataFlags::sRESERVED_21) {
511 0 : return BinaryDataFlagsMod::RESERVED_21;
512 : }
513 :
514 0 : if (name == CBinaryDataFlags::sRESERVED_22) {
515 0 : return BinaryDataFlagsMod::RESERVED_22;
516 : }
517 :
518 0 : if (name == CBinaryDataFlags::sRESERVED_23) {
519 0 : return BinaryDataFlagsMod::RESERVED_23;
520 : }
521 :
522 0 : if (name == CBinaryDataFlags::sRESERVED_24) {
523 0 : return BinaryDataFlagsMod::RESERVED_24;
524 : }
525 :
526 0 : if (name == CBinaryDataFlags::sRESERVED_25) {
527 0 : return BinaryDataFlagsMod::RESERVED_25;
528 : }
529 :
530 0 : if (name == CBinaryDataFlags::sRESERVED_26) {
531 0 : return BinaryDataFlagsMod::RESERVED_26;
532 : }
533 :
534 0 : if (name == CBinaryDataFlags::sRESERVED_27) {
535 0 : return BinaryDataFlagsMod::RESERVED_27;
536 : }
537 :
538 0 : if (name == CBinaryDataFlags::sRESERVED_28) {
539 0 : return BinaryDataFlagsMod::RESERVED_28;
540 : }
541 :
542 0 : if (name == CBinaryDataFlags::sRESERVED_29) {
543 0 : return BinaryDataFlagsMod::RESERVED_29;
544 : }
545 :
546 0 : if (name == CBinaryDataFlags::sRESERVED_30) {
547 0 : return BinaryDataFlagsMod::RESERVED_30;
548 : }
549 :
550 0 : if (name == CBinaryDataFlags::sALL_PURPOSE_ERROR) {
551 0 : return BinaryDataFlagsMod::ALL_PURPOSE_ERROR;
552 : }
553 :
554 0 : throw badString(name);
555 : }
556 :
557 0 : BinaryDataFlagsMod::BinaryDataFlags CBinaryDataFlags::from_int(unsigned int i) {
558 0 : vector<string> names_ = names();
559 0 : if (i >= names_.size()) throw badInt(i);
560 0 : return newBinaryDataFlags(names_.at(i));
561 0 : }
562 :
563 0 : string CBinaryDataFlags::badString(const string& name) {
564 0 : return "'"+name+"' does not correspond to any literal in the enumeration 'BinaryDataFlags'.";
565 : }
566 :
567 0 : string CBinaryDataFlags::badInt(unsigned int i) {
568 0 : ostringstream oss ;
569 0 : oss << "'" << i << "' is out of range for the enumeration 'BinaryDataFlags'.";
570 0 : return oss.str();
571 0 : }
572 :
573 : namespace BinaryDataFlagsMod {
574 0 : std::ostream & operator << ( std::ostream & out, const BinaryDataFlags& value) {
575 0 : out << CBinaryDataFlags::name(value);
576 0 : return out;
577 : }
578 :
579 0 : std::istream & operator >> ( std::istream & in , BinaryDataFlags& value ) {
580 0 : in.clear();
581 0 : string s ;
582 0 : in >> s;
583 : try {
584 0 : value = CBinaryDataFlags::literal(s);
585 : }
586 0 : catch (string & m) {
587 0 : in.setstate(ios::failbit);
588 0 : }
589 0 : return in;
590 0 : }
591 : }
592 :
|
