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 CStokesParameter.cpp
34 : */
35 : #include <sstream>
36 : #include <alma/Enumerations/CStokesParameter.h>
37 : #include <string>
38 : using namespace std;
39 :
40 0 : int CStokesParameter::version() {
41 0 : return StokesParameterMod::version;
42 : }
43 :
44 0 : string CStokesParameter::revision () {
45 0 : return StokesParameterMod::revision;
46 : }
47 :
48 0 : unsigned int CStokesParameter::size() {
49 0 : return 32;
50 : }
51 :
52 :
53 : const std::string& CStokesParameter::sI = "I";
54 :
55 : const std::string& CStokesParameter::sQ = "Q";
56 :
57 : const std::string& CStokesParameter::sU = "U";
58 :
59 : const std::string& CStokesParameter::sV = "V";
60 :
61 : const std::string& CStokesParameter::sRR = "RR";
62 :
63 : const std::string& CStokesParameter::sRL = "RL";
64 :
65 : const std::string& CStokesParameter::sLR = "LR";
66 :
67 : const std::string& CStokesParameter::sLL = "LL";
68 :
69 : const std::string& CStokesParameter::sXX = "XX";
70 :
71 : const std::string& CStokesParameter::sXY = "XY";
72 :
73 : const std::string& CStokesParameter::sYX = "YX";
74 :
75 : const std::string& CStokesParameter::sYY = "YY";
76 :
77 : const std::string& CStokesParameter::sRX = "RX";
78 :
79 : const std::string& CStokesParameter::sRY = "RY";
80 :
81 : const std::string& CStokesParameter::sLX = "LX";
82 :
83 : const std::string& CStokesParameter::sLY = "LY";
84 :
85 : const std::string& CStokesParameter::sXR = "XR";
86 :
87 : const std::string& CStokesParameter::sXL = "XL";
88 :
89 : const std::string& CStokesParameter::sYR = "YR";
90 :
91 : const std::string& CStokesParameter::sYL = "YL";
92 :
93 : const std::string& CStokesParameter::sPP = "PP";
94 :
95 : const std::string& CStokesParameter::sPQ = "PQ";
96 :
97 : const std::string& CStokesParameter::sQP = "QP";
98 :
99 : const std::string& CStokesParameter::sQQ = "QQ";
100 :
101 : const std::string& CStokesParameter::sRCIRCULAR = "RCIRCULAR";
102 :
103 : const std::string& CStokesParameter::sLCIRCULAR = "LCIRCULAR";
104 :
105 : const std::string& CStokesParameter::sLINEAR = "LINEAR";
106 :
107 : const std::string& CStokesParameter::sPTOTAL = "PTOTAL";
108 :
109 : const std::string& CStokesParameter::sPLINEAR = "PLINEAR";
110 :
111 : const std::string& CStokesParameter::sPFTOTAL = "PFTOTAL";
112 :
113 : const std::string& CStokesParameter::sPFLINEAR = "PFLINEAR";
114 :
115 : const std::string& CStokesParameter::sPANGLE = "PANGLE";
116 :
117 0 : const std::vector<std::string> CStokesParameter::names() {
118 0 : std::vector<std::string> enumSet;
119 :
120 0 : enumSet.insert(enumSet.end(), CStokesParameter::sI);
121 :
122 0 : enumSet.insert(enumSet.end(), CStokesParameter::sQ);
123 :
124 0 : enumSet.insert(enumSet.end(), CStokesParameter::sU);
125 :
126 0 : enumSet.insert(enumSet.end(), CStokesParameter::sV);
127 :
128 0 : enumSet.insert(enumSet.end(), CStokesParameter::sRR);
129 :
130 0 : enumSet.insert(enumSet.end(), CStokesParameter::sRL);
131 :
132 0 : enumSet.insert(enumSet.end(), CStokesParameter::sLR);
133 :
134 0 : enumSet.insert(enumSet.end(), CStokesParameter::sLL);
135 :
136 0 : enumSet.insert(enumSet.end(), CStokesParameter::sXX);
137 :
138 0 : enumSet.insert(enumSet.end(), CStokesParameter::sXY);
139 :
140 0 : enumSet.insert(enumSet.end(), CStokesParameter::sYX);
141 :
142 0 : enumSet.insert(enumSet.end(), CStokesParameter::sYY);
143 :
144 0 : enumSet.insert(enumSet.end(), CStokesParameter::sRX);
145 :
146 0 : enumSet.insert(enumSet.end(), CStokesParameter::sRY);
147 :
148 0 : enumSet.insert(enumSet.end(), CStokesParameter::sLX);
149 :
150 0 : enumSet.insert(enumSet.end(), CStokesParameter::sLY);
151 :
152 0 : enumSet.insert(enumSet.end(), CStokesParameter::sXR);
153 :
154 0 : enumSet.insert(enumSet.end(), CStokesParameter::sXL);
155 :
156 0 : enumSet.insert(enumSet.end(), CStokesParameter::sYR);
157 :
158 0 : enumSet.insert(enumSet.end(), CStokesParameter::sYL);
159 :
160 0 : enumSet.insert(enumSet.end(), CStokesParameter::sPP);
161 :
162 0 : enumSet.insert(enumSet.end(), CStokesParameter::sPQ);
163 :
164 0 : enumSet.insert(enumSet.end(), CStokesParameter::sQP);
165 :
166 0 : enumSet.insert(enumSet.end(), CStokesParameter::sQQ);
167 :
168 0 : enumSet.insert(enumSet.end(), CStokesParameter::sRCIRCULAR);
169 :
170 0 : enumSet.insert(enumSet.end(), CStokesParameter::sLCIRCULAR);
171 :
172 0 : enumSet.insert(enumSet.end(), CStokesParameter::sLINEAR);
173 :
174 0 : enumSet.insert(enumSet.end(), CStokesParameter::sPTOTAL);
175 :
176 0 : enumSet.insert(enumSet.end(), CStokesParameter::sPLINEAR);
177 :
178 0 : enumSet.insert(enumSet.end(), CStokesParameter::sPFTOTAL);
179 :
180 0 : enumSet.insert(enumSet.end(), CStokesParameter::sPFLINEAR);
181 :
182 0 : enumSet.insert(enumSet.end(), CStokesParameter::sPANGLE);
183 :
184 0 : return enumSet;
185 0 : }
186 :
187 1550 : std::string CStokesParameter::name(const StokesParameterMod::StokesParameter& f) {
188 1550 : switch (f) {
189 :
190 0 : case StokesParameterMod::I:
191 0 : return CStokesParameter::sI;
192 :
193 0 : case StokesParameterMod::Q:
194 0 : return CStokesParameter::sQ;
195 :
196 0 : case StokesParameterMod::U:
197 0 : return CStokesParameter::sU;
198 :
199 0 : case StokesParameterMod::V:
200 0 : return CStokesParameter::sV;
201 :
202 26 : case StokesParameterMod::RR:
203 26 : return CStokesParameter::sRR;
204 :
205 26 : case StokesParameterMod::RL:
206 26 : return CStokesParameter::sRL;
207 :
208 26 : case StokesParameterMod::LR:
209 26 : return CStokesParameter::sLR;
210 :
211 26 : case StokesParameterMod::LL:
212 26 : return CStokesParameter::sLL;
213 :
214 734 : case StokesParameterMod::XX:
215 734 : return CStokesParameter::sXX;
216 :
217 0 : case StokesParameterMod::XY:
218 0 : return CStokesParameter::sXY;
219 :
220 0 : case StokesParameterMod::YX:
221 0 : return CStokesParameter::sYX;
222 :
223 712 : case StokesParameterMod::YY:
224 712 : return CStokesParameter::sYY;
225 :
226 0 : case StokesParameterMod::RX:
227 0 : return CStokesParameter::sRX;
228 :
229 0 : case StokesParameterMod::RY:
230 0 : return CStokesParameter::sRY;
231 :
232 0 : case StokesParameterMod::LX:
233 0 : return CStokesParameter::sLX;
234 :
235 0 : case StokesParameterMod::LY:
236 0 : return CStokesParameter::sLY;
237 :
238 0 : case StokesParameterMod::XR:
239 0 : return CStokesParameter::sXR;
240 :
241 0 : case StokesParameterMod::XL:
242 0 : return CStokesParameter::sXL;
243 :
244 0 : case StokesParameterMod::YR:
245 0 : return CStokesParameter::sYR;
246 :
247 0 : case StokesParameterMod::YL:
248 0 : return CStokesParameter::sYL;
249 :
250 0 : case StokesParameterMod::PP:
251 0 : return CStokesParameter::sPP;
252 :
253 0 : case StokesParameterMod::PQ:
254 0 : return CStokesParameter::sPQ;
255 :
256 0 : case StokesParameterMod::QP:
257 0 : return CStokesParameter::sQP;
258 :
259 0 : case StokesParameterMod::QQ:
260 0 : return CStokesParameter::sQQ;
261 :
262 0 : case StokesParameterMod::RCIRCULAR:
263 0 : return CStokesParameter::sRCIRCULAR;
264 :
265 0 : case StokesParameterMod::LCIRCULAR:
266 0 : return CStokesParameter::sLCIRCULAR;
267 :
268 0 : case StokesParameterMod::LINEAR:
269 0 : return CStokesParameter::sLINEAR;
270 :
271 0 : case StokesParameterMod::PTOTAL:
272 0 : return CStokesParameter::sPTOTAL;
273 :
274 0 : case StokesParameterMod::PLINEAR:
275 0 : return CStokesParameter::sPLINEAR;
276 :
277 0 : case StokesParameterMod::PFTOTAL:
278 0 : return CStokesParameter::sPFTOTAL;
279 :
280 0 : case StokesParameterMod::PFLINEAR:
281 0 : return CStokesParameter::sPFLINEAR;
282 :
283 0 : case StokesParameterMod::PANGLE:
284 0 : return CStokesParameter::sPANGLE;
285 :
286 : }
287 : // Impossible siutation but....who knows with C++ enums
288 0 : throw badInt((int) f);
289 : }
290 :
291 13 : StokesParameterMod::StokesParameter CStokesParameter::newStokesParameter(const std::string& name) {
292 :
293 13 : if (name == CStokesParameter::sI) {
294 0 : return StokesParameterMod::I;
295 : }
296 :
297 13 : if (name == CStokesParameter::sQ) {
298 0 : return StokesParameterMod::Q;
299 : }
300 :
301 13 : if (name == CStokesParameter::sU) {
302 0 : return StokesParameterMod::U;
303 : }
304 :
305 13 : if (name == CStokesParameter::sV) {
306 0 : return StokesParameterMod::V;
307 : }
308 :
309 13 : if (name == CStokesParameter::sRR) {
310 2 : return StokesParameterMod::RR;
311 : }
312 :
313 11 : if (name == CStokesParameter::sRL) {
314 2 : return StokesParameterMod::RL;
315 : }
316 :
317 9 : if (name == CStokesParameter::sLR) {
318 1 : return StokesParameterMod::LR;
319 : }
320 :
321 8 : if (name == CStokesParameter::sLL) {
322 2 : return StokesParameterMod::LL;
323 : }
324 :
325 6 : if (name == CStokesParameter::sXX) {
326 4 : return StokesParameterMod::XX;
327 : }
328 :
329 2 : if (name == CStokesParameter::sXY) {
330 0 : return StokesParameterMod::XY;
331 : }
332 :
333 2 : if (name == CStokesParameter::sYX) {
334 0 : return StokesParameterMod::YX;
335 : }
336 :
337 2 : if (name == CStokesParameter::sYY) {
338 2 : return StokesParameterMod::YY;
339 : }
340 :
341 0 : if (name == CStokesParameter::sRX) {
342 0 : return StokesParameterMod::RX;
343 : }
344 :
345 0 : if (name == CStokesParameter::sRY) {
346 0 : return StokesParameterMod::RY;
347 : }
348 :
349 0 : if (name == CStokesParameter::sLX) {
350 0 : return StokesParameterMod::LX;
351 : }
352 :
353 0 : if (name == CStokesParameter::sLY) {
354 0 : return StokesParameterMod::LY;
355 : }
356 :
357 0 : if (name == CStokesParameter::sXR) {
358 0 : return StokesParameterMod::XR;
359 : }
360 :
361 0 : if (name == CStokesParameter::sXL) {
362 0 : return StokesParameterMod::XL;
363 : }
364 :
365 0 : if (name == CStokesParameter::sYR) {
366 0 : return StokesParameterMod::YR;
367 : }
368 :
369 0 : if (name == CStokesParameter::sYL) {
370 0 : return StokesParameterMod::YL;
371 : }
372 :
373 0 : if (name == CStokesParameter::sPP) {
374 0 : return StokesParameterMod::PP;
375 : }
376 :
377 0 : if (name == CStokesParameter::sPQ) {
378 0 : return StokesParameterMod::PQ;
379 : }
380 :
381 0 : if (name == CStokesParameter::sQP) {
382 0 : return StokesParameterMod::QP;
383 : }
384 :
385 0 : if (name == CStokesParameter::sQQ) {
386 0 : return StokesParameterMod::QQ;
387 : }
388 :
389 0 : if (name == CStokesParameter::sRCIRCULAR) {
390 0 : return StokesParameterMod::RCIRCULAR;
391 : }
392 :
393 0 : if (name == CStokesParameter::sLCIRCULAR) {
394 0 : return StokesParameterMod::LCIRCULAR;
395 : }
396 :
397 0 : if (name == CStokesParameter::sLINEAR) {
398 0 : return StokesParameterMod::LINEAR;
399 : }
400 :
401 0 : if (name == CStokesParameter::sPTOTAL) {
402 0 : return StokesParameterMod::PTOTAL;
403 : }
404 :
405 0 : if (name == CStokesParameter::sPLINEAR) {
406 0 : return StokesParameterMod::PLINEAR;
407 : }
408 :
409 0 : if (name == CStokesParameter::sPFTOTAL) {
410 0 : return StokesParameterMod::PFTOTAL;
411 : }
412 :
413 0 : if (name == CStokesParameter::sPFLINEAR) {
414 0 : return StokesParameterMod::PFLINEAR;
415 : }
416 :
417 0 : if (name == CStokesParameter::sPANGLE) {
418 0 : return StokesParameterMod::PANGLE;
419 : }
420 :
421 0 : throw badString(name);
422 : }
423 :
424 0 : StokesParameterMod::StokesParameter CStokesParameter::literal(const std::string& name) {
425 :
426 0 : if (name == CStokesParameter::sI) {
427 0 : return StokesParameterMod::I;
428 : }
429 :
430 0 : if (name == CStokesParameter::sQ) {
431 0 : return StokesParameterMod::Q;
432 : }
433 :
434 0 : if (name == CStokesParameter::sU) {
435 0 : return StokesParameterMod::U;
436 : }
437 :
438 0 : if (name == CStokesParameter::sV) {
439 0 : return StokesParameterMod::V;
440 : }
441 :
442 0 : if (name == CStokesParameter::sRR) {
443 0 : return StokesParameterMod::RR;
444 : }
445 :
446 0 : if (name == CStokesParameter::sRL) {
447 0 : return StokesParameterMod::RL;
448 : }
449 :
450 0 : if (name == CStokesParameter::sLR) {
451 0 : return StokesParameterMod::LR;
452 : }
453 :
454 0 : if (name == CStokesParameter::sLL) {
455 0 : return StokesParameterMod::LL;
456 : }
457 :
458 0 : if (name == CStokesParameter::sXX) {
459 0 : return StokesParameterMod::XX;
460 : }
461 :
462 0 : if (name == CStokesParameter::sXY) {
463 0 : return StokesParameterMod::XY;
464 : }
465 :
466 0 : if (name == CStokesParameter::sYX) {
467 0 : return StokesParameterMod::YX;
468 : }
469 :
470 0 : if (name == CStokesParameter::sYY) {
471 0 : return StokesParameterMod::YY;
472 : }
473 :
474 0 : if (name == CStokesParameter::sRX) {
475 0 : return StokesParameterMod::RX;
476 : }
477 :
478 0 : if (name == CStokesParameter::sRY) {
479 0 : return StokesParameterMod::RY;
480 : }
481 :
482 0 : if (name == CStokesParameter::sLX) {
483 0 : return StokesParameterMod::LX;
484 : }
485 :
486 0 : if (name == CStokesParameter::sLY) {
487 0 : return StokesParameterMod::LY;
488 : }
489 :
490 0 : if (name == CStokesParameter::sXR) {
491 0 : return StokesParameterMod::XR;
492 : }
493 :
494 0 : if (name == CStokesParameter::sXL) {
495 0 : return StokesParameterMod::XL;
496 : }
497 :
498 0 : if (name == CStokesParameter::sYR) {
499 0 : return StokesParameterMod::YR;
500 : }
501 :
502 0 : if (name == CStokesParameter::sYL) {
503 0 : return StokesParameterMod::YL;
504 : }
505 :
506 0 : if (name == CStokesParameter::sPP) {
507 0 : return StokesParameterMod::PP;
508 : }
509 :
510 0 : if (name == CStokesParameter::sPQ) {
511 0 : return StokesParameterMod::PQ;
512 : }
513 :
514 0 : if (name == CStokesParameter::sQP) {
515 0 : return StokesParameterMod::QP;
516 : }
517 :
518 0 : if (name == CStokesParameter::sQQ) {
519 0 : return StokesParameterMod::QQ;
520 : }
521 :
522 0 : if (name == CStokesParameter::sRCIRCULAR) {
523 0 : return StokesParameterMod::RCIRCULAR;
524 : }
525 :
526 0 : if (name == CStokesParameter::sLCIRCULAR) {
527 0 : return StokesParameterMod::LCIRCULAR;
528 : }
529 :
530 0 : if (name == CStokesParameter::sLINEAR) {
531 0 : return StokesParameterMod::LINEAR;
532 : }
533 :
534 0 : if (name == CStokesParameter::sPTOTAL) {
535 0 : return StokesParameterMod::PTOTAL;
536 : }
537 :
538 0 : if (name == CStokesParameter::sPLINEAR) {
539 0 : return StokesParameterMod::PLINEAR;
540 : }
541 :
542 0 : if (name == CStokesParameter::sPFTOTAL) {
543 0 : return StokesParameterMod::PFTOTAL;
544 : }
545 :
546 0 : if (name == CStokesParameter::sPFLINEAR) {
547 0 : return StokesParameterMod::PFLINEAR;
548 : }
549 :
550 0 : if (name == CStokesParameter::sPANGLE) {
551 0 : return StokesParameterMod::PANGLE;
552 : }
553 :
554 0 : throw badString(name);
555 : }
556 :
557 0 : StokesParameterMod::StokesParameter CStokesParameter::from_int(unsigned int i) {
558 0 : vector<string> names_ = names();
559 0 : if (i >= names_.size()) throw badInt(i);
560 0 : return newStokesParameter(names_.at(i));
561 0 : }
562 :
563 0 : string CStokesParameter::badString(const string& name) {
564 0 : return "'"+name+"' does not correspond to any literal in the enumeration 'StokesParameter'.";
565 : }
566 :
567 0 : string CStokesParameter::badInt(unsigned int i) {
568 0 : ostringstream oss ;
569 0 : oss << "'" << i << "' is out of range for the enumeration 'StokesParameter'.";
570 0 : return oss.str();
571 0 : }
572 :
573 : namespace StokesParameterMod {
574 0 : std::ostream & operator << ( std::ostream & out, const StokesParameter& value) {
575 0 : out << CStokesParameter::name(value);
576 0 : return out;
577 : }
578 :
579 0 : std::istream & operator >> ( std::istream & in , StokesParameter& value ) {
580 0 : in.clear();
581 0 : string s ;
582 0 : in >> s;
583 : try {
584 0 : value = CStokesParameter::literal(s);
585 : }
586 0 : catch (string & m) {
587 0 : in.setstate(ios::failbit);
588 0 : }
589 0 : return in;
590 0 : }
591 : }
592 :
|
