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 ExecBlockRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/ExecBlockRow.h>
39 : #include <alma/ASDM/ExecBlockTable.h>
40 :
41 : #include <alma/ASDM/AntennaTable.h>
42 : #include <alma/ASDM/AntennaRow.h>
43 :
44 : #include <alma/ASDM/SBSummaryTable.h>
45 : #include <alma/ASDM/SBSummaryRow.h>
46 :
47 : #include <alma/ASDM/ScaleTable.h>
48 : #include <alma/ASDM/ScaleRow.h>
49 :
50 :
51 : using asdm::ASDM;
52 : using asdm::ExecBlockRow;
53 : using asdm::ExecBlockTable;
54 :
55 : using asdm::AntennaTable;
56 : using asdm::AntennaRow;
57 :
58 : using asdm::SBSummaryTable;
59 : using asdm::SBSummaryRow;
60 :
61 : using asdm::ScaleTable;
62 : using asdm::ScaleRow;
63 :
64 :
65 : #include <alma/ASDM/Parser.h>
66 :
67 : #include <alma/ASDM/EnumerationParser.h>
68 : #include <alma/ASDM/ASDMValuesParser.h>
69 :
70 : #include <alma/ASDM/InvalidArgumentException.h>
71 :
72 : using namespace std;
73 :
74 : namespace asdm {
75 986 : ExecBlockRow::~ExecBlockRow() {
76 986 : }
77 :
78 : /**
79 : * Return the table to which this row belongs.
80 : */
81 386 : ExecBlockTable &ExecBlockRow::getTable() const {
82 386 : return table;
83 : }
84 :
85 0 : bool ExecBlockRow::isAdded() const {
86 0 : return hasBeenAdded;
87 : }
88 :
89 493 : void ExecBlockRow::isAdded(bool added) {
90 493 : hasBeenAdded = added;
91 493 : }
92 :
93 : #ifndef WITHOUT_ACS
94 : using asdmIDL::ExecBlockRowIDL;
95 : #endif
96 :
97 : #ifndef WITHOUT_ACS
98 : /**
99 : * Return this row in the form of an IDL struct.
100 : * @return The values of this row as a ExecBlockRowIDL struct.
101 : */
102 : ExecBlockRowIDL *ExecBlockRow::toIDL() const {
103 : ExecBlockRowIDL *x = new ExecBlockRowIDL ();
104 :
105 : // Fill the IDL structure.
106 :
107 :
108 :
109 :
110 :
111 :
112 :
113 : x->execBlockId = execBlockId.toIDLTag();
114 :
115 :
116 :
117 :
118 :
119 :
120 :
121 :
122 :
123 : x->startTime = startTime.toIDLArrayTime();
124 :
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 : x->endTime = endTime.toIDLArrayTime();
134 :
135 :
136 :
137 :
138 :
139 :
140 :
141 :
142 :
143 :
144 : x->execBlockNum = execBlockNum;
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 :
153 :
154 :
155 : x->execBlockUID = execBlockUID.toIDLEntityRef();
156 :
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 :
165 : x->projectUID = projectUID.toIDLEntityRef();
166 :
167 :
168 :
169 :
170 :
171 :
172 :
173 :
174 :
175 :
176 : x->configName = CORBA::string_dup(configName.c_str());
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 :
185 :
186 :
187 :
188 : x->telescopeName = CORBA::string_dup(telescopeName.c_str());
189 :
190 :
191 :
192 :
193 :
194 :
195 :
196 :
197 :
198 :
199 :
200 : x->observerName = CORBA::string_dup(observerName.c_str());
201 :
202 :
203 :
204 :
205 :
206 :
207 :
208 :
209 :
210 :
211 :
212 : x->numObservingLog = numObservingLog;
213 :
214 :
215 :
216 :
217 :
218 :
219 :
220 :
221 :
222 :
223 : x->observingLog.length(observingLog.size());
224 : for (unsigned int i = 0; i < observingLog.size(); ++i) {
225 :
226 :
227 : x->observingLog[i] = CORBA::string_dup(observingLog.at(i).c_str());
228 :
229 :
230 : }
231 :
232 :
233 :
234 :
235 :
236 :
237 :
238 :
239 :
240 : x->sessionReference = sessionReference.toIDLEntityRef();
241 :
242 :
243 :
244 :
245 :
246 :
247 :
248 :
249 :
250 : x->baseRangeMin = baseRangeMin.toIDLLength();
251 :
252 :
253 :
254 :
255 :
256 :
257 :
258 :
259 :
260 : x->baseRangeMax = baseRangeMax.toIDLLength();
261 :
262 :
263 :
264 :
265 :
266 :
267 :
268 :
269 :
270 : x->baseRmsMinor = baseRmsMinor.toIDLLength();
271 :
272 :
273 :
274 :
275 :
276 :
277 :
278 :
279 :
280 : x->baseRmsMajor = baseRmsMajor.toIDLLength();
281 :
282 :
283 :
284 :
285 :
286 :
287 :
288 :
289 :
290 : x->basePa = basePa.toIDLAngle();
291 :
292 :
293 :
294 :
295 :
296 :
297 :
298 :
299 :
300 :
301 : x->aborted = aborted;
302 :
303 :
304 :
305 :
306 :
307 :
308 :
309 :
310 :
311 :
312 :
313 : x->numAntenna = numAntenna;
314 :
315 :
316 :
317 :
318 :
319 :
320 :
321 :
322 : x->releaseDateExists = releaseDateExists;
323 :
324 :
325 :
326 : x->releaseDate = releaseDate.toIDLArrayTime();
327 :
328 :
329 :
330 :
331 :
332 :
333 :
334 : x->schedulerModeExists = schedulerModeExists;
335 :
336 :
337 :
338 :
339 : x->schedulerMode = CORBA::string_dup(schedulerMode.c_str());
340 :
341 :
342 :
343 :
344 :
345 :
346 :
347 :
348 : x->siteAltitudeExists = siteAltitudeExists;
349 :
350 :
351 :
352 : x->siteAltitude = siteAltitude.toIDLLength();
353 :
354 :
355 :
356 :
357 :
358 :
359 :
360 : x->siteLongitudeExists = siteLongitudeExists;
361 :
362 :
363 :
364 : x->siteLongitude = siteLongitude.toIDLAngle();
365 :
366 :
367 :
368 :
369 :
370 :
371 :
372 : x->siteLatitudeExists = siteLatitudeExists;
373 :
374 :
375 :
376 : x->siteLatitude = siteLatitude.toIDLAngle();
377 :
378 :
379 :
380 :
381 :
382 :
383 :
384 : x->observingScriptExists = observingScriptExists;
385 :
386 :
387 :
388 :
389 : x->observingScript = CORBA::string_dup(observingScript.c_str());
390 :
391 :
392 :
393 :
394 :
395 :
396 :
397 :
398 : x->observingScriptUIDExists = observingScriptUIDExists;
399 :
400 :
401 :
402 : x->observingScriptUID = observingScriptUID.toIDLEntityRef();
403 :
404 :
405 :
406 :
407 :
408 :
409 :
410 :
411 :
412 :
413 :
414 :
415 : x->antennaId.length(antennaId.size());
416 : for (unsigned int i = 0; i < antennaId.size(); ++i) {
417 :
418 : x->antennaId[i] = antennaId.at(i).toIDLTag();
419 :
420 : }
421 :
422 :
423 :
424 :
425 :
426 :
427 :
428 :
429 :
430 : x->sBSummaryId = sBSummaryId.toIDLTag();
431 :
432 :
433 :
434 :
435 :
436 :
437 :
438 :
439 : x->scaleIdExists = scaleIdExists;
440 :
441 :
442 :
443 :
444 : x->scaleId = scaleId.toIDLTag();
445 :
446 :
447 :
448 :
449 :
450 :
451 :
452 :
453 :
454 :
455 :
456 :
457 :
458 : return x;
459 :
460 : }
461 :
462 : void ExecBlockRow::toIDL(asdmIDL::ExecBlockRowIDL& x) const {
463 : // Set the x's fields.
464 :
465 :
466 :
467 :
468 :
469 :
470 :
471 : x.execBlockId = execBlockId.toIDLTag();
472 :
473 :
474 :
475 :
476 :
477 :
478 :
479 :
480 :
481 : x.startTime = startTime.toIDLArrayTime();
482 :
483 :
484 :
485 :
486 :
487 :
488 :
489 :
490 :
491 : x.endTime = endTime.toIDLArrayTime();
492 :
493 :
494 :
495 :
496 :
497 :
498 :
499 :
500 :
501 :
502 : x.execBlockNum = execBlockNum;
503 :
504 :
505 :
506 :
507 :
508 :
509 :
510 :
511 :
512 :
513 : x.execBlockUID = execBlockUID.toIDLEntityRef();
514 :
515 :
516 :
517 :
518 :
519 :
520 :
521 :
522 :
523 : x.projectUID = projectUID.toIDLEntityRef();
524 :
525 :
526 :
527 :
528 :
529 :
530 :
531 :
532 :
533 :
534 : x.configName = CORBA::string_dup(configName.c_str());
535 :
536 :
537 :
538 :
539 :
540 :
541 :
542 :
543 :
544 :
545 :
546 : x.telescopeName = CORBA::string_dup(telescopeName.c_str());
547 :
548 :
549 :
550 :
551 :
552 :
553 :
554 :
555 :
556 :
557 :
558 : x.observerName = CORBA::string_dup(observerName.c_str());
559 :
560 :
561 :
562 :
563 :
564 :
565 :
566 :
567 :
568 :
569 :
570 : x.numObservingLog = numObservingLog;
571 :
572 :
573 :
574 :
575 :
576 :
577 :
578 :
579 :
580 :
581 : x.observingLog.length(observingLog.size());
582 : for (unsigned int i = 0; i < observingLog.size(); ++i) {
583 :
584 :
585 : x.observingLog[i] = CORBA::string_dup(observingLog.at(i).c_str());
586 :
587 :
588 : }
589 :
590 :
591 :
592 :
593 :
594 :
595 :
596 :
597 :
598 : x.sessionReference = sessionReference.toIDLEntityRef();
599 :
600 :
601 :
602 :
603 :
604 :
605 :
606 :
607 :
608 : x.baseRangeMin = baseRangeMin.toIDLLength();
609 :
610 :
611 :
612 :
613 :
614 :
615 :
616 :
617 :
618 : x.baseRangeMax = baseRangeMax.toIDLLength();
619 :
620 :
621 :
622 :
623 :
624 :
625 :
626 :
627 :
628 : x.baseRmsMinor = baseRmsMinor.toIDLLength();
629 :
630 :
631 :
632 :
633 :
634 :
635 :
636 :
637 :
638 : x.baseRmsMajor = baseRmsMajor.toIDLLength();
639 :
640 :
641 :
642 :
643 :
644 :
645 :
646 :
647 :
648 : x.basePa = basePa.toIDLAngle();
649 :
650 :
651 :
652 :
653 :
654 :
655 :
656 :
657 :
658 :
659 : x.aborted = aborted;
660 :
661 :
662 :
663 :
664 :
665 :
666 :
667 :
668 :
669 :
670 :
671 : x.numAntenna = numAntenna;
672 :
673 :
674 :
675 :
676 :
677 :
678 :
679 :
680 : x.releaseDateExists = releaseDateExists;
681 :
682 :
683 :
684 : x.releaseDate = releaseDate.toIDLArrayTime();
685 :
686 :
687 :
688 :
689 :
690 :
691 :
692 : x.schedulerModeExists = schedulerModeExists;
693 :
694 :
695 :
696 :
697 : x.schedulerMode = CORBA::string_dup(schedulerMode.c_str());
698 :
699 :
700 :
701 :
702 :
703 :
704 :
705 :
706 : x.siteAltitudeExists = siteAltitudeExists;
707 :
708 :
709 :
710 : x.siteAltitude = siteAltitude.toIDLLength();
711 :
712 :
713 :
714 :
715 :
716 :
717 :
718 : x.siteLongitudeExists = siteLongitudeExists;
719 :
720 :
721 :
722 : x.siteLongitude = siteLongitude.toIDLAngle();
723 :
724 :
725 :
726 :
727 :
728 :
729 :
730 : x.siteLatitudeExists = siteLatitudeExists;
731 :
732 :
733 :
734 : x.siteLatitude = siteLatitude.toIDLAngle();
735 :
736 :
737 :
738 :
739 :
740 :
741 :
742 : x.observingScriptExists = observingScriptExists;
743 :
744 :
745 :
746 :
747 : x.observingScript = CORBA::string_dup(observingScript.c_str());
748 :
749 :
750 :
751 :
752 :
753 :
754 :
755 :
756 : x.observingScriptUIDExists = observingScriptUIDExists;
757 :
758 :
759 :
760 : x.observingScriptUID = observingScriptUID.toIDLEntityRef();
761 :
762 :
763 :
764 :
765 :
766 :
767 :
768 :
769 :
770 :
771 :
772 :
773 : x.antennaId.length(antennaId.size());
774 : for (unsigned int i = 0; i < antennaId.size(); ++i) {
775 :
776 : x.antennaId[i] = antennaId.at(i).toIDLTag();
777 :
778 : }
779 :
780 :
781 :
782 :
783 :
784 :
785 :
786 :
787 :
788 : x.sBSummaryId = sBSummaryId.toIDLTag();
789 :
790 :
791 :
792 :
793 :
794 :
795 :
796 :
797 : x.scaleIdExists = scaleIdExists;
798 :
799 :
800 :
801 :
802 : x.scaleId = scaleId.toIDLTag();
803 :
804 :
805 :
806 :
807 :
808 :
809 :
810 :
811 :
812 :
813 :
814 :
815 :
816 : }
817 : #endif
818 :
819 :
820 : #ifndef WITHOUT_ACS
821 : /**
822 : * Fill the values of this row from the IDL struct ExecBlockRowIDL.
823 : * @param x The IDL struct containing the values used to fill this row.
824 : */
825 : void ExecBlockRow::setFromIDL (ExecBlockRowIDL x){
826 : try {
827 : // Fill the values from x.
828 :
829 :
830 :
831 :
832 :
833 :
834 : setExecBlockId(Tag (x.execBlockId));
835 :
836 :
837 :
838 :
839 :
840 :
841 :
842 :
843 :
844 : setStartTime(ArrayTime (x.startTime));
845 :
846 :
847 :
848 :
849 :
850 :
851 :
852 :
853 :
854 : setEndTime(ArrayTime (x.endTime));
855 :
856 :
857 :
858 :
859 :
860 :
861 :
862 :
863 :
864 : setExecBlockNum(x.execBlockNum);
865 :
866 :
867 :
868 :
869 :
870 :
871 :
872 :
873 :
874 : setExecBlockUID(EntityRef (x.execBlockUID));
875 :
876 :
877 :
878 :
879 :
880 :
881 :
882 :
883 :
884 : setProjectUID(EntityRef (x.projectUID));
885 :
886 :
887 :
888 :
889 :
890 :
891 :
892 :
893 :
894 : setConfigName(string (x.configName));
895 :
896 :
897 :
898 :
899 :
900 :
901 :
902 :
903 :
904 : setTelescopeName(string (x.telescopeName));
905 :
906 :
907 :
908 :
909 :
910 :
911 :
912 :
913 :
914 : setObserverName(string (x.observerName));
915 :
916 :
917 :
918 :
919 :
920 :
921 :
922 :
923 :
924 : setNumObservingLog(x.numObservingLog);
925 :
926 :
927 :
928 :
929 :
930 :
931 :
932 :
933 :
934 : observingLog .clear();
935 : for (unsigned int i = 0; i <x.observingLog.length(); ++i) {
936 :
937 : observingLog.push_back(string (x.observingLog[i]));
938 :
939 : }
940 :
941 :
942 :
943 :
944 :
945 :
946 :
947 :
948 :
949 : setSessionReference(EntityRef (x.sessionReference));
950 :
951 :
952 :
953 :
954 :
955 :
956 :
957 :
958 :
959 : setBaseRangeMin(Length (x.baseRangeMin));
960 :
961 :
962 :
963 :
964 :
965 :
966 :
967 :
968 :
969 : setBaseRangeMax(Length (x.baseRangeMax));
970 :
971 :
972 :
973 :
974 :
975 :
976 :
977 :
978 :
979 : setBaseRmsMinor(Length (x.baseRmsMinor));
980 :
981 :
982 :
983 :
984 :
985 :
986 :
987 :
988 :
989 : setBaseRmsMajor(Length (x.baseRmsMajor));
990 :
991 :
992 :
993 :
994 :
995 :
996 :
997 :
998 :
999 : setBasePa(Angle (x.basePa));
1000 :
1001 :
1002 :
1003 :
1004 :
1005 :
1006 :
1007 :
1008 :
1009 : setAborted(x.aborted);
1010 :
1011 :
1012 :
1013 :
1014 :
1015 :
1016 :
1017 :
1018 :
1019 : setNumAntenna(x.numAntenna);
1020 :
1021 :
1022 :
1023 :
1024 :
1025 :
1026 :
1027 : releaseDateExists = x.releaseDateExists;
1028 : if (x.releaseDateExists) {
1029 :
1030 :
1031 :
1032 : setReleaseDate(ArrayTime (x.releaseDate));
1033 :
1034 :
1035 :
1036 : }
1037 :
1038 :
1039 :
1040 :
1041 :
1042 : schedulerModeExists = x.schedulerModeExists;
1043 : if (x.schedulerModeExists) {
1044 :
1045 :
1046 :
1047 : setSchedulerMode(string (x.schedulerMode));
1048 :
1049 :
1050 :
1051 : }
1052 :
1053 :
1054 :
1055 :
1056 :
1057 : siteAltitudeExists = x.siteAltitudeExists;
1058 : if (x.siteAltitudeExists) {
1059 :
1060 :
1061 :
1062 : setSiteAltitude(Length (x.siteAltitude));
1063 :
1064 :
1065 :
1066 : }
1067 :
1068 :
1069 :
1070 :
1071 :
1072 : siteLongitudeExists = x.siteLongitudeExists;
1073 : if (x.siteLongitudeExists) {
1074 :
1075 :
1076 :
1077 : setSiteLongitude(Angle (x.siteLongitude));
1078 :
1079 :
1080 :
1081 : }
1082 :
1083 :
1084 :
1085 :
1086 :
1087 : siteLatitudeExists = x.siteLatitudeExists;
1088 : if (x.siteLatitudeExists) {
1089 :
1090 :
1091 :
1092 : setSiteLatitude(Angle (x.siteLatitude));
1093 :
1094 :
1095 :
1096 : }
1097 :
1098 :
1099 :
1100 :
1101 :
1102 : observingScriptExists = x.observingScriptExists;
1103 : if (x.observingScriptExists) {
1104 :
1105 :
1106 :
1107 : setObservingScript(string (x.observingScript));
1108 :
1109 :
1110 :
1111 : }
1112 :
1113 :
1114 :
1115 :
1116 :
1117 : observingScriptUIDExists = x.observingScriptUIDExists;
1118 : if (x.observingScriptUIDExists) {
1119 :
1120 :
1121 :
1122 : setObservingScriptUID(EntityRef (x.observingScriptUID));
1123 :
1124 :
1125 :
1126 : }
1127 :
1128 :
1129 :
1130 :
1131 :
1132 :
1133 :
1134 :
1135 : antennaId .clear();
1136 : for (unsigned int i = 0; i <x.antennaId.length(); ++i) {
1137 :
1138 : antennaId.push_back(Tag (x.antennaId[i]));
1139 :
1140 : }
1141 :
1142 :
1143 :
1144 :
1145 :
1146 :
1147 :
1148 : setSBSummaryId(Tag (x.sBSummaryId));
1149 :
1150 :
1151 :
1152 :
1153 :
1154 :
1155 :
1156 : scaleIdExists = x.scaleIdExists;
1157 : if (x.scaleIdExists) {
1158 :
1159 :
1160 :
1161 : setScaleId(Tag (x.scaleId));
1162 :
1163 :
1164 :
1165 : }
1166 :
1167 :
1168 :
1169 :
1170 :
1171 :
1172 :
1173 :
1174 :
1175 :
1176 :
1177 : } catch (const IllegalAccessException &err) {
1178 : throw ConversionException (err.getMessage(),"ExecBlock");
1179 : }
1180 : }
1181 : #endif
1182 :
1183 : /**
1184 : * Return this row in the form of an XML string.
1185 : * @return The values of this row as an XML string.
1186 : */
1187 334 : string ExecBlockRow::toXML() const {
1188 334 : string buf;
1189 334 : buf.append("<row> \n");
1190 :
1191 :
1192 :
1193 :
1194 :
1195 :
1196 334 : Parser::toXML(execBlockId, "execBlockId", buf);
1197 :
1198 :
1199 :
1200 :
1201 :
1202 :
1203 :
1204 334 : Parser::toXML(startTime, "startTime", buf);
1205 :
1206 :
1207 :
1208 :
1209 :
1210 :
1211 :
1212 334 : Parser::toXML(endTime, "endTime", buf);
1213 :
1214 :
1215 :
1216 :
1217 :
1218 :
1219 :
1220 334 : Parser::toXML(execBlockNum, "execBlockNum", buf);
1221 :
1222 :
1223 :
1224 :
1225 :
1226 :
1227 :
1228 334 : Parser::toXML(execBlockUID, "execBlockUID", buf);
1229 :
1230 :
1231 :
1232 :
1233 :
1234 :
1235 :
1236 334 : Parser::toXML(projectUID, "projectUID", buf);
1237 :
1238 :
1239 :
1240 :
1241 :
1242 :
1243 :
1244 334 : Parser::toXML(configName, "configName", buf);
1245 :
1246 :
1247 :
1248 :
1249 :
1250 :
1251 :
1252 334 : Parser::toXML(telescopeName, "telescopeName", buf);
1253 :
1254 :
1255 :
1256 :
1257 :
1258 :
1259 :
1260 334 : Parser::toXML(observerName, "observerName", buf);
1261 :
1262 :
1263 :
1264 :
1265 :
1266 :
1267 :
1268 334 : Parser::toXML(numObservingLog, "numObservingLog", buf);
1269 :
1270 :
1271 :
1272 :
1273 :
1274 :
1275 :
1276 334 : Parser::toXML(observingLog, "observingLog", buf);
1277 :
1278 :
1279 :
1280 :
1281 :
1282 :
1283 :
1284 334 : Parser::toXML(sessionReference, "sessionReference", buf);
1285 :
1286 :
1287 :
1288 :
1289 :
1290 :
1291 :
1292 334 : Parser::toXML(baseRangeMin, "baseRangeMin", buf);
1293 :
1294 :
1295 :
1296 :
1297 :
1298 :
1299 :
1300 334 : Parser::toXML(baseRangeMax, "baseRangeMax", buf);
1301 :
1302 :
1303 :
1304 :
1305 :
1306 :
1307 :
1308 334 : Parser::toXML(baseRmsMinor, "baseRmsMinor", buf);
1309 :
1310 :
1311 :
1312 :
1313 :
1314 :
1315 :
1316 334 : Parser::toXML(baseRmsMajor, "baseRmsMajor", buf);
1317 :
1318 :
1319 :
1320 :
1321 :
1322 :
1323 :
1324 334 : Parser::toXML(basePa, "basePa", buf);
1325 :
1326 :
1327 :
1328 :
1329 :
1330 :
1331 :
1332 334 : Parser::toXML(aborted, "aborted", buf);
1333 :
1334 :
1335 :
1336 :
1337 :
1338 :
1339 :
1340 334 : Parser::toXML(numAntenna, "numAntenna", buf);
1341 :
1342 :
1343 :
1344 :
1345 :
1346 :
1347 334 : if (releaseDateExists) {
1348 :
1349 :
1350 0 : Parser::toXML(releaseDate, "releaseDate", buf);
1351 :
1352 :
1353 : }
1354 :
1355 :
1356 :
1357 :
1358 :
1359 334 : if (schedulerModeExists) {
1360 :
1361 :
1362 0 : Parser::toXML(schedulerMode, "schedulerMode", buf);
1363 :
1364 :
1365 : }
1366 :
1367 :
1368 :
1369 :
1370 :
1371 334 : if (siteAltitudeExists) {
1372 :
1373 :
1374 0 : Parser::toXML(siteAltitude, "siteAltitude", buf);
1375 :
1376 :
1377 : }
1378 :
1379 :
1380 :
1381 :
1382 :
1383 334 : if (siteLongitudeExists) {
1384 :
1385 :
1386 0 : Parser::toXML(siteLongitude, "siteLongitude", buf);
1387 :
1388 :
1389 : }
1390 :
1391 :
1392 :
1393 :
1394 :
1395 334 : if (siteLatitudeExists) {
1396 :
1397 :
1398 0 : Parser::toXML(siteLatitude, "siteLatitude", buf);
1399 :
1400 :
1401 : }
1402 :
1403 :
1404 :
1405 :
1406 :
1407 334 : if (observingScriptExists) {
1408 :
1409 :
1410 0 : Parser::toXML(observingScript, "observingScript", buf);
1411 :
1412 :
1413 : }
1414 :
1415 :
1416 :
1417 :
1418 :
1419 334 : if (observingScriptUIDExists) {
1420 :
1421 :
1422 0 : Parser::toXML(observingScriptUID, "observingScriptUID", buf);
1423 :
1424 :
1425 : }
1426 :
1427 :
1428 :
1429 :
1430 :
1431 :
1432 :
1433 :
1434 :
1435 334 : Parser::toXML(antennaId, "antennaId", buf);
1436 :
1437 :
1438 :
1439 :
1440 :
1441 :
1442 :
1443 334 : Parser::toXML(sBSummaryId, "sBSummaryId", buf);
1444 :
1445 :
1446 :
1447 :
1448 :
1449 :
1450 334 : if (scaleIdExists) {
1451 :
1452 :
1453 0 : Parser::toXML(scaleId, "scaleId", buf);
1454 :
1455 :
1456 : }
1457 :
1458 :
1459 :
1460 :
1461 :
1462 :
1463 :
1464 :
1465 :
1466 :
1467 :
1468 :
1469 334 : buf.append("</row>\n");
1470 334 : return buf;
1471 0 : }
1472 :
1473 : /**
1474 : * Fill the values of this row from an XML string
1475 : * that was produced by the toXML() method.
1476 : * @param x The XML string being used to set the values of this row.
1477 : */
1478 159 : void ExecBlockRow::setFromXML (string rowDoc) {
1479 159 : Parser row(rowDoc);
1480 159 : string s = "";
1481 : try {
1482 :
1483 :
1484 :
1485 :
1486 :
1487 159 : setExecBlockId(Parser::getTag("execBlockId","ExecBlock",rowDoc));
1488 :
1489 :
1490 :
1491 :
1492 :
1493 :
1494 :
1495 159 : setStartTime(Parser::getArrayTime("startTime","ExecBlock",rowDoc));
1496 :
1497 :
1498 :
1499 :
1500 :
1501 :
1502 :
1503 159 : setEndTime(Parser::getArrayTime("endTime","ExecBlock",rowDoc));
1504 :
1505 :
1506 :
1507 :
1508 :
1509 :
1510 :
1511 159 : setExecBlockNum(Parser::getInteger("execBlockNum","ExecBlock",rowDoc));
1512 :
1513 :
1514 :
1515 :
1516 :
1517 :
1518 :
1519 159 : setExecBlockUID(Parser::getEntityRef("execBlockUID","ExecBlock",rowDoc));
1520 :
1521 :
1522 :
1523 :
1524 :
1525 :
1526 :
1527 159 : setProjectUID(Parser::getEntityRef("projectUID","ExecBlock",rowDoc));
1528 :
1529 :
1530 :
1531 :
1532 :
1533 :
1534 :
1535 159 : setConfigName(Parser::getString("configName","ExecBlock",rowDoc));
1536 :
1537 :
1538 :
1539 :
1540 :
1541 :
1542 :
1543 159 : setTelescopeName(Parser::getString("telescopeName","ExecBlock",rowDoc));
1544 :
1545 :
1546 :
1547 :
1548 :
1549 :
1550 :
1551 159 : setObserverName(Parser::getString("observerName","ExecBlock",rowDoc));
1552 :
1553 :
1554 :
1555 :
1556 :
1557 :
1558 :
1559 159 : setNumObservingLog(Parser::getInteger("numObservingLog","ExecBlock",rowDoc));
1560 :
1561 :
1562 :
1563 :
1564 :
1565 :
1566 :
1567 :
1568 159 : setObservingLog(Parser::get1DString("observingLog","ExecBlock",rowDoc));
1569 :
1570 :
1571 :
1572 :
1573 :
1574 :
1575 :
1576 :
1577 159 : setSessionReference(Parser::getEntityRef("sessionReference","ExecBlock",rowDoc));
1578 :
1579 :
1580 :
1581 :
1582 :
1583 :
1584 :
1585 159 : setBaseRangeMin(Parser::getLength("baseRangeMin","ExecBlock",rowDoc));
1586 :
1587 :
1588 :
1589 :
1590 :
1591 :
1592 :
1593 159 : setBaseRangeMax(Parser::getLength("baseRangeMax","ExecBlock",rowDoc));
1594 :
1595 :
1596 :
1597 :
1598 :
1599 :
1600 :
1601 159 : setBaseRmsMinor(Parser::getLength("baseRmsMinor","ExecBlock",rowDoc));
1602 :
1603 :
1604 :
1605 :
1606 :
1607 :
1608 :
1609 159 : setBaseRmsMajor(Parser::getLength("baseRmsMajor","ExecBlock",rowDoc));
1610 :
1611 :
1612 :
1613 :
1614 :
1615 :
1616 :
1617 159 : setBasePa(Parser::getAngle("basePa","ExecBlock",rowDoc));
1618 :
1619 :
1620 :
1621 :
1622 :
1623 :
1624 :
1625 159 : setAborted(Parser::getBoolean("aborted","ExecBlock",rowDoc));
1626 :
1627 :
1628 :
1629 :
1630 :
1631 :
1632 :
1633 159 : setNumAntenna(Parser::getInteger("numAntenna","ExecBlock",rowDoc));
1634 :
1635 :
1636 :
1637 :
1638 :
1639 :
1640 159 : if (row.isStr("<releaseDate>")) {
1641 :
1642 0 : setReleaseDate(Parser::getArrayTime("releaseDate","ExecBlock",rowDoc));
1643 :
1644 : }
1645 :
1646 :
1647 :
1648 :
1649 :
1650 159 : if (row.isStr("<schedulerMode>")) {
1651 :
1652 29 : setSchedulerMode(Parser::getString("schedulerMode","ExecBlock",rowDoc));
1653 :
1654 : }
1655 :
1656 :
1657 :
1658 :
1659 :
1660 159 : if (row.isStr("<siteAltitude>")) {
1661 :
1662 86 : setSiteAltitude(Parser::getLength("siteAltitude","ExecBlock",rowDoc));
1663 :
1664 : }
1665 :
1666 :
1667 :
1668 :
1669 :
1670 159 : if (row.isStr("<siteLongitude>")) {
1671 :
1672 86 : setSiteLongitude(Parser::getAngle("siteLongitude","ExecBlock",rowDoc));
1673 :
1674 : }
1675 :
1676 :
1677 :
1678 :
1679 :
1680 159 : if (row.isStr("<siteLatitude>")) {
1681 :
1682 86 : setSiteLatitude(Parser::getAngle("siteLatitude","ExecBlock",rowDoc));
1683 :
1684 : }
1685 :
1686 :
1687 :
1688 :
1689 :
1690 159 : if (row.isStr("<observingScript>")) {
1691 :
1692 57 : setObservingScript(Parser::getString("observingScript","ExecBlock",rowDoc));
1693 :
1694 : }
1695 :
1696 :
1697 :
1698 :
1699 :
1700 159 : if (row.isStr("<observingScriptUID>")) {
1701 :
1702 0 : setObservingScriptUID(Parser::getEntityRef("observingScriptUID","ExecBlock",rowDoc));
1703 :
1704 : }
1705 :
1706 :
1707 :
1708 :
1709 :
1710 :
1711 :
1712 :
1713 159 : setAntennaId(Parser::get1DTag("antennaId","ExecBlock",rowDoc));
1714 :
1715 :
1716 :
1717 :
1718 :
1719 :
1720 159 : setSBSummaryId(Parser::getTag("sBSummaryId","ExecBlock",rowDoc));
1721 :
1722 :
1723 :
1724 :
1725 :
1726 :
1727 159 : if (row.isStr("<scaleId>")) {
1728 :
1729 0 : setScaleId(Parser::getTag("scaleId","ExecBlock",rowDoc));
1730 :
1731 : }
1732 :
1733 :
1734 :
1735 :
1736 :
1737 :
1738 :
1739 :
1740 :
1741 :
1742 :
1743 0 : } catch (const IllegalAccessException &err) {
1744 0 : throw ConversionException (err.getMessage(),"ExecBlock");
1745 0 : }
1746 159 : }
1747 :
1748 0 : void ExecBlockRow::toBin(EndianOSStream& eoss) {
1749 :
1750 :
1751 :
1752 :
1753 :
1754 0 : execBlockId.toBin(eoss);
1755 :
1756 :
1757 :
1758 :
1759 :
1760 :
1761 0 : startTime.toBin(eoss);
1762 :
1763 :
1764 :
1765 :
1766 :
1767 :
1768 0 : endTime.toBin(eoss);
1769 :
1770 :
1771 :
1772 :
1773 :
1774 :
1775 :
1776 0 : eoss.writeInt(execBlockNum);
1777 :
1778 :
1779 :
1780 :
1781 :
1782 :
1783 :
1784 0 : execBlockUID.toBin(eoss);
1785 :
1786 :
1787 :
1788 :
1789 :
1790 :
1791 0 : projectUID.toBin(eoss);
1792 :
1793 :
1794 :
1795 :
1796 :
1797 :
1798 :
1799 0 : eoss.writeString(configName);
1800 :
1801 :
1802 :
1803 :
1804 :
1805 :
1806 :
1807 :
1808 0 : eoss.writeString(telescopeName);
1809 :
1810 :
1811 :
1812 :
1813 :
1814 :
1815 :
1816 :
1817 0 : eoss.writeString(observerName);
1818 :
1819 :
1820 :
1821 :
1822 :
1823 :
1824 :
1825 :
1826 0 : eoss.writeInt(numObservingLog);
1827 :
1828 :
1829 :
1830 :
1831 :
1832 :
1833 :
1834 :
1835 :
1836 0 : eoss.writeInt((int) observingLog.size());
1837 0 : for (unsigned int i = 0; i < observingLog.size(); i++)
1838 :
1839 0 : eoss.writeString(observingLog.at(i));
1840 :
1841 :
1842 :
1843 :
1844 :
1845 :
1846 :
1847 :
1848 :
1849 0 : sessionReference.toBin(eoss);
1850 :
1851 :
1852 :
1853 :
1854 :
1855 :
1856 0 : baseRangeMin.toBin(eoss);
1857 :
1858 :
1859 :
1860 :
1861 :
1862 :
1863 0 : baseRangeMax.toBin(eoss);
1864 :
1865 :
1866 :
1867 :
1868 :
1869 :
1870 0 : baseRmsMinor.toBin(eoss);
1871 :
1872 :
1873 :
1874 :
1875 :
1876 :
1877 0 : baseRmsMajor.toBin(eoss);
1878 :
1879 :
1880 :
1881 :
1882 :
1883 :
1884 0 : basePa.toBin(eoss);
1885 :
1886 :
1887 :
1888 :
1889 :
1890 :
1891 :
1892 0 : eoss.writeBoolean(aborted);
1893 :
1894 :
1895 :
1896 :
1897 :
1898 :
1899 :
1900 :
1901 0 : eoss.writeInt(numAntenna);
1902 :
1903 :
1904 :
1905 :
1906 :
1907 :
1908 :
1909 0 : Tag::toBin(antennaId, eoss);
1910 :
1911 :
1912 :
1913 :
1914 :
1915 :
1916 0 : sBSummaryId.toBin(eoss);
1917 :
1918 :
1919 :
1920 :
1921 :
1922 :
1923 0 : eoss.writeBoolean(releaseDateExists);
1924 0 : if (releaseDateExists) {
1925 :
1926 :
1927 :
1928 :
1929 0 : releaseDate.toBin(eoss);
1930 :
1931 :
1932 :
1933 : }
1934 :
1935 0 : eoss.writeBoolean(schedulerModeExists);
1936 0 : if (schedulerModeExists) {
1937 :
1938 :
1939 :
1940 :
1941 :
1942 0 : eoss.writeString(schedulerMode);
1943 :
1944 :
1945 :
1946 :
1947 : }
1948 :
1949 0 : eoss.writeBoolean(siteAltitudeExists);
1950 0 : if (siteAltitudeExists) {
1951 :
1952 :
1953 :
1954 :
1955 0 : siteAltitude.toBin(eoss);
1956 :
1957 :
1958 :
1959 : }
1960 :
1961 0 : eoss.writeBoolean(siteLongitudeExists);
1962 0 : if (siteLongitudeExists) {
1963 :
1964 :
1965 :
1966 :
1967 0 : siteLongitude.toBin(eoss);
1968 :
1969 :
1970 :
1971 : }
1972 :
1973 0 : eoss.writeBoolean(siteLatitudeExists);
1974 0 : if (siteLatitudeExists) {
1975 :
1976 :
1977 :
1978 :
1979 0 : siteLatitude.toBin(eoss);
1980 :
1981 :
1982 :
1983 : }
1984 :
1985 0 : eoss.writeBoolean(observingScriptExists);
1986 0 : if (observingScriptExists) {
1987 :
1988 :
1989 :
1990 :
1991 :
1992 0 : eoss.writeString(observingScript);
1993 :
1994 :
1995 :
1996 :
1997 : }
1998 :
1999 0 : eoss.writeBoolean(observingScriptUIDExists);
2000 0 : if (observingScriptUIDExists) {
2001 :
2002 :
2003 :
2004 :
2005 0 : observingScriptUID.toBin(eoss);
2006 :
2007 :
2008 :
2009 : }
2010 :
2011 0 : eoss.writeBoolean(scaleIdExists);
2012 0 : if (scaleIdExists) {
2013 :
2014 :
2015 :
2016 :
2017 0 : scaleId.toBin(eoss);
2018 :
2019 :
2020 :
2021 : }
2022 :
2023 0 : }
2024 :
2025 0 : void ExecBlockRow::execBlockIdFromBin(EndianIStream& eis) {
2026 :
2027 :
2028 :
2029 :
2030 0 : execBlockId = Tag::fromBin(eis);
2031 :
2032 :
2033 :
2034 0 : }
2035 0 : void ExecBlockRow::startTimeFromBin(EndianIStream& eis) {
2036 :
2037 :
2038 :
2039 :
2040 0 : startTime = ArrayTime::fromBin(eis);
2041 :
2042 :
2043 :
2044 0 : }
2045 0 : void ExecBlockRow::endTimeFromBin(EndianIStream& eis) {
2046 :
2047 :
2048 :
2049 :
2050 0 : endTime = ArrayTime::fromBin(eis);
2051 :
2052 :
2053 :
2054 0 : }
2055 0 : void ExecBlockRow::execBlockNumFromBin(EndianIStream& eis) {
2056 :
2057 :
2058 :
2059 :
2060 :
2061 0 : execBlockNum = eis.readInt();
2062 :
2063 :
2064 :
2065 :
2066 0 : }
2067 0 : void ExecBlockRow::execBlockUIDFromBin(EndianIStream& eis) {
2068 :
2069 :
2070 :
2071 :
2072 0 : execBlockUID = EntityRef::fromBin(eis);
2073 :
2074 :
2075 :
2076 0 : }
2077 0 : void ExecBlockRow::projectUIDFromBin(EndianIStream& eis) {
2078 :
2079 :
2080 :
2081 :
2082 0 : projectUID = EntityRef::fromBin(eis);
2083 :
2084 :
2085 :
2086 0 : }
2087 0 : void ExecBlockRow::configNameFromBin(EndianIStream& eis) {
2088 :
2089 :
2090 :
2091 :
2092 :
2093 0 : configName = eis.readString();
2094 :
2095 :
2096 :
2097 :
2098 0 : }
2099 0 : void ExecBlockRow::telescopeNameFromBin(EndianIStream& eis) {
2100 :
2101 :
2102 :
2103 :
2104 :
2105 0 : telescopeName = eis.readString();
2106 :
2107 :
2108 :
2109 :
2110 0 : }
2111 0 : void ExecBlockRow::observerNameFromBin(EndianIStream& eis) {
2112 :
2113 :
2114 :
2115 :
2116 :
2117 0 : observerName = eis.readString();
2118 :
2119 :
2120 :
2121 :
2122 0 : }
2123 0 : void ExecBlockRow::numObservingLogFromBin(EndianIStream& eis) {
2124 :
2125 :
2126 :
2127 :
2128 :
2129 0 : numObservingLog = eis.readInt();
2130 :
2131 :
2132 :
2133 :
2134 0 : }
2135 0 : void ExecBlockRow::observingLogFromBin(EndianIStream& eis) {
2136 :
2137 :
2138 :
2139 :
2140 :
2141 :
2142 0 : observingLog.clear();
2143 :
2144 0 : unsigned int observingLogDim1 = eis.readInt();
2145 0 : for (unsigned int i = 0 ; i < observingLogDim1; i++)
2146 :
2147 0 : observingLog.push_back(eis.readString());
2148 :
2149 :
2150 :
2151 :
2152 :
2153 :
2154 0 : }
2155 0 : void ExecBlockRow::sessionReferenceFromBin(EndianIStream& eis) {
2156 :
2157 :
2158 :
2159 :
2160 0 : sessionReference = EntityRef::fromBin(eis);
2161 :
2162 :
2163 :
2164 0 : }
2165 0 : void ExecBlockRow::baseRangeMinFromBin(EndianIStream& eis) {
2166 :
2167 :
2168 :
2169 :
2170 0 : baseRangeMin = Length::fromBin(eis);
2171 :
2172 :
2173 :
2174 0 : }
2175 0 : void ExecBlockRow::baseRangeMaxFromBin(EndianIStream& eis) {
2176 :
2177 :
2178 :
2179 :
2180 0 : baseRangeMax = Length::fromBin(eis);
2181 :
2182 :
2183 :
2184 0 : }
2185 0 : void ExecBlockRow::baseRmsMinorFromBin(EndianIStream& eis) {
2186 :
2187 :
2188 :
2189 :
2190 0 : baseRmsMinor = Length::fromBin(eis);
2191 :
2192 :
2193 :
2194 0 : }
2195 0 : void ExecBlockRow::baseRmsMajorFromBin(EndianIStream& eis) {
2196 :
2197 :
2198 :
2199 :
2200 0 : baseRmsMajor = Length::fromBin(eis);
2201 :
2202 :
2203 :
2204 0 : }
2205 0 : void ExecBlockRow::basePaFromBin(EndianIStream& eis) {
2206 :
2207 :
2208 :
2209 :
2210 0 : basePa = Angle::fromBin(eis);
2211 :
2212 :
2213 :
2214 0 : }
2215 0 : void ExecBlockRow::abortedFromBin(EndianIStream& eis) {
2216 :
2217 :
2218 :
2219 :
2220 :
2221 0 : aborted = eis.readBoolean();
2222 :
2223 :
2224 :
2225 :
2226 0 : }
2227 0 : void ExecBlockRow::numAntennaFromBin(EndianIStream& eis) {
2228 :
2229 :
2230 :
2231 :
2232 :
2233 0 : numAntenna = eis.readInt();
2234 :
2235 :
2236 :
2237 :
2238 0 : }
2239 0 : void ExecBlockRow::antennaIdFromBin(EndianIStream& eis) {
2240 :
2241 :
2242 :
2243 :
2244 :
2245 :
2246 0 : antennaId = Tag::from1DBin(eis);
2247 :
2248 :
2249 :
2250 :
2251 :
2252 0 : }
2253 0 : void ExecBlockRow::sBSummaryIdFromBin(EndianIStream& eis) {
2254 :
2255 :
2256 :
2257 :
2258 0 : sBSummaryId = Tag::fromBin(eis);
2259 :
2260 :
2261 :
2262 0 : }
2263 :
2264 0 : void ExecBlockRow::releaseDateFromBin(EndianIStream& eis) {
2265 :
2266 0 : releaseDateExists = eis.readBoolean();
2267 0 : if (releaseDateExists) {
2268 :
2269 :
2270 :
2271 :
2272 0 : releaseDate = ArrayTime::fromBin(eis);
2273 :
2274 :
2275 :
2276 : }
2277 :
2278 0 : }
2279 0 : void ExecBlockRow::schedulerModeFromBin(EndianIStream& eis) {
2280 :
2281 0 : schedulerModeExists = eis.readBoolean();
2282 0 : if (schedulerModeExists) {
2283 :
2284 :
2285 :
2286 :
2287 :
2288 0 : schedulerMode = eis.readString();
2289 :
2290 :
2291 :
2292 :
2293 : }
2294 :
2295 0 : }
2296 0 : void ExecBlockRow::siteAltitudeFromBin(EndianIStream& eis) {
2297 :
2298 0 : siteAltitudeExists = eis.readBoolean();
2299 0 : if (siteAltitudeExists) {
2300 :
2301 :
2302 :
2303 :
2304 0 : siteAltitude = Length::fromBin(eis);
2305 :
2306 :
2307 :
2308 : }
2309 :
2310 0 : }
2311 0 : void ExecBlockRow::siteLongitudeFromBin(EndianIStream& eis) {
2312 :
2313 0 : siteLongitudeExists = eis.readBoolean();
2314 0 : if (siteLongitudeExists) {
2315 :
2316 :
2317 :
2318 :
2319 0 : siteLongitude = Angle::fromBin(eis);
2320 :
2321 :
2322 :
2323 : }
2324 :
2325 0 : }
2326 0 : void ExecBlockRow::siteLatitudeFromBin(EndianIStream& eis) {
2327 :
2328 0 : siteLatitudeExists = eis.readBoolean();
2329 0 : if (siteLatitudeExists) {
2330 :
2331 :
2332 :
2333 :
2334 0 : siteLatitude = Angle::fromBin(eis);
2335 :
2336 :
2337 :
2338 : }
2339 :
2340 0 : }
2341 0 : void ExecBlockRow::observingScriptFromBin(EndianIStream& eis) {
2342 :
2343 0 : observingScriptExists = eis.readBoolean();
2344 0 : if (observingScriptExists) {
2345 :
2346 :
2347 :
2348 :
2349 :
2350 0 : observingScript = eis.readString();
2351 :
2352 :
2353 :
2354 :
2355 : }
2356 :
2357 0 : }
2358 0 : void ExecBlockRow::observingScriptUIDFromBin(EndianIStream& eis) {
2359 :
2360 0 : observingScriptUIDExists = eis.readBoolean();
2361 0 : if (observingScriptUIDExists) {
2362 :
2363 :
2364 :
2365 :
2366 0 : observingScriptUID = EntityRef::fromBin(eis);
2367 :
2368 :
2369 :
2370 : }
2371 :
2372 0 : }
2373 0 : void ExecBlockRow::scaleIdFromBin(EndianIStream& eis) {
2374 :
2375 0 : scaleIdExists = eis.readBoolean();
2376 0 : if (scaleIdExists) {
2377 :
2378 :
2379 :
2380 :
2381 0 : scaleId = Tag::fromBin(eis);
2382 :
2383 :
2384 :
2385 : }
2386 :
2387 0 : }
2388 :
2389 :
2390 0 : ExecBlockRow* ExecBlockRow::fromBin(EndianIStream& eis, ExecBlockTable& table, const vector<string>& attributesSeq) {
2391 0 : ExecBlockRow* row = new ExecBlockRow(table);
2392 :
2393 0 : map<string, ExecBlockAttributeFromBin>::iterator iter ;
2394 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
2395 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
2396 0 : if (iter != row->fromBinMethods.end()) {
2397 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
2398 : }
2399 : else {
2400 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
2401 0 : if (functorP)
2402 0 : (*functorP)(eis);
2403 : else
2404 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "ExecBlockTable");
2405 : }
2406 :
2407 : }
2408 0 : return row;
2409 : }
2410 :
2411 : //
2412 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
2413 : // of one row.
2414 : //
2415 :
2416 : // Convert a string into an Tag
2417 0 : void ExecBlockRow::execBlockIdFromText(const string & s) {
2418 :
2419 :
2420 0 : execBlockId = ASDMValuesParser::parse<Tag>(s);
2421 :
2422 :
2423 0 : }
2424 :
2425 :
2426 : // Convert a string into an ArrayTime
2427 0 : void ExecBlockRow::startTimeFromText(const string & s) {
2428 :
2429 :
2430 0 : startTime = ASDMValuesParser::parse<ArrayTime>(s);
2431 :
2432 :
2433 0 : }
2434 :
2435 :
2436 : // Convert a string into an ArrayTime
2437 0 : void ExecBlockRow::endTimeFromText(const string & s) {
2438 :
2439 :
2440 0 : endTime = ASDMValuesParser::parse<ArrayTime>(s);
2441 :
2442 :
2443 0 : }
2444 :
2445 :
2446 : // Convert a string into an int
2447 0 : void ExecBlockRow::execBlockNumFromText(const string & s) {
2448 :
2449 :
2450 0 : execBlockNum = ASDMValuesParser::parse<int>(s);
2451 :
2452 :
2453 0 : }
2454 :
2455 :
2456 :
2457 :
2458 : // Convert a string into an String
2459 0 : void ExecBlockRow::configNameFromText(const string & s) {
2460 :
2461 :
2462 0 : configName = ASDMValuesParser::parse<string>(s);
2463 :
2464 :
2465 0 : }
2466 :
2467 :
2468 : // Convert a string into an String
2469 0 : void ExecBlockRow::telescopeNameFromText(const string & s) {
2470 :
2471 :
2472 0 : telescopeName = ASDMValuesParser::parse<string>(s);
2473 :
2474 :
2475 0 : }
2476 :
2477 :
2478 : // Convert a string into an String
2479 0 : void ExecBlockRow::observerNameFromText(const string & s) {
2480 :
2481 :
2482 0 : observerName = ASDMValuesParser::parse<string>(s);
2483 :
2484 :
2485 0 : }
2486 :
2487 :
2488 : // Convert a string into an int
2489 0 : void ExecBlockRow::numObservingLogFromText(const string & s) {
2490 :
2491 :
2492 0 : numObservingLog = ASDMValuesParser::parse<int>(s);
2493 :
2494 :
2495 0 : }
2496 :
2497 :
2498 : // Convert a string into an String
2499 0 : void ExecBlockRow::observingLogFromText(const string & s) {
2500 :
2501 :
2502 0 : observingLog = ASDMValuesParser::parse1D<string>(s);
2503 :
2504 :
2505 0 : }
2506 :
2507 :
2508 :
2509 : // Convert a string into an Length
2510 0 : void ExecBlockRow::baseRangeMinFromText(const string & s) {
2511 :
2512 :
2513 0 : baseRangeMin = ASDMValuesParser::parse<Length>(s);
2514 :
2515 :
2516 0 : }
2517 :
2518 :
2519 : // Convert a string into an Length
2520 0 : void ExecBlockRow::baseRangeMaxFromText(const string & s) {
2521 :
2522 :
2523 0 : baseRangeMax = ASDMValuesParser::parse<Length>(s);
2524 :
2525 :
2526 0 : }
2527 :
2528 :
2529 : // Convert a string into an Length
2530 0 : void ExecBlockRow::baseRmsMinorFromText(const string & s) {
2531 :
2532 :
2533 0 : baseRmsMinor = ASDMValuesParser::parse<Length>(s);
2534 :
2535 :
2536 0 : }
2537 :
2538 :
2539 : // Convert a string into an Length
2540 0 : void ExecBlockRow::baseRmsMajorFromText(const string & s) {
2541 :
2542 :
2543 0 : baseRmsMajor = ASDMValuesParser::parse<Length>(s);
2544 :
2545 :
2546 0 : }
2547 :
2548 :
2549 : // Convert a string into an Angle
2550 0 : void ExecBlockRow::basePaFromText(const string & s) {
2551 :
2552 :
2553 0 : basePa = ASDMValuesParser::parse<Angle>(s);
2554 :
2555 :
2556 0 : }
2557 :
2558 :
2559 : // Convert a string into an boolean
2560 0 : void ExecBlockRow::abortedFromText(const string & s) {
2561 :
2562 :
2563 0 : aborted = ASDMValuesParser::parse<bool>(s);
2564 :
2565 :
2566 0 : }
2567 :
2568 :
2569 : // Convert a string into an int
2570 0 : void ExecBlockRow::numAntennaFromText(const string & s) {
2571 :
2572 :
2573 0 : numAntenna = ASDMValuesParser::parse<int>(s);
2574 :
2575 :
2576 0 : }
2577 :
2578 :
2579 : // Convert a string into an Tag
2580 0 : void ExecBlockRow::antennaIdFromText(const string & s) {
2581 :
2582 :
2583 0 : antennaId = ASDMValuesParser::parse1D<Tag>(s);
2584 :
2585 :
2586 0 : }
2587 :
2588 :
2589 : // Convert a string into an Tag
2590 0 : void ExecBlockRow::sBSummaryIdFromText(const string & s) {
2591 :
2592 :
2593 0 : sBSummaryId = ASDMValuesParser::parse<Tag>(s);
2594 :
2595 :
2596 0 : }
2597 :
2598 :
2599 :
2600 : // Convert a string into an ArrayTime
2601 0 : void ExecBlockRow::releaseDateFromText(const string & s) {
2602 0 : releaseDateExists = true;
2603 :
2604 :
2605 0 : releaseDate = ASDMValuesParser::parse<ArrayTime>(s);
2606 :
2607 :
2608 0 : }
2609 :
2610 :
2611 : // Convert a string into an String
2612 0 : void ExecBlockRow::schedulerModeFromText(const string & s) {
2613 0 : schedulerModeExists = true;
2614 :
2615 :
2616 0 : schedulerMode = ASDMValuesParser::parse<string>(s);
2617 :
2618 :
2619 0 : }
2620 :
2621 :
2622 : // Convert a string into an Length
2623 0 : void ExecBlockRow::siteAltitudeFromText(const string & s) {
2624 0 : siteAltitudeExists = true;
2625 :
2626 :
2627 0 : siteAltitude = ASDMValuesParser::parse<Length>(s);
2628 :
2629 :
2630 0 : }
2631 :
2632 :
2633 : // Convert a string into an Angle
2634 0 : void ExecBlockRow::siteLongitudeFromText(const string & s) {
2635 0 : siteLongitudeExists = true;
2636 :
2637 :
2638 0 : siteLongitude = ASDMValuesParser::parse<Angle>(s);
2639 :
2640 :
2641 0 : }
2642 :
2643 :
2644 : // Convert a string into an Angle
2645 0 : void ExecBlockRow::siteLatitudeFromText(const string & s) {
2646 0 : siteLatitudeExists = true;
2647 :
2648 :
2649 0 : siteLatitude = ASDMValuesParser::parse<Angle>(s);
2650 :
2651 :
2652 0 : }
2653 :
2654 :
2655 : // Convert a string into an String
2656 0 : void ExecBlockRow::observingScriptFromText(const string & s) {
2657 0 : observingScriptExists = true;
2658 :
2659 :
2660 0 : observingScript = ASDMValuesParser::parse<string>(s);
2661 :
2662 :
2663 0 : }
2664 :
2665 :
2666 :
2667 : // Convert a string into an Tag
2668 0 : void ExecBlockRow::scaleIdFromText(const string & s) {
2669 0 : scaleIdExists = true;
2670 :
2671 :
2672 0 : scaleId = ASDMValuesParser::parse<Tag>(s);
2673 :
2674 :
2675 0 : }
2676 :
2677 :
2678 :
2679 0 : void ExecBlockRow::fromText(const std::string& attributeName, const std::string& t) {
2680 0 : map<string, ExecBlockAttributeFromText>::iterator iter;
2681 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
2682 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "ExecBlockTable");
2683 0 : (this->*(iter->second))(t);
2684 0 : }
2685 :
2686 : ////////////////////////////////////////////////
2687 : // Intrinsic Table Attributes getters/setters //
2688 : ////////////////////////////////////////////////
2689 :
2690 :
2691 :
2692 :
2693 : /**
2694 : * Get execBlockId.
2695 : * @return execBlockId as Tag
2696 : */
2697 6172 : Tag ExecBlockRow::getExecBlockId() const {
2698 :
2699 6172 : return execBlockId;
2700 : }
2701 :
2702 : /**
2703 : * Set execBlockId with the specified Tag.
2704 : * @param execBlockId The Tag value to which execBlockId is to be set.
2705 :
2706 :
2707 :
2708 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2709 :
2710 : */
2711 493 : void ExecBlockRow::setExecBlockId (Tag execBlockId) {
2712 :
2713 :
2714 493 : if (hasBeenAdded) {
2715 :
2716 0 : throw IllegalAccessException("execBlockId", "ExecBlock");
2717 :
2718 : }
2719 :
2720 493 : this->execBlockId = execBlockId;
2721 :
2722 493 : }
2723 :
2724 :
2725 :
2726 :
2727 :
2728 :
2729 : /**
2730 : * Get startTime.
2731 : * @return startTime as ArrayTime
2732 : */
2733 493 : ArrayTime ExecBlockRow::getStartTime() const {
2734 :
2735 493 : return startTime;
2736 : }
2737 :
2738 : /**
2739 : * Set startTime with the specified ArrayTime.
2740 : * @param startTime The ArrayTime value to which startTime is to be set.
2741 :
2742 :
2743 :
2744 : */
2745 493 : void ExecBlockRow::setStartTime (ArrayTime startTime) {
2746 :
2747 :
2748 493 : if (hasBeenAdded) {
2749 :
2750 : }
2751 :
2752 493 : this->startTime = startTime;
2753 :
2754 493 : }
2755 :
2756 :
2757 :
2758 :
2759 :
2760 :
2761 : /**
2762 : * Get endTime.
2763 : * @return endTime as ArrayTime
2764 : */
2765 827 : ArrayTime ExecBlockRow::getEndTime() const {
2766 :
2767 827 : return endTime;
2768 : }
2769 :
2770 : /**
2771 : * Set endTime with the specified ArrayTime.
2772 : * @param endTime The ArrayTime value to which endTime is to be set.
2773 :
2774 :
2775 :
2776 : */
2777 493 : void ExecBlockRow::setEndTime (ArrayTime endTime) {
2778 :
2779 :
2780 493 : if (hasBeenAdded) {
2781 :
2782 : }
2783 :
2784 493 : this->endTime = endTime;
2785 :
2786 493 : }
2787 :
2788 :
2789 :
2790 :
2791 :
2792 :
2793 : /**
2794 : * Get execBlockNum.
2795 : * @return execBlockNum as int
2796 : */
2797 877 : int ExecBlockRow::getExecBlockNum() const {
2798 :
2799 877 : return execBlockNum;
2800 : }
2801 :
2802 : /**
2803 : * Set execBlockNum with the specified int.
2804 : * @param execBlockNum The int value to which execBlockNum is to be set.
2805 :
2806 :
2807 :
2808 : */
2809 493 : void ExecBlockRow::setExecBlockNum (int execBlockNum) {
2810 :
2811 :
2812 493 : if (hasBeenAdded) {
2813 :
2814 : }
2815 :
2816 493 : this->execBlockNum = execBlockNum;
2817 :
2818 493 : }
2819 :
2820 :
2821 :
2822 :
2823 :
2824 :
2825 : /**
2826 : * Get execBlockUID.
2827 : * @return execBlockUID as EntityRef
2828 : */
2829 1025 : EntityRef ExecBlockRow::getExecBlockUID() const {
2830 :
2831 1025 : return execBlockUID;
2832 : }
2833 :
2834 : /**
2835 : * Set execBlockUID with the specified EntityRef.
2836 : * @param execBlockUID The EntityRef value to which execBlockUID is to be set.
2837 :
2838 :
2839 :
2840 : */
2841 493 : void ExecBlockRow::setExecBlockUID (EntityRef execBlockUID) {
2842 :
2843 :
2844 493 : if (hasBeenAdded) {
2845 :
2846 : }
2847 :
2848 493 : this->execBlockUID = execBlockUID;
2849 :
2850 493 : }
2851 :
2852 :
2853 :
2854 :
2855 :
2856 :
2857 : /**
2858 : * Get projectUID.
2859 : * @return projectUID as EntityRef
2860 : */
2861 489 : EntityRef ExecBlockRow::getProjectUID() const {
2862 :
2863 489 : return projectUID;
2864 : }
2865 :
2866 : /**
2867 : * Set projectUID with the specified EntityRef.
2868 : * @param projectUID The EntityRef value to which projectUID is to be set.
2869 :
2870 :
2871 :
2872 : */
2873 493 : void ExecBlockRow::setProjectUID (EntityRef projectUID) {
2874 :
2875 :
2876 493 : if (hasBeenAdded) {
2877 :
2878 : }
2879 :
2880 493 : this->projectUID = projectUID;
2881 :
2882 493 : }
2883 :
2884 :
2885 :
2886 :
2887 :
2888 :
2889 : /**
2890 : * Get configName.
2891 : * @return configName as std::string
2892 : */
2893 345 : std::string ExecBlockRow::getConfigName() const {
2894 :
2895 345 : return configName;
2896 : }
2897 :
2898 : /**
2899 : * Set configName with the specified std::string.
2900 : * @param configName The std::string value to which configName is to be set.
2901 :
2902 :
2903 :
2904 : */
2905 493 : void ExecBlockRow::setConfigName (std::string configName) {
2906 :
2907 :
2908 493 : if (hasBeenAdded) {
2909 :
2910 : }
2911 :
2912 493 : this->configName = configName;
2913 :
2914 493 : }
2915 :
2916 :
2917 :
2918 :
2919 :
2920 :
2921 : /**
2922 : * Get telescopeName.
2923 : * @return telescopeName as std::string
2924 : */
2925 726 : std::string ExecBlockRow::getTelescopeName() const {
2926 :
2927 726 : return telescopeName;
2928 : }
2929 :
2930 : /**
2931 : * Set telescopeName with the specified std::string.
2932 : * @param telescopeName The std::string value to which telescopeName is to be set.
2933 :
2934 :
2935 :
2936 : */
2937 493 : void ExecBlockRow::setTelescopeName (std::string telescopeName) {
2938 :
2939 :
2940 493 : if (hasBeenAdded) {
2941 :
2942 : }
2943 :
2944 493 : this->telescopeName = telescopeName;
2945 :
2946 493 : }
2947 :
2948 :
2949 :
2950 :
2951 :
2952 :
2953 : /**
2954 : * Get observerName.
2955 : * @return observerName as std::string
2956 : */
2957 493 : std::string ExecBlockRow::getObserverName() const {
2958 :
2959 493 : return observerName;
2960 : }
2961 :
2962 : /**
2963 : * Set observerName with the specified std::string.
2964 : * @param observerName The std::string value to which observerName is to be set.
2965 :
2966 :
2967 :
2968 : */
2969 493 : void ExecBlockRow::setObserverName (std::string observerName) {
2970 :
2971 :
2972 493 : if (hasBeenAdded) {
2973 :
2974 : }
2975 :
2976 493 : this->observerName = observerName;
2977 :
2978 493 : }
2979 :
2980 :
2981 :
2982 :
2983 :
2984 :
2985 : /**
2986 : * Get numObservingLog.
2987 : * @return numObservingLog as int
2988 : */
2989 341 : int ExecBlockRow::getNumObservingLog() const {
2990 :
2991 341 : return numObservingLog;
2992 : }
2993 :
2994 : /**
2995 : * Set numObservingLog with the specified int.
2996 : * @param numObservingLog The int value to which numObservingLog is to be set.
2997 :
2998 :
2999 :
3000 : */
3001 493 : void ExecBlockRow::setNumObservingLog (int numObservingLog) {
3002 :
3003 :
3004 493 : if (hasBeenAdded) {
3005 :
3006 : }
3007 :
3008 493 : this->numObservingLog = numObservingLog;
3009 :
3010 493 : }
3011 :
3012 :
3013 :
3014 :
3015 :
3016 :
3017 : /**
3018 : * Get observingLog.
3019 : * @return observingLog as std::vector<std::string >
3020 : */
3021 489 : std::vector<std::string > ExecBlockRow::getObservingLog() const {
3022 :
3023 489 : return observingLog;
3024 : }
3025 :
3026 : /**
3027 : * Set observingLog with the specified std::vector<std::string >.
3028 : * @param observingLog The std::vector<std::string > value to which observingLog is to be set.
3029 :
3030 :
3031 :
3032 : */
3033 493 : void ExecBlockRow::setObservingLog (std::vector<std::string > observingLog) {
3034 :
3035 :
3036 493 : if (hasBeenAdded) {
3037 :
3038 : }
3039 :
3040 493 : this->observingLog = observingLog;
3041 :
3042 493 : }
3043 :
3044 :
3045 :
3046 :
3047 :
3048 :
3049 : /**
3050 : * Get sessionReference.
3051 : * @return sessionReference as EntityRef
3052 : */
3053 341 : EntityRef ExecBlockRow::getSessionReference() const {
3054 :
3055 341 : return sessionReference;
3056 : }
3057 :
3058 : /**
3059 : * Set sessionReference with the specified EntityRef.
3060 : * @param sessionReference The EntityRef value to which sessionReference is to be set.
3061 :
3062 :
3063 :
3064 : */
3065 493 : void ExecBlockRow::setSessionReference (EntityRef sessionReference) {
3066 :
3067 :
3068 493 : if (hasBeenAdded) {
3069 :
3070 : }
3071 :
3072 493 : this->sessionReference = sessionReference;
3073 :
3074 493 : }
3075 :
3076 :
3077 :
3078 :
3079 :
3080 :
3081 : /**
3082 : * Get baseRangeMin.
3083 : * @return baseRangeMin as Length
3084 : */
3085 341 : Length ExecBlockRow::getBaseRangeMin() const {
3086 :
3087 341 : return baseRangeMin;
3088 : }
3089 :
3090 : /**
3091 : * Set baseRangeMin with the specified Length.
3092 : * @param baseRangeMin The Length value to which baseRangeMin is to be set.
3093 :
3094 :
3095 :
3096 : */
3097 493 : void ExecBlockRow::setBaseRangeMin (Length baseRangeMin) {
3098 :
3099 :
3100 493 : if (hasBeenAdded) {
3101 :
3102 : }
3103 :
3104 493 : this->baseRangeMin = baseRangeMin;
3105 :
3106 493 : }
3107 :
3108 :
3109 :
3110 :
3111 :
3112 :
3113 : /**
3114 : * Get baseRangeMax.
3115 : * @return baseRangeMax as Length
3116 : */
3117 341 : Length ExecBlockRow::getBaseRangeMax() const {
3118 :
3119 341 : return baseRangeMax;
3120 : }
3121 :
3122 : /**
3123 : * Set baseRangeMax with the specified Length.
3124 : * @param baseRangeMax The Length value to which baseRangeMax is to be set.
3125 :
3126 :
3127 :
3128 : */
3129 493 : void ExecBlockRow::setBaseRangeMax (Length baseRangeMax) {
3130 :
3131 :
3132 493 : if (hasBeenAdded) {
3133 :
3134 : }
3135 :
3136 493 : this->baseRangeMax = baseRangeMax;
3137 :
3138 493 : }
3139 :
3140 :
3141 :
3142 :
3143 :
3144 :
3145 : /**
3146 : * Get baseRmsMinor.
3147 : * @return baseRmsMinor as Length
3148 : */
3149 341 : Length ExecBlockRow::getBaseRmsMinor() const {
3150 :
3151 341 : return baseRmsMinor;
3152 : }
3153 :
3154 : /**
3155 : * Set baseRmsMinor with the specified Length.
3156 : * @param baseRmsMinor The Length value to which baseRmsMinor is to be set.
3157 :
3158 :
3159 :
3160 : */
3161 493 : void ExecBlockRow::setBaseRmsMinor (Length baseRmsMinor) {
3162 :
3163 :
3164 493 : if (hasBeenAdded) {
3165 :
3166 : }
3167 :
3168 493 : this->baseRmsMinor = baseRmsMinor;
3169 :
3170 493 : }
3171 :
3172 :
3173 :
3174 :
3175 :
3176 :
3177 : /**
3178 : * Get baseRmsMajor.
3179 : * @return baseRmsMajor as Length
3180 : */
3181 341 : Length ExecBlockRow::getBaseRmsMajor() const {
3182 :
3183 341 : return baseRmsMajor;
3184 : }
3185 :
3186 : /**
3187 : * Set baseRmsMajor with the specified Length.
3188 : * @param baseRmsMajor The Length value to which baseRmsMajor is to be set.
3189 :
3190 :
3191 :
3192 : */
3193 493 : void ExecBlockRow::setBaseRmsMajor (Length baseRmsMajor) {
3194 :
3195 :
3196 493 : if (hasBeenAdded) {
3197 :
3198 : }
3199 :
3200 493 : this->baseRmsMajor = baseRmsMajor;
3201 :
3202 493 : }
3203 :
3204 :
3205 :
3206 :
3207 :
3208 :
3209 : /**
3210 : * Get basePa.
3211 : * @return basePa as Angle
3212 : */
3213 341 : Angle ExecBlockRow::getBasePa() const {
3214 :
3215 341 : return basePa;
3216 : }
3217 :
3218 : /**
3219 : * Set basePa with the specified Angle.
3220 : * @param basePa The Angle value to which basePa is to be set.
3221 :
3222 :
3223 :
3224 : */
3225 493 : void ExecBlockRow::setBasePa (Angle basePa) {
3226 :
3227 :
3228 493 : if (hasBeenAdded) {
3229 :
3230 : }
3231 :
3232 493 : this->basePa = basePa;
3233 :
3234 493 : }
3235 :
3236 :
3237 :
3238 :
3239 :
3240 :
3241 : /**
3242 : * Get aborted.
3243 : * @return aborted as bool
3244 : */
3245 345 : bool ExecBlockRow::getAborted() const {
3246 :
3247 345 : return aborted;
3248 : }
3249 :
3250 : /**
3251 : * Set aborted with the specified bool.
3252 : * @param aborted The bool value to which aborted is to be set.
3253 :
3254 :
3255 :
3256 : */
3257 493 : void ExecBlockRow::setAborted (bool aborted) {
3258 :
3259 :
3260 493 : if (hasBeenAdded) {
3261 :
3262 : }
3263 :
3264 493 : this->aborted = aborted;
3265 :
3266 493 : }
3267 :
3268 :
3269 :
3270 :
3271 :
3272 :
3273 : /**
3274 : * Get numAntenna.
3275 : * @return numAntenna as int
3276 : */
3277 341 : int ExecBlockRow::getNumAntenna() const {
3278 :
3279 341 : return numAntenna;
3280 : }
3281 :
3282 : /**
3283 : * Set numAntenna with the specified int.
3284 : * @param numAntenna The int value to which numAntenna is to be set.
3285 :
3286 :
3287 :
3288 : */
3289 493 : void ExecBlockRow::setNumAntenna (int numAntenna) {
3290 :
3291 :
3292 493 : if (hasBeenAdded) {
3293 :
3294 : }
3295 :
3296 493 : this->numAntenna = numAntenna;
3297 :
3298 493 : }
3299 :
3300 :
3301 :
3302 :
3303 : /**
3304 : * The attribute releaseDate is optional. Return true if this attribute exists.
3305 : * @return true if and only if the releaseDate attribute exists.
3306 : */
3307 148 : bool ExecBlockRow::isReleaseDateExists() const {
3308 148 : return releaseDateExists;
3309 : }
3310 :
3311 :
3312 :
3313 : /**
3314 : * Get releaseDate, which is optional.
3315 : * @return releaseDate as ArrayTime
3316 : * @throw IllegalAccessException If releaseDate does not exist.
3317 : */
3318 0 : ArrayTime ExecBlockRow::getReleaseDate() const {
3319 0 : if (!releaseDateExists) {
3320 0 : throw IllegalAccessException("releaseDate", "ExecBlock");
3321 : }
3322 :
3323 0 : return releaseDate;
3324 : }
3325 :
3326 : /**
3327 : * Set releaseDate with the specified ArrayTime.
3328 : * @param releaseDate The ArrayTime value to which releaseDate is to be set.
3329 :
3330 :
3331 : */
3332 0 : void ExecBlockRow::setReleaseDate (ArrayTime releaseDate) {
3333 :
3334 0 : this->releaseDate = releaseDate;
3335 :
3336 0 : releaseDateExists = true;
3337 :
3338 0 : }
3339 :
3340 :
3341 : /**
3342 : * Mark releaseDate, which is an optional field, as non-existent.
3343 : */
3344 0 : void ExecBlockRow::clearReleaseDate () {
3345 0 : releaseDateExists = false;
3346 0 : }
3347 :
3348 :
3349 :
3350 : /**
3351 : * The attribute schedulerMode is optional. Return true if this attribute exists.
3352 : * @return true if and only if the schedulerMode attribute exists.
3353 : */
3354 0 : bool ExecBlockRow::isSchedulerModeExists() const {
3355 0 : return schedulerModeExists;
3356 : }
3357 :
3358 :
3359 :
3360 : /**
3361 : * Get schedulerMode, which is optional.
3362 : * @return schedulerMode as std::string
3363 : * @throw IllegalAccessException If schedulerMode does not exist.
3364 : */
3365 0 : std::string ExecBlockRow::getSchedulerMode() const {
3366 0 : if (!schedulerModeExists) {
3367 0 : throw IllegalAccessException("schedulerMode", "ExecBlock");
3368 : }
3369 :
3370 0 : return schedulerMode;
3371 : }
3372 :
3373 : /**
3374 : * Set schedulerMode with the specified std::string.
3375 : * @param schedulerMode The std::string value to which schedulerMode is to be set.
3376 :
3377 :
3378 : */
3379 29 : void ExecBlockRow::setSchedulerMode (std::string schedulerMode) {
3380 :
3381 29 : this->schedulerMode = schedulerMode;
3382 :
3383 29 : schedulerModeExists = true;
3384 :
3385 29 : }
3386 :
3387 :
3388 : /**
3389 : * Mark schedulerMode, which is an optional field, as non-existent.
3390 : */
3391 0 : void ExecBlockRow::clearSchedulerMode () {
3392 0 : schedulerModeExists = false;
3393 0 : }
3394 :
3395 :
3396 :
3397 : /**
3398 : * The attribute siteAltitude is optional. Return true if this attribute exists.
3399 : * @return true if and only if the siteAltitude attribute exists.
3400 : */
3401 0 : bool ExecBlockRow::isSiteAltitudeExists() const {
3402 0 : return siteAltitudeExists;
3403 : }
3404 :
3405 :
3406 :
3407 : /**
3408 : * Get siteAltitude, which is optional.
3409 : * @return siteAltitude as Length
3410 : * @throw IllegalAccessException If siteAltitude does not exist.
3411 : */
3412 0 : Length ExecBlockRow::getSiteAltitude() const {
3413 0 : if (!siteAltitudeExists) {
3414 0 : throw IllegalAccessException("siteAltitude", "ExecBlock");
3415 : }
3416 :
3417 0 : return siteAltitude;
3418 : }
3419 :
3420 : /**
3421 : * Set siteAltitude with the specified Length.
3422 : * @param siteAltitude The Length value to which siteAltitude is to be set.
3423 :
3424 :
3425 : */
3426 86 : void ExecBlockRow::setSiteAltitude (Length siteAltitude) {
3427 :
3428 86 : this->siteAltitude = siteAltitude;
3429 :
3430 86 : siteAltitudeExists = true;
3431 :
3432 86 : }
3433 :
3434 :
3435 : /**
3436 : * Mark siteAltitude, which is an optional field, as non-existent.
3437 : */
3438 0 : void ExecBlockRow::clearSiteAltitude () {
3439 0 : siteAltitudeExists = false;
3440 0 : }
3441 :
3442 :
3443 :
3444 : /**
3445 : * The attribute siteLongitude is optional. Return true if this attribute exists.
3446 : * @return true if and only if the siteLongitude attribute exists.
3447 : */
3448 0 : bool ExecBlockRow::isSiteLongitudeExists() const {
3449 0 : return siteLongitudeExists;
3450 : }
3451 :
3452 :
3453 :
3454 : /**
3455 : * Get siteLongitude, which is optional.
3456 : * @return siteLongitude as Angle
3457 : * @throw IllegalAccessException If siteLongitude does not exist.
3458 : */
3459 0 : Angle ExecBlockRow::getSiteLongitude() const {
3460 0 : if (!siteLongitudeExists) {
3461 0 : throw IllegalAccessException("siteLongitude", "ExecBlock");
3462 : }
3463 :
3464 0 : return siteLongitude;
3465 : }
3466 :
3467 : /**
3468 : * Set siteLongitude with the specified Angle.
3469 : * @param siteLongitude The Angle value to which siteLongitude is to be set.
3470 :
3471 :
3472 : */
3473 86 : void ExecBlockRow::setSiteLongitude (Angle siteLongitude) {
3474 :
3475 86 : this->siteLongitude = siteLongitude;
3476 :
3477 86 : siteLongitudeExists = true;
3478 :
3479 86 : }
3480 :
3481 :
3482 : /**
3483 : * Mark siteLongitude, which is an optional field, as non-existent.
3484 : */
3485 0 : void ExecBlockRow::clearSiteLongitude () {
3486 0 : siteLongitudeExists = false;
3487 0 : }
3488 :
3489 :
3490 :
3491 : /**
3492 : * The attribute siteLatitude is optional. Return true if this attribute exists.
3493 : * @return true if and only if the siteLatitude attribute exists.
3494 : */
3495 0 : bool ExecBlockRow::isSiteLatitudeExists() const {
3496 0 : return siteLatitudeExists;
3497 : }
3498 :
3499 :
3500 :
3501 : /**
3502 : * Get siteLatitude, which is optional.
3503 : * @return siteLatitude as Angle
3504 : * @throw IllegalAccessException If siteLatitude does not exist.
3505 : */
3506 0 : Angle ExecBlockRow::getSiteLatitude() const {
3507 0 : if (!siteLatitudeExists) {
3508 0 : throw IllegalAccessException("siteLatitude", "ExecBlock");
3509 : }
3510 :
3511 0 : return siteLatitude;
3512 : }
3513 :
3514 : /**
3515 : * Set siteLatitude with the specified Angle.
3516 : * @param siteLatitude The Angle value to which siteLatitude is to be set.
3517 :
3518 :
3519 : */
3520 86 : void ExecBlockRow::setSiteLatitude (Angle siteLatitude) {
3521 :
3522 86 : this->siteLatitude = siteLatitude;
3523 :
3524 86 : siteLatitudeExists = true;
3525 :
3526 86 : }
3527 :
3528 :
3529 : /**
3530 : * Mark siteLatitude, which is an optional field, as non-existent.
3531 : */
3532 0 : void ExecBlockRow::clearSiteLatitude () {
3533 0 : siteLatitudeExists = false;
3534 0 : }
3535 :
3536 :
3537 :
3538 : /**
3539 : * The attribute observingScript is optional. Return true if this attribute exists.
3540 : * @return true if and only if the observingScript attribute exists.
3541 : */
3542 0 : bool ExecBlockRow::isObservingScriptExists() const {
3543 0 : return observingScriptExists;
3544 : }
3545 :
3546 :
3547 :
3548 : /**
3549 : * Get observingScript, which is optional.
3550 : * @return observingScript as std::string
3551 : * @throw IllegalAccessException If observingScript does not exist.
3552 : */
3553 0 : std::string ExecBlockRow::getObservingScript() const {
3554 0 : if (!observingScriptExists) {
3555 0 : throw IllegalAccessException("observingScript", "ExecBlock");
3556 : }
3557 :
3558 0 : return observingScript;
3559 : }
3560 :
3561 : /**
3562 : * Set observingScript with the specified std::string.
3563 : * @param observingScript The std::string value to which observingScript is to be set.
3564 :
3565 :
3566 : */
3567 57 : void ExecBlockRow::setObservingScript (std::string observingScript) {
3568 :
3569 57 : this->observingScript = observingScript;
3570 :
3571 57 : observingScriptExists = true;
3572 :
3573 57 : }
3574 :
3575 :
3576 : /**
3577 : * Mark observingScript, which is an optional field, as non-existent.
3578 : */
3579 0 : void ExecBlockRow::clearObservingScript () {
3580 0 : observingScriptExists = false;
3581 0 : }
3582 :
3583 :
3584 :
3585 : /**
3586 : * The attribute observingScriptUID is optional. Return true if this attribute exists.
3587 : * @return true if and only if the observingScriptUID attribute exists.
3588 : */
3589 0 : bool ExecBlockRow::isObservingScriptUIDExists() const {
3590 0 : return observingScriptUIDExists;
3591 : }
3592 :
3593 :
3594 :
3595 : /**
3596 : * Get observingScriptUID, which is optional.
3597 : * @return observingScriptUID as EntityRef
3598 : * @throw IllegalAccessException If observingScriptUID does not exist.
3599 : */
3600 0 : EntityRef ExecBlockRow::getObservingScriptUID() const {
3601 0 : if (!observingScriptUIDExists) {
3602 0 : throw IllegalAccessException("observingScriptUID", "ExecBlock");
3603 : }
3604 :
3605 0 : return observingScriptUID;
3606 : }
3607 :
3608 : /**
3609 : * Set observingScriptUID with the specified EntityRef.
3610 : * @param observingScriptUID The EntityRef value to which observingScriptUID is to be set.
3611 :
3612 :
3613 : */
3614 0 : void ExecBlockRow::setObservingScriptUID (EntityRef observingScriptUID) {
3615 :
3616 0 : this->observingScriptUID = observingScriptUID;
3617 :
3618 0 : observingScriptUIDExists = true;
3619 :
3620 0 : }
3621 :
3622 :
3623 : /**
3624 : * Mark observingScriptUID, which is an optional field, as non-existent.
3625 : */
3626 0 : void ExecBlockRow::clearObservingScriptUID () {
3627 0 : observingScriptUIDExists = false;
3628 0 : }
3629 :
3630 :
3631 :
3632 : ///////////////////////////////////////////////
3633 : // Extrinsic Table Attributes getters/setters//
3634 : ///////////////////////////////////////////////
3635 :
3636 :
3637 :
3638 :
3639 : /**
3640 : * Get antennaId.
3641 : * @return antennaId as std::vector<Tag>
3642 : */
3643 345 : std::vector<Tag> ExecBlockRow::getAntennaId() const {
3644 :
3645 345 : return antennaId;
3646 : }
3647 :
3648 : /**
3649 : * Set antennaId with the specified std::vector<Tag> .
3650 : * @param antennaId The std::vector<Tag> value to which antennaId is to be set.
3651 :
3652 :
3653 :
3654 : */
3655 493 : void ExecBlockRow::setAntennaId (std::vector<Tag> antennaId) {
3656 :
3657 :
3658 493 : if (hasBeenAdded) {
3659 :
3660 : }
3661 :
3662 493 : this->antennaId = antennaId;
3663 :
3664 493 : }
3665 :
3666 :
3667 :
3668 :
3669 :
3670 :
3671 : /**
3672 : * Get sBSummaryId.
3673 : * @return sBSummaryId as Tag
3674 : */
3675 489 : Tag ExecBlockRow::getSBSummaryId() const {
3676 :
3677 489 : return sBSummaryId;
3678 : }
3679 :
3680 : /**
3681 : * Set sBSummaryId with the specified Tag.
3682 : * @param sBSummaryId The Tag value to which sBSummaryId is to be set.
3683 :
3684 :
3685 :
3686 : */
3687 493 : void ExecBlockRow::setSBSummaryId (Tag sBSummaryId) {
3688 :
3689 :
3690 493 : if (hasBeenAdded) {
3691 :
3692 : }
3693 :
3694 493 : this->sBSummaryId = sBSummaryId;
3695 :
3696 493 : }
3697 :
3698 :
3699 :
3700 :
3701 : /**
3702 : * The attribute scaleId is optional. Return true if this attribute exists.
3703 : * @return true if and only if the scaleId attribute exists.
3704 : */
3705 0 : bool ExecBlockRow::isScaleIdExists() const {
3706 0 : return scaleIdExists;
3707 : }
3708 :
3709 :
3710 :
3711 : /**
3712 : * Get scaleId, which is optional.
3713 : * @return scaleId as Tag
3714 : * @throw IllegalAccessException If scaleId does not exist.
3715 : */
3716 0 : Tag ExecBlockRow::getScaleId() const {
3717 0 : if (!scaleIdExists) {
3718 0 : throw IllegalAccessException("scaleId", "ExecBlock");
3719 : }
3720 :
3721 0 : return scaleId;
3722 : }
3723 :
3724 : /**
3725 : * Set scaleId with the specified Tag.
3726 : * @param scaleId The Tag value to which scaleId is to be set.
3727 :
3728 :
3729 : */
3730 0 : void ExecBlockRow::setScaleId (Tag scaleId) {
3731 :
3732 0 : this->scaleId = scaleId;
3733 :
3734 0 : scaleIdExists = true;
3735 :
3736 0 : }
3737 :
3738 :
3739 : /**
3740 : * Mark scaleId, which is an optional field, as non-existent.
3741 : */
3742 0 : void ExecBlockRow::clearScaleId () {
3743 0 : scaleIdExists = false;
3744 0 : }
3745 :
3746 :
3747 :
3748 : //////////////////////////////////////
3749 : // Links Attributes getters/setters //
3750 : //////////////////////////////////////
3751 :
3752 :
3753 :
3754 : /**
3755 : * Set antennaId[i] with the specified Tag.
3756 : * @param i The index in antennaId where to set the Tag value.
3757 : * @param antennaId The Tag value to which antennaId[i] is to be set.
3758 :
3759 : * @throws IndexOutOfBoundsException
3760 : */
3761 0 : void ExecBlockRow::setAntennaId (int i, Tag antennaId) {
3762 0 : if (hasBeenAdded) {
3763 :
3764 : }
3765 0 : if ((i < 0) || (i > ((int) this->antennaId.size())))
3766 0 : throw OutOfBoundsException("Index out of bounds during a set operation on attribute antennaId in table ExecBlockTable");
3767 0 : std::vector<Tag> ::iterator iter = this->antennaId.begin();
3768 0 : int j = 0;
3769 0 : while (j < i) {
3770 0 : j++; iter++;
3771 : }
3772 0 : this->antennaId.insert(this->antennaId.erase(iter), antennaId);
3773 0 : }
3774 :
3775 :
3776 :
3777 :
3778 :
3779 : /**
3780 : * Append a Tag to antennaId.
3781 : * @param id the Tag to be appended to antennaId
3782 : */
3783 0 : void ExecBlockRow::addAntennaId(Tag id){
3784 0 : antennaId.push_back(id);
3785 0 : }
3786 :
3787 : /**
3788 : * Append an array of Tag to antennaId.
3789 : * @param id an array of Tag to be appended to antennaId
3790 : */
3791 0 : void ExecBlockRow::addAntennaId(const std::vector<Tag> & id) {
3792 0 : for (unsigned int i=0; i < id.size(); i++)
3793 0 : antennaId.push_back(id.at(i));
3794 0 : }
3795 :
3796 :
3797 : /**
3798 : * Returns the Tag stored in antennaId at position i.
3799 : *
3800 : */
3801 0 : const Tag ExecBlockRow::getAntennaId(int i) {
3802 0 : return antennaId.at(i);
3803 : }
3804 :
3805 : /**
3806 : * Returns the AntennaRow linked to this row via the Tag stored in antennaId
3807 : * at position i.
3808 : */
3809 0 : AntennaRow* ExecBlockRow::getAntennaUsingAntennaId(int i) {
3810 0 : return table.getContainer().getAntenna().getRowByKey(antennaId.at(i));
3811 : }
3812 :
3813 : /**
3814 : * Returns the vector of AntennaRow* linked to this row via the Tags stored in antennaId
3815 : *
3816 : */
3817 0 : vector<AntennaRow *> ExecBlockRow::getAntennasUsingAntennaId() {
3818 0 : vector<AntennaRow *> result;
3819 0 : for (unsigned int i = 0; i < antennaId.size(); i++)
3820 0 : result.push_back(table.getContainer().getAntenna().getRowByKey(antennaId.at(i)));
3821 :
3822 0 : return result;
3823 0 : }
3824 :
3825 :
3826 :
3827 :
3828 :
3829 :
3830 :
3831 :
3832 :
3833 : /**
3834 : * Returns the pointer to the row in the SBSummary table having SBSummary.sBSummaryId == sBSummaryId
3835 : * @return a SBSummaryRow*
3836 : *
3837 :
3838 : */
3839 0 : SBSummaryRow* ExecBlockRow::getSBSummaryUsingSBSummaryId() {
3840 :
3841 0 : return table.getContainer().getSBSummary().getRowByKey(sBSummaryId);
3842 : }
3843 :
3844 :
3845 :
3846 :
3847 :
3848 :
3849 :
3850 :
3851 :
3852 : /**
3853 : * Returns the pointer to the row in the Scale table having Scale.scaleId == scaleId
3854 : * @return a ScaleRow*
3855 : *
3856 :
3857 : * throws IllegalAccessException
3858 :
3859 : */
3860 0 : ScaleRow* ExecBlockRow::getScaleUsingScaleId() {
3861 :
3862 0 : if (!scaleIdExists)
3863 0 : throw IllegalAccessException();
3864 :
3865 0 : return table.getContainer().getScale().getRowByKey(scaleId);
3866 : }
3867 :
3868 :
3869 :
3870 :
3871 :
3872 : /**
3873 : * Create a ExecBlockRow.
3874 : * <p>
3875 : * This constructor is private because only the
3876 : * table can create rows. All rows know the table
3877 : * to which they belong.
3878 : * @param table The table to which this row belongs.
3879 : */
3880 493 : ExecBlockRow::ExecBlockRow (ExecBlockTable &t) : table(t) {
3881 493 : hasBeenAdded = false;
3882 :
3883 :
3884 :
3885 :
3886 :
3887 :
3888 :
3889 :
3890 :
3891 :
3892 :
3893 :
3894 :
3895 :
3896 :
3897 :
3898 :
3899 :
3900 :
3901 :
3902 :
3903 :
3904 :
3905 :
3906 :
3907 :
3908 :
3909 :
3910 :
3911 :
3912 :
3913 :
3914 :
3915 :
3916 :
3917 :
3918 :
3919 :
3920 :
3921 :
3922 :
3923 493 : releaseDateExists = false;
3924 :
3925 :
3926 :
3927 493 : schedulerModeExists = false;
3928 :
3929 :
3930 :
3931 493 : siteAltitudeExists = false;
3932 :
3933 :
3934 :
3935 493 : siteLongitudeExists = false;
3936 :
3937 :
3938 :
3939 493 : siteLatitudeExists = false;
3940 :
3941 :
3942 :
3943 493 : observingScriptExists = false;
3944 :
3945 :
3946 :
3947 493 : observingScriptUIDExists = false;
3948 :
3949 :
3950 :
3951 :
3952 :
3953 :
3954 :
3955 :
3956 493 : scaleIdExists = false;
3957 :
3958 :
3959 :
3960 :
3961 :
3962 :
3963 :
3964 :
3965 :
3966 :
3967 :
3968 :
3969 :
3970 :
3971 :
3972 :
3973 :
3974 :
3975 :
3976 :
3977 :
3978 :
3979 :
3980 :
3981 :
3982 :
3983 :
3984 :
3985 :
3986 :
3987 :
3988 :
3989 :
3990 :
3991 :
3992 :
3993 :
3994 :
3995 :
3996 :
3997 :
3998 :
3999 :
4000 :
4001 :
4002 :
4003 :
4004 :
4005 :
4006 :
4007 :
4008 :
4009 :
4010 :
4011 :
4012 :
4013 :
4014 :
4015 :
4016 493 : fromBinMethods["execBlockId"] = &ExecBlockRow::execBlockIdFromBin;
4017 493 : fromBinMethods["startTime"] = &ExecBlockRow::startTimeFromBin;
4018 493 : fromBinMethods["endTime"] = &ExecBlockRow::endTimeFromBin;
4019 493 : fromBinMethods["execBlockNum"] = &ExecBlockRow::execBlockNumFromBin;
4020 493 : fromBinMethods["execBlockUID"] = &ExecBlockRow::execBlockUIDFromBin;
4021 493 : fromBinMethods["projectUID"] = &ExecBlockRow::projectUIDFromBin;
4022 493 : fromBinMethods["configName"] = &ExecBlockRow::configNameFromBin;
4023 493 : fromBinMethods["telescopeName"] = &ExecBlockRow::telescopeNameFromBin;
4024 493 : fromBinMethods["observerName"] = &ExecBlockRow::observerNameFromBin;
4025 493 : fromBinMethods["numObservingLog"] = &ExecBlockRow::numObservingLogFromBin;
4026 493 : fromBinMethods["observingLog"] = &ExecBlockRow::observingLogFromBin;
4027 493 : fromBinMethods["sessionReference"] = &ExecBlockRow::sessionReferenceFromBin;
4028 493 : fromBinMethods["baseRangeMin"] = &ExecBlockRow::baseRangeMinFromBin;
4029 493 : fromBinMethods["baseRangeMax"] = &ExecBlockRow::baseRangeMaxFromBin;
4030 493 : fromBinMethods["baseRmsMinor"] = &ExecBlockRow::baseRmsMinorFromBin;
4031 493 : fromBinMethods["baseRmsMajor"] = &ExecBlockRow::baseRmsMajorFromBin;
4032 493 : fromBinMethods["basePa"] = &ExecBlockRow::basePaFromBin;
4033 493 : fromBinMethods["aborted"] = &ExecBlockRow::abortedFromBin;
4034 493 : fromBinMethods["numAntenna"] = &ExecBlockRow::numAntennaFromBin;
4035 493 : fromBinMethods["antennaId"] = &ExecBlockRow::antennaIdFromBin;
4036 493 : fromBinMethods["sBSummaryId"] = &ExecBlockRow::sBSummaryIdFromBin;
4037 :
4038 :
4039 493 : fromBinMethods["releaseDate"] = &ExecBlockRow::releaseDateFromBin;
4040 493 : fromBinMethods["schedulerMode"] = &ExecBlockRow::schedulerModeFromBin;
4041 493 : fromBinMethods["siteAltitude"] = &ExecBlockRow::siteAltitudeFromBin;
4042 493 : fromBinMethods["siteLongitude"] = &ExecBlockRow::siteLongitudeFromBin;
4043 493 : fromBinMethods["siteLatitude"] = &ExecBlockRow::siteLatitudeFromBin;
4044 493 : fromBinMethods["observingScript"] = &ExecBlockRow::observingScriptFromBin;
4045 493 : fromBinMethods["observingScriptUID"] = &ExecBlockRow::observingScriptUIDFromBin;
4046 493 : fromBinMethods["scaleId"] = &ExecBlockRow::scaleIdFromBin;
4047 :
4048 :
4049 :
4050 :
4051 :
4052 493 : fromTextMethods["execBlockId"] = &ExecBlockRow::execBlockIdFromText;
4053 :
4054 :
4055 :
4056 493 : fromTextMethods["startTime"] = &ExecBlockRow::startTimeFromText;
4057 :
4058 :
4059 :
4060 493 : fromTextMethods["endTime"] = &ExecBlockRow::endTimeFromText;
4061 :
4062 :
4063 :
4064 493 : fromTextMethods["execBlockNum"] = &ExecBlockRow::execBlockNumFromText;
4065 :
4066 :
4067 :
4068 :
4069 :
4070 :
4071 :
4072 493 : fromTextMethods["configName"] = &ExecBlockRow::configNameFromText;
4073 :
4074 :
4075 :
4076 493 : fromTextMethods["telescopeName"] = &ExecBlockRow::telescopeNameFromText;
4077 :
4078 :
4079 :
4080 493 : fromTextMethods["observerName"] = &ExecBlockRow::observerNameFromText;
4081 :
4082 :
4083 :
4084 493 : fromTextMethods["numObservingLog"] = &ExecBlockRow::numObservingLogFromText;
4085 :
4086 :
4087 :
4088 493 : fromTextMethods["observingLog"] = &ExecBlockRow::observingLogFromText;
4089 :
4090 :
4091 :
4092 :
4093 :
4094 493 : fromTextMethods["baseRangeMin"] = &ExecBlockRow::baseRangeMinFromText;
4095 :
4096 :
4097 :
4098 493 : fromTextMethods["baseRangeMax"] = &ExecBlockRow::baseRangeMaxFromText;
4099 :
4100 :
4101 :
4102 493 : fromTextMethods["baseRmsMinor"] = &ExecBlockRow::baseRmsMinorFromText;
4103 :
4104 :
4105 :
4106 493 : fromTextMethods["baseRmsMajor"] = &ExecBlockRow::baseRmsMajorFromText;
4107 :
4108 :
4109 :
4110 493 : fromTextMethods["basePa"] = &ExecBlockRow::basePaFromText;
4111 :
4112 :
4113 :
4114 493 : fromTextMethods["aborted"] = &ExecBlockRow::abortedFromText;
4115 :
4116 :
4117 :
4118 493 : fromTextMethods["numAntenna"] = &ExecBlockRow::numAntennaFromText;
4119 :
4120 :
4121 :
4122 493 : fromTextMethods["antennaId"] = &ExecBlockRow::antennaIdFromText;
4123 :
4124 :
4125 :
4126 493 : fromTextMethods["sBSummaryId"] = &ExecBlockRow::sBSummaryIdFromText;
4127 :
4128 :
4129 :
4130 :
4131 :
4132 493 : fromTextMethods["releaseDate"] = &ExecBlockRow::releaseDateFromText;
4133 :
4134 :
4135 :
4136 493 : fromTextMethods["schedulerMode"] = &ExecBlockRow::schedulerModeFromText;
4137 :
4138 :
4139 :
4140 493 : fromTextMethods["siteAltitude"] = &ExecBlockRow::siteAltitudeFromText;
4141 :
4142 :
4143 :
4144 493 : fromTextMethods["siteLongitude"] = &ExecBlockRow::siteLongitudeFromText;
4145 :
4146 :
4147 :
4148 493 : fromTextMethods["siteLatitude"] = &ExecBlockRow::siteLatitudeFromText;
4149 :
4150 :
4151 :
4152 493 : fromTextMethods["observingScript"] = &ExecBlockRow::observingScriptFromText;
4153 :
4154 :
4155 :
4156 :
4157 :
4158 493 : fromTextMethods["scaleId"] = &ExecBlockRow::scaleIdFromText;
4159 :
4160 :
4161 493 : }
4162 :
4163 0 : ExecBlockRow::ExecBlockRow (ExecBlockTable &t, ExecBlockRow *row) : table(t) {
4164 0 : hasBeenAdded = false;
4165 :
4166 0 : if (row == 0) {
4167 :
4168 :
4169 :
4170 :
4171 :
4172 :
4173 :
4174 :
4175 :
4176 :
4177 :
4178 :
4179 :
4180 :
4181 :
4182 :
4183 :
4184 :
4185 :
4186 :
4187 :
4188 :
4189 :
4190 :
4191 :
4192 :
4193 :
4194 :
4195 :
4196 :
4197 :
4198 :
4199 :
4200 :
4201 :
4202 :
4203 :
4204 :
4205 :
4206 :
4207 :
4208 0 : releaseDateExists = false;
4209 :
4210 :
4211 :
4212 0 : schedulerModeExists = false;
4213 :
4214 :
4215 :
4216 0 : siteAltitudeExists = false;
4217 :
4218 :
4219 :
4220 0 : siteLongitudeExists = false;
4221 :
4222 :
4223 :
4224 0 : siteLatitudeExists = false;
4225 :
4226 :
4227 :
4228 0 : observingScriptExists = false;
4229 :
4230 :
4231 :
4232 0 : observingScriptUIDExists = false;
4233 :
4234 :
4235 :
4236 :
4237 :
4238 :
4239 :
4240 :
4241 0 : scaleIdExists = false;
4242 :
4243 :
4244 : }
4245 : else {
4246 :
4247 :
4248 0 : execBlockId = row->execBlockId;
4249 :
4250 :
4251 :
4252 :
4253 0 : startTime = row->startTime;
4254 :
4255 0 : endTime = row->endTime;
4256 :
4257 0 : execBlockNum = row->execBlockNum;
4258 :
4259 0 : execBlockUID = row->execBlockUID;
4260 :
4261 0 : projectUID = row->projectUID;
4262 :
4263 0 : configName = row->configName;
4264 :
4265 0 : telescopeName = row->telescopeName;
4266 :
4267 0 : observerName = row->observerName;
4268 :
4269 0 : numObservingLog = row->numObservingLog;
4270 :
4271 0 : observingLog = row->observingLog;
4272 :
4273 0 : sessionReference = row->sessionReference;
4274 :
4275 0 : baseRangeMin = row->baseRangeMin;
4276 :
4277 0 : baseRangeMax = row->baseRangeMax;
4278 :
4279 0 : baseRmsMinor = row->baseRmsMinor;
4280 :
4281 0 : baseRmsMajor = row->baseRmsMajor;
4282 :
4283 0 : basePa = row->basePa;
4284 :
4285 0 : aborted = row->aborted;
4286 :
4287 0 : numAntenna = row->numAntenna;
4288 :
4289 0 : antennaId = row->antennaId;
4290 :
4291 0 : sBSummaryId = row->sBSummaryId;
4292 :
4293 :
4294 :
4295 :
4296 0 : if (row->releaseDateExists) {
4297 0 : releaseDate = row->releaseDate;
4298 0 : releaseDateExists = true;
4299 : }
4300 : else
4301 0 : releaseDateExists = false;
4302 :
4303 0 : if (row->schedulerModeExists) {
4304 0 : schedulerMode = row->schedulerMode;
4305 0 : schedulerModeExists = true;
4306 : }
4307 : else
4308 0 : schedulerModeExists = false;
4309 :
4310 0 : if (row->siteAltitudeExists) {
4311 0 : siteAltitude = row->siteAltitude;
4312 0 : siteAltitudeExists = true;
4313 : }
4314 : else
4315 0 : siteAltitudeExists = false;
4316 :
4317 0 : if (row->siteLongitudeExists) {
4318 0 : siteLongitude = row->siteLongitude;
4319 0 : siteLongitudeExists = true;
4320 : }
4321 : else
4322 0 : siteLongitudeExists = false;
4323 :
4324 0 : if (row->siteLatitudeExists) {
4325 0 : siteLatitude = row->siteLatitude;
4326 0 : siteLatitudeExists = true;
4327 : }
4328 : else
4329 0 : siteLatitudeExists = false;
4330 :
4331 0 : if (row->observingScriptExists) {
4332 0 : observingScript = row->observingScript;
4333 0 : observingScriptExists = true;
4334 : }
4335 : else
4336 0 : observingScriptExists = false;
4337 :
4338 0 : if (row->observingScriptUIDExists) {
4339 0 : observingScriptUID = row->observingScriptUID;
4340 0 : observingScriptUIDExists = true;
4341 : }
4342 : else
4343 0 : observingScriptUIDExists = false;
4344 :
4345 0 : if (row->scaleIdExists) {
4346 0 : scaleId = row->scaleId;
4347 0 : scaleIdExists = true;
4348 : }
4349 : else
4350 0 : scaleIdExists = false;
4351 :
4352 : }
4353 :
4354 0 : fromBinMethods["execBlockId"] = &ExecBlockRow::execBlockIdFromBin;
4355 0 : fromBinMethods["startTime"] = &ExecBlockRow::startTimeFromBin;
4356 0 : fromBinMethods["endTime"] = &ExecBlockRow::endTimeFromBin;
4357 0 : fromBinMethods["execBlockNum"] = &ExecBlockRow::execBlockNumFromBin;
4358 0 : fromBinMethods["execBlockUID"] = &ExecBlockRow::execBlockUIDFromBin;
4359 0 : fromBinMethods["projectUID"] = &ExecBlockRow::projectUIDFromBin;
4360 0 : fromBinMethods["configName"] = &ExecBlockRow::configNameFromBin;
4361 0 : fromBinMethods["telescopeName"] = &ExecBlockRow::telescopeNameFromBin;
4362 0 : fromBinMethods["observerName"] = &ExecBlockRow::observerNameFromBin;
4363 0 : fromBinMethods["numObservingLog"] = &ExecBlockRow::numObservingLogFromBin;
4364 0 : fromBinMethods["observingLog"] = &ExecBlockRow::observingLogFromBin;
4365 0 : fromBinMethods["sessionReference"] = &ExecBlockRow::sessionReferenceFromBin;
4366 0 : fromBinMethods["baseRangeMin"] = &ExecBlockRow::baseRangeMinFromBin;
4367 0 : fromBinMethods["baseRangeMax"] = &ExecBlockRow::baseRangeMaxFromBin;
4368 0 : fromBinMethods["baseRmsMinor"] = &ExecBlockRow::baseRmsMinorFromBin;
4369 0 : fromBinMethods["baseRmsMajor"] = &ExecBlockRow::baseRmsMajorFromBin;
4370 0 : fromBinMethods["basePa"] = &ExecBlockRow::basePaFromBin;
4371 0 : fromBinMethods["aborted"] = &ExecBlockRow::abortedFromBin;
4372 0 : fromBinMethods["numAntenna"] = &ExecBlockRow::numAntennaFromBin;
4373 0 : fromBinMethods["antennaId"] = &ExecBlockRow::antennaIdFromBin;
4374 0 : fromBinMethods["sBSummaryId"] = &ExecBlockRow::sBSummaryIdFromBin;
4375 :
4376 :
4377 0 : fromBinMethods["releaseDate"] = &ExecBlockRow::releaseDateFromBin;
4378 0 : fromBinMethods["schedulerMode"] = &ExecBlockRow::schedulerModeFromBin;
4379 0 : fromBinMethods["siteAltitude"] = &ExecBlockRow::siteAltitudeFromBin;
4380 0 : fromBinMethods["siteLongitude"] = &ExecBlockRow::siteLongitudeFromBin;
4381 0 : fromBinMethods["siteLatitude"] = &ExecBlockRow::siteLatitudeFromBin;
4382 0 : fromBinMethods["observingScript"] = &ExecBlockRow::observingScriptFromBin;
4383 0 : fromBinMethods["observingScriptUID"] = &ExecBlockRow::observingScriptUIDFromBin;
4384 0 : fromBinMethods["scaleId"] = &ExecBlockRow::scaleIdFromBin;
4385 :
4386 0 : }
4387 :
4388 :
4389 8661 : bool ExecBlockRow::compareNoAutoInc(ArrayTime startTime, ArrayTime endTime, int execBlockNum, EntityRef execBlockUID, EntityRef projectUID, std::string configName, std::string telescopeName, std::string observerName, int numObservingLog, std::vector<std::string > observingLog, EntityRef sessionReference, Length baseRangeMin, Length baseRangeMax, Length baseRmsMinor, Length baseRmsMajor, Angle basePa, bool aborted, int numAntenna, std::vector<Tag> antennaId, Tag sBSummaryId) {
4390 : bool result;
4391 8661 : result = true;
4392 :
4393 :
4394 :
4395 8661 : result = result && (this->startTime == startTime);
4396 :
4397 8661 : if (!result) return false;
4398 :
4399 :
4400 :
4401 :
4402 0 : result = result && (this->endTime == endTime);
4403 :
4404 0 : if (!result) return false;
4405 :
4406 :
4407 :
4408 :
4409 0 : result = result && (this->execBlockNum == execBlockNum);
4410 :
4411 0 : if (!result) return false;
4412 :
4413 :
4414 :
4415 :
4416 0 : result = result && (this->execBlockUID == execBlockUID);
4417 :
4418 0 : if (!result) return false;
4419 :
4420 :
4421 :
4422 :
4423 0 : result = result && (this->projectUID == projectUID);
4424 :
4425 0 : if (!result) return false;
4426 :
4427 :
4428 :
4429 :
4430 0 : result = result && (this->configName == configName);
4431 :
4432 0 : if (!result) return false;
4433 :
4434 :
4435 :
4436 :
4437 0 : result = result && (this->telescopeName == telescopeName);
4438 :
4439 0 : if (!result) return false;
4440 :
4441 :
4442 :
4443 :
4444 0 : result = result && (this->observerName == observerName);
4445 :
4446 0 : if (!result) return false;
4447 :
4448 :
4449 :
4450 :
4451 0 : result = result && (this->numObservingLog == numObservingLog);
4452 :
4453 0 : if (!result) return false;
4454 :
4455 :
4456 :
4457 :
4458 0 : result = result && (this->observingLog == observingLog);
4459 :
4460 0 : if (!result) return false;
4461 :
4462 :
4463 :
4464 :
4465 0 : result = result && (this->sessionReference == sessionReference);
4466 :
4467 0 : if (!result) return false;
4468 :
4469 :
4470 :
4471 :
4472 0 : result = result && (this->baseRangeMin == baseRangeMin);
4473 :
4474 0 : if (!result) return false;
4475 :
4476 :
4477 :
4478 :
4479 0 : result = result && (this->baseRangeMax == baseRangeMax);
4480 :
4481 0 : if (!result) return false;
4482 :
4483 :
4484 :
4485 :
4486 0 : result = result && (this->baseRmsMinor == baseRmsMinor);
4487 :
4488 0 : if (!result) return false;
4489 :
4490 :
4491 :
4492 :
4493 0 : result = result && (this->baseRmsMajor == baseRmsMajor);
4494 :
4495 0 : if (!result) return false;
4496 :
4497 :
4498 :
4499 :
4500 0 : result = result && (this->basePa == basePa);
4501 :
4502 0 : if (!result) return false;
4503 :
4504 :
4505 :
4506 :
4507 0 : result = result && (this->aborted == aborted);
4508 :
4509 0 : if (!result) return false;
4510 :
4511 :
4512 :
4513 :
4514 0 : result = result && (this->numAntenna == numAntenna);
4515 :
4516 0 : if (!result) return false;
4517 :
4518 :
4519 :
4520 :
4521 0 : result = result && (this->antennaId == antennaId);
4522 :
4523 0 : if (!result) return false;
4524 :
4525 :
4526 :
4527 :
4528 0 : result = result && (this->sBSummaryId == sBSummaryId);
4529 :
4530 0 : if (!result) return false;
4531 :
4532 :
4533 0 : return result;
4534 : }
4535 :
4536 :
4537 :
4538 0 : bool ExecBlockRow::compareRequiredValue(ArrayTime startTime, ArrayTime endTime, int execBlockNum, EntityRef execBlockUID, EntityRef projectUID, std::string configName, std::string telescopeName, std::string observerName, int numObservingLog, std::vector<std::string > observingLog, EntityRef sessionReference, Length baseRangeMin, Length baseRangeMax, Length baseRmsMinor, Length baseRmsMajor, Angle basePa, bool aborted, int numAntenna, std::vector<Tag> antennaId, Tag sBSummaryId) {
4539 : bool result;
4540 0 : result = true;
4541 :
4542 :
4543 0 : if (!(this->startTime == startTime)) return false;
4544 :
4545 :
4546 :
4547 0 : if (!(this->endTime == endTime)) return false;
4548 :
4549 :
4550 :
4551 0 : if (!(this->execBlockNum == execBlockNum)) return false;
4552 :
4553 :
4554 :
4555 0 : if (!(this->execBlockUID == execBlockUID)) return false;
4556 :
4557 :
4558 :
4559 0 : if (!(this->projectUID == projectUID)) return false;
4560 :
4561 :
4562 :
4563 0 : if (!(this->configName == configName)) return false;
4564 :
4565 :
4566 :
4567 0 : if (!(this->telescopeName == telescopeName)) return false;
4568 :
4569 :
4570 :
4571 0 : if (!(this->observerName == observerName)) return false;
4572 :
4573 :
4574 :
4575 0 : if (!(this->numObservingLog == numObservingLog)) return false;
4576 :
4577 :
4578 :
4579 0 : if (!(this->observingLog == observingLog)) return false;
4580 :
4581 :
4582 :
4583 0 : if (!(this->sessionReference == sessionReference)) return false;
4584 :
4585 :
4586 :
4587 0 : if (!(this->baseRangeMin == baseRangeMin)) return false;
4588 :
4589 :
4590 :
4591 0 : if (!(this->baseRangeMax == baseRangeMax)) return false;
4592 :
4593 :
4594 :
4595 0 : if (!(this->baseRmsMinor == baseRmsMinor)) return false;
4596 :
4597 :
4598 :
4599 0 : if (!(this->baseRmsMajor == baseRmsMajor)) return false;
4600 :
4601 :
4602 :
4603 0 : if (!(this->basePa == basePa)) return false;
4604 :
4605 :
4606 :
4607 0 : if (!(this->aborted == aborted)) return false;
4608 :
4609 :
4610 :
4611 0 : if (!(this->numAntenna == numAntenna)) return false;
4612 :
4613 :
4614 :
4615 0 : if (!(this->antennaId == antennaId)) return false;
4616 :
4617 :
4618 :
4619 0 : if (!(this->sBSummaryId == sBSummaryId)) return false;
4620 :
4621 :
4622 0 : return result;
4623 : }
4624 :
4625 :
4626 : /**
4627 : * Return true if all required attributes of the value part are equal to their homologues
4628 : * in x and false otherwise.
4629 : *
4630 :
4631 : * @param x a pointer on the ExecBlockRow whose required attributes of the value part
4632 :
4633 : * will be compared with those of this.
4634 : * @return a boolean.
4635 : */
4636 0 : bool ExecBlockRow::equalByRequiredValue(ExecBlockRow* x ) {
4637 :
4638 :
4639 0 : if (this->startTime != x->startTime) return false;
4640 :
4641 0 : if (this->endTime != x->endTime) return false;
4642 :
4643 0 : if (this->execBlockNum != x->execBlockNum) return false;
4644 :
4645 0 : if (this->execBlockUID != x->execBlockUID) return false;
4646 :
4647 0 : if (this->projectUID != x->projectUID) return false;
4648 :
4649 0 : if (this->configName != x->configName) return false;
4650 :
4651 0 : if (this->telescopeName != x->telescopeName) return false;
4652 :
4653 0 : if (this->observerName != x->observerName) return false;
4654 :
4655 0 : if (this->numObservingLog != x->numObservingLog) return false;
4656 :
4657 0 : if (this->observingLog != x->observingLog) return false;
4658 :
4659 0 : if (this->sessionReference != x->sessionReference) return false;
4660 :
4661 0 : if (this->baseRangeMin != x->baseRangeMin) return false;
4662 :
4663 0 : if (this->baseRangeMax != x->baseRangeMax) return false;
4664 :
4665 0 : if (this->baseRmsMinor != x->baseRmsMinor) return false;
4666 :
4667 0 : if (this->baseRmsMajor != x->baseRmsMajor) return false;
4668 :
4669 0 : if (this->basePa != x->basePa) return false;
4670 :
4671 0 : if (this->aborted != x->aborted) return false;
4672 :
4673 0 : if (this->numAntenna != x->numAntenna) return false;
4674 :
4675 0 : if (this->antennaId != x->antennaId) return false;
4676 :
4677 0 : if (this->sBSummaryId != x->sBSummaryId) return false;
4678 :
4679 :
4680 0 : return true;
4681 : }
4682 :
4683 : /*
4684 : map<string, ExecBlockAttributeFromBin> ExecBlockRow::initFromBinMethods() {
4685 : map<string, ExecBlockAttributeFromBin> result;
4686 :
4687 : result["execBlockId"] = &ExecBlockRow::execBlockIdFromBin;
4688 : result["startTime"] = &ExecBlockRow::startTimeFromBin;
4689 : result["endTime"] = &ExecBlockRow::endTimeFromBin;
4690 : result["execBlockNum"] = &ExecBlockRow::execBlockNumFromBin;
4691 : result["execBlockUID"] = &ExecBlockRow::execBlockUIDFromBin;
4692 : result["projectUID"] = &ExecBlockRow::projectUIDFromBin;
4693 : result["configName"] = &ExecBlockRow::configNameFromBin;
4694 : result["telescopeName"] = &ExecBlockRow::telescopeNameFromBin;
4695 : result["observerName"] = &ExecBlockRow::observerNameFromBin;
4696 : result["numObservingLog"] = &ExecBlockRow::numObservingLogFromBin;
4697 : result["observingLog"] = &ExecBlockRow::observingLogFromBin;
4698 : result["sessionReference"] = &ExecBlockRow::sessionReferenceFromBin;
4699 : result["baseRangeMin"] = &ExecBlockRow::baseRangeMinFromBin;
4700 : result["baseRangeMax"] = &ExecBlockRow::baseRangeMaxFromBin;
4701 : result["baseRmsMinor"] = &ExecBlockRow::baseRmsMinorFromBin;
4702 : result["baseRmsMajor"] = &ExecBlockRow::baseRmsMajorFromBin;
4703 : result["basePa"] = &ExecBlockRow::basePaFromBin;
4704 : result["aborted"] = &ExecBlockRow::abortedFromBin;
4705 : result["numAntenna"] = &ExecBlockRow::numAntennaFromBin;
4706 : result["antennaId"] = &ExecBlockRow::antennaIdFromBin;
4707 : result["sBSummaryId"] = &ExecBlockRow::sBSummaryIdFromBin;
4708 :
4709 :
4710 : result["releaseDate"] = &ExecBlockRow::releaseDateFromBin;
4711 : result["schedulerMode"] = &ExecBlockRow::schedulerModeFromBin;
4712 : result["siteAltitude"] = &ExecBlockRow::siteAltitudeFromBin;
4713 : result["siteLongitude"] = &ExecBlockRow::siteLongitudeFromBin;
4714 : result["siteLatitude"] = &ExecBlockRow::siteLatitudeFromBin;
4715 : result["observingScript"] = &ExecBlockRow::observingScriptFromBin;
4716 : result["observingScriptUID"] = &ExecBlockRow::observingScriptUIDFromBin;
4717 : result["scaleId"] = &ExecBlockRow::scaleIdFromBin;
4718 :
4719 :
4720 : return result;
4721 : }
4722 : */
4723 : } // End namespace asdm
4724 :
|
