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