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