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