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