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 CalReductionRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/CalReductionRow.h>
39 : #include <alma/ASDM/CalReductionTable.h>
40 :
41 :
42 : using asdm::ASDM;
43 : using asdm::CalReductionRow;
44 : using asdm::CalReductionTable;
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 : CalReductionRow::~CalReductionRow() {
58 0 : }
59 :
60 : /**
61 : * Return the table to which this row belongs.
62 : */
63 0 : CalReductionTable &CalReductionRow::getTable() const {
64 0 : return table;
65 : }
66 :
67 0 : bool CalReductionRow::isAdded() const {
68 0 : return hasBeenAdded;
69 : }
70 :
71 0 : void CalReductionRow::isAdded(bool added) {
72 0 : hasBeenAdded = added;
73 0 : }
74 :
75 : #ifndef WITHOUT_ACS
76 : using asdmIDL::CalReductionRowIDL;
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 CalReductionRowIDL struct.
83 : */
84 : CalReductionRowIDL *CalReductionRow::toIDL() const {
85 : CalReductionRowIDL *x = new CalReductionRowIDL ();
86 :
87 : // Fill the IDL structure.
88 :
89 :
90 :
91 :
92 :
93 :
94 :
95 : x->calReductionId = calReductionId.toIDLTag();
96 :
97 :
98 :
99 :
100 :
101 :
102 :
103 :
104 :
105 :
106 : x->numApplied = numApplied;
107 :
108 :
109 :
110 :
111 :
112 :
113 :
114 :
115 :
116 :
117 : x->appliedCalibrations.length(appliedCalibrations.size());
118 : for (unsigned int i = 0; i < appliedCalibrations.size(); ++i) {
119 :
120 :
121 : x->appliedCalibrations[i] = CORBA::string_dup(appliedCalibrations.at(i).c_str());
122 :
123 :
124 : }
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 :
135 : x->numParam = numParam;
136 :
137 :
138 :
139 :
140 :
141 :
142 :
143 :
144 :
145 :
146 : x->paramSet.length(paramSet.size());
147 : for (unsigned int i = 0; i < paramSet.size(); ++i) {
148 :
149 :
150 : x->paramSet[i] = CORBA::string_dup(paramSet.at(i).c_str());
151 :
152 :
153 : }
154 :
155 :
156 :
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 : x->numInvalidConditions = numInvalidConditions;
165 :
166 :
167 :
168 :
169 :
170 :
171 :
172 :
173 :
174 :
175 : x->invalidConditions.length(invalidConditions.size());
176 : for (unsigned int i = 0; i < invalidConditions.size(); ++i) {
177 :
178 :
179 : x->invalidConditions[i] = invalidConditions.at(i);
180 :
181 :
182 : }
183 :
184 :
185 :
186 :
187 :
188 :
189 :
190 :
191 :
192 : x->timeReduced = timeReduced.toIDLArrayTime();
193 :
194 :
195 :
196 :
197 :
198 :
199 :
200 :
201 :
202 :
203 : x->messages = CORBA::string_dup(messages.c_str());
204 :
205 :
206 :
207 :
208 :
209 :
210 :
211 :
212 :
213 :
214 :
215 : x->software = CORBA::string_dup(software.c_str());
216 :
217 :
218 :
219 :
220 :
221 :
222 :
223 :
224 :
225 :
226 :
227 : x->softwareVersion = CORBA::string_dup(softwareVersion.c_str());
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 :
236 :
237 : return x;
238 :
239 : }
240 :
241 : void CalReductionRow::toIDL(asdmIDL::CalReductionRowIDL& x) const {
242 : // Set the x's fields.
243 :
244 :
245 :
246 :
247 :
248 :
249 :
250 : x.calReductionId = calReductionId.toIDLTag();
251 :
252 :
253 :
254 :
255 :
256 :
257 :
258 :
259 :
260 :
261 : x.numApplied = numApplied;
262 :
263 :
264 :
265 :
266 :
267 :
268 :
269 :
270 :
271 :
272 : x.appliedCalibrations.length(appliedCalibrations.size());
273 : for (unsigned int i = 0; i < appliedCalibrations.size(); ++i) {
274 :
275 :
276 : x.appliedCalibrations[i] = CORBA::string_dup(appliedCalibrations.at(i).c_str());
277 :
278 :
279 : }
280 :
281 :
282 :
283 :
284 :
285 :
286 :
287 :
288 :
289 :
290 : x.numParam = numParam;
291 :
292 :
293 :
294 :
295 :
296 :
297 :
298 :
299 :
300 :
301 : x.paramSet.length(paramSet.size());
302 : for (unsigned int i = 0; i < paramSet.size(); ++i) {
303 :
304 :
305 : x.paramSet[i] = CORBA::string_dup(paramSet.at(i).c_str());
306 :
307 :
308 : }
309 :
310 :
311 :
312 :
313 :
314 :
315 :
316 :
317 :
318 :
319 : x.numInvalidConditions = numInvalidConditions;
320 :
321 :
322 :
323 :
324 :
325 :
326 :
327 :
328 :
329 :
330 : x.invalidConditions.length(invalidConditions.size());
331 : for (unsigned int i = 0; i < invalidConditions.size(); ++i) {
332 :
333 :
334 : x.invalidConditions[i] = invalidConditions.at(i);
335 :
336 :
337 : }
338 :
339 :
340 :
341 :
342 :
343 :
344 :
345 :
346 :
347 : x.timeReduced = timeReduced.toIDLArrayTime();
348 :
349 :
350 :
351 :
352 :
353 :
354 :
355 :
356 :
357 :
358 : x.messages = CORBA::string_dup(messages.c_str());
359 :
360 :
361 :
362 :
363 :
364 :
365 :
366 :
367 :
368 :
369 :
370 : x.software = CORBA::string_dup(software.c_str());
371 :
372 :
373 :
374 :
375 :
376 :
377 :
378 :
379 :
380 :
381 :
382 : x.softwareVersion = CORBA::string_dup(softwareVersion.c_str());
383 :
384 :
385 :
386 :
387 :
388 :
389 :
390 :
391 :
392 : }
393 : #endif
394 :
395 :
396 : #ifndef WITHOUT_ACS
397 : /**
398 : * Fill the values of this row from the IDL struct CalReductionRowIDL.
399 : * @param x The IDL struct containing the values used to fill this row.
400 : */
401 : void CalReductionRow::setFromIDL (CalReductionRowIDL x){
402 : try {
403 : // Fill the values from x.
404 :
405 :
406 :
407 :
408 :
409 :
410 : setCalReductionId(Tag (x.calReductionId));
411 :
412 :
413 :
414 :
415 :
416 :
417 :
418 :
419 :
420 : setNumApplied(x.numApplied);
421 :
422 :
423 :
424 :
425 :
426 :
427 :
428 :
429 :
430 : appliedCalibrations .clear();
431 : for (unsigned int i = 0; i <x.appliedCalibrations.length(); ++i) {
432 :
433 : appliedCalibrations.push_back(string (x.appliedCalibrations[i]));
434 :
435 : }
436 :
437 :
438 :
439 :
440 :
441 :
442 :
443 :
444 :
445 : setNumParam(x.numParam);
446 :
447 :
448 :
449 :
450 :
451 :
452 :
453 :
454 :
455 : paramSet .clear();
456 : for (unsigned int i = 0; i <x.paramSet.length(); ++i) {
457 :
458 : paramSet.push_back(string (x.paramSet[i]));
459 :
460 : }
461 :
462 :
463 :
464 :
465 :
466 :
467 :
468 :
469 :
470 : setNumInvalidConditions(x.numInvalidConditions);
471 :
472 :
473 :
474 :
475 :
476 :
477 :
478 :
479 :
480 : invalidConditions .clear();
481 : for (unsigned int i = 0; i <x.invalidConditions.length(); ++i) {
482 :
483 : invalidConditions.push_back(x.invalidConditions[i]);
484 :
485 : }
486 :
487 :
488 :
489 :
490 :
491 :
492 :
493 :
494 :
495 : setTimeReduced(ArrayTime (x.timeReduced));
496 :
497 :
498 :
499 :
500 :
501 :
502 :
503 :
504 :
505 : setMessages(string (x.messages));
506 :
507 :
508 :
509 :
510 :
511 :
512 :
513 :
514 :
515 : setSoftware(string (x.software));
516 :
517 :
518 :
519 :
520 :
521 :
522 :
523 :
524 :
525 : setSoftwareVersion(string (x.softwareVersion));
526 :
527 :
528 :
529 :
530 :
531 :
532 :
533 :
534 : } catch (const IllegalAccessException &err) {
535 : throw ConversionException (err.getMessage(),"CalReduction");
536 : }
537 : }
538 : #endif
539 :
540 : /**
541 : * Return this row in the form of an XML string.
542 : * @return The values of this row as an XML string.
543 : */
544 0 : string CalReductionRow::toXML() const {
545 0 : string buf;
546 0 : buf.append("<row> \n");
547 :
548 :
549 :
550 :
551 :
552 :
553 0 : Parser::toXML(calReductionId, "calReductionId", buf);
554 :
555 :
556 :
557 :
558 :
559 :
560 :
561 0 : Parser::toXML(numApplied, "numApplied", buf);
562 :
563 :
564 :
565 :
566 :
567 :
568 :
569 0 : Parser::toXML(appliedCalibrations, "appliedCalibrations", buf);
570 :
571 :
572 :
573 :
574 :
575 :
576 :
577 0 : Parser::toXML(numParam, "numParam", buf);
578 :
579 :
580 :
581 :
582 :
583 :
584 :
585 0 : Parser::toXML(paramSet, "paramSet", buf);
586 :
587 :
588 :
589 :
590 :
591 :
592 :
593 0 : Parser::toXML(numInvalidConditions, "numInvalidConditions", buf);
594 :
595 :
596 :
597 :
598 :
599 :
600 :
601 0 : buf.append(EnumerationParser::toXML("invalidConditions", invalidConditions));
602 :
603 :
604 :
605 :
606 :
607 :
608 :
609 0 : Parser::toXML(timeReduced, "timeReduced", buf);
610 :
611 :
612 :
613 :
614 :
615 :
616 :
617 0 : Parser::toXML(messages, "messages", buf);
618 :
619 :
620 :
621 :
622 :
623 :
624 :
625 0 : Parser::toXML(software, "software", buf);
626 :
627 :
628 :
629 :
630 :
631 :
632 :
633 0 : Parser::toXML(softwareVersion, "softwareVersion", buf);
634 :
635 :
636 :
637 :
638 :
639 :
640 :
641 :
642 0 : buf.append("</row>\n");
643 0 : return buf;
644 0 : }
645 :
646 : /**
647 : * Fill the values of this row from an XML string
648 : * that was produced by the toXML() method.
649 : * @param x The XML string being used to set the values of this row.
650 : */
651 0 : void CalReductionRow::setFromXML (string rowDoc) {
652 0 : Parser row(rowDoc);
653 0 : string s = "";
654 : try {
655 :
656 :
657 :
658 :
659 :
660 0 : setCalReductionId(Parser::getTag("calReductionId","CalReduction",rowDoc));
661 :
662 :
663 :
664 :
665 :
666 :
667 :
668 0 : setNumApplied(Parser::getInteger("numApplied","CalReduction",rowDoc));
669 :
670 :
671 :
672 :
673 :
674 :
675 :
676 :
677 0 : setAppliedCalibrations(Parser::get1DString("appliedCalibrations","CalReduction",rowDoc));
678 :
679 :
680 :
681 :
682 :
683 :
684 :
685 :
686 0 : setNumParam(Parser::getInteger("numParam","CalReduction",rowDoc));
687 :
688 :
689 :
690 :
691 :
692 :
693 :
694 :
695 0 : setParamSet(Parser::get1DString("paramSet","CalReduction",rowDoc));
696 :
697 :
698 :
699 :
700 :
701 :
702 :
703 :
704 0 : setNumInvalidConditions(Parser::getInteger("numInvalidConditions","CalReduction",rowDoc));
705 :
706 :
707 :
708 :
709 :
710 :
711 :
712 :
713 0 : invalidConditions = EnumerationParser::getInvalidatingCondition1D("invalidConditions","CalReduction",rowDoc);
714 :
715 :
716 :
717 :
718 :
719 :
720 :
721 :
722 0 : setTimeReduced(Parser::getArrayTime("timeReduced","CalReduction",rowDoc));
723 :
724 :
725 :
726 :
727 :
728 :
729 :
730 0 : setMessages(Parser::getString("messages","CalReduction",rowDoc));
731 :
732 :
733 :
734 :
735 :
736 :
737 :
738 0 : setSoftware(Parser::getString("software","CalReduction",rowDoc));
739 :
740 :
741 :
742 :
743 :
744 :
745 :
746 0 : setSoftwareVersion(Parser::getString("softwareVersion","CalReduction",rowDoc));
747 :
748 :
749 :
750 :
751 :
752 :
753 :
754 0 : } catch (const IllegalAccessException &err) {
755 0 : throw ConversionException (err.getMessage(),"CalReduction");
756 0 : }
757 0 : }
758 :
759 0 : void CalReductionRow::toBin(EndianOSStream& eoss) {
760 :
761 :
762 :
763 :
764 :
765 0 : calReductionId.toBin(eoss);
766 :
767 :
768 :
769 :
770 :
771 :
772 :
773 0 : eoss.writeInt(numApplied);
774 :
775 :
776 :
777 :
778 :
779 :
780 :
781 :
782 :
783 0 : eoss.writeInt((int) appliedCalibrations.size());
784 0 : for (unsigned int i = 0; i < appliedCalibrations.size(); i++)
785 :
786 0 : eoss.writeString(appliedCalibrations.at(i));
787 :
788 :
789 :
790 :
791 :
792 :
793 :
794 :
795 :
796 :
797 0 : eoss.writeInt(numParam);
798 :
799 :
800 :
801 :
802 :
803 :
804 :
805 :
806 :
807 0 : eoss.writeInt((int) paramSet.size());
808 0 : for (unsigned int i = 0; i < paramSet.size(); i++)
809 :
810 0 : eoss.writeString(paramSet.at(i));
811 :
812 :
813 :
814 :
815 :
816 :
817 :
818 :
819 :
820 :
821 0 : eoss.writeInt(numInvalidConditions);
822 :
823 :
824 :
825 :
826 :
827 :
828 :
829 :
830 :
831 0 : eoss.writeInt((int) invalidConditions.size());
832 0 : for (unsigned int i = 0; i < invalidConditions.size(); i++)
833 :
834 0 : eoss.writeString(CInvalidatingCondition::name(invalidConditions.at(i)));
835 : /* eoss.writeInt(invalidConditions.at(i)); */
836 :
837 :
838 :
839 :
840 :
841 :
842 :
843 :
844 :
845 0 : timeReduced.toBin(eoss);
846 :
847 :
848 :
849 :
850 :
851 :
852 :
853 0 : eoss.writeString(messages);
854 :
855 :
856 :
857 :
858 :
859 :
860 :
861 :
862 0 : eoss.writeString(software);
863 :
864 :
865 :
866 :
867 :
868 :
869 :
870 :
871 0 : eoss.writeString(softwareVersion);
872 :
873 :
874 :
875 :
876 :
877 :
878 :
879 0 : }
880 :
881 0 : void CalReductionRow::calReductionIdFromBin(EndianIStream& eis) {
882 :
883 :
884 :
885 :
886 0 : calReductionId = Tag::fromBin(eis);
887 :
888 :
889 :
890 0 : }
891 0 : void CalReductionRow::numAppliedFromBin(EndianIStream& eis) {
892 :
893 :
894 :
895 :
896 :
897 0 : numApplied = eis.readInt();
898 :
899 :
900 :
901 :
902 0 : }
903 0 : void CalReductionRow::appliedCalibrationsFromBin(EndianIStream& eis) {
904 :
905 :
906 :
907 :
908 :
909 :
910 0 : appliedCalibrations.clear();
911 :
912 0 : unsigned int appliedCalibrationsDim1 = eis.readInt();
913 0 : for (unsigned int i = 0 ; i < appliedCalibrationsDim1; i++)
914 :
915 0 : appliedCalibrations.push_back(eis.readString());
916 :
917 :
918 :
919 :
920 :
921 :
922 0 : }
923 0 : void CalReductionRow::numParamFromBin(EndianIStream& eis) {
924 :
925 :
926 :
927 :
928 :
929 0 : numParam = eis.readInt();
930 :
931 :
932 :
933 :
934 0 : }
935 0 : void CalReductionRow::paramSetFromBin(EndianIStream& eis) {
936 :
937 :
938 :
939 :
940 :
941 :
942 0 : paramSet.clear();
943 :
944 0 : unsigned int paramSetDim1 = eis.readInt();
945 0 : for (unsigned int i = 0 ; i < paramSetDim1; i++)
946 :
947 0 : paramSet.push_back(eis.readString());
948 :
949 :
950 :
951 :
952 :
953 :
954 0 : }
955 0 : void CalReductionRow::numInvalidConditionsFromBin(EndianIStream& eis) {
956 :
957 :
958 :
959 :
960 :
961 0 : numInvalidConditions = eis.readInt();
962 :
963 :
964 :
965 :
966 0 : }
967 0 : void CalReductionRow::invalidConditionsFromBin(EndianIStream& eis) {
968 :
969 :
970 :
971 :
972 :
973 :
974 0 : invalidConditions.clear();
975 :
976 0 : unsigned int invalidConditionsDim1 = eis.readInt();
977 0 : for (unsigned int i = 0 ; i < invalidConditionsDim1; i++)
978 :
979 0 : invalidConditions.push_back(CInvalidatingCondition::literal(eis.readString()));
980 :
981 :
982 :
983 :
984 :
985 :
986 0 : }
987 0 : void CalReductionRow::timeReducedFromBin(EndianIStream& eis) {
988 :
989 :
990 :
991 :
992 0 : timeReduced = ArrayTime::fromBin(eis);
993 :
994 :
995 :
996 0 : }
997 0 : void CalReductionRow::messagesFromBin(EndianIStream& eis) {
998 :
999 :
1000 :
1001 :
1002 :
1003 0 : messages = eis.readString();
1004 :
1005 :
1006 :
1007 :
1008 0 : }
1009 0 : void CalReductionRow::softwareFromBin(EndianIStream& eis) {
1010 :
1011 :
1012 :
1013 :
1014 :
1015 0 : software = eis.readString();
1016 :
1017 :
1018 :
1019 :
1020 0 : }
1021 0 : void CalReductionRow::softwareVersionFromBin(EndianIStream& eis) {
1022 :
1023 :
1024 :
1025 :
1026 :
1027 0 : softwareVersion = eis.readString();
1028 :
1029 :
1030 :
1031 :
1032 0 : }
1033 :
1034 :
1035 :
1036 0 : CalReductionRow* CalReductionRow::fromBin(EndianIStream& eis, CalReductionTable& table, const vector<string>& attributesSeq) {
1037 0 : CalReductionRow* row = new CalReductionRow(table);
1038 :
1039 0 : map<string, CalReductionAttributeFromBin>::iterator iter ;
1040 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
1041 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
1042 0 : if (iter != row->fromBinMethods.end()) {
1043 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
1044 : }
1045 : else {
1046 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
1047 0 : if (functorP)
1048 0 : (*functorP)(eis);
1049 : else
1050 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "CalReductionTable");
1051 : }
1052 :
1053 : }
1054 0 : return row;
1055 : }
1056 :
1057 : //
1058 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
1059 : // of one row.
1060 : //
1061 :
1062 : // Convert a string into an Tag
1063 0 : void CalReductionRow::calReductionIdFromText(const string & s) {
1064 :
1065 :
1066 0 : calReductionId = ASDMValuesParser::parse<Tag>(s);
1067 :
1068 :
1069 0 : }
1070 :
1071 :
1072 : // Convert a string into an int
1073 0 : void CalReductionRow::numAppliedFromText(const string & s) {
1074 :
1075 :
1076 0 : numApplied = ASDMValuesParser::parse<int>(s);
1077 :
1078 :
1079 0 : }
1080 :
1081 :
1082 : // Convert a string into an String
1083 0 : void CalReductionRow::appliedCalibrationsFromText(const string & s) {
1084 :
1085 :
1086 0 : appliedCalibrations = ASDMValuesParser::parse1D<string>(s);
1087 :
1088 :
1089 0 : }
1090 :
1091 :
1092 : // Convert a string into an int
1093 0 : void CalReductionRow::numParamFromText(const string & s) {
1094 :
1095 :
1096 0 : numParam = ASDMValuesParser::parse<int>(s);
1097 :
1098 :
1099 0 : }
1100 :
1101 :
1102 : // Convert a string into an String
1103 0 : void CalReductionRow::paramSetFromText(const string & s) {
1104 :
1105 :
1106 0 : paramSet = ASDMValuesParser::parse1D<string>(s);
1107 :
1108 :
1109 0 : }
1110 :
1111 :
1112 : // Convert a string into an int
1113 0 : void CalReductionRow::numInvalidConditionsFromText(const string & s) {
1114 :
1115 :
1116 0 : numInvalidConditions = ASDMValuesParser::parse<int>(s);
1117 :
1118 :
1119 0 : }
1120 :
1121 :
1122 : // Convert a string into an InvalidatingCondition
1123 0 : void CalReductionRow::invalidConditionsFromText(const string & s) {
1124 :
1125 :
1126 0 : invalidConditions = ASDMValuesParser::parse1D<InvalidatingConditionMod::InvalidatingCondition>(s);
1127 :
1128 :
1129 0 : }
1130 :
1131 :
1132 : // Convert a string into an ArrayTime
1133 0 : void CalReductionRow::timeReducedFromText(const string & s) {
1134 :
1135 :
1136 0 : timeReduced = ASDMValuesParser::parse<ArrayTime>(s);
1137 :
1138 :
1139 0 : }
1140 :
1141 :
1142 : // Convert a string into an String
1143 0 : void CalReductionRow::messagesFromText(const string & s) {
1144 :
1145 :
1146 0 : messages = ASDMValuesParser::parse<string>(s);
1147 :
1148 :
1149 0 : }
1150 :
1151 :
1152 : // Convert a string into an String
1153 0 : void CalReductionRow::softwareFromText(const string & s) {
1154 :
1155 :
1156 0 : software = ASDMValuesParser::parse<string>(s);
1157 :
1158 :
1159 0 : }
1160 :
1161 :
1162 : // Convert a string into an String
1163 0 : void CalReductionRow::softwareVersionFromText(const string & s) {
1164 :
1165 :
1166 0 : softwareVersion = ASDMValuesParser::parse<string>(s);
1167 :
1168 :
1169 0 : }
1170 :
1171 :
1172 :
1173 :
1174 0 : void CalReductionRow::fromText(const std::string& attributeName, const std::string& t) {
1175 0 : map<string, CalReductionAttributeFromText>::iterator iter;
1176 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
1177 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "CalReductionTable");
1178 0 : (this->*(iter->second))(t);
1179 0 : }
1180 :
1181 : ////////////////////////////////////////////////
1182 : // Intrinsic Table Attributes getters/setters //
1183 : ////////////////////////////////////////////////
1184 :
1185 :
1186 :
1187 :
1188 : /**
1189 : * Get calReductionId.
1190 : * @return calReductionId as Tag
1191 : */
1192 0 : Tag CalReductionRow::getCalReductionId() const {
1193 :
1194 0 : return calReductionId;
1195 : }
1196 :
1197 : /**
1198 : * Set calReductionId with the specified Tag.
1199 : * @param calReductionId The Tag value to which calReductionId is to be set.
1200 :
1201 :
1202 :
1203 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1204 :
1205 : */
1206 0 : void CalReductionRow::setCalReductionId (Tag calReductionId) {
1207 :
1208 :
1209 0 : if (hasBeenAdded) {
1210 :
1211 0 : throw IllegalAccessException("calReductionId", "CalReduction");
1212 :
1213 : }
1214 :
1215 0 : this->calReductionId = calReductionId;
1216 :
1217 0 : }
1218 :
1219 :
1220 :
1221 :
1222 :
1223 :
1224 : /**
1225 : * Get numApplied.
1226 : * @return numApplied as int
1227 : */
1228 0 : int CalReductionRow::getNumApplied() const {
1229 :
1230 0 : return numApplied;
1231 : }
1232 :
1233 : /**
1234 : * Set numApplied with the specified int.
1235 : * @param numApplied The int value to which numApplied is to be set.
1236 :
1237 :
1238 :
1239 : */
1240 0 : void CalReductionRow::setNumApplied (int numApplied) {
1241 :
1242 :
1243 0 : if (hasBeenAdded) {
1244 :
1245 : }
1246 :
1247 0 : this->numApplied = numApplied;
1248 :
1249 0 : }
1250 :
1251 :
1252 :
1253 :
1254 :
1255 :
1256 : /**
1257 : * Get appliedCalibrations.
1258 : * @return appliedCalibrations as std::vector<std::string >
1259 : */
1260 0 : std::vector<std::string > CalReductionRow::getAppliedCalibrations() const {
1261 :
1262 0 : return appliedCalibrations;
1263 : }
1264 :
1265 : /**
1266 : * Set appliedCalibrations with the specified std::vector<std::string >.
1267 : * @param appliedCalibrations The std::vector<std::string > value to which appliedCalibrations is to be set.
1268 :
1269 :
1270 :
1271 : */
1272 0 : void CalReductionRow::setAppliedCalibrations (std::vector<std::string > appliedCalibrations) {
1273 :
1274 :
1275 0 : if (hasBeenAdded) {
1276 :
1277 : }
1278 :
1279 0 : this->appliedCalibrations = appliedCalibrations;
1280 :
1281 0 : }
1282 :
1283 :
1284 :
1285 :
1286 :
1287 :
1288 : /**
1289 : * Get numParam.
1290 : * @return numParam as int
1291 : */
1292 0 : int CalReductionRow::getNumParam() const {
1293 :
1294 0 : return numParam;
1295 : }
1296 :
1297 : /**
1298 : * Set numParam with the specified int.
1299 : * @param numParam The int value to which numParam is to be set.
1300 :
1301 :
1302 :
1303 : */
1304 0 : void CalReductionRow::setNumParam (int numParam) {
1305 :
1306 :
1307 0 : if (hasBeenAdded) {
1308 :
1309 : }
1310 :
1311 0 : this->numParam = numParam;
1312 :
1313 0 : }
1314 :
1315 :
1316 :
1317 :
1318 :
1319 :
1320 : /**
1321 : * Get paramSet.
1322 : * @return paramSet as std::vector<std::string >
1323 : */
1324 0 : std::vector<std::string > CalReductionRow::getParamSet() const {
1325 :
1326 0 : return paramSet;
1327 : }
1328 :
1329 : /**
1330 : * Set paramSet with the specified std::vector<std::string >.
1331 : * @param paramSet The std::vector<std::string > value to which paramSet is to be set.
1332 :
1333 :
1334 :
1335 : */
1336 0 : void CalReductionRow::setParamSet (std::vector<std::string > paramSet) {
1337 :
1338 :
1339 0 : if (hasBeenAdded) {
1340 :
1341 : }
1342 :
1343 0 : this->paramSet = paramSet;
1344 :
1345 0 : }
1346 :
1347 :
1348 :
1349 :
1350 :
1351 :
1352 : /**
1353 : * Get numInvalidConditions.
1354 : * @return numInvalidConditions as int
1355 : */
1356 0 : int CalReductionRow::getNumInvalidConditions() const {
1357 :
1358 0 : return numInvalidConditions;
1359 : }
1360 :
1361 : /**
1362 : * Set numInvalidConditions with the specified int.
1363 : * @param numInvalidConditions The int value to which numInvalidConditions is to be set.
1364 :
1365 :
1366 :
1367 : */
1368 0 : void CalReductionRow::setNumInvalidConditions (int numInvalidConditions) {
1369 :
1370 :
1371 0 : if (hasBeenAdded) {
1372 :
1373 : }
1374 :
1375 0 : this->numInvalidConditions = numInvalidConditions;
1376 :
1377 0 : }
1378 :
1379 :
1380 :
1381 :
1382 :
1383 :
1384 : /**
1385 : * Get invalidConditions.
1386 : * @return invalidConditions as std::vector<InvalidatingConditionMod::InvalidatingCondition >
1387 : */
1388 0 : std::vector<InvalidatingConditionMod::InvalidatingCondition > CalReductionRow::getInvalidConditions() const {
1389 :
1390 0 : return invalidConditions;
1391 : }
1392 :
1393 : /**
1394 : * Set invalidConditions with the specified std::vector<InvalidatingConditionMod::InvalidatingCondition >.
1395 : * @param invalidConditions The std::vector<InvalidatingConditionMod::InvalidatingCondition > value to which invalidConditions is to be set.
1396 :
1397 :
1398 :
1399 : */
1400 0 : void CalReductionRow::setInvalidConditions (std::vector<InvalidatingConditionMod::InvalidatingCondition > invalidConditions) {
1401 :
1402 :
1403 0 : if (hasBeenAdded) {
1404 :
1405 : }
1406 :
1407 0 : this->invalidConditions = invalidConditions;
1408 :
1409 0 : }
1410 :
1411 :
1412 :
1413 :
1414 :
1415 :
1416 : /**
1417 : * Get timeReduced.
1418 : * @return timeReduced as ArrayTime
1419 : */
1420 0 : ArrayTime CalReductionRow::getTimeReduced() const {
1421 :
1422 0 : return timeReduced;
1423 : }
1424 :
1425 : /**
1426 : * Set timeReduced with the specified ArrayTime.
1427 : * @param timeReduced The ArrayTime value to which timeReduced is to be set.
1428 :
1429 :
1430 :
1431 : */
1432 0 : void CalReductionRow::setTimeReduced (ArrayTime timeReduced) {
1433 :
1434 :
1435 0 : if (hasBeenAdded) {
1436 :
1437 : }
1438 :
1439 0 : this->timeReduced = timeReduced;
1440 :
1441 0 : }
1442 :
1443 :
1444 :
1445 :
1446 :
1447 :
1448 : /**
1449 : * Get messages.
1450 : * @return messages as std::string
1451 : */
1452 0 : std::string CalReductionRow::getMessages() const {
1453 :
1454 0 : return messages;
1455 : }
1456 :
1457 : /**
1458 : * Set messages with the specified std::string.
1459 : * @param messages The std::string value to which messages is to be set.
1460 :
1461 :
1462 :
1463 : */
1464 0 : void CalReductionRow::setMessages (std::string messages) {
1465 :
1466 :
1467 0 : if (hasBeenAdded) {
1468 :
1469 : }
1470 :
1471 0 : this->messages = messages;
1472 :
1473 0 : }
1474 :
1475 :
1476 :
1477 :
1478 :
1479 :
1480 : /**
1481 : * Get software.
1482 : * @return software as std::string
1483 : */
1484 0 : std::string CalReductionRow::getSoftware() const {
1485 :
1486 0 : return software;
1487 : }
1488 :
1489 : /**
1490 : * Set software with the specified std::string.
1491 : * @param software The std::string value to which software is to be set.
1492 :
1493 :
1494 :
1495 : */
1496 0 : void CalReductionRow::setSoftware (std::string software) {
1497 :
1498 :
1499 0 : if (hasBeenAdded) {
1500 :
1501 : }
1502 :
1503 0 : this->software = software;
1504 :
1505 0 : }
1506 :
1507 :
1508 :
1509 :
1510 :
1511 :
1512 : /**
1513 : * Get softwareVersion.
1514 : * @return softwareVersion as std::string
1515 : */
1516 0 : std::string CalReductionRow::getSoftwareVersion() const {
1517 :
1518 0 : return softwareVersion;
1519 : }
1520 :
1521 : /**
1522 : * Set softwareVersion with the specified std::string.
1523 : * @param softwareVersion The std::string value to which softwareVersion is to be set.
1524 :
1525 :
1526 :
1527 : */
1528 0 : void CalReductionRow::setSoftwareVersion (std::string softwareVersion) {
1529 :
1530 :
1531 0 : if (hasBeenAdded) {
1532 :
1533 : }
1534 :
1535 0 : this->softwareVersion = softwareVersion;
1536 :
1537 0 : }
1538 :
1539 :
1540 :
1541 :
1542 : ///////////////////////////////////////////////
1543 : // Extrinsic Table Attributes getters/setters//
1544 : ///////////////////////////////////////////////
1545 :
1546 :
1547 : //////////////////////////////////////
1548 : // Links Attributes getters/setters //
1549 : //////////////////////////////////////
1550 :
1551 :
1552 : /**
1553 : * Create a CalReductionRow.
1554 : * <p>
1555 : * This constructor is private because only the
1556 : * table can create rows. All rows know the table
1557 : * to which they belong.
1558 : * @param table The table to which this row belongs.
1559 : */
1560 0 : CalReductionRow::CalReductionRow (CalReductionTable &t) : table(t) {
1561 0 : hasBeenAdded = false;
1562 :
1563 :
1564 :
1565 :
1566 :
1567 :
1568 :
1569 :
1570 :
1571 :
1572 :
1573 :
1574 :
1575 :
1576 :
1577 :
1578 :
1579 :
1580 :
1581 :
1582 :
1583 :
1584 :
1585 :
1586 :
1587 :
1588 :
1589 :
1590 :
1591 :
1592 :
1593 :
1594 :
1595 :
1596 :
1597 :
1598 :
1599 :
1600 :
1601 :
1602 :
1603 :
1604 :
1605 :
1606 :
1607 :
1608 :
1609 :
1610 :
1611 :
1612 :
1613 :
1614 0 : fromBinMethods["calReductionId"] = &CalReductionRow::calReductionIdFromBin;
1615 0 : fromBinMethods["numApplied"] = &CalReductionRow::numAppliedFromBin;
1616 0 : fromBinMethods["appliedCalibrations"] = &CalReductionRow::appliedCalibrationsFromBin;
1617 0 : fromBinMethods["numParam"] = &CalReductionRow::numParamFromBin;
1618 0 : fromBinMethods["paramSet"] = &CalReductionRow::paramSetFromBin;
1619 0 : fromBinMethods["numInvalidConditions"] = &CalReductionRow::numInvalidConditionsFromBin;
1620 0 : fromBinMethods["invalidConditions"] = &CalReductionRow::invalidConditionsFromBin;
1621 0 : fromBinMethods["timeReduced"] = &CalReductionRow::timeReducedFromBin;
1622 0 : fromBinMethods["messages"] = &CalReductionRow::messagesFromBin;
1623 0 : fromBinMethods["software"] = &CalReductionRow::softwareFromBin;
1624 0 : fromBinMethods["softwareVersion"] = &CalReductionRow::softwareVersionFromBin;
1625 :
1626 :
1627 :
1628 :
1629 :
1630 :
1631 :
1632 0 : fromTextMethods["calReductionId"] = &CalReductionRow::calReductionIdFromText;
1633 :
1634 :
1635 :
1636 0 : fromTextMethods["numApplied"] = &CalReductionRow::numAppliedFromText;
1637 :
1638 :
1639 :
1640 0 : fromTextMethods["appliedCalibrations"] = &CalReductionRow::appliedCalibrationsFromText;
1641 :
1642 :
1643 :
1644 0 : fromTextMethods["numParam"] = &CalReductionRow::numParamFromText;
1645 :
1646 :
1647 :
1648 0 : fromTextMethods["paramSet"] = &CalReductionRow::paramSetFromText;
1649 :
1650 :
1651 :
1652 0 : fromTextMethods["numInvalidConditions"] = &CalReductionRow::numInvalidConditionsFromText;
1653 :
1654 :
1655 :
1656 0 : fromTextMethods["invalidConditions"] = &CalReductionRow::invalidConditionsFromText;
1657 :
1658 :
1659 :
1660 0 : fromTextMethods["timeReduced"] = &CalReductionRow::timeReducedFromText;
1661 :
1662 :
1663 :
1664 0 : fromTextMethods["messages"] = &CalReductionRow::messagesFromText;
1665 :
1666 :
1667 :
1668 0 : fromTextMethods["software"] = &CalReductionRow::softwareFromText;
1669 :
1670 :
1671 :
1672 0 : fromTextMethods["softwareVersion"] = &CalReductionRow::softwareVersionFromText;
1673 :
1674 :
1675 :
1676 :
1677 0 : }
1678 :
1679 0 : CalReductionRow::CalReductionRow (CalReductionTable &t, CalReductionRow *row) : table(t) {
1680 0 : hasBeenAdded = false;
1681 :
1682 0 : if (row == 0) {
1683 :
1684 :
1685 :
1686 :
1687 :
1688 :
1689 :
1690 :
1691 :
1692 :
1693 :
1694 :
1695 :
1696 :
1697 :
1698 :
1699 :
1700 :
1701 :
1702 :
1703 :
1704 :
1705 :
1706 :
1707 :
1708 : }
1709 : else {
1710 :
1711 :
1712 0 : calReductionId = row->calReductionId;
1713 :
1714 :
1715 :
1716 :
1717 0 : numApplied = row->numApplied;
1718 :
1719 0 : appliedCalibrations = row->appliedCalibrations;
1720 :
1721 0 : numParam = row->numParam;
1722 :
1723 0 : paramSet = row->paramSet;
1724 :
1725 0 : numInvalidConditions = row->numInvalidConditions;
1726 :
1727 0 : invalidConditions = row->invalidConditions;
1728 :
1729 0 : timeReduced = row->timeReduced;
1730 :
1731 0 : messages = row->messages;
1732 :
1733 0 : software = row->software;
1734 :
1735 0 : softwareVersion = row->softwareVersion;
1736 :
1737 :
1738 :
1739 :
1740 : }
1741 :
1742 0 : fromBinMethods["calReductionId"] = &CalReductionRow::calReductionIdFromBin;
1743 0 : fromBinMethods["numApplied"] = &CalReductionRow::numAppliedFromBin;
1744 0 : fromBinMethods["appliedCalibrations"] = &CalReductionRow::appliedCalibrationsFromBin;
1745 0 : fromBinMethods["numParam"] = &CalReductionRow::numParamFromBin;
1746 0 : fromBinMethods["paramSet"] = &CalReductionRow::paramSetFromBin;
1747 0 : fromBinMethods["numInvalidConditions"] = &CalReductionRow::numInvalidConditionsFromBin;
1748 0 : fromBinMethods["invalidConditions"] = &CalReductionRow::invalidConditionsFromBin;
1749 0 : fromBinMethods["timeReduced"] = &CalReductionRow::timeReducedFromBin;
1750 0 : fromBinMethods["messages"] = &CalReductionRow::messagesFromBin;
1751 0 : fromBinMethods["software"] = &CalReductionRow::softwareFromBin;
1752 0 : fromBinMethods["softwareVersion"] = &CalReductionRow::softwareVersionFromBin;
1753 :
1754 :
1755 :
1756 0 : }
1757 :
1758 :
1759 0 : bool CalReductionRow::compareNoAutoInc(int numApplied, std::vector<std::string > appliedCalibrations, int numParam, std::vector<std::string > paramSet, int numInvalidConditions, std::vector<InvalidatingConditionMod::InvalidatingCondition > invalidConditions, ArrayTime timeReduced, std::string messages, std::string software, std::string softwareVersion) {
1760 : bool result;
1761 0 : result = true;
1762 :
1763 :
1764 :
1765 0 : result = result && (this->numApplied == numApplied);
1766 :
1767 0 : if (!result) return false;
1768 :
1769 :
1770 :
1771 :
1772 0 : result = result && (this->appliedCalibrations == appliedCalibrations);
1773 :
1774 0 : if (!result) return false;
1775 :
1776 :
1777 :
1778 :
1779 0 : result = result && (this->numParam == numParam);
1780 :
1781 0 : if (!result) return false;
1782 :
1783 :
1784 :
1785 :
1786 0 : result = result && (this->paramSet == paramSet);
1787 :
1788 0 : if (!result) return false;
1789 :
1790 :
1791 :
1792 :
1793 0 : result = result && (this->numInvalidConditions == numInvalidConditions);
1794 :
1795 0 : if (!result) return false;
1796 :
1797 :
1798 :
1799 :
1800 0 : result = result && (this->invalidConditions == invalidConditions);
1801 :
1802 0 : if (!result) return false;
1803 :
1804 :
1805 :
1806 :
1807 0 : result = result && (this->timeReduced == timeReduced);
1808 :
1809 0 : if (!result) return false;
1810 :
1811 :
1812 :
1813 :
1814 0 : result = result && (this->messages == messages);
1815 :
1816 0 : if (!result) return false;
1817 :
1818 :
1819 :
1820 :
1821 0 : result = result && (this->software == software);
1822 :
1823 0 : if (!result) return false;
1824 :
1825 :
1826 :
1827 :
1828 0 : result = result && (this->softwareVersion == softwareVersion);
1829 :
1830 0 : if (!result) return false;
1831 :
1832 :
1833 0 : return result;
1834 : }
1835 :
1836 :
1837 :
1838 0 : bool CalReductionRow::compareRequiredValue(int numApplied, std::vector<std::string > appliedCalibrations, int numParam, std::vector<std::string > paramSet, int numInvalidConditions, std::vector<InvalidatingConditionMod::InvalidatingCondition > invalidConditions, ArrayTime timeReduced, std::string messages, std::string software, std::string softwareVersion) {
1839 : bool result;
1840 0 : result = true;
1841 :
1842 :
1843 0 : if (!(this->numApplied == numApplied)) return false;
1844 :
1845 :
1846 :
1847 0 : if (!(this->appliedCalibrations == appliedCalibrations)) return false;
1848 :
1849 :
1850 :
1851 0 : if (!(this->numParam == numParam)) return false;
1852 :
1853 :
1854 :
1855 0 : if (!(this->paramSet == paramSet)) return false;
1856 :
1857 :
1858 :
1859 0 : if (!(this->numInvalidConditions == numInvalidConditions)) return false;
1860 :
1861 :
1862 :
1863 0 : if (!(this->invalidConditions == invalidConditions)) return false;
1864 :
1865 :
1866 :
1867 0 : if (!(this->timeReduced == timeReduced)) return false;
1868 :
1869 :
1870 :
1871 0 : if (!(this->messages == messages)) return false;
1872 :
1873 :
1874 :
1875 0 : if (!(this->software == software)) return false;
1876 :
1877 :
1878 :
1879 0 : if (!(this->softwareVersion == softwareVersion)) return false;
1880 :
1881 :
1882 0 : return result;
1883 : }
1884 :
1885 :
1886 : /**
1887 : * Return true if all required attributes of the value part are equal to their homologues
1888 : * in x and false otherwise.
1889 : *
1890 :
1891 : * @param x a pointer on the CalReductionRow whose required attributes of the value part
1892 :
1893 : * will be compared with those of this.
1894 : * @return a boolean.
1895 : */
1896 0 : bool CalReductionRow::equalByRequiredValue(CalReductionRow* x ) {
1897 :
1898 :
1899 0 : if (this->numApplied != x->numApplied) return false;
1900 :
1901 0 : if (this->appliedCalibrations != x->appliedCalibrations) return false;
1902 :
1903 0 : if (this->numParam != x->numParam) return false;
1904 :
1905 0 : if (this->paramSet != x->paramSet) return false;
1906 :
1907 0 : if (this->numInvalidConditions != x->numInvalidConditions) return false;
1908 :
1909 0 : if (this->invalidConditions != x->invalidConditions) return false;
1910 :
1911 0 : if (this->timeReduced != x->timeReduced) return false;
1912 :
1913 0 : if (this->messages != x->messages) return false;
1914 :
1915 0 : if (this->software != x->software) return false;
1916 :
1917 0 : if (this->softwareVersion != x->softwareVersion) return false;
1918 :
1919 :
1920 0 : return true;
1921 : }
1922 :
1923 : /*
1924 : map<string, CalReductionAttributeFromBin> CalReductionRow::initFromBinMethods() {
1925 : map<string, CalReductionAttributeFromBin> result;
1926 :
1927 : result["calReductionId"] = &CalReductionRow::calReductionIdFromBin;
1928 : result["numApplied"] = &CalReductionRow::numAppliedFromBin;
1929 : result["appliedCalibrations"] = &CalReductionRow::appliedCalibrationsFromBin;
1930 : result["numParam"] = &CalReductionRow::numParamFromBin;
1931 : result["paramSet"] = &CalReductionRow::paramSetFromBin;
1932 : result["numInvalidConditions"] = &CalReductionRow::numInvalidConditionsFromBin;
1933 : result["invalidConditions"] = &CalReductionRow::invalidConditionsFromBin;
1934 : result["timeReduced"] = &CalReductionRow::timeReducedFromBin;
1935 : result["messages"] = &CalReductionRow::messagesFromBin;
1936 : result["software"] = &CalReductionRow::softwareFromBin;
1937 : result["softwareVersion"] = &CalReductionRow::softwareVersionFromBin;
1938 :
1939 :
1940 :
1941 :
1942 : return result;
1943 : }
1944 : */
1945 : } // End namespace asdm
1946 :
|
