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