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