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