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