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 : * Warning!
26 : * --------------------------------------------------------------------
27 : * | This is generated code! Do not modify this file. |
28 : * | If you do, all changes will be lost when the file is re-generated. |
29 : * --------------------------------------------------------------------
30 : *
31 : * File SourceRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/SourceRow.h>
39 : #include <alma/ASDM/SourceTable.h>
40 :
41 : #include <alma/ASDM/SpectralWindowTable.h>
42 : #include <alma/ASDM/SpectralWindowRow.h>
43 :
44 :
45 : using asdm::ASDM;
46 : using asdm::SourceRow;
47 : using asdm::SourceTable;
48 :
49 : using asdm::SpectralWindowTable;
50 : using asdm::SpectralWindowRow;
51 :
52 :
53 : #include <alma/ASDM/Parser.h>
54 :
55 : #include <alma/ASDM/EnumerationParser.h>
56 : #include <alma/ASDM/ASDMValuesParser.h>
57 :
58 : #include <alma/ASDM/InvalidArgumentException.h>
59 :
60 : using namespace std;
61 :
62 : namespace asdm {
63 17728 : SourceRow::~SourceRow() {
64 17728 : }
65 :
66 : /**
67 : * Return the table to which this row belongs.
68 : */
69 0 : SourceTable &SourceRow::getTable() const {
70 0 : return table;
71 : }
72 :
73 0 : bool SourceRow::isAdded() const {
74 0 : return hasBeenAdded;
75 : }
76 :
77 8864 : void SourceRow::isAdded(bool added) {
78 8864 : hasBeenAdded = added;
79 8864 : }
80 :
81 : #ifndef WITHOUT_ACS
82 : using asdmIDL::SourceRowIDL;
83 : #endif
84 :
85 : #ifndef WITHOUT_ACS
86 : /**
87 : * Return this row in the form of an IDL struct.
88 : * @return The values of this row as a SourceRowIDL struct.
89 : */
90 : SourceRowIDL *SourceRow::toIDL() const {
91 : SourceRowIDL *x = new SourceRowIDL ();
92 :
93 : // Fill the IDL structure.
94 :
95 :
96 :
97 :
98 :
99 :
100 :
101 :
102 : x->sourceId = sourceId;
103 :
104 :
105 :
106 :
107 :
108 :
109 :
110 :
111 :
112 :
113 : x->timeInterval = timeInterval.toIDLArrayTimeInterval();
114 :
115 :
116 :
117 :
118 :
119 :
120 :
121 :
122 :
123 :
124 : x->code = CORBA::string_dup(code.c_str());
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 :
135 : x->direction.length(direction.size());
136 : for (unsigned int i = 0; i < direction.size(); ++i) {
137 :
138 : x->direction[i] = direction.at(i).toIDLAngle();
139 :
140 : }
141 :
142 :
143 :
144 :
145 :
146 :
147 :
148 :
149 :
150 : x->properMotion.length(properMotion.size());
151 : for (unsigned int i = 0; i < properMotion.size(); ++i) {
152 :
153 : x->properMotion[i] = properMotion.at(i).toIDLAngularRate();
154 :
155 : }
156 :
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 :
165 :
166 : x->sourceName = CORBA::string_dup(sourceName.c_str());
167 :
168 :
169 :
170 :
171 :
172 :
173 :
174 :
175 : x->directionCodeExists = directionCodeExists;
176 :
177 :
178 :
179 :
180 : x->directionCode = directionCode;
181 :
182 :
183 :
184 :
185 :
186 :
187 :
188 :
189 : x->directionEquinoxExists = directionEquinoxExists;
190 :
191 :
192 :
193 : x->directionEquinox = directionEquinox.toIDLArrayTime();
194 :
195 :
196 :
197 :
198 :
199 :
200 :
201 : x->calibrationGroupExists = calibrationGroupExists;
202 :
203 :
204 :
205 :
206 : x->calibrationGroup = calibrationGroup;
207 :
208 :
209 :
210 :
211 :
212 :
213 :
214 :
215 : x->catalogExists = catalogExists;
216 :
217 :
218 :
219 :
220 : x->catalog = CORBA::string_dup(catalog.c_str());
221 :
222 :
223 :
224 :
225 :
226 :
227 :
228 :
229 : x->deltaVelExists = deltaVelExists;
230 :
231 :
232 :
233 : x->deltaVel = deltaVel.toIDLSpeed();
234 :
235 :
236 :
237 :
238 :
239 :
240 :
241 : x->positionExists = positionExists;
242 :
243 :
244 :
245 : x->position.length(position.size());
246 : for (unsigned int i = 0; i < position.size(); ++i) {
247 :
248 : x->position[i] = position.at(i).toIDLLength();
249 :
250 : }
251 :
252 :
253 :
254 :
255 :
256 :
257 :
258 : x->numLinesExists = numLinesExists;
259 :
260 :
261 :
262 :
263 : x->numLines = numLines;
264 :
265 :
266 :
267 :
268 :
269 :
270 :
271 :
272 : x->transitionExists = transitionExists;
273 :
274 :
275 :
276 : x->transition.length(transition.size());
277 : for (unsigned int i = 0; i < transition.size(); ++i) {
278 :
279 :
280 : x->transition[i] = CORBA::string_dup(transition.at(i).c_str());
281 :
282 :
283 : }
284 :
285 :
286 :
287 :
288 :
289 :
290 :
291 : x->restFrequencyExists = restFrequencyExists;
292 :
293 :
294 :
295 : x->restFrequency.length(restFrequency.size());
296 : for (unsigned int i = 0; i < restFrequency.size(); ++i) {
297 :
298 : x->restFrequency[i] = restFrequency.at(i).toIDLFrequency();
299 :
300 : }
301 :
302 :
303 :
304 :
305 :
306 :
307 :
308 : x->sysVelExists = sysVelExists;
309 :
310 :
311 :
312 : x->sysVel.length(sysVel.size());
313 : for (unsigned int i = 0; i < sysVel.size(); ++i) {
314 :
315 : x->sysVel[i] = sysVel.at(i).toIDLSpeed();
316 :
317 : }
318 :
319 :
320 :
321 :
322 :
323 :
324 :
325 : x->rangeVelExists = rangeVelExists;
326 :
327 :
328 :
329 : x->rangeVel.length(rangeVel.size());
330 : for (unsigned int i = 0; i < rangeVel.size(); ++i) {
331 :
332 : x->rangeVel[i] = rangeVel.at(i).toIDLSpeed();
333 :
334 : }
335 :
336 :
337 :
338 :
339 :
340 :
341 :
342 : x->sourceModelExists = sourceModelExists;
343 :
344 :
345 :
346 :
347 : x->sourceModel = sourceModel;
348 :
349 :
350 :
351 :
352 :
353 :
354 :
355 :
356 : x->frequencyRefCodeExists = frequencyRefCodeExists;
357 :
358 :
359 :
360 :
361 : x->frequencyRefCode = frequencyRefCode;
362 :
363 :
364 :
365 :
366 :
367 :
368 :
369 :
370 : x->numFreqExists = numFreqExists;
371 :
372 :
373 :
374 :
375 : x->numFreq = numFreq;
376 :
377 :
378 :
379 :
380 :
381 :
382 :
383 :
384 : x->numStokesExists = numStokesExists;
385 :
386 :
387 :
388 :
389 : x->numStokes = numStokes;
390 :
391 :
392 :
393 :
394 :
395 :
396 :
397 :
398 : x->frequencyExists = frequencyExists;
399 :
400 :
401 :
402 : x->frequency.length(frequency.size());
403 : for (unsigned int i = 0; i < frequency.size(); ++i) {
404 :
405 : x->frequency[i] = frequency.at(i).toIDLFrequency();
406 :
407 : }
408 :
409 :
410 :
411 :
412 :
413 :
414 :
415 : x->frequencyIntervalExists = frequencyIntervalExists;
416 :
417 :
418 :
419 : x->frequencyInterval.length(frequencyInterval.size());
420 : for (unsigned int i = 0; i < frequencyInterval.size(); ++i) {
421 :
422 : x->frequencyInterval[i] = frequencyInterval.at(i).toIDLFrequency();
423 :
424 : }
425 :
426 :
427 :
428 :
429 :
430 :
431 :
432 : x->stokesParameterExists = stokesParameterExists;
433 :
434 :
435 :
436 : x->stokesParameter.length(stokesParameter.size());
437 : for (unsigned int i = 0; i < stokesParameter.size(); ++i) {
438 :
439 :
440 : x->stokesParameter[i] = stokesParameter.at(i);
441 :
442 :
443 : }
444 :
445 :
446 :
447 :
448 :
449 :
450 :
451 : x->fluxExists = fluxExists;
452 :
453 :
454 :
455 : x->flux.length(flux.size());
456 : for (unsigned int i = 0; i < flux.size(); i++) {
457 : x->flux[i].length(flux.at(i).size());
458 : }
459 :
460 : for (unsigned int i = 0; i < flux.size() ; i++)
461 : for (unsigned int j = 0; j < flux.at(i).size(); j++)
462 :
463 : x->flux[i][j]= flux.at(i).at(j).toIDLFlux();
464 :
465 :
466 :
467 :
468 :
469 :
470 :
471 :
472 :
473 : x->fluxErrExists = fluxErrExists;
474 :
475 :
476 :
477 : x->fluxErr.length(fluxErr.size());
478 : for (unsigned int i = 0; i < fluxErr.size(); i++) {
479 : x->fluxErr[i].length(fluxErr.at(i).size());
480 : }
481 :
482 : for (unsigned int i = 0; i < fluxErr.size() ; i++)
483 : for (unsigned int j = 0; j < fluxErr.at(i).size(); j++)
484 :
485 : x->fluxErr[i][j]= fluxErr.at(i).at(j).toIDLFlux();
486 :
487 :
488 :
489 :
490 :
491 :
492 :
493 :
494 :
495 : x->positionAngleExists = positionAngleExists;
496 :
497 :
498 :
499 : x->positionAngle.length(positionAngle.size());
500 : for (unsigned int i = 0; i < positionAngle.size(); ++i) {
501 :
502 : x->positionAngle[i] = positionAngle.at(i).toIDLAngle();
503 :
504 : }
505 :
506 :
507 :
508 :
509 :
510 :
511 :
512 : x->positionAngleErrExists = positionAngleErrExists;
513 :
514 :
515 :
516 : x->positionAngleErr.length(positionAngleErr.size());
517 : for (unsigned int i = 0; i < positionAngleErr.size(); ++i) {
518 :
519 : x->positionAngleErr[i] = positionAngleErr.at(i).toIDLAngle();
520 :
521 : }
522 :
523 :
524 :
525 :
526 :
527 :
528 :
529 : x->sizeExists = sizeExists;
530 :
531 :
532 :
533 : x->size.length(size.size());
534 : for (unsigned int i = 0; i < size.size(); i++) {
535 : x->size[i].length(size.at(i).size());
536 : }
537 :
538 : for (unsigned int i = 0; i < size.size() ; i++)
539 : for (unsigned int j = 0; j < size.at(i).size(); j++)
540 :
541 : x->size[i][j]= size.at(i).at(j).toIDLAngle();
542 :
543 :
544 :
545 :
546 :
547 :
548 :
549 :
550 :
551 : x->sizeErrExists = sizeErrExists;
552 :
553 :
554 :
555 : x->sizeErr.length(sizeErr.size());
556 : for (unsigned int i = 0; i < sizeErr.size(); i++) {
557 : x->sizeErr[i].length(sizeErr.at(i).size());
558 : }
559 :
560 : for (unsigned int i = 0; i < sizeErr.size() ; i++)
561 : for (unsigned int j = 0; j < sizeErr.at(i).size(); j++)
562 :
563 : x->sizeErr[i][j]= sizeErr.at(i).at(j).toIDLAngle();
564 :
565 :
566 :
567 :
568 :
569 :
570 :
571 :
572 :
573 : x->velRefCodeExists = velRefCodeExists;
574 :
575 :
576 :
577 :
578 : x->velRefCode = velRefCode;
579 :
580 :
581 :
582 :
583 :
584 :
585 :
586 :
587 : x->dopplerVelocityExists = dopplerVelocityExists;
588 :
589 :
590 :
591 : x->dopplerVelocity.length(dopplerVelocity.size());
592 : for (unsigned int i = 0; i < dopplerVelocity.size(); ++i) {
593 :
594 : x->dopplerVelocity[i] = dopplerVelocity.at(i).toIDLSpeed();
595 :
596 : }
597 :
598 :
599 :
600 :
601 :
602 :
603 :
604 : x->dopplerReferenceSystemExists = dopplerReferenceSystemExists;
605 :
606 :
607 :
608 :
609 : x->dopplerReferenceSystem = dopplerReferenceSystem;
610 :
611 :
612 :
613 :
614 :
615 :
616 :
617 :
618 : x->dopplerCalcTypeExists = dopplerCalcTypeExists;
619 :
620 :
621 :
622 :
623 : x->dopplerCalcType = dopplerCalcType;
624 :
625 :
626 :
627 :
628 :
629 :
630 :
631 :
632 : x->parallaxExists = parallaxExists;
633 :
634 :
635 :
636 : x->parallax.length(parallax.size());
637 : for (unsigned int i = 0; i < parallax.size(); ++i) {
638 :
639 : x->parallax[i] = parallax.at(i).toIDLAngle();
640 :
641 : }
642 :
643 :
644 :
645 :
646 :
647 :
648 :
649 :
650 :
651 :
652 :
653 :
654 :
655 : x->spectralWindowId = spectralWindowId.toIDLTag();
656 :
657 :
658 :
659 :
660 :
661 :
662 :
663 :
664 :
665 : return x;
666 :
667 : }
668 :
669 : void SourceRow::toIDL(asdmIDL::SourceRowIDL& x) const {
670 : // Set the x's fields.
671 :
672 :
673 :
674 :
675 :
676 :
677 :
678 :
679 : x.sourceId = sourceId;
680 :
681 :
682 :
683 :
684 :
685 :
686 :
687 :
688 :
689 :
690 : x.timeInterval = timeInterval.toIDLArrayTimeInterval();
691 :
692 :
693 :
694 :
695 :
696 :
697 :
698 :
699 :
700 :
701 : x.code = CORBA::string_dup(code.c_str());
702 :
703 :
704 :
705 :
706 :
707 :
708 :
709 :
710 :
711 :
712 : x.direction.length(direction.size());
713 : for (unsigned int i = 0; i < direction.size(); ++i) {
714 :
715 : x.direction[i] = direction.at(i).toIDLAngle();
716 :
717 : }
718 :
719 :
720 :
721 :
722 :
723 :
724 :
725 :
726 :
727 : x.properMotion.length(properMotion.size());
728 : for (unsigned int i = 0; i < properMotion.size(); ++i) {
729 :
730 : x.properMotion[i] = properMotion.at(i).toIDLAngularRate();
731 :
732 : }
733 :
734 :
735 :
736 :
737 :
738 :
739 :
740 :
741 :
742 :
743 : x.sourceName = CORBA::string_dup(sourceName.c_str());
744 :
745 :
746 :
747 :
748 :
749 :
750 :
751 :
752 : x.directionCodeExists = directionCodeExists;
753 :
754 :
755 :
756 :
757 : x.directionCode = directionCode;
758 :
759 :
760 :
761 :
762 :
763 :
764 :
765 :
766 : x.directionEquinoxExists = directionEquinoxExists;
767 :
768 :
769 :
770 : x.directionEquinox = directionEquinox.toIDLArrayTime();
771 :
772 :
773 :
774 :
775 :
776 :
777 :
778 : x.calibrationGroupExists = calibrationGroupExists;
779 :
780 :
781 :
782 :
783 : x.calibrationGroup = calibrationGroup;
784 :
785 :
786 :
787 :
788 :
789 :
790 :
791 :
792 : x.catalogExists = catalogExists;
793 :
794 :
795 :
796 :
797 : x.catalog = CORBA::string_dup(catalog.c_str());
798 :
799 :
800 :
801 :
802 :
803 :
804 :
805 :
806 : x.deltaVelExists = deltaVelExists;
807 :
808 :
809 :
810 : x.deltaVel = deltaVel.toIDLSpeed();
811 :
812 :
813 :
814 :
815 :
816 :
817 :
818 : x.positionExists = positionExists;
819 :
820 :
821 :
822 : x.position.length(position.size());
823 : for (unsigned int i = 0; i < position.size(); ++i) {
824 :
825 : x.position[i] = position.at(i).toIDLLength();
826 :
827 : }
828 :
829 :
830 :
831 :
832 :
833 :
834 :
835 : x.numLinesExists = numLinesExists;
836 :
837 :
838 :
839 :
840 : x.numLines = numLines;
841 :
842 :
843 :
844 :
845 :
846 :
847 :
848 :
849 : x.transitionExists = transitionExists;
850 :
851 :
852 :
853 : x.transition.length(transition.size());
854 : for (unsigned int i = 0; i < transition.size(); ++i) {
855 :
856 :
857 : x.transition[i] = CORBA::string_dup(transition.at(i).c_str());
858 :
859 :
860 : }
861 :
862 :
863 :
864 :
865 :
866 :
867 :
868 : x.restFrequencyExists = restFrequencyExists;
869 :
870 :
871 :
872 : x.restFrequency.length(restFrequency.size());
873 : for (unsigned int i = 0; i < restFrequency.size(); ++i) {
874 :
875 : x.restFrequency[i] = restFrequency.at(i).toIDLFrequency();
876 :
877 : }
878 :
879 :
880 :
881 :
882 :
883 :
884 :
885 : x.sysVelExists = sysVelExists;
886 :
887 :
888 :
889 : x.sysVel.length(sysVel.size());
890 : for (unsigned int i = 0; i < sysVel.size(); ++i) {
891 :
892 : x.sysVel[i] = sysVel.at(i).toIDLSpeed();
893 :
894 : }
895 :
896 :
897 :
898 :
899 :
900 :
901 :
902 : x.rangeVelExists = rangeVelExists;
903 :
904 :
905 :
906 : x.rangeVel.length(rangeVel.size());
907 : for (unsigned int i = 0; i < rangeVel.size(); ++i) {
908 :
909 : x.rangeVel[i] = rangeVel.at(i).toIDLSpeed();
910 :
911 : }
912 :
913 :
914 :
915 :
916 :
917 :
918 :
919 : x.sourceModelExists = sourceModelExists;
920 :
921 :
922 :
923 :
924 : x.sourceModel = sourceModel;
925 :
926 :
927 :
928 :
929 :
930 :
931 :
932 :
933 : x.frequencyRefCodeExists = frequencyRefCodeExists;
934 :
935 :
936 :
937 :
938 : x.frequencyRefCode = frequencyRefCode;
939 :
940 :
941 :
942 :
943 :
944 :
945 :
946 :
947 : x.numFreqExists = numFreqExists;
948 :
949 :
950 :
951 :
952 : x.numFreq = numFreq;
953 :
954 :
955 :
956 :
957 :
958 :
959 :
960 :
961 : x.numStokesExists = numStokesExists;
962 :
963 :
964 :
965 :
966 : x.numStokes = numStokes;
967 :
968 :
969 :
970 :
971 :
972 :
973 :
974 :
975 : x.frequencyExists = frequencyExists;
976 :
977 :
978 :
979 : x.frequency.length(frequency.size());
980 : for (unsigned int i = 0; i < frequency.size(); ++i) {
981 :
982 : x.frequency[i] = frequency.at(i).toIDLFrequency();
983 :
984 : }
985 :
986 :
987 :
988 :
989 :
990 :
991 :
992 : x.frequencyIntervalExists = frequencyIntervalExists;
993 :
994 :
995 :
996 : x.frequencyInterval.length(frequencyInterval.size());
997 : for (unsigned int i = 0; i < frequencyInterval.size(); ++i) {
998 :
999 : x.frequencyInterval[i] = frequencyInterval.at(i).toIDLFrequency();
1000 :
1001 : }
1002 :
1003 :
1004 :
1005 :
1006 :
1007 :
1008 :
1009 : x.stokesParameterExists = stokesParameterExists;
1010 :
1011 :
1012 :
1013 : x.stokesParameter.length(stokesParameter.size());
1014 : for (unsigned int i = 0; i < stokesParameter.size(); ++i) {
1015 :
1016 :
1017 : x.stokesParameter[i] = stokesParameter.at(i);
1018 :
1019 :
1020 : }
1021 :
1022 :
1023 :
1024 :
1025 :
1026 :
1027 :
1028 : x.fluxExists = fluxExists;
1029 :
1030 :
1031 :
1032 : x.flux.length(flux.size());
1033 : for (unsigned int i = 0; i < flux.size(); i++) {
1034 : x.flux[i].length(flux.at(i).size());
1035 : }
1036 :
1037 : for (unsigned int i = 0; i < flux.size() ; i++)
1038 : for (unsigned int j = 0; j < flux.at(i).size(); j++)
1039 :
1040 : x.flux[i][j]= flux.at(i).at(j).toIDLFlux();
1041 :
1042 :
1043 :
1044 :
1045 :
1046 :
1047 :
1048 :
1049 :
1050 : x.fluxErrExists = fluxErrExists;
1051 :
1052 :
1053 :
1054 : x.fluxErr.length(fluxErr.size());
1055 : for (unsigned int i = 0; i < fluxErr.size(); i++) {
1056 : x.fluxErr[i].length(fluxErr.at(i).size());
1057 : }
1058 :
1059 : for (unsigned int i = 0; i < fluxErr.size() ; i++)
1060 : for (unsigned int j = 0; j < fluxErr.at(i).size(); j++)
1061 :
1062 : x.fluxErr[i][j]= fluxErr.at(i).at(j).toIDLFlux();
1063 :
1064 :
1065 :
1066 :
1067 :
1068 :
1069 :
1070 :
1071 :
1072 : x.positionAngleExists = positionAngleExists;
1073 :
1074 :
1075 :
1076 : x.positionAngle.length(positionAngle.size());
1077 : for (unsigned int i = 0; i < positionAngle.size(); ++i) {
1078 :
1079 : x.positionAngle[i] = positionAngle.at(i).toIDLAngle();
1080 :
1081 : }
1082 :
1083 :
1084 :
1085 :
1086 :
1087 :
1088 :
1089 : x.positionAngleErrExists = positionAngleErrExists;
1090 :
1091 :
1092 :
1093 : x.positionAngleErr.length(positionAngleErr.size());
1094 : for (unsigned int i = 0; i < positionAngleErr.size(); ++i) {
1095 :
1096 : x.positionAngleErr[i] = positionAngleErr.at(i).toIDLAngle();
1097 :
1098 : }
1099 :
1100 :
1101 :
1102 :
1103 :
1104 :
1105 :
1106 : x.sizeExists = sizeExists;
1107 :
1108 :
1109 :
1110 : x.size.length(size.size());
1111 : for (unsigned int i = 0; i < size.size(); i++) {
1112 : x.size[i].length(size.at(i).size());
1113 : }
1114 :
1115 : for (unsigned int i = 0; i < size.size() ; i++)
1116 : for (unsigned int j = 0; j < size.at(i).size(); j++)
1117 :
1118 : x.size[i][j]= size.at(i).at(j).toIDLAngle();
1119 :
1120 :
1121 :
1122 :
1123 :
1124 :
1125 :
1126 :
1127 :
1128 : x.sizeErrExists = sizeErrExists;
1129 :
1130 :
1131 :
1132 : x.sizeErr.length(sizeErr.size());
1133 : for (unsigned int i = 0; i < sizeErr.size(); i++) {
1134 : x.sizeErr[i].length(sizeErr.at(i).size());
1135 : }
1136 :
1137 : for (unsigned int i = 0; i < sizeErr.size() ; i++)
1138 : for (unsigned int j = 0; j < sizeErr.at(i).size(); j++)
1139 :
1140 : x.sizeErr[i][j]= sizeErr.at(i).at(j).toIDLAngle();
1141 :
1142 :
1143 :
1144 :
1145 :
1146 :
1147 :
1148 :
1149 :
1150 : x.velRefCodeExists = velRefCodeExists;
1151 :
1152 :
1153 :
1154 :
1155 : x.velRefCode = velRefCode;
1156 :
1157 :
1158 :
1159 :
1160 :
1161 :
1162 :
1163 :
1164 : x.dopplerVelocityExists = dopplerVelocityExists;
1165 :
1166 :
1167 :
1168 : x.dopplerVelocity.length(dopplerVelocity.size());
1169 : for (unsigned int i = 0; i < dopplerVelocity.size(); ++i) {
1170 :
1171 : x.dopplerVelocity[i] = dopplerVelocity.at(i).toIDLSpeed();
1172 :
1173 : }
1174 :
1175 :
1176 :
1177 :
1178 :
1179 :
1180 :
1181 : x.dopplerReferenceSystemExists = dopplerReferenceSystemExists;
1182 :
1183 :
1184 :
1185 :
1186 : x.dopplerReferenceSystem = dopplerReferenceSystem;
1187 :
1188 :
1189 :
1190 :
1191 :
1192 :
1193 :
1194 :
1195 : x.dopplerCalcTypeExists = dopplerCalcTypeExists;
1196 :
1197 :
1198 :
1199 :
1200 : x.dopplerCalcType = dopplerCalcType;
1201 :
1202 :
1203 :
1204 :
1205 :
1206 :
1207 :
1208 :
1209 : x.parallaxExists = parallaxExists;
1210 :
1211 :
1212 :
1213 : x.parallax.length(parallax.size());
1214 : for (unsigned int i = 0; i < parallax.size(); ++i) {
1215 :
1216 : x.parallax[i] = parallax.at(i).toIDLAngle();
1217 :
1218 : }
1219 :
1220 :
1221 :
1222 :
1223 :
1224 :
1225 :
1226 :
1227 :
1228 :
1229 :
1230 :
1231 :
1232 : x.spectralWindowId = spectralWindowId.toIDLTag();
1233 :
1234 :
1235 :
1236 :
1237 :
1238 :
1239 :
1240 :
1241 :
1242 : }
1243 : #endif
1244 :
1245 :
1246 : #ifndef WITHOUT_ACS
1247 : /**
1248 : * Fill the values of this row from the IDL struct SourceRowIDL.
1249 : * @param x The IDL struct containing the values used to fill this row.
1250 : */
1251 : void SourceRow::setFromIDL (SourceRowIDL x){
1252 : try {
1253 : // Fill the values from x.
1254 :
1255 :
1256 :
1257 :
1258 :
1259 :
1260 : setSourceId(x.sourceId);
1261 :
1262 :
1263 :
1264 :
1265 :
1266 :
1267 :
1268 :
1269 :
1270 : setTimeInterval(ArrayTimeInterval (x.timeInterval));
1271 :
1272 :
1273 :
1274 :
1275 :
1276 :
1277 :
1278 :
1279 :
1280 : setCode(string (x.code));
1281 :
1282 :
1283 :
1284 :
1285 :
1286 :
1287 :
1288 :
1289 :
1290 : direction .clear();
1291 : for (unsigned int i = 0; i <x.direction.length(); ++i) {
1292 :
1293 : direction.push_back(Angle (x.direction[i]));
1294 :
1295 : }
1296 :
1297 :
1298 :
1299 :
1300 :
1301 :
1302 :
1303 :
1304 :
1305 : properMotion .clear();
1306 : for (unsigned int i = 0; i <x.properMotion.length(); ++i) {
1307 :
1308 : properMotion.push_back(AngularRate (x.properMotion[i]));
1309 :
1310 : }
1311 :
1312 :
1313 :
1314 :
1315 :
1316 :
1317 :
1318 :
1319 :
1320 : setSourceName(string (x.sourceName));
1321 :
1322 :
1323 :
1324 :
1325 :
1326 :
1327 :
1328 : directionCodeExists = x.directionCodeExists;
1329 : if (x.directionCodeExists) {
1330 :
1331 :
1332 :
1333 : setDirectionCode(x.directionCode);
1334 :
1335 :
1336 :
1337 : }
1338 :
1339 :
1340 :
1341 :
1342 :
1343 : directionEquinoxExists = x.directionEquinoxExists;
1344 : if (x.directionEquinoxExists) {
1345 :
1346 :
1347 :
1348 : setDirectionEquinox(ArrayTime (x.directionEquinox));
1349 :
1350 :
1351 :
1352 : }
1353 :
1354 :
1355 :
1356 :
1357 :
1358 : calibrationGroupExists = x.calibrationGroupExists;
1359 : if (x.calibrationGroupExists) {
1360 :
1361 :
1362 :
1363 : setCalibrationGroup(x.calibrationGroup);
1364 :
1365 :
1366 :
1367 : }
1368 :
1369 :
1370 :
1371 :
1372 :
1373 : catalogExists = x.catalogExists;
1374 : if (x.catalogExists) {
1375 :
1376 :
1377 :
1378 : setCatalog(string (x.catalog));
1379 :
1380 :
1381 :
1382 : }
1383 :
1384 :
1385 :
1386 :
1387 :
1388 : deltaVelExists = x.deltaVelExists;
1389 : if (x.deltaVelExists) {
1390 :
1391 :
1392 :
1393 : setDeltaVel(Speed (x.deltaVel));
1394 :
1395 :
1396 :
1397 : }
1398 :
1399 :
1400 :
1401 :
1402 :
1403 : positionExists = x.positionExists;
1404 : if (x.positionExists) {
1405 :
1406 :
1407 :
1408 : position .clear();
1409 : for (unsigned int i = 0; i <x.position.length(); ++i) {
1410 :
1411 : position.push_back(Length (x.position[i]));
1412 :
1413 : }
1414 :
1415 :
1416 :
1417 : }
1418 :
1419 :
1420 :
1421 :
1422 :
1423 : numLinesExists = x.numLinesExists;
1424 : if (x.numLinesExists) {
1425 :
1426 :
1427 :
1428 : setNumLines(x.numLines);
1429 :
1430 :
1431 :
1432 : }
1433 :
1434 :
1435 :
1436 :
1437 :
1438 : transitionExists = x.transitionExists;
1439 : if (x.transitionExists) {
1440 :
1441 :
1442 :
1443 : transition .clear();
1444 : for (unsigned int i = 0; i <x.transition.length(); ++i) {
1445 :
1446 : transition.push_back(string (x.transition[i]));
1447 :
1448 : }
1449 :
1450 :
1451 :
1452 : }
1453 :
1454 :
1455 :
1456 :
1457 :
1458 : restFrequencyExists = x.restFrequencyExists;
1459 : if (x.restFrequencyExists) {
1460 :
1461 :
1462 :
1463 : restFrequency .clear();
1464 : for (unsigned int i = 0; i <x.restFrequency.length(); ++i) {
1465 :
1466 : restFrequency.push_back(Frequency (x.restFrequency[i]));
1467 :
1468 : }
1469 :
1470 :
1471 :
1472 : }
1473 :
1474 :
1475 :
1476 :
1477 :
1478 : sysVelExists = x.sysVelExists;
1479 : if (x.sysVelExists) {
1480 :
1481 :
1482 :
1483 : sysVel .clear();
1484 : for (unsigned int i = 0; i <x.sysVel.length(); ++i) {
1485 :
1486 : sysVel.push_back(Speed (x.sysVel[i]));
1487 :
1488 : }
1489 :
1490 :
1491 :
1492 : }
1493 :
1494 :
1495 :
1496 :
1497 :
1498 : rangeVelExists = x.rangeVelExists;
1499 : if (x.rangeVelExists) {
1500 :
1501 :
1502 :
1503 : rangeVel .clear();
1504 : for (unsigned int i = 0; i <x.rangeVel.length(); ++i) {
1505 :
1506 : rangeVel.push_back(Speed (x.rangeVel[i]));
1507 :
1508 : }
1509 :
1510 :
1511 :
1512 : }
1513 :
1514 :
1515 :
1516 :
1517 :
1518 : sourceModelExists = x.sourceModelExists;
1519 : if (x.sourceModelExists) {
1520 :
1521 :
1522 :
1523 : setSourceModel(x.sourceModel);
1524 :
1525 :
1526 :
1527 : }
1528 :
1529 :
1530 :
1531 :
1532 :
1533 : frequencyRefCodeExists = x.frequencyRefCodeExists;
1534 : if (x.frequencyRefCodeExists) {
1535 :
1536 :
1537 :
1538 : setFrequencyRefCode(x.frequencyRefCode);
1539 :
1540 :
1541 :
1542 : }
1543 :
1544 :
1545 :
1546 :
1547 :
1548 : numFreqExists = x.numFreqExists;
1549 : if (x.numFreqExists) {
1550 :
1551 :
1552 :
1553 : setNumFreq(x.numFreq);
1554 :
1555 :
1556 :
1557 : }
1558 :
1559 :
1560 :
1561 :
1562 :
1563 : numStokesExists = x.numStokesExists;
1564 : if (x.numStokesExists) {
1565 :
1566 :
1567 :
1568 : setNumStokes(x.numStokes);
1569 :
1570 :
1571 :
1572 : }
1573 :
1574 :
1575 :
1576 :
1577 :
1578 : frequencyExists = x.frequencyExists;
1579 : if (x.frequencyExists) {
1580 :
1581 :
1582 :
1583 : frequency .clear();
1584 : for (unsigned int i = 0; i <x.frequency.length(); ++i) {
1585 :
1586 : frequency.push_back(Frequency (x.frequency[i]));
1587 :
1588 : }
1589 :
1590 :
1591 :
1592 : }
1593 :
1594 :
1595 :
1596 :
1597 :
1598 : frequencyIntervalExists = x.frequencyIntervalExists;
1599 : if (x.frequencyIntervalExists) {
1600 :
1601 :
1602 :
1603 : frequencyInterval .clear();
1604 : for (unsigned int i = 0; i <x.frequencyInterval.length(); ++i) {
1605 :
1606 : frequencyInterval.push_back(Frequency (x.frequencyInterval[i]));
1607 :
1608 : }
1609 :
1610 :
1611 :
1612 : }
1613 :
1614 :
1615 :
1616 :
1617 :
1618 : stokesParameterExists = x.stokesParameterExists;
1619 : if (x.stokesParameterExists) {
1620 :
1621 :
1622 :
1623 : stokesParameter .clear();
1624 : for (unsigned int i = 0; i <x.stokesParameter.length(); ++i) {
1625 :
1626 : stokesParameter.push_back(x.stokesParameter[i]);
1627 :
1628 : }
1629 :
1630 :
1631 :
1632 : }
1633 :
1634 :
1635 :
1636 :
1637 :
1638 : fluxExists = x.fluxExists;
1639 : if (x.fluxExists) {
1640 :
1641 :
1642 :
1643 : flux .clear();
1644 :
1645 : vector<Flux> v_aux_flux;
1646 :
1647 : for (unsigned int i = 0; i < x.flux.length(); ++i) {
1648 : v_aux_flux.clear();
1649 : for (unsigned int j = 0; j < x.flux[0].length(); ++j) {
1650 :
1651 : v_aux_flux.push_back(Flux (x.flux[i][j]));
1652 :
1653 : }
1654 : flux.push_back(v_aux_flux);
1655 : }
1656 :
1657 :
1658 :
1659 : }
1660 :
1661 :
1662 :
1663 :
1664 :
1665 : fluxErrExists = x.fluxErrExists;
1666 : if (x.fluxErrExists) {
1667 :
1668 :
1669 :
1670 : fluxErr .clear();
1671 :
1672 : vector<Flux> v_aux_fluxErr;
1673 :
1674 : for (unsigned int i = 0; i < x.fluxErr.length(); ++i) {
1675 : v_aux_fluxErr.clear();
1676 : for (unsigned int j = 0; j < x.fluxErr[0].length(); ++j) {
1677 :
1678 : v_aux_fluxErr.push_back(Flux (x.fluxErr[i][j]));
1679 :
1680 : }
1681 : fluxErr.push_back(v_aux_fluxErr);
1682 : }
1683 :
1684 :
1685 :
1686 : }
1687 :
1688 :
1689 :
1690 :
1691 :
1692 : positionAngleExists = x.positionAngleExists;
1693 : if (x.positionAngleExists) {
1694 :
1695 :
1696 :
1697 : positionAngle .clear();
1698 : for (unsigned int i = 0; i <x.positionAngle.length(); ++i) {
1699 :
1700 : positionAngle.push_back(Angle (x.positionAngle[i]));
1701 :
1702 : }
1703 :
1704 :
1705 :
1706 : }
1707 :
1708 :
1709 :
1710 :
1711 :
1712 : positionAngleErrExists = x.positionAngleErrExists;
1713 : if (x.positionAngleErrExists) {
1714 :
1715 :
1716 :
1717 : positionAngleErr .clear();
1718 : for (unsigned int i = 0; i <x.positionAngleErr.length(); ++i) {
1719 :
1720 : positionAngleErr.push_back(Angle (x.positionAngleErr[i]));
1721 :
1722 : }
1723 :
1724 :
1725 :
1726 : }
1727 :
1728 :
1729 :
1730 :
1731 :
1732 : sizeExists = x.sizeExists;
1733 : if (x.sizeExists) {
1734 :
1735 :
1736 :
1737 : size .clear();
1738 :
1739 : vector<Angle> v_aux_size;
1740 :
1741 : for (unsigned int i = 0; i < x.size.length(); ++i) {
1742 : v_aux_size.clear();
1743 : for (unsigned int j = 0; j < x.size[0].length(); ++j) {
1744 :
1745 : v_aux_size.push_back(Angle (x.size[i][j]));
1746 :
1747 : }
1748 : size.push_back(v_aux_size);
1749 : }
1750 :
1751 :
1752 :
1753 : }
1754 :
1755 :
1756 :
1757 :
1758 :
1759 : sizeErrExists = x.sizeErrExists;
1760 : if (x.sizeErrExists) {
1761 :
1762 :
1763 :
1764 : sizeErr .clear();
1765 :
1766 : vector<Angle> v_aux_sizeErr;
1767 :
1768 : for (unsigned int i = 0; i < x.sizeErr.length(); ++i) {
1769 : v_aux_sizeErr.clear();
1770 : for (unsigned int j = 0; j < x.sizeErr[0].length(); ++j) {
1771 :
1772 : v_aux_sizeErr.push_back(Angle (x.sizeErr[i][j]));
1773 :
1774 : }
1775 : sizeErr.push_back(v_aux_sizeErr);
1776 : }
1777 :
1778 :
1779 :
1780 : }
1781 :
1782 :
1783 :
1784 :
1785 :
1786 : velRefCodeExists = x.velRefCodeExists;
1787 : if (x.velRefCodeExists) {
1788 :
1789 :
1790 :
1791 : setVelRefCode(x.velRefCode);
1792 :
1793 :
1794 :
1795 : }
1796 :
1797 :
1798 :
1799 :
1800 :
1801 : dopplerVelocityExists = x.dopplerVelocityExists;
1802 : if (x.dopplerVelocityExists) {
1803 :
1804 :
1805 :
1806 : dopplerVelocity .clear();
1807 : for (unsigned int i = 0; i <x.dopplerVelocity.length(); ++i) {
1808 :
1809 : dopplerVelocity.push_back(Speed (x.dopplerVelocity[i]));
1810 :
1811 : }
1812 :
1813 :
1814 :
1815 : }
1816 :
1817 :
1818 :
1819 :
1820 :
1821 : dopplerReferenceSystemExists = x.dopplerReferenceSystemExists;
1822 : if (x.dopplerReferenceSystemExists) {
1823 :
1824 :
1825 :
1826 : setDopplerReferenceSystem(x.dopplerReferenceSystem);
1827 :
1828 :
1829 :
1830 : }
1831 :
1832 :
1833 :
1834 :
1835 :
1836 : dopplerCalcTypeExists = x.dopplerCalcTypeExists;
1837 : if (x.dopplerCalcTypeExists) {
1838 :
1839 :
1840 :
1841 : setDopplerCalcType(x.dopplerCalcType);
1842 :
1843 :
1844 :
1845 : }
1846 :
1847 :
1848 :
1849 :
1850 :
1851 : parallaxExists = x.parallaxExists;
1852 : if (x.parallaxExists) {
1853 :
1854 :
1855 :
1856 : parallax .clear();
1857 : for (unsigned int i = 0; i <x.parallax.length(); ++i) {
1858 :
1859 : parallax.push_back(Angle (x.parallax[i]));
1860 :
1861 : }
1862 :
1863 :
1864 :
1865 : }
1866 :
1867 :
1868 :
1869 :
1870 :
1871 :
1872 :
1873 :
1874 :
1875 :
1876 : setSpectralWindowId(Tag (x.spectralWindowId));
1877 :
1878 :
1879 :
1880 :
1881 :
1882 :
1883 :
1884 :
1885 :
1886 : } catch (const IllegalAccessException &err) {
1887 : throw ConversionException (err.getMessage(),"Source");
1888 : }
1889 : }
1890 : #endif
1891 :
1892 : /**
1893 : * Return this row in the form of an XML string.
1894 : * @return The values of this row as an XML string.
1895 : */
1896 499 : string SourceRow::toXML() const {
1897 499 : string buf;
1898 499 : buf.append("<row> \n");
1899 :
1900 :
1901 :
1902 :
1903 :
1904 :
1905 499 : Parser::toXML(sourceId, "sourceId", buf);
1906 :
1907 :
1908 :
1909 :
1910 :
1911 :
1912 :
1913 499 : Parser::toXML(timeInterval, "timeInterval", buf);
1914 :
1915 :
1916 :
1917 :
1918 :
1919 :
1920 :
1921 499 : Parser::toXML(code, "code", buf);
1922 :
1923 :
1924 :
1925 :
1926 :
1927 :
1928 :
1929 499 : Parser::toXML(direction, "direction", buf);
1930 :
1931 :
1932 :
1933 :
1934 :
1935 :
1936 :
1937 499 : Parser::toXML(properMotion, "properMotion", buf);
1938 :
1939 :
1940 :
1941 :
1942 :
1943 :
1944 :
1945 499 : Parser::toXML(sourceName, "sourceName", buf);
1946 :
1947 :
1948 :
1949 :
1950 :
1951 :
1952 499 : if (directionCodeExists) {
1953 :
1954 :
1955 499 : buf.append(EnumerationParser::toXML("directionCode", directionCode));
1956 :
1957 :
1958 : }
1959 :
1960 :
1961 :
1962 :
1963 :
1964 499 : if (directionEquinoxExists) {
1965 :
1966 :
1967 0 : Parser::toXML(directionEquinox, "directionEquinox", buf);
1968 :
1969 :
1970 : }
1971 :
1972 :
1973 :
1974 :
1975 :
1976 499 : if (calibrationGroupExists) {
1977 :
1978 :
1979 0 : Parser::toXML(calibrationGroup, "calibrationGroup", buf);
1980 :
1981 :
1982 : }
1983 :
1984 :
1985 :
1986 :
1987 :
1988 499 : if (catalogExists) {
1989 :
1990 :
1991 0 : Parser::toXML(catalog, "catalog", buf);
1992 :
1993 :
1994 : }
1995 :
1996 :
1997 :
1998 :
1999 :
2000 499 : if (deltaVelExists) {
2001 :
2002 :
2003 0 : Parser::toXML(deltaVel, "deltaVel", buf);
2004 :
2005 :
2006 : }
2007 :
2008 :
2009 :
2010 :
2011 :
2012 499 : if (positionExists) {
2013 :
2014 :
2015 0 : Parser::toXML(position, "position", buf);
2016 :
2017 :
2018 : }
2019 :
2020 :
2021 :
2022 :
2023 :
2024 499 : if (numLinesExists) {
2025 :
2026 :
2027 0 : Parser::toXML(numLines, "numLines", buf);
2028 :
2029 :
2030 : }
2031 :
2032 :
2033 :
2034 :
2035 :
2036 499 : if (transitionExists) {
2037 :
2038 :
2039 0 : Parser::toXML(transition, "transition", buf);
2040 :
2041 :
2042 : }
2043 :
2044 :
2045 :
2046 :
2047 :
2048 499 : if (restFrequencyExists) {
2049 :
2050 :
2051 0 : Parser::toXML(restFrequency, "restFrequency", buf);
2052 :
2053 :
2054 : }
2055 :
2056 :
2057 :
2058 :
2059 :
2060 499 : if (sysVelExists) {
2061 :
2062 :
2063 0 : Parser::toXML(sysVel, "sysVel", buf);
2064 :
2065 :
2066 : }
2067 :
2068 :
2069 :
2070 :
2071 :
2072 499 : if (rangeVelExists) {
2073 :
2074 :
2075 0 : Parser::toXML(rangeVel, "rangeVel", buf);
2076 :
2077 :
2078 : }
2079 :
2080 :
2081 :
2082 :
2083 :
2084 499 : if (sourceModelExists) {
2085 :
2086 :
2087 0 : buf.append(EnumerationParser::toXML("sourceModel", sourceModel));
2088 :
2089 :
2090 : }
2091 :
2092 :
2093 :
2094 :
2095 :
2096 499 : if (frequencyRefCodeExists) {
2097 :
2098 :
2099 0 : buf.append(EnumerationParser::toXML("frequencyRefCode", frequencyRefCode));
2100 :
2101 :
2102 : }
2103 :
2104 :
2105 :
2106 :
2107 :
2108 499 : if (numFreqExists) {
2109 :
2110 :
2111 0 : Parser::toXML(numFreq, "numFreq", buf);
2112 :
2113 :
2114 : }
2115 :
2116 :
2117 :
2118 :
2119 :
2120 499 : if (numStokesExists) {
2121 :
2122 :
2123 0 : Parser::toXML(numStokes, "numStokes", buf);
2124 :
2125 :
2126 : }
2127 :
2128 :
2129 :
2130 :
2131 :
2132 499 : if (frequencyExists) {
2133 :
2134 :
2135 0 : Parser::toXML(frequency, "frequency", buf);
2136 :
2137 :
2138 : }
2139 :
2140 :
2141 :
2142 :
2143 :
2144 499 : if (frequencyIntervalExists) {
2145 :
2146 :
2147 0 : Parser::toXML(frequencyInterval, "frequencyInterval", buf);
2148 :
2149 :
2150 : }
2151 :
2152 :
2153 :
2154 :
2155 :
2156 499 : if (stokesParameterExists) {
2157 :
2158 :
2159 0 : buf.append(EnumerationParser::toXML("stokesParameter", stokesParameter));
2160 :
2161 :
2162 : }
2163 :
2164 :
2165 :
2166 :
2167 :
2168 499 : if (fluxExists) {
2169 :
2170 :
2171 0 : Parser::toXML(flux, "flux", buf);
2172 :
2173 :
2174 : }
2175 :
2176 :
2177 :
2178 :
2179 :
2180 499 : if (fluxErrExists) {
2181 :
2182 :
2183 0 : Parser::toXML(fluxErr, "fluxErr", buf);
2184 :
2185 :
2186 : }
2187 :
2188 :
2189 :
2190 :
2191 :
2192 499 : if (positionAngleExists) {
2193 :
2194 :
2195 0 : Parser::toXML(positionAngle, "positionAngle", buf);
2196 :
2197 :
2198 : }
2199 :
2200 :
2201 :
2202 :
2203 :
2204 499 : if (positionAngleErrExists) {
2205 :
2206 :
2207 0 : Parser::toXML(positionAngleErr, "positionAngleErr", buf);
2208 :
2209 :
2210 : }
2211 :
2212 :
2213 :
2214 :
2215 :
2216 499 : if (sizeExists) {
2217 :
2218 :
2219 0 : Parser::toXML(size, "size", buf);
2220 :
2221 :
2222 : }
2223 :
2224 :
2225 :
2226 :
2227 :
2228 499 : if (sizeErrExists) {
2229 :
2230 :
2231 0 : Parser::toXML(sizeErr, "sizeErr", buf);
2232 :
2233 :
2234 : }
2235 :
2236 :
2237 :
2238 :
2239 :
2240 499 : if (velRefCodeExists) {
2241 :
2242 :
2243 0 : buf.append(EnumerationParser::toXML("velRefCode", velRefCode));
2244 :
2245 :
2246 : }
2247 :
2248 :
2249 :
2250 :
2251 :
2252 499 : if (dopplerVelocityExists) {
2253 :
2254 :
2255 0 : Parser::toXML(dopplerVelocity, "dopplerVelocity", buf);
2256 :
2257 :
2258 : }
2259 :
2260 :
2261 :
2262 :
2263 :
2264 499 : if (dopplerReferenceSystemExists) {
2265 :
2266 :
2267 0 : buf.append(EnumerationParser::toXML("dopplerReferenceSystem", dopplerReferenceSystem));
2268 :
2269 :
2270 : }
2271 :
2272 :
2273 :
2274 :
2275 :
2276 499 : if (dopplerCalcTypeExists) {
2277 :
2278 :
2279 0 : buf.append(EnumerationParser::toXML("dopplerCalcType", dopplerCalcType));
2280 :
2281 :
2282 : }
2283 :
2284 :
2285 :
2286 :
2287 :
2288 499 : if (parallaxExists) {
2289 :
2290 :
2291 0 : Parser::toXML(parallax, "parallax", buf);
2292 :
2293 :
2294 : }
2295 :
2296 :
2297 :
2298 :
2299 :
2300 :
2301 :
2302 :
2303 :
2304 499 : Parser::toXML(spectralWindowId, "spectralWindowId", buf);
2305 :
2306 :
2307 :
2308 :
2309 :
2310 :
2311 :
2312 :
2313 :
2314 499 : buf.append("</row>\n");
2315 499 : return buf;
2316 : }
2317 :
2318 : /**
2319 : * Fill the values of this row from an XML string
2320 : * that was produced by the toXML() method.
2321 : * @param x The XML string being used to set the values of this row.
2322 : */
2323 8221 : void SourceRow::setFromXML (string rowDoc) {
2324 16442 : Parser row(rowDoc);
2325 8221 : string s = "";
2326 : try {
2327 :
2328 :
2329 :
2330 :
2331 :
2332 8221 : setSourceId(Parser::getInteger("sourceId","Source",rowDoc));
2333 :
2334 :
2335 :
2336 :
2337 :
2338 :
2339 :
2340 8221 : setTimeInterval(Parser::getArrayTimeInterval("timeInterval","Source",rowDoc));
2341 :
2342 :
2343 :
2344 :
2345 :
2346 :
2347 :
2348 8221 : setCode(Parser::getString("code","Source",rowDoc));
2349 :
2350 :
2351 :
2352 :
2353 :
2354 :
2355 :
2356 :
2357 8221 : setDirection(Parser::get1DAngle("direction","Source",rowDoc));
2358 :
2359 :
2360 :
2361 :
2362 :
2363 :
2364 :
2365 :
2366 :
2367 8221 : setProperMotion(Parser::get1DAngularRate("properMotion","Source",rowDoc));
2368 :
2369 :
2370 :
2371 :
2372 :
2373 :
2374 :
2375 :
2376 8221 : setSourceName(Parser::getString("sourceName","Source",rowDoc));
2377 :
2378 :
2379 :
2380 :
2381 :
2382 :
2383 8221 : if (row.isStr("<directionCode>")) {
2384 :
2385 :
2386 :
2387 7797 : directionCode = EnumerationParser::getDirectionReferenceCode("directionCode","Source",rowDoc);
2388 :
2389 :
2390 :
2391 7797 : directionCodeExists = true;
2392 : }
2393 :
2394 :
2395 :
2396 :
2397 :
2398 8221 : if (row.isStr("<directionEquinox>")) {
2399 :
2400 0 : setDirectionEquinox(Parser::getArrayTime("directionEquinox","Source",rowDoc));
2401 :
2402 : }
2403 :
2404 :
2405 :
2406 :
2407 :
2408 8221 : if (row.isStr("<calibrationGroup>")) {
2409 :
2410 0 : setCalibrationGroup(Parser::getInteger("calibrationGroup","Source",rowDoc));
2411 :
2412 : }
2413 :
2414 :
2415 :
2416 :
2417 :
2418 8221 : if (row.isStr("<catalog>")) {
2419 :
2420 0 : setCatalog(Parser::getString("catalog","Source",rowDoc));
2421 :
2422 : }
2423 :
2424 :
2425 :
2426 :
2427 :
2428 8221 : if (row.isStr("<deltaVel>")) {
2429 :
2430 0 : setDeltaVel(Parser::getSpeed("deltaVel","Source",rowDoc));
2431 :
2432 : }
2433 :
2434 :
2435 :
2436 :
2437 :
2438 8221 : if (row.isStr("<position>")) {
2439 :
2440 :
2441 0 : setPosition(Parser::get1DLength("position","Source",rowDoc));
2442 :
2443 :
2444 : }
2445 :
2446 :
2447 :
2448 :
2449 :
2450 8221 : if (row.isStr("<numLines>")) {
2451 :
2452 1632 : setNumLines(Parser::getInteger("numLines","Source",rowDoc));
2453 :
2454 : }
2455 :
2456 :
2457 :
2458 :
2459 :
2460 8221 : if (row.isStr("<transition>")) {
2461 :
2462 :
2463 1208 : setTransition(Parser::get1DString("transition","Source",rowDoc));
2464 :
2465 :
2466 : }
2467 :
2468 :
2469 :
2470 :
2471 :
2472 8221 : if (row.isStr("<restFrequency>")) {
2473 :
2474 :
2475 1632 : setRestFrequency(Parser::get1DFrequency("restFrequency","Source",rowDoc));
2476 :
2477 :
2478 : }
2479 :
2480 :
2481 :
2482 :
2483 :
2484 8221 : if (row.isStr("<sysVel>")) {
2485 :
2486 :
2487 1632 : setSysVel(Parser::get1DSpeed("sysVel","Source",rowDoc));
2488 :
2489 :
2490 : }
2491 :
2492 :
2493 :
2494 :
2495 :
2496 8221 : if (row.isStr("<rangeVel>")) {
2497 :
2498 :
2499 0 : setRangeVel(Parser::get1DSpeed("rangeVel","Source",rowDoc));
2500 :
2501 :
2502 : }
2503 :
2504 :
2505 :
2506 :
2507 :
2508 8221 : if (row.isStr("<sourceModel>")) {
2509 :
2510 :
2511 :
2512 0 : sourceModel = EnumerationParser::getSourceModel("sourceModel","Source",rowDoc);
2513 :
2514 :
2515 :
2516 0 : sourceModelExists = true;
2517 : }
2518 :
2519 :
2520 :
2521 :
2522 :
2523 8221 : if (row.isStr("<frequencyRefCode>")) {
2524 :
2525 :
2526 :
2527 0 : frequencyRefCode = EnumerationParser::getFrequencyReferenceCode("frequencyRefCode","Source",rowDoc);
2528 :
2529 :
2530 :
2531 0 : frequencyRefCodeExists = true;
2532 : }
2533 :
2534 :
2535 :
2536 :
2537 :
2538 8221 : if (row.isStr("<numFreq>")) {
2539 :
2540 2963 : setNumFreq(Parser::getInteger("numFreq","Source",rowDoc));
2541 :
2542 : }
2543 :
2544 :
2545 :
2546 :
2547 :
2548 8221 : if (row.isStr("<numStokes>")) {
2549 :
2550 2963 : setNumStokes(Parser::getInteger("numStokes","Source",rowDoc));
2551 :
2552 : }
2553 :
2554 :
2555 :
2556 :
2557 :
2558 8221 : if (row.isStr("<frequency>")) {
2559 :
2560 :
2561 2963 : setFrequency(Parser::get1DFrequency("frequency","Source",rowDoc));
2562 :
2563 :
2564 : }
2565 :
2566 :
2567 :
2568 :
2569 :
2570 8221 : if (row.isStr("<frequencyInterval>")) {
2571 :
2572 :
2573 0 : setFrequencyInterval(Parser::get1DFrequency("frequencyInterval","Source",rowDoc));
2574 :
2575 :
2576 : }
2577 :
2578 :
2579 :
2580 :
2581 :
2582 8221 : if (row.isStr("<stokesParameter>")) {
2583 :
2584 :
2585 :
2586 2963 : stokesParameter = EnumerationParser::getStokesParameter1D("stokesParameter","Source",rowDoc);
2587 :
2588 :
2589 :
2590 2963 : stokesParameterExists = true;
2591 : }
2592 :
2593 :
2594 :
2595 :
2596 :
2597 8221 : if (row.isStr("<flux>")) {
2598 :
2599 :
2600 2963 : setFlux(Parser::get2DFlux("flux","Source",rowDoc));
2601 :
2602 :
2603 : }
2604 :
2605 :
2606 :
2607 :
2608 :
2609 8221 : if (row.isStr("<fluxErr>")) {
2610 :
2611 :
2612 0 : setFluxErr(Parser::get2DFlux("fluxErr","Source",rowDoc));
2613 :
2614 :
2615 : }
2616 :
2617 :
2618 :
2619 :
2620 :
2621 8221 : if (row.isStr("<positionAngle>")) {
2622 :
2623 :
2624 0 : setPositionAngle(Parser::get1DAngle("positionAngle","Source",rowDoc));
2625 :
2626 :
2627 : }
2628 :
2629 :
2630 :
2631 :
2632 :
2633 8221 : if (row.isStr("<positionAngleErr>")) {
2634 :
2635 :
2636 0 : setPositionAngleErr(Parser::get1DAngle("positionAngleErr","Source",rowDoc));
2637 :
2638 :
2639 : }
2640 :
2641 :
2642 :
2643 :
2644 :
2645 8221 : if (row.isStr("<size>")) {
2646 :
2647 :
2648 2963 : setSize(Parser::get2DAngle("size","Source",rowDoc));
2649 :
2650 :
2651 : }
2652 :
2653 :
2654 :
2655 :
2656 :
2657 8221 : if (row.isStr("<sizeErr>")) {
2658 :
2659 :
2660 0 : setSizeErr(Parser::get2DAngle("sizeErr","Source",rowDoc));
2661 :
2662 :
2663 : }
2664 :
2665 :
2666 :
2667 :
2668 :
2669 8221 : if (row.isStr("<velRefCode>")) {
2670 :
2671 :
2672 :
2673 1208 : velRefCode = EnumerationParser::getRadialVelocityReferenceCode("velRefCode","Source",rowDoc);
2674 :
2675 :
2676 :
2677 1208 : velRefCodeExists = true;
2678 : }
2679 :
2680 :
2681 :
2682 :
2683 :
2684 8221 : if (row.isStr("<dopplerVelocity>")) {
2685 :
2686 :
2687 0 : setDopplerVelocity(Parser::get1DSpeed("dopplerVelocity","Source",rowDoc));
2688 :
2689 :
2690 : }
2691 :
2692 :
2693 :
2694 :
2695 :
2696 8221 : if (row.isStr("<dopplerReferenceSystem>")) {
2697 :
2698 :
2699 :
2700 0 : dopplerReferenceSystem = EnumerationParser::getRadialVelocityReferenceCode("dopplerReferenceSystem","Source",rowDoc);
2701 :
2702 :
2703 :
2704 0 : dopplerReferenceSystemExists = true;
2705 : }
2706 :
2707 :
2708 :
2709 :
2710 :
2711 8221 : if (row.isStr("<dopplerCalcType>")) {
2712 :
2713 :
2714 :
2715 0 : dopplerCalcType = EnumerationParser::getDopplerReferenceCode("dopplerCalcType","Source",rowDoc);
2716 :
2717 :
2718 :
2719 0 : dopplerCalcTypeExists = true;
2720 : }
2721 :
2722 :
2723 :
2724 :
2725 :
2726 8221 : if (row.isStr("<parallax>")) {
2727 :
2728 :
2729 0 : setParallax(Parser::get1DAngle("parallax","Source",rowDoc));
2730 :
2731 :
2732 : }
2733 :
2734 :
2735 :
2736 :
2737 :
2738 :
2739 :
2740 :
2741 :
2742 8221 : setSpectralWindowId(Parser::getTag("spectralWindowId","SpectralWindow",rowDoc));
2743 :
2744 :
2745 :
2746 :
2747 :
2748 :
2749 :
2750 :
2751 0 : } catch (const IllegalAccessException &err) {
2752 0 : throw ConversionException (err.getMessage(),"Source");
2753 : }
2754 8221 : }
2755 :
2756 0 : void SourceRow::toBin(EndianOSStream& eoss) {
2757 :
2758 :
2759 :
2760 :
2761 :
2762 :
2763 0 : eoss.writeInt(sourceId);
2764 :
2765 :
2766 :
2767 :
2768 :
2769 :
2770 :
2771 0 : timeInterval.toBin(eoss);
2772 :
2773 :
2774 :
2775 :
2776 :
2777 :
2778 0 : spectralWindowId.toBin(eoss);
2779 :
2780 :
2781 :
2782 :
2783 :
2784 :
2785 :
2786 0 : eoss.writeString(code);
2787 :
2788 :
2789 :
2790 :
2791 :
2792 :
2793 :
2794 0 : Angle::toBin(direction, eoss);
2795 :
2796 :
2797 :
2798 :
2799 :
2800 :
2801 0 : AngularRate::toBin(properMotion, eoss);
2802 :
2803 :
2804 :
2805 :
2806 :
2807 :
2808 :
2809 0 : eoss.writeString(sourceName);
2810 :
2811 :
2812 :
2813 :
2814 :
2815 :
2816 :
2817 0 : eoss.writeBoolean(directionCodeExists);
2818 0 : if (directionCodeExists) {
2819 :
2820 :
2821 :
2822 :
2823 :
2824 0 : eoss.writeString(CDirectionReferenceCode::name(directionCode));
2825 : /* eoss.writeInt(directionCode); */
2826 :
2827 :
2828 :
2829 :
2830 : }
2831 :
2832 0 : eoss.writeBoolean(directionEquinoxExists);
2833 0 : if (directionEquinoxExists) {
2834 :
2835 :
2836 :
2837 :
2838 0 : directionEquinox.toBin(eoss);
2839 :
2840 :
2841 :
2842 : }
2843 :
2844 0 : eoss.writeBoolean(calibrationGroupExists);
2845 0 : if (calibrationGroupExists) {
2846 :
2847 :
2848 :
2849 :
2850 :
2851 0 : eoss.writeInt(calibrationGroup);
2852 :
2853 :
2854 :
2855 :
2856 : }
2857 :
2858 0 : eoss.writeBoolean(catalogExists);
2859 0 : if (catalogExists) {
2860 :
2861 :
2862 :
2863 :
2864 :
2865 0 : eoss.writeString(catalog);
2866 :
2867 :
2868 :
2869 :
2870 : }
2871 :
2872 0 : eoss.writeBoolean(deltaVelExists);
2873 0 : if (deltaVelExists) {
2874 :
2875 :
2876 :
2877 :
2878 0 : deltaVel.toBin(eoss);
2879 :
2880 :
2881 :
2882 : }
2883 :
2884 0 : eoss.writeBoolean(positionExists);
2885 0 : if (positionExists) {
2886 :
2887 :
2888 :
2889 :
2890 0 : Length::toBin(position, eoss);
2891 :
2892 :
2893 :
2894 : }
2895 :
2896 0 : eoss.writeBoolean(numLinesExists);
2897 0 : if (numLinesExists) {
2898 :
2899 :
2900 :
2901 :
2902 :
2903 0 : eoss.writeInt(numLines);
2904 :
2905 :
2906 :
2907 :
2908 : }
2909 :
2910 0 : eoss.writeBoolean(transitionExists);
2911 0 : if (transitionExists) {
2912 :
2913 :
2914 :
2915 :
2916 :
2917 :
2918 0 : eoss.writeInt((int) transition.size());
2919 0 : for (unsigned int i = 0; i < transition.size(); i++)
2920 :
2921 0 : eoss.writeString(transition.at(i));
2922 :
2923 :
2924 :
2925 :
2926 :
2927 :
2928 : }
2929 :
2930 0 : eoss.writeBoolean(restFrequencyExists);
2931 0 : if (restFrequencyExists) {
2932 :
2933 :
2934 :
2935 :
2936 0 : Frequency::toBin(restFrequency, eoss);
2937 :
2938 :
2939 :
2940 : }
2941 :
2942 0 : eoss.writeBoolean(sysVelExists);
2943 0 : if (sysVelExists) {
2944 :
2945 :
2946 :
2947 :
2948 0 : Speed::toBin(sysVel, eoss);
2949 :
2950 :
2951 :
2952 : }
2953 :
2954 0 : eoss.writeBoolean(rangeVelExists);
2955 0 : if (rangeVelExists) {
2956 :
2957 :
2958 :
2959 :
2960 0 : Speed::toBin(rangeVel, eoss);
2961 :
2962 :
2963 :
2964 : }
2965 :
2966 0 : eoss.writeBoolean(sourceModelExists);
2967 0 : if (sourceModelExists) {
2968 :
2969 :
2970 :
2971 :
2972 :
2973 0 : eoss.writeString(CSourceModel::name(sourceModel));
2974 : /* eoss.writeInt(sourceModel); */
2975 :
2976 :
2977 :
2978 :
2979 : }
2980 :
2981 0 : eoss.writeBoolean(frequencyRefCodeExists);
2982 0 : if (frequencyRefCodeExists) {
2983 :
2984 :
2985 :
2986 :
2987 :
2988 0 : eoss.writeString(CFrequencyReferenceCode::name(frequencyRefCode));
2989 : /* eoss.writeInt(frequencyRefCode); */
2990 :
2991 :
2992 :
2993 :
2994 : }
2995 :
2996 0 : eoss.writeBoolean(numFreqExists);
2997 0 : if (numFreqExists) {
2998 :
2999 :
3000 :
3001 :
3002 :
3003 0 : eoss.writeInt(numFreq);
3004 :
3005 :
3006 :
3007 :
3008 : }
3009 :
3010 0 : eoss.writeBoolean(numStokesExists);
3011 0 : if (numStokesExists) {
3012 :
3013 :
3014 :
3015 :
3016 :
3017 0 : eoss.writeInt(numStokes);
3018 :
3019 :
3020 :
3021 :
3022 : }
3023 :
3024 0 : eoss.writeBoolean(frequencyExists);
3025 0 : if (frequencyExists) {
3026 :
3027 :
3028 :
3029 :
3030 0 : Frequency::toBin(frequency, eoss);
3031 :
3032 :
3033 :
3034 : }
3035 :
3036 0 : eoss.writeBoolean(frequencyIntervalExists);
3037 0 : if (frequencyIntervalExists) {
3038 :
3039 :
3040 :
3041 :
3042 0 : Frequency::toBin(frequencyInterval, eoss);
3043 :
3044 :
3045 :
3046 : }
3047 :
3048 0 : eoss.writeBoolean(stokesParameterExists);
3049 0 : if (stokesParameterExists) {
3050 :
3051 :
3052 :
3053 :
3054 :
3055 :
3056 0 : eoss.writeInt((int) stokesParameter.size());
3057 0 : for (unsigned int i = 0; i < stokesParameter.size(); i++)
3058 :
3059 0 : eoss.writeString(CStokesParameter::name(stokesParameter.at(i)));
3060 : /* eoss.writeInt(stokesParameter.at(i)); */
3061 :
3062 :
3063 :
3064 :
3065 :
3066 :
3067 : }
3068 :
3069 0 : eoss.writeBoolean(fluxExists);
3070 0 : if (fluxExists) {
3071 :
3072 :
3073 :
3074 :
3075 0 : Flux::toBin(flux, eoss);
3076 :
3077 :
3078 :
3079 : }
3080 :
3081 0 : eoss.writeBoolean(fluxErrExists);
3082 0 : if (fluxErrExists) {
3083 :
3084 :
3085 :
3086 :
3087 0 : Flux::toBin(fluxErr, eoss);
3088 :
3089 :
3090 :
3091 : }
3092 :
3093 0 : eoss.writeBoolean(positionAngleExists);
3094 0 : if (positionAngleExists) {
3095 :
3096 :
3097 :
3098 :
3099 0 : Angle::toBin(positionAngle, eoss);
3100 :
3101 :
3102 :
3103 : }
3104 :
3105 0 : eoss.writeBoolean(positionAngleErrExists);
3106 0 : if (positionAngleErrExists) {
3107 :
3108 :
3109 :
3110 :
3111 0 : Angle::toBin(positionAngleErr, eoss);
3112 :
3113 :
3114 :
3115 : }
3116 :
3117 0 : eoss.writeBoolean(sizeExists);
3118 0 : if (sizeExists) {
3119 :
3120 :
3121 :
3122 :
3123 0 : Angle::toBin(size, eoss);
3124 :
3125 :
3126 :
3127 : }
3128 :
3129 0 : eoss.writeBoolean(sizeErrExists);
3130 0 : if (sizeErrExists) {
3131 :
3132 :
3133 :
3134 :
3135 0 : Angle::toBin(sizeErr, eoss);
3136 :
3137 :
3138 :
3139 : }
3140 :
3141 0 : eoss.writeBoolean(velRefCodeExists);
3142 0 : if (velRefCodeExists) {
3143 :
3144 :
3145 :
3146 :
3147 :
3148 0 : eoss.writeString(CRadialVelocityReferenceCode::name(velRefCode));
3149 : /* eoss.writeInt(velRefCode); */
3150 :
3151 :
3152 :
3153 :
3154 : }
3155 :
3156 0 : eoss.writeBoolean(dopplerVelocityExists);
3157 0 : if (dopplerVelocityExists) {
3158 :
3159 :
3160 :
3161 :
3162 0 : Speed::toBin(dopplerVelocity, eoss);
3163 :
3164 :
3165 :
3166 : }
3167 :
3168 0 : eoss.writeBoolean(dopplerReferenceSystemExists);
3169 0 : if (dopplerReferenceSystemExists) {
3170 :
3171 :
3172 :
3173 :
3174 :
3175 0 : eoss.writeString(CRadialVelocityReferenceCode::name(dopplerReferenceSystem));
3176 : /* eoss.writeInt(dopplerReferenceSystem); */
3177 :
3178 :
3179 :
3180 :
3181 : }
3182 :
3183 0 : eoss.writeBoolean(dopplerCalcTypeExists);
3184 0 : if (dopplerCalcTypeExists) {
3185 :
3186 :
3187 :
3188 :
3189 :
3190 0 : eoss.writeString(CDopplerReferenceCode::name(dopplerCalcType));
3191 : /* eoss.writeInt(dopplerCalcType); */
3192 :
3193 :
3194 :
3195 :
3196 : }
3197 :
3198 0 : eoss.writeBoolean(parallaxExists);
3199 0 : if (parallaxExists) {
3200 :
3201 :
3202 :
3203 :
3204 0 : Angle::toBin(parallax, eoss);
3205 :
3206 :
3207 :
3208 : }
3209 :
3210 0 : }
3211 :
3212 0 : void SourceRow::sourceIdFromBin(EndianIStream& eis) {
3213 :
3214 :
3215 :
3216 :
3217 :
3218 0 : sourceId = eis.readInt();
3219 :
3220 :
3221 :
3222 :
3223 0 : }
3224 0 : void SourceRow::timeIntervalFromBin(EndianIStream& eis) {
3225 :
3226 :
3227 :
3228 :
3229 0 : timeInterval = ArrayTimeInterval::fromBin(eis);
3230 :
3231 :
3232 :
3233 0 : }
3234 0 : void SourceRow::spectralWindowIdFromBin(EndianIStream& eis) {
3235 :
3236 :
3237 :
3238 :
3239 0 : spectralWindowId = Tag::fromBin(eis);
3240 :
3241 :
3242 :
3243 0 : }
3244 0 : void SourceRow::codeFromBin(EndianIStream& eis) {
3245 :
3246 :
3247 :
3248 :
3249 :
3250 0 : code = eis.readString();
3251 :
3252 :
3253 :
3254 :
3255 0 : }
3256 0 : void SourceRow::directionFromBin(EndianIStream& eis) {
3257 :
3258 :
3259 :
3260 :
3261 :
3262 :
3263 0 : direction = Angle::from1DBin(eis);
3264 :
3265 :
3266 :
3267 :
3268 :
3269 0 : }
3270 0 : void SourceRow::properMotionFromBin(EndianIStream& eis) {
3271 :
3272 :
3273 :
3274 :
3275 :
3276 :
3277 0 : properMotion = AngularRate::from1DBin(eis);
3278 :
3279 :
3280 :
3281 :
3282 :
3283 0 : }
3284 0 : void SourceRow::sourceNameFromBin(EndianIStream& eis) {
3285 :
3286 :
3287 :
3288 :
3289 :
3290 0 : sourceName = eis.readString();
3291 :
3292 :
3293 :
3294 :
3295 0 : }
3296 :
3297 0 : void SourceRow::directionCodeFromBin(EndianIStream& eis) {
3298 :
3299 0 : directionCodeExists = eis.readBoolean();
3300 0 : if (directionCodeExists) {
3301 :
3302 :
3303 :
3304 :
3305 :
3306 0 : directionCode = CDirectionReferenceCode::literal(eis.readString());
3307 :
3308 :
3309 :
3310 :
3311 : }
3312 :
3313 0 : }
3314 0 : void SourceRow::directionEquinoxFromBin(EndianIStream& eis) {
3315 :
3316 0 : directionEquinoxExists = eis.readBoolean();
3317 0 : if (directionEquinoxExists) {
3318 :
3319 :
3320 :
3321 :
3322 0 : directionEquinox = ArrayTime::fromBin(eis);
3323 :
3324 :
3325 :
3326 : }
3327 :
3328 0 : }
3329 0 : void SourceRow::calibrationGroupFromBin(EndianIStream& eis) {
3330 :
3331 0 : calibrationGroupExists = eis.readBoolean();
3332 0 : if (calibrationGroupExists) {
3333 :
3334 :
3335 :
3336 :
3337 :
3338 0 : calibrationGroup = eis.readInt();
3339 :
3340 :
3341 :
3342 :
3343 : }
3344 :
3345 0 : }
3346 0 : void SourceRow::catalogFromBin(EndianIStream& eis) {
3347 :
3348 0 : catalogExists = eis.readBoolean();
3349 0 : if (catalogExists) {
3350 :
3351 :
3352 :
3353 :
3354 :
3355 0 : catalog = eis.readString();
3356 :
3357 :
3358 :
3359 :
3360 : }
3361 :
3362 0 : }
3363 0 : void SourceRow::deltaVelFromBin(EndianIStream& eis) {
3364 :
3365 0 : deltaVelExists = eis.readBoolean();
3366 0 : if (deltaVelExists) {
3367 :
3368 :
3369 :
3370 :
3371 0 : deltaVel = Speed::fromBin(eis);
3372 :
3373 :
3374 :
3375 : }
3376 :
3377 0 : }
3378 0 : void SourceRow::positionFromBin(EndianIStream& eis) {
3379 :
3380 0 : positionExists = eis.readBoolean();
3381 0 : if (positionExists) {
3382 :
3383 :
3384 :
3385 :
3386 :
3387 :
3388 0 : position = Length::from1DBin(eis);
3389 :
3390 :
3391 :
3392 :
3393 :
3394 : }
3395 :
3396 0 : }
3397 0 : void SourceRow::numLinesFromBin(EndianIStream& eis) {
3398 :
3399 0 : numLinesExists = eis.readBoolean();
3400 0 : if (numLinesExists) {
3401 :
3402 :
3403 :
3404 :
3405 :
3406 0 : numLines = eis.readInt();
3407 :
3408 :
3409 :
3410 :
3411 : }
3412 :
3413 0 : }
3414 0 : void SourceRow::transitionFromBin(EndianIStream& eis) {
3415 :
3416 0 : transitionExists = eis.readBoolean();
3417 0 : if (transitionExists) {
3418 :
3419 :
3420 :
3421 :
3422 :
3423 :
3424 0 : transition.clear();
3425 :
3426 0 : unsigned int transitionDim1 = eis.readInt();
3427 0 : for (unsigned int i = 0 ; i < transitionDim1; i++)
3428 :
3429 0 : transition.push_back(eis.readString());
3430 :
3431 :
3432 :
3433 :
3434 :
3435 :
3436 : }
3437 :
3438 0 : }
3439 0 : void SourceRow::restFrequencyFromBin(EndianIStream& eis) {
3440 :
3441 0 : restFrequencyExists = eis.readBoolean();
3442 0 : if (restFrequencyExists) {
3443 :
3444 :
3445 :
3446 :
3447 :
3448 :
3449 0 : restFrequency = Frequency::from1DBin(eis);
3450 :
3451 :
3452 :
3453 :
3454 :
3455 : }
3456 :
3457 0 : }
3458 0 : void SourceRow::sysVelFromBin(EndianIStream& eis) {
3459 :
3460 0 : sysVelExists = eis.readBoolean();
3461 0 : if (sysVelExists) {
3462 :
3463 :
3464 :
3465 :
3466 :
3467 :
3468 0 : sysVel = Speed::from1DBin(eis);
3469 :
3470 :
3471 :
3472 :
3473 :
3474 : }
3475 :
3476 0 : }
3477 0 : void SourceRow::rangeVelFromBin(EndianIStream& eis) {
3478 :
3479 0 : rangeVelExists = eis.readBoolean();
3480 0 : if (rangeVelExists) {
3481 :
3482 :
3483 :
3484 :
3485 :
3486 :
3487 0 : rangeVel = Speed::from1DBin(eis);
3488 :
3489 :
3490 :
3491 :
3492 :
3493 : }
3494 :
3495 0 : }
3496 0 : void SourceRow::sourceModelFromBin(EndianIStream& eis) {
3497 :
3498 0 : sourceModelExists = eis.readBoolean();
3499 0 : if (sourceModelExists) {
3500 :
3501 :
3502 :
3503 :
3504 :
3505 0 : sourceModel = CSourceModel::literal(eis.readString());
3506 :
3507 :
3508 :
3509 :
3510 : }
3511 :
3512 0 : }
3513 0 : void SourceRow::frequencyRefCodeFromBin(EndianIStream& eis) {
3514 :
3515 0 : frequencyRefCodeExists = eis.readBoolean();
3516 0 : if (frequencyRefCodeExists) {
3517 :
3518 :
3519 :
3520 :
3521 :
3522 0 : frequencyRefCode = CFrequencyReferenceCode::literal(eis.readString());
3523 :
3524 :
3525 :
3526 :
3527 : }
3528 :
3529 0 : }
3530 0 : void SourceRow::numFreqFromBin(EndianIStream& eis) {
3531 :
3532 0 : numFreqExists = eis.readBoolean();
3533 0 : if (numFreqExists) {
3534 :
3535 :
3536 :
3537 :
3538 :
3539 0 : numFreq = eis.readInt();
3540 :
3541 :
3542 :
3543 :
3544 : }
3545 :
3546 0 : }
3547 0 : void SourceRow::numStokesFromBin(EndianIStream& eis) {
3548 :
3549 0 : numStokesExists = eis.readBoolean();
3550 0 : if (numStokesExists) {
3551 :
3552 :
3553 :
3554 :
3555 :
3556 0 : numStokes = eis.readInt();
3557 :
3558 :
3559 :
3560 :
3561 : }
3562 :
3563 0 : }
3564 0 : void SourceRow::frequencyFromBin(EndianIStream& eis) {
3565 :
3566 0 : frequencyExists = eis.readBoolean();
3567 0 : if (frequencyExists) {
3568 :
3569 :
3570 :
3571 :
3572 :
3573 :
3574 0 : frequency = Frequency::from1DBin(eis);
3575 :
3576 :
3577 :
3578 :
3579 :
3580 : }
3581 :
3582 0 : }
3583 0 : void SourceRow::frequencyIntervalFromBin(EndianIStream& eis) {
3584 :
3585 0 : frequencyIntervalExists = eis.readBoolean();
3586 0 : if (frequencyIntervalExists) {
3587 :
3588 :
3589 :
3590 :
3591 :
3592 :
3593 0 : frequencyInterval = Frequency::from1DBin(eis);
3594 :
3595 :
3596 :
3597 :
3598 :
3599 : }
3600 :
3601 0 : }
3602 0 : void SourceRow::stokesParameterFromBin(EndianIStream& eis) {
3603 :
3604 0 : stokesParameterExists = eis.readBoolean();
3605 0 : if (stokesParameterExists) {
3606 :
3607 :
3608 :
3609 :
3610 :
3611 :
3612 0 : stokesParameter.clear();
3613 :
3614 0 : unsigned int stokesParameterDim1 = eis.readInt();
3615 0 : for (unsigned int i = 0 ; i < stokesParameterDim1; i++)
3616 :
3617 0 : stokesParameter.push_back(CStokesParameter::literal(eis.readString()));
3618 :
3619 :
3620 :
3621 :
3622 :
3623 :
3624 : }
3625 :
3626 0 : }
3627 0 : void SourceRow::fluxFromBin(EndianIStream& eis) {
3628 :
3629 0 : fluxExists = eis.readBoolean();
3630 0 : if (fluxExists) {
3631 :
3632 :
3633 :
3634 :
3635 :
3636 :
3637 0 : flux = Flux::from2DBin(eis);
3638 :
3639 :
3640 :
3641 :
3642 :
3643 : }
3644 :
3645 0 : }
3646 0 : void SourceRow::fluxErrFromBin(EndianIStream& eis) {
3647 :
3648 0 : fluxErrExists = eis.readBoolean();
3649 0 : if (fluxErrExists) {
3650 :
3651 :
3652 :
3653 :
3654 :
3655 :
3656 0 : fluxErr = Flux::from2DBin(eis);
3657 :
3658 :
3659 :
3660 :
3661 :
3662 : }
3663 :
3664 0 : }
3665 0 : void SourceRow::positionAngleFromBin(EndianIStream& eis) {
3666 :
3667 0 : positionAngleExists = eis.readBoolean();
3668 0 : if (positionAngleExists) {
3669 :
3670 :
3671 :
3672 :
3673 :
3674 :
3675 0 : positionAngle = Angle::from1DBin(eis);
3676 :
3677 :
3678 :
3679 :
3680 :
3681 : }
3682 :
3683 0 : }
3684 0 : void SourceRow::positionAngleErrFromBin(EndianIStream& eis) {
3685 :
3686 0 : positionAngleErrExists = eis.readBoolean();
3687 0 : if (positionAngleErrExists) {
3688 :
3689 :
3690 :
3691 :
3692 :
3693 :
3694 0 : positionAngleErr = Angle::from1DBin(eis);
3695 :
3696 :
3697 :
3698 :
3699 :
3700 : }
3701 :
3702 0 : }
3703 0 : void SourceRow::sizeFromBin(EndianIStream& eis) {
3704 :
3705 0 : sizeExists = eis.readBoolean();
3706 0 : if (sizeExists) {
3707 :
3708 :
3709 :
3710 :
3711 :
3712 :
3713 0 : size = Angle::from2DBin(eis);
3714 :
3715 :
3716 :
3717 :
3718 :
3719 : }
3720 :
3721 0 : }
3722 0 : void SourceRow::sizeErrFromBin(EndianIStream& eis) {
3723 :
3724 0 : sizeErrExists = eis.readBoolean();
3725 0 : if (sizeErrExists) {
3726 :
3727 :
3728 :
3729 :
3730 :
3731 :
3732 0 : sizeErr = Angle::from2DBin(eis);
3733 :
3734 :
3735 :
3736 :
3737 :
3738 : }
3739 :
3740 0 : }
3741 0 : void SourceRow::velRefCodeFromBin(EndianIStream& eis) {
3742 :
3743 0 : velRefCodeExists = eis.readBoolean();
3744 0 : if (velRefCodeExists) {
3745 :
3746 :
3747 :
3748 :
3749 :
3750 0 : velRefCode = CRadialVelocityReferenceCode::literal(eis.readString());
3751 :
3752 :
3753 :
3754 :
3755 : }
3756 :
3757 0 : }
3758 0 : void SourceRow::dopplerVelocityFromBin(EndianIStream& eis) {
3759 :
3760 0 : dopplerVelocityExists = eis.readBoolean();
3761 0 : if (dopplerVelocityExists) {
3762 :
3763 :
3764 :
3765 :
3766 :
3767 :
3768 0 : dopplerVelocity = Speed::from1DBin(eis);
3769 :
3770 :
3771 :
3772 :
3773 :
3774 : }
3775 :
3776 0 : }
3777 0 : void SourceRow::dopplerReferenceSystemFromBin(EndianIStream& eis) {
3778 :
3779 0 : dopplerReferenceSystemExists = eis.readBoolean();
3780 0 : if (dopplerReferenceSystemExists) {
3781 :
3782 :
3783 :
3784 :
3785 :
3786 0 : dopplerReferenceSystem = CRadialVelocityReferenceCode::literal(eis.readString());
3787 :
3788 :
3789 :
3790 :
3791 : }
3792 :
3793 0 : }
3794 0 : void SourceRow::dopplerCalcTypeFromBin(EndianIStream& eis) {
3795 :
3796 0 : dopplerCalcTypeExists = eis.readBoolean();
3797 0 : if (dopplerCalcTypeExists) {
3798 :
3799 :
3800 :
3801 :
3802 :
3803 0 : dopplerCalcType = CDopplerReferenceCode::literal(eis.readString());
3804 :
3805 :
3806 :
3807 :
3808 : }
3809 :
3810 0 : }
3811 0 : void SourceRow::parallaxFromBin(EndianIStream& eis) {
3812 :
3813 0 : parallaxExists = eis.readBoolean();
3814 0 : if (parallaxExists) {
3815 :
3816 :
3817 :
3818 :
3819 :
3820 :
3821 0 : parallax = Angle::from1DBin(eis);
3822 :
3823 :
3824 :
3825 :
3826 :
3827 : }
3828 :
3829 0 : }
3830 :
3831 :
3832 0 : SourceRow* SourceRow::fromBin(EndianIStream& eis, SourceTable& table, const vector<string>& attributesSeq) {
3833 0 : SourceRow* row = new SourceRow(table);
3834 :
3835 0 : map<string, SourceAttributeFromBin>::iterator iter ;
3836 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
3837 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
3838 0 : if (iter != row->fromBinMethods.end()) {
3839 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
3840 : }
3841 : else {
3842 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
3843 0 : if (functorP)
3844 0 : (*functorP)(eis);
3845 : else
3846 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "SourceTable");
3847 : }
3848 :
3849 : }
3850 0 : return row;
3851 : }
3852 :
3853 : //
3854 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
3855 : // of one row.
3856 : //
3857 :
3858 : // Convert a string into an int
3859 0 : void SourceRow::sourceIdFromText(const string & s) {
3860 :
3861 :
3862 0 : sourceId = ASDMValuesParser::parse<int>(s);
3863 :
3864 :
3865 0 : }
3866 :
3867 :
3868 : // Convert a string into an ArrayTimeInterval
3869 0 : void SourceRow::timeIntervalFromText(const string & s) {
3870 :
3871 :
3872 0 : timeInterval = ASDMValuesParser::parse<ArrayTimeInterval>(s);
3873 :
3874 :
3875 0 : }
3876 :
3877 :
3878 : // Convert a string into an Tag
3879 0 : void SourceRow::spectralWindowIdFromText(const string & s) {
3880 :
3881 :
3882 0 : spectralWindowId = ASDMValuesParser::parse<Tag>(s);
3883 :
3884 :
3885 0 : }
3886 :
3887 :
3888 : // Convert a string into an String
3889 0 : void SourceRow::codeFromText(const string & s) {
3890 :
3891 :
3892 0 : code = ASDMValuesParser::parse<string>(s);
3893 :
3894 :
3895 0 : }
3896 :
3897 :
3898 : // Convert a string into an Angle
3899 0 : void SourceRow::directionFromText(const string & s) {
3900 :
3901 :
3902 0 : direction = ASDMValuesParser::parse1D<Angle>(s);
3903 :
3904 :
3905 0 : }
3906 :
3907 :
3908 : // Convert a string into an AngularRate
3909 0 : void SourceRow::properMotionFromText(const string & s) {
3910 :
3911 :
3912 0 : properMotion = ASDMValuesParser::parse1D<AngularRate>(s);
3913 :
3914 :
3915 0 : }
3916 :
3917 :
3918 : // Convert a string into an String
3919 0 : void SourceRow::sourceNameFromText(const string & s) {
3920 :
3921 :
3922 0 : sourceName = ASDMValuesParser::parse<string>(s);
3923 :
3924 :
3925 0 : }
3926 :
3927 :
3928 :
3929 : // Convert a string into an DirectionReferenceCode
3930 0 : void SourceRow::directionCodeFromText(const string & s) {
3931 0 : directionCodeExists = true;
3932 :
3933 :
3934 0 : directionCode = ASDMValuesParser::parse<DirectionReferenceCodeMod::DirectionReferenceCode>(s);
3935 :
3936 :
3937 0 : }
3938 :
3939 :
3940 : // Convert a string into an ArrayTime
3941 0 : void SourceRow::directionEquinoxFromText(const string & s) {
3942 0 : directionEquinoxExists = true;
3943 :
3944 :
3945 0 : directionEquinox = ASDMValuesParser::parse<ArrayTime>(s);
3946 :
3947 :
3948 0 : }
3949 :
3950 :
3951 : // Convert a string into an int
3952 0 : void SourceRow::calibrationGroupFromText(const string & s) {
3953 0 : calibrationGroupExists = true;
3954 :
3955 :
3956 0 : calibrationGroup = ASDMValuesParser::parse<int>(s);
3957 :
3958 :
3959 0 : }
3960 :
3961 :
3962 : // Convert a string into an String
3963 0 : void SourceRow::catalogFromText(const string & s) {
3964 0 : catalogExists = true;
3965 :
3966 :
3967 0 : catalog = ASDMValuesParser::parse<string>(s);
3968 :
3969 :
3970 0 : }
3971 :
3972 :
3973 : // Convert a string into an Speed
3974 0 : void SourceRow::deltaVelFromText(const string & s) {
3975 0 : deltaVelExists = true;
3976 :
3977 :
3978 0 : deltaVel = ASDMValuesParser::parse<Speed>(s);
3979 :
3980 :
3981 0 : }
3982 :
3983 :
3984 : // Convert a string into an Length
3985 0 : void SourceRow::positionFromText(const string & s) {
3986 0 : positionExists = true;
3987 :
3988 :
3989 0 : position = ASDMValuesParser::parse1D<Length>(s);
3990 :
3991 :
3992 0 : }
3993 :
3994 :
3995 : // Convert a string into an int
3996 0 : void SourceRow::numLinesFromText(const string & s) {
3997 0 : numLinesExists = true;
3998 :
3999 :
4000 0 : numLines = ASDMValuesParser::parse<int>(s);
4001 :
4002 :
4003 0 : }
4004 :
4005 :
4006 : // Convert a string into an String
4007 0 : void SourceRow::transitionFromText(const string & s) {
4008 0 : transitionExists = true;
4009 :
4010 :
4011 0 : transition = ASDMValuesParser::parse1D<string>(s);
4012 :
4013 :
4014 0 : }
4015 :
4016 :
4017 : // Convert a string into an Frequency
4018 0 : void SourceRow::restFrequencyFromText(const string & s) {
4019 0 : restFrequencyExists = true;
4020 :
4021 :
4022 0 : restFrequency = ASDMValuesParser::parse1D<Frequency>(s);
4023 :
4024 :
4025 0 : }
4026 :
4027 :
4028 : // Convert a string into an Speed
4029 0 : void SourceRow::sysVelFromText(const string & s) {
4030 0 : sysVelExists = true;
4031 :
4032 :
4033 0 : sysVel = ASDMValuesParser::parse1D<Speed>(s);
4034 :
4035 :
4036 0 : }
4037 :
4038 :
4039 : // Convert a string into an Speed
4040 0 : void SourceRow::rangeVelFromText(const string & s) {
4041 0 : rangeVelExists = true;
4042 :
4043 :
4044 0 : rangeVel = ASDMValuesParser::parse1D<Speed>(s);
4045 :
4046 :
4047 0 : }
4048 :
4049 :
4050 : // Convert a string into an SourceModel
4051 0 : void SourceRow::sourceModelFromText(const string & s) {
4052 0 : sourceModelExists = true;
4053 :
4054 :
4055 0 : sourceModel = ASDMValuesParser::parse<SourceModelMod::SourceModel>(s);
4056 :
4057 :
4058 0 : }
4059 :
4060 :
4061 : // Convert a string into an FrequencyReferenceCode
4062 0 : void SourceRow::frequencyRefCodeFromText(const string & s) {
4063 0 : frequencyRefCodeExists = true;
4064 :
4065 :
4066 0 : frequencyRefCode = ASDMValuesParser::parse<FrequencyReferenceCodeMod::FrequencyReferenceCode>(s);
4067 :
4068 :
4069 0 : }
4070 :
4071 :
4072 : // Convert a string into an int
4073 0 : void SourceRow::numFreqFromText(const string & s) {
4074 0 : numFreqExists = true;
4075 :
4076 :
4077 0 : numFreq = ASDMValuesParser::parse<int>(s);
4078 :
4079 :
4080 0 : }
4081 :
4082 :
4083 : // Convert a string into an int
4084 0 : void SourceRow::numStokesFromText(const string & s) {
4085 0 : numStokesExists = true;
4086 :
4087 :
4088 0 : numStokes = ASDMValuesParser::parse<int>(s);
4089 :
4090 :
4091 0 : }
4092 :
4093 :
4094 : // Convert a string into an Frequency
4095 0 : void SourceRow::frequencyFromText(const string & s) {
4096 0 : frequencyExists = true;
4097 :
4098 :
4099 0 : frequency = ASDMValuesParser::parse1D<Frequency>(s);
4100 :
4101 :
4102 0 : }
4103 :
4104 :
4105 : // Convert a string into an Frequency
4106 0 : void SourceRow::frequencyIntervalFromText(const string & s) {
4107 0 : frequencyIntervalExists = true;
4108 :
4109 :
4110 0 : frequencyInterval = ASDMValuesParser::parse1D<Frequency>(s);
4111 :
4112 :
4113 0 : }
4114 :
4115 :
4116 : // Convert a string into an StokesParameter
4117 0 : void SourceRow::stokesParameterFromText(const string & s) {
4118 0 : stokesParameterExists = true;
4119 :
4120 :
4121 0 : stokesParameter = ASDMValuesParser::parse1D<StokesParameterMod::StokesParameter>(s);
4122 :
4123 :
4124 0 : }
4125 :
4126 :
4127 : // Convert a string into an Flux
4128 0 : void SourceRow::fluxFromText(const string & s) {
4129 0 : fluxExists = true;
4130 :
4131 :
4132 0 : flux = ASDMValuesParser::parse2D<Flux>(s);
4133 :
4134 :
4135 0 : }
4136 :
4137 :
4138 : // Convert a string into an Flux
4139 0 : void SourceRow::fluxErrFromText(const string & s) {
4140 0 : fluxErrExists = true;
4141 :
4142 :
4143 0 : fluxErr = ASDMValuesParser::parse2D<Flux>(s);
4144 :
4145 :
4146 0 : }
4147 :
4148 :
4149 : // Convert a string into an Angle
4150 0 : void SourceRow::positionAngleFromText(const string & s) {
4151 0 : positionAngleExists = true;
4152 :
4153 :
4154 0 : positionAngle = ASDMValuesParser::parse1D<Angle>(s);
4155 :
4156 :
4157 0 : }
4158 :
4159 :
4160 : // Convert a string into an Angle
4161 0 : void SourceRow::positionAngleErrFromText(const string & s) {
4162 0 : positionAngleErrExists = true;
4163 :
4164 :
4165 0 : positionAngleErr = ASDMValuesParser::parse1D<Angle>(s);
4166 :
4167 :
4168 0 : }
4169 :
4170 :
4171 : // Convert a string into an Angle
4172 0 : void SourceRow::sizeFromText(const string & s) {
4173 0 : sizeExists = true;
4174 :
4175 :
4176 0 : size = ASDMValuesParser::parse2D<Angle>(s);
4177 :
4178 :
4179 0 : }
4180 :
4181 :
4182 : // Convert a string into an Angle
4183 0 : void SourceRow::sizeErrFromText(const string & s) {
4184 0 : sizeErrExists = true;
4185 :
4186 :
4187 0 : sizeErr = ASDMValuesParser::parse2D<Angle>(s);
4188 :
4189 :
4190 0 : }
4191 :
4192 :
4193 : // Convert a string into an RadialVelocityReferenceCode
4194 0 : void SourceRow::velRefCodeFromText(const string & s) {
4195 0 : velRefCodeExists = true;
4196 :
4197 :
4198 0 : velRefCode = ASDMValuesParser::parse<RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode>(s);
4199 :
4200 :
4201 0 : }
4202 :
4203 :
4204 : // Convert a string into an Speed
4205 0 : void SourceRow::dopplerVelocityFromText(const string & s) {
4206 0 : dopplerVelocityExists = true;
4207 :
4208 :
4209 0 : dopplerVelocity = ASDMValuesParser::parse1D<Speed>(s);
4210 :
4211 :
4212 0 : }
4213 :
4214 :
4215 : // Convert a string into an RadialVelocityReferenceCode
4216 0 : void SourceRow::dopplerReferenceSystemFromText(const string & s) {
4217 0 : dopplerReferenceSystemExists = true;
4218 :
4219 :
4220 0 : dopplerReferenceSystem = ASDMValuesParser::parse<RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode>(s);
4221 :
4222 :
4223 0 : }
4224 :
4225 :
4226 : // Convert a string into an DopplerReferenceCode
4227 0 : void SourceRow::dopplerCalcTypeFromText(const string & s) {
4228 0 : dopplerCalcTypeExists = true;
4229 :
4230 :
4231 0 : dopplerCalcType = ASDMValuesParser::parse<DopplerReferenceCodeMod::DopplerReferenceCode>(s);
4232 :
4233 :
4234 0 : }
4235 :
4236 :
4237 : // Convert a string into an Angle
4238 0 : void SourceRow::parallaxFromText(const string & s) {
4239 0 : parallaxExists = true;
4240 :
4241 :
4242 0 : parallax = ASDMValuesParser::parse1D<Angle>(s);
4243 :
4244 :
4245 0 : }
4246 :
4247 :
4248 :
4249 0 : void SourceRow::fromText(const std::string& attributeName, const std::string& t) {
4250 0 : map<string, SourceAttributeFromText>::iterator iter;
4251 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
4252 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "SourceTable");
4253 0 : (this->*(iter->second))(t);
4254 0 : }
4255 :
4256 : ////////////////////////////////////////////////
4257 : // Intrinsic Table Attributes getters/setters //
4258 : ////////////////////////////////////////////////
4259 :
4260 :
4261 :
4262 :
4263 : /**
4264 : * Get sourceId.
4265 : * @return sourceId as int
4266 : */
4267 16697 : int SourceRow::getSourceId() const {
4268 :
4269 16697 : return sourceId;
4270 : }
4271 :
4272 : /**
4273 : * Set sourceId with the specified int.
4274 : * @param sourceId The int value to which sourceId is to be set.
4275 :
4276 :
4277 :
4278 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
4279 :
4280 : */
4281 8864 : void SourceRow::setSourceId (int sourceId) {
4282 :
4283 :
4284 8864 : if (hasBeenAdded) {
4285 :
4286 0 : throw IllegalAccessException("sourceId", "Source");
4287 :
4288 : }
4289 :
4290 8864 : this->sourceId = sourceId;
4291 :
4292 8864 : }
4293 :
4294 :
4295 :
4296 :
4297 :
4298 :
4299 : /**
4300 : * Get timeInterval.
4301 : * @return timeInterval as ArrayTimeInterval
4302 : */
4303 53243 : ArrayTimeInterval SourceRow::getTimeInterval() const {
4304 :
4305 53243 : return timeInterval;
4306 : }
4307 :
4308 : /**
4309 : * Set timeInterval with the specified ArrayTimeInterval.
4310 : * @param timeInterval The ArrayTimeInterval value to which timeInterval is to be set.
4311 :
4312 :
4313 :
4314 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
4315 :
4316 : */
4317 8864 : void SourceRow::setTimeInterval (ArrayTimeInterval timeInterval) {
4318 :
4319 :
4320 8864 : if (hasBeenAdded) {
4321 :
4322 0 : throw IllegalAccessException("timeInterval", "Source");
4323 :
4324 : }
4325 :
4326 8864 : this->timeInterval = timeInterval;
4327 :
4328 8864 : }
4329 :
4330 :
4331 :
4332 :
4333 :
4334 :
4335 : /**
4336 : * Get code.
4337 : * @return code as std::string
4338 : */
4339 31211 : std::string SourceRow::getCode() const {
4340 :
4341 31211 : return code;
4342 : }
4343 :
4344 : /**
4345 : * Set code with the specified std::string.
4346 : * @param code The std::string value to which code is to be set.
4347 :
4348 :
4349 :
4350 : */
4351 8864 : void SourceRow::setCode (std::string code) {
4352 :
4353 :
4354 8864 : if (hasBeenAdded) {
4355 :
4356 : }
4357 :
4358 8864 : this->code = code;
4359 :
4360 8864 : }
4361 :
4362 :
4363 :
4364 :
4365 :
4366 :
4367 : /**
4368 : * Get direction.
4369 : * @return direction as std::vector<Angle >
4370 : */
4371 31211 : std::vector<Angle > SourceRow::getDirection() const {
4372 :
4373 31211 : return direction;
4374 : }
4375 :
4376 : /**
4377 : * Set direction with the specified std::vector<Angle >.
4378 : * @param direction The std::vector<Angle > value to which direction is to be set.
4379 :
4380 :
4381 :
4382 : */
4383 8864 : void SourceRow::setDirection (std::vector<Angle > direction) {
4384 :
4385 :
4386 8864 : if (hasBeenAdded) {
4387 :
4388 : }
4389 :
4390 8864 : this->direction = direction;
4391 :
4392 8864 : }
4393 :
4394 :
4395 :
4396 :
4397 :
4398 :
4399 : /**
4400 : * Get properMotion.
4401 : * @return properMotion as std::vector<AngularRate >
4402 : */
4403 8221 : std::vector<AngularRate > SourceRow::getProperMotion() const {
4404 :
4405 8221 : return properMotion;
4406 : }
4407 :
4408 : /**
4409 : * Set properMotion with the specified std::vector<AngularRate >.
4410 : * @param properMotion The std::vector<AngularRate > value to which properMotion is to be set.
4411 :
4412 :
4413 :
4414 : */
4415 8864 : void SourceRow::setProperMotion (std::vector<AngularRate > properMotion) {
4416 :
4417 :
4418 8864 : if (hasBeenAdded) {
4419 :
4420 : }
4421 :
4422 8864 : this->properMotion = properMotion;
4423 :
4424 8864 : }
4425 :
4426 :
4427 :
4428 :
4429 :
4430 :
4431 : /**
4432 : * Get sourceName.
4433 : * @return sourceName as std::string
4434 : */
4435 19944 : std::string SourceRow::getSourceName() const {
4436 :
4437 19944 : return sourceName;
4438 : }
4439 :
4440 : /**
4441 : * Set sourceName with the specified std::string.
4442 : * @param sourceName The std::string value to which sourceName is to be set.
4443 :
4444 :
4445 :
4446 : */
4447 8864 : void SourceRow::setSourceName (std::string sourceName) {
4448 :
4449 :
4450 8864 : if (hasBeenAdded) {
4451 :
4452 : }
4453 :
4454 8864 : this->sourceName = sourceName;
4455 :
4456 8864 : }
4457 :
4458 :
4459 :
4460 :
4461 : /**
4462 : * The attribute directionCode is optional. Return true if this attribute exists.
4463 : * @return true if and only if the directionCode attribute exists.
4464 : */
4465 8221 : bool SourceRow::isDirectionCodeExists() const {
4466 8221 : return directionCodeExists;
4467 : }
4468 :
4469 :
4470 :
4471 : /**
4472 : * Get directionCode, which is optional.
4473 : * @return directionCode as DirectionReferenceCodeMod::DirectionReferenceCode
4474 : * @throw IllegalAccessException If directionCode does not exist.
4475 : */
4476 7797 : DirectionReferenceCodeMod::DirectionReferenceCode SourceRow::getDirectionCode() const {
4477 7797 : if (!directionCodeExists) {
4478 0 : throw IllegalAccessException("directionCode", "Source");
4479 : }
4480 :
4481 7797 : return directionCode;
4482 : }
4483 :
4484 : /**
4485 : * Set directionCode with the specified DirectionReferenceCodeMod::DirectionReferenceCode.
4486 : * @param directionCode The DirectionReferenceCodeMod::DirectionReferenceCode value to which directionCode is to be set.
4487 :
4488 :
4489 : */
4490 643 : void SourceRow::setDirectionCode (DirectionReferenceCodeMod::DirectionReferenceCode directionCode) {
4491 :
4492 643 : this->directionCode = directionCode;
4493 :
4494 643 : directionCodeExists = true;
4495 :
4496 643 : }
4497 :
4498 :
4499 : /**
4500 : * Mark directionCode, which is an optional field, as non-existent.
4501 : */
4502 0 : void SourceRow::clearDirectionCode () {
4503 0 : directionCodeExists = false;
4504 0 : }
4505 :
4506 :
4507 :
4508 : /**
4509 : * The attribute directionEquinox is optional. Return true if this attribute exists.
4510 : * @return true if and only if the directionEquinox attribute exists.
4511 : */
4512 0 : bool SourceRow::isDirectionEquinoxExists() const {
4513 0 : return directionEquinoxExists;
4514 : }
4515 :
4516 :
4517 :
4518 : /**
4519 : * Get directionEquinox, which is optional.
4520 : * @return directionEquinox as ArrayTime
4521 : * @throw IllegalAccessException If directionEquinox does not exist.
4522 : */
4523 0 : ArrayTime SourceRow::getDirectionEquinox() const {
4524 0 : if (!directionEquinoxExists) {
4525 0 : throw IllegalAccessException("directionEquinox", "Source");
4526 : }
4527 :
4528 0 : return directionEquinox;
4529 : }
4530 :
4531 : /**
4532 : * Set directionEquinox with the specified ArrayTime.
4533 : * @param directionEquinox The ArrayTime value to which directionEquinox is to be set.
4534 :
4535 :
4536 : */
4537 0 : void SourceRow::setDirectionEquinox (ArrayTime directionEquinox) {
4538 :
4539 0 : this->directionEquinox = directionEquinox;
4540 :
4541 0 : directionEquinoxExists = true;
4542 :
4543 0 : }
4544 :
4545 :
4546 : /**
4547 : * Mark directionEquinox, which is an optional field, as non-existent.
4548 : */
4549 0 : void SourceRow::clearDirectionEquinox () {
4550 0 : directionEquinoxExists = false;
4551 0 : }
4552 :
4553 :
4554 :
4555 : /**
4556 : * The attribute calibrationGroup is optional. Return true if this attribute exists.
4557 : * @return true if and only if the calibrationGroup attribute exists.
4558 : */
4559 8221 : bool SourceRow::isCalibrationGroupExists() const {
4560 8221 : return calibrationGroupExists;
4561 : }
4562 :
4563 :
4564 :
4565 : /**
4566 : * Get calibrationGroup, which is optional.
4567 : * @return calibrationGroup as int
4568 : * @throw IllegalAccessException If calibrationGroup does not exist.
4569 : */
4570 0 : int SourceRow::getCalibrationGroup() const {
4571 0 : if (!calibrationGroupExists) {
4572 0 : throw IllegalAccessException("calibrationGroup", "Source");
4573 : }
4574 :
4575 0 : return calibrationGroup;
4576 : }
4577 :
4578 : /**
4579 : * Set calibrationGroup with the specified int.
4580 : * @param calibrationGroup The int value to which calibrationGroup is to be set.
4581 :
4582 :
4583 : */
4584 0 : void SourceRow::setCalibrationGroup (int calibrationGroup) {
4585 :
4586 0 : this->calibrationGroup = calibrationGroup;
4587 :
4588 0 : calibrationGroupExists = true;
4589 :
4590 0 : }
4591 :
4592 :
4593 : /**
4594 : * Mark calibrationGroup, which is an optional field, as non-existent.
4595 : */
4596 0 : void SourceRow::clearCalibrationGroup () {
4597 0 : calibrationGroupExists = false;
4598 0 : }
4599 :
4600 :
4601 :
4602 : /**
4603 : * The attribute catalog is optional. Return true if this attribute exists.
4604 : * @return true if and only if the catalog attribute exists.
4605 : */
4606 0 : bool SourceRow::isCatalogExists() const {
4607 0 : return catalogExists;
4608 : }
4609 :
4610 :
4611 :
4612 : /**
4613 : * Get catalog, which is optional.
4614 : * @return catalog as std::string
4615 : * @throw IllegalAccessException If catalog does not exist.
4616 : */
4617 0 : std::string SourceRow::getCatalog() const {
4618 0 : if (!catalogExists) {
4619 0 : throw IllegalAccessException("catalog", "Source");
4620 : }
4621 :
4622 0 : return catalog;
4623 : }
4624 :
4625 : /**
4626 : * Set catalog with the specified std::string.
4627 : * @param catalog The std::string value to which catalog is to be set.
4628 :
4629 :
4630 : */
4631 0 : void SourceRow::setCatalog (std::string catalog) {
4632 :
4633 0 : this->catalog = catalog;
4634 :
4635 0 : catalogExists = true;
4636 :
4637 0 : }
4638 :
4639 :
4640 : /**
4641 : * Mark catalog, which is an optional field, as non-existent.
4642 : */
4643 0 : void SourceRow::clearCatalog () {
4644 0 : catalogExists = false;
4645 0 : }
4646 :
4647 :
4648 :
4649 : /**
4650 : * The attribute deltaVel is optional. Return true if this attribute exists.
4651 : * @return true if and only if the deltaVel attribute exists.
4652 : */
4653 0 : bool SourceRow::isDeltaVelExists() const {
4654 0 : return deltaVelExists;
4655 : }
4656 :
4657 :
4658 :
4659 : /**
4660 : * Get deltaVel, which is optional.
4661 : * @return deltaVel as Speed
4662 : * @throw IllegalAccessException If deltaVel does not exist.
4663 : */
4664 0 : Speed SourceRow::getDeltaVel() const {
4665 0 : if (!deltaVelExists) {
4666 0 : throw IllegalAccessException("deltaVel", "Source");
4667 : }
4668 :
4669 0 : return deltaVel;
4670 : }
4671 :
4672 : /**
4673 : * Set deltaVel with the specified Speed.
4674 : * @param deltaVel The Speed value to which deltaVel is to be set.
4675 :
4676 :
4677 : */
4678 0 : void SourceRow::setDeltaVel (Speed deltaVel) {
4679 :
4680 0 : this->deltaVel = deltaVel;
4681 :
4682 0 : deltaVelExists = true;
4683 :
4684 0 : }
4685 :
4686 :
4687 : /**
4688 : * Mark deltaVel, which is an optional field, as non-existent.
4689 : */
4690 0 : void SourceRow::clearDeltaVel () {
4691 0 : deltaVelExists = false;
4692 0 : }
4693 :
4694 :
4695 :
4696 : /**
4697 : * The attribute position is optional. Return true if this attribute exists.
4698 : * @return true if and only if the position attribute exists.
4699 : */
4700 8221 : bool SourceRow::isPositionExists() const {
4701 8221 : return positionExists;
4702 : }
4703 :
4704 :
4705 :
4706 : /**
4707 : * Get position, which is optional.
4708 : * @return position as std::vector<Length >
4709 : * @throw IllegalAccessException If position does not exist.
4710 : */
4711 0 : std::vector<Length > SourceRow::getPosition() const {
4712 0 : if (!positionExists) {
4713 0 : throw IllegalAccessException("position", "Source");
4714 : }
4715 :
4716 0 : return position;
4717 : }
4718 :
4719 : /**
4720 : * Set position with the specified std::vector<Length >.
4721 : * @param position The std::vector<Length > value to which position is to be set.
4722 :
4723 :
4724 : */
4725 0 : void SourceRow::setPosition (std::vector<Length > position) {
4726 :
4727 0 : this->position = position;
4728 :
4729 0 : positionExists = true;
4730 :
4731 0 : }
4732 :
4733 :
4734 : /**
4735 : * Mark position, which is an optional field, as non-existent.
4736 : */
4737 0 : void SourceRow::clearPosition () {
4738 0 : positionExists = false;
4739 0 : }
4740 :
4741 :
4742 :
4743 : /**
4744 : * The attribute numLines is optional. Return true if this attribute exists.
4745 : * @return true if and only if the numLines attribute exists.
4746 : */
4747 12693 : bool SourceRow::isNumLinesExists() const {
4748 12693 : return numLinesExists;
4749 : }
4750 :
4751 :
4752 :
4753 : /**
4754 : * Get numLines, which is optional.
4755 : * @return numLines as int
4756 : * @throw IllegalAccessException If numLines does not exist.
4757 : */
4758 1632 : int SourceRow::getNumLines() const {
4759 1632 : if (!numLinesExists) {
4760 0 : throw IllegalAccessException("numLines", "Source");
4761 : }
4762 :
4763 1632 : return numLines;
4764 : }
4765 :
4766 : /**
4767 : * Set numLines with the specified int.
4768 : * @param numLines The int value to which numLines is to be set.
4769 :
4770 :
4771 : */
4772 1632 : void SourceRow::setNumLines (int numLines) {
4773 :
4774 1632 : this->numLines = numLines;
4775 :
4776 1632 : numLinesExists = true;
4777 :
4778 1632 : }
4779 :
4780 :
4781 : /**
4782 : * Mark numLines, which is an optional field, as non-existent.
4783 : */
4784 0 : void SourceRow::clearNumLines () {
4785 0 : numLinesExists = false;
4786 0 : }
4787 :
4788 :
4789 :
4790 : /**
4791 : * The attribute transition is optional. Return true if this attribute exists.
4792 : * @return true if and only if the transition attribute exists.
4793 : */
4794 16442 : bool SourceRow::isTransitionExists() const {
4795 16442 : return transitionExists;
4796 : }
4797 :
4798 :
4799 :
4800 : /**
4801 : * Get transition, which is optional.
4802 : * @return transition as std::vector<std::string >
4803 : * @throw IllegalAccessException If transition does not exist.
4804 : */
4805 2416 : std::vector<std::string > SourceRow::getTransition() const {
4806 2416 : if (!transitionExists) {
4807 0 : throw IllegalAccessException("transition", "Source");
4808 : }
4809 :
4810 2416 : return transition;
4811 : }
4812 :
4813 : /**
4814 : * Set transition with the specified std::vector<std::string >.
4815 : * @param transition The std::vector<std::string > value to which transition is to be set.
4816 :
4817 :
4818 : */
4819 1208 : void SourceRow::setTransition (std::vector<std::string > transition) {
4820 :
4821 1208 : this->transition = transition;
4822 :
4823 1208 : transitionExists = true;
4824 :
4825 1208 : }
4826 :
4827 :
4828 : /**
4829 : * Mark transition, which is an optional field, as non-existent.
4830 : */
4831 0 : void SourceRow::clearTransition () {
4832 0 : transitionExists = false;
4833 0 : }
4834 :
4835 :
4836 :
4837 : /**
4838 : * The attribute restFrequency is optional. Return true if this attribute exists.
4839 : * @return true if and only if the restFrequency attribute exists.
4840 : */
4841 16442 : bool SourceRow::isRestFrequencyExists() const {
4842 16442 : return restFrequencyExists;
4843 : }
4844 :
4845 :
4846 :
4847 : /**
4848 : * Get restFrequency, which is optional.
4849 : * @return restFrequency as std::vector<Frequency >
4850 : * @throw IllegalAccessException If restFrequency does not exist.
4851 : */
4852 3264 : std::vector<Frequency > SourceRow::getRestFrequency() const {
4853 3264 : if (!restFrequencyExists) {
4854 0 : throw IllegalAccessException("restFrequency", "Source");
4855 : }
4856 :
4857 3264 : return restFrequency;
4858 : }
4859 :
4860 : /**
4861 : * Set restFrequency with the specified std::vector<Frequency >.
4862 : * @param restFrequency The std::vector<Frequency > value to which restFrequency is to be set.
4863 :
4864 :
4865 : */
4866 1632 : void SourceRow::setRestFrequency (std::vector<Frequency > restFrequency) {
4867 :
4868 1632 : this->restFrequency = restFrequency;
4869 :
4870 1632 : restFrequencyExists = true;
4871 :
4872 1632 : }
4873 :
4874 :
4875 : /**
4876 : * Mark restFrequency, which is an optional field, as non-existent.
4877 : */
4878 0 : void SourceRow::clearRestFrequency () {
4879 0 : restFrequencyExists = false;
4880 0 : }
4881 :
4882 :
4883 :
4884 : /**
4885 : * The attribute sysVel is optional. Return true if this attribute exists.
4886 : * @return true if and only if the sysVel attribute exists.
4887 : */
4888 16442 : bool SourceRow::isSysVelExists() const {
4889 16442 : return sysVelExists;
4890 : }
4891 :
4892 :
4893 :
4894 : /**
4895 : * Get sysVel, which is optional.
4896 : * @return sysVel as std::vector<Speed >
4897 : * @throw IllegalAccessException If sysVel does not exist.
4898 : */
4899 3264 : std::vector<Speed > SourceRow::getSysVel() const {
4900 3264 : if (!sysVelExists) {
4901 0 : throw IllegalAccessException("sysVel", "Source");
4902 : }
4903 :
4904 3264 : return sysVel;
4905 : }
4906 :
4907 : /**
4908 : * Set sysVel with the specified std::vector<Speed >.
4909 : * @param sysVel The std::vector<Speed > value to which sysVel is to be set.
4910 :
4911 :
4912 : */
4913 1632 : void SourceRow::setSysVel (std::vector<Speed > sysVel) {
4914 :
4915 1632 : this->sysVel = sysVel;
4916 :
4917 1632 : sysVelExists = true;
4918 :
4919 1632 : }
4920 :
4921 :
4922 : /**
4923 : * Mark sysVel, which is an optional field, as non-existent.
4924 : */
4925 0 : void SourceRow::clearSysVel () {
4926 0 : sysVelExists = false;
4927 0 : }
4928 :
4929 :
4930 :
4931 : /**
4932 : * The attribute rangeVel is optional. Return true if this attribute exists.
4933 : * @return true if and only if the rangeVel attribute exists.
4934 : */
4935 0 : bool SourceRow::isRangeVelExists() const {
4936 0 : return rangeVelExists;
4937 : }
4938 :
4939 :
4940 :
4941 : /**
4942 : * Get rangeVel, which is optional.
4943 : * @return rangeVel as std::vector<Speed >
4944 : * @throw IllegalAccessException If rangeVel does not exist.
4945 : */
4946 0 : std::vector<Speed > SourceRow::getRangeVel() const {
4947 0 : if (!rangeVelExists) {
4948 0 : throw IllegalAccessException("rangeVel", "Source");
4949 : }
4950 :
4951 0 : return rangeVel;
4952 : }
4953 :
4954 : /**
4955 : * Set rangeVel with the specified std::vector<Speed >.
4956 : * @param rangeVel The std::vector<Speed > value to which rangeVel is to be set.
4957 :
4958 :
4959 : */
4960 0 : void SourceRow::setRangeVel (std::vector<Speed > rangeVel) {
4961 :
4962 0 : this->rangeVel = rangeVel;
4963 :
4964 0 : rangeVelExists = true;
4965 :
4966 0 : }
4967 :
4968 :
4969 : /**
4970 : * Mark rangeVel, which is an optional field, as non-existent.
4971 : */
4972 0 : void SourceRow::clearRangeVel () {
4973 0 : rangeVelExists = false;
4974 0 : }
4975 :
4976 :
4977 :
4978 : /**
4979 : * The attribute sourceModel is optional. Return true if this attribute exists.
4980 : * @return true if and only if the sourceModel attribute exists.
4981 : */
4982 0 : bool SourceRow::isSourceModelExists() const {
4983 0 : return sourceModelExists;
4984 : }
4985 :
4986 :
4987 :
4988 : /**
4989 : * Get sourceModel, which is optional.
4990 : * @return sourceModel as SourceModelMod::SourceModel
4991 : * @throw IllegalAccessException If sourceModel does not exist.
4992 : */
4993 0 : SourceModelMod::SourceModel SourceRow::getSourceModel() const {
4994 0 : if (!sourceModelExists) {
4995 0 : throw IllegalAccessException("sourceModel", "Source");
4996 : }
4997 :
4998 0 : return sourceModel;
4999 : }
5000 :
5001 : /**
5002 : * Set sourceModel with the specified SourceModelMod::SourceModel.
5003 : * @param sourceModel The SourceModelMod::SourceModel value to which sourceModel is to be set.
5004 :
5005 :
5006 : */
5007 0 : void SourceRow::setSourceModel (SourceModelMod::SourceModel sourceModel) {
5008 :
5009 0 : this->sourceModel = sourceModel;
5010 :
5011 0 : sourceModelExists = true;
5012 :
5013 0 : }
5014 :
5015 :
5016 : /**
5017 : * Mark sourceModel, which is an optional field, as non-existent.
5018 : */
5019 0 : void SourceRow::clearSourceModel () {
5020 0 : sourceModelExists = false;
5021 0 : }
5022 :
5023 :
5024 :
5025 : /**
5026 : * The attribute frequencyRefCode is optional. Return true if this attribute exists.
5027 : * @return true if and only if the frequencyRefCode attribute exists.
5028 : */
5029 0 : bool SourceRow::isFrequencyRefCodeExists() const {
5030 0 : return frequencyRefCodeExists;
5031 : }
5032 :
5033 :
5034 :
5035 : /**
5036 : * Get frequencyRefCode, which is optional.
5037 : * @return frequencyRefCode as FrequencyReferenceCodeMod::FrequencyReferenceCode
5038 : * @throw IllegalAccessException If frequencyRefCode does not exist.
5039 : */
5040 0 : FrequencyReferenceCodeMod::FrequencyReferenceCode SourceRow::getFrequencyRefCode() const {
5041 0 : if (!frequencyRefCodeExists) {
5042 0 : throw IllegalAccessException("frequencyRefCode", "Source");
5043 : }
5044 :
5045 0 : return frequencyRefCode;
5046 : }
5047 :
5048 : /**
5049 : * Set frequencyRefCode with the specified FrequencyReferenceCodeMod::FrequencyReferenceCode.
5050 : * @param frequencyRefCode The FrequencyReferenceCodeMod::FrequencyReferenceCode value to which frequencyRefCode is to be set.
5051 :
5052 :
5053 : */
5054 0 : void SourceRow::setFrequencyRefCode (FrequencyReferenceCodeMod::FrequencyReferenceCode frequencyRefCode) {
5055 :
5056 0 : this->frequencyRefCode = frequencyRefCode;
5057 :
5058 0 : frequencyRefCodeExists = true;
5059 :
5060 0 : }
5061 :
5062 :
5063 : /**
5064 : * Mark frequencyRefCode, which is an optional field, as non-existent.
5065 : */
5066 0 : void SourceRow::clearFrequencyRefCode () {
5067 0 : frequencyRefCodeExists = false;
5068 0 : }
5069 :
5070 :
5071 :
5072 : /**
5073 : * The attribute numFreq is optional. Return true if this attribute exists.
5074 : * @return true if and only if the numFreq attribute exists.
5075 : */
5076 0 : bool SourceRow::isNumFreqExists() const {
5077 0 : return numFreqExists;
5078 : }
5079 :
5080 :
5081 :
5082 : /**
5083 : * Get numFreq, which is optional.
5084 : * @return numFreq as int
5085 : * @throw IllegalAccessException If numFreq does not exist.
5086 : */
5087 0 : int SourceRow::getNumFreq() const {
5088 0 : if (!numFreqExists) {
5089 0 : throw IllegalAccessException("numFreq", "Source");
5090 : }
5091 :
5092 0 : return numFreq;
5093 : }
5094 :
5095 : /**
5096 : * Set numFreq with the specified int.
5097 : * @param numFreq The int value to which numFreq is to be set.
5098 :
5099 :
5100 : */
5101 2963 : void SourceRow::setNumFreq (int numFreq) {
5102 :
5103 2963 : this->numFreq = numFreq;
5104 :
5105 2963 : numFreqExists = true;
5106 :
5107 2963 : }
5108 :
5109 :
5110 : /**
5111 : * Mark numFreq, which is an optional field, as non-existent.
5112 : */
5113 0 : void SourceRow::clearNumFreq () {
5114 0 : numFreqExists = false;
5115 0 : }
5116 :
5117 :
5118 :
5119 : /**
5120 : * The attribute numStokes is optional. Return true if this attribute exists.
5121 : * @return true if and only if the numStokes attribute exists.
5122 : */
5123 0 : bool SourceRow::isNumStokesExists() const {
5124 0 : return numStokesExists;
5125 : }
5126 :
5127 :
5128 :
5129 : /**
5130 : * Get numStokes, which is optional.
5131 : * @return numStokes as int
5132 : * @throw IllegalAccessException If numStokes does not exist.
5133 : */
5134 0 : int SourceRow::getNumStokes() const {
5135 0 : if (!numStokesExists) {
5136 0 : throw IllegalAccessException("numStokes", "Source");
5137 : }
5138 :
5139 0 : return numStokes;
5140 : }
5141 :
5142 : /**
5143 : * Set numStokes with the specified int.
5144 : * @param numStokes The int value to which numStokes is to be set.
5145 :
5146 :
5147 : */
5148 2963 : void SourceRow::setNumStokes (int numStokes) {
5149 :
5150 2963 : this->numStokes = numStokes;
5151 :
5152 2963 : numStokesExists = true;
5153 :
5154 2963 : }
5155 :
5156 :
5157 : /**
5158 : * Mark numStokes, which is an optional field, as non-existent.
5159 : */
5160 0 : void SourceRow::clearNumStokes () {
5161 0 : numStokesExists = false;
5162 0 : }
5163 :
5164 :
5165 :
5166 : /**
5167 : * The attribute frequency is optional. Return true if this attribute exists.
5168 : * @return true if and only if the frequency attribute exists.
5169 : */
5170 0 : bool SourceRow::isFrequencyExists() const {
5171 0 : return frequencyExists;
5172 : }
5173 :
5174 :
5175 :
5176 : /**
5177 : * Get frequency, which is optional.
5178 : * @return frequency as std::vector<Frequency >
5179 : * @throw IllegalAccessException If frequency does not exist.
5180 : */
5181 0 : std::vector<Frequency > SourceRow::getFrequency() const {
5182 0 : if (!frequencyExists) {
5183 0 : throw IllegalAccessException("frequency", "Source");
5184 : }
5185 :
5186 0 : return frequency;
5187 : }
5188 :
5189 : /**
5190 : * Set frequency with the specified std::vector<Frequency >.
5191 : * @param frequency The std::vector<Frequency > value to which frequency is to be set.
5192 :
5193 :
5194 : */
5195 2963 : void SourceRow::setFrequency (std::vector<Frequency > frequency) {
5196 :
5197 2963 : this->frequency = frequency;
5198 :
5199 2963 : frequencyExists = true;
5200 :
5201 2963 : }
5202 :
5203 :
5204 : /**
5205 : * Mark frequency, which is an optional field, as non-existent.
5206 : */
5207 0 : void SourceRow::clearFrequency () {
5208 0 : frequencyExists = false;
5209 0 : }
5210 :
5211 :
5212 :
5213 : /**
5214 : * The attribute frequencyInterval is optional. Return true if this attribute exists.
5215 : * @return true if and only if the frequencyInterval attribute exists.
5216 : */
5217 0 : bool SourceRow::isFrequencyIntervalExists() const {
5218 0 : return frequencyIntervalExists;
5219 : }
5220 :
5221 :
5222 :
5223 : /**
5224 : * Get frequencyInterval, which is optional.
5225 : * @return frequencyInterval as std::vector<Frequency >
5226 : * @throw IllegalAccessException If frequencyInterval does not exist.
5227 : */
5228 0 : std::vector<Frequency > SourceRow::getFrequencyInterval() const {
5229 0 : if (!frequencyIntervalExists) {
5230 0 : throw IllegalAccessException("frequencyInterval", "Source");
5231 : }
5232 :
5233 0 : return frequencyInterval;
5234 : }
5235 :
5236 : /**
5237 : * Set frequencyInterval with the specified std::vector<Frequency >.
5238 : * @param frequencyInterval The std::vector<Frequency > value to which frequencyInterval is to be set.
5239 :
5240 :
5241 : */
5242 0 : void SourceRow::setFrequencyInterval (std::vector<Frequency > frequencyInterval) {
5243 :
5244 0 : this->frequencyInterval = frequencyInterval;
5245 :
5246 0 : frequencyIntervalExists = true;
5247 :
5248 0 : }
5249 :
5250 :
5251 : /**
5252 : * Mark frequencyInterval, which is an optional field, as non-existent.
5253 : */
5254 0 : void SourceRow::clearFrequencyInterval () {
5255 0 : frequencyIntervalExists = false;
5256 0 : }
5257 :
5258 :
5259 :
5260 : /**
5261 : * The attribute stokesParameter is optional. Return true if this attribute exists.
5262 : * @return true if and only if the stokesParameter attribute exists.
5263 : */
5264 0 : bool SourceRow::isStokesParameterExists() const {
5265 0 : return stokesParameterExists;
5266 : }
5267 :
5268 :
5269 :
5270 : /**
5271 : * Get stokesParameter, which is optional.
5272 : * @return stokesParameter as std::vector<StokesParameterMod::StokesParameter >
5273 : * @throw IllegalAccessException If stokesParameter does not exist.
5274 : */
5275 0 : std::vector<StokesParameterMod::StokesParameter > SourceRow::getStokesParameter() const {
5276 0 : if (!stokesParameterExists) {
5277 0 : throw IllegalAccessException("stokesParameter", "Source");
5278 : }
5279 :
5280 0 : return stokesParameter;
5281 : }
5282 :
5283 : /**
5284 : * Set stokesParameter with the specified std::vector<StokesParameterMod::StokesParameter >.
5285 : * @param stokesParameter The std::vector<StokesParameterMod::StokesParameter > value to which stokesParameter is to be set.
5286 :
5287 :
5288 : */
5289 0 : void SourceRow::setStokesParameter (std::vector<StokesParameterMod::StokesParameter > stokesParameter) {
5290 :
5291 0 : this->stokesParameter = stokesParameter;
5292 :
5293 0 : stokesParameterExists = true;
5294 :
5295 0 : }
5296 :
5297 :
5298 : /**
5299 : * Mark stokesParameter, which is an optional field, as non-existent.
5300 : */
5301 0 : void SourceRow::clearStokesParameter () {
5302 0 : stokesParameterExists = false;
5303 0 : }
5304 :
5305 :
5306 :
5307 : /**
5308 : * The attribute flux is optional. Return true if this attribute exists.
5309 : * @return true if and only if the flux attribute exists.
5310 : */
5311 0 : bool SourceRow::isFluxExists() const {
5312 0 : return fluxExists;
5313 : }
5314 :
5315 :
5316 :
5317 : /**
5318 : * Get flux, which is optional.
5319 : * @return flux as std::vector<std::vector<Flux > >
5320 : * @throw IllegalAccessException If flux does not exist.
5321 : */
5322 0 : std::vector<std::vector<Flux > > SourceRow::getFlux() const {
5323 0 : if (!fluxExists) {
5324 0 : throw IllegalAccessException("flux", "Source");
5325 : }
5326 :
5327 0 : return flux;
5328 : }
5329 :
5330 : /**
5331 : * Set flux with the specified std::vector<std::vector<Flux > >.
5332 : * @param flux The std::vector<std::vector<Flux > > value to which flux is to be set.
5333 :
5334 :
5335 : */
5336 2963 : void SourceRow::setFlux (std::vector<std::vector<Flux > > flux) {
5337 :
5338 2963 : this->flux = flux;
5339 :
5340 2963 : fluxExists = true;
5341 :
5342 2963 : }
5343 :
5344 :
5345 : /**
5346 : * Mark flux, which is an optional field, as non-existent.
5347 : */
5348 0 : void SourceRow::clearFlux () {
5349 0 : fluxExists = false;
5350 0 : }
5351 :
5352 :
5353 :
5354 : /**
5355 : * The attribute fluxErr is optional. Return true if this attribute exists.
5356 : * @return true if and only if the fluxErr attribute exists.
5357 : */
5358 0 : bool SourceRow::isFluxErrExists() const {
5359 0 : return fluxErrExists;
5360 : }
5361 :
5362 :
5363 :
5364 : /**
5365 : * Get fluxErr, which is optional.
5366 : * @return fluxErr as std::vector<std::vector<Flux > >
5367 : * @throw IllegalAccessException If fluxErr does not exist.
5368 : */
5369 0 : std::vector<std::vector<Flux > > SourceRow::getFluxErr() const {
5370 0 : if (!fluxErrExists) {
5371 0 : throw IllegalAccessException("fluxErr", "Source");
5372 : }
5373 :
5374 0 : return fluxErr;
5375 : }
5376 :
5377 : /**
5378 : * Set fluxErr with the specified std::vector<std::vector<Flux > >.
5379 : * @param fluxErr The std::vector<std::vector<Flux > > value to which fluxErr is to be set.
5380 :
5381 :
5382 : */
5383 0 : void SourceRow::setFluxErr (std::vector<std::vector<Flux > > fluxErr) {
5384 :
5385 0 : this->fluxErr = fluxErr;
5386 :
5387 0 : fluxErrExists = true;
5388 :
5389 0 : }
5390 :
5391 :
5392 : /**
5393 : * Mark fluxErr, which is an optional field, as non-existent.
5394 : */
5395 0 : void SourceRow::clearFluxErr () {
5396 0 : fluxErrExists = false;
5397 0 : }
5398 :
5399 :
5400 :
5401 : /**
5402 : * The attribute positionAngle is optional. Return true if this attribute exists.
5403 : * @return true if and only if the positionAngle attribute exists.
5404 : */
5405 0 : bool SourceRow::isPositionAngleExists() const {
5406 0 : return positionAngleExists;
5407 : }
5408 :
5409 :
5410 :
5411 : /**
5412 : * Get positionAngle, which is optional.
5413 : * @return positionAngle as std::vector<Angle >
5414 : * @throw IllegalAccessException If positionAngle does not exist.
5415 : */
5416 0 : std::vector<Angle > SourceRow::getPositionAngle() const {
5417 0 : if (!positionAngleExists) {
5418 0 : throw IllegalAccessException("positionAngle", "Source");
5419 : }
5420 :
5421 0 : return positionAngle;
5422 : }
5423 :
5424 : /**
5425 : * Set positionAngle with the specified std::vector<Angle >.
5426 : * @param positionAngle The std::vector<Angle > value to which positionAngle is to be set.
5427 :
5428 :
5429 : */
5430 0 : void SourceRow::setPositionAngle (std::vector<Angle > positionAngle) {
5431 :
5432 0 : this->positionAngle = positionAngle;
5433 :
5434 0 : positionAngleExists = true;
5435 :
5436 0 : }
5437 :
5438 :
5439 : /**
5440 : * Mark positionAngle, which is an optional field, as non-existent.
5441 : */
5442 0 : void SourceRow::clearPositionAngle () {
5443 0 : positionAngleExists = false;
5444 0 : }
5445 :
5446 :
5447 :
5448 : /**
5449 : * The attribute positionAngleErr is optional. Return true if this attribute exists.
5450 : * @return true if and only if the positionAngleErr attribute exists.
5451 : */
5452 0 : bool SourceRow::isPositionAngleErrExists() const {
5453 0 : return positionAngleErrExists;
5454 : }
5455 :
5456 :
5457 :
5458 : /**
5459 : * Get positionAngleErr, which is optional.
5460 : * @return positionAngleErr as std::vector<Angle >
5461 : * @throw IllegalAccessException If positionAngleErr does not exist.
5462 : */
5463 0 : std::vector<Angle > SourceRow::getPositionAngleErr() const {
5464 0 : if (!positionAngleErrExists) {
5465 0 : throw IllegalAccessException("positionAngleErr", "Source");
5466 : }
5467 :
5468 0 : return positionAngleErr;
5469 : }
5470 :
5471 : /**
5472 : * Set positionAngleErr with the specified std::vector<Angle >.
5473 : * @param positionAngleErr The std::vector<Angle > value to which positionAngleErr is to be set.
5474 :
5475 :
5476 : */
5477 0 : void SourceRow::setPositionAngleErr (std::vector<Angle > positionAngleErr) {
5478 :
5479 0 : this->positionAngleErr = positionAngleErr;
5480 :
5481 0 : positionAngleErrExists = true;
5482 :
5483 0 : }
5484 :
5485 :
5486 : /**
5487 : * Mark positionAngleErr, which is an optional field, as non-existent.
5488 : */
5489 0 : void SourceRow::clearPositionAngleErr () {
5490 0 : positionAngleErrExists = false;
5491 0 : }
5492 :
5493 :
5494 :
5495 : /**
5496 : * The attribute size is optional. Return true if this attribute exists.
5497 : * @return true if and only if the size attribute exists.
5498 : */
5499 0 : bool SourceRow::isSizeExists() const {
5500 0 : return sizeExists;
5501 : }
5502 :
5503 :
5504 :
5505 : /**
5506 : * Get size, which is optional.
5507 : * @return size as std::vector<std::vector<Angle > >
5508 : * @throw IllegalAccessException If size does not exist.
5509 : */
5510 0 : std::vector<std::vector<Angle > > SourceRow::getSize() const {
5511 0 : if (!sizeExists) {
5512 0 : throw IllegalAccessException("size", "Source");
5513 : }
5514 :
5515 0 : return size;
5516 : }
5517 :
5518 : /**
5519 : * Set size with the specified std::vector<std::vector<Angle > >.
5520 : * @param size The std::vector<std::vector<Angle > > value to which size is to be set.
5521 :
5522 :
5523 : */
5524 2963 : void SourceRow::setSize (std::vector<std::vector<Angle > > size) {
5525 :
5526 2963 : this->size = size;
5527 :
5528 2963 : sizeExists = true;
5529 :
5530 2963 : }
5531 :
5532 :
5533 : /**
5534 : * Mark size, which is an optional field, as non-existent.
5535 : */
5536 0 : void SourceRow::clearSize () {
5537 0 : sizeExists = false;
5538 0 : }
5539 :
5540 :
5541 :
5542 : /**
5543 : * The attribute sizeErr is optional. Return true if this attribute exists.
5544 : * @return true if and only if the sizeErr attribute exists.
5545 : */
5546 0 : bool SourceRow::isSizeErrExists() const {
5547 0 : return sizeErrExists;
5548 : }
5549 :
5550 :
5551 :
5552 : /**
5553 : * Get sizeErr, which is optional.
5554 : * @return sizeErr as std::vector<std::vector<Angle > >
5555 : * @throw IllegalAccessException If sizeErr does not exist.
5556 : */
5557 0 : std::vector<std::vector<Angle > > SourceRow::getSizeErr() const {
5558 0 : if (!sizeErrExists) {
5559 0 : throw IllegalAccessException("sizeErr", "Source");
5560 : }
5561 :
5562 0 : return sizeErr;
5563 : }
5564 :
5565 : /**
5566 : * Set sizeErr with the specified std::vector<std::vector<Angle > >.
5567 : * @param sizeErr The std::vector<std::vector<Angle > > value to which sizeErr is to be set.
5568 :
5569 :
5570 : */
5571 0 : void SourceRow::setSizeErr (std::vector<std::vector<Angle > > sizeErr) {
5572 :
5573 0 : this->sizeErr = sizeErr;
5574 :
5575 0 : sizeErrExists = true;
5576 :
5577 0 : }
5578 :
5579 :
5580 : /**
5581 : * Mark sizeErr, which is an optional field, as non-existent.
5582 : */
5583 0 : void SourceRow::clearSizeErr () {
5584 0 : sizeErrExists = false;
5585 0 : }
5586 :
5587 :
5588 :
5589 : /**
5590 : * The attribute velRefCode is optional. Return true if this attribute exists.
5591 : * @return true if and only if the velRefCode attribute exists.
5592 : */
5593 0 : bool SourceRow::isVelRefCodeExists() const {
5594 0 : return velRefCodeExists;
5595 : }
5596 :
5597 :
5598 :
5599 : /**
5600 : * Get velRefCode, which is optional.
5601 : * @return velRefCode as RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode
5602 : * @throw IllegalAccessException If velRefCode does not exist.
5603 : */
5604 0 : RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode SourceRow::getVelRefCode() const {
5605 0 : if (!velRefCodeExists) {
5606 0 : throw IllegalAccessException("velRefCode", "Source");
5607 : }
5608 :
5609 0 : return velRefCode;
5610 : }
5611 :
5612 : /**
5613 : * Set velRefCode with the specified RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode.
5614 : * @param velRefCode The RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode value to which velRefCode is to be set.
5615 :
5616 :
5617 : */
5618 0 : void SourceRow::setVelRefCode (RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode velRefCode) {
5619 :
5620 0 : this->velRefCode = velRefCode;
5621 :
5622 0 : velRefCodeExists = true;
5623 :
5624 0 : }
5625 :
5626 :
5627 : /**
5628 : * Mark velRefCode, which is an optional field, as non-existent.
5629 : */
5630 0 : void SourceRow::clearVelRefCode () {
5631 0 : velRefCodeExists = false;
5632 0 : }
5633 :
5634 :
5635 :
5636 : /**
5637 : * The attribute dopplerVelocity is optional. Return true if this attribute exists.
5638 : * @return true if and only if the dopplerVelocity attribute exists.
5639 : */
5640 0 : bool SourceRow::isDopplerVelocityExists() const {
5641 0 : return dopplerVelocityExists;
5642 : }
5643 :
5644 :
5645 :
5646 : /**
5647 : * Get dopplerVelocity, which is optional.
5648 : * @return dopplerVelocity as std::vector<Speed >
5649 : * @throw IllegalAccessException If dopplerVelocity does not exist.
5650 : */
5651 0 : std::vector<Speed > SourceRow::getDopplerVelocity() const {
5652 0 : if (!dopplerVelocityExists) {
5653 0 : throw IllegalAccessException("dopplerVelocity", "Source");
5654 : }
5655 :
5656 0 : return dopplerVelocity;
5657 : }
5658 :
5659 : /**
5660 : * Set dopplerVelocity with the specified std::vector<Speed >.
5661 : * @param dopplerVelocity The std::vector<Speed > value to which dopplerVelocity is to be set.
5662 :
5663 :
5664 : */
5665 0 : void SourceRow::setDopplerVelocity (std::vector<Speed > dopplerVelocity) {
5666 :
5667 0 : this->dopplerVelocity = dopplerVelocity;
5668 :
5669 0 : dopplerVelocityExists = true;
5670 :
5671 0 : }
5672 :
5673 :
5674 : /**
5675 : * Mark dopplerVelocity, which is an optional field, as non-existent.
5676 : */
5677 0 : void SourceRow::clearDopplerVelocity () {
5678 0 : dopplerVelocityExists = false;
5679 0 : }
5680 :
5681 :
5682 :
5683 : /**
5684 : * The attribute dopplerReferenceSystem is optional. Return true if this attribute exists.
5685 : * @return true if and only if the dopplerReferenceSystem attribute exists.
5686 : */
5687 0 : bool SourceRow::isDopplerReferenceSystemExists() const {
5688 0 : return dopplerReferenceSystemExists;
5689 : }
5690 :
5691 :
5692 :
5693 : /**
5694 : * Get dopplerReferenceSystem, which is optional.
5695 : * @return dopplerReferenceSystem as RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode
5696 : * @throw IllegalAccessException If dopplerReferenceSystem does not exist.
5697 : */
5698 0 : RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode SourceRow::getDopplerReferenceSystem() const {
5699 0 : if (!dopplerReferenceSystemExists) {
5700 0 : throw IllegalAccessException("dopplerReferenceSystem", "Source");
5701 : }
5702 :
5703 0 : return dopplerReferenceSystem;
5704 : }
5705 :
5706 : /**
5707 : * Set dopplerReferenceSystem with the specified RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode.
5708 : * @param dopplerReferenceSystem The RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode value to which dopplerReferenceSystem is to be set.
5709 :
5710 :
5711 : */
5712 0 : void SourceRow::setDopplerReferenceSystem (RadialVelocityReferenceCodeMod::RadialVelocityReferenceCode dopplerReferenceSystem) {
5713 :
5714 0 : this->dopplerReferenceSystem = dopplerReferenceSystem;
5715 :
5716 0 : dopplerReferenceSystemExists = true;
5717 :
5718 0 : }
5719 :
5720 :
5721 : /**
5722 : * Mark dopplerReferenceSystem, which is an optional field, as non-existent.
5723 : */
5724 0 : void SourceRow::clearDopplerReferenceSystem () {
5725 0 : dopplerReferenceSystemExists = false;
5726 0 : }
5727 :
5728 :
5729 :
5730 : /**
5731 : * The attribute dopplerCalcType is optional. Return true if this attribute exists.
5732 : * @return true if and only if the dopplerCalcType attribute exists.
5733 : */
5734 0 : bool SourceRow::isDopplerCalcTypeExists() const {
5735 0 : return dopplerCalcTypeExists;
5736 : }
5737 :
5738 :
5739 :
5740 : /**
5741 : * Get dopplerCalcType, which is optional.
5742 : * @return dopplerCalcType as DopplerReferenceCodeMod::DopplerReferenceCode
5743 : * @throw IllegalAccessException If dopplerCalcType does not exist.
5744 : */
5745 0 : DopplerReferenceCodeMod::DopplerReferenceCode SourceRow::getDopplerCalcType() const {
5746 0 : if (!dopplerCalcTypeExists) {
5747 0 : throw IllegalAccessException("dopplerCalcType", "Source");
5748 : }
5749 :
5750 0 : return dopplerCalcType;
5751 : }
5752 :
5753 : /**
5754 : * Set dopplerCalcType with the specified DopplerReferenceCodeMod::DopplerReferenceCode.
5755 : * @param dopplerCalcType The DopplerReferenceCodeMod::DopplerReferenceCode value to which dopplerCalcType is to be set.
5756 :
5757 :
5758 : */
5759 0 : void SourceRow::setDopplerCalcType (DopplerReferenceCodeMod::DopplerReferenceCode dopplerCalcType) {
5760 :
5761 0 : this->dopplerCalcType = dopplerCalcType;
5762 :
5763 0 : dopplerCalcTypeExists = true;
5764 :
5765 0 : }
5766 :
5767 :
5768 : /**
5769 : * Mark dopplerCalcType, which is an optional field, as non-existent.
5770 : */
5771 0 : void SourceRow::clearDopplerCalcType () {
5772 0 : dopplerCalcTypeExists = false;
5773 0 : }
5774 :
5775 :
5776 :
5777 : /**
5778 : * The attribute parallax is optional. Return true if this attribute exists.
5779 : * @return true if and only if the parallax attribute exists.
5780 : */
5781 0 : bool SourceRow::isParallaxExists() const {
5782 0 : return parallaxExists;
5783 : }
5784 :
5785 :
5786 :
5787 : /**
5788 : * Get parallax, which is optional.
5789 : * @return parallax as std::vector<Angle >
5790 : * @throw IllegalAccessException If parallax does not exist.
5791 : */
5792 0 : std::vector<Angle > SourceRow::getParallax() const {
5793 0 : if (!parallaxExists) {
5794 0 : throw IllegalAccessException("parallax", "Source");
5795 : }
5796 :
5797 0 : return parallax;
5798 : }
5799 :
5800 : /**
5801 : * Set parallax with the specified std::vector<Angle >.
5802 : * @param parallax The std::vector<Angle > value to which parallax is to be set.
5803 :
5804 :
5805 : */
5806 0 : void SourceRow::setParallax (std::vector<Angle > parallax) {
5807 :
5808 0 : this->parallax = parallax;
5809 :
5810 0 : parallaxExists = true;
5811 :
5812 0 : }
5813 :
5814 :
5815 : /**
5816 : * Mark parallax, which is an optional field, as non-existent.
5817 : */
5818 0 : void SourceRow::clearParallax () {
5819 0 : parallaxExists = false;
5820 0 : }
5821 :
5822 :
5823 :
5824 : ///////////////////////////////////////////////
5825 : // Extrinsic Table Attributes getters/setters//
5826 : ///////////////////////////////////////////////
5827 :
5828 :
5829 :
5830 :
5831 : /**
5832 : * Get spectralWindowId.
5833 : * @return spectralWindowId as Tag
5834 : */
5835 17085 : Tag SourceRow::getSpectralWindowId() const {
5836 :
5837 17085 : return spectralWindowId;
5838 : }
5839 :
5840 : /**
5841 : * Set spectralWindowId with the specified Tag.
5842 : * @param spectralWindowId The Tag value to which spectralWindowId is to be set.
5843 :
5844 :
5845 :
5846 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
5847 :
5848 : */
5849 8864 : void SourceRow::setSpectralWindowId (Tag spectralWindowId) {
5850 :
5851 :
5852 8864 : if (hasBeenAdded) {
5853 :
5854 0 : throw IllegalAccessException("spectralWindowId", "Source");
5855 :
5856 : }
5857 :
5858 8864 : this->spectralWindowId = spectralWindowId;
5859 :
5860 8864 : }
5861 :
5862 :
5863 :
5864 :
5865 : //////////////////////////////////////
5866 : // Links Attributes getters/setters //
5867 : //////////////////////////////////////
5868 :
5869 :
5870 :
5871 :
5872 :
5873 :
5874 : /**
5875 : * Returns the pointer to the row in the SpectralWindow table having SpectralWindow.spectralWindowId == spectralWindowId
5876 : * @return a SpectralWindowRow*
5877 : *
5878 :
5879 : */
5880 0 : SpectralWindowRow* SourceRow::getSpectralWindowUsingSpectralWindowId() {
5881 :
5882 0 : return table.getContainer().getSpectralWindow().getRowByKey(spectralWindowId);
5883 : }
5884 :
5885 :
5886 :
5887 :
5888 :
5889 : /**
5890 : * Create a SourceRow.
5891 : * <p>
5892 : * This constructor is private because only the
5893 : * table can create rows. All rows know the table
5894 : * to which they belong.
5895 : * @param table The table to which this row belongs.
5896 : */
5897 8864 : SourceRow::SourceRow (SourceTable &t) : table(t) {
5898 8864 : hasBeenAdded = false;
5899 :
5900 :
5901 :
5902 :
5903 :
5904 :
5905 :
5906 :
5907 :
5908 :
5909 :
5910 :
5911 :
5912 :
5913 :
5914 8864 : directionCodeExists = false;
5915 :
5916 :
5917 :
5918 8864 : directionEquinoxExists = false;
5919 :
5920 :
5921 :
5922 8864 : calibrationGroupExists = false;
5923 :
5924 :
5925 :
5926 8864 : catalogExists = false;
5927 :
5928 :
5929 :
5930 8864 : deltaVelExists = false;
5931 :
5932 :
5933 :
5934 8864 : positionExists = false;
5935 :
5936 :
5937 :
5938 8864 : numLinesExists = false;
5939 :
5940 :
5941 :
5942 8864 : transitionExists = false;
5943 :
5944 :
5945 :
5946 8864 : restFrequencyExists = false;
5947 :
5948 :
5949 :
5950 8864 : sysVelExists = false;
5951 :
5952 :
5953 :
5954 8864 : rangeVelExists = false;
5955 :
5956 :
5957 :
5958 8864 : sourceModelExists = false;
5959 :
5960 :
5961 :
5962 8864 : frequencyRefCodeExists = false;
5963 :
5964 :
5965 :
5966 8864 : numFreqExists = false;
5967 :
5968 :
5969 :
5970 8864 : numStokesExists = false;
5971 :
5972 :
5973 :
5974 8864 : frequencyExists = false;
5975 :
5976 :
5977 :
5978 8864 : frequencyIntervalExists = false;
5979 :
5980 :
5981 :
5982 8864 : stokesParameterExists = false;
5983 :
5984 :
5985 :
5986 8864 : fluxExists = false;
5987 :
5988 :
5989 :
5990 8864 : fluxErrExists = false;
5991 :
5992 :
5993 :
5994 8864 : positionAngleExists = false;
5995 :
5996 :
5997 :
5998 8864 : positionAngleErrExists = false;
5999 :
6000 :
6001 :
6002 8864 : sizeExists = false;
6003 :
6004 :
6005 :
6006 8864 : sizeErrExists = false;
6007 :
6008 :
6009 :
6010 8864 : velRefCodeExists = false;
6011 :
6012 :
6013 :
6014 8864 : dopplerVelocityExists = false;
6015 :
6016 :
6017 :
6018 8864 : dopplerReferenceSystemExists = false;
6019 :
6020 :
6021 :
6022 8864 : dopplerCalcTypeExists = false;
6023 :
6024 :
6025 :
6026 8864 : parallaxExists = false;
6027 :
6028 :
6029 :
6030 :
6031 :
6032 :
6033 :
6034 :
6035 :
6036 :
6037 :
6038 :
6039 :
6040 :
6041 :
6042 :
6043 :
6044 :
6045 :
6046 :
6047 :
6048 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
6049 8864 : directionCode = CDirectionReferenceCode::from_int(0);
6050 :
6051 :
6052 :
6053 :
6054 :
6055 :
6056 :
6057 :
6058 :
6059 :
6060 :
6061 :
6062 :
6063 :
6064 :
6065 :
6066 :
6067 :
6068 :
6069 :
6070 :
6071 :
6072 :
6073 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
6074 8864 : sourceModel = CSourceModel::from_int(0);
6075 :
6076 :
6077 :
6078 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
6079 8864 : frequencyRefCode = CFrequencyReferenceCode::from_int(0);
6080 :
6081 :
6082 :
6083 :
6084 :
6085 :
6086 :
6087 :
6088 :
6089 :
6090 :
6091 :
6092 :
6093 :
6094 :
6095 :
6096 :
6097 :
6098 :
6099 :
6100 :
6101 :
6102 :
6103 :
6104 :
6105 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
6106 8864 : velRefCode = CRadialVelocityReferenceCode::from_int(0);
6107 :
6108 :
6109 :
6110 :
6111 :
6112 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
6113 8864 : dopplerReferenceSystem = CRadialVelocityReferenceCode::from_int(0);
6114 :
6115 :
6116 :
6117 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
6118 8864 : dopplerCalcType = CDopplerReferenceCode::from_int(0);
6119 :
6120 :
6121 :
6122 :
6123 :
6124 :
6125 8864 : fromBinMethods["sourceId"] = &SourceRow::sourceIdFromBin;
6126 8864 : fromBinMethods["timeInterval"] = &SourceRow::timeIntervalFromBin;
6127 8864 : fromBinMethods["spectralWindowId"] = &SourceRow::spectralWindowIdFromBin;
6128 8864 : fromBinMethods["code"] = &SourceRow::codeFromBin;
6129 8864 : fromBinMethods["direction"] = &SourceRow::directionFromBin;
6130 8864 : fromBinMethods["properMotion"] = &SourceRow::properMotionFromBin;
6131 8864 : fromBinMethods["sourceName"] = &SourceRow::sourceNameFromBin;
6132 :
6133 :
6134 8864 : fromBinMethods["directionCode"] = &SourceRow::directionCodeFromBin;
6135 8864 : fromBinMethods["directionEquinox"] = &SourceRow::directionEquinoxFromBin;
6136 8864 : fromBinMethods["calibrationGroup"] = &SourceRow::calibrationGroupFromBin;
6137 8864 : fromBinMethods["catalog"] = &SourceRow::catalogFromBin;
6138 8864 : fromBinMethods["deltaVel"] = &SourceRow::deltaVelFromBin;
6139 8864 : fromBinMethods["position"] = &SourceRow::positionFromBin;
6140 8864 : fromBinMethods["numLines"] = &SourceRow::numLinesFromBin;
6141 8864 : fromBinMethods["transition"] = &SourceRow::transitionFromBin;
6142 8864 : fromBinMethods["restFrequency"] = &SourceRow::restFrequencyFromBin;
6143 8864 : fromBinMethods["sysVel"] = &SourceRow::sysVelFromBin;
6144 8864 : fromBinMethods["rangeVel"] = &SourceRow::rangeVelFromBin;
6145 8864 : fromBinMethods["sourceModel"] = &SourceRow::sourceModelFromBin;
6146 8864 : fromBinMethods["frequencyRefCode"] = &SourceRow::frequencyRefCodeFromBin;
6147 8864 : fromBinMethods["numFreq"] = &SourceRow::numFreqFromBin;
6148 8864 : fromBinMethods["numStokes"] = &SourceRow::numStokesFromBin;
6149 8864 : fromBinMethods["frequency"] = &SourceRow::frequencyFromBin;
6150 8864 : fromBinMethods["frequencyInterval"] = &SourceRow::frequencyIntervalFromBin;
6151 8864 : fromBinMethods["stokesParameter"] = &SourceRow::stokesParameterFromBin;
6152 8864 : fromBinMethods["flux"] = &SourceRow::fluxFromBin;
6153 8864 : fromBinMethods["fluxErr"] = &SourceRow::fluxErrFromBin;
6154 8864 : fromBinMethods["positionAngle"] = &SourceRow::positionAngleFromBin;
6155 8864 : fromBinMethods["positionAngleErr"] = &SourceRow::positionAngleErrFromBin;
6156 8864 : fromBinMethods["size"] = &SourceRow::sizeFromBin;
6157 8864 : fromBinMethods["sizeErr"] = &SourceRow::sizeErrFromBin;
6158 8864 : fromBinMethods["velRefCode"] = &SourceRow::velRefCodeFromBin;
6159 8864 : fromBinMethods["dopplerVelocity"] = &SourceRow::dopplerVelocityFromBin;
6160 8864 : fromBinMethods["dopplerReferenceSystem"] = &SourceRow::dopplerReferenceSystemFromBin;
6161 8864 : fromBinMethods["dopplerCalcType"] = &SourceRow::dopplerCalcTypeFromBin;
6162 8864 : fromBinMethods["parallax"] = &SourceRow::parallaxFromBin;
6163 :
6164 :
6165 :
6166 :
6167 :
6168 8864 : fromTextMethods["sourceId"] = &SourceRow::sourceIdFromText;
6169 :
6170 :
6171 :
6172 8864 : fromTextMethods["timeInterval"] = &SourceRow::timeIntervalFromText;
6173 :
6174 :
6175 :
6176 8864 : fromTextMethods["spectralWindowId"] = &SourceRow::spectralWindowIdFromText;
6177 :
6178 :
6179 :
6180 8864 : fromTextMethods["code"] = &SourceRow::codeFromText;
6181 :
6182 :
6183 :
6184 8864 : fromTextMethods["direction"] = &SourceRow::directionFromText;
6185 :
6186 :
6187 :
6188 8864 : fromTextMethods["properMotion"] = &SourceRow::properMotionFromText;
6189 :
6190 :
6191 :
6192 8864 : fromTextMethods["sourceName"] = &SourceRow::sourceNameFromText;
6193 :
6194 :
6195 :
6196 :
6197 :
6198 8864 : fromTextMethods["directionCode"] = &SourceRow::directionCodeFromText;
6199 :
6200 :
6201 :
6202 8864 : fromTextMethods["directionEquinox"] = &SourceRow::directionEquinoxFromText;
6203 :
6204 :
6205 :
6206 8864 : fromTextMethods["calibrationGroup"] = &SourceRow::calibrationGroupFromText;
6207 :
6208 :
6209 :
6210 8864 : fromTextMethods["catalog"] = &SourceRow::catalogFromText;
6211 :
6212 :
6213 :
6214 8864 : fromTextMethods["deltaVel"] = &SourceRow::deltaVelFromText;
6215 :
6216 :
6217 :
6218 8864 : fromTextMethods["position"] = &SourceRow::positionFromText;
6219 :
6220 :
6221 :
6222 8864 : fromTextMethods["numLines"] = &SourceRow::numLinesFromText;
6223 :
6224 :
6225 :
6226 8864 : fromTextMethods["transition"] = &SourceRow::transitionFromText;
6227 :
6228 :
6229 :
6230 8864 : fromTextMethods["restFrequency"] = &SourceRow::restFrequencyFromText;
6231 :
6232 :
6233 :
6234 8864 : fromTextMethods["sysVel"] = &SourceRow::sysVelFromText;
6235 :
6236 :
6237 :
6238 8864 : fromTextMethods["rangeVel"] = &SourceRow::rangeVelFromText;
6239 :
6240 :
6241 :
6242 8864 : fromTextMethods["sourceModel"] = &SourceRow::sourceModelFromText;
6243 :
6244 :
6245 :
6246 8864 : fromTextMethods["frequencyRefCode"] = &SourceRow::frequencyRefCodeFromText;
6247 :
6248 :
6249 :
6250 8864 : fromTextMethods["numFreq"] = &SourceRow::numFreqFromText;
6251 :
6252 :
6253 :
6254 8864 : fromTextMethods["numStokes"] = &SourceRow::numStokesFromText;
6255 :
6256 :
6257 :
6258 8864 : fromTextMethods["frequency"] = &SourceRow::frequencyFromText;
6259 :
6260 :
6261 :
6262 8864 : fromTextMethods["frequencyInterval"] = &SourceRow::frequencyIntervalFromText;
6263 :
6264 :
6265 :
6266 8864 : fromTextMethods["stokesParameter"] = &SourceRow::stokesParameterFromText;
6267 :
6268 :
6269 :
6270 8864 : fromTextMethods["flux"] = &SourceRow::fluxFromText;
6271 :
6272 :
6273 :
6274 8864 : fromTextMethods["fluxErr"] = &SourceRow::fluxErrFromText;
6275 :
6276 :
6277 :
6278 8864 : fromTextMethods["positionAngle"] = &SourceRow::positionAngleFromText;
6279 :
6280 :
6281 :
6282 8864 : fromTextMethods["positionAngleErr"] = &SourceRow::positionAngleErrFromText;
6283 :
6284 :
6285 :
6286 8864 : fromTextMethods["size"] = &SourceRow::sizeFromText;
6287 :
6288 :
6289 :
6290 8864 : fromTextMethods["sizeErr"] = &SourceRow::sizeErrFromText;
6291 :
6292 :
6293 :
6294 8864 : fromTextMethods["velRefCode"] = &SourceRow::velRefCodeFromText;
6295 :
6296 :
6297 :
6298 8864 : fromTextMethods["dopplerVelocity"] = &SourceRow::dopplerVelocityFromText;
6299 :
6300 :
6301 :
6302 8864 : fromTextMethods["dopplerReferenceSystem"] = &SourceRow::dopplerReferenceSystemFromText;
6303 :
6304 :
6305 :
6306 8864 : fromTextMethods["dopplerCalcType"] = &SourceRow::dopplerCalcTypeFromText;
6307 :
6308 :
6309 :
6310 8864 : fromTextMethods["parallax"] = &SourceRow::parallaxFromText;
6311 :
6312 :
6313 8864 : }
6314 :
6315 0 : SourceRow::SourceRow (SourceTable &t, SourceRow *row) : table(t) {
6316 0 : hasBeenAdded = false;
6317 :
6318 0 : if (row == 0) {
6319 :
6320 :
6321 :
6322 :
6323 :
6324 :
6325 :
6326 :
6327 :
6328 :
6329 :
6330 :
6331 :
6332 :
6333 :
6334 0 : directionCodeExists = false;
6335 :
6336 :
6337 :
6338 0 : directionEquinoxExists = false;
6339 :
6340 :
6341 :
6342 0 : calibrationGroupExists = false;
6343 :
6344 :
6345 :
6346 0 : catalogExists = false;
6347 :
6348 :
6349 :
6350 0 : deltaVelExists = false;
6351 :
6352 :
6353 :
6354 0 : positionExists = false;
6355 :
6356 :
6357 :
6358 0 : numLinesExists = false;
6359 :
6360 :
6361 :
6362 0 : transitionExists = false;
6363 :
6364 :
6365 :
6366 0 : restFrequencyExists = false;
6367 :
6368 :
6369 :
6370 0 : sysVelExists = false;
6371 :
6372 :
6373 :
6374 0 : rangeVelExists = false;
6375 :
6376 :
6377 :
6378 0 : sourceModelExists = false;
6379 :
6380 :
6381 :
6382 0 : frequencyRefCodeExists = false;
6383 :
6384 :
6385 :
6386 0 : numFreqExists = false;
6387 :
6388 :
6389 :
6390 0 : numStokesExists = false;
6391 :
6392 :
6393 :
6394 0 : frequencyExists = false;
6395 :
6396 :
6397 :
6398 0 : frequencyIntervalExists = false;
6399 :
6400 :
6401 :
6402 0 : stokesParameterExists = false;
6403 :
6404 :
6405 :
6406 0 : fluxExists = false;
6407 :
6408 :
6409 :
6410 0 : fluxErrExists = false;
6411 :
6412 :
6413 :
6414 0 : positionAngleExists = false;
6415 :
6416 :
6417 :
6418 0 : positionAngleErrExists = false;
6419 :
6420 :
6421 :
6422 0 : sizeExists = false;
6423 :
6424 :
6425 :
6426 0 : sizeErrExists = false;
6427 :
6428 :
6429 :
6430 0 : velRefCodeExists = false;
6431 :
6432 :
6433 :
6434 0 : dopplerVelocityExists = false;
6435 :
6436 :
6437 :
6438 0 : dopplerReferenceSystemExists = false;
6439 :
6440 :
6441 :
6442 0 : dopplerCalcTypeExists = false;
6443 :
6444 :
6445 :
6446 0 : parallaxExists = false;
6447 :
6448 :
6449 :
6450 :
6451 :
6452 : }
6453 : else {
6454 :
6455 :
6456 0 : sourceId = row->sourceId;
6457 :
6458 0 : timeInterval = row->timeInterval;
6459 :
6460 0 : spectralWindowId = row->spectralWindowId;
6461 :
6462 :
6463 :
6464 :
6465 0 : code = row->code;
6466 :
6467 0 : direction = row->direction;
6468 :
6469 0 : properMotion = row->properMotion;
6470 :
6471 0 : sourceName = row->sourceName;
6472 :
6473 :
6474 :
6475 :
6476 0 : if (row->directionCodeExists) {
6477 0 : directionCode = row->directionCode;
6478 0 : directionCodeExists = true;
6479 : }
6480 : else
6481 0 : directionCodeExists = false;
6482 :
6483 0 : if (row->directionEquinoxExists) {
6484 0 : directionEquinox = row->directionEquinox;
6485 0 : directionEquinoxExists = true;
6486 : }
6487 : else
6488 0 : directionEquinoxExists = false;
6489 :
6490 0 : if (row->calibrationGroupExists) {
6491 0 : calibrationGroup = row->calibrationGroup;
6492 0 : calibrationGroupExists = true;
6493 : }
6494 : else
6495 0 : calibrationGroupExists = false;
6496 :
6497 0 : if (row->catalogExists) {
6498 0 : catalog = row->catalog;
6499 0 : catalogExists = true;
6500 : }
6501 : else
6502 0 : catalogExists = false;
6503 :
6504 0 : if (row->deltaVelExists) {
6505 0 : deltaVel = row->deltaVel;
6506 0 : deltaVelExists = true;
6507 : }
6508 : else
6509 0 : deltaVelExists = false;
6510 :
6511 0 : if (row->positionExists) {
6512 0 : position = row->position;
6513 0 : positionExists = true;
6514 : }
6515 : else
6516 0 : positionExists = false;
6517 :
6518 0 : if (row->numLinesExists) {
6519 0 : numLines = row->numLines;
6520 0 : numLinesExists = true;
6521 : }
6522 : else
6523 0 : numLinesExists = false;
6524 :
6525 0 : if (row->transitionExists) {
6526 0 : transition = row->transition;
6527 0 : transitionExists = true;
6528 : }
6529 : else
6530 0 : transitionExists = false;
6531 :
6532 0 : if (row->restFrequencyExists) {
6533 0 : restFrequency = row->restFrequency;
6534 0 : restFrequencyExists = true;
6535 : }
6536 : else
6537 0 : restFrequencyExists = false;
6538 :
6539 0 : if (row->sysVelExists) {
6540 0 : sysVel = row->sysVel;
6541 0 : sysVelExists = true;
6542 : }
6543 : else
6544 0 : sysVelExists = false;
6545 :
6546 0 : if (row->rangeVelExists) {
6547 0 : rangeVel = row->rangeVel;
6548 0 : rangeVelExists = true;
6549 : }
6550 : else
6551 0 : rangeVelExists = false;
6552 :
6553 0 : if (row->sourceModelExists) {
6554 0 : sourceModel = row->sourceModel;
6555 0 : sourceModelExists = true;
6556 : }
6557 : else
6558 0 : sourceModelExists = false;
6559 :
6560 0 : if (row->frequencyRefCodeExists) {
6561 0 : frequencyRefCode = row->frequencyRefCode;
6562 0 : frequencyRefCodeExists = true;
6563 : }
6564 : else
6565 0 : frequencyRefCodeExists = false;
6566 :
6567 0 : if (row->numFreqExists) {
6568 0 : numFreq = row->numFreq;
6569 0 : numFreqExists = true;
6570 : }
6571 : else
6572 0 : numFreqExists = false;
6573 :
6574 0 : if (row->numStokesExists) {
6575 0 : numStokes = row->numStokes;
6576 0 : numStokesExists = true;
6577 : }
6578 : else
6579 0 : numStokesExists = false;
6580 :
6581 0 : if (row->frequencyExists) {
6582 0 : frequency = row->frequency;
6583 0 : frequencyExists = true;
6584 : }
6585 : else
6586 0 : frequencyExists = false;
6587 :
6588 0 : if (row->frequencyIntervalExists) {
6589 0 : frequencyInterval = row->frequencyInterval;
6590 0 : frequencyIntervalExists = true;
6591 : }
6592 : else
6593 0 : frequencyIntervalExists = false;
6594 :
6595 0 : if (row->stokesParameterExists) {
6596 0 : stokesParameter = row->stokesParameter;
6597 0 : stokesParameterExists = true;
6598 : }
6599 : else
6600 0 : stokesParameterExists = false;
6601 :
6602 0 : if (row->fluxExists) {
6603 0 : flux = row->flux;
6604 0 : fluxExists = true;
6605 : }
6606 : else
6607 0 : fluxExists = false;
6608 :
6609 0 : if (row->fluxErrExists) {
6610 0 : fluxErr = row->fluxErr;
6611 0 : fluxErrExists = true;
6612 : }
6613 : else
6614 0 : fluxErrExists = false;
6615 :
6616 0 : if (row->positionAngleExists) {
6617 0 : positionAngle = row->positionAngle;
6618 0 : positionAngleExists = true;
6619 : }
6620 : else
6621 0 : positionAngleExists = false;
6622 :
6623 0 : if (row->positionAngleErrExists) {
6624 0 : positionAngleErr = row->positionAngleErr;
6625 0 : positionAngleErrExists = true;
6626 : }
6627 : else
6628 0 : positionAngleErrExists = false;
6629 :
6630 0 : if (row->sizeExists) {
6631 0 : size = row->size;
6632 0 : sizeExists = true;
6633 : }
6634 : else
6635 0 : sizeExists = false;
6636 :
6637 0 : if (row->sizeErrExists) {
6638 0 : sizeErr = row->sizeErr;
6639 0 : sizeErrExists = true;
6640 : }
6641 : else
6642 0 : sizeErrExists = false;
6643 :
6644 0 : if (row->velRefCodeExists) {
6645 0 : velRefCode = row->velRefCode;
6646 0 : velRefCodeExists = true;
6647 : }
6648 : else
6649 0 : velRefCodeExists = false;
6650 :
6651 0 : if (row->dopplerVelocityExists) {
6652 0 : dopplerVelocity = row->dopplerVelocity;
6653 0 : dopplerVelocityExists = true;
6654 : }
6655 : else
6656 0 : dopplerVelocityExists = false;
6657 :
6658 0 : if (row->dopplerReferenceSystemExists) {
6659 0 : dopplerReferenceSystem = row->dopplerReferenceSystem;
6660 0 : dopplerReferenceSystemExists = true;
6661 : }
6662 : else
6663 0 : dopplerReferenceSystemExists = false;
6664 :
6665 0 : if (row->dopplerCalcTypeExists) {
6666 0 : dopplerCalcType = row->dopplerCalcType;
6667 0 : dopplerCalcTypeExists = true;
6668 : }
6669 : else
6670 0 : dopplerCalcTypeExists = false;
6671 :
6672 0 : if (row->parallaxExists) {
6673 0 : parallax = row->parallax;
6674 0 : parallaxExists = true;
6675 : }
6676 : else
6677 0 : parallaxExists = false;
6678 :
6679 : }
6680 :
6681 0 : fromBinMethods["sourceId"] = &SourceRow::sourceIdFromBin;
6682 0 : fromBinMethods["timeInterval"] = &SourceRow::timeIntervalFromBin;
6683 0 : fromBinMethods["spectralWindowId"] = &SourceRow::spectralWindowIdFromBin;
6684 0 : fromBinMethods["code"] = &SourceRow::codeFromBin;
6685 0 : fromBinMethods["direction"] = &SourceRow::directionFromBin;
6686 0 : fromBinMethods["properMotion"] = &SourceRow::properMotionFromBin;
6687 0 : fromBinMethods["sourceName"] = &SourceRow::sourceNameFromBin;
6688 :
6689 :
6690 0 : fromBinMethods["directionCode"] = &SourceRow::directionCodeFromBin;
6691 0 : fromBinMethods["directionEquinox"] = &SourceRow::directionEquinoxFromBin;
6692 0 : fromBinMethods["calibrationGroup"] = &SourceRow::calibrationGroupFromBin;
6693 0 : fromBinMethods["catalog"] = &SourceRow::catalogFromBin;
6694 0 : fromBinMethods["deltaVel"] = &SourceRow::deltaVelFromBin;
6695 0 : fromBinMethods["position"] = &SourceRow::positionFromBin;
6696 0 : fromBinMethods["numLines"] = &SourceRow::numLinesFromBin;
6697 0 : fromBinMethods["transition"] = &SourceRow::transitionFromBin;
6698 0 : fromBinMethods["restFrequency"] = &SourceRow::restFrequencyFromBin;
6699 0 : fromBinMethods["sysVel"] = &SourceRow::sysVelFromBin;
6700 0 : fromBinMethods["rangeVel"] = &SourceRow::rangeVelFromBin;
6701 0 : fromBinMethods["sourceModel"] = &SourceRow::sourceModelFromBin;
6702 0 : fromBinMethods["frequencyRefCode"] = &SourceRow::frequencyRefCodeFromBin;
6703 0 : fromBinMethods["numFreq"] = &SourceRow::numFreqFromBin;
6704 0 : fromBinMethods["numStokes"] = &SourceRow::numStokesFromBin;
6705 0 : fromBinMethods["frequency"] = &SourceRow::frequencyFromBin;
6706 0 : fromBinMethods["frequencyInterval"] = &SourceRow::frequencyIntervalFromBin;
6707 0 : fromBinMethods["stokesParameter"] = &SourceRow::stokesParameterFromBin;
6708 0 : fromBinMethods["flux"] = &SourceRow::fluxFromBin;
6709 0 : fromBinMethods["fluxErr"] = &SourceRow::fluxErrFromBin;
6710 0 : fromBinMethods["positionAngle"] = &SourceRow::positionAngleFromBin;
6711 0 : fromBinMethods["positionAngleErr"] = &SourceRow::positionAngleErrFromBin;
6712 0 : fromBinMethods["size"] = &SourceRow::sizeFromBin;
6713 0 : fromBinMethods["sizeErr"] = &SourceRow::sizeErrFromBin;
6714 0 : fromBinMethods["velRefCode"] = &SourceRow::velRefCodeFromBin;
6715 0 : fromBinMethods["dopplerVelocity"] = &SourceRow::dopplerVelocityFromBin;
6716 0 : fromBinMethods["dopplerReferenceSystem"] = &SourceRow::dopplerReferenceSystemFromBin;
6717 0 : fromBinMethods["dopplerCalcType"] = &SourceRow::dopplerCalcTypeFromBin;
6718 0 : fromBinMethods["parallax"] = &SourceRow::parallaxFromBin;
6719 :
6720 0 : }
6721 :
6722 :
6723 0 : bool SourceRow::compareNoAutoInc(ArrayTimeInterval timeInterval, Tag spectralWindowId, std::string code, std::vector<Angle > direction, std::vector<AngularRate > properMotion, std::string sourceName) {
6724 : bool result;
6725 0 : result = true;
6726 :
6727 :
6728 :
6729 0 : result = result && (this->timeInterval.overlaps(timeInterval));
6730 :
6731 0 : if (!result) return false;
6732 :
6733 :
6734 :
6735 :
6736 0 : result = result && (this->spectralWindowId == spectralWindowId);
6737 :
6738 0 : if (!result) return false;
6739 :
6740 :
6741 :
6742 :
6743 0 : result = result && (this->code == code);
6744 :
6745 0 : if (!result) return false;
6746 :
6747 :
6748 :
6749 :
6750 0 : result = result && (this->direction == direction);
6751 :
6752 0 : if (!result) return false;
6753 :
6754 :
6755 :
6756 :
6757 0 : result = result && (this->properMotion == properMotion);
6758 :
6759 0 : if (!result) return false;
6760 :
6761 :
6762 :
6763 :
6764 0 : result = result && (this->sourceName == sourceName);
6765 :
6766 0 : if (!result) return false;
6767 :
6768 :
6769 0 : return result;
6770 : }
6771 :
6772 :
6773 :
6774 0 : bool SourceRow::compareRequiredValue(std::string code, std::vector<Angle > direction, std::vector<AngularRate > properMotion, std::string sourceName) {
6775 : bool result;
6776 0 : result = true;
6777 :
6778 :
6779 0 : if (!(this->code == code)) return false;
6780 :
6781 :
6782 :
6783 0 : if (!(this->direction == direction)) return false;
6784 :
6785 :
6786 :
6787 0 : if (!(this->properMotion == properMotion)) return false;
6788 :
6789 :
6790 :
6791 0 : if (!(this->sourceName == sourceName)) return false;
6792 :
6793 :
6794 0 : return result;
6795 : }
6796 :
6797 :
6798 : /**
6799 : * Return true if all required attributes of the value part are equal to their homologues
6800 : * in x and false otherwise.
6801 : *
6802 :
6803 : * @param x a pointer on the SourceRow whose required attributes of the value part
6804 :
6805 : * will be compared with those of this.
6806 : * @return a boolean.
6807 : */
6808 0 : bool SourceRow::equalByRequiredValue(SourceRow* x ) {
6809 :
6810 :
6811 0 : if (this->code != x->code) return false;
6812 :
6813 0 : if (this->direction != x->direction) return false;
6814 :
6815 0 : if (this->properMotion != x->properMotion) return false;
6816 :
6817 0 : if (this->sourceName != x->sourceName) return false;
6818 :
6819 :
6820 0 : return true;
6821 : }
6822 :
6823 : /*
6824 : map<string, SourceAttributeFromBin> SourceRow::initFromBinMethods() {
6825 : map<string, SourceAttributeFromBin> result;
6826 :
6827 : result["sourceId"] = &SourceRow::sourceIdFromBin;
6828 : result["timeInterval"] = &SourceRow::timeIntervalFromBin;
6829 : result["spectralWindowId"] = &SourceRow::spectralWindowIdFromBin;
6830 : result["code"] = &SourceRow::codeFromBin;
6831 : result["direction"] = &SourceRow::directionFromBin;
6832 : result["properMotion"] = &SourceRow::properMotionFromBin;
6833 : result["sourceName"] = &SourceRow::sourceNameFromBin;
6834 :
6835 :
6836 : result["directionCode"] = &SourceRow::directionCodeFromBin;
6837 : result["directionEquinox"] = &SourceRow::directionEquinoxFromBin;
6838 : result["calibrationGroup"] = &SourceRow::calibrationGroupFromBin;
6839 : result["catalog"] = &SourceRow::catalogFromBin;
6840 : result["deltaVel"] = &SourceRow::deltaVelFromBin;
6841 : result["position"] = &SourceRow::positionFromBin;
6842 : result["numLines"] = &SourceRow::numLinesFromBin;
6843 : result["transition"] = &SourceRow::transitionFromBin;
6844 : result["restFrequency"] = &SourceRow::restFrequencyFromBin;
6845 : result["sysVel"] = &SourceRow::sysVelFromBin;
6846 : result["rangeVel"] = &SourceRow::rangeVelFromBin;
6847 : result["sourceModel"] = &SourceRow::sourceModelFromBin;
6848 : result["frequencyRefCode"] = &SourceRow::frequencyRefCodeFromBin;
6849 : result["numFreq"] = &SourceRow::numFreqFromBin;
6850 : result["numStokes"] = &SourceRow::numStokesFromBin;
6851 : result["frequency"] = &SourceRow::frequencyFromBin;
6852 : result["frequencyInterval"] = &SourceRow::frequencyIntervalFromBin;
6853 : result["stokesParameter"] = &SourceRow::stokesParameterFromBin;
6854 : result["flux"] = &SourceRow::fluxFromBin;
6855 : result["fluxErr"] = &SourceRow::fluxErrFromBin;
6856 : result["positionAngle"] = &SourceRow::positionAngleFromBin;
6857 : result["positionAngleErr"] = &SourceRow::positionAngleErrFromBin;
6858 : result["size"] = &SourceRow::sizeFromBin;
6859 : result["sizeErr"] = &SourceRow::sizeErrFromBin;
6860 : result["velRefCode"] = &SourceRow::velRefCodeFromBin;
6861 : result["dopplerVelocity"] = &SourceRow::dopplerVelocityFromBin;
6862 : result["dopplerReferenceSystem"] = &SourceRow::dopplerReferenceSystemFromBin;
6863 : result["dopplerCalcType"] = &SourceRow::dopplerCalcTypeFromBin;
6864 : result["parallax"] = &SourceRow::parallaxFromBin;
6865 :
6866 :
6867 : return result;
6868 : }
6869 : */
6870 : } // End namespace asdm
6871 :
|
