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