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