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 CalAmpliRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/CalAmpliRow.h>
39 : #include <alma/ASDM/CalAmpliTable.h>
40 :
41 : #include <alma/ASDM/CalDataTable.h>
42 : #include <alma/ASDM/CalDataRow.h>
43 :
44 : #include <alma/ASDM/CalReductionTable.h>
45 : #include <alma/ASDM/CalReductionRow.h>
46 :
47 :
48 : using asdm::ASDM;
49 : using asdm::CalAmpliRow;
50 : using asdm::CalAmpliTable;
51 :
52 : using asdm::CalDataTable;
53 : using asdm::CalDataRow;
54 :
55 : using asdm::CalReductionTable;
56 : using asdm::CalReductionRow;
57 :
58 :
59 : #include <alma/ASDM/Parser.h>
60 :
61 : #include <alma/ASDM/EnumerationParser.h>
62 : #include <alma/ASDM/ASDMValuesParser.h>
63 :
64 : #include <alma/ASDM/InvalidArgumentException.h>
65 :
66 : using namespace std;
67 :
68 : namespace asdm {
69 0 : CalAmpliRow::~CalAmpliRow() {
70 0 : }
71 :
72 : /**
73 : * Return the table to which this row belongs.
74 : */
75 0 : CalAmpliTable &CalAmpliRow::getTable() const {
76 0 : return table;
77 : }
78 :
79 0 : bool CalAmpliRow::isAdded() const {
80 0 : return hasBeenAdded;
81 : }
82 :
83 0 : void CalAmpliRow::isAdded(bool added) {
84 0 : hasBeenAdded = added;
85 0 : }
86 :
87 : #ifndef WITHOUT_ACS
88 : using asdmIDL::CalAmpliRowIDL;
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 CalAmpliRowIDL struct.
95 : */
96 : CalAmpliRowIDL *CalAmpliRow::toIDL() const {
97 : CalAmpliRowIDL *x = new CalAmpliRowIDL ();
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->atmPhaseCorrection = atmPhaseCorrection;
121 :
122 :
123 :
124 :
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 : x->receiverBand = receiverBand;
133 :
134 :
135 :
136 :
137 :
138 :
139 :
140 :
141 :
142 :
143 :
144 : x->basebandName = basebandName;
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 :
153 :
154 :
155 :
156 : x->numReceptor = numReceptor;
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 :
165 :
166 :
167 : x->polarizationTypes.length(polarizationTypes.size());
168 : for (unsigned int i = 0; i < polarizationTypes.size(); ++i) {
169 :
170 :
171 : x->polarizationTypes[i] = polarizationTypes.at(i);
172 :
173 :
174 : }
175 :
176 :
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 : x->startValidTime = startValidTime.toIDLArrayTime();
185 :
186 :
187 :
188 :
189 :
190 :
191 :
192 :
193 :
194 : x->endValidTime = endValidTime.toIDLArrayTime();
195 :
196 :
197 :
198 :
199 :
200 :
201 :
202 :
203 :
204 : x->frequencyRange.length(frequencyRange.size());
205 : for (unsigned int i = 0; i < frequencyRange.size(); ++i) {
206 :
207 : x->frequencyRange[i] = frequencyRange.at(i).toIDLFrequency();
208 :
209 : }
210 :
211 :
212 :
213 :
214 :
215 :
216 :
217 :
218 :
219 : x->apertureEfficiency.length(apertureEfficiency.size());
220 : for (unsigned int i = 0; i < apertureEfficiency.size(); ++i) {
221 :
222 :
223 : x->apertureEfficiency[i] = apertureEfficiency.at(i);
224 :
225 :
226 : }
227 :
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 :
236 : x->apertureEfficiencyError.length(apertureEfficiencyError.size());
237 : for (unsigned int i = 0; i < apertureEfficiencyError.size(); ++i) {
238 :
239 :
240 : x->apertureEfficiencyError[i] = apertureEfficiencyError.at(i);
241 :
242 :
243 : }
244 :
245 :
246 :
247 :
248 :
249 :
250 :
251 : x->correctionValidityExists = correctionValidityExists;
252 :
253 :
254 :
255 :
256 : x->correctionValidity = correctionValidity;
257 :
258 :
259 :
260 :
261 :
262 :
263 :
264 :
265 :
266 :
267 :
268 :
269 :
270 :
271 : x->calDataId = calDataId.toIDLTag();
272 :
273 :
274 :
275 :
276 :
277 :
278 :
279 :
280 :
281 :
282 : x->calReductionId = calReductionId.toIDLTag();
283 :
284 :
285 :
286 :
287 :
288 :
289 :
290 :
291 :
292 :
293 :
294 : return x;
295 :
296 : }
297 :
298 : void CalAmpliRow::toIDL(asdmIDL::CalAmpliRowIDL& x) const {
299 : // Set the x's fields.
300 :
301 :
302 :
303 :
304 :
305 :
306 :
307 :
308 : x.antennaName = CORBA::string_dup(antennaName.c_str());
309 :
310 :
311 :
312 :
313 :
314 :
315 :
316 :
317 :
318 :
319 :
320 : x.atmPhaseCorrection = atmPhaseCorrection;
321 :
322 :
323 :
324 :
325 :
326 :
327 :
328 :
329 :
330 :
331 :
332 : x.receiverBand = receiverBand;
333 :
334 :
335 :
336 :
337 :
338 :
339 :
340 :
341 :
342 :
343 :
344 : x.basebandName = basebandName;
345 :
346 :
347 :
348 :
349 :
350 :
351 :
352 :
353 :
354 :
355 :
356 : x.numReceptor = numReceptor;
357 :
358 :
359 :
360 :
361 :
362 :
363 :
364 :
365 :
366 :
367 : x.polarizationTypes.length(polarizationTypes.size());
368 : for (unsigned int i = 0; i < polarizationTypes.size(); ++i) {
369 :
370 :
371 : x.polarizationTypes[i] = polarizationTypes.at(i);
372 :
373 :
374 : }
375 :
376 :
377 :
378 :
379 :
380 :
381 :
382 :
383 :
384 : x.startValidTime = startValidTime.toIDLArrayTime();
385 :
386 :
387 :
388 :
389 :
390 :
391 :
392 :
393 :
394 : x.endValidTime = endValidTime.toIDLArrayTime();
395 :
396 :
397 :
398 :
399 :
400 :
401 :
402 :
403 :
404 : x.frequencyRange.length(frequencyRange.size());
405 : for (unsigned int i = 0; i < frequencyRange.size(); ++i) {
406 :
407 : x.frequencyRange[i] = frequencyRange.at(i).toIDLFrequency();
408 :
409 : }
410 :
411 :
412 :
413 :
414 :
415 :
416 :
417 :
418 :
419 : x.apertureEfficiency.length(apertureEfficiency.size());
420 : for (unsigned int i = 0; i < apertureEfficiency.size(); ++i) {
421 :
422 :
423 : x.apertureEfficiency[i] = apertureEfficiency.at(i);
424 :
425 :
426 : }
427 :
428 :
429 :
430 :
431 :
432 :
433 :
434 :
435 :
436 : x.apertureEfficiencyError.length(apertureEfficiencyError.size());
437 : for (unsigned int i = 0; i < apertureEfficiencyError.size(); ++i) {
438 :
439 :
440 : x.apertureEfficiencyError[i] = apertureEfficiencyError.at(i);
441 :
442 :
443 : }
444 :
445 :
446 :
447 :
448 :
449 :
450 :
451 : x.correctionValidityExists = correctionValidityExists;
452 :
453 :
454 :
455 :
456 : x.correctionValidity = correctionValidity;
457 :
458 :
459 :
460 :
461 :
462 :
463 :
464 :
465 :
466 :
467 :
468 :
469 :
470 :
471 : x.calDataId = calDataId.toIDLTag();
472 :
473 :
474 :
475 :
476 :
477 :
478 :
479 :
480 :
481 :
482 : x.calReductionId = calReductionId.toIDLTag();
483 :
484 :
485 :
486 :
487 :
488 :
489 :
490 :
491 :
492 :
493 :
494 : }
495 : #endif
496 :
497 :
498 : #ifndef WITHOUT_ACS
499 : /**
500 : * Fill the values of this row from the IDL struct CalAmpliRowIDL.
501 : * @param x The IDL struct containing the values used to fill this row.
502 : */
503 : void CalAmpliRow::setFromIDL (CalAmpliRowIDL x){
504 : try {
505 : // Fill the values from x.
506 :
507 :
508 :
509 :
510 :
511 :
512 : setAntennaName(string (x.antennaName));
513 :
514 :
515 :
516 :
517 :
518 :
519 :
520 :
521 :
522 : setAtmPhaseCorrection(x.atmPhaseCorrection);
523 :
524 :
525 :
526 :
527 :
528 :
529 :
530 :
531 :
532 : setReceiverBand(x.receiverBand);
533 :
534 :
535 :
536 :
537 :
538 :
539 :
540 :
541 :
542 : setBasebandName(x.basebandName);
543 :
544 :
545 :
546 :
547 :
548 :
549 :
550 :
551 :
552 : setNumReceptor(x.numReceptor);
553 :
554 :
555 :
556 :
557 :
558 :
559 :
560 :
561 :
562 : polarizationTypes .clear();
563 : for (unsigned int i = 0; i <x.polarizationTypes.length(); ++i) {
564 :
565 : polarizationTypes.push_back(x.polarizationTypes[i]);
566 :
567 : }
568 :
569 :
570 :
571 :
572 :
573 :
574 :
575 :
576 :
577 : setStartValidTime(ArrayTime (x.startValidTime));
578 :
579 :
580 :
581 :
582 :
583 :
584 :
585 :
586 :
587 : setEndValidTime(ArrayTime (x.endValidTime));
588 :
589 :
590 :
591 :
592 :
593 :
594 :
595 :
596 :
597 : frequencyRange .clear();
598 : for (unsigned int i = 0; i <x.frequencyRange.length(); ++i) {
599 :
600 : frequencyRange.push_back(Frequency (x.frequencyRange[i]));
601 :
602 : }
603 :
604 :
605 :
606 :
607 :
608 :
609 :
610 :
611 :
612 : apertureEfficiency .clear();
613 : for (unsigned int i = 0; i <x.apertureEfficiency.length(); ++i) {
614 :
615 : apertureEfficiency.push_back(x.apertureEfficiency[i]);
616 :
617 : }
618 :
619 :
620 :
621 :
622 :
623 :
624 :
625 :
626 :
627 : apertureEfficiencyError .clear();
628 : for (unsigned int i = 0; i <x.apertureEfficiencyError.length(); ++i) {
629 :
630 : apertureEfficiencyError.push_back(x.apertureEfficiencyError[i]);
631 :
632 : }
633 :
634 :
635 :
636 :
637 :
638 :
639 :
640 : correctionValidityExists = x.correctionValidityExists;
641 : if (x.correctionValidityExists) {
642 :
643 :
644 :
645 : setCorrectionValidity(x.correctionValidity);
646 :
647 :
648 :
649 : }
650 :
651 :
652 :
653 :
654 :
655 :
656 :
657 :
658 :
659 :
660 : setCalDataId(Tag (x.calDataId));
661 :
662 :
663 :
664 :
665 :
666 :
667 :
668 :
669 :
670 : setCalReductionId(Tag (x.calReductionId));
671 :
672 :
673 :
674 :
675 :
676 :
677 :
678 :
679 :
680 :
681 :
682 : } catch (const IllegalAccessException &err) {
683 : throw ConversionException (err.getMessage(),"CalAmpli");
684 : }
685 : }
686 : #endif
687 :
688 : /**
689 : * Return this row in the form of an XML string.
690 : * @return The values of this row as an XML string.
691 : */
692 0 : string CalAmpliRow::toXML() const {
693 0 : string buf;
694 0 : buf.append("<row> \n");
695 :
696 :
697 :
698 :
699 :
700 :
701 0 : Parser::toXML(antennaName, "antennaName", buf);
702 :
703 :
704 :
705 :
706 :
707 :
708 :
709 0 : buf.append(EnumerationParser::toXML("atmPhaseCorrection", atmPhaseCorrection));
710 :
711 :
712 :
713 :
714 :
715 :
716 :
717 0 : buf.append(EnumerationParser::toXML("receiverBand", receiverBand));
718 :
719 :
720 :
721 :
722 :
723 :
724 :
725 0 : buf.append(EnumerationParser::toXML("basebandName", basebandName));
726 :
727 :
728 :
729 :
730 :
731 :
732 :
733 0 : Parser::toXML(numReceptor, "numReceptor", buf);
734 :
735 :
736 :
737 :
738 :
739 :
740 :
741 0 : buf.append(EnumerationParser::toXML("polarizationTypes", polarizationTypes));
742 :
743 :
744 :
745 :
746 :
747 :
748 :
749 0 : Parser::toXML(startValidTime, "startValidTime", buf);
750 :
751 :
752 :
753 :
754 :
755 :
756 :
757 0 : Parser::toXML(endValidTime, "endValidTime", buf);
758 :
759 :
760 :
761 :
762 :
763 :
764 :
765 0 : Parser::toXML(frequencyRange, "frequencyRange", buf);
766 :
767 :
768 :
769 :
770 :
771 :
772 :
773 0 : Parser::toXML(apertureEfficiency, "apertureEfficiency", buf);
774 :
775 :
776 :
777 :
778 :
779 :
780 :
781 0 : Parser::toXML(apertureEfficiencyError, "apertureEfficiencyError", buf);
782 :
783 :
784 :
785 :
786 :
787 :
788 0 : if (correctionValidityExists) {
789 :
790 :
791 0 : Parser::toXML(correctionValidity, "correctionValidity", buf);
792 :
793 :
794 : }
795 :
796 :
797 :
798 :
799 :
800 :
801 :
802 :
803 :
804 0 : Parser::toXML(calDataId, "calDataId", buf);
805 :
806 :
807 :
808 :
809 :
810 :
811 :
812 0 : Parser::toXML(calReductionId, "calReductionId", buf);
813 :
814 :
815 :
816 :
817 :
818 :
819 :
820 :
821 :
822 :
823 :
824 0 : buf.append("</row>\n");
825 0 : return buf;
826 : }
827 :
828 : /**
829 : * Fill the values of this row from an XML string
830 : * that was produced by the toXML() method.
831 : * @param x The XML string being used to set the values of this row.
832 : */
833 0 : void CalAmpliRow::setFromXML (string rowDoc) {
834 0 : Parser row(rowDoc);
835 0 : string s = "";
836 : try {
837 :
838 :
839 :
840 :
841 :
842 0 : setAntennaName(Parser::getString("antennaName","CalAmpli",rowDoc));
843 :
844 :
845 :
846 :
847 :
848 :
849 :
850 :
851 0 : atmPhaseCorrection = EnumerationParser::getAtmPhaseCorrection("atmPhaseCorrection","CalAmpli",rowDoc);
852 :
853 :
854 :
855 :
856 :
857 :
858 :
859 :
860 :
861 0 : receiverBand = EnumerationParser::getReceiverBand("receiverBand","CalAmpli",rowDoc);
862 :
863 :
864 :
865 :
866 :
867 :
868 :
869 :
870 :
871 0 : basebandName = EnumerationParser::getBasebandName("basebandName","CalAmpli",rowDoc);
872 :
873 :
874 :
875 :
876 :
877 :
878 :
879 :
880 0 : setNumReceptor(Parser::getInteger("numReceptor","CalAmpli",rowDoc));
881 :
882 :
883 :
884 :
885 :
886 :
887 :
888 :
889 0 : polarizationTypes = EnumerationParser::getPolarizationType1D("polarizationTypes","CalAmpli",rowDoc);
890 :
891 :
892 :
893 :
894 :
895 :
896 :
897 :
898 0 : setStartValidTime(Parser::getArrayTime("startValidTime","CalAmpli",rowDoc));
899 :
900 :
901 :
902 :
903 :
904 :
905 :
906 0 : setEndValidTime(Parser::getArrayTime("endValidTime","CalAmpli",rowDoc));
907 :
908 :
909 :
910 :
911 :
912 :
913 :
914 :
915 0 : setFrequencyRange(Parser::get1DFrequency("frequencyRange","CalAmpli",rowDoc));
916 :
917 :
918 :
919 :
920 :
921 :
922 :
923 :
924 :
925 0 : setApertureEfficiency(Parser::get1DFloat("apertureEfficiency","CalAmpli",rowDoc));
926 :
927 :
928 :
929 :
930 :
931 :
932 :
933 :
934 :
935 0 : setApertureEfficiencyError(Parser::get1DFloat("apertureEfficiencyError","CalAmpli",rowDoc));
936 :
937 :
938 :
939 :
940 :
941 :
942 :
943 0 : if (row.isStr("<correctionValidity>")) {
944 :
945 0 : setCorrectionValidity(Parser::getBoolean("correctionValidity","CalAmpli",rowDoc));
946 :
947 : }
948 :
949 :
950 :
951 :
952 :
953 :
954 :
955 :
956 :
957 0 : setCalDataId(Parser::getTag("calDataId","CalData",rowDoc));
958 :
959 :
960 :
961 :
962 :
963 :
964 :
965 0 : setCalReductionId(Parser::getTag("calReductionId","CalReduction",rowDoc));
966 :
967 :
968 :
969 :
970 :
971 :
972 :
973 :
974 :
975 :
976 0 : } catch (const IllegalAccessException &err) {
977 0 : throw ConversionException (err.getMessage(),"CalAmpli");
978 : }
979 0 : }
980 :
981 0 : void CalAmpliRow::toBin(EndianOSStream& eoss) {
982 :
983 :
984 :
985 :
986 :
987 :
988 0 : eoss.writeString(antennaName);
989 :
990 :
991 :
992 :
993 :
994 :
995 :
996 :
997 0 : eoss.writeString(CAtmPhaseCorrection::name(atmPhaseCorrection));
998 : /* eoss.writeInt(atmPhaseCorrection); */
999 :
1000 :
1001 :
1002 :
1003 :
1004 :
1005 :
1006 :
1007 0 : eoss.writeString(CReceiverBand::name(receiverBand));
1008 : /* eoss.writeInt(receiverBand); */
1009 :
1010 :
1011 :
1012 :
1013 :
1014 :
1015 :
1016 :
1017 0 : eoss.writeString(CBasebandName::name(basebandName));
1018 : /* eoss.writeInt(basebandName); */
1019 :
1020 :
1021 :
1022 :
1023 :
1024 :
1025 :
1026 0 : calDataId.toBin(eoss);
1027 :
1028 :
1029 :
1030 :
1031 :
1032 :
1033 0 : calReductionId.toBin(eoss);
1034 :
1035 :
1036 :
1037 :
1038 :
1039 :
1040 :
1041 0 : eoss.writeInt(numReceptor);
1042 :
1043 :
1044 :
1045 :
1046 :
1047 :
1048 :
1049 :
1050 :
1051 0 : eoss.writeInt((int) polarizationTypes.size());
1052 0 : for (unsigned int i = 0; i < polarizationTypes.size(); i++)
1053 :
1054 0 : eoss.writeString(CPolarizationType::name(polarizationTypes.at(i)));
1055 : /* eoss.writeInt(polarizationTypes.at(i)); */
1056 :
1057 :
1058 :
1059 :
1060 :
1061 :
1062 :
1063 :
1064 :
1065 0 : startValidTime.toBin(eoss);
1066 :
1067 :
1068 :
1069 :
1070 :
1071 :
1072 0 : endValidTime.toBin(eoss);
1073 :
1074 :
1075 :
1076 :
1077 :
1078 :
1079 0 : Frequency::toBin(frequencyRange, eoss);
1080 :
1081 :
1082 :
1083 :
1084 :
1085 :
1086 :
1087 :
1088 0 : eoss.writeInt((int) apertureEfficiency.size());
1089 0 : for (unsigned int i = 0; i < apertureEfficiency.size(); i++)
1090 :
1091 0 : eoss.writeFloat(apertureEfficiency.at(i));
1092 :
1093 :
1094 :
1095 :
1096 :
1097 :
1098 :
1099 :
1100 :
1101 :
1102 :
1103 0 : eoss.writeInt((int) apertureEfficiencyError.size());
1104 0 : for (unsigned int i = 0; i < apertureEfficiencyError.size(); i++)
1105 :
1106 0 : eoss.writeFloat(apertureEfficiencyError.at(i));
1107 :
1108 :
1109 :
1110 :
1111 :
1112 :
1113 :
1114 :
1115 :
1116 0 : eoss.writeBoolean(correctionValidityExists);
1117 0 : if (correctionValidityExists) {
1118 :
1119 :
1120 :
1121 :
1122 :
1123 0 : eoss.writeBoolean(correctionValidity);
1124 :
1125 :
1126 :
1127 :
1128 : }
1129 :
1130 0 : }
1131 :
1132 0 : void CalAmpliRow::antennaNameFromBin(EndianIStream& eis) {
1133 :
1134 :
1135 :
1136 :
1137 :
1138 0 : antennaName = eis.readString();
1139 :
1140 :
1141 :
1142 :
1143 0 : }
1144 0 : void CalAmpliRow::atmPhaseCorrectionFromBin(EndianIStream& eis) {
1145 :
1146 :
1147 :
1148 :
1149 :
1150 0 : atmPhaseCorrection = CAtmPhaseCorrection::literal(eis.readString());
1151 :
1152 :
1153 :
1154 :
1155 0 : }
1156 0 : void CalAmpliRow::receiverBandFromBin(EndianIStream& eis) {
1157 :
1158 :
1159 :
1160 :
1161 :
1162 0 : receiverBand = CReceiverBand::literal(eis.readString());
1163 :
1164 :
1165 :
1166 :
1167 0 : }
1168 0 : void CalAmpliRow::basebandNameFromBin(EndianIStream& eis) {
1169 :
1170 :
1171 :
1172 :
1173 :
1174 0 : basebandName = CBasebandName::literal(eis.readString());
1175 :
1176 :
1177 :
1178 :
1179 0 : }
1180 0 : void CalAmpliRow::calDataIdFromBin(EndianIStream& eis) {
1181 :
1182 :
1183 :
1184 :
1185 0 : calDataId = Tag::fromBin(eis);
1186 :
1187 :
1188 :
1189 0 : }
1190 0 : void CalAmpliRow::calReductionIdFromBin(EndianIStream& eis) {
1191 :
1192 :
1193 :
1194 :
1195 0 : calReductionId = Tag::fromBin(eis);
1196 :
1197 :
1198 :
1199 0 : }
1200 0 : void CalAmpliRow::numReceptorFromBin(EndianIStream& eis) {
1201 :
1202 :
1203 :
1204 :
1205 :
1206 0 : numReceptor = eis.readInt();
1207 :
1208 :
1209 :
1210 :
1211 0 : }
1212 0 : void CalAmpliRow::polarizationTypesFromBin(EndianIStream& eis) {
1213 :
1214 :
1215 :
1216 :
1217 :
1218 :
1219 0 : polarizationTypes.clear();
1220 :
1221 0 : unsigned int polarizationTypesDim1 = eis.readInt();
1222 0 : for (unsigned int i = 0 ; i < polarizationTypesDim1; i++)
1223 :
1224 0 : polarizationTypes.push_back(CPolarizationType::literal(eis.readString()));
1225 :
1226 :
1227 :
1228 :
1229 :
1230 :
1231 0 : }
1232 0 : void CalAmpliRow::startValidTimeFromBin(EndianIStream& eis) {
1233 :
1234 :
1235 :
1236 :
1237 0 : startValidTime = ArrayTime::fromBin(eis);
1238 :
1239 :
1240 :
1241 0 : }
1242 0 : void CalAmpliRow::endValidTimeFromBin(EndianIStream& eis) {
1243 :
1244 :
1245 :
1246 :
1247 0 : endValidTime = ArrayTime::fromBin(eis);
1248 :
1249 :
1250 :
1251 0 : }
1252 0 : void CalAmpliRow::frequencyRangeFromBin(EndianIStream& eis) {
1253 :
1254 :
1255 :
1256 :
1257 :
1258 :
1259 0 : frequencyRange = Frequency::from1DBin(eis);
1260 :
1261 :
1262 :
1263 :
1264 :
1265 0 : }
1266 0 : void CalAmpliRow::apertureEfficiencyFromBin(EndianIStream& eis) {
1267 :
1268 :
1269 :
1270 :
1271 :
1272 :
1273 0 : apertureEfficiency.clear();
1274 :
1275 0 : unsigned int apertureEfficiencyDim1 = eis.readInt();
1276 0 : for (unsigned int i = 0 ; i < apertureEfficiencyDim1; i++)
1277 :
1278 0 : apertureEfficiency.push_back(eis.readFloat());
1279 :
1280 :
1281 :
1282 :
1283 :
1284 :
1285 0 : }
1286 0 : void CalAmpliRow::apertureEfficiencyErrorFromBin(EndianIStream& eis) {
1287 :
1288 :
1289 :
1290 :
1291 :
1292 :
1293 0 : apertureEfficiencyError.clear();
1294 :
1295 0 : unsigned int apertureEfficiencyErrorDim1 = eis.readInt();
1296 0 : for (unsigned int i = 0 ; i < apertureEfficiencyErrorDim1; i++)
1297 :
1298 0 : apertureEfficiencyError.push_back(eis.readFloat());
1299 :
1300 :
1301 :
1302 :
1303 :
1304 :
1305 0 : }
1306 :
1307 0 : void CalAmpliRow::correctionValidityFromBin(EndianIStream& eis) {
1308 :
1309 0 : correctionValidityExists = eis.readBoolean();
1310 0 : if (correctionValidityExists) {
1311 :
1312 :
1313 :
1314 :
1315 :
1316 0 : correctionValidity = eis.readBoolean();
1317 :
1318 :
1319 :
1320 :
1321 : }
1322 :
1323 0 : }
1324 :
1325 :
1326 0 : CalAmpliRow* CalAmpliRow::fromBin(EndianIStream& eis, CalAmpliTable& table, const vector<string>& attributesSeq) {
1327 0 : CalAmpliRow* row = new CalAmpliRow(table);
1328 :
1329 0 : map<string, CalAmpliAttributeFromBin>::iterator iter ;
1330 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
1331 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
1332 0 : if (iter != row->fromBinMethods.end()) {
1333 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
1334 : }
1335 : else {
1336 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
1337 0 : if (functorP)
1338 0 : (*functorP)(eis);
1339 : else
1340 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "CalAmpliTable");
1341 : }
1342 :
1343 : }
1344 0 : return row;
1345 : }
1346 :
1347 : //
1348 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
1349 : // of one row.
1350 : //
1351 :
1352 : // Convert a string into an String
1353 0 : void CalAmpliRow::antennaNameFromText(const string & s) {
1354 :
1355 :
1356 0 : antennaName = ASDMValuesParser::parse<string>(s);
1357 :
1358 :
1359 0 : }
1360 :
1361 :
1362 : // Convert a string into an AtmPhaseCorrection
1363 0 : void CalAmpliRow::atmPhaseCorrectionFromText(const string & s) {
1364 :
1365 :
1366 0 : atmPhaseCorrection = ASDMValuesParser::parse<AtmPhaseCorrectionMod::AtmPhaseCorrection>(s);
1367 :
1368 :
1369 0 : }
1370 :
1371 :
1372 : // Convert a string into an ReceiverBand
1373 0 : void CalAmpliRow::receiverBandFromText(const string & s) {
1374 :
1375 :
1376 0 : receiverBand = ASDMValuesParser::parse<ReceiverBandMod::ReceiverBand>(s);
1377 :
1378 :
1379 0 : }
1380 :
1381 :
1382 : // Convert a string into an BasebandName
1383 0 : void CalAmpliRow::basebandNameFromText(const string & s) {
1384 :
1385 :
1386 0 : basebandName = ASDMValuesParser::parse<BasebandNameMod::BasebandName>(s);
1387 :
1388 :
1389 0 : }
1390 :
1391 :
1392 : // Convert a string into an Tag
1393 0 : void CalAmpliRow::calDataIdFromText(const string & s) {
1394 :
1395 :
1396 0 : calDataId = ASDMValuesParser::parse<Tag>(s);
1397 :
1398 :
1399 0 : }
1400 :
1401 :
1402 : // Convert a string into an Tag
1403 0 : void CalAmpliRow::calReductionIdFromText(const string & s) {
1404 :
1405 :
1406 0 : calReductionId = ASDMValuesParser::parse<Tag>(s);
1407 :
1408 :
1409 0 : }
1410 :
1411 :
1412 : // Convert a string into an int
1413 0 : void CalAmpliRow::numReceptorFromText(const string & s) {
1414 :
1415 :
1416 0 : numReceptor = ASDMValuesParser::parse<int>(s);
1417 :
1418 :
1419 0 : }
1420 :
1421 :
1422 : // Convert a string into an PolarizationType
1423 0 : void CalAmpliRow::polarizationTypesFromText(const string & s) {
1424 :
1425 :
1426 0 : polarizationTypes = ASDMValuesParser::parse1D<PolarizationTypeMod::PolarizationType>(s);
1427 :
1428 :
1429 0 : }
1430 :
1431 :
1432 : // Convert a string into an ArrayTime
1433 0 : void CalAmpliRow::startValidTimeFromText(const string & s) {
1434 :
1435 :
1436 0 : startValidTime = ASDMValuesParser::parse<ArrayTime>(s);
1437 :
1438 :
1439 0 : }
1440 :
1441 :
1442 : // Convert a string into an ArrayTime
1443 0 : void CalAmpliRow::endValidTimeFromText(const string & s) {
1444 :
1445 :
1446 0 : endValidTime = ASDMValuesParser::parse<ArrayTime>(s);
1447 :
1448 :
1449 0 : }
1450 :
1451 :
1452 : // Convert a string into an Frequency
1453 0 : void CalAmpliRow::frequencyRangeFromText(const string & s) {
1454 :
1455 :
1456 0 : frequencyRange = ASDMValuesParser::parse1D<Frequency>(s);
1457 :
1458 :
1459 0 : }
1460 :
1461 :
1462 : // Convert a string into an float
1463 0 : void CalAmpliRow::apertureEfficiencyFromText(const string & s) {
1464 :
1465 :
1466 0 : apertureEfficiency = ASDMValuesParser::parse1D<float>(s);
1467 :
1468 :
1469 0 : }
1470 :
1471 :
1472 : // Convert a string into an float
1473 0 : void CalAmpliRow::apertureEfficiencyErrorFromText(const string & s) {
1474 :
1475 :
1476 0 : apertureEfficiencyError = ASDMValuesParser::parse1D<float>(s);
1477 :
1478 :
1479 0 : }
1480 :
1481 :
1482 :
1483 : // Convert a string into an boolean
1484 0 : void CalAmpliRow::correctionValidityFromText(const string & s) {
1485 0 : correctionValidityExists = true;
1486 :
1487 :
1488 0 : correctionValidity = ASDMValuesParser::parse<bool>(s);
1489 :
1490 :
1491 0 : }
1492 :
1493 :
1494 :
1495 0 : void CalAmpliRow::fromText(const std::string& attributeName, const std::string& t) {
1496 0 : map<string, CalAmpliAttributeFromText>::iterator iter;
1497 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
1498 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "CalAmpliTable");
1499 0 : (this->*(iter->second))(t);
1500 0 : }
1501 :
1502 : ////////////////////////////////////////////////
1503 : // Intrinsic Table Attributes getters/setters //
1504 : ////////////////////////////////////////////////
1505 :
1506 :
1507 :
1508 :
1509 : /**
1510 : * Get antennaName.
1511 : * @return antennaName as std::string
1512 : */
1513 0 : std::string CalAmpliRow::getAntennaName() const {
1514 :
1515 0 : return antennaName;
1516 : }
1517 :
1518 : /**
1519 : * Set antennaName with the specified std::string.
1520 : * @param antennaName The std::string value to which antennaName is to be set.
1521 :
1522 :
1523 :
1524 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1525 :
1526 : */
1527 0 : void CalAmpliRow::setAntennaName (std::string antennaName) {
1528 :
1529 :
1530 0 : if (hasBeenAdded) {
1531 :
1532 0 : throw IllegalAccessException("antennaName", "CalAmpli");
1533 :
1534 : }
1535 :
1536 0 : this->antennaName = antennaName;
1537 :
1538 0 : }
1539 :
1540 :
1541 :
1542 :
1543 :
1544 :
1545 : /**
1546 : * Get atmPhaseCorrection.
1547 : * @return atmPhaseCorrection as AtmPhaseCorrectionMod::AtmPhaseCorrection
1548 : */
1549 0 : AtmPhaseCorrectionMod::AtmPhaseCorrection CalAmpliRow::getAtmPhaseCorrection() const {
1550 :
1551 0 : return atmPhaseCorrection;
1552 : }
1553 :
1554 : /**
1555 : * Set atmPhaseCorrection with the specified AtmPhaseCorrectionMod::AtmPhaseCorrection.
1556 : * @param atmPhaseCorrection The AtmPhaseCorrectionMod::AtmPhaseCorrection value to which atmPhaseCorrection is to be set.
1557 :
1558 :
1559 :
1560 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1561 :
1562 : */
1563 0 : void CalAmpliRow::setAtmPhaseCorrection (AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection) {
1564 :
1565 :
1566 0 : if (hasBeenAdded) {
1567 :
1568 0 : throw IllegalAccessException("atmPhaseCorrection", "CalAmpli");
1569 :
1570 : }
1571 :
1572 0 : this->atmPhaseCorrection = atmPhaseCorrection;
1573 :
1574 0 : }
1575 :
1576 :
1577 :
1578 :
1579 :
1580 :
1581 : /**
1582 : * Get receiverBand.
1583 : * @return receiverBand as ReceiverBandMod::ReceiverBand
1584 : */
1585 0 : ReceiverBandMod::ReceiverBand CalAmpliRow::getReceiverBand() const {
1586 :
1587 0 : return receiverBand;
1588 : }
1589 :
1590 : /**
1591 : * Set receiverBand with the specified ReceiverBandMod::ReceiverBand.
1592 : * @param receiverBand The ReceiverBandMod::ReceiverBand value to which receiverBand is to be set.
1593 :
1594 :
1595 :
1596 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1597 :
1598 : */
1599 0 : void CalAmpliRow::setReceiverBand (ReceiverBandMod::ReceiverBand receiverBand) {
1600 :
1601 :
1602 0 : if (hasBeenAdded) {
1603 :
1604 0 : throw IllegalAccessException("receiverBand", "CalAmpli");
1605 :
1606 : }
1607 :
1608 0 : this->receiverBand = receiverBand;
1609 :
1610 0 : }
1611 :
1612 :
1613 :
1614 :
1615 :
1616 :
1617 : /**
1618 : * Get basebandName.
1619 : * @return basebandName as BasebandNameMod::BasebandName
1620 : */
1621 0 : BasebandNameMod::BasebandName CalAmpliRow::getBasebandName() const {
1622 :
1623 0 : return basebandName;
1624 : }
1625 :
1626 : /**
1627 : * Set basebandName with the specified BasebandNameMod::BasebandName.
1628 : * @param basebandName The BasebandNameMod::BasebandName value to which basebandName is to be set.
1629 :
1630 :
1631 :
1632 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1633 :
1634 : */
1635 0 : void CalAmpliRow::setBasebandName (BasebandNameMod::BasebandName basebandName) {
1636 :
1637 :
1638 0 : if (hasBeenAdded) {
1639 :
1640 0 : throw IllegalAccessException("basebandName", "CalAmpli");
1641 :
1642 : }
1643 :
1644 0 : this->basebandName = basebandName;
1645 :
1646 0 : }
1647 :
1648 :
1649 :
1650 :
1651 :
1652 :
1653 : /**
1654 : * Get numReceptor.
1655 : * @return numReceptor as int
1656 : */
1657 0 : int CalAmpliRow::getNumReceptor() const {
1658 :
1659 0 : return numReceptor;
1660 : }
1661 :
1662 : /**
1663 : * Set numReceptor with the specified int.
1664 : * @param numReceptor The int value to which numReceptor is to be set.
1665 :
1666 :
1667 :
1668 : */
1669 0 : void CalAmpliRow::setNumReceptor (int numReceptor) {
1670 :
1671 :
1672 0 : if (hasBeenAdded) {
1673 :
1674 : }
1675 :
1676 0 : this->numReceptor = numReceptor;
1677 :
1678 0 : }
1679 :
1680 :
1681 :
1682 :
1683 :
1684 :
1685 : /**
1686 : * Get polarizationTypes.
1687 : * @return polarizationTypes as std::vector<PolarizationTypeMod::PolarizationType >
1688 : */
1689 0 : std::vector<PolarizationTypeMod::PolarizationType > CalAmpliRow::getPolarizationTypes() const {
1690 :
1691 0 : return polarizationTypes;
1692 : }
1693 :
1694 : /**
1695 : * Set polarizationTypes with the specified std::vector<PolarizationTypeMod::PolarizationType >.
1696 : * @param polarizationTypes The std::vector<PolarizationTypeMod::PolarizationType > value to which polarizationTypes is to be set.
1697 :
1698 :
1699 :
1700 : */
1701 0 : void CalAmpliRow::setPolarizationTypes (std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes) {
1702 :
1703 :
1704 0 : if (hasBeenAdded) {
1705 :
1706 : }
1707 :
1708 0 : this->polarizationTypes = polarizationTypes;
1709 :
1710 0 : }
1711 :
1712 :
1713 :
1714 :
1715 :
1716 :
1717 : /**
1718 : * Get startValidTime.
1719 : * @return startValidTime as ArrayTime
1720 : */
1721 0 : ArrayTime CalAmpliRow::getStartValidTime() const {
1722 :
1723 0 : return startValidTime;
1724 : }
1725 :
1726 : /**
1727 : * Set startValidTime with the specified ArrayTime.
1728 : * @param startValidTime The ArrayTime value to which startValidTime is to be set.
1729 :
1730 :
1731 :
1732 : */
1733 0 : void CalAmpliRow::setStartValidTime (ArrayTime startValidTime) {
1734 :
1735 :
1736 0 : if (hasBeenAdded) {
1737 :
1738 : }
1739 :
1740 0 : this->startValidTime = startValidTime;
1741 :
1742 0 : }
1743 :
1744 :
1745 :
1746 :
1747 :
1748 :
1749 : /**
1750 : * Get endValidTime.
1751 : * @return endValidTime as ArrayTime
1752 : */
1753 0 : ArrayTime CalAmpliRow::getEndValidTime() const {
1754 :
1755 0 : return endValidTime;
1756 : }
1757 :
1758 : /**
1759 : * Set endValidTime with the specified ArrayTime.
1760 : * @param endValidTime The ArrayTime value to which endValidTime is to be set.
1761 :
1762 :
1763 :
1764 : */
1765 0 : void CalAmpliRow::setEndValidTime (ArrayTime endValidTime) {
1766 :
1767 :
1768 0 : if (hasBeenAdded) {
1769 :
1770 : }
1771 :
1772 0 : this->endValidTime = endValidTime;
1773 :
1774 0 : }
1775 :
1776 :
1777 :
1778 :
1779 :
1780 :
1781 : /**
1782 : * Get frequencyRange.
1783 : * @return frequencyRange as std::vector<Frequency >
1784 : */
1785 0 : std::vector<Frequency > CalAmpliRow::getFrequencyRange() const {
1786 :
1787 0 : return frequencyRange;
1788 : }
1789 :
1790 : /**
1791 : * Set frequencyRange with the specified std::vector<Frequency >.
1792 : * @param frequencyRange The std::vector<Frequency > value to which frequencyRange is to be set.
1793 :
1794 :
1795 :
1796 : */
1797 0 : void CalAmpliRow::setFrequencyRange (std::vector<Frequency > frequencyRange) {
1798 :
1799 :
1800 0 : if (hasBeenAdded) {
1801 :
1802 : }
1803 :
1804 0 : this->frequencyRange = frequencyRange;
1805 :
1806 0 : }
1807 :
1808 :
1809 :
1810 :
1811 :
1812 :
1813 : /**
1814 : * Get apertureEfficiency.
1815 : * @return apertureEfficiency as std::vector<float >
1816 : */
1817 0 : std::vector<float > CalAmpliRow::getApertureEfficiency() const {
1818 :
1819 0 : return apertureEfficiency;
1820 : }
1821 :
1822 : /**
1823 : * Set apertureEfficiency with the specified std::vector<float >.
1824 : * @param apertureEfficiency The std::vector<float > value to which apertureEfficiency is to be set.
1825 :
1826 :
1827 :
1828 : */
1829 0 : void CalAmpliRow::setApertureEfficiency (std::vector<float > apertureEfficiency) {
1830 :
1831 :
1832 0 : if (hasBeenAdded) {
1833 :
1834 : }
1835 :
1836 0 : this->apertureEfficiency = apertureEfficiency;
1837 :
1838 0 : }
1839 :
1840 :
1841 :
1842 :
1843 :
1844 :
1845 : /**
1846 : * Get apertureEfficiencyError.
1847 : * @return apertureEfficiencyError as std::vector<float >
1848 : */
1849 0 : std::vector<float > CalAmpliRow::getApertureEfficiencyError() const {
1850 :
1851 0 : return apertureEfficiencyError;
1852 : }
1853 :
1854 : /**
1855 : * Set apertureEfficiencyError with the specified std::vector<float >.
1856 : * @param apertureEfficiencyError The std::vector<float > value to which apertureEfficiencyError is to be set.
1857 :
1858 :
1859 :
1860 : */
1861 0 : void CalAmpliRow::setApertureEfficiencyError (std::vector<float > apertureEfficiencyError) {
1862 :
1863 :
1864 0 : if (hasBeenAdded) {
1865 :
1866 : }
1867 :
1868 0 : this->apertureEfficiencyError = apertureEfficiencyError;
1869 :
1870 0 : }
1871 :
1872 :
1873 :
1874 :
1875 : /**
1876 : * The attribute correctionValidity is optional. Return true if this attribute exists.
1877 : * @return true if and only if the correctionValidity attribute exists.
1878 : */
1879 0 : bool CalAmpliRow::isCorrectionValidityExists() const {
1880 0 : return correctionValidityExists;
1881 : }
1882 :
1883 :
1884 :
1885 : /**
1886 : * Get correctionValidity, which is optional.
1887 : * @return correctionValidity as bool
1888 : * @throw IllegalAccessException If correctionValidity does not exist.
1889 : */
1890 0 : bool CalAmpliRow::getCorrectionValidity() const {
1891 0 : if (!correctionValidityExists) {
1892 0 : throw IllegalAccessException("correctionValidity", "CalAmpli");
1893 : }
1894 :
1895 0 : return correctionValidity;
1896 : }
1897 :
1898 : /**
1899 : * Set correctionValidity with the specified bool.
1900 : * @param correctionValidity The bool value to which correctionValidity is to be set.
1901 :
1902 :
1903 : */
1904 0 : void CalAmpliRow::setCorrectionValidity (bool correctionValidity) {
1905 :
1906 0 : this->correctionValidity = correctionValidity;
1907 :
1908 0 : correctionValidityExists = true;
1909 :
1910 0 : }
1911 :
1912 :
1913 : /**
1914 : * Mark correctionValidity, which is an optional field, as non-existent.
1915 : */
1916 0 : void CalAmpliRow::clearCorrectionValidity () {
1917 0 : correctionValidityExists = false;
1918 0 : }
1919 :
1920 :
1921 :
1922 : ///////////////////////////////////////////////
1923 : // Extrinsic Table Attributes getters/setters//
1924 : ///////////////////////////////////////////////
1925 :
1926 :
1927 :
1928 :
1929 : /**
1930 : * Get calDataId.
1931 : * @return calDataId as Tag
1932 : */
1933 0 : Tag CalAmpliRow::getCalDataId() const {
1934 :
1935 0 : return calDataId;
1936 : }
1937 :
1938 : /**
1939 : * Set calDataId with the specified Tag.
1940 : * @param calDataId The Tag value to which calDataId is to be set.
1941 :
1942 :
1943 :
1944 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1945 :
1946 : */
1947 0 : void CalAmpliRow::setCalDataId (Tag calDataId) {
1948 :
1949 :
1950 0 : if (hasBeenAdded) {
1951 :
1952 0 : throw IllegalAccessException("calDataId", "CalAmpli");
1953 :
1954 : }
1955 :
1956 0 : this->calDataId = calDataId;
1957 :
1958 0 : }
1959 :
1960 :
1961 :
1962 :
1963 :
1964 :
1965 : /**
1966 : * Get calReductionId.
1967 : * @return calReductionId as Tag
1968 : */
1969 0 : Tag CalAmpliRow::getCalReductionId() const {
1970 :
1971 0 : return calReductionId;
1972 : }
1973 :
1974 : /**
1975 : * Set calReductionId with the specified Tag.
1976 : * @param calReductionId The Tag value to which calReductionId is to be set.
1977 :
1978 :
1979 :
1980 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1981 :
1982 : */
1983 0 : void CalAmpliRow::setCalReductionId (Tag calReductionId) {
1984 :
1985 :
1986 0 : if (hasBeenAdded) {
1987 :
1988 0 : throw IllegalAccessException("calReductionId", "CalAmpli");
1989 :
1990 : }
1991 :
1992 0 : this->calReductionId = calReductionId;
1993 :
1994 0 : }
1995 :
1996 :
1997 :
1998 :
1999 : //////////////////////////////////////
2000 : // Links Attributes getters/setters //
2001 : //////////////////////////////////////
2002 :
2003 :
2004 :
2005 :
2006 :
2007 :
2008 : /**
2009 : * Returns the pointer to the row in the CalData table having CalData.calDataId == calDataId
2010 : * @return a CalDataRow*
2011 : *
2012 :
2013 : */
2014 0 : CalDataRow* CalAmpliRow::getCalDataUsingCalDataId() {
2015 :
2016 0 : return table.getContainer().getCalData().getRowByKey(calDataId);
2017 : }
2018 :
2019 :
2020 :
2021 :
2022 :
2023 :
2024 :
2025 :
2026 :
2027 : /**
2028 : * Returns the pointer to the row in the CalReduction table having CalReduction.calReductionId == calReductionId
2029 : * @return a CalReductionRow*
2030 : *
2031 :
2032 : */
2033 0 : CalReductionRow* CalAmpliRow::getCalReductionUsingCalReductionId() {
2034 :
2035 0 : return table.getContainer().getCalReduction().getRowByKey(calReductionId);
2036 : }
2037 :
2038 :
2039 :
2040 :
2041 :
2042 : /**
2043 : * Create a CalAmpliRow.
2044 : * <p>
2045 : * This constructor is private because only the
2046 : * table can create rows. All rows know the table
2047 : * to which they belong.
2048 : * @param table The table to which this row belongs.
2049 : */
2050 0 : CalAmpliRow::CalAmpliRow (CalAmpliTable &t) : table(t) {
2051 0 : hasBeenAdded = false;
2052 :
2053 :
2054 :
2055 :
2056 :
2057 :
2058 :
2059 :
2060 :
2061 :
2062 :
2063 :
2064 :
2065 :
2066 :
2067 :
2068 :
2069 :
2070 :
2071 :
2072 :
2073 :
2074 :
2075 :
2076 :
2077 0 : correctionValidityExists = false;
2078 :
2079 :
2080 :
2081 :
2082 :
2083 :
2084 :
2085 :
2086 :
2087 :
2088 :
2089 :
2090 :
2091 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
2092 0 : atmPhaseCorrection = CAtmPhaseCorrection::from_int(0);
2093 :
2094 :
2095 :
2096 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
2097 0 : receiverBand = CReceiverBand::from_int(0);
2098 :
2099 :
2100 :
2101 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
2102 0 : basebandName = CBasebandName::from_int(0);
2103 :
2104 :
2105 :
2106 :
2107 :
2108 :
2109 :
2110 :
2111 :
2112 :
2113 :
2114 :
2115 :
2116 :
2117 :
2118 :
2119 :
2120 :
2121 :
2122 :
2123 0 : fromBinMethods["antennaName"] = &CalAmpliRow::antennaNameFromBin;
2124 0 : fromBinMethods["atmPhaseCorrection"] = &CalAmpliRow::atmPhaseCorrectionFromBin;
2125 0 : fromBinMethods["receiverBand"] = &CalAmpliRow::receiverBandFromBin;
2126 0 : fromBinMethods["basebandName"] = &CalAmpliRow::basebandNameFromBin;
2127 0 : fromBinMethods["calDataId"] = &CalAmpliRow::calDataIdFromBin;
2128 0 : fromBinMethods["calReductionId"] = &CalAmpliRow::calReductionIdFromBin;
2129 0 : fromBinMethods["numReceptor"] = &CalAmpliRow::numReceptorFromBin;
2130 0 : fromBinMethods["polarizationTypes"] = &CalAmpliRow::polarizationTypesFromBin;
2131 0 : fromBinMethods["startValidTime"] = &CalAmpliRow::startValidTimeFromBin;
2132 0 : fromBinMethods["endValidTime"] = &CalAmpliRow::endValidTimeFromBin;
2133 0 : fromBinMethods["frequencyRange"] = &CalAmpliRow::frequencyRangeFromBin;
2134 0 : fromBinMethods["apertureEfficiency"] = &CalAmpliRow::apertureEfficiencyFromBin;
2135 0 : fromBinMethods["apertureEfficiencyError"] = &CalAmpliRow::apertureEfficiencyErrorFromBin;
2136 :
2137 :
2138 0 : fromBinMethods["correctionValidity"] = &CalAmpliRow::correctionValidityFromBin;
2139 :
2140 :
2141 :
2142 :
2143 :
2144 0 : fromTextMethods["antennaName"] = &CalAmpliRow::antennaNameFromText;
2145 :
2146 :
2147 :
2148 0 : fromTextMethods["atmPhaseCorrection"] = &CalAmpliRow::atmPhaseCorrectionFromText;
2149 :
2150 :
2151 :
2152 0 : fromTextMethods["receiverBand"] = &CalAmpliRow::receiverBandFromText;
2153 :
2154 :
2155 :
2156 0 : fromTextMethods["basebandName"] = &CalAmpliRow::basebandNameFromText;
2157 :
2158 :
2159 :
2160 0 : fromTextMethods["calDataId"] = &CalAmpliRow::calDataIdFromText;
2161 :
2162 :
2163 :
2164 0 : fromTextMethods["calReductionId"] = &CalAmpliRow::calReductionIdFromText;
2165 :
2166 :
2167 :
2168 0 : fromTextMethods["numReceptor"] = &CalAmpliRow::numReceptorFromText;
2169 :
2170 :
2171 :
2172 0 : fromTextMethods["polarizationTypes"] = &CalAmpliRow::polarizationTypesFromText;
2173 :
2174 :
2175 :
2176 0 : fromTextMethods["startValidTime"] = &CalAmpliRow::startValidTimeFromText;
2177 :
2178 :
2179 :
2180 0 : fromTextMethods["endValidTime"] = &CalAmpliRow::endValidTimeFromText;
2181 :
2182 :
2183 :
2184 0 : fromTextMethods["frequencyRange"] = &CalAmpliRow::frequencyRangeFromText;
2185 :
2186 :
2187 :
2188 0 : fromTextMethods["apertureEfficiency"] = &CalAmpliRow::apertureEfficiencyFromText;
2189 :
2190 :
2191 :
2192 0 : fromTextMethods["apertureEfficiencyError"] = &CalAmpliRow::apertureEfficiencyErrorFromText;
2193 :
2194 :
2195 :
2196 :
2197 :
2198 0 : fromTextMethods["correctionValidity"] = &CalAmpliRow::correctionValidityFromText;
2199 :
2200 :
2201 0 : }
2202 :
2203 0 : CalAmpliRow::CalAmpliRow (CalAmpliTable &t, CalAmpliRow *row) : table(t) {
2204 0 : hasBeenAdded = false;
2205 :
2206 0 : if (row == 0) {
2207 :
2208 :
2209 :
2210 :
2211 :
2212 :
2213 :
2214 :
2215 :
2216 :
2217 :
2218 :
2219 :
2220 :
2221 :
2222 :
2223 :
2224 :
2225 :
2226 :
2227 :
2228 :
2229 :
2230 :
2231 :
2232 0 : correctionValidityExists = false;
2233 :
2234 :
2235 :
2236 :
2237 :
2238 :
2239 :
2240 : }
2241 : else {
2242 :
2243 :
2244 0 : antennaName = row->antennaName;
2245 :
2246 0 : atmPhaseCorrection = row->atmPhaseCorrection;
2247 :
2248 0 : receiverBand = row->receiverBand;
2249 :
2250 0 : basebandName = row->basebandName;
2251 :
2252 0 : calDataId = row->calDataId;
2253 :
2254 0 : calReductionId = row->calReductionId;
2255 :
2256 :
2257 :
2258 :
2259 0 : numReceptor = row->numReceptor;
2260 :
2261 0 : polarizationTypes = row->polarizationTypes;
2262 :
2263 0 : startValidTime = row->startValidTime;
2264 :
2265 0 : endValidTime = row->endValidTime;
2266 :
2267 0 : frequencyRange = row->frequencyRange;
2268 :
2269 0 : apertureEfficiency = row->apertureEfficiency;
2270 :
2271 0 : apertureEfficiencyError = row->apertureEfficiencyError;
2272 :
2273 :
2274 :
2275 :
2276 0 : if (row->correctionValidityExists) {
2277 0 : correctionValidity = row->correctionValidity;
2278 0 : correctionValidityExists = true;
2279 : }
2280 : else
2281 0 : correctionValidityExists = false;
2282 :
2283 : }
2284 :
2285 0 : fromBinMethods["antennaName"] = &CalAmpliRow::antennaNameFromBin;
2286 0 : fromBinMethods["atmPhaseCorrection"] = &CalAmpliRow::atmPhaseCorrectionFromBin;
2287 0 : fromBinMethods["receiverBand"] = &CalAmpliRow::receiverBandFromBin;
2288 0 : fromBinMethods["basebandName"] = &CalAmpliRow::basebandNameFromBin;
2289 0 : fromBinMethods["calDataId"] = &CalAmpliRow::calDataIdFromBin;
2290 0 : fromBinMethods["calReductionId"] = &CalAmpliRow::calReductionIdFromBin;
2291 0 : fromBinMethods["numReceptor"] = &CalAmpliRow::numReceptorFromBin;
2292 0 : fromBinMethods["polarizationTypes"] = &CalAmpliRow::polarizationTypesFromBin;
2293 0 : fromBinMethods["startValidTime"] = &CalAmpliRow::startValidTimeFromBin;
2294 0 : fromBinMethods["endValidTime"] = &CalAmpliRow::endValidTimeFromBin;
2295 0 : fromBinMethods["frequencyRange"] = &CalAmpliRow::frequencyRangeFromBin;
2296 0 : fromBinMethods["apertureEfficiency"] = &CalAmpliRow::apertureEfficiencyFromBin;
2297 0 : fromBinMethods["apertureEfficiencyError"] = &CalAmpliRow::apertureEfficiencyErrorFromBin;
2298 :
2299 :
2300 0 : fromBinMethods["correctionValidity"] = &CalAmpliRow::correctionValidityFromBin;
2301 :
2302 0 : }
2303 :
2304 :
2305 0 : bool CalAmpliRow::compareNoAutoInc(std::string antennaName, AtmPhaseCorrectionMod::AtmPhaseCorrection atmPhaseCorrection, ReceiverBandMod::ReceiverBand receiverBand, BasebandNameMod::BasebandName basebandName, Tag calDataId, Tag calReductionId, int numReceptor, std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes, ArrayTime startValidTime, ArrayTime endValidTime, std::vector<Frequency > frequencyRange, std::vector<float > apertureEfficiency, std::vector<float > apertureEfficiencyError) {
2306 : bool result;
2307 0 : result = true;
2308 :
2309 :
2310 :
2311 0 : result = result && (this->antennaName == antennaName);
2312 :
2313 0 : if (!result) return false;
2314 :
2315 :
2316 :
2317 :
2318 0 : result = result && (this->atmPhaseCorrection == atmPhaseCorrection);
2319 :
2320 0 : if (!result) return false;
2321 :
2322 :
2323 :
2324 :
2325 0 : result = result && (this->receiverBand == receiverBand);
2326 :
2327 0 : if (!result) return false;
2328 :
2329 :
2330 :
2331 :
2332 0 : result = result && (this->basebandName == basebandName);
2333 :
2334 0 : if (!result) return false;
2335 :
2336 :
2337 :
2338 :
2339 0 : result = result && (this->calDataId == calDataId);
2340 :
2341 0 : if (!result) return false;
2342 :
2343 :
2344 :
2345 :
2346 0 : result = result && (this->calReductionId == calReductionId);
2347 :
2348 0 : if (!result) return false;
2349 :
2350 :
2351 :
2352 :
2353 0 : result = result && (this->numReceptor == numReceptor);
2354 :
2355 0 : if (!result) return false;
2356 :
2357 :
2358 :
2359 :
2360 0 : result = result && (this->polarizationTypes == polarizationTypes);
2361 :
2362 0 : if (!result) return false;
2363 :
2364 :
2365 :
2366 :
2367 0 : result = result && (this->startValidTime == startValidTime);
2368 :
2369 0 : if (!result) return false;
2370 :
2371 :
2372 :
2373 :
2374 0 : result = result && (this->endValidTime == endValidTime);
2375 :
2376 0 : if (!result) return false;
2377 :
2378 :
2379 :
2380 :
2381 0 : result = result && (this->frequencyRange == frequencyRange);
2382 :
2383 0 : if (!result) return false;
2384 :
2385 :
2386 :
2387 :
2388 0 : result = result && (this->apertureEfficiency == apertureEfficiency);
2389 :
2390 0 : if (!result) return false;
2391 :
2392 :
2393 :
2394 :
2395 0 : result = result && (this->apertureEfficiencyError == apertureEfficiencyError);
2396 :
2397 0 : if (!result) return false;
2398 :
2399 :
2400 0 : return result;
2401 : }
2402 :
2403 :
2404 :
2405 0 : bool CalAmpliRow::compareRequiredValue(int numReceptor, std::vector<PolarizationTypeMod::PolarizationType > polarizationTypes, ArrayTime startValidTime, ArrayTime endValidTime, std::vector<Frequency > frequencyRange, std::vector<float > apertureEfficiency, std::vector<float > apertureEfficiencyError) {
2406 : bool result;
2407 0 : result = true;
2408 :
2409 :
2410 0 : if (!(this->numReceptor == numReceptor)) return false;
2411 :
2412 :
2413 :
2414 0 : if (!(this->polarizationTypes == polarizationTypes)) return false;
2415 :
2416 :
2417 :
2418 0 : if (!(this->startValidTime == startValidTime)) return false;
2419 :
2420 :
2421 :
2422 0 : if (!(this->endValidTime == endValidTime)) return false;
2423 :
2424 :
2425 :
2426 0 : if (!(this->frequencyRange == frequencyRange)) return false;
2427 :
2428 :
2429 :
2430 0 : if (!(this->apertureEfficiency == apertureEfficiency)) return false;
2431 :
2432 :
2433 :
2434 0 : if (!(this->apertureEfficiencyError == apertureEfficiencyError)) return false;
2435 :
2436 :
2437 0 : return result;
2438 : }
2439 :
2440 :
2441 : /**
2442 : * Return true if all required attributes of the value part are equal to their homologues
2443 : * in x and false otherwise.
2444 : *
2445 :
2446 : * @param x a pointer on the CalAmpliRow whose required attributes of the value part
2447 :
2448 : * will be compared with those of this.
2449 : * @return a boolean.
2450 : */
2451 0 : bool CalAmpliRow::equalByRequiredValue(CalAmpliRow* x ) {
2452 :
2453 :
2454 0 : if (this->numReceptor != x->numReceptor) return false;
2455 :
2456 0 : if (this->polarizationTypes != x->polarizationTypes) return false;
2457 :
2458 0 : if (this->startValidTime != x->startValidTime) return false;
2459 :
2460 0 : if (this->endValidTime != x->endValidTime) return false;
2461 :
2462 0 : if (this->frequencyRange != x->frequencyRange) return false;
2463 :
2464 0 : if (this->apertureEfficiency != x->apertureEfficiency) return false;
2465 :
2466 0 : if (this->apertureEfficiencyError != x->apertureEfficiencyError) return false;
2467 :
2468 :
2469 0 : return true;
2470 : }
2471 :
2472 : /*
2473 : map<string, CalAmpliAttributeFromBin> CalAmpliRow::initFromBinMethods() {
2474 : map<string, CalAmpliAttributeFromBin> result;
2475 :
2476 : result["antennaName"] = &CalAmpliRow::antennaNameFromBin;
2477 : result["atmPhaseCorrection"] = &CalAmpliRow::atmPhaseCorrectionFromBin;
2478 : result["receiverBand"] = &CalAmpliRow::receiverBandFromBin;
2479 : result["basebandName"] = &CalAmpliRow::basebandNameFromBin;
2480 : result["calDataId"] = &CalAmpliRow::calDataIdFromBin;
2481 : result["calReductionId"] = &CalAmpliRow::calReductionIdFromBin;
2482 : result["numReceptor"] = &CalAmpliRow::numReceptorFromBin;
2483 : result["polarizationTypes"] = &CalAmpliRow::polarizationTypesFromBin;
2484 : result["startValidTime"] = &CalAmpliRow::startValidTimeFromBin;
2485 : result["endValidTime"] = &CalAmpliRow::endValidTimeFromBin;
2486 : result["frequencyRange"] = &CalAmpliRow::frequencyRangeFromBin;
2487 : result["apertureEfficiency"] = &CalAmpliRow::apertureEfficiencyFromBin;
2488 : result["apertureEfficiencyError"] = &CalAmpliRow::apertureEfficiencyErrorFromBin;
2489 :
2490 :
2491 : result["correctionValidity"] = &CalAmpliRow::correctionValidityFromBin;
2492 :
2493 :
2494 : return result;
2495 : }
2496 : */
2497 : } // End namespace asdm
2498 :
|
