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