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 TotalPowerRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/TotalPowerRow.h>
39 : #include <alma/ASDM/TotalPowerTable.h>
40 :
41 : #include <alma/ASDM/StateTable.h>
42 : #include <alma/ASDM/StateRow.h>
43 :
44 : #include <alma/ASDM/FieldTable.h>
45 : #include <alma/ASDM/FieldRow.h>
46 :
47 : #include <alma/ASDM/ConfigDescriptionTable.h>
48 : #include <alma/ASDM/ConfigDescriptionRow.h>
49 :
50 : #include <alma/ASDM/ExecBlockTable.h>
51 : #include <alma/ASDM/ExecBlockRow.h>
52 :
53 :
54 : using asdm::ASDM;
55 : using asdm::TotalPowerRow;
56 : using asdm::TotalPowerTable;
57 :
58 : using asdm::StateTable;
59 : using asdm::StateRow;
60 :
61 : using asdm::FieldTable;
62 : using asdm::FieldRow;
63 :
64 : using asdm::ConfigDescriptionTable;
65 : using asdm::ConfigDescriptionRow;
66 :
67 : using asdm::ExecBlockTable;
68 : using asdm::ExecBlockRow;
69 :
70 :
71 : #include <alma/ASDM/Parser.h>
72 :
73 : #include <alma/ASDM/EnumerationParser.h>
74 : #include <alma/ASDM/ASDMValuesParser.h>
75 :
76 : #include <alma/ASDM/InvalidArgumentException.h>
77 :
78 : using namespace std;
79 :
80 : namespace asdm {
81 0 : TotalPowerRow::~TotalPowerRow() {
82 0 : }
83 :
84 : /**
85 : * Return the table to which this row belongs.
86 : */
87 0 : TotalPowerTable &TotalPowerRow::getTable() const {
88 0 : return table;
89 : }
90 :
91 0 : bool TotalPowerRow::isAdded() const {
92 0 : return hasBeenAdded;
93 : }
94 :
95 0 : void TotalPowerRow::isAdded(bool added) {
96 0 : hasBeenAdded = added;
97 0 : }
98 :
99 : #ifndef WITHOUT_ACS
100 : using asdmIDL::TotalPowerRowIDL;
101 : #endif
102 :
103 : #ifndef WITHOUT_ACS
104 : /**
105 : * Return this row in the form of an IDL struct.
106 : * @return The values of this row as a TotalPowerRowIDL struct.
107 : */
108 : TotalPowerRowIDL *TotalPowerRow::toIDL() const {
109 : TotalPowerRowIDL *x = new TotalPowerRowIDL ();
110 :
111 : // Fill the IDL structure.
112 :
113 :
114 :
115 :
116 :
117 :
118 :
119 : x->time = time.toIDLArrayTime();
120 :
121 :
122 :
123 :
124 :
125 :
126 :
127 :
128 :
129 :
130 : x->scanNumber = scanNumber;
131 :
132 :
133 :
134 :
135 :
136 :
137 :
138 :
139 :
140 :
141 :
142 : x->subscanNumber = subscanNumber;
143 :
144 :
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 :
153 :
154 : x->integrationNumber = integrationNumber;
155 :
156 :
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 :
165 : x->uvw.length(uvw.size());
166 : for (unsigned int i = 0; i < uvw.size(); i++) {
167 : x->uvw[i].length(uvw.at(i).size());
168 : }
169 :
170 : for (unsigned int i = 0; i < uvw.size() ; i++)
171 : for (unsigned int j = 0; j < uvw.at(i).size(); j++)
172 :
173 : x->uvw[i][j]= uvw.at(i).at(j).toIDLLength();
174 :
175 :
176 :
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 :
185 : x->exposure.length(exposure.size());
186 : for (unsigned int i = 0; i < exposure.size(); i++) {
187 : x->exposure[i].length(exposure.at(i).size());
188 : }
189 :
190 : for (unsigned int i = 0; i < exposure.size() ; i++)
191 : for (unsigned int j = 0; j < exposure.at(i).size(); j++)
192 :
193 : x->exposure[i][j]= exposure.at(i).at(j).toIDLInterval();
194 :
195 :
196 :
197 :
198 :
199 :
200 :
201 :
202 :
203 :
204 :
205 : x->timeCentroid.length(timeCentroid.size());
206 : for (unsigned int i = 0; i < timeCentroid.size(); i++) {
207 : x->timeCentroid[i].length(timeCentroid.at(i).size());
208 : }
209 :
210 : for (unsigned int i = 0; i < timeCentroid.size() ; i++)
211 : for (unsigned int j = 0; j < timeCentroid.at(i).size(); j++)
212 :
213 : x->timeCentroid[i][j]= timeCentroid.at(i).at(j).toIDLArrayTime();
214 :
215 :
216 :
217 :
218 :
219 :
220 :
221 :
222 :
223 :
224 :
225 : x->floatData.length(floatData.size());
226 : for (unsigned int i = 0; i < floatData.size(); i++) {
227 : x->floatData[i].length(floatData.at(i).size());
228 : for (unsigned int j = 0; j < floatData.at(i).size(); j++) {
229 : x->floatData[i][j].length(floatData.at(i).at(j).size());
230 : }
231 : }
232 :
233 : for (unsigned int i = 0; i < floatData.size() ; i++)
234 : for (unsigned int j = 0; j < floatData.at(i).size(); j++)
235 : for (unsigned int k = 0; k < floatData.at(i).at(j).size(); k++)
236 :
237 :
238 : x->floatData[i][j][k] = floatData.at(i).at(j).at(k);
239 :
240 :
241 :
242 :
243 :
244 :
245 :
246 :
247 :
248 :
249 :
250 : x->flagAnt.length(flagAnt.size());
251 : for (unsigned int i = 0; i < flagAnt.size(); ++i) {
252 :
253 :
254 : x->flagAnt[i] = flagAnt.at(i);
255 :
256 :
257 : }
258 :
259 :
260 :
261 :
262 :
263 :
264 :
265 :
266 :
267 : x->flagPol.length(flagPol.size());
268 : for (unsigned int i = 0; i < flagPol.size(); i++) {
269 : x->flagPol[i].length(flagPol.at(i).size());
270 : }
271 :
272 : for (unsigned int i = 0; i < flagPol.size() ; i++)
273 : for (unsigned int j = 0; j < flagPol.at(i).size(); j++)
274 :
275 :
276 : x->flagPol[i][j] = flagPol.at(i).at(j);
277 :
278 :
279 :
280 :
281 :
282 :
283 :
284 :
285 :
286 :
287 :
288 :
289 : x->interval = interval.toIDLInterval();
290 :
291 :
292 :
293 :
294 :
295 :
296 :
297 : x->subintegrationNumberExists = subintegrationNumberExists;
298 :
299 :
300 :
301 :
302 : x->subintegrationNumber = subintegrationNumber;
303 :
304 :
305 :
306 :
307 :
308 :
309 :
310 :
311 :
312 :
313 :
314 :
315 :
316 :
317 : x->configDescriptionId = configDescriptionId.toIDLTag();
318 :
319 :
320 :
321 :
322 :
323 :
324 :
325 :
326 :
327 :
328 : x->execBlockId = execBlockId.toIDLTag();
329 :
330 :
331 :
332 :
333 :
334 :
335 :
336 :
337 :
338 :
339 : x->fieldId = fieldId.toIDLTag();
340 :
341 :
342 :
343 :
344 :
345 :
346 :
347 :
348 :
349 : x->stateId.length(stateId.size());
350 : for (unsigned int i = 0; i < stateId.size(); ++i) {
351 :
352 : x->stateId[i] = stateId.at(i).toIDLTag();
353 :
354 : }
355 :
356 :
357 :
358 :
359 :
360 :
361 :
362 :
363 :
364 :
365 :
366 :
367 :
368 :
369 : return x;
370 :
371 : }
372 :
373 : void TotalPowerRow::toIDL(asdmIDL::TotalPowerRowIDL& x) const {
374 : // Set the x's fields.
375 :
376 :
377 :
378 :
379 :
380 :
381 :
382 : x.time = time.toIDLArrayTime();
383 :
384 :
385 :
386 :
387 :
388 :
389 :
390 :
391 :
392 :
393 : x.scanNumber = scanNumber;
394 :
395 :
396 :
397 :
398 :
399 :
400 :
401 :
402 :
403 :
404 :
405 : x.subscanNumber = subscanNumber;
406 :
407 :
408 :
409 :
410 :
411 :
412 :
413 :
414 :
415 :
416 :
417 : x.integrationNumber = integrationNumber;
418 :
419 :
420 :
421 :
422 :
423 :
424 :
425 :
426 :
427 :
428 : x.uvw.length(uvw.size());
429 : for (unsigned int i = 0; i < uvw.size(); i++) {
430 : x.uvw[i].length(uvw.at(i).size());
431 : }
432 :
433 : for (unsigned int i = 0; i < uvw.size() ; i++)
434 : for (unsigned int j = 0; j < uvw.at(i).size(); j++)
435 :
436 : x.uvw[i][j]= uvw.at(i).at(j).toIDLLength();
437 :
438 :
439 :
440 :
441 :
442 :
443 :
444 :
445 :
446 :
447 :
448 : x.exposure.length(exposure.size());
449 : for (unsigned int i = 0; i < exposure.size(); i++) {
450 : x.exposure[i].length(exposure.at(i).size());
451 : }
452 :
453 : for (unsigned int i = 0; i < exposure.size() ; i++)
454 : for (unsigned int j = 0; j < exposure.at(i).size(); j++)
455 :
456 : x.exposure[i][j]= exposure.at(i).at(j).toIDLInterval();
457 :
458 :
459 :
460 :
461 :
462 :
463 :
464 :
465 :
466 :
467 :
468 : x.timeCentroid.length(timeCentroid.size());
469 : for (unsigned int i = 0; i < timeCentroid.size(); i++) {
470 : x.timeCentroid[i].length(timeCentroid.at(i).size());
471 : }
472 :
473 : for (unsigned int i = 0; i < timeCentroid.size() ; i++)
474 : for (unsigned int j = 0; j < timeCentroid.at(i).size(); j++)
475 :
476 : x.timeCentroid[i][j]= timeCentroid.at(i).at(j).toIDLArrayTime();
477 :
478 :
479 :
480 :
481 :
482 :
483 :
484 :
485 :
486 :
487 :
488 : x.floatData.length(floatData.size());
489 : for (unsigned int i = 0; i < floatData.size(); i++) {
490 : x.floatData[i].length(floatData.at(i).size());
491 : for (unsigned int j = 0; j < floatData.at(i).size(); j++) {
492 : x.floatData[i][j].length(floatData.at(i).at(j).size());
493 : }
494 : }
495 :
496 : for (unsigned int i = 0; i < floatData.size() ; i++)
497 : for (unsigned int j = 0; j < floatData.at(i).size(); j++)
498 : for (unsigned int k = 0; k < floatData.at(i).at(j).size(); k++)
499 :
500 :
501 : x.floatData[i][j][k] = floatData.at(i).at(j).at(k);
502 :
503 :
504 :
505 :
506 :
507 :
508 :
509 :
510 :
511 :
512 :
513 : x.flagAnt.length(flagAnt.size());
514 : for (unsigned int i = 0; i < flagAnt.size(); ++i) {
515 :
516 :
517 : x.flagAnt[i] = flagAnt.at(i);
518 :
519 :
520 : }
521 :
522 :
523 :
524 :
525 :
526 :
527 :
528 :
529 :
530 : x.flagPol.length(flagPol.size());
531 : for (unsigned int i = 0; i < flagPol.size(); i++) {
532 : x.flagPol[i].length(flagPol.at(i).size());
533 : }
534 :
535 : for (unsigned int i = 0; i < flagPol.size() ; i++)
536 : for (unsigned int j = 0; j < flagPol.at(i).size(); j++)
537 :
538 :
539 : x.flagPol[i][j] = flagPol.at(i).at(j);
540 :
541 :
542 :
543 :
544 :
545 :
546 :
547 :
548 :
549 :
550 :
551 :
552 : x.interval = interval.toIDLInterval();
553 :
554 :
555 :
556 :
557 :
558 :
559 :
560 : x.subintegrationNumberExists = subintegrationNumberExists;
561 :
562 :
563 :
564 :
565 : x.subintegrationNumber = subintegrationNumber;
566 :
567 :
568 :
569 :
570 :
571 :
572 :
573 :
574 :
575 :
576 :
577 :
578 :
579 :
580 : x.configDescriptionId = configDescriptionId.toIDLTag();
581 :
582 :
583 :
584 :
585 :
586 :
587 :
588 :
589 :
590 :
591 : x.execBlockId = execBlockId.toIDLTag();
592 :
593 :
594 :
595 :
596 :
597 :
598 :
599 :
600 :
601 :
602 : x.fieldId = fieldId.toIDLTag();
603 :
604 :
605 :
606 :
607 :
608 :
609 :
610 :
611 :
612 : x.stateId.length(stateId.size());
613 : for (unsigned int i = 0; i < stateId.size(); ++i) {
614 :
615 : x.stateId[i] = stateId.at(i).toIDLTag();
616 :
617 : }
618 :
619 :
620 :
621 :
622 :
623 :
624 :
625 :
626 :
627 :
628 :
629 :
630 :
631 :
632 : }
633 : #endif
634 :
635 :
636 : #ifndef WITHOUT_ACS
637 : /**
638 : * Fill the values of this row from the IDL struct TotalPowerRowIDL.
639 : * @param x The IDL struct containing the values used to fill this row.
640 : */
641 : void TotalPowerRow::setFromIDL (TotalPowerRowIDL x){
642 : try {
643 : // Fill the values from x.
644 :
645 :
646 :
647 :
648 :
649 :
650 : setTime(ArrayTime (x.time));
651 :
652 :
653 :
654 :
655 :
656 :
657 :
658 :
659 :
660 : setScanNumber(x.scanNumber);
661 :
662 :
663 :
664 :
665 :
666 :
667 :
668 :
669 :
670 : setSubscanNumber(x.subscanNumber);
671 :
672 :
673 :
674 :
675 :
676 :
677 :
678 :
679 :
680 : setIntegrationNumber(x.integrationNumber);
681 :
682 :
683 :
684 :
685 :
686 :
687 :
688 :
689 :
690 : uvw .clear();
691 :
692 : vector<Length> v_aux_uvw;
693 :
694 : for (unsigned int i = 0; i < x.uvw.length(); ++i) {
695 : v_aux_uvw.clear();
696 : for (unsigned int j = 0; j < x.uvw[0].length(); ++j) {
697 :
698 : v_aux_uvw.push_back(Length (x.uvw[i][j]));
699 :
700 : }
701 : uvw.push_back(v_aux_uvw);
702 : }
703 :
704 :
705 :
706 :
707 :
708 :
709 :
710 :
711 :
712 : exposure .clear();
713 :
714 : vector<Interval> v_aux_exposure;
715 :
716 : for (unsigned int i = 0; i < x.exposure.length(); ++i) {
717 : v_aux_exposure.clear();
718 : for (unsigned int j = 0; j < x.exposure[0].length(); ++j) {
719 :
720 : v_aux_exposure.push_back(Interval (x.exposure[i][j]));
721 :
722 : }
723 : exposure.push_back(v_aux_exposure);
724 : }
725 :
726 :
727 :
728 :
729 :
730 :
731 :
732 :
733 :
734 : timeCentroid .clear();
735 :
736 : vector<ArrayTime> v_aux_timeCentroid;
737 :
738 : for (unsigned int i = 0; i < x.timeCentroid.length(); ++i) {
739 : v_aux_timeCentroid.clear();
740 : for (unsigned int j = 0; j < x.timeCentroid[0].length(); ++j) {
741 :
742 : v_aux_timeCentroid.push_back(ArrayTime (x.timeCentroid[i][j]));
743 :
744 : }
745 : timeCentroid.push_back(v_aux_timeCentroid);
746 : }
747 :
748 :
749 :
750 :
751 :
752 :
753 :
754 :
755 :
756 : floatData .clear();
757 : vector< vector<float> > vv_aux_floatData;
758 : vector<float> v_aux_floatData;
759 :
760 : for (unsigned int i = 0; i < x.floatData.length(); ++i) {
761 : vv_aux_floatData.clear();
762 : for (unsigned int j = 0; j < x.floatData[0].length(); ++j) {
763 : v_aux_floatData.clear();
764 : for (unsigned int k = 0; k < x.floatData[0][0].length(); ++k) {
765 :
766 : v_aux_floatData.push_back(x.floatData[i][j][k]);
767 :
768 : }
769 : vv_aux_floatData.push_back(v_aux_floatData);
770 : }
771 : floatData.push_back(vv_aux_floatData);
772 : }
773 :
774 :
775 :
776 :
777 :
778 :
779 :
780 :
781 :
782 : flagAnt .clear();
783 : for (unsigned int i = 0; i <x.flagAnt.length(); ++i) {
784 :
785 : flagAnt.push_back(x.flagAnt[i]);
786 :
787 : }
788 :
789 :
790 :
791 :
792 :
793 :
794 :
795 :
796 :
797 : flagPol .clear();
798 :
799 : vector<int> v_aux_flagPol;
800 :
801 : for (unsigned int i = 0; i < x.flagPol.length(); ++i) {
802 : v_aux_flagPol.clear();
803 : for (unsigned int j = 0; j < x.flagPol[0].length(); ++j) {
804 :
805 : v_aux_flagPol.push_back(x.flagPol[i][j]);
806 :
807 : }
808 : flagPol.push_back(v_aux_flagPol);
809 : }
810 :
811 :
812 :
813 :
814 :
815 :
816 :
817 :
818 :
819 : setInterval(Interval (x.interval));
820 :
821 :
822 :
823 :
824 :
825 :
826 :
827 : subintegrationNumberExists = x.subintegrationNumberExists;
828 : if (x.subintegrationNumberExists) {
829 :
830 :
831 :
832 : setSubintegrationNumber(x.subintegrationNumber);
833 :
834 :
835 :
836 : }
837 :
838 :
839 :
840 :
841 :
842 :
843 :
844 :
845 :
846 :
847 : setConfigDescriptionId(Tag (x.configDescriptionId));
848 :
849 :
850 :
851 :
852 :
853 :
854 :
855 :
856 :
857 : setExecBlockId(Tag (x.execBlockId));
858 :
859 :
860 :
861 :
862 :
863 :
864 :
865 :
866 :
867 : setFieldId(Tag (x.fieldId));
868 :
869 :
870 :
871 :
872 :
873 :
874 :
875 : stateId .clear();
876 : for (unsigned int i = 0; i <x.stateId.length(); ++i) {
877 :
878 : stateId.push_back(Tag (x.stateId[i]));
879 :
880 : }
881 :
882 :
883 :
884 :
885 :
886 :
887 :
888 :
889 :
890 :
891 :
892 :
893 :
894 : } catch (const IllegalAccessException &err) {
895 : throw ConversionException (err.getMessage(),"TotalPower");
896 : }
897 : }
898 : #endif
899 :
900 : /**
901 : * Return this row in the form of an XML string.
902 : * @return The values of this row as an XML string.
903 : */
904 0 : string TotalPowerRow::toXML() const {
905 0 : string buf;
906 0 : buf.append("<row> \n");
907 :
908 :
909 :
910 :
911 :
912 :
913 0 : Parser::toXML(time, "time", buf);
914 :
915 :
916 :
917 :
918 :
919 :
920 :
921 0 : Parser::toXML(scanNumber, "scanNumber", buf);
922 :
923 :
924 :
925 :
926 :
927 :
928 :
929 0 : Parser::toXML(subscanNumber, "subscanNumber", buf);
930 :
931 :
932 :
933 :
934 :
935 :
936 :
937 0 : Parser::toXML(integrationNumber, "integrationNumber", buf);
938 :
939 :
940 :
941 :
942 :
943 :
944 :
945 0 : Parser::toXML(uvw, "uvw", buf);
946 :
947 :
948 :
949 :
950 :
951 :
952 :
953 0 : Parser::toXML(exposure, "exposure", buf);
954 :
955 :
956 :
957 :
958 :
959 :
960 :
961 0 : Parser::toXML(timeCentroid, "timeCentroid", buf);
962 :
963 :
964 :
965 :
966 :
967 :
968 :
969 0 : Parser::toXML(floatData, "floatData", buf);
970 :
971 :
972 :
973 :
974 :
975 :
976 :
977 0 : Parser::toXML(flagAnt, "flagAnt", buf);
978 :
979 :
980 :
981 :
982 :
983 :
984 :
985 0 : Parser::toXML(flagPol, "flagPol", buf);
986 :
987 :
988 :
989 :
990 :
991 :
992 :
993 0 : Parser::toXML(interval, "interval", buf);
994 :
995 :
996 :
997 :
998 :
999 :
1000 0 : if (subintegrationNumberExists) {
1001 :
1002 :
1003 0 : Parser::toXML(subintegrationNumber, "subintegrationNumber", buf);
1004 :
1005 :
1006 : }
1007 :
1008 :
1009 :
1010 :
1011 :
1012 :
1013 :
1014 :
1015 :
1016 0 : Parser::toXML(configDescriptionId, "configDescriptionId", buf);
1017 :
1018 :
1019 :
1020 :
1021 :
1022 :
1023 :
1024 0 : Parser::toXML(execBlockId, "execBlockId", buf);
1025 :
1026 :
1027 :
1028 :
1029 :
1030 :
1031 :
1032 0 : Parser::toXML(fieldId, "fieldId", buf);
1033 :
1034 :
1035 :
1036 :
1037 :
1038 :
1039 :
1040 0 : Parser::toXML(stateId, "stateId", buf);
1041 :
1042 :
1043 :
1044 :
1045 :
1046 :
1047 :
1048 :
1049 :
1050 :
1051 :
1052 :
1053 :
1054 :
1055 :
1056 0 : buf.append("</row>\n");
1057 0 : return buf;
1058 : }
1059 :
1060 : /**
1061 : * Fill the values of this row from an XML string
1062 : * that was produced by the toXML() method.
1063 : * @param x The XML string being used to set the values of this row.
1064 : */
1065 0 : void TotalPowerRow::setFromXML (string rowDoc) {
1066 0 : Parser row(rowDoc);
1067 0 : string s = "";
1068 : try {
1069 :
1070 :
1071 :
1072 :
1073 :
1074 0 : setTime(Parser::getArrayTime("time","TotalPower",rowDoc));
1075 :
1076 :
1077 :
1078 :
1079 :
1080 :
1081 :
1082 0 : setScanNumber(Parser::getInteger("scanNumber","TotalPower",rowDoc));
1083 :
1084 :
1085 :
1086 :
1087 :
1088 :
1089 :
1090 0 : setSubscanNumber(Parser::getInteger("subscanNumber","TotalPower",rowDoc));
1091 :
1092 :
1093 :
1094 :
1095 :
1096 :
1097 :
1098 0 : setIntegrationNumber(Parser::getInteger("integrationNumber","TotalPower",rowDoc));
1099 :
1100 :
1101 :
1102 :
1103 :
1104 :
1105 :
1106 :
1107 0 : setUvw(Parser::get2DLength("uvw","TotalPower",rowDoc));
1108 :
1109 :
1110 :
1111 :
1112 :
1113 :
1114 :
1115 :
1116 :
1117 0 : setExposure(Parser::get2DInterval("exposure","TotalPower",rowDoc));
1118 :
1119 :
1120 :
1121 :
1122 :
1123 :
1124 :
1125 :
1126 :
1127 0 : setTimeCentroid(Parser::get2DArrayTime("timeCentroid","TotalPower",rowDoc));
1128 :
1129 :
1130 :
1131 :
1132 :
1133 :
1134 :
1135 :
1136 :
1137 0 : setFloatData(Parser::get3DFloat("floatData","TotalPower",rowDoc));
1138 :
1139 :
1140 :
1141 :
1142 :
1143 :
1144 :
1145 :
1146 :
1147 0 : setFlagAnt(Parser::get1DInteger("flagAnt","TotalPower",rowDoc));
1148 :
1149 :
1150 :
1151 :
1152 :
1153 :
1154 :
1155 :
1156 :
1157 0 : setFlagPol(Parser::get2DInteger("flagPol","TotalPower",rowDoc));
1158 :
1159 :
1160 :
1161 :
1162 :
1163 :
1164 :
1165 :
1166 0 : setInterval(Parser::getInterval("interval","TotalPower",rowDoc));
1167 :
1168 :
1169 :
1170 :
1171 :
1172 :
1173 0 : if (row.isStr("<subintegrationNumber>")) {
1174 :
1175 0 : setSubintegrationNumber(Parser::getInteger("subintegrationNumber","TotalPower",rowDoc));
1176 :
1177 : }
1178 :
1179 :
1180 :
1181 :
1182 :
1183 :
1184 :
1185 :
1186 :
1187 0 : setConfigDescriptionId(Parser::getTag("configDescriptionId","Processor",rowDoc));
1188 :
1189 :
1190 :
1191 :
1192 :
1193 :
1194 :
1195 0 : setExecBlockId(Parser::getTag("execBlockId","TotalPower",rowDoc));
1196 :
1197 :
1198 :
1199 :
1200 :
1201 :
1202 :
1203 0 : setFieldId(Parser::getTag("fieldId","Field",rowDoc));
1204 :
1205 :
1206 :
1207 :
1208 :
1209 :
1210 0 : setStateId(Parser::get1DTag("stateId","TotalPower",rowDoc));
1211 :
1212 :
1213 :
1214 :
1215 :
1216 :
1217 :
1218 :
1219 :
1220 :
1221 :
1222 :
1223 :
1224 0 : } catch (const IllegalAccessException &err) {
1225 0 : throw ConversionException (err.getMessage(),"TotalPower");
1226 : }
1227 0 : }
1228 :
1229 0 : void TotalPowerRow::toBin(EndianOSStream& eoss) {
1230 :
1231 :
1232 :
1233 :
1234 :
1235 0 : time.toBin(eoss);
1236 :
1237 :
1238 :
1239 :
1240 :
1241 :
1242 0 : configDescriptionId.toBin(eoss);
1243 :
1244 :
1245 :
1246 :
1247 :
1248 :
1249 0 : fieldId.toBin(eoss);
1250 :
1251 :
1252 :
1253 :
1254 :
1255 :
1256 :
1257 0 : eoss.writeInt(scanNumber);
1258 :
1259 :
1260 :
1261 :
1262 :
1263 :
1264 :
1265 :
1266 0 : eoss.writeInt(subscanNumber);
1267 :
1268 :
1269 :
1270 :
1271 :
1272 :
1273 :
1274 :
1275 0 : eoss.writeInt(integrationNumber);
1276 :
1277 :
1278 :
1279 :
1280 :
1281 :
1282 :
1283 0 : Length::toBin(uvw, eoss);
1284 :
1285 :
1286 :
1287 :
1288 :
1289 :
1290 0 : Interval::toBin(exposure, eoss);
1291 :
1292 :
1293 :
1294 :
1295 :
1296 :
1297 0 : ArrayTime::toBin(timeCentroid, eoss);
1298 :
1299 :
1300 :
1301 :
1302 :
1303 :
1304 :
1305 :
1306 0 : eoss.writeInt((int) floatData.size());
1307 0 : eoss.writeInt((int) floatData.at(0).size());
1308 0 : eoss.writeInt((int) floatData.at(0).at(0).size());
1309 0 : for (unsigned int i = 0; i < floatData.size(); i++)
1310 0 : for (unsigned int j = 0; j < floatData.at(0).size(); j++)
1311 0 : for (unsigned int k = 0; k < floatData.at(0).at(0).size(); k++)
1312 :
1313 0 : eoss.writeFloat(floatData.at(i).at(j).at(k));
1314 :
1315 :
1316 :
1317 :
1318 :
1319 :
1320 :
1321 :
1322 :
1323 :
1324 0 : eoss.writeInt((int) flagAnt.size());
1325 0 : for (unsigned int i = 0; i < flagAnt.size(); i++)
1326 :
1327 0 : eoss.writeInt(flagAnt.at(i));
1328 :
1329 :
1330 :
1331 :
1332 :
1333 :
1334 :
1335 :
1336 :
1337 :
1338 :
1339 0 : eoss.writeInt((int) flagPol.size());
1340 0 : eoss.writeInt((int) flagPol.at(0).size());
1341 0 : for (unsigned int i = 0; i < flagPol.size(); i++)
1342 0 : for (unsigned int j = 0; j < flagPol.at(0).size(); j++)
1343 :
1344 0 : eoss.writeInt(flagPol.at(i).at(j));
1345 :
1346 :
1347 :
1348 :
1349 :
1350 :
1351 :
1352 :
1353 :
1354 0 : interval.toBin(eoss);
1355 :
1356 :
1357 :
1358 :
1359 :
1360 :
1361 0 : Tag::toBin(stateId, eoss);
1362 :
1363 :
1364 :
1365 :
1366 :
1367 :
1368 0 : execBlockId.toBin(eoss);
1369 :
1370 :
1371 :
1372 :
1373 :
1374 :
1375 0 : eoss.writeBoolean(subintegrationNumberExists);
1376 0 : if (subintegrationNumberExists) {
1377 :
1378 :
1379 :
1380 :
1381 :
1382 0 : eoss.writeInt(subintegrationNumber);
1383 :
1384 :
1385 :
1386 :
1387 : }
1388 :
1389 0 : }
1390 :
1391 0 : void TotalPowerRow::timeFromBin(EndianIStream& eis) {
1392 :
1393 :
1394 :
1395 :
1396 0 : time = ArrayTime::fromBin(eis);
1397 :
1398 :
1399 :
1400 0 : }
1401 0 : void TotalPowerRow::configDescriptionIdFromBin(EndianIStream& eis) {
1402 :
1403 :
1404 :
1405 :
1406 0 : configDescriptionId = Tag::fromBin(eis);
1407 :
1408 :
1409 :
1410 0 : }
1411 0 : void TotalPowerRow::fieldIdFromBin(EndianIStream& eis) {
1412 :
1413 :
1414 :
1415 :
1416 0 : fieldId = Tag::fromBin(eis);
1417 :
1418 :
1419 :
1420 0 : }
1421 0 : void TotalPowerRow::scanNumberFromBin(EndianIStream& eis) {
1422 :
1423 :
1424 :
1425 :
1426 :
1427 0 : scanNumber = eis.readInt();
1428 :
1429 :
1430 :
1431 :
1432 0 : }
1433 0 : void TotalPowerRow::subscanNumberFromBin(EndianIStream& eis) {
1434 :
1435 :
1436 :
1437 :
1438 :
1439 0 : subscanNumber = eis.readInt();
1440 :
1441 :
1442 :
1443 :
1444 0 : }
1445 0 : void TotalPowerRow::integrationNumberFromBin(EndianIStream& eis) {
1446 :
1447 :
1448 :
1449 :
1450 :
1451 0 : integrationNumber = eis.readInt();
1452 :
1453 :
1454 :
1455 :
1456 0 : }
1457 0 : void TotalPowerRow::uvwFromBin(EndianIStream& eis) {
1458 :
1459 :
1460 :
1461 :
1462 :
1463 :
1464 0 : uvw = Length::from2DBin(eis);
1465 :
1466 :
1467 :
1468 :
1469 :
1470 0 : }
1471 0 : void TotalPowerRow::exposureFromBin(EndianIStream& eis) {
1472 :
1473 :
1474 :
1475 :
1476 :
1477 :
1478 0 : exposure = Interval::from2DBin(eis);
1479 :
1480 :
1481 :
1482 :
1483 :
1484 0 : }
1485 0 : void TotalPowerRow::timeCentroidFromBin(EndianIStream& eis) {
1486 :
1487 :
1488 :
1489 :
1490 :
1491 :
1492 0 : timeCentroid = ArrayTime::from2DBin(eis);
1493 :
1494 :
1495 :
1496 :
1497 :
1498 0 : }
1499 0 : void TotalPowerRow::floatDataFromBin(EndianIStream& eis) {
1500 :
1501 :
1502 :
1503 :
1504 :
1505 :
1506 0 : floatData.clear();
1507 :
1508 0 : unsigned int floatDataDim1 = eis.readInt();
1509 0 : unsigned int floatDataDim2 = eis.readInt();
1510 0 : unsigned int floatDataDim3 = eis.readInt();
1511 0 : vector <vector<float> > floatDataAux2;
1512 0 : vector <float> floatDataAux1;
1513 0 : for (unsigned int i = 0; i < floatDataDim1; i++) {
1514 0 : floatDataAux2.clear();
1515 0 : for (unsigned int j = 0; j < floatDataDim2 ; j++) {
1516 0 : floatDataAux1.clear();
1517 0 : for (unsigned int k = 0; k < floatDataDim3; k++) {
1518 :
1519 0 : floatDataAux1.push_back(eis.readFloat());
1520 :
1521 : }
1522 0 : floatDataAux2.push_back(floatDataAux1);
1523 : }
1524 0 : floatData.push_back(floatDataAux2);
1525 : }
1526 :
1527 :
1528 :
1529 :
1530 :
1531 0 : }
1532 0 : void TotalPowerRow::flagAntFromBin(EndianIStream& eis) {
1533 :
1534 :
1535 :
1536 :
1537 :
1538 :
1539 0 : flagAnt.clear();
1540 :
1541 0 : unsigned int flagAntDim1 = eis.readInt();
1542 0 : for (unsigned int i = 0 ; i < flagAntDim1; i++)
1543 :
1544 0 : flagAnt.push_back(eis.readInt());
1545 :
1546 :
1547 :
1548 :
1549 :
1550 :
1551 0 : }
1552 0 : void TotalPowerRow::flagPolFromBin(EndianIStream& eis) {
1553 :
1554 :
1555 :
1556 :
1557 :
1558 :
1559 0 : flagPol.clear();
1560 :
1561 0 : unsigned int flagPolDim1 = eis.readInt();
1562 0 : unsigned int flagPolDim2 = eis.readInt();
1563 :
1564 0 : vector <int> flagPolAux1;
1565 :
1566 0 : for (unsigned int i = 0; i < flagPolDim1; i++) {
1567 0 : flagPolAux1.clear();
1568 0 : for (unsigned int j = 0; j < flagPolDim2 ; j++)
1569 :
1570 0 : flagPolAux1.push_back(eis.readInt());
1571 :
1572 0 : flagPol.push_back(flagPolAux1);
1573 : }
1574 :
1575 :
1576 :
1577 :
1578 :
1579 :
1580 0 : }
1581 0 : void TotalPowerRow::intervalFromBin(EndianIStream& eis) {
1582 :
1583 :
1584 :
1585 :
1586 0 : interval = Interval::fromBin(eis);
1587 :
1588 :
1589 :
1590 0 : }
1591 0 : void TotalPowerRow::stateIdFromBin(EndianIStream& eis) {
1592 :
1593 :
1594 :
1595 :
1596 :
1597 :
1598 0 : stateId = Tag::from1DBin(eis);
1599 :
1600 :
1601 :
1602 :
1603 :
1604 0 : }
1605 0 : void TotalPowerRow::execBlockIdFromBin(EndianIStream& eis) {
1606 :
1607 :
1608 :
1609 :
1610 0 : execBlockId = Tag::fromBin(eis);
1611 :
1612 :
1613 :
1614 0 : }
1615 :
1616 0 : void TotalPowerRow::subintegrationNumberFromBin(EndianIStream& eis) {
1617 :
1618 0 : subintegrationNumberExists = eis.readBoolean();
1619 0 : if (subintegrationNumberExists) {
1620 :
1621 :
1622 :
1623 :
1624 :
1625 0 : subintegrationNumber = eis.readInt();
1626 :
1627 :
1628 :
1629 :
1630 : }
1631 :
1632 0 : }
1633 :
1634 :
1635 0 : TotalPowerRow* TotalPowerRow::fromBin(EndianIStream& eis, TotalPowerTable& table, const vector<string>& attributesSeq) {
1636 0 : TotalPowerRow* row = new TotalPowerRow(table);
1637 :
1638 0 : map<string, TotalPowerAttributeFromBin>::iterator iter ;
1639 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
1640 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
1641 0 : if (iter != row->fromBinMethods.end()) {
1642 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
1643 : }
1644 : else {
1645 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
1646 0 : if (functorP)
1647 0 : (*functorP)(eis);
1648 : else
1649 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "TotalPowerTable");
1650 : }
1651 :
1652 : }
1653 0 : return row;
1654 : }
1655 :
1656 : //
1657 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
1658 : // of one row.
1659 : //
1660 :
1661 : // Convert a string into an ArrayTime
1662 0 : void TotalPowerRow::timeFromText(const string & s) {
1663 :
1664 :
1665 0 : time = ASDMValuesParser::parse<ArrayTime>(s);
1666 :
1667 :
1668 0 : }
1669 :
1670 :
1671 : // Convert a string into an Tag
1672 0 : void TotalPowerRow::configDescriptionIdFromText(const string & s) {
1673 :
1674 :
1675 0 : configDescriptionId = ASDMValuesParser::parse<Tag>(s);
1676 :
1677 :
1678 0 : }
1679 :
1680 :
1681 : // Convert a string into an Tag
1682 0 : void TotalPowerRow::fieldIdFromText(const string & s) {
1683 :
1684 :
1685 0 : fieldId = ASDMValuesParser::parse<Tag>(s);
1686 :
1687 :
1688 0 : }
1689 :
1690 :
1691 : // Convert a string into an int
1692 0 : void TotalPowerRow::scanNumberFromText(const string & s) {
1693 :
1694 :
1695 0 : scanNumber = ASDMValuesParser::parse<int>(s);
1696 :
1697 :
1698 0 : }
1699 :
1700 :
1701 : // Convert a string into an int
1702 0 : void TotalPowerRow::subscanNumberFromText(const string & s) {
1703 :
1704 :
1705 0 : subscanNumber = ASDMValuesParser::parse<int>(s);
1706 :
1707 :
1708 0 : }
1709 :
1710 :
1711 : // Convert a string into an int
1712 0 : void TotalPowerRow::integrationNumberFromText(const string & s) {
1713 :
1714 :
1715 0 : integrationNumber = ASDMValuesParser::parse<int>(s);
1716 :
1717 :
1718 0 : }
1719 :
1720 :
1721 : // Convert a string into an Length
1722 0 : void TotalPowerRow::uvwFromText(const string & s) {
1723 :
1724 :
1725 0 : uvw = ASDMValuesParser::parse2D<Length>(s);
1726 :
1727 :
1728 0 : }
1729 :
1730 :
1731 : // Convert a string into an Interval
1732 0 : void TotalPowerRow::exposureFromText(const string & s) {
1733 :
1734 :
1735 0 : exposure = ASDMValuesParser::parse2D<Interval>(s);
1736 :
1737 :
1738 0 : }
1739 :
1740 :
1741 : // Convert a string into an ArrayTime
1742 0 : void TotalPowerRow::timeCentroidFromText(const string & s) {
1743 :
1744 :
1745 0 : timeCentroid = ASDMValuesParser::parse2D<ArrayTime>(s);
1746 :
1747 :
1748 0 : }
1749 :
1750 :
1751 : // Convert a string into an float
1752 0 : void TotalPowerRow::floatDataFromText(const string & s) {
1753 :
1754 :
1755 0 : floatData = ASDMValuesParser::parse3D<float>(s);
1756 :
1757 :
1758 0 : }
1759 :
1760 :
1761 : // Convert a string into an int
1762 0 : void TotalPowerRow::flagAntFromText(const string & s) {
1763 :
1764 :
1765 0 : flagAnt = ASDMValuesParser::parse1D<int>(s);
1766 :
1767 :
1768 0 : }
1769 :
1770 :
1771 : // Convert a string into an int
1772 0 : void TotalPowerRow::flagPolFromText(const string & s) {
1773 :
1774 :
1775 0 : flagPol = ASDMValuesParser::parse2D<int>(s);
1776 :
1777 :
1778 0 : }
1779 :
1780 :
1781 : // Convert a string into an Interval
1782 0 : void TotalPowerRow::intervalFromText(const string & s) {
1783 :
1784 :
1785 0 : interval = ASDMValuesParser::parse<Interval>(s);
1786 :
1787 :
1788 0 : }
1789 :
1790 :
1791 : // Convert a string into an Tag
1792 0 : void TotalPowerRow::stateIdFromText(const string & s) {
1793 :
1794 :
1795 0 : stateId = ASDMValuesParser::parse1D<Tag>(s);
1796 :
1797 :
1798 0 : }
1799 :
1800 :
1801 : // Convert a string into an Tag
1802 0 : void TotalPowerRow::execBlockIdFromText(const string & s) {
1803 :
1804 :
1805 0 : execBlockId = ASDMValuesParser::parse<Tag>(s);
1806 :
1807 :
1808 0 : }
1809 :
1810 :
1811 :
1812 : // Convert a string into an int
1813 0 : void TotalPowerRow::subintegrationNumberFromText(const string & s) {
1814 0 : subintegrationNumberExists = true;
1815 :
1816 :
1817 0 : subintegrationNumber = ASDMValuesParser::parse<int>(s);
1818 :
1819 :
1820 0 : }
1821 :
1822 :
1823 :
1824 0 : void TotalPowerRow::fromText(const std::string& attributeName, const std::string& t) {
1825 0 : map<string, TotalPowerAttributeFromText>::iterator iter;
1826 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
1827 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "TotalPowerTable");
1828 0 : (this->*(iter->second))(t);
1829 0 : }
1830 :
1831 : ////////////////////////////////////////////////
1832 : // Intrinsic Table Attributes getters/setters //
1833 : ////////////////////////////////////////////////
1834 :
1835 :
1836 :
1837 :
1838 : /**
1839 : * Get time.
1840 : * @return time as ArrayTime
1841 : */
1842 0 : ArrayTime TotalPowerRow::getTime() const {
1843 :
1844 0 : return time;
1845 : }
1846 :
1847 : /**
1848 : * Set time with the specified ArrayTime.
1849 : * @param time The ArrayTime value to which time is to be set.
1850 :
1851 :
1852 :
1853 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1854 :
1855 : */
1856 0 : void TotalPowerRow::setTime (ArrayTime time) {
1857 :
1858 :
1859 0 : if (hasBeenAdded) {
1860 :
1861 0 : throw IllegalAccessException("time", "TotalPower");
1862 :
1863 : }
1864 :
1865 0 : this->time = time;
1866 :
1867 0 : }
1868 :
1869 :
1870 :
1871 :
1872 :
1873 :
1874 : /**
1875 : * Get scanNumber.
1876 : * @return scanNumber as int
1877 : */
1878 0 : int TotalPowerRow::getScanNumber() const {
1879 :
1880 0 : return scanNumber;
1881 : }
1882 :
1883 : /**
1884 : * Set scanNumber with the specified int.
1885 : * @param scanNumber The int value to which scanNumber is to be set.
1886 :
1887 :
1888 :
1889 : */
1890 0 : void TotalPowerRow::setScanNumber (int scanNumber) {
1891 :
1892 :
1893 0 : if (hasBeenAdded) {
1894 :
1895 : }
1896 :
1897 0 : this->scanNumber = scanNumber;
1898 :
1899 0 : }
1900 :
1901 :
1902 :
1903 :
1904 :
1905 :
1906 : /**
1907 : * Get subscanNumber.
1908 : * @return subscanNumber as int
1909 : */
1910 0 : int TotalPowerRow::getSubscanNumber() const {
1911 :
1912 0 : return subscanNumber;
1913 : }
1914 :
1915 : /**
1916 : * Set subscanNumber with the specified int.
1917 : * @param subscanNumber The int value to which subscanNumber is to be set.
1918 :
1919 :
1920 :
1921 : */
1922 0 : void TotalPowerRow::setSubscanNumber (int subscanNumber) {
1923 :
1924 :
1925 0 : if (hasBeenAdded) {
1926 :
1927 : }
1928 :
1929 0 : this->subscanNumber = subscanNumber;
1930 :
1931 0 : }
1932 :
1933 :
1934 :
1935 :
1936 :
1937 :
1938 : /**
1939 : * Get integrationNumber.
1940 : * @return integrationNumber as int
1941 : */
1942 0 : int TotalPowerRow::getIntegrationNumber() const {
1943 :
1944 0 : return integrationNumber;
1945 : }
1946 :
1947 : /**
1948 : * Set integrationNumber with the specified int.
1949 : * @param integrationNumber The int value to which integrationNumber is to be set.
1950 :
1951 :
1952 :
1953 : */
1954 0 : void TotalPowerRow::setIntegrationNumber (int integrationNumber) {
1955 :
1956 :
1957 0 : if (hasBeenAdded) {
1958 :
1959 : }
1960 :
1961 0 : this->integrationNumber = integrationNumber;
1962 :
1963 0 : }
1964 :
1965 :
1966 :
1967 :
1968 :
1969 :
1970 : /**
1971 : * Get uvw.
1972 : * @return uvw as std::vector<std::vector<Length > >
1973 : */
1974 0 : std::vector<std::vector<Length > > TotalPowerRow::getUvw() const {
1975 :
1976 0 : return uvw;
1977 : }
1978 :
1979 : /**
1980 : * Set uvw with the specified std::vector<std::vector<Length > >.
1981 : * @param uvw The std::vector<std::vector<Length > > value to which uvw is to be set.
1982 :
1983 :
1984 :
1985 : */
1986 0 : void TotalPowerRow::setUvw (std::vector<std::vector<Length > > uvw) {
1987 :
1988 :
1989 0 : if (hasBeenAdded) {
1990 :
1991 : }
1992 :
1993 0 : this->uvw = uvw;
1994 :
1995 0 : }
1996 :
1997 :
1998 :
1999 :
2000 :
2001 :
2002 : /**
2003 : * Get exposure.
2004 : * @return exposure as std::vector<std::vector<Interval > >
2005 : */
2006 0 : std::vector<std::vector<Interval > > TotalPowerRow::getExposure() const {
2007 :
2008 0 : return exposure;
2009 : }
2010 :
2011 : /**
2012 : * Set exposure with the specified std::vector<std::vector<Interval > >.
2013 : * @param exposure The std::vector<std::vector<Interval > > value to which exposure is to be set.
2014 :
2015 :
2016 :
2017 : */
2018 0 : void TotalPowerRow::setExposure (std::vector<std::vector<Interval > > exposure) {
2019 :
2020 :
2021 0 : if (hasBeenAdded) {
2022 :
2023 : }
2024 :
2025 0 : this->exposure = exposure;
2026 :
2027 0 : }
2028 :
2029 :
2030 :
2031 :
2032 :
2033 :
2034 : /**
2035 : * Get timeCentroid.
2036 : * @return timeCentroid as std::vector<std::vector<ArrayTime > >
2037 : */
2038 0 : std::vector<std::vector<ArrayTime > > TotalPowerRow::getTimeCentroid() const {
2039 :
2040 0 : return timeCentroid;
2041 : }
2042 :
2043 : /**
2044 : * Set timeCentroid with the specified std::vector<std::vector<ArrayTime > >.
2045 : * @param timeCentroid The std::vector<std::vector<ArrayTime > > value to which timeCentroid is to be set.
2046 :
2047 :
2048 :
2049 : */
2050 0 : void TotalPowerRow::setTimeCentroid (std::vector<std::vector<ArrayTime > > timeCentroid) {
2051 :
2052 :
2053 0 : if (hasBeenAdded) {
2054 :
2055 : }
2056 :
2057 0 : this->timeCentroid = timeCentroid;
2058 :
2059 0 : }
2060 :
2061 :
2062 :
2063 :
2064 :
2065 :
2066 : /**
2067 : * Get floatData.
2068 : * @return floatData as std::vector<std::vector<std::vector<float > > >
2069 : */
2070 0 : std::vector<std::vector<std::vector<float > > > TotalPowerRow::getFloatData() const {
2071 :
2072 0 : return floatData;
2073 : }
2074 :
2075 : /**
2076 : * Set floatData with the specified std::vector<std::vector<std::vector<float > > >.
2077 : * @param floatData The std::vector<std::vector<std::vector<float > > > value to which floatData is to be set.
2078 :
2079 :
2080 :
2081 : */
2082 0 : void TotalPowerRow::setFloatData (std::vector<std::vector<std::vector<float > > > floatData) {
2083 :
2084 :
2085 0 : if (hasBeenAdded) {
2086 :
2087 : }
2088 :
2089 0 : this->floatData = floatData;
2090 :
2091 0 : }
2092 :
2093 :
2094 :
2095 :
2096 :
2097 :
2098 : /**
2099 : * Get flagAnt.
2100 : * @return flagAnt as std::vector<int >
2101 : */
2102 0 : std::vector<int > TotalPowerRow::getFlagAnt() const {
2103 :
2104 0 : return flagAnt;
2105 : }
2106 :
2107 : /**
2108 : * Set flagAnt with the specified std::vector<int >.
2109 : * @param flagAnt The std::vector<int > value to which flagAnt is to be set.
2110 :
2111 :
2112 :
2113 : */
2114 0 : void TotalPowerRow::setFlagAnt (std::vector<int > flagAnt) {
2115 :
2116 :
2117 0 : if (hasBeenAdded) {
2118 :
2119 : }
2120 :
2121 0 : this->flagAnt = flagAnt;
2122 :
2123 0 : }
2124 :
2125 :
2126 :
2127 :
2128 :
2129 :
2130 : /**
2131 : * Get flagPol.
2132 : * @return flagPol as std::vector<std::vector<int > >
2133 : */
2134 0 : std::vector<std::vector<int > > TotalPowerRow::getFlagPol() const {
2135 :
2136 0 : return flagPol;
2137 : }
2138 :
2139 : /**
2140 : * Set flagPol with the specified std::vector<std::vector<int > >.
2141 : * @param flagPol The std::vector<std::vector<int > > value to which flagPol is to be set.
2142 :
2143 :
2144 :
2145 : */
2146 0 : void TotalPowerRow::setFlagPol (std::vector<std::vector<int > > flagPol) {
2147 :
2148 :
2149 0 : if (hasBeenAdded) {
2150 :
2151 : }
2152 :
2153 0 : this->flagPol = flagPol;
2154 :
2155 0 : }
2156 :
2157 :
2158 :
2159 :
2160 :
2161 :
2162 : /**
2163 : * Get interval.
2164 : * @return interval as Interval
2165 : */
2166 0 : Interval TotalPowerRow::getInterval() const {
2167 :
2168 0 : return interval;
2169 : }
2170 :
2171 : /**
2172 : * Set interval with the specified Interval.
2173 : * @param interval The Interval value to which interval is to be set.
2174 :
2175 :
2176 :
2177 : */
2178 0 : void TotalPowerRow::setInterval (Interval interval) {
2179 :
2180 :
2181 0 : if (hasBeenAdded) {
2182 :
2183 : }
2184 :
2185 0 : this->interval = interval;
2186 :
2187 0 : }
2188 :
2189 :
2190 :
2191 :
2192 : /**
2193 : * The attribute subintegrationNumber is optional. Return true if this attribute exists.
2194 : * @return true if and only if the subintegrationNumber attribute exists.
2195 : */
2196 0 : bool TotalPowerRow::isSubintegrationNumberExists() const {
2197 0 : return subintegrationNumberExists;
2198 : }
2199 :
2200 :
2201 :
2202 : /**
2203 : * Get subintegrationNumber, which is optional.
2204 : * @return subintegrationNumber as int
2205 : * @throw IllegalAccessException If subintegrationNumber does not exist.
2206 : */
2207 0 : int TotalPowerRow::getSubintegrationNumber() const {
2208 0 : if (!subintegrationNumberExists) {
2209 0 : throw IllegalAccessException("subintegrationNumber", "TotalPower");
2210 : }
2211 :
2212 0 : return subintegrationNumber;
2213 : }
2214 :
2215 : /**
2216 : * Set subintegrationNumber with the specified int.
2217 : * @param subintegrationNumber The int value to which subintegrationNumber is to be set.
2218 :
2219 :
2220 : */
2221 0 : void TotalPowerRow::setSubintegrationNumber (int subintegrationNumber) {
2222 :
2223 0 : this->subintegrationNumber = subintegrationNumber;
2224 :
2225 0 : subintegrationNumberExists = true;
2226 :
2227 0 : }
2228 :
2229 :
2230 : /**
2231 : * Mark subintegrationNumber, which is an optional field, as non-existent.
2232 : */
2233 0 : void TotalPowerRow::clearSubintegrationNumber () {
2234 0 : subintegrationNumberExists = false;
2235 0 : }
2236 :
2237 :
2238 :
2239 : ///////////////////////////////////////////////
2240 : // Extrinsic Table Attributes getters/setters//
2241 : ///////////////////////////////////////////////
2242 :
2243 :
2244 :
2245 :
2246 : /**
2247 : * Get configDescriptionId.
2248 : * @return configDescriptionId as Tag
2249 : */
2250 0 : Tag TotalPowerRow::getConfigDescriptionId() const {
2251 :
2252 0 : return configDescriptionId;
2253 : }
2254 :
2255 : /**
2256 : * Set configDescriptionId with the specified Tag.
2257 : * @param configDescriptionId The Tag value to which configDescriptionId is to be set.
2258 :
2259 :
2260 :
2261 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2262 :
2263 : */
2264 0 : void TotalPowerRow::setConfigDescriptionId (Tag configDescriptionId) {
2265 :
2266 :
2267 0 : if (hasBeenAdded) {
2268 :
2269 0 : throw IllegalAccessException("configDescriptionId", "TotalPower");
2270 :
2271 : }
2272 :
2273 0 : this->configDescriptionId = configDescriptionId;
2274 :
2275 0 : }
2276 :
2277 :
2278 :
2279 :
2280 :
2281 :
2282 : /**
2283 : * Get execBlockId.
2284 : * @return execBlockId as Tag
2285 : */
2286 0 : Tag TotalPowerRow::getExecBlockId() const {
2287 :
2288 0 : return execBlockId;
2289 : }
2290 :
2291 : /**
2292 : * Set execBlockId with the specified Tag.
2293 : * @param execBlockId The Tag value to which execBlockId is to be set.
2294 :
2295 :
2296 :
2297 : */
2298 0 : void TotalPowerRow::setExecBlockId (Tag execBlockId) {
2299 :
2300 :
2301 0 : if (hasBeenAdded) {
2302 :
2303 : }
2304 :
2305 0 : this->execBlockId = execBlockId;
2306 :
2307 0 : }
2308 :
2309 :
2310 :
2311 :
2312 :
2313 :
2314 : /**
2315 : * Get fieldId.
2316 : * @return fieldId as Tag
2317 : */
2318 0 : Tag TotalPowerRow::getFieldId() const {
2319 :
2320 0 : return fieldId;
2321 : }
2322 :
2323 : /**
2324 : * Set fieldId with the specified Tag.
2325 : * @param fieldId The Tag value to which fieldId is to be set.
2326 :
2327 :
2328 :
2329 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2330 :
2331 : */
2332 0 : void TotalPowerRow::setFieldId (Tag fieldId) {
2333 :
2334 :
2335 0 : if (hasBeenAdded) {
2336 :
2337 0 : throw IllegalAccessException("fieldId", "TotalPower");
2338 :
2339 : }
2340 :
2341 0 : this->fieldId = fieldId;
2342 :
2343 0 : }
2344 :
2345 :
2346 :
2347 :
2348 :
2349 :
2350 : /**
2351 : * Get stateId.
2352 : * @return stateId as std::vector<Tag>
2353 : */
2354 0 : std::vector<Tag> TotalPowerRow::getStateId() const {
2355 :
2356 0 : return stateId;
2357 : }
2358 :
2359 : /**
2360 : * Set stateId with the specified std::vector<Tag> .
2361 : * @param stateId The std::vector<Tag> value to which stateId is to be set.
2362 :
2363 :
2364 :
2365 : */
2366 0 : void TotalPowerRow::setStateId (std::vector<Tag> stateId) {
2367 :
2368 :
2369 0 : if (hasBeenAdded) {
2370 :
2371 : }
2372 :
2373 0 : this->stateId = stateId;
2374 :
2375 0 : }
2376 :
2377 :
2378 :
2379 :
2380 : //////////////////////////////////////
2381 : // Links Attributes getters/setters //
2382 : //////////////////////////////////////
2383 :
2384 :
2385 :
2386 : /**
2387 : * Set stateId[i] with the specified Tag.
2388 : * @param i The index in stateId where to set the Tag value.
2389 : * @param stateId The Tag value to which stateId[i] is to be set.
2390 :
2391 : * @throws IndexOutOfBoundsException
2392 : */
2393 0 : void TotalPowerRow::setStateId (int i, Tag stateId) {
2394 0 : if (hasBeenAdded) {
2395 :
2396 : }
2397 0 : if ((i < 0) || (i > ((int) this->stateId.size())))
2398 0 : throw OutOfBoundsException("Index out of bounds during a set operation on attribute stateId in table TotalPowerTable");
2399 0 : std::vector<Tag> ::iterator iter = this->stateId.begin();
2400 0 : int j = 0;
2401 0 : while (j < i) {
2402 0 : j++; iter++;
2403 : }
2404 0 : this->stateId.insert(this->stateId.erase(iter), stateId);
2405 0 : }
2406 :
2407 :
2408 :
2409 :
2410 :
2411 : /**
2412 : * Append a Tag to stateId.
2413 : * @param id the Tag to be appended to stateId
2414 : */
2415 0 : void TotalPowerRow::addStateId(Tag id){
2416 0 : stateId.push_back(id);
2417 0 : }
2418 :
2419 : /**
2420 : * Append an array of Tag to stateId.
2421 : * @param id an array of Tag to be appended to stateId
2422 : */
2423 0 : void TotalPowerRow::addStateId(const std::vector<Tag> & id) {
2424 0 : for (unsigned int i=0; i < id.size(); i++)
2425 0 : stateId.push_back(id.at(i));
2426 0 : }
2427 :
2428 :
2429 : /**
2430 : * Returns the Tag stored in stateId at position i.
2431 : *
2432 : */
2433 0 : const Tag TotalPowerRow::getStateId(int i) {
2434 0 : return stateId.at(i);
2435 : }
2436 :
2437 : /**
2438 : * Returns the StateRow linked to this row via the Tag stored in stateId
2439 : * at position i.
2440 : */
2441 0 : StateRow* TotalPowerRow::getStateUsingStateId(int i) {
2442 0 : return table.getContainer().getState().getRowByKey(stateId.at(i));
2443 : }
2444 :
2445 : /**
2446 : * Returns the vector of StateRow* linked to this row via the Tags stored in stateId
2447 : *
2448 : */
2449 0 : vector<StateRow *> TotalPowerRow::getStatesUsingStateId() {
2450 0 : vector<StateRow *> result;
2451 0 : for (unsigned int i = 0; i < stateId.size(); i++)
2452 0 : result.push_back(table.getContainer().getState().getRowByKey(stateId.at(i)));
2453 :
2454 0 : return result;
2455 : }
2456 :
2457 :
2458 :
2459 :
2460 :
2461 :
2462 :
2463 :
2464 :
2465 : /**
2466 : * Returns the pointer to the row in the Field table having Field.fieldId == fieldId
2467 : * @return a FieldRow*
2468 : *
2469 :
2470 : */
2471 0 : FieldRow* TotalPowerRow::getFieldUsingFieldId() {
2472 :
2473 0 : return table.getContainer().getField().getRowByKey(fieldId);
2474 : }
2475 :
2476 :
2477 :
2478 :
2479 :
2480 :
2481 :
2482 :
2483 :
2484 : /**
2485 : * Returns the pointer to the row in the ConfigDescription table having ConfigDescription.configDescriptionId == configDescriptionId
2486 : * @return a ConfigDescriptionRow*
2487 : *
2488 :
2489 : */
2490 0 : ConfigDescriptionRow* TotalPowerRow::getConfigDescriptionUsingConfigDescriptionId() {
2491 :
2492 0 : return table.getContainer().getConfigDescription().getRowByKey(configDescriptionId);
2493 : }
2494 :
2495 :
2496 :
2497 :
2498 :
2499 :
2500 :
2501 :
2502 :
2503 : /**
2504 : * Returns the pointer to the row in the ExecBlock table having ExecBlock.execBlockId == execBlockId
2505 : * @return a ExecBlockRow*
2506 : *
2507 :
2508 : */
2509 0 : ExecBlockRow* TotalPowerRow::getExecBlockUsingExecBlockId() {
2510 :
2511 0 : return table.getContainer().getExecBlock().getRowByKey(execBlockId);
2512 : }
2513 :
2514 :
2515 :
2516 :
2517 :
2518 : /**
2519 : * Create a TotalPowerRow.
2520 : * <p>
2521 : * This constructor is private because only the
2522 : * table can create rows. All rows know the table
2523 : * to which they belong.
2524 : * @param table The table to which this row belongs.
2525 : */
2526 0 : TotalPowerRow::TotalPowerRow (TotalPowerTable &t) : table(t) {
2527 0 : hasBeenAdded = false;
2528 :
2529 :
2530 :
2531 :
2532 :
2533 :
2534 :
2535 :
2536 :
2537 :
2538 :
2539 :
2540 :
2541 :
2542 :
2543 :
2544 :
2545 :
2546 :
2547 :
2548 :
2549 :
2550 :
2551 :
2552 :
2553 0 : subintegrationNumberExists = false;
2554 :
2555 :
2556 :
2557 :
2558 :
2559 :
2560 :
2561 :
2562 :
2563 :
2564 :
2565 :
2566 :
2567 :
2568 :
2569 :
2570 :
2571 :
2572 :
2573 :
2574 :
2575 :
2576 :
2577 :
2578 :
2579 :
2580 :
2581 :
2582 :
2583 :
2584 :
2585 :
2586 :
2587 :
2588 :
2589 :
2590 :
2591 :
2592 :
2593 :
2594 0 : fromBinMethods["time"] = &TotalPowerRow::timeFromBin;
2595 0 : fromBinMethods["configDescriptionId"] = &TotalPowerRow::configDescriptionIdFromBin;
2596 0 : fromBinMethods["fieldId"] = &TotalPowerRow::fieldIdFromBin;
2597 0 : fromBinMethods["scanNumber"] = &TotalPowerRow::scanNumberFromBin;
2598 0 : fromBinMethods["subscanNumber"] = &TotalPowerRow::subscanNumberFromBin;
2599 0 : fromBinMethods["integrationNumber"] = &TotalPowerRow::integrationNumberFromBin;
2600 0 : fromBinMethods["uvw"] = &TotalPowerRow::uvwFromBin;
2601 0 : fromBinMethods["exposure"] = &TotalPowerRow::exposureFromBin;
2602 0 : fromBinMethods["timeCentroid"] = &TotalPowerRow::timeCentroidFromBin;
2603 0 : fromBinMethods["floatData"] = &TotalPowerRow::floatDataFromBin;
2604 0 : fromBinMethods["flagAnt"] = &TotalPowerRow::flagAntFromBin;
2605 0 : fromBinMethods["flagPol"] = &TotalPowerRow::flagPolFromBin;
2606 0 : fromBinMethods["interval"] = &TotalPowerRow::intervalFromBin;
2607 0 : fromBinMethods["stateId"] = &TotalPowerRow::stateIdFromBin;
2608 0 : fromBinMethods["execBlockId"] = &TotalPowerRow::execBlockIdFromBin;
2609 :
2610 :
2611 0 : fromBinMethods["subintegrationNumber"] = &TotalPowerRow::subintegrationNumberFromBin;
2612 :
2613 :
2614 :
2615 :
2616 :
2617 0 : fromTextMethods["time"] = &TotalPowerRow::timeFromText;
2618 :
2619 :
2620 :
2621 0 : fromTextMethods["configDescriptionId"] = &TotalPowerRow::configDescriptionIdFromText;
2622 :
2623 :
2624 :
2625 0 : fromTextMethods["fieldId"] = &TotalPowerRow::fieldIdFromText;
2626 :
2627 :
2628 :
2629 0 : fromTextMethods["scanNumber"] = &TotalPowerRow::scanNumberFromText;
2630 :
2631 :
2632 :
2633 0 : fromTextMethods["subscanNumber"] = &TotalPowerRow::subscanNumberFromText;
2634 :
2635 :
2636 :
2637 0 : fromTextMethods["integrationNumber"] = &TotalPowerRow::integrationNumberFromText;
2638 :
2639 :
2640 :
2641 0 : fromTextMethods["uvw"] = &TotalPowerRow::uvwFromText;
2642 :
2643 :
2644 :
2645 0 : fromTextMethods["exposure"] = &TotalPowerRow::exposureFromText;
2646 :
2647 :
2648 :
2649 0 : fromTextMethods["timeCentroid"] = &TotalPowerRow::timeCentroidFromText;
2650 :
2651 :
2652 :
2653 0 : fromTextMethods["floatData"] = &TotalPowerRow::floatDataFromText;
2654 :
2655 :
2656 :
2657 0 : fromTextMethods["flagAnt"] = &TotalPowerRow::flagAntFromText;
2658 :
2659 :
2660 :
2661 0 : fromTextMethods["flagPol"] = &TotalPowerRow::flagPolFromText;
2662 :
2663 :
2664 :
2665 0 : fromTextMethods["interval"] = &TotalPowerRow::intervalFromText;
2666 :
2667 :
2668 :
2669 0 : fromTextMethods["stateId"] = &TotalPowerRow::stateIdFromText;
2670 :
2671 :
2672 :
2673 0 : fromTextMethods["execBlockId"] = &TotalPowerRow::execBlockIdFromText;
2674 :
2675 :
2676 :
2677 :
2678 :
2679 0 : fromTextMethods["subintegrationNumber"] = &TotalPowerRow::subintegrationNumberFromText;
2680 :
2681 :
2682 0 : }
2683 :
2684 0 : TotalPowerRow::TotalPowerRow (TotalPowerTable &t, TotalPowerRow *row) : table(t) {
2685 0 : hasBeenAdded = false;
2686 :
2687 0 : if (row == 0) {
2688 :
2689 :
2690 :
2691 :
2692 :
2693 :
2694 :
2695 :
2696 :
2697 :
2698 :
2699 :
2700 :
2701 :
2702 :
2703 :
2704 :
2705 :
2706 :
2707 :
2708 :
2709 :
2710 :
2711 :
2712 :
2713 0 : subintegrationNumberExists = false;
2714 :
2715 :
2716 :
2717 :
2718 :
2719 :
2720 :
2721 :
2722 :
2723 :
2724 :
2725 : }
2726 : else {
2727 :
2728 :
2729 0 : time = row->time;
2730 :
2731 0 : configDescriptionId = row->configDescriptionId;
2732 :
2733 0 : fieldId = row->fieldId;
2734 :
2735 :
2736 :
2737 :
2738 0 : scanNumber = row->scanNumber;
2739 :
2740 0 : subscanNumber = row->subscanNumber;
2741 :
2742 0 : integrationNumber = row->integrationNumber;
2743 :
2744 0 : uvw = row->uvw;
2745 :
2746 0 : exposure = row->exposure;
2747 :
2748 0 : timeCentroid = row->timeCentroid;
2749 :
2750 0 : floatData = row->floatData;
2751 :
2752 0 : flagAnt = row->flagAnt;
2753 :
2754 0 : flagPol = row->flagPol;
2755 :
2756 0 : interval = row->interval;
2757 :
2758 0 : stateId = row->stateId;
2759 :
2760 0 : execBlockId = row->execBlockId;
2761 :
2762 :
2763 :
2764 :
2765 0 : if (row->subintegrationNumberExists) {
2766 0 : subintegrationNumber = row->subintegrationNumber;
2767 0 : subintegrationNumberExists = true;
2768 : }
2769 : else
2770 0 : subintegrationNumberExists = false;
2771 :
2772 : }
2773 :
2774 0 : fromBinMethods["time"] = &TotalPowerRow::timeFromBin;
2775 0 : fromBinMethods["configDescriptionId"] = &TotalPowerRow::configDescriptionIdFromBin;
2776 0 : fromBinMethods["fieldId"] = &TotalPowerRow::fieldIdFromBin;
2777 0 : fromBinMethods["scanNumber"] = &TotalPowerRow::scanNumberFromBin;
2778 0 : fromBinMethods["subscanNumber"] = &TotalPowerRow::subscanNumberFromBin;
2779 0 : fromBinMethods["integrationNumber"] = &TotalPowerRow::integrationNumberFromBin;
2780 0 : fromBinMethods["uvw"] = &TotalPowerRow::uvwFromBin;
2781 0 : fromBinMethods["exposure"] = &TotalPowerRow::exposureFromBin;
2782 0 : fromBinMethods["timeCentroid"] = &TotalPowerRow::timeCentroidFromBin;
2783 0 : fromBinMethods["floatData"] = &TotalPowerRow::floatDataFromBin;
2784 0 : fromBinMethods["flagAnt"] = &TotalPowerRow::flagAntFromBin;
2785 0 : fromBinMethods["flagPol"] = &TotalPowerRow::flagPolFromBin;
2786 0 : fromBinMethods["interval"] = &TotalPowerRow::intervalFromBin;
2787 0 : fromBinMethods["stateId"] = &TotalPowerRow::stateIdFromBin;
2788 0 : fromBinMethods["execBlockId"] = &TotalPowerRow::execBlockIdFromBin;
2789 :
2790 :
2791 0 : fromBinMethods["subintegrationNumber"] = &TotalPowerRow::subintegrationNumberFromBin;
2792 :
2793 0 : }
2794 :
2795 :
2796 0 : bool TotalPowerRow::compareNoAutoInc(ArrayTime time, Tag configDescriptionId, Tag fieldId, int scanNumber, int subscanNumber, int integrationNumber, std::vector<std::vector<Length > > uvw, std::vector<std::vector<Interval > > exposure, std::vector<std::vector<ArrayTime > > timeCentroid, std::vector<std::vector<std::vector<float > > > floatData, std::vector<int > flagAnt, std::vector<std::vector<int > > flagPol, Interval interval, std::vector<Tag> stateId, Tag execBlockId) {
2797 : bool result;
2798 0 : result = true;
2799 :
2800 :
2801 :
2802 0 : result = result && (this->time == time);
2803 :
2804 0 : if (!result) return false;
2805 :
2806 :
2807 :
2808 :
2809 0 : result = result && (this->configDescriptionId == configDescriptionId);
2810 :
2811 0 : if (!result) return false;
2812 :
2813 :
2814 :
2815 :
2816 0 : result = result && (this->fieldId == fieldId);
2817 :
2818 0 : if (!result) return false;
2819 :
2820 :
2821 :
2822 :
2823 0 : result = result && (this->scanNumber == scanNumber);
2824 :
2825 0 : if (!result) return false;
2826 :
2827 :
2828 :
2829 :
2830 0 : result = result && (this->subscanNumber == subscanNumber);
2831 :
2832 0 : if (!result) return false;
2833 :
2834 :
2835 :
2836 :
2837 0 : result = result && (this->integrationNumber == integrationNumber);
2838 :
2839 0 : if (!result) return false;
2840 :
2841 :
2842 :
2843 :
2844 0 : result = result && (this->uvw == uvw);
2845 :
2846 0 : if (!result) return false;
2847 :
2848 :
2849 :
2850 :
2851 0 : result = result && (this->exposure == exposure);
2852 :
2853 0 : if (!result) return false;
2854 :
2855 :
2856 :
2857 :
2858 0 : result = result && (this->timeCentroid == timeCentroid);
2859 :
2860 0 : if (!result) return false;
2861 :
2862 :
2863 :
2864 :
2865 0 : result = result && (this->floatData == floatData);
2866 :
2867 0 : if (!result) return false;
2868 :
2869 :
2870 :
2871 :
2872 0 : result = result && (this->flagAnt == flagAnt);
2873 :
2874 0 : if (!result) return false;
2875 :
2876 :
2877 :
2878 :
2879 0 : result = result && (this->flagPol == flagPol);
2880 :
2881 0 : if (!result) return false;
2882 :
2883 :
2884 :
2885 :
2886 0 : result = result && (this->interval == interval);
2887 :
2888 0 : if (!result) return false;
2889 :
2890 :
2891 :
2892 :
2893 0 : result = result && (this->stateId == stateId);
2894 :
2895 0 : if (!result) return false;
2896 :
2897 :
2898 :
2899 :
2900 0 : result = result && (this->execBlockId == execBlockId);
2901 :
2902 0 : if (!result) return false;
2903 :
2904 :
2905 0 : return result;
2906 : }
2907 :
2908 :
2909 :
2910 0 : bool TotalPowerRow::compareRequiredValue(int scanNumber, int subscanNumber, int integrationNumber, std::vector<std::vector<Length > > uvw, std::vector<std::vector<Interval > > exposure, std::vector<std::vector<ArrayTime > > timeCentroid, std::vector<std::vector<std::vector<float > > > floatData, std::vector<int > flagAnt, std::vector<std::vector<int > > flagPol, Interval interval, std::vector<Tag> stateId, Tag execBlockId) {
2911 : bool result;
2912 0 : result = true;
2913 :
2914 :
2915 0 : if (!(this->scanNumber == scanNumber)) return false;
2916 :
2917 :
2918 :
2919 0 : if (!(this->subscanNumber == subscanNumber)) return false;
2920 :
2921 :
2922 :
2923 0 : if (!(this->integrationNumber == integrationNumber)) return false;
2924 :
2925 :
2926 :
2927 0 : if (!(this->uvw == uvw)) return false;
2928 :
2929 :
2930 :
2931 0 : if (!(this->exposure == exposure)) return false;
2932 :
2933 :
2934 :
2935 0 : if (!(this->timeCentroid == timeCentroid)) return false;
2936 :
2937 :
2938 :
2939 0 : if (!(this->floatData == floatData)) return false;
2940 :
2941 :
2942 :
2943 0 : if (!(this->flagAnt == flagAnt)) return false;
2944 :
2945 :
2946 :
2947 0 : if (!(this->flagPol == flagPol)) return false;
2948 :
2949 :
2950 :
2951 0 : if (!(this->interval == interval)) return false;
2952 :
2953 :
2954 :
2955 0 : if (!(this->stateId == stateId)) return false;
2956 :
2957 :
2958 :
2959 0 : if (!(this->execBlockId == execBlockId)) return false;
2960 :
2961 :
2962 0 : return result;
2963 : }
2964 :
2965 :
2966 : /**
2967 : * Return true if all required attributes of the value part are equal to their homologues
2968 : * in x and false otherwise.
2969 : *
2970 :
2971 : * @param x a pointer on the TotalPowerRow whose required attributes of the value part
2972 :
2973 : * will be compared with those of this.
2974 : * @return a boolean.
2975 : */
2976 0 : bool TotalPowerRow::equalByRequiredValue(TotalPowerRow* x ) {
2977 :
2978 :
2979 0 : if (this->scanNumber != x->scanNumber) return false;
2980 :
2981 0 : if (this->subscanNumber != x->subscanNumber) return false;
2982 :
2983 0 : if (this->integrationNumber != x->integrationNumber) return false;
2984 :
2985 0 : if (this->uvw != x->uvw) return false;
2986 :
2987 0 : if (this->exposure != x->exposure) return false;
2988 :
2989 0 : if (this->timeCentroid != x->timeCentroid) return false;
2990 :
2991 0 : if (this->floatData != x->floatData) return false;
2992 :
2993 0 : if (this->flagAnt != x->flagAnt) return false;
2994 :
2995 0 : if (this->flagPol != x->flagPol) return false;
2996 :
2997 0 : if (this->interval != x->interval) return false;
2998 :
2999 0 : if (this->stateId != x->stateId) return false;
3000 :
3001 0 : if (this->execBlockId != x->execBlockId) return false;
3002 :
3003 :
3004 0 : return true;
3005 : }
3006 :
3007 : /*
3008 : map<string, TotalPowerAttributeFromBin> TotalPowerRow::initFromBinMethods() {
3009 : map<string, TotalPowerAttributeFromBin> result;
3010 :
3011 : result["time"] = &TotalPowerRow::timeFromBin;
3012 : result["configDescriptionId"] = &TotalPowerRow::configDescriptionIdFromBin;
3013 : result["fieldId"] = &TotalPowerRow::fieldIdFromBin;
3014 : result["scanNumber"] = &TotalPowerRow::scanNumberFromBin;
3015 : result["subscanNumber"] = &TotalPowerRow::subscanNumberFromBin;
3016 : result["integrationNumber"] = &TotalPowerRow::integrationNumberFromBin;
3017 : result["uvw"] = &TotalPowerRow::uvwFromBin;
3018 : result["exposure"] = &TotalPowerRow::exposureFromBin;
3019 : result["timeCentroid"] = &TotalPowerRow::timeCentroidFromBin;
3020 : result["floatData"] = &TotalPowerRow::floatDataFromBin;
3021 : result["flagAnt"] = &TotalPowerRow::flagAntFromBin;
3022 : result["flagPol"] = &TotalPowerRow::flagPolFromBin;
3023 : result["interval"] = &TotalPowerRow::intervalFromBin;
3024 : result["stateId"] = &TotalPowerRow::stateIdFromBin;
3025 : result["execBlockId"] = &TotalPowerRow::execBlockIdFromBin;
3026 :
3027 :
3028 : result["subintegrationNumber"] = &TotalPowerRow::subintegrationNumberFromBin;
3029 :
3030 :
3031 : return result;
3032 : }
3033 : */
3034 : } // End namespace asdm
3035 :
|
