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 CalAppPhaseRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/CalAppPhaseRow.h>
39 : #include <alma/ASDM/CalAppPhaseTable.h>
40 :
41 : #include <alma/ASDM/CalDataTable.h>
42 : #include <alma/ASDM/CalDataRow.h>
43 :
44 : #include <alma/ASDM/CalReductionTable.h>
45 : #include <alma/ASDM/CalReductionRow.h>
46 :
47 :
48 : using asdm::ASDM;
49 : using asdm::CalAppPhaseRow;
50 : using asdm::CalAppPhaseTable;
51 :
52 : using asdm::CalDataTable;
53 : using asdm::CalDataRow;
54 :
55 : using asdm::CalReductionTable;
56 : using asdm::CalReductionRow;
57 :
58 :
59 : #include <alma/ASDM/Parser.h>
60 :
61 : #include <alma/ASDM/EnumerationParser.h>
62 : #include <alma/ASDM/ASDMValuesParser.h>
63 :
64 : #include <alma/ASDM/InvalidArgumentException.h>
65 :
66 : using namespace std;
67 :
68 : namespace asdm {
69 0 : CalAppPhaseRow::~CalAppPhaseRow() {
70 0 : }
71 :
72 : /**
73 : * Return the table to which this row belongs.
74 : */
75 0 : CalAppPhaseTable &CalAppPhaseRow::getTable() const {
76 0 : return table;
77 : }
78 :
79 0 : bool CalAppPhaseRow::isAdded() const {
80 0 : return hasBeenAdded;
81 : }
82 :
83 0 : void CalAppPhaseRow::isAdded(bool added) {
84 0 : hasBeenAdded = added;
85 0 : }
86 :
87 : #ifndef WITHOUT_ACS
88 : using asdmIDL::CalAppPhaseRowIDL;
89 : #endif
90 :
91 : #ifndef WITHOUT_ACS
92 : /**
93 : * Return this row in the form of an IDL struct.
94 : * @return The values of this row as a CalAppPhaseRowIDL struct.
95 : */
96 : CalAppPhaseRowIDL *CalAppPhaseRow::toIDL() const {
97 : CalAppPhaseRowIDL *x = new CalAppPhaseRowIDL ();
98 :
99 : // Fill the IDL structure.
100 :
101 :
102 :
103 :
104 :
105 :
106 :
107 :
108 : x->basebandName = basebandName;
109 :
110 :
111 :
112 :
113 :
114 :
115 :
116 :
117 :
118 :
119 :
120 : x->scanNumber = scanNumber;
121 :
122 :
123 :
124 :
125 :
126 :
127 :
128 :
129 :
130 :
131 : x->startValidTime = startValidTime.toIDLArrayTime();
132 :
133 :
134 :
135 :
136 :
137 :
138 :
139 :
140 :
141 : x->endValidTime = endValidTime.toIDLArrayTime();
142 :
143 :
144 :
145 :
146 :
147 :
148 :
149 :
150 :
151 : x->adjustTime = adjustTime.toIDLArrayTime();
152 :
153 :
154 :
155 :
156 :
157 :
158 :
159 :
160 :
161 :
162 : x->adjustToken = CORBA::string_dup(adjustToken.c_str());
163 :
164 :
165 :
166 :
167 :
168 :
169 :
170 :
171 :
172 :
173 :
174 : x->phasingMode = CORBA::string_dup(phasingMode.c_str());
175 :
176 :
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 :
185 :
186 : x->numPhasedAntennas = numPhasedAntennas;
187 :
188 :
189 :
190 :
191 :
192 :
193 :
194 :
195 :
196 :
197 : x->phasedAntennas.length(phasedAntennas.size());
198 : for (unsigned int i = 0; i < phasedAntennas.size(); ++i) {
199 :
200 :
201 : x->phasedAntennas[i] = CORBA::string_dup(phasedAntennas.at(i).c_str());
202 :
203 :
204 : }
205 :
206 :
207 :
208 :
209 :
210 :
211 :
212 :
213 :
214 :
215 : x->refAntennaIndex = refAntennaIndex;
216 :
217 :
218 :
219 :
220 :
221 :
222 :
223 :
224 :
225 :
226 :
227 : x->candRefAntennaIndex = candRefAntennaIndex;
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 :
236 :
237 :
238 :
239 : x->phasePacking = CORBA::string_dup(phasePacking.c_str());
240 :
241 :
242 :
243 :
244 :
245 :
246 :
247 :
248 :
249 :
250 :
251 : x->numReceptors = numReceptors;
252 :
253 :
254 :
255 :
256 :
257 :
258 :
259 :
260 :
261 :
262 :
263 : x->numChannels = numChannels;
264 :
265 :
266 :
267 :
268 :
269 :
270 :
271 :
272 :
273 :
274 :
275 : x->numPhaseValues = numPhaseValues;
276 :
277 :
278 :
279 :
280 :
281 :
282 :
283 :
284 :
285 :
286 : x->phaseValues.length(phaseValues.size());
287 : for (unsigned int i = 0; i < phaseValues.size(); ++i) {
288 :
289 :
290 : x->phaseValues[i] = phaseValues.at(i);
291 :
292 :
293 : }
294 :
295 :
296 :
297 :
298 :
299 :
300 :
301 :
302 :
303 :
304 : x->numCompare = numCompare;
305 :
306 :
307 :
308 :
309 :
310 :
311 :
312 :
313 :
314 :
315 :
316 : x->numEfficiencies = numEfficiencies;
317 :
318 :
319 :
320 :
321 :
322 :
323 :
324 :
325 :
326 :
327 : x->compareArray.length(compareArray.size());
328 : for (unsigned int i = 0; i < compareArray.size(); ++i) {
329 :
330 :
331 : x->compareArray[i] = CORBA::string_dup(compareArray.at(i).c_str());
332 :
333 :
334 : }
335 :
336 :
337 :
338 :
339 :
340 :
341 :
342 :
343 :
344 : x->efficiencyIndices.length(efficiencyIndices.size());
345 : for (unsigned int i = 0; i < efficiencyIndices.size(); ++i) {
346 :
347 :
348 : x->efficiencyIndices[i] = efficiencyIndices.at(i);
349 :
350 :
351 : }
352 :
353 :
354 :
355 :
356 :
357 :
358 :
359 :
360 :
361 : x->efficiencies.length(efficiencies.size());
362 : for (unsigned int i = 0; i < efficiencies.size(); i++) {
363 : x->efficiencies[i].length(efficiencies.at(i).size());
364 : }
365 :
366 : for (unsigned int i = 0; i < efficiencies.size() ; i++)
367 : for (unsigned int j = 0; j < efficiencies.at(i).size(); j++)
368 :
369 :
370 : x->efficiencies[i][j] = efficiencies.at(i).at(j);
371 :
372 :
373 :
374 :
375 :
376 :
377 :
378 :
379 :
380 :
381 :
382 :
383 : x->quality.length(quality.size());
384 : for (unsigned int i = 0; i < quality.size(); ++i) {
385 :
386 :
387 : x->quality[i] = quality.at(i);
388 :
389 :
390 : }
391 :
392 :
393 :
394 :
395 :
396 :
397 :
398 :
399 :
400 :
401 : x->phasedSumAntenna = CORBA::string_dup(phasedSumAntenna.c_str());
402 :
403 :
404 :
405 :
406 :
407 :
408 :
409 :
410 : x->typeSupportsExists = typeSupportsExists;
411 :
412 :
413 :
414 :
415 : x->typeSupports = CORBA::string_dup(typeSupports.c_str());
416 :
417 :
418 :
419 :
420 :
421 :
422 :
423 :
424 : x->numSupportsExists = numSupportsExists;
425 :
426 :
427 :
428 :
429 : x->numSupports = numSupports;
430 :
431 :
432 :
433 :
434 :
435 :
436 :
437 :
438 : x->phaseSupportsExists = phaseSupportsExists;
439 :
440 :
441 :
442 : x->phaseSupports.length(phaseSupports.size());
443 : for (unsigned int i = 0; i < phaseSupports.size(); ++i) {
444 :
445 :
446 : x->phaseSupports[i] = phaseSupports.at(i);
447 :
448 :
449 : }
450 :
451 :
452 :
453 :
454 :
455 :
456 :
457 :
458 :
459 :
460 :
461 :
462 :
463 : x->calDataId = calDataId.toIDLTag();
464 :
465 :
466 :
467 :
468 :
469 :
470 :
471 :
472 :
473 :
474 : x->calReductionId = calReductionId.toIDLTag();
475 :
476 :
477 :
478 :
479 :
480 :
481 :
482 :
483 :
484 :
485 :
486 : return x;
487 :
488 : }
489 :
490 : void CalAppPhaseRow::toIDL(asdmIDL::CalAppPhaseRowIDL& x) const {
491 : // Set the x's fields.
492 :
493 :
494 :
495 :
496 :
497 :
498 :
499 :
500 : x.basebandName = basebandName;
501 :
502 :
503 :
504 :
505 :
506 :
507 :
508 :
509 :
510 :
511 :
512 : x.scanNumber = scanNumber;
513 :
514 :
515 :
516 :
517 :
518 :
519 :
520 :
521 :
522 :
523 : x.startValidTime = startValidTime.toIDLArrayTime();
524 :
525 :
526 :
527 :
528 :
529 :
530 :
531 :
532 :
533 : x.endValidTime = endValidTime.toIDLArrayTime();
534 :
535 :
536 :
537 :
538 :
539 :
540 :
541 :
542 :
543 : x.adjustTime = adjustTime.toIDLArrayTime();
544 :
545 :
546 :
547 :
548 :
549 :
550 :
551 :
552 :
553 :
554 : x.adjustToken = CORBA::string_dup(adjustToken.c_str());
555 :
556 :
557 :
558 :
559 :
560 :
561 :
562 :
563 :
564 :
565 :
566 : x.phasingMode = CORBA::string_dup(phasingMode.c_str());
567 :
568 :
569 :
570 :
571 :
572 :
573 :
574 :
575 :
576 :
577 :
578 : x.numPhasedAntennas = numPhasedAntennas;
579 :
580 :
581 :
582 :
583 :
584 :
585 :
586 :
587 :
588 :
589 : x.phasedAntennas.length(phasedAntennas.size());
590 : for (unsigned int i = 0; i < phasedAntennas.size(); ++i) {
591 :
592 :
593 : x.phasedAntennas[i] = CORBA::string_dup(phasedAntennas.at(i).c_str());
594 :
595 :
596 : }
597 :
598 :
599 :
600 :
601 :
602 :
603 :
604 :
605 :
606 :
607 : x.refAntennaIndex = refAntennaIndex;
608 :
609 :
610 :
611 :
612 :
613 :
614 :
615 :
616 :
617 :
618 :
619 : x.candRefAntennaIndex = candRefAntennaIndex;
620 :
621 :
622 :
623 :
624 :
625 :
626 :
627 :
628 :
629 :
630 :
631 : x.phasePacking = CORBA::string_dup(phasePacking.c_str());
632 :
633 :
634 :
635 :
636 :
637 :
638 :
639 :
640 :
641 :
642 :
643 : x.numReceptors = numReceptors;
644 :
645 :
646 :
647 :
648 :
649 :
650 :
651 :
652 :
653 :
654 :
655 : x.numChannels = numChannels;
656 :
657 :
658 :
659 :
660 :
661 :
662 :
663 :
664 :
665 :
666 :
667 : x.numPhaseValues = numPhaseValues;
668 :
669 :
670 :
671 :
672 :
673 :
674 :
675 :
676 :
677 :
678 : x.phaseValues.length(phaseValues.size());
679 : for (unsigned int i = 0; i < phaseValues.size(); ++i) {
680 :
681 :
682 : x.phaseValues[i] = phaseValues.at(i);
683 :
684 :
685 : }
686 :
687 :
688 :
689 :
690 :
691 :
692 :
693 :
694 :
695 :
696 : x.numCompare = numCompare;
697 :
698 :
699 :
700 :
701 :
702 :
703 :
704 :
705 :
706 :
707 :
708 : x.numEfficiencies = numEfficiencies;
709 :
710 :
711 :
712 :
713 :
714 :
715 :
716 :
717 :
718 :
719 : x.compareArray.length(compareArray.size());
720 : for (unsigned int i = 0; i < compareArray.size(); ++i) {
721 :
722 :
723 : x.compareArray[i] = CORBA::string_dup(compareArray.at(i).c_str());
724 :
725 :
726 : }
727 :
728 :
729 :
730 :
731 :
732 :
733 :
734 :
735 :
736 : x.efficiencyIndices.length(efficiencyIndices.size());
737 : for (unsigned int i = 0; i < efficiencyIndices.size(); ++i) {
738 :
739 :
740 : x.efficiencyIndices[i] = efficiencyIndices.at(i);
741 :
742 :
743 : }
744 :
745 :
746 :
747 :
748 :
749 :
750 :
751 :
752 :
753 : x.efficiencies.length(efficiencies.size());
754 : for (unsigned int i = 0; i < efficiencies.size(); i++) {
755 : x.efficiencies[i].length(efficiencies.at(i).size());
756 : }
757 :
758 : for (unsigned int i = 0; i < efficiencies.size() ; i++)
759 : for (unsigned int j = 0; j < efficiencies.at(i).size(); j++)
760 :
761 :
762 : x.efficiencies[i][j] = efficiencies.at(i).at(j);
763 :
764 :
765 :
766 :
767 :
768 :
769 :
770 :
771 :
772 :
773 :
774 :
775 : x.quality.length(quality.size());
776 : for (unsigned int i = 0; i < quality.size(); ++i) {
777 :
778 :
779 : x.quality[i] = quality.at(i);
780 :
781 :
782 : }
783 :
784 :
785 :
786 :
787 :
788 :
789 :
790 :
791 :
792 :
793 : x.phasedSumAntenna = CORBA::string_dup(phasedSumAntenna.c_str());
794 :
795 :
796 :
797 :
798 :
799 :
800 :
801 :
802 : x.typeSupportsExists = typeSupportsExists;
803 :
804 :
805 :
806 :
807 : x.typeSupports = CORBA::string_dup(typeSupports.c_str());
808 :
809 :
810 :
811 :
812 :
813 :
814 :
815 :
816 : x.numSupportsExists = numSupportsExists;
817 :
818 :
819 :
820 :
821 : x.numSupports = numSupports;
822 :
823 :
824 :
825 :
826 :
827 :
828 :
829 :
830 : x.phaseSupportsExists = phaseSupportsExists;
831 :
832 :
833 :
834 : x.phaseSupports.length(phaseSupports.size());
835 : for (unsigned int i = 0; i < phaseSupports.size(); ++i) {
836 :
837 :
838 : x.phaseSupports[i] = phaseSupports.at(i);
839 :
840 :
841 : }
842 :
843 :
844 :
845 :
846 :
847 :
848 :
849 :
850 :
851 :
852 :
853 :
854 :
855 : x.calDataId = calDataId.toIDLTag();
856 :
857 :
858 :
859 :
860 :
861 :
862 :
863 :
864 :
865 :
866 : x.calReductionId = calReductionId.toIDLTag();
867 :
868 :
869 :
870 :
871 :
872 :
873 :
874 :
875 :
876 :
877 :
878 : }
879 : #endif
880 :
881 :
882 : #ifndef WITHOUT_ACS
883 : /**
884 : * Fill the values of this row from the IDL struct CalAppPhaseRowIDL.
885 : * @param x The IDL struct containing the values used to fill this row.
886 : */
887 : void CalAppPhaseRow::setFromIDL (CalAppPhaseRowIDL x){
888 : try {
889 : // Fill the values from x.
890 :
891 :
892 :
893 :
894 :
895 :
896 : setBasebandName(x.basebandName);
897 :
898 :
899 :
900 :
901 :
902 :
903 :
904 :
905 :
906 : setScanNumber(x.scanNumber);
907 :
908 :
909 :
910 :
911 :
912 :
913 :
914 :
915 :
916 : setStartValidTime(ArrayTime (x.startValidTime));
917 :
918 :
919 :
920 :
921 :
922 :
923 :
924 :
925 :
926 : setEndValidTime(ArrayTime (x.endValidTime));
927 :
928 :
929 :
930 :
931 :
932 :
933 :
934 :
935 :
936 : setAdjustTime(ArrayTime (x.adjustTime));
937 :
938 :
939 :
940 :
941 :
942 :
943 :
944 :
945 :
946 : setAdjustToken(string (x.adjustToken));
947 :
948 :
949 :
950 :
951 :
952 :
953 :
954 :
955 :
956 : setPhasingMode(string (x.phasingMode));
957 :
958 :
959 :
960 :
961 :
962 :
963 :
964 :
965 :
966 : setNumPhasedAntennas(x.numPhasedAntennas);
967 :
968 :
969 :
970 :
971 :
972 :
973 :
974 :
975 :
976 : phasedAntennas .clear();
977 : for (unsigned int i = 0; i <x.phasedAntennas.length(); ++i) {
978 :
979 : phasedAntennas.push_back(string (x.phasedAntennas[i]));
980 :
981 : }
982 :
983 :
984 :
985 :
986 :
987 :
988 :
989 :
990 :
991 : setRefAntennaIndex(x.refAntennaIndex);
992 :
993 :
994 :
995 :
996 :
997 :
998 :
999 :
1000 :
1001 : setCandRefAntennaIndex(x.candRefAntennaIndex);
1002 :
1003 :
1004 :
1005 :
1006 :
1007 :
1008 :
1009 :
1010 :
1011 : setPhasePacking(string (x.phasePacking));
1012 :
1013 :
1014 :
1015 :
1016 :
1017 :
1018 :
1019 :
1020 :
1021 : setNumReceptors(x.numReceptors);
1022 :
1023 :
1024 :
1025 :
1026 :
1027 :
1028 :
1029 :
1030 :
1031 : setNumChannels(x.numChannels);
1032 :
1033 :
1034 :
1035 :
1036 :
1037 :
1038 :
1039 :
1040 :
1041 : setNumPhaseValues(x.numPhaseValues);
1042 :
1043 :
1044 :
1045 :
1046 :
1047 :
1048 :
1049 :
1050 :
1051 : phaseValues .clear();
1052 : for (unsigned int i = 0; i <x.phaseValues.length(); ++i) {
1053 :
1054 : phaseValues.push_back(x.phaseValues[i]);
1055 :
1056 : }
1057 :
1058 :
1059 :
1060 :
1061 :
1062 :
1063 :
1064 :
1065 :
1066 : setNumCompare(x.numCompare);
1067 :
1068 :
1069 :
1070 :
1071 :
1072 :
1073 :
1074 :
1075 :
1076 : setNumEfficiencies(x.numEfficiencies);
1077 :
1078 :
1079 :
1080 :
1081 :
1082 :
1083 :
1084 :
1085 :
1086 : compareArray .clear();
1087 : for (unsigned int i = 0; i <x.compareArray.length(); ++i) {
1088 :
1089 : compareArray.push_back(string (x.compareArray[i]));
1090 :
1091 : }
1092 :
1093 :
1094 :
1095 :
1096 :
1097 :
1098 :
1099 :
1100 :
1101 : efficiencyIndices .clear();
1102 : for (unsigned int i = 0; i <x.efficiencyIndices.length(); ++i) {
1103 :
1104 : efficiencyIndices.push_back(x.efficiencyIndices[i]);
1105 :
1106 : }
1107 :
1108 :
1109 :
1110 :
1111 :
1112 :
1113 :
1114 :
1115 :
1116 : efficiencies .clear();
1117 :
1118 : vector<float> v_aux_efficiencies;
1119 :
1120 : for (unsigned int i = 0; i < x.efficiencies.length(); ++i) {
1121 : v_aux_efficiencies.clear();
1122 : for (unsigned int j = 0; j < x.efficiencies[0].length(); ++j) {
1123 :
1124 : v_aux_efficiencies.push_back(x.efficiencies[i][j]);
1125 :
1126 : }
1127 : efficiencies.push_back(v_aux_efficiencies);
1128 : }
1129 :
1130 :
1131 :
1132 :
1133 :
1134 :
1135 :
1136 :
1137 :
1138 : quality .clear();
1139 : for (unsigned int i = 0; i <x.quality.length(); ++i) {
1140 :
1141 : quality.push_back(x.quality[i]);
1142 :
1143 : }
1144 :
1145 :
1146 :
1147 :
1148 :
1149 :
1150 :
1151 :
1152 :
1153 : setPhasedSumAntenna(string (x.phasedSumAntenna));
1154 :
1155 :
1156 :
1157 :
1158 :
1159 :
1160 :
1161 : typeSupportsExists = x.typeSupportsExists;
1162 : if (x.typeSupportsExists) {
1163 :
1164 :
1165 :
1166 : setTypeSupports(string (x.typeSupports));
1167 :
1168 :
1169 :
1170 : }
1171 :
1172 :
1173 :
1174 :
1175 :
1176 : numSupportsExists = x.numSupportsExists;
1177 : if (x.numSupportsExists) {
1178 :
1179 :
1180 :
1181 : setNumSupports(x.numSupports);
1182 :
1183 :
1184 :
1185 : }
1186 :
1187 :
1188 :
1189 :
1190 :
1191 : phaseSupportsExists = x.phaseSupportsExists;
1192 : if (x.phaseSupportsExists) {
1193 :
1194 :
1195 :
1196 : phaseSupports .clear();
1197 : for (unsigned int i = 0; i <x.phaseSupports.length(); ++i) {
1198 :
1199 : phaseSupports.push_back(x.phaseSupports[i]);
1200 :
1201 : }
1202 :
1203 :
1204 :
1205 : }
1206 :
1207 :
1208 :
1209 :
1210 :
1211 :
1212 :
1213 :
1214 :
1215 :
1216 : setCalDataId(Tag (x.calDataId));
1217 :
1218 :
1219 :
1220 :
1221 :
1222 :
1223 :
1224 :
1225 :
1226 : setCalReductionId(Tag (x.calReductionId));
1227 :
1228 :
1229 :
1230 :
1231 :
1232 :
1233 :
1234 :
1235 :
1236 :
1237 :
1238 : } catch (const IllegalAccessException &err) {
1239 : throw ConversionException (err.getMessage(),"CalAppPhase");
1240 : }
1241 : }
1242 : #endif
1243 :
1244 : /**
1245 : * Return this row in the form of an XML string.
1246 : * @return The values of this row as an XML string.
1247 : */
1248 0 : string CalAppPhaseRow::toXML() const {
1249 0 : string buf;
1250 0 : buf.append("<row> \n");
1251 :
1252 :
1253 :
1254 :
1255 :
1256 :
1257 0 : buf.append(EnumerationParser::toXML("basebandName", basebandName));
1258 :
1259 :
1260 :
1261 :
1262 :
1263 :
1264 :
1265 0 : Parser::toXML(scanNumber, "scanNumber", buf);
1266 :
1267 :
1268 :
1269 :
1270 :
1271 :
1272 :
1273 0 : Parser::toXML(startValidTime, "startValidTime", buf);
1274 :
1275 :
1276 :
1277 :
1278 :
1279 :
1280 :
1281 0 : Parser::toXML(endValidTime, "endValidTime", buf);
1282 :
1283 :
1284 :
1285 :
1286 :
1287 :
1288 :
1289 0 : Parser::toXML(adjustTime, "adjustTime", buf);
1290 :
1291 :
1292 :
1293 :
1294 :
1295 :
1296 :
1297 0 : Parser::toXML(adjustToken, "adjustToken", buf);
1298 :
1299 :
1300 :
1301 :
1302 :
1303 :
1304 :
1305 0 : Parser::toXML(phasingMode, "phasingMode", buf);
1306 :
1307 :
1308 :
1309 :
1310 :
1311 :
1312 :
1313 0 : Parser::toXML(numPhasedAntennas, "numPhasedAntennas", buf);
1314 :
1315 :
1316 :
1317 :
1318 :
1319 :
1320 :
1321 0 : Parser::toXML(phasedAntennas, "phasedAntennas", buf);
1322 :
1323 :
1324 :
1325 :
1326 :
1327 :
1328 :
1329 0 : Parser::toXML(refAntennaIndex, "refAntennaIndex", buf);
1330 :
1331 :
1332 :
1333 :
1334 :
1335 :
1336 :
1337 0 : Parser::toXML(candRefAntennaIndex, "candRefAntennaIndex", buf);
1338 :
1339 :
1340 :
1341 :
1342 :
1343 :
1344 :
1345 0 : Parser::toXML(phasePacking, "phasePacking", buf);
1346 :
1347 :
1348 :
1349 :
1350 :
1351 :
1352 :
1353 0 : Parser::toXML(numReceptors, "numReceptors", buf);
1354 :
1355 :
1356 :
1357 :
1358 :
1359 :
1360 :
1361 0 : Parser::toXML(numChannels, "numChannels", buf);
1362 :
1363 :
1364 :
1365 :
1366 :
1367 :
1368 :
1369 0 : Parser::toXML(numPhaseValues, "numPhaseValues", buf);
1370 :
1371 :
1372 :
1373 :
1374 :
1375 :
1376 :
1377 0 : Parser::toXML(phaseValues, "phaseValues", buf);
1378 :
1379 :
1380 :
1381 :
1382 :
1383 :
1384 :
1385 0 : Parser::toXML(numCompare, "numCompare", buf);
1386 :
1387 :
1388 :
1389 :
1390 :
1391 :
1392 :
1393 0 : Parser::toXML(numEfficiencies, "numEfficiencies", buf);
1394 :
1395 :
1396 :
1397 :
1398 :
1399 :
1400 :
1401 0 : Parser::toXML(compareArray, "compareArray", buf);
1402 :
1403 :
1404 :
1405 :
1406 :
1407 :
1408 :
1409 0 : Parser::toXML(efficiencyIndices, "efficiencyIndices", buf);
1410 :
1411 :
1412 :
1413 :
1414 :
1415 :
1416 :
1417 0 : Parser::toXML(efficiencies, "efficiencies", buf);
1418 :
1419 :
1420 :
1421 :
1422 :
1423 :
1424 :
1425 0 : Parser::toXML(quality, "quality", buf);
1426 :
1427 :
1428 :
1429 :
1430 :
1431 :
1432 :
1433 0 : Parser::toXML(phasedSumAntenna, "phasedSumAntenna", buf);
1434 :
1435 :
1436 :
1437 :
1438 :
1439 :
1440 0 : if (typeSupportsExists) {
1441 :
1442 :
1443 0 : Parser::toXML(typeSupports, "typeSupports", buf);
1444 :
1445 :
1446 : }
1447 :
1448 :
1449 :
1450 :
1451 :
1452 0 : if (numSupportsExists) {
1453 :
1454 :
1455 0 : Parser::toXML(numSupports, "numSupports", buf);
1456 :
1457 :
1458 : }
1459 :
1460 :
1461 :
1462 :
1463 :
1464 0 : if (phaseSupportsExists) {
1465 :
1466 :
1467 0 : Parser::toXML(phaseSupports, "phaseSupports", buf);
1468 :
1469 :
1470 : }
1471 :
1472 :
1473 :
1474 :
1475 :
1476 :
1477 :
1478 :
1479 :
1480 0 : Parser::toXML(calDataId, "calDataId", buf);
1481 :
1482 :
1483 :
1484 :
1485 :
1486 :
1487 :
1488 0 : Parser::toXML(calReductionId, "calReductionId", buf);
1489 :
1490 :
1491 :
1492 :
1493 :
1494 :
1495 :
1496 :
1497 :
1498 :
1499 :
1500 0 : buf.append("</row>\n");
1501 0 : return buf;
1502 0 : }
1503 :
1504 : /**
1505 : * Fill the values of this row from an XML string
1506 : * that was produced by the toXML() method.
1507 : * @param x The XML string being used to set the values of this row.
1508 : */
1509 0 : void CalAppPhaseRow::setFromXML (string rowDoc) {
1510 0 : Parser row(rowDoc);
1511 0 : string s = "";
1512 : try {
1513 :
1514 :
1515 :
1516 :
1517 :
1518 :
1519 0 : basebandName = EnumerationParser::getBasebandName("basebandName","CalAppPhase",rowDoc);
1520 :
1521 :
1522 :
1523 :
1524 :
1525 :
1526 :
1527 :
1528 0 : setScanNumber(Parser::getInteger("scanNumber","CalAppPhase",rowDoc));
1529 :
1530 :
1531 :
1532 :
1533 :
1534 :
1535 :
1536 0 : setStartValidTime(Parser::getArrayTime("startValidTime","CalAppPhase",rowDoc));
1537 :
1538 :
1539 :
1540 :
1541 :
1542 :
1543 :
1544 0 : setEndValidTime(Parser::getArrayTime("endValidTime","CalAppPhase",rowDoc));
1545 :
1546 :
1547 :
1548 :
1549 :
1550 :
1551 :
1552 0 : setAdjustTime(Parser::getArrayTime("adjustTime","CalAppPhase",rowDoc));
1553 :
1554 :
1555 :
1556 :
1557 :
1558 :
1559 :
1560 0 : setAdjustToken(Parser::getString("adjustToken","CalAppPhase",rowDoc));
1561 :
1562 :
1563 :
1564 :
1565 :
1566 :
1567 :
1568 0 : setPhasingMode(Parser::getString("phasingMode","CalAppPhase",rowDoc));
1569 :
1570 :
1571 :
1572 :
1573 :
1574 :
1575 :
1576 0 : setNumPhasedAntennas(Parser::getInteger("numPhasedAntennas","CalAppPhase",rowDoc));
1577 :
1578 :
1579 :
1580 :
1581 :
1582 :
1583 :
1584 :
1585 0 : setPhasedAntennas(Parser::get1DString("phasedAntennas","CalAppPhase",rowDoc));
1586 :
1587 :
1588 :
1589 :
1590 :
1591 :
1592 :
1593 :
1594 0 : setRefAntennaIndex(Parser::getInteger("refAntennaIndex","CalAppPhase",rowDoc));
1595 :
1596 :
1597 :
1598 :
1599 :
1600 :
1601 :
1602 0 : setCandRefAntennaIndex(Parser::getInteger("candRefAntennaIndex","CalAppPhase",rowDoc));
1603 :
1604 :
1605 :
1606 :
1607 :
1608 :
1609 :
1610 0 : setPhasePacking(Parser::getString("phasePacking","CalAppPhase",rowDoc));
1611 :
1612 :
1613 :
1614 :
1615 :
1616 :
1617 :
1618 0 : setNumReceptors(Parser::getInteger("numReceptors","CalAppPhase",rowDoc));
1619 :
1620 :
1621 :
1622 :
1623 :
1624 :
1625 :
1626 0 : setNumChannels(Parser::getInteger("numChannels","CalAppPhase",rowDoc));
1627 :
1628 :
1629 :
1630 :
1631 :
1632 :
1633 :
1634 0 : setNumPhaseValues(Parser::getInteger("numPhaseValues","CalAppPhase",rowDoc));
1635 :
1636 :
1637 :
1638 :
1639 :
1640 :
1641 :
1642 :
1643 0 : setPhaseValues(Parser::get1DFloat("phaseValues","CalAppPhase",rowDoc));
1644 :
1645 :
1646 :
1647 :
1648 :
1649 :
1650 :
1651 :
1652 0 : setNumCompare(Parser::getInteger("numCompare","CalAppPhase",rowDoc));
1653 :
1654 :
1655 :
1656 :
1657 :
1658 :
1659 :
1660 0 : setNumEfficiencies(Parser::getInteger("numEfficiencies","CalAppPhase",rowDoc));
1661 :
1662 :
1663 :
1664 :
1665 :
1666 :
1667 :
1668 :
1669 0 : setCompareArray(Parser::get1DString("compareArray","CalAppPhase",rowDoc));
1670 :
1671 :
1672 :
1673 :
1674 :
1675 :
1676 :
1677 :
1678 :
1679 0 : setEfficiencyIndices(Parser::get1DInteger("efficiencyIndices","CalAppPhase",rowDoc));
1680 :
1681 :
1682 :
1683 :
1684 :
1685 :
1686 :
1687 :
1688 :
1689 0 : setEfficiencies(Parser::get2DFloat("efficiencies","CalAppPhase",rowDoc));
1690 :
1691 :
1692 :
1693 :
1694 :
1695 :
1696 :
1697 :
1698 :
1699 0 : setQuality(Parser::get1DFloat("quality","CalAppPhase",rowDoc));
1700 :
1701 :
1702 :
1703 :
1704 :
1705 :
1706 :
1707 :
1708 0 : setPhasedSumAntenna(Parser::getString("phasedSumAntenna","CalAppPhase",rowDoc));
1709 :
1710 :
1711 :
1712 :
1713 :
1714 :
1715 0 : if (row.isStr("<typeSupports>")) {
1716 :
1717 0 : setTypeSupports(Parser::getString("typeSupports","CalAppPhase",rowDoc));
1718 :
1719 : }
1720 :
1721 :
1722 :
1723 :
1724 :
1725 0 : if (row.isStr("<numSupports>")) {
1726 :
1727 0 : setNumSupports(Parser::getInteger("numSupports","CalAppPhase",rowDoc));
1728 :
1729 : }
1730 :
1731 :
1732 :
1733 :
1734 :
1735 0 : if (row.isStr("<phaseSupports>")) {
1736 :
1737 :
1738 0 : setPhaseSupports(Parser::get1DFloat("phaseSupports","CalAppPhase",rowDoc));
1739 :
1740 :
1741 : }
1742 :
1743 :
1744 :
1745 :
1746 :
1747 :
1748 :
1749 :
1750 :
1751 0 : setCalDataId(Parser::getTag("calDataId","CalData",rowDoc));
1752 :
1753 :
1754 :
1755 :
1756 :
1757 :
1758 :
1759 0 : setCalReductionId(Parser::getTag("calReductionId","CalReduction",rowDoc));
1760 :
1761 :
1762 :
1763 :
1764 :
1765 :
1766 :
1767 :
1768 :
1769 :
1770 0 : } catch (const IllegalAccessException &err) {
1771 0 : throw ConversionException (err.getMessage(),"CalAppPhase");
1772 0 : }
1773 0 : }
1774 :
1775 0 : void CalAppPhaseRow::toBin(EndianOSStream& eoss) {
1776 :
1777 :
1778 :
1779 :
1780 :
1781 :
1782 0 : eoss.writeString(CBasebandName::name(basebandName));
1783 : /* eoss.writeInt(basebandName); */
1784 :
1785 :
1786 :
1787 :
1788 :
1789 :
1790 :
1791 :
1792 0 : eoss.writeInt(scanNumber);
1793 :
1794 :
1795 :
1796 :
1797 :
1798 :
1799 :
1800 0 : calDataId.toBin(eoss);
1801 :
1802 :
1803 :
1804 :
1805 :
1806 :
1807 0 : calReductionId.toBin(eoss);
1808 :
1809 :
1810 :
1811 :
1812 :
1813 :
1814 0 : startValidTime.toBin(eoss);
1815 :
1816 :
1817 :
1818 :
1819 :
1820 :
1821 0 : endValidTime.toBin(eoss);
1822 :
1823 :
1824 :
1825 :
1826 :
1827 :
1828 0 : adjustTime.toBin(eoss);
1829 :
1830 :
1831 :
1832 :
1833 :
1834 :
1835 :
1836 0 : eoss.writeString(adjustToken);
1837 :
1838 :
1839 :
1840 :
1841 :
1842 :
1843 :
1844 :
1845 0 : eoss.writeString(phasingMode);
1846 :
1847 :
1848 :
1849 :
1850 :
1851 :
1852 :
1853 :
1854 0 : eoss.writeInt(numPhasedAntennas);
1855 :
1856 :
1857 :
1858 :
1859 :
1860 :
1861 :
1862 :
1863 :
1864 0 : eoss.writeInt((int) phasedAntennas.size());
1865 0 : for (unsigned int i = 0; i < phasedAntennas.size(); i++)
1866 :
1867 0 : eoss.writeString(phasedAntennas.at(i));
1868 :
1869 :
1870 :
1871 :
1872 :
1873 :
1874 :
1875 :
1876 :
1877 :
1878 0 : eoss.writeInt(refAntennaIndex);
1879 :
1880 :
1881 :
1882 :
1883 :
1884 :
1885 :
1886 :
1887 0 : eoss.writeInt(candRefAntennaIndex);
1888 :
1889 :
1890 :
1891 :
1892 :
1893 :
1894 :
1895 :
1896 0 : eoss.writeString(phasePacking);
1897 :
1898 :
1899 :
1900 :
1901 :
1902 :
1903 :
1904 :
1905 0 : eoss.writeInt(numReceptors);
1906 :
1907 :
1908 :
1909 :
1910 :
1911 :
1912 :
1913 :
1914 0 : eoss.writeInt(numChannels);
1915 :
1916 :
1917 :
1918 :
1919 :
1920 :
1921 :
1922 :
1923 0 : eoss.writeInt(numPhaseValues);
1924 :
1925 :
1926 :
1927 :
1928 :
1929 :
1930 :
1931 :
1932 :
1933 0 : eoss.writeInt((int) phaseValues.size());
1934 0 : for (unsigned int i = 0; i < phaseValues.size(); i++)
1935 :
1936 0 : eoss.writeFloat(phaseValues.at(i));
1937 :
1938 :
1939 :
1940 :
1941 :
1942 :
1943 :
1944 :
1945 :
1946 :
1947 0 : eoss.writeInt(numCompare);
1948 :
1949 :
1950 :
1951 :
1952 :
1953 :
1954 :
1955 :
1956 0 : eoss.writeInt(numEfficiencies);
1957 :
1958 :
1959 :
1960 :
1961 :
1962 :
1963 :
1964 :
1965 :
1966 0 : eoss.writeInt((int) compareArray.size());
1967 0 : for (unsigned int i = 0; i < compareArray.size(); i++)
1968 :
1969 0 : eoss.writeString(compareArray.at(i));
1970 :
1971 :
1972 :
1973 :
1974 :
1975 :
1976 :
1977 :
1978 :
1979 :
1980 :
1981 0 : eoss.writeInt((int) efficiencyIndices.size());
1982 0 : for (unsigned int i = 0; i < efficiencyIndices.size(); i++)
1983 :
1984 0 : eoss.writeInt(efficiencyIndices.at(i));
1985 :
1986 :
1987 :
1988 :
1989 :
1990 :
1991 :
1992 :
1993 :
1994 :
1995 :
1996 0 : eoss.writeInt((int) efficiencies.size());
1997 0 : eoss.writeInt((int) efficiencies.at(0).size());
1998 0 : for (unsigned int i = 0; i < efficiencies.size(); i++)
1999 0 : for (unsigned int j = 0; j < efficiencies.at(0).size(); j++)
2000 :
2001 0 : eoss.writeFloat(efficiencies.at(i).at(j));
2002 :
2003 :
2004 :
2005 :
2006 :
2007 :
2008 :
2009 :
2010 :
2011 :
2012 :
2013 0 : eoss.writeInt((int) quality.size());
2014 0 : for (unsigned int i = 0; i < quality.size(); i++)
2015 :
2016 0 : eoss.writeFloat(quality.at(i));
2017 :
2018 :
2019 :
2020 :
2021 :
2022 :
2023 :
2024 :
2025 :
2026 :
2027 0 : eoss.writeString(phasedSumAntenna);
2028 :
2029 :
2030 :
2031 :
2032 :
2033 :
2034 :
2035 0 : eoss.writeBoolean(typeSupportsExists);
2036 0 : if (typeSupportsExists) {
2037 :
2038 :
2039 :
2040 :
2041 :
2042 0 : eoss.writeString(typeSupports);
2043 :
2044 :
2045 :
2046 :
2047 : }
2048 :
2049 0 : eoss.writeBoolean(numSupportsExists);
2050 0 : if (numSupportsExists) {
2051 :
2052 :
2053 :
2054 :
2055 :
2056 0 : eoss.writeInt(numSupports);
2057 :
2058 :
2059 :
2060 :
2061 : }
2062 :
2063 0 : eoss.writeBoolean(phaseSupportsExists);
2064 0 : if (phaseSupportsExists) {
2065 :
2066 :
2067 :
2068 :
2069 :
2070 :
2071 0 : eoss.writeInt((int) phaseSupports.size());
2072 0 : for (unsigned int i = 0; i < phaseSupports.size(); i++)
2073 :
2074 0 : eoss.writeFloat(phaseSupports.at(i));
2075 :
2076 :
2077 :
2078 :
2079 :
2080 :
2081 : }
2082 :
2083 0 : }
2084 :
2085 0 : void CalAppPhaseRow::basebandNameFromBin(EndianIStream& eis) {
2086 :
2087 :
2088 :
2089 :
2090 :
2091 0 : basebandName = CBasebandName::literal(eis.readString());
2092 :
2093 :
2094 :
2095 :
2096 0 : }
2097 0 : void CalAppPhaseRow::scanNumberFromBin(EndianIStream& eis) {
2098 :
2099 :
2100 :
2101 :
2102 :
2103 0 : scanNumber = eis.readInt();
2104 :
2105 :
2106 :
2107 :
2108 0 : }
2109 0 : void CalAppPhaseRow::calDataIdFromBin(EndianIStream& eis) {
2110 :
2111 :
2112 :
2113 :
2114 0 : calDataId = Tag::fromBin(eis);
2115 :
2116 :
2117 :
2118 0 : }
2119 0 : void CalAppPhaseRow::calReductionIdFromBin(EndianIStream& eis) {
2120 :
2121 :
2122 :
2123 :
2124 0 : calReductionId = Tag::fromBin(eis);
2125 :
2126 :
2127 :
2128 0 : }
2129 0 : void CalAppPhaseRow::startValidTimeFromBin(EndianIStream& eis) {
2130 :
2131 :
2132 :
2133 :
2134 0 : startValidTime = ArrayTime::fromBin(eis);
2135 :
2136 :
2137 :
2138 0 : }
2139 0 : void CalAppPhaseRow::endValidTimeFromBin(EndianIStream& eis) {
2140 :
2141 :
2142 :
2143 :
2144 0 : endValidTime = ArrayTime::fromBin(eis);
2145 :
2146 :
2147 :
2148 0 : }
2149 0 : void CalAppPhaseRow::adjustTimeFromBin(EndianIStream& eis) {
2150 :
2151 :
2152 :
2153 :
2154 0 : adjustTime = ArrayTime::fromBin(eis);
2155 :
2156 :
2157 :
2158 0 : }
2159 0 : void CalAppPhaseRow::adjustTokenFromBin(EndianIStream& eis) {
2160 :
2161 :
2162 :
2163 :
2164 :
2165 0 : adjustToken = eis.readString();
2166 :
2167 :
2168 :
2169 :
2170 0 : }
2171 0 : void CalAppPhaseRow::phasingModeFromBin(EndianIStream& eis) {
2172 :
2173 :
2174 :
2175 :
2176 :
2177 0 : phasingMode = eis.readString();
2178 :
2179 :
2180 :
2181 :
2182 0 : }
2183 0 : void CalAppPhaseRow::numPhasedAntennasFromBin(EndianIStream& eis) {
2184 :
2185 :
2186 :
2187 :
2188 :
2189 0 : numPhasedAntennas = eis.readInt();
2190 :
2191 :
2192 :
2193 :
2194 0 : }
2195 0 : void CalAppPhaseRow::phasedAntennasFromBin(EndianIStream& eis) {
2196 :
2197 :
2198 :
2199 :
2200 :
2201 :
2202 0 : phasedAntennas.clear();
2203 :
2204 0 : unsigned int phasedAntennasDim1 = eis.readInt();
2205 0 : for (unsigned int i = 0 ; i < phasedAntennasDim1; i++)
2206 :
2207 0 : phasedAntennas.push_back(eis.readString());
2208 :
2209 :
2210 :
2211 :
2212 :
2213 :
2214 0 : }
2215 0 : void CalAppPhaseRow::refAntennaIndexFromBin(EndianIStream& eis) {
2216 :
2217 :
2218 :
2219 :
2220 :
2221 0 : refAntennaIndex = eis.readInt();
2222 :
2223 :
2224 :
2225 :
2226 0 : }
2227 0 : void CalAppPhaseRow::candRefAntennaIndexFromBin(EndianIStream& eis) {
2228 :
2229 :
2230 :
2231 :
2232 :
2233 0 : candRefAntennaIndex = eis.readInt();
2234 :
2235 :
2236 :
2237 :
2238 0 : }
2239 0 : void CalAppPhaseRow::phasePackingFromBin(EndianIStream& eis) {
2240 :
2241 :
2242 :
2243 :
2244 :
2245 0 : phasePacking = eis.readString();
2246 :
2247 :
2248 :
2249 :
2250 0 : }
2251 0 : void CalAppPhaseRow::numReceptorsFromBin(EndianIStream& eis) {
2252 :
2253 :
2254 :
2255 :
2256 :
2257 0 : numReceptors = eis.readInt();
2258 :
2259 :
2260 :
2261 :
2262 0 : }
2263 0 : void CalAppPhaseRow::numChannelsFromBin(EndianIStream& eis) {
2264 :
2265 :
2266 :
2267 :
2268 :
2269 0 : numChannels = eis.readInt();
2270 :
2271 :
2272 :
2273 :
2274 0 : }
2275 0 : void CalAppPhaseRow::numPhaseValuesFromBin(EndianIStream& eis) {
2276 :
2277 :
2278 :
2279 :
2280 :
2281 0 : numPhaseValues = eis.readInt();
2282 :
2283 :
2284 :
2285 :
2286 0 : }
2287 0 : void CalAppPhaseRow::phaseValuesFromBin(EndianIStream& eis) {
2288 :
2289 :
2290 :
2291 :
2292 :
2293 :
2294 0 : phaseValues.clear();
2295 :
2296 0 : unsigned int phaseValuesDim1 = eis.readInt();
2297 0 : for (unsigned int i = 0 ; i < phaseValuesDim1; i++)
2298 :
2299 0 : phaseValues.push_back(eis.readFloat());
2300 :
2301 :
2302 :
2303 :
2304 :
2305 :
2306 0 : }
2307 0 : void CalAppPhaseRow::numCompareFromBin(EndianIStream& eis) {
2308 :
2309 :
2310 :
2311 :
2312 :
2313 0 : numCompare = eis.readInt();
2314 :
2315 :
2316 :
2317 :
2318 0 : }
2319 0 : void CalAppPhaseRow::numEfficienciesFromBin(EndianIStream& eis) {
2320 :
2321 :
2322 :
2323 :
2324 :
2325 0 : numEfficiencies = eis.readInt();
2326 :
2327 :
2328 :
2329 :
2330 0 : }
2331 0 : void CalAppPhaseRow::compareArrayFromBin(EndianIStream& eis) {
2332 :
2333 :
2334 :
2335 :
2336 :
2337 :
2338 0 : compareArray.clear();
2339 :
2340 0 : unsigned int compareArrayDim1 = eis.readInt();
2341 0 : for (unsigned int i = 0 ; i < compareArrayDim1; i++)
2342 :
2343 0 : compareArray.push_back(eis.readString());
2344 :
2345 :
2346 :
2347 :
2348 :
2349 :
2350 0 : }
2351 0 : void CalAppPhaseRow::efficiencyIndicesFromBin(EndianIStream& eis) {
2352 :
2353 :
2354 :
2355 :
2356 :
2357 :
2358 0 : efficiencyIndices.clear();
2359 :
2360 0 : unsigned int efficiencyIndicesDim1 = eis.readInt();
2361 0 : for (unsigned int i = 0 ; i < efficiencyIndicesDim1; i++)
2362 :
2363 0 : efficiencyIndices.push_back(eis.readInt());
2364 :
2365 :
2366 :
2367 :
2368 :
2369 :
2370 0 : }
2371 0 : void CalAppPhaseRow::efficienciesFromBin(EndianIStream& eis) {
2372 :
2373 :
2374 :
2375 :
2376 :
2377 :
2378 0 : efficiencies.clear();
2379 :
2380 0 : unsigned int efficienciesDim1 = eis.readInt();
2381 0 : unsigned int efficienciesDim2 = eis.readInt();
2382 :
2383 0 : vector <float> efficienciesAux1;
2384 :
2385 0 : for (unsigned int i = 0; i < efficienciesDim1; i++) {
2386 0 : efficienciesAux1.clear();
2387 0 : for (unsigned int j = 0; j < efficienciesDim2 ; j++)
2388 :
2389 0 : efficienciesAux1.push_back(eis.readFloat());
2390 :
2391 0 : efficiencies.push_back(efficienciesAux1);
2392 : }
2393 :
2394 :
2395 :
2396 :
2397 :
2398 :
2399 0 : }
2400 0 : void CalAppPhaseRow::qualityFromBin(EndianIStream& eis) {
2401 :
2402 :
2403 :
2404 :
2405 :
2406 :
2407 0 : quality.clear();
2408 :
2409 0 : unsigned int qualityDim1 = eis.readInt();
2410 0 : for (unsigned int i = 0 ; i < qualityDim1; i++)
2411 :
2412 0 : quality.push_back(eis.readFloat());
2413 :
2414 :
2415 :
2416 :
2417 :
2418 :
2419 0 : }
2420 0 : void CalAppPhaseRow::phasedSumAntennaFromBin(EndianIStream& eis) {
2421 :
2422 :
2423 :
2424 :
2425 :
2426 0 : phasedSumAntenna = eis.readString();
2427 :
2428 :
2429 :
2430 :
2431 0 : }
2432 :
2433 0 : void CalAppPhaseRow::typeSupportsFromBin(EndianIStream& eis) {
2434 :
2435 0 : typeSupportsExists = eis.readBoolean();
2436 0 : if (typeSupportsExists) {
2437 :
2438 :
2439 :
2440 :
2441 :
2442 0 : typeSupports = eis.readString();
2443 :
2444 :
2445 :
2446 :
2447 : }
2448 :
2449 0 : }
2450 0 : void CalAppPhaseRow::numSupportsFromBin(EndianIStream& eis) {
2451 :
2452 0 : numSupportsExists = eis.readBoolean();
2453 0 : if (numSupportsExists) {
2454 :
2455 :
2456 :
2457 :
2458 :
2459 0 : numSupports = eis.readInt();
2460 :
2461 :
2462 :
2463 :
2464 : }
2465 :
2466 0 : }
2467 0 : void CalAppPhaseRow::phaseSupportsFromBin(EndianIStream& eis) {
2468 :
2469 0 : phaseSupportsExists = eis.readBoolean();
2470 0 : if (phaseSupportsExists) {
2471 :
2472 :
2473 :
2474 :
2475 :
2476 :
2477 0 : phaseSupports.clear();
2478 :
2479 0 : unsigned int phaseSupportsDim1 = eis.readInt();
2480 0 : for (unsigned int i = 0 ; i < phaseSupportsDim1; i++)
2481 :
2482 0 : phaseSupports.push_back(eis.readFloat());
2483 :
2484 :
2485 :
2486 :
2487 :
2488 :
2489 : }
2490 :
2491 0 : }
2492 :
2493 :
2494 0 : CalAppPhaseRow* CalAppPhaseRow::fromBin(EndianIStream& eis, CalAppPhaseTable& table, const vector<string>& attributesSeq) {
2495 0 : CalAppPhaseRow* row = new CalAppPhaseRow(table);
2496 :
2497 0 : map<string, CalAppPhaseAttributeFromBin>::iterator iter ;
2498 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
2499 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
2500 0 : if (iter != row->fromBinMethods.end()) {
2501 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
2502 : }
2503 : else {
2504 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
2505 0 : if (functorP)
2506 0 : (*functorP)(eis);
2507 : else
2508 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "CalAppPhaseTable");
2509 : }
2510 :
2511 : }
2512 0 : return row;
2513 : }
2514 :
2515 : //
2516 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
2517 : // of one row.
2518 : //
2519 :
2520 : // Convert a string into an BasebandName
2521 0 : void CalAppPhaseRow::basebandNameFromText(const string & s) {
2522 :
2523 :
2524 0 : basebandName = ASDMValuesParser::parse<BasebandNameMod::BasebandName>(s);
2525 :
2526 :
2527 0 : }
2528 :
2529 :
2530 : // Convert a string into an int
2531 0 : void CalAppPhaseRow::scanNumberFromText(const string & s) {
2532 :
2533 :
2534 0 : scanNumber = ASDMValuesParser::parse<int>(s);
2535 :
2536 :
2537 0 : }
2538 :
2539 :
2540 : // Convert a string into an Tag
2541 0 : void CalAppPhaseRow::calDataIdFromText(const string & s) {
2542 :
2543 :
2544 0 : calDataId = ASDMValuesParser::parse<Tag>(s);
2545 :
2546 :
2547 0 : }
2548 :
2549 :
2550 : // Convert a string into an Tag
2551 0 : void CalAppPhaseRow::calReductionIdFromText(const string & s) {
2552 :
2553 :
2554 0 : calReductionId = ASDMValuesParser::parse<Tag>(s);
2555 :
2556 :
2557 0 : }
2558 :
2559 :
2560 : // Convert a string into an ArrayTime
2561 0 : void CalAppPhaseRow::startValidTimeFromText(const string & s) {
2562 :
2563 :
2564 0 : startValidTime = ASDMValuesParser::parse<ArrayTime>(s);
2565 :
2566 :
2567 0 : }
2568 :
2569 :
2570 : // Convert a string into an ArrayTime
2571 0 : void CalAppPhaseRow::endValidTimeFromText(const string & s) {
2572 :
2573 :
2574 0 : endValidTime = ASDMValuesParser::parse<ArrayTime>(s);
2575 :
2576 :
2577 0 : }
2578 :
2579 :
2580 : // Convert a string into an ArrayTime
2581 0 : void CalAppPhaseRow::adjustTimeFromText(const string & s) {
2582 :
2583 :
2584 0 : adjustTime = ASDMValuesParser::parse<ArrayTime>(s);
2585 :
2586 :
2587 0 : }
2588 :
2589 :
2590 : // Convert a string into an String
2591 0 : void CalAppPhaseRow::adjustTokenFromText(const string & s) {
2592 :
2593 :
2594 0 : adjustToken = ASDMValuesParser::parse<string>(s);
2595 :
2596 :
2597 0 : }
2598 :
2599 :
2600 : // Convert a string into an String
2601 0 : void CalAppPhaseRow::phasingModeFromText(const string & s) {
2602 :
2603 :
2604 0 : phasingMode = ASDMValuesParser::parse<string>(s);
2605 :
2606 :
2607 0 : }
2608 :
2609 :
2610 : // Convert a string into an int
2611 0 : void CalAppPhaseRow::numPhasedAntennasFromText(const string & s) {
2612 :
2613 :
2614 0 : numPhasedAntennas = ASDMValuesParser::parse<int>(s);
2615 :
2616 :
2617 0 : }
2618 :
2619 :
2620 : // Convert a string into an String
2621 0 : void CalAppPhaseRow::phasedAntennasFromText(const string & s) {
2622 :
2623 :
2624 0 : phasedAntennas = ASDMValuesParser::parse1D<string>(s);
2625 :
2626 :
2627 0 : }
2628 :
2629 :
2630 : // Convert a string into an int
2631 0 : void CalAppPhaseRow::refAntennaIndexFromText(const string & s) {
2632 :
2633 :
2634 0 : refAntennaIndex = ASDMValuesParser::parse<int>(s);
2635 :
2636 :
2637 0 : }
2638 :
2639 :
2640 : // Convert a string into an int
2641 0 : void CalAppPhaseRow::candRefAntennaIndexFromText(const string & s) {
2642 :
2643 :
2644 0 : candRefAntennaIndex = ASDMValuesParser::parse<int>(s);
2645 :
2646 :
2647 0 : }
2648 :
2649 :
2650 : // Convert a string into an String
2651 0 : void CalAppPhaseRow::phasePackingFromText(const string & s) {
2652 :
2653 :
2654 0 : phasePacking = ASDMValuesParser::parse<string>(s);
2655 :
2656 :
2657 0 : }
2658 :
2659 :
2660 : // Convert a string into an int
2661 0 : void CalAppPhaseRow::numReceptorsFromText(const string & s) {
2662 :
2663 :
2664 0 : numReceptors = ASDMValuesParser::parse<int>(s);
2665 :
2666 :
2667 0 : }
2668 :
2669 :
2670 : // Convert a string into an int
2671 0 : void CalAppPhaseRow::numChannelsFromText(const string & s) {
2672 :
2673 :
2674 0 : numChannels = ASDMValuesParser::parse<int>(s);
2675 :
2676 :
2677 0 : }
2678 :
2679 :
2680 : // Convert a string into an int
2681 0 : void CalAppPhaseRow::numPhaseValuesFromText(const string & s) {
2682 :
2683 :
2684 0 : numPhaseValues = ASDMValuesParser::parse<int>(s);
2685 :
2686 :
2687 0 : }
2688 :
2689 :
2690 : // Convert a string into an float
2691 0 : void CalAppPhaseRow::phaseValuesFromText(const string & s) {
2692 :
2693 :
2694 0 : phaseValues = ASDMValuesParser::parse1D<float>(s);
2695 :
2696 :
2697 0 : }
2698 :
2699 :
2700 : // Convert a string into an int
2701 0 : void CalAppPhaseRow::numCompareFromText(const string & s) {
2702 :
2703 :
2704 0 : numCompare = ASDMValuesParser::parse<int>(s);
2705 :
2706 :
2707 0 : }
2708 :
2709 :
2710 : // Convert a string into an int
2711 0 : void CalAppPhaseRow::numEfficienciesFromText(const string & s) {
2712 :
2713 :
2714 0 : numEfficiencies = ASDMValuesParser::parse<int>(s);
2715 :
2716 :
2717 0 : }
2718 :
2719 :
2720 : // Convert a string into an String
2721 0 : void CalAppPhaseRow::compareArrayFromText(const string & s) {
2722 :
2723 :
2724 0 : compareArray = ASDMValuesParser::parse1D<string>(s);
2725 :
2726 :
2727 0 : }
2728 :
2729 :
2730 : // Convert a string into an int
2731 0 : void CalAppPhaseRow::efficiencyIndicesFromText(const string & s) {
2732 :
2733 :
2734 0 : efficiencyIndices = ASDMValuesParser::parse1D<int>(s);
2735 :
2736 :
2737 0 : }
2738 :
2739 :
2740 : // Convert a string into an float
2741 0 : void CalAppPhaseRow::efficienciesFromText(const string & s) {
2742 :
2743 :
2744 0 : efficiencies = ASDMValuesParser::parse2D<float>(s);
2745 :
2746 :
2747 0 : }
2748 :
2749 :
2750 : // Convert a string into an float
2751 0 : void CalAppPhaseRow::qualityFromText(const string & s) {
2752 :
2753 :
2754 0 : quality = ASDMValuesParser::parse1D<float>(s);
2755 :
2756 :
2757 0 : }
2758 :
2759 :
2760 : // Convert a string into an String
2761 0 : void CalAppPhaseRow::phasedSumAntennaFromText(const string & s) {
2762 :
2763 :
2764 0 : phasedSumAntenna = ASDMValuesParser::parse<string>(s);
2765 :
2766 :
2767 0 : }
2768 :
2769 :
2770 :
2771 : // Convert a string into an String
2772 0 : void CalAppPhaseRow::typeSupportsFromText(const string & s) {
2773 0 : typeSupportsExists = true;
2774 :
2775 :
2776 0 : typeSupports = ASDMValuesParser::parse<string>(s);
2777 :
2778 :
2779 0 : }
2780 :
2781 :
2782 : // Convert a string into an int
2783 0 : void CalAppPhaseRow::numSupportsFromText(const string & s) {
2784 0 : numSupportsExists = true;
2785 :
2786 :
2787 0 : numSupports = ASDMValuesParser::parse<int>(s);
2788 :
2789 :
2790 0 : }
2791 :
2792 :
2793 : // Convert a string into an float
2794 0 : void CalAppPhaseRow::phaseSupportsFromText(const string & s) {
2795 0 : phaseSupportsExists = true;
2796 :
2797 :
2798 0 : phaseSupports = ASDMValuesParser::parse1D<float>(s);
2799 :
2800 :
2801 0 : }
2802 :
2803 :
2804 :
2805 0 : void CalAppPhaseRow::fromText(const std::string& attributeName, const std::string& t) {
2806 0 : map<string, CalAppPhaseAttributeFromText>::iterator iter;
2807 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
2808 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "CalAppPhaseTable");
2809 0 : (this->*(iter->second))(t);
2810 0 : }
2811 :
2812 : ////////////////////////////////////////////////
2813 : // Intrinsic Table Attributes getters/setters //
2814 : ////////////////////////////////////////////////
2815 :
2816 :
2817 :
2818 :
2819 : /**
2820 : * Get basebandName.
2821 : * @return basebandName as BasebandNameMod::BasebandName
2822 : */
2823 0 : BasebandNameMod::BasebandName CalAppPhaseRow::getBasebandName() const {
2824 :
2825 0 : return basebandName;
2826 : }
2827 :
2828 : /**
2829 : * Set basebandName with the specified BasebandNameMod::BasebandName.
2830 : * @param basebandName The BasebandNameMod::BasebandName value to which basebandName is to be set.
2831 :
2832 :
2833 :
2834 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2835 :
2836 : */
2837 0 : void CalAppPhaseRow::setBasebandName (BasebandNameMod::BasebandName basebandName) {
2838 :
2839 :
2840 0 : if (hasBeenAdded) {
2841 :
2842 0 : throw IllegalAccessException("basebandName", "CalAppPhase");
2843 :
2844 : }
2845 :
2846 0 : this->basebandName = basebandName;
2847 :
2848 0 : }
2849 :
2850 :
2851 :
2852 :
2853 :
2854 :
2855 : /**
2856 : * Get scanNumber.
2857 : * @return scanNumber as int
2858 : */
2859 0 : int CalAppPhaseRow::getScanNumber() const {
2860 :
2861 0 : return scanNumber;
2862 : }
2863 :
2864 : /**
2865 : * Set scanNumber with the specified int.
2866 : * @param scanNumber The int value to which scanNumber is to be set.
2867 :
2868 :
2869 :
2870 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2871 :
2872 : */
2873 0 : void CalAppPhaseRow::setScanNumber (int scanNumber) {
2874 :
2875 :
2876 0 : if (hasBeenAdded) {
2877 :
2878 0 : throw IllegalAccessException("scanNumber", "CalAppPhase");
2879 :
2880 : }
2881 :
2882 0 : this->scanNumber = scanNumber;
2883 :
2884 0 : }
2885 :
2886 :
2887 :
2888 :
2889 :
2890 :
2891 : /**
2892 : * Get startValidTime.
2893 : * @return startValidTime as ArrayTime
2894 : */
2895 0 : ArrayTime CalAppPhaseRow::getStartValidTime() const {
2896 :
2897 0 : return startValidTime;
2898 : }
2899 :
2900 : /**
2901 : * Set startValidTime with the specified ArrayTime.
2902 : * @param startValidTime The ArrayTime value to which startValidTime is to be set.
2903 :
2904 :
2905 :
2906 : */
2907 0 : void CalAppPhaseRow::setStartValidTime (ArrayTime startValidTime) {
2908 :
2909 :
2910 0 : if (hasBeenAdded) {
2911 :
2912 : }
2913 :
2914 0 : this->startValidTime = startValidTime;
2915 :
2916 0 : }
2917 :
2918 :
2919 :
2920 :
2921 :
2922 :
2923 : /**
2924 : * Get endValidTime.
2925 : * @return endValidTime as ArrayTime
2926 : */
2927 0 : ArrayTime CalAppPhaseRow::getEndValidTime() const {
2928 :
2929 0 : return endValidTime;
2930 : }
2931 :
2932 : /**
2933 : * Set endValidTime with the specified ArrayTime.
2934 : * @param endValidTime The ArrayTime value to which endValidTime is to be set.
2935 :
2936 :
2937 :
2938 : */
2939 0 : void CalAppPhaseRow::setEndValidTime (ArrayTime endValidTime) {
2940 :
2941 :
2942 0 : if (hasBeenAdded) {
2943 :
2944 : }
2945 :
2946 0 : this->endValidTime = endValidTime;
2947 :
2948 0 : }
2949 :
2950 :
2951 :
2952 :
2953 :
2954 :
2955 : /**
2956 : * Get adjustTime.
2957 : * @return adjustTime as ArrayTime
2958 : */
2959 0 : ArrayTime CalAppPhaseRow::getAdjustTime() const {
2960 :
2961 0 : return adjustTime;
2962 : }
2963 :
2964 : /**
2965 : * Set adjustTime with the specified ArrayTime.
2966 : * @param adjustTime The ArrayTime value to which adjustTime is to be set.
2967 :
2968 :
2969 :
2970 : */
2971 0 : void CalAppPhaseRow::setAdjustTime (ArrayTime adjustTime) {
2972 :
2973 :
2974 0 : if (hasBeenAdded) {
2975 :
2976 : }
2977 :
2978 0 : this->adjustTime = adjustTime;
2979 :
2980 0 : }
2981 :
2982 :
2983 :
2984 :
2985 :
2986 :
2987 : /**
2988 : * Get adjustToken.
2989 : * @return adjustToken as std::string
2990 : */
2991 0 : std::string CalAppPhaseRow::getAdjustToken() const {
2992 :
2993 0 : return adjustToken;
2994 : }
2995 :
2996 : /**
2997 : * Set adjustToken with the specified std::string.
2998 : * @param adjustToken The std::string value to which adjustToken is to be set.
2999 :
3000 :
3001 :
3002 : */
3003 0 : void CalAppPhaseRow::setAdjustToken (std::string adjustToken) {
3004 :
3005 :
3006 0 : if (hasBeenAdded) {
3007 :
3008 : }
3009 :
3010 0 : this->adjustToken = adjustToken;
3011 :
3012 0 : }
3013 :
3014 :
3015 :
3016 :
3017 :
3018 :
3019 : /**
3020 : * Get phasingMode.
3021 : * @return phasingMode as std::string
3022 : */
3023 0 : std::string CalAppPhaseRow::getPhasingMode() const {
3024 :
3025 0 : return phasingMode;
3026 : }
3027 :
3028 : /**
3029 : * Set phasingMode with the specified std::string.
3030 : * @param phasingMode The std::string value to which phasingMode is to be set.
3031 :
3032 :
3033 :
3034 : */
3035 0 : void CalAppPhaseRow::setPhasingMode (std::string phasingMode) {
3036 :
3037 :
3038 0 : if (hasBeenAdded) {
3039 :
3040 : }
3041 :
3042 0 : this->phasingMode = phasingMode;
3043 :
3044 0 : }
3045 :
3046 :
3047 :
3048 :
3049 :
3050 :
3051 : /**
3052 : * Get numPhasedAntennas.
3053 : * @return numPhasedAntennas as int
3054 : */
3055 0 : int CalAppPhaseRow::getNumPhasedAntennas() const {
3056 :
3057 0 : return numPhasedAntennas;
3058 : }
3059 :
3060 : /**
3061 : * Set numPhasedAntennas with the specified int.
3062 : * @param numPhasedAntennas The int value to which numPhasedAntennas is to be set.
3063 :
3064 :
3065 :
3066 : */
3067 0 : void CalAppPhaseRow::setNumPhasedAntennas (int numPhasedAntennas) {
3068 :
3069 :
3070 0 : if (hasBeenAdded) {
3071 :
3072 : }
3073 :
3074 0 : this->numPhasedAntennas = numPhasedAntennas;
3075 :
3076 0 : }
3077 :
3078 :
3079 :
3080 :
3081 :
3082 :
3083 : /**
3084 : * Get phasedAntennas.
3085 : * @return phasedAntennas as std::vector<std::string >
3086 : */
3087 0 : std::vector<std::string > CalAppPhaseRow::getPhasedAntennas() const {
3088 :
3089 0 : return phasedAntennas;
3090 : }
3091 :
3092 : /**
3093 : * Set phasedAntennas with the specified std::vector<std::string >.
3094 : * @param phasedAntennas The std::vector<std::string > value to which phasedAntennas is to be set.
3095 :
3096 :
3097 :
3098 : */
3099 0 : void CalAppPhaseRow::setPhasedAntennas (std::vector<std::string > phasedAntennas) {
3100 :
3101 :
3102 0 : if (hasBeenAdded) {
3103 :
3104 : }
3105 :
3106 0 : this->phasedAntennas = phasedAntennas;
3107 :
3108 0 : }
3109 :
3110 :
3111 :
3112 :
3113 :
3114 :
3115 : /**
3116 : * Get refAntennaIndex.
3117 : * @return refAntennaIndex as int
3118 : */
3119 0 : int CalAppPhaseRow::getRefAntennaIndex() const {
3120 :
3121 0 : return refAntennaIndex;
3122 : }
3123 :
3124 : /**
3125 : * Set refAntennaIndex with the specified int.
3126 : * @param refAntennaIndex The int value to which refAntennaIndex is to be set.
3127 :
3128 :
3129 :
3130 : */
3131 0 : void CalAppPhaseRow::setRefAntennaIndex (int refAntennaIndex) {
3132 :
3133 :
3134 0 : if (hasBeenAdded) {
3135 :
3136 : }
3137 :
3138 0 : this->refAntennaIndex = refAntennaIndex;
3139 :
3140 0 : }
3141 :
3142 :
3143 :
3144 :
3145 :
3146 :
3147 : /**
3148 : * Get candRefAntennaIndex.
3149 : * @return candRefAntennaIndex as int
3150 : */
3151 0 : int CalAppPhaseRow::getCandRefAntennaIndex() const {
3152 :
3153 0 : return candRefAntennaIndex;
3154 : }
3155 :
3156 : /**
3157 : * Set candRefAntennaIndex with the specified int.
3158 : * @param candRefAntennaIndex The int value to which candRefAntennaIndex is to be set.
3159 :
3160 :
3161 :
3162 : */
3163 0 : void CalAppPhaseRow::setCandRefAntennaIndex (int candRefAntennaIndex) {
3164 :
3165 :
3166 0 : if (hasBeenAdded) {
3167 :
3168 : }
3169 :
3170 0 : this->candRefAntennaIndex = candRefAntennaIndex;
3171 :
3172 0 : }
3173 :
3174 :
3175 :
3176 :
3177 :
3178 :
3179 : /**
3180 : * Get phasePacking.
3181 : * @return phasePacking as std::string
3182 : */
3183 0 : std::string CalAppPhaseRow::getPhasePacking() const {
3184 :
3185 0 : return phasePacking;
3186 : }
3187 :
3188 : /**
3189 : * Set phasePacking with the specified std::string.
3190 : * @param phasePacking The std::string value to which phasePacking is to be set.
3191 :
3192 :
3193 :
3194 : */
3195 0 : void CalAppPhaseRow::setPhasePacking (std::string phasePacking) {
3196 :
3197 :
3198 0 : if (hasBeenAdded) {
3199 :
3200 : }
3201 :
3202 0 : this->phasePacking = phasePacking;
3203 :
3204 0 : }
3205 :
3206 :
3207 :
3208 :
3209 :
3210 :
3211 : /**
3212 : * Get numReceptors.
3213 : * @return numReceptors as int
3214 : */
3215 0 : int CalAppPhaseRow::getNumReceptors() const {
3216 :
3217 0 : return numReceptors;
3218 : }
3219 :
3220 : /**
3221 : * Set numReceptors with the specified int.
3222 : * @param numReceptors The int value to which numReceptors is to be set.
3223 :
3224 :
3225 :
3226 : */
3227 0 : void CalAppPhaseRow::setNumReceptors (int numReceptors) {
3228 :
3229 :
3230 0 : if (hasBeenAdded) {
3231 :
3232 : }
3233 :
3234 0 : this->numReceptors = numReceptors;
3235 :
3236 0 : }
3237 :
3238 :
3239 :
3240 :
3241 :
3242 :
3243 : /**
3244 : * Get numChannels.
3245 : * @return numChannels as int
3246 : */
3247 0 : int CalAppPhaseRow::getNumChannels() const {
3248 :
3249 0 : return numChannels;
3250 : }
3251 :
3252 : /**
3253 : * Set numChannels with the specified int.
3254 : * @param numChannels The int value to which numChannels is to be set.
3255 :
3256 :
3257 :
3258 : */
3259 0 : void CalAppPhaseRow::setNumChannels (int numChannels) {
3260 :
3261 :
3262 0 : if (hasBeenAdded) {
3263 :
3264 : }
3265 :
3266 0 : this->numChannels = numChannels;
3267 :
3268 0 : }
3269 :
3270 :
3271 :
3272 :
3273 :
3274 :
3275 : /**
3276 : * Get numPhaseValues.
3277 : * @return numPhaseValues as int
3278 : */
3279 0 : int CalAppPhaseRow::getNumPhaseValues() const {
3280 :
3281 0 : return numPhaseValues;
3282 : }
3283 :
3284 : /**
3285 : * Set numPhaseValues with the specified int.
3286 : * @param numPhaseValues The int value to which numPhaseValues is to be set.
3287 :
3288 :
3289 :
3290 : */
3291 0 : void CalAppPhaseRow::setNumPhaseValues (int numPhaseValues) {
3292 :
3293 :
3294 0 : if (hasBeenAdded) {
3295 :
3296 : }
3297 :
3298 0 : this->numPhaseValues = numPhaseValues;
3299 :
3300 0 : }
3301 :
3302 :
3303 :
3304 :
3305 :
3306 :
3307 : /**
3308 : * Get phaseValues.
3309 : * @return phaseValues as std::vector<float >
3310 : */
3311 0 : std::vector<float > CalAppPhaseRow::getPhaseValues() const {
3312 :
3313 0 : return phaseValues;
3314 : }
3315 :
3316 : /**
3317 : * Set phaseValues with the specified std::vector<float >.
3318 : * @param phaseValues The std::vector<float > value to which phaseValues is to be set.
3319 :
3320 :
3321 :
3322 : */
3323 0 : void CalAppPhaseRow::setPhaseValues (std::vector<float > phaseValues) {
3324 :
3325 :
3326 0 : if (hasBeenAdded) {
3327 :
3328 : }
3329 :
3330 0 : this->phaseValues = phaseValues;
3331 :
3332 0 : }
3333 :
3334 :
3335 :
3336 :
3337 :
3338 :
3339 : /**
3340 : * Get numCompare.
3341 : * @return numCompare as int
3342 : */
3343 0 : int CalAppPhaseRow::getNumCompare() const {
3344 :
3345 0 : return numCompare;
3346 : }
3347 :
3348 : /**
3349 : * Set numCompare with the specified int.
3350 : * @param numCompare The int value to which numCompare is to be set.
3351 :
3352 :
3353 :
3354 : */
3355 0 : void CalAppPhaseRow::setNumCompare (int numCompare) {
3356 :
3357 :
3358 0 : if (hasBeenAdded) {
3359 :
3360 : }
3361 :
3362 0 : this->numCompare = numCompare;
3363 :
3364 0 : }
3365 :
3366 :
3367 :
3368 :
3369 :
3370 :
3371 : /**
3372 : * Get numEfficiencies.
3373 : * @return numEfficiencies as int
3374 : */
3375 0 : int CalAppPhaseRow::getNumEfficiencies() const {
3376 :
3377 0 : return numEfficiencies;
3378 : }
3379 :
3380 : /**
3381 : * Set numEfficiencies with the specified int.
3382 : * @param numEfficiencies The int value to which numEfficiencies is to be set.
3383 :
3384 :
3385 :
3386 : */
3387 0 : void CalAppPhaseRow::setNumEfficiencies (int numEfficiencies) {
3388 :
3389 :
3390 0 : if (hasBeenAdded) {
3391 :
3392 : }
3393 :
3394 0 : this->numEfficiencies = numEfficiencies;
3395 :
3396 0 : }
3397 :
3398 :
3399 :
3400 :
3401 :
3402 :
3403 : /**
3404 : * Get compareArray.
3405 : * @return compareArray as std::vector<std::string >
3406 : */
3407 0 : std::vector<std::string > CalAppPhaseRow::getCompareArray() const {
3408 :
3409 0 : return compareArray;
3410 : }
3411 :
3412 : /**
3413 : * Set compareArray with the specified std::vector<std::string >.
3414 : * @param compareArray The std::vector<std::string > value to which compareArray is to be set.
3415 :
3416 :
3417 :
3418 : */
3419 0 : void CalAppPhaseRow::setCompareArray (std::vector<std::string > compareArray) {
3420 :
3421 :
3422 0 : if (hasBeenAdded) {
3423 :
3424 : }
3425 :
3426 0 : this->compareArray = compareArray;
3427 :
3428 0 : }
3429 :
3430 :
3431 :
3432 :
3433 :
3434 :
3435 : /**
3436 : * Get efficiencyIndices.
3437 : * @return efficiencyIndices as std::vector<int >
3438 : */
3439 0 : std::vector<int > CalAppPhaseRow::getEfficiencyIndices() const {
3440 :
3441 0 : return efficiencyIndices;
3442 : }
3443 :
3444 : /**
3445 : * Set efficiencyIndices with the specified std::vector<int >.
3446 : * @param efficiencyIndices The std::vector<int > value to which efficiencyIndices is to be set.
3447 :
3448 :
3449 :
3450 : */
3451 0 : void CalAppPhaseRow::setEfficiencyIndices (std::vector<int > efficiencyIndices) {
3452 :
3453 :
3454 0 : if (hasBeenAdded) {
3455 :
3456 : }
3457 :
3458 0 : this->efficiencyIndices = efficiencyIndices;
3459 :
3460 0 : }
3461 :
3462 :
3463 :
3464 :
3465 :
3466 :
3467 : /**
3468 : * Get efficiencies.
3469 : * @return efficiencies as std::vector<std::vector<float > >
3470 : */
3471 0 : std::vector<std::vector<float > > CalAppPhaseRow::getEfficiencies() const {
3472 :
3473 0 : return efficiencies;
3474 : }
3475 :
3476 : /**
3477 : * Set efficiencies with the specified std::vector<std::vector<float > >.
3478 : * @param efficiencies The std::vector<std::vector<float > > value to which efficiencies is to be set.
3479 :
3480 :
3481 :
3482 : */
3483 0 : void CalAppPhaseRow::setEfficiencies (std::vector<std::vector<float > > efficiencies) {
3484 :
3485 :
3486 0 : if (hasBeenAdded) {
3487 :
3488 : }
3489 :
3490 0 : this->efficiencies = efficiencies;
3491 :
3492 0 : }
3493 :
3494 :
3495 :
3496 :
3497 :
3498 :
3499 : /**
3500 : * Get quality.
3501 : * @return quality as std::vector<float >
3502 : */
3503 0 : std::vector<float > CalAppPhaseRow::getQuality() const {
3504 :
3505 0 : return quality;
3506 : }
3507 :
3508 : /**
3509 : * Set quality with the specified std::vector<float >.
3510 : * @param quality The std::vector<float > value to which quality is to be set.
3511 :
3512 :
3513 :
3514 : */
3515 0 : void CalAppPhaseRow::setQuality (std::vector<float > quality) {
3516 :
3517 :
3518 0 : if (hasBeenAdded) {
3519 :
3520 : }
3521 :
3522 0 : this->quality = quality;
3523 :
3524 0 : }
3525 :
3526 :
3527 :
3528 :
3529 :
3530 :
3531 : /**
3532 : * Get phasedSumAntenna.
3533 : * @return phasedSumAntenna as std::string
3534 : */
3535 0 : std::string CalAppPhaseRow::getPhasedSumAntenna() const {
3536 :
3537 0 : return phasedSumAntenna;
3538 : }
3539 :
3540 : /**
3541 : * Set phasedSumAntenna with the specified std::string.
3542 : * @param phasedSumAntenna The std::string value to which phasedSumAntenna is to be set.
3543 :
3544 :
3545 :
3546 : */
3547 0 : void CalAppPhaseRow::setPhasedSumAntenna (std::string phasedSumAntenna) {
3548 :
3549 :
3550 0 : if (hasBeenAdded) {
3551 :
3552 : }
3553 :
3554 0 : this->phasedSumAntenna = phasedSumAntenna;
3555 :
3556 0 : }
3557 :
3558 :
3559 :
3560 :
3561 : /**
3562 : * The attribute typeSupports is optional. Return true if this attribute exists.
3563 : * @return true if and only if the typeSupports attribute exists.
3564 : */
3565 0 : bool CalAppPhaseRow::isTypeSupportsExists() const {
3566 0 : return typeSupportsExists;
3567 : }
3568 :
3569 :
3570 :
3571 : /**
3572 : * Get typeSupports, which is optional.
3573 : * @return typeSupports as std::string
3574 : * @throw IllegalAccessException If typeSupports does not exist.
3575 : */
3576 0 : std::string CalAppPhaseRow::getTypeSupports() const {
3577 0 : if (!typeSupportsExists) {
3578 0 : throw IllegalAccessException("typeSupports", "CalAppPhase");
3579 : }
3580 :
3581 0 : return typeSupports;
3582 : }
3583 :
3584 : /**
3585 : * Set typeSupports with the specified std::string.
3586 : * @param typeSupports The std::string value to which typeSupports is to be set.
3587 :
3588 :
3589 : */
3590 0 : void CalAppPhaseRow::setTypeSupports (std::string typeSupports) {
3591 :
3592 0 : this->typeSupports = typeSupports;
3593 :
3594 0 : typeSupportsExists = true;
3595 :
3596 0 : }
3597 :
3598 :
3599 : /**
3600 : * Mark typeSupports, which is an optional field, as non-existent.
3601 : */
3602 0 : void CalAppPhaseRow::clearTypeSupports () {
3603 0 : typeSupportsExists = false;
3604 0 : }
3605 :
3606 :
3607 :
3608 : /**
3609 : * The attribute numSupports is optional. Return true if this attribute exists.
3610 : * @return true if and only if the numSupports attribute exists.
3611 : */
3612 0 : bool CalAppPhaseRow::isNumSupportsExists() const {
3613 0 : return numSupportsExists;
3614 : }
3615 :
3616 :
3617 :
3618 : /**
3619 : * Get numSupports, which is optional.
3620 : * @return numSupports as int
3621 : * @throw IllegalAccessException If numSupports does not exist.
3622 : */
3623 0 : int CalAppPhaseRow::getNumSupports() const {
3624 0 : if (!numSupportsExists) {
3625 0 : throw IllegalAccessException("numSupports", "CalAppPhase");
3626 : }
3627 :
3628 0 : return numSupports;
3629 : }
3630 :
3631 : /**
3632 : * Set numSupports with the specified int.
3633 : * @param numSupports The int value to which numSupports is to be set.
3634 :
3635 :
3636 : */
3637 0 : void CalAppPhaseRow::setNumSupports (int numSupports) {
3638 :
3639 0 : this->numSupports = numSupports;
3640 :
3641 0 : numSupportsExists = true;
3642 :
3643 0 : }
3644 :
3645 :
3646 : /**
3647 : * Mark numSupports, which is an optional field, as non-existent.
3648 : */
3649 0 : void CalAppPhaseRow::clearNumSupports () {
3650 0 : numSupportsExists = false;
3651 0 : }
3652 :
3653 :
3654 :
3655 : /**
3656 : * The attribute phaseSupports is optional. Return true if this attribute exists.
3657 : * @return true if and only if the phaseSupports attribute exists.
3658 : */
3659 0 : bool CalAppPhaseRow::isPhaseSupportsExists() const {
3660 0 : return phaseSupportsExists;
3661 : }
3662 :
3663 :
3664 :
3665 : /**
3666 : * Get phaseSupports, which is optional.
3667 : * @return phaseSupports as std::vector<float >
3668 : * @throw IllegalAccessException If phaseSupports does not exist.
3669 : */
3670 0 : std::vector<float > CalAppPhaseRow::getPhaseSupports() const {
3671 0 : if (!phaseSupportsExists) {
3672 0 : throw IllegalAccessException("phaseSupports", "CalAppPhase");
3673 : }
3674 :
3675 0 : return phaseSupports;
3676 : }
3677 :
3678 : /**
3679 : * Set phaseSupports with the specified std::vector<float >.
3680 : * @param phaseSupports The std::vector<float > value to which phaseSupports is to be set.
3681 :
3682 :
3683 : */
3684 0 : void CalAppPhaseRow::setPhaseSupports (std::vector<float > phaseSupports) {
3685 :
3686 0 : this->phaseSupports = phaseSupports;
3687 :
3688 0 : phaseSupportsExists = true;
3689 :
3690 0 : }
3691 :
3692 :
3693 : /**
3694 : * Mark phaseSupports, which is an optional field, as non-existent.
3695 : */
3696 0 : void CalAppPhaseRow::clearPhaseSupports () {
3697 0 : phaseSupportsExists = false;
3698 0 : }
3699 :
3700 :
3701 :
3702 : ///////////////////////////////////////////////
3703 : // Extrinsic Table Attributes getters/setters//
3704 : ///////////////////////////////////////////////
3705 :
3706 :
3707 :
3708 :
3709 : /**
3710 : * Get calDataId.
3711 : * @return calDataId as Tag
3712 : */
3713 0 : Tag CalAppPhaseRow::getCalDataId() const {
3714 :
3715 0 : return calDataId;
3716 : }
3717 :
3718 : /**
3719 : * Set calDataId with the specified Tag.
3720 : * @param calDataId The Tag value to which calDataId is to be set.
3721 :
3722 :
3723 :
3724 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
3725 :
3726 : */
3727 0 : void CalAppPhaseRow::setCalDataId (Tag calDataId) {
3728 :
3729 :
3730 0 : if (hasBeenAdded) {
3731 :
3732 0 : throw IllegalAccessException("calDataId", "CalAppPhase");
3733 :
3734 : }
3735 :
3736 0 : this->calDataId = calDataId;
3737 :
3738 0 : }
3739 :
3740 :
3741 :
3742 :
3743 :
3744 :
3745 : /**
3746 : * Get calReductionId.
3747 : * @return calReductionId as Tag
3748 : */
3749 0 : Tag CalAppPhaseRow::getCalReductionId() const {
3750 :
3751 0 : return calReductionId;
3752 : }
3753 :
3754 : /**
3755 : * Set calReductionId with the specified Tag.
3756 : * @param calReductionId The Tag value to which calReductionId is to be set.
3757 :
3758 :
3759 :
3760 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
3761 :
3762 : */
3763 0 : void CalAppPhaseRow::setCalReductionId (Tag calReductionId) {
3764 :
3765 :
3766 0 : if (hasBeenAdded) {
3767 :
3768 0 : throw IllegalAccessException("calReductionId", "CalAppPhase");
3769 :
3770 : }
3771 :
3772 0 : this->calReductionId = calReductionId;
3773 :
3774 0 : }
3775 :
3776 :
3777 :
3778 :
3779 : //////////////////////////////////////
3780 : // Links Attributes getters/setters //
3781 : //////////////////////////////////////
3782 :
3783 :
3784 :
3785 :
3786 :
3787 :
3788 : /**
3789 : * Returns the pointer to the row in the CalData table having CalData.calDataId == calDataId
3790 : * @return a CalDataRow*
3791 : *
3792 :
3793 : */
3794 0 : CalDataRow* CalAppPhaseRow::getCalDataUsingCalDataId() {
3795 :
3796 0 : return table.getContainer().getCalData().getRowByKey(calDataId);
3797 : }
3798 :
3799 :
3800 :
3801 :
3802 :
3803 :
3804 :
3805 :
3806 :
3807 : /**
3808 : * Returns the pointer to the row in the CalReduction table having CalReduction.calReductionId == calReductionId
3809 : * @return a CalReductionRow*
3810 : *
3811 :
3812 : */
3813 0 : CalReductionRow* CalAppPhaseRow::getCalReductionUsingCalReductionId() {
3814 :
3815 0 : return table.getContainer().getCalReduction().getRowByKey(calReductionId);
3816 : }
3817 :
3818 :
3819 :
3820 :
3821 :
3822 : /**
3823 : * Create a CalAppPhaseRow.
3824 : * <p>
3825 : * This constructor is private because only the
3826 : * table can create rows. All rows know the table
3827 : * to which they belong.
3828 : * @param table The table to which this row belongs.
3829 : */
3830 0 : CalAppPhaseRow::CalAppPhaseRow (CalAppPhaseTable &t) : table(t) {
3831 0 : hasBeenAdded = false;
3832 :
3833 :
3834 :
3835 :
3836 :
3837 :
3838 :
3839 :
3840 :
3841 :
3842 :
3843 :
3844 :
3845 :
3846 :
3847 :
3848 :
3849 :
3850 :
3851 :
3852 :
3853 :
3854 :
3855 :
3856 :
3857 :
3858 :
3859 :
3860 :
3861 :
3862 :
3863 :
3864 :
3865 :
3866 :
3867 :
3868 :
3869 :
3870 :
3871 :
3872 :
3873 :
3874 :
3875 :
3876 :
3877 :
3878 :
3879 :
3880 :
3881 0 : typeSupportsExists = false;
3882 :
3883 :
3884 :
3885 0 : numSupportsExists = false;
3886 :
3887 :
3888 :
3889 0 : phaseSupportsExists = false;
3890 :
3891 :
3892 :
3893 :
3894 :
3895 :
3896 :
3897 :
3898 :
3899 :
3900 :
3901 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
3902 0 : basebandName = CBasebandName::from_int(0);
3903 :
3904 :
3905 :
3906 :
3907 :
3908 :
3909 :
3910 :
3911 :
3912 :
3913 :
3914 :
3915 :
3916 :
3917 :
3918 :
3919 :
3920 :
3921 :
3922 :
3923 :
3924 :
3925 :
3926 :
3927 :
3928 :
3929 :
3930 :
3931 :
3932 :
3933 :
3934 :
3935 :
3936 :
3937 :
3938 :
3939 :
3940 :
3941 :
3942 :
3943 :
3944 :
3945 :
3946 :
3947 :
3948 :
3949 :
3950 :
3951 :
3952 :
3953 :
3954 :
3955 :
3956 :
3957 0 : fromBinMethods["basebandName"] = &CalAppPhaseRow::basebandNameFromBin;
3958 0 : fromBinMethods["scanNumber"] = &CalAppPhaseRow::scanNumberFromBin;
3959 0 : fromBinMethods["calDataId"] = &CalAppPhaseRow::calDataIdFromBin;
3960 0 : fromBinMethods["calReductionId"] = &CalAppPhaseRow::calReductionIdFromBin;
3961 0 : fromBinMethods["startValidTime"] = &CalAppPhaseRow::startValidTimeFromBin;
3962 0 : fromBinMethods["endValidTime"] = &CalAppPhaseRow::endValidTimeFromBin;
3963 0 : fromBinMethods["adjustTime"] = &CalAppPhaseRow::adjustTimeFromBin;
3964 0 : fromBinMethods["adjustToken"] = &CalAppPhaseRow::adjustTokenFromBin;
3965 0 : fromBinMethods["phasingMode"] = &CalAppPhaseRow::phasingModeFromBin;
3966 0 : fromBinMethods["numPhasedAntennas"] = &CalAppPhaseRow::numPhasedAntennasFromBin;
3967 0 : fromBinMethods["phasedAntennas"] = &CalAppPhaseRow::phasedAntennasFromBin;
3968 0 : fromBinMethods["refAntennaIndex"] = &CalAppPhaseRow::refAntennaIndexFromBin;
3969 0 : fromBinMethods["candRefAntennaIndex"] = &CalAppPhaseRow::candRefAntennaIndexFromBin;
3970 0 : fromBinMethods["phasePacking"] = &CalAppPhaseRow::phasePackingFromBin;
3971 0 : fromBinMethods["numReceptors"] = &CalAppPhaseRow::numReceptorsFromBin;
3972 0 : fromBinMethods["numChannels"] = &CalAppPhaseRow::numChannelsFromBin;
3973 0 : fromBinMethods["numPhaseValues"] = &CalAppPhaseRow::numPhaseValuesFromBin;
3974 0 : fromBinMethods["phaseValues"] = &CalAppPhaseRow::phaseValuesFromBin;
3975 0 : fromBinMethods["numCompare"] = &CalAppPhaseRow::numCompareFromBin;
3976 0 : fromBinMethods["numEfficiencies"] = &CalAppPhaseRow::numEfficienciesFromBin;
3977 0 : fromBinMethods["compareArray"] = &CalAppPhaseRow::compareArrayFromBin;
3978 0 : fromBinMethods["efficiencyIndices"] = &CalAppPhaseRow::efficiencyIndicesFromBin;
3979 0 : fromBinMethods["efficiencies"] = &CalAppPhaseRow::efficienciesFromBin;
3980 0 : fromBinMethods["quality"] = &CalAppPhaseRow::qualityFromBin;
3981 0 : fromBinMethods["phasedSumAntenna"] = &CalAppPhaseRow::phasedSumAntennaFromBin;
3982 :
3983 :
3984 0 : fromBinMethods["typeSupports"] = &CalAppPhaseRow::typeSupportsFromBin;
3985 0 : fromBinMethods["numSupports"] = &CalAppPhaseRow::numSupportsFromBin;
3986 0 : fromBinMethods["phaseSupports"] = &CalAppPhaseRow::phaseSupportsFromBin;
3987 :
3988 :
3989 :
3990 :
3991 :
3992 0 : fromTextMethods["basebandName"] = &CalAppPhaseRow::basebandNameFromText;
3993 :
3994 :
3995 :
3996 0 : fromTextMethods["scanNumber"] = &CalAppPhaseRow::scanNumberFromText;
3997 :
3998 :
3999 :
4000 0 : fromTextMethods["calDataId"] = &CalAppPhaseRow::calDataIdFromText;
4001 :
4002 :
4003 :
4004 0 : fromTextMethods["calReductionId"] = &CalAppPhaseRow::calReductionIdFromText;
4005 :
4006 :
4007 :
4008 0 : fromTextMethods["startValidTime"] = &CalAppPhaseRow::startValidTimeFromText;
4009 :
4010 :
4011 :
4012 0 : fromTextMethods["endValidTime"] = &CalAppPhaseRow::endValidTimeFromText;
4013 :
4014 :
4015 :
4016 0 : fromTextMethods["adjustTime"] = &CalAppPhaseRow::adjustTimeFromText;
4017 :
4018 :
4019 :
4020 0 : fromTextMethods["adjustToken"] = &CalAppPhaseRow::adjustTokenFromText;
4021 :
4022 :
4023 :
4024 0 : fromTextMethods["phasingMode"] = &CalAppPhaseRow::phasingModeFromText;
4025 :
4026 :
4027 :
4028 0 : fromTextMethods["numPhasedAntennas"] = &CalAppPhaseRow::numPhasedAntennasFromText;
4029 :
4030 :
4031 :
4032 0 : fromTextMethods["phasedAntennas"] = &CalAppPhaseRow::phasedAntennasFromText;
4033 :
4034 :
4035 :
4036 0 : fromTextMethods["refAntennaIndex"] = &CalAppPhaseRow::refAntennaIndexFromText;
4037 :
4038 :
4039 :
4040 0 : fromTextMethods["candRefAntennaIndex"] = &CalAppPhaseRow::candRefAntennaIndexFromText;
4041 :
4042 :
4043 :
4044 0 : fromTextMethods["phasePacking"] = &CalAppPhaseRow::phasePackingFromText;
4045 :
4046 :
4047 :
4048 0 : fromTextMethods["numReceptors"] = &CalAppPhaseRow::numReceptorsFromText;
4049 :
4050 :
4051 :
4052 0 : fromTextMethods["numChannels"] = &CalAppPhaseRow::numChannelsFromText;
4053 :
4054 :
4055 :
4056 0 : fromTextMethods["numPhaseValues"] = &CalAppPhaseRow::numPhaseValuesFromText;
4057 :
4058 :
4059 :
4060 0 : fromTextMethods["phaseValues"] = &CalAppPhaseRow::phaseValuesFromText;
4061 :
4062 :
4063 :
4064 0 : fromTextMethods["numCompare"] = &CalAppPhaseRow::numCompareFromText;
4065 :
4066 :
4067 :
4068 0 : fromTextMethods["numEfficiencies"] = &CalAppPhaseRow::numEfficienciesFromText;
4069 :
4070 :
4071 :
4072 0 : fromTextMethods["compareArray"] = &CalAppPhaseRow::compareArrayFromText;
4073 :
4074 :
4075 :
4076 0 : fromTextMethods["efficiencyIndices"] = &CalAppPhaseRow::efficiencyIndicesFromText;
4077 :
4078 :
4079 :
4080 0 : fromTextMethods["efficiencies"] = &CalAppPhaseRow::efficienciesFromText;
4081 :
4082 :
4083 :
4084 0 : fromTextMethods["quality"] = &CalAppPhaseRow::qualityFromText;
4085 :
4086 :
4087 :
4088 0 : fromTextMethods["phasedSumAntenna"] = &CalAppPhaseRow::phasedSumAntennaFromText;
4089 :
4090 :
4091 :
4092 :
4093 :
4094 0 : fromTextMethods["typeSupports"] = &CalAppPhaseRow::typeSupportsFromText;
4095 :
4096 :
4097 :
4098 0 : fromTextMethods["numSupports"] = &CalAppPhaseRow::numSupportsFromText;
4099 :
4100 :
4101 :
4102 0 : fromTextMethods["phaseSupports"] = &CalAppPhaseRow::phaseSupportsFromText;
4103 :
4104 :
4105 0 : }
4106 :
4107 0 : CalAppPhaseRow::CalAppPhaseRow (CalAppPhaseTable &t, CalAppPhaseRow *row) : table(t) {
4108 0 : hasBeenAdded = false;
4109 :
4110 0 : if (row == 0) {
4111 :
4112 :
4113 :
4114 :
4115 :
4116 :
4117 :
4118 :
4119 :
4120 :
4121 :
4122 :
4123 :
4124 :
4125 :
4126 :
4127 :
4128 :
4129 :
4130 :
4131 :
4132 :
4133 :
4134 :
4135 :
4136 :
4137 :
4138 :
4139 :
4140 :
4141 :
4142 :
4143 :
4144 :
4145 :
4146 :
4147 :
4148 :
4149 :
4150 :
4151 :
4152 :
4153 :
4154 :
4155 :
4156 :
4157 :
4158 :
4159 :
4160 0 : typeSupportsExists = false;
4161 :
4162 :
4163 :
4164 0 : numSupportsExists = false;
4165 :
4166 :
4167 :
4168 0 : phaseSupportsExists = false;
4169 :
4170 :
4171 :
4172 :
4173 :
4174 :
4175 :
4176 : }
4177 : else {
4178 :
4179 :
4180 0 : basebandName = row->basebandName;
4181 :
4182 0 : scanNumber = row->scanNumber;
4183 :
4184 0 : calDataId = row->calDataId;
4185 :
4186 0 : calReductionId = row->calReductionId;
4187 :
4188 :
4189 :
4190 :
4191 0 : startValidTime = row->startValidTime;
4192 :
4193 0 : endValidTime = row->endValidTime;
4194 :
4195 0 : adjustTime = row->adjustTime;
4196 :
4197 0 : adjustToken = row->adjustToken;
4198 :
4199 0 : phasingMode = row->phasingMode;
4200 :
4201 0 : numPhasedAntennas = row->numPhasedAntennas;
4202 :
4203 0 : phasedAntennas = row->phasedAntennas;
4204 :
4205 0 : refAntennaIndex = row->refAntennaIndex;
4206 :
4207 0 : candRefAntennaIndex = row->candRefAntennaIndex;
4208 :
4209 0 : phasePacking = row->phasePacking;
4210 :
4211 0 : numReceptors = row->numReceptors;
4212 :
4213 0 : numChannels = row->numChannels;
4214 :
4215 0 : numPhaseValues = row->numPhaseValues;
4216 :
4217 0 : phaseValues = row->phaseValues;
4218 :
4219 0 : numCompare = row->numCompare;
4220 :
4221 0 : numEfficiencies = row->numEfficiencies;
4222 :
4223 0 : compareArray = row->compareArray;
4224 :
4225 0 : efficiencyIndices = row->efficiencyIndices;
4226 :
4227 0 : efficiencies = row->efficiencies;
4228 :
4229 0 : quality = row->quality;
4230 :
4231 0 : phasedSumAntenna = row->phasedSumAntenna;
4232 :
4233 :
4234 :
4235 :
4236 0 : if (row->typeSupportsExists) {
4237 0 : typeSupports = row->typeSupports;
4238 0 : typeSupportsExists = true;
4239 : }
4240 : else
4241 0 : typeSupportsExists = false;
4242 :
4243 0 : if (row->numSupportsExists) {
4244 0 : numSupports = row->numSupports;
4245 0 : numSupportsExists = true;
4246 : }
4247 : else
4248 0 : numSupportsExists = false;
4249 :
4250 0 : if (row->phaseSupportsExists) {
4251 0 : phaseSupports = row->phaseSupports;
4252 0 : phaseSupportsExists = true;
4253 : }
4254 : else
4255 0 : phaseSupportsExists = false;
4256 :
4257 : }
4258 :
4259 0 : fromBinMethods["basebandName"] = &CalAppPhaseRow::basebandNameFromBin;
4260 0 : fromBinMethods["scanNumber"] = &CalAppPhaseRow::scanNumberFromBin;
4261 0 : fromBinMethods["calDataId"] = &CalAppPhaseRow::calDataIdFromBin;
4262 0 : fromBinMethods["calReductionId"] = &CalAppPhaseRow::calReductionIdFromBin;
4263 0 : fromBinMethods["startValidTime"] = &CalAppPhaseRow::startValidTimeFromBin;
4264 0 : fromBinMethods["endValidTime"] = &CalAppPhaseRow::endValidTimeFromBin;
4265 0 : fromBinMethods["adjustTime"] = &CalAppPhaseRow::adjustTimeFromBin;
4266 0 : fromBinMethods["adjustToken"] = &CalAppPhaseRow::adjustTokenFromBin;
4267 0 : fromBinMethods["phasingMode"] = &CalAppPhaseRow::phasingModeFromBin;
4268 0 : fromBinMethods["numPhasedAntennas"] = &CalAppPhaseRow::numPhasedAntennasFromBin;
4269 0 : fromBinMethods["phasedAntennas"] = &CalAppPhaseRow::phasedAntennasFromBin;
4270 0 : fromBinMethods["refAntennaIndex"] = &CalAppPhaseRow::refAntennaIndexFromBin;
4271 0 : fromBinMethods["candRefAntennaIndex"] = &CalAppPhaseRow::candRefAntennaIndexFromBin;
4272 0 : fromBinMethods["phasePacking"] = &CalAppPhaseRow::phasePackingFromBin;
4273 0 : fromBinMethods["numReceptors"] = &CalAppPhaseRow::numReceptorsFromBin;
4274 0 : fromBinMethods["numChannels"] = &CalAppPhaseRow::numChannelsFromBin;
4275 0 : fromBinMethods["numPhaseValues"] = &CalAppPhaseRow::numPhaseValuesFromBin;
4276 0 : fromBinMethods["phaseValues"] = &CalAppPhaseRow::phaseValuesFromBin;
4277 0 : fromBinMethods["numCompare"] = &CalAppPhaseRow::numCompareFromBin;
4278 0 : fromBinMethods["numEfficiencies"] = &CalAppPhaseRow::numEfficienciesFromBin;
4279 0 : fromBinMethods["compareArray"] = &CalAppPhaseRow::compareArrayFromBin;
4280 0 : fromBinMethods["efficiencyIndices"] = &CalAppPhaseRow::efficiencyIndicesFromBin;
4281 0 : fromBinMethods["efficiencies"] = &CalAppPhaseRow::efficienciesFromBin;
4282 0 : fromBinMethods["quality"] = &CalAppPhaseRow::qualityFromBin;
4283 0 : fromBinMethods["phasedSumAntenna"] = &CalAppPhaseRow::phasedSumAntennaFromBin;
4284 :
4285 :
4286 0 : fromBinMethods["typeSupports"] = &CalAppPhaseRow::typeSupportsFromBin;
4287 0 : fromBinMethods["numSupports"] = &CalAppPhaseRow::numSupportsFromBin;
4288 0 : fromBinMethods["phaseSupports"] = &CalAppPhaseRow::phaseSupportsFromBin;
4289 :
4290 0 : }
4291 :
4292 :
4293 0 : bool CalAppPhaseRow::compareNoAutoInc(BasebandNameMod::BasebandName basebandName, int scanNumber, Tag calDataId, Tag calReductionId, ArrayTime startValidTime, ArrayTime endValidTime, ArrayTime adjustTime, std::string adjustToken, std::string phasingMode, int numPhasedAntennas, std::vector<std::string > phasedAntennas, int refAntennaIndex, int candRefAntennaIndex, std::string phasePacking, int numReceptors, int numChannels, int numPhaseValues, std::vector<float > phaseValues, int numCompare, int numEfficiencies, std::vector<std::string > compareArray, std::vector<int > efficiencyIndices, std::vector<std::vector<float > > efficiencies, std::vector<float > quality, std::string phasedSumAntenna) {
4294 : bool result;
4295 0 : result = true;
4296 :
4297 :
4298 :
4299 0 : result = result && (this->basebandName == basebandName);
4300 :
4301 0 : if (!result) return false;
4302 :
4303 :
4304 :
4305 :
4306 0 : result = result && (this->scanNumber == scanNumber);
4307 :
4308 0 : if (!result) return false;
4309 :
4310 :
4311 :
4312 :
4313 0 : result = result && (this->calDataId == calDataId);
4314 :
4315 0 : if (!result) return false;
4316 :
4317 :
4318 :
4319 :
4320 0 : result = result && (this->calReductionId == calReductionId);
4321 :
4322 0 : if (!result) return false;
4323 :
4324 :
4325 :
4326 :
4327 0 : result = result && (this->startValidTime == startValidTime);
4328 :
4329 0 : if (!result) return false;
4330 :
4331 :
4332 :
4333 :
4334 0 : result = result && (this->endValidTime == endValidTime);
4335 :
4336 0 : if (!result) return false;
4337 :
4338 :
4339 :
4340 :
4341 0 : result = result && (this->adjustTime == adjustTime);
4342 :
4343 0 : if (!result) return false;
4344 :
4345 :
4346 :
4347 :
4348 0 : result = result && (this->adjustToken == adjustToken);
4349 :
4350 0 : if (!result) return false;
4351 :
4352 :
4353 :
4354 :
4355 0 : result = result && (this->phasingMode == phasingMode);
4356 :
4357 0 : if (!result) return false;
4358 :
4359 :
4360 :
4361 :
4362 0 : result = result && (this->numPhasedAntennas == numPhasedAntennas);
4363 :
4364 0 : if (!result) return false;
4365 :
4366 :
4367 :
4368 :
4369 0 : result = result && (this->phasedAntennas == phasedAntennas);
4370 :
4371 0 : if (!result) return false;
4372 :
4373 :
4374 :
4375 :
4376 0 : result = result && (this->refAntennaIndex == refAntennaIndex);
4377 :
4378 0 : if (!result) return false;
4379 :
4380 :
4381 :
4382 :
4383 0 : result = result && (this->candRefAntennaIndex == candRefAntennaIndex);
4384 :
4385 0 : if (!result) return false;
4386 :
4387 :
4388 :
4389 :
4390 0 : result = result && (this->phasePacking == phasePacking);
4391 :
4392 0 : if (!result) return false;
4393 :
4394 :
4395 :
4396 :
4397 0 : result = result && (this->numReceptors == numReceptors);
4398 :
4399 0 : if (!result) return false;
4400 :
4401 :
4402 :
4403 :
4404 0 : result = result && (this->numChannels == numChannels);
4405 :
4406 0 : if (!result) return false;
4407 :
4408 :
4409 :
4410 :
4411 0 : result = result && (this->numPhaseValues == numPhaseValues);
4412 :
4413 0 : if (!result) return false;
4414 :
4415 :
4416 :
4417 :
4418 0 : result = result && (this->phaseValues == phaseValues);
4419 :
4420 0 : if (!result) return false;
4421 :
4422 :
4423 :
4424 :
4425 0 : result = result && (this->numCompare == numCompare);
4426 :
4427 0 : if (!result) return false;
4428 :
4429 :
4430 :
4431 :
4432 0 : result = result && (this->numEfficiencies == numEfficiencies);
4433 :
4434 0 : if (!result) return false;
4435 :
4436 :
4437 :
4438 :
4439 0 : result = result && (this->compareArray == compareArray);
4440 :
4441 0 : if (!result) return false;
4442 :
4443 :
4444 :
4445 :
4446 0 : result = result && (this->efficiencyIndices == efficiencyIndices);
4447 :
4448 0 : if (!result) return false;
4449 :
4450 :
4451 :
4452 :
4453 0 : result = result && (this->efficiencies == efficiencies);
4454 :
4455 0 : if (!result) return false;
4456 :
4457 :
4458 :
4459 :
4460 0 : result = result && (this->quality == quality);
4461 :
4462 0 : if (!result) return false;
4463 :
4464 :
4465 :
4466 :
4467 0 : result = result && (this->phasedSumAntenna == phasedSumAntenna);
4468 :
4469 0 : if (!result) return false;
4470 :
4471 :
4472 0 : return result;
4473 : }
4474 :
4475 :
4476 :
4477 0 : bool CalAppPhaseRow::compareRequiredValue(ArrayTime startValidTime, ArrayTime endValidTime, ArrayTime adjustTime, std::string adjustToken, std::string phasingMode, int numPhasedAntennas, std::vector<std::string > phasedAntennas, int refAntennaIndex, int candRefAntennaIndex, std::string phasePacking, int numReceptors, int numChannels, int numPhaseValues, std::vector<float > phaseValues, int numCompare, int numEfficiencies, std::vector<std::string > compareArray, std::vector<int > efficiencyIndices, std::vector<std::vector<float > > efficiencies, std::vector<float > quality, std::string phasedSumAntenna) {
4478 : bool result;
4479 0 : result = true;
4480 :
4481 :
4482 0 : if (!(this->startValidTime == startValidTime)) return false;
4483 :
4484 :
4485 :
4486 0 : if (!(this->endValidTime == endValidTime)) return false;
4487 :
4488 :
4489 :
4490 0 : if (!(this->adjustTime == adjustTime)) return false;
4491 :
4492 :
4493 :
4494 0 : if (!(this->adjustToken == adjustToken)) return false;
4495 :
4496 :
4497 :
4498 0 : if (!(this->phasingMode == phasingMode)) return false;
4499 :
4500 :
4501 :
4502 0 : if (!(this->numPhasedAntennas == numPhasedAntennas)) return false;
4503 :
4504 :
4505 :
4506 0 : if (!(this->phasedAntennas == phasedAntennas)) return false;
4507 :
4508 :
4509 :
4510 0 : if (!(this->refAntennaIndex == refAntennaIndex)) return false;
4511 :
4512 :
4513 :
4514 0 : if (!(this->candRefAntennaIndex == candRefAntennaIndex)) return false;
4515 :
4516 :
4517 :
4518 0 : if (!(this->phasePacking == phasePacking)) return false;
4519 :
4520 :
4521 :
4522 0 : if (!(this->numReceptors == numReceptors)) return false;
4523 :
4524 :
4525 :
4526 0 : if (!(this->numChannels == numChannels)) return false;
4527 :
4528 :
4529 :
4530 0 : if (!(this->numPhaseValues == numPhaseValues)) return false;
4531 :
4532 :
4533 :
4534 0 : if (!(this->phaseValues == phaseValues)) return false;
4535 :
4536 :
4537 :
4538 0 : if (!(this->numCompare == numCompare)) return false;
4539 :
4540 :
4541 :
4542 0 : if (!(this->numEfficiencies == numEfficiencies)) return false;
4543 :
4544 :
4545 :
4546 0 : if (!(this->compareArray == compareArray)) return false;
4547 :
4548 :
4549 :
4550 0 : if (!(this->efficiencyIndices == efficiencyIndices)) return false;
4551 :
4552 :
4553 :
4554 0 : if (!(this->efficiencies == efficiencies)) return false;
4555 :
4556 :
4557 :
4558 0 : if (!(this->quality == quality)) return false;
4559 :
4560 :
4561 :
4562 0 : if (!(this->phasedSumAntenna == phasedSumAntenna)) return false;
4563 :
4564 :
4565 0 : return result;
4566 : }
4567 :
4568 :
4569 : /**
4570 : * Return true if all required attributes of the value part are equal to their homologues
4571 : * in x and false otherwise.
4572 : *
4573 :
4574 : * @param x a pointer on the CalAppPhaseRow whose required attributes of the value part
4575 :
4576 : * will be compared with those of this.
4577 : * @return a boolean.
4578 : */
4579 0 : bool CalAppPhaseRow::equalByRequiredValue(CalAppPhaseRow* x ) {
4580 :
4581 :
4582 0 : if (this->startValidTime != x->startValidTime) return false;
4583 :
4584 0 : if (this->endValidTime != x->endValidTime) return false;
4585 :
4586 0 : if (this->adjustTime != x->adjustTime) return false;
4587 :
4588 0 : if (this->adjustToken != x->adjustToken) return false;
4589 :
4590 0 : if (this->phasingMode != x->phasingMode) return false;
4591 :
4592 0 : if (this->numPhasedAntennas != x->numPhasedAntennas) return false;
4593 :
4594 0 : if (this->phasedAntennas != x->phasedAntennas) return false;
4595 :
4596 0 : if (this->refAntennaIndex != x->refAntennaIndex) return false;
4597 :
4598 0 : if (this->candRefAntennaIndex != x->candRefAntennaIndex) return false;
4599 :
4600 0 : if (this->phasePacking != x->phasePacking) return false;
4601 :
4602 0 : if (this->numReceptors != x->numReceptors) return false;
4603 :
4604 0 : if (this->numChannels != x->numChannels) return false;
4605 :
4606 0 : if (this->numPhaseValues != x->numPhaseValues) return false;
4607 :
4608 0 : if (this->phaseValues != x->phaseValues) return false;
4609 :
4610 0 : if (this->numCompare != x->numCompare) return false;
4611 :
4612 0 : if (this->numEfficiencies != x->numEfficiencies) return false;
4613 :
4614 0 : if (this->compareArray != x->compareArray) return false;
4615 :
4616 0 : if (this->efficiencyIndices != x->efficiencyIndices) return false;
4617 :
4618 0 : if (this->efficiencies != x->efficiencies) return false;
4619 :
4620 0 : if (this->quality != x->quality) return false;
4621 :
4622 0 : if (this->phasedSumAntenna != x->phasedSumAntenna) return false;
4623 :
4624 :
4625 0 : return true;
4626 : }
4627 :
4628 : /*
4629 : map<string, CalAppPhaseAttributeFromBin> CalAppPhaseRow::initFromBinMethods() {
4630 : map<string, CalAppPhaseAttributeFromBin> result;
4631 :
4632 : result["basebandName"] = &CalAppPhaseRow::basebandNameFromBin;
4633 : result["scanNumber"] = &CalAppPhaseRow::scanNumberFromBin;
4634 : result["calDataId"] = &CalAppPhaseRow::calDataIdFromBin;
4635 : result["calReductionId"] = &CalAppPhaseRow::calReductionIdFromBin;
4636 : result["startValidTime"] = &CalAppPhaseRow::startValidTimeFromBin;
4637 : result["endValidTime"] = &CalAppPhaseRow::endValidTimeFromBin;
4638 : result["adjustTime"] = &CalAppPhaseRow::adjustTimeFromBin;
4639 : result["adjustToken"] = &CalAppPhaseRow::adjustTokenFromBin;
4640 : result["phasingMode"] = &CalAppPhaseRow::phasingModeFromBin;
4641 : result["numPhasedAntennas"] = &CalAppPhaseRow::numPhasedAntennasFromBin;
4642 : result["phasedAntennas"] = &CalAppPhaseRow::phasedAntennasFromBin;
4643 : result["refAntennaIndex"] = &CalAppPhaseRow::refAntennaIndexFromBin;
4644 : result["candRefAntennaIndex"] = &CalAppPhaseRow::candRefAntennaIndexFromBin;
4645 : result["phasePacking"] = &CalAppPhaseRow::phasePackingFromBin;
4646 : result["numReceptors"] = &CalAppPhaseRow::numReceptorsFromBin;
4647 : result["numChannels"] = &CalAppPhaseRow::numChannelsFromBin;
4648 : result["numPhaseValues"] = &CalAppPhaseRow::numPhaseValuesFromBin;
4649 : result["phaseValues"] = &CalAppPhaseRow::phaseValuesFromBin;
4650 : result["numCompare"] = &CalAppPhaseRow::numCompareFromBin;
4651 : result["numEfficiencies"] = &CalAppPhaseRow::numEfficienciesFromBin;
4652 : result["compareArray"] = &CalAppPhaseRow::compareArrayFromBin;
4653 : result["efficiencyIndices"] = &CalAppPhaseRow::efficiencyIndicesFromBin;
4654 : result["efficiencies"] = &CalAppPhaseRow::efficienciesFromBin;
4655 : result["quality"] = &CalAppPhaseRow::qualityFromBin;
4656 : result["phasedSumAntenna"] = &CalAppPhaseRow::phasedSumAntennaFromBin;
4657 :
4658 :
4659 : result["typeSupports"] = &CalAppPhaseRow::typeSupportsFromBin;
4660 : result["numSupports"] = &CalAppPhaseRow::numSupportsFromBin;
4661 : result["phaseSupports"] = &CalAppPhaseRow::phaseSupportsFromBin;
4662 :
4663 :
4664 : return result;
4665 : }
4666 : */
4667 : } // End namespace asdm
4668 :
|
