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