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