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 ConfigDescriptionRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/ConfigDescriptionRow.h>
39 : #include <alma/ASDM/ConfigDescriptionTable.h>
40 :
41 : #include <alma/ASDM/ConfigDescriptionTable.h>
42 : #include <alma/ASDM/ConfigDescriptionRow.h>
43 :
44 : #include <alma/ASDM/AntennaTable.h>
45 : #include <alma/ASDM/AntennaRow.h>
46 :
47 : #include <alma/ASDM/FeedTable.h>
48 : #include <alma/ASDM/FeedRow.h>
49 :
50 : #include <alma/ASDM/SwitchCycleTable.h>
51 : #include <alma/ASDM/SwitchCycleRow.h>
52 :
53 : #include <alma/ASDM/DataDescriptionTable.h>
54 : #include <alma/ASDM/DataDescriptionRow.h>
55 :
56 : #include <alma/ASDM/ProcessorTable.h>
57 : #include <alma/ASDM/ProcessorRow.h>
58 :
59 :
60 : using asdm::ASDM;
61 : using asdm::ConfigDescriptionRow;
62 : using asdm::ConfigDescriptionTable;
63 :
64 : using asdm::ConfigDescriptionTable;
65 : using asdm::ConfigDescriptionRow;
66 :
67 : using asdm::AntennaTable;
68 : using asdm::AntennaRow;
69 :
70 : using asdm::FeedTable;
71 : using asdm::FeedRow;
72 :
73 : using asdm::SwitchCycleTable;
74 : using asdm::SwitchCycleRow;
75 :
76 : using asdm::DataDescriptionTable;
77 : using asdm::DataDescriptionRow;
78 :
79 : using asdm::ProcessorTable;
80 : using asdm::ProcessorRow;
81 :
82 :
83 : #include <alma/ASDM/Parser.h>
84 :
85 : #include <alma/ASDM/EnumerationParser.h>
86 : #include <alma/ASDM/ASDMValuesParser.h>
87 :
88 : #include <alma/ASDM/InvalidArgumentException.h>
89 :
90 : using namespace std;
91 :
92 : namespace asdm {
93 776 : ConfigDescriptionRow::~ConfigDescriptionRow() {
94 776 : }
95 :
96 : /**
97 : * Return the table to which this row belongs.
98 : */
99 0 : ConfigDescriptionTable &ConfigDescriptionRow::getTable() const {
100 0 : return table;
101 : }
102 :
103 0 : bool ConfigDescriptionRow::isAdded() const {
104 0 : return hasBeenAdded;
105 : }
106 :
107 388 : void ConfigDescriptionRow::isAdded(bool added) {
108 388 : hasBeenAdded = added;
109 388 : }
110 :
111 : #ifndef WITHOUT_ACS
112 : using asdmIDL::ConfigDescriptionRowIDL;
113 : #endif
114 :
115 : #ifndef WITHOUT_ACS
116 : /**
117 : * Return this row in the form of an IDL struct.
118 : * @return The values of this row as a ConfigDescriptionRowIDL struct.
119 : */
120 : ConfigDescriptionRowIDL *ConfigDescriptionRow::toIDL() const {
121 : ConfigDescriptionRowIDL *x = new ConfigDescriptionRowIDL ();
122 :
123 : // Fill the IDL structure.
124 :
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 : x->numAntenna = numAntenna;
133 :
134 :
135 :
136 :
137 :
138 :
139 :
140 :
141 :
142 :
143 :
144 : x->numDataDescription = numDataDescription;
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 :
153 :
154 :
155 :
156 : x->numFeed = numFeed;
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 :
165 :
166 :
167 :
168 : x->correlationMode = correlationMode;
169 :
170 :
171 :
172 :
173 :
174 :
175 :
176 :
177 :
178 :
179 : x->configDescriptionId = configDescriptionId.toIDLTag();
180 :
181 :
182 :
183 :
184 :
185 :
186 :
187 :
188 :
189 :
190 : x->numAtmPhaseCorrection = numAtmPhaseCorrection;
191 :
192 :
193 :
194 :
195 :
196 :
197 :
198 :
199 :
200 :
201 : x->atmPhaseCorrection.length(atmPhaseCorrection.size());
202 : for (unsigned int i = 0; i < atmPhaseCorrection.size(); ++i) {
203 :
204 :
205 : x->atmPhaseCorrection[i] = atmPhaseCorrection.at(i);
206 :
207 :
208 : }
209 :
210 :
211 :
212 :
213 :
214 :
215 :
216 :
217 :
218 :
219 : x->processorType = processorType;
220 :
221 :
222 :
223 :
224 :
225 :
226 :
227 :
228 : x->phasedArrayListExists = phasedArrayListExists;
229 :
230 :
231 :
232 : x->phasedArrayList.length(phasedArrayList.size());
233 : for (unsigned int i = 0; i < phasedArrayList.size(); ++i) {
234 :
235 :
236 : x->phasedArrayList[i] = phasedArrayList.at(i);
237 :
238 :
239 : }
240 :
241 :
242 :
243 :
244 :
245 :
246 :
247 :
248 :
249 :
250 : x->spectralType = spectralType;
251 :
252 :
253 :
254 :
255 :
256 :
257 :
258 :
259 : x->numAssocValuesExists = numAssocValuesExists;
260 :
261 :
262 :
263 :
264 : x->numAssocValues = numAssocValues;
265 :
266 :
267 :
268 :
269 :
270 :
271 :
272 :
273 : x->assocNatureExists = assocNatureExists;
274 :
275 :
276 :
277 : x->assocNature.length(assocNature.size());
278 : for (unsigned int i = 0; i < assocNature.size(); ++i) {
279 :
280 :
281 : x->assocNature[i] = assocNature.at(i);
282 :
283 :
284 : }
285 :
286 :
287 :
288 :
289 :
290 :
291 :
292 :
293 :
294 :
295 :
296 :
297 : x->antennaId.length(antennaId.size());
298 : for (unsigned int i = 0; i < antennaId.size(); ++i) {
299 :
300 : x->antennaId[i] = antennaId.at(i).toIDLTag();
301 :
302 : }
303 :
304 :
305 :
306 :
307 :
308 :
309 :
310 : x->assocConfigDescriptionIdExists = assocConfigDescriptionIdExists;
311 :
312 :
313 :
314 : x->assocConfigDescriptionId.length(assocConfigDescriptionId.size());
315 : for (unsigned int i = 0; i < assocConfigDescriptionId.size(); ++i) {
316 :
317 : x->assocConfigDescriptionId[i] = assocConfigDescriptionId.at(i).toIDLTag();
318 :
319 : }
320 :
321 :
322 :
323 :
324 :
325 :
326 :
327 :
328 : x->dataDescriptionId.length(dataDescriptionId.size());
329 : for (unsigned int i = 0; i < dataDescriptionId.size(); ++i) {
330 :
331 : x->dataDescriptionId[i] = dataDescriptionId.at(i).toIDLTag();
332 :
333 : }
334 :
335 :
336 :
337 :
338 :
339 :
340 :
341 :
342 : x->feedId.length(feedId.size());
343 : for (unsigned int i = 0; i < feedId.size(); ++i) {
344 :
345 :
346 : x->feedId[i] = feedId.at(i);
347 :
348 :
349 : }
350 :
351 :
352 :
353 :
354 :
355 :
356 :
357 :
358 :
359 : x->processorId = processorId.toIDLTag();
360 :
361 :
362 :
363 :
364 :
365 :
366 :
367 :
368 :
369 : x->switchCycleId.length(switchCycleId.size());
370 : for (unsigned int i = 0; i < switchCycleId.size(); ++i) {
371 :
372 : x->switchCycleId[i] = switchCycleId.at(i).toIDLTag();
373 :
374 : }
375 :
376 :
377 :
378 :
379 :
380 :
381 :
382 :
383 :
384 :
385 :
386 :
387 :
388 :
389 :
390 :
391 :
392 :
393 : return x;
394 :
395 : }
396 :
397 : void ConfigDescriptionRow::toIDL(asdmIDL::ConfigDescriptionRowIDL& x) const {
398 : // Set the x's fields.
399 :
400 :
401 :
402 :
403 :
404 :
405 :
406 :
407 : x.numAntenna = numAntenna;
408 :
409 :
410 :
411 :
412 :
413 :
414 :
415 :
416 :
417 :
418 :
419 : x.numDataDescription = numDataDescription;
420 :
421 :
422 :
423 :
424 :
425 :
426 :
427 :
428 :
429 :
430 :
431 : x.numFeed = numFeed;
432 :
433 :
434 :
435 :
436 :
437 :
438 :
439 :
440 :
441 :
442 :
443 : x.correlationMode = correlationMode;
444 :
445 :
446 :
447 :
448 :
449 :
450 :
451 :
452 :
453 :
454 : x.configDescriptionId = configDescriptionId.toIDLTag();
455 :
456 :
457 :
458 :
459 :
460 :
461 :
462 :
463 :
464 :
465 : x.numAtmPhaseCorrection = numAtmPhaseCorrection;
466 :
467 :
468 :
469 :
470 :
471 :
472 :
473 :
474 :
475 :
476 : x.atmPhaseCorrection.length(atmPhaseCorrection.size());
477 : for (unsigned int i = 0; i < atmPhaseCorrection.size(); ++i) {
478 :
479 :
480 : x.atmPhaseCorrection[i] = atmPhaseCorrection.at(i);
481 :
482 :
483 : }
484 :
485 :
486 :
487 :
488 :
489 :
490 :
491 :
492 :
493 :
494 : x.processorType = processorType;
495 :
496 :
497 :
498 :
499 :
500 :
501 :
502 :
503 : x.phasedArrayListExists = phasedArrayListExists;
504 :
505 :
506 :
507 : x.phasedArrayList.length(phasedArrayList.size());
508 : for (unsigned int i = 0; i < phasedArrayList.size(); ++i) {
509 :
510 :
511 : x.phasedArrayList[i] = phasedArrayList.at(i);
512 :
513 :
514 : }
515 :
516 :
517 :
518 :
519 :
520 :
521 :
522 :
523 :
524 :
525 : x.spectralType = spectralType;
526 :
527 :
528 :
529 :
530 :
531 :
532 :
533 :
534 : x.numAssocValuesExists = numAssocValuesExists;
535 :
536 :
537 :
538 :
539 : x.numAssocValues = numAssocValues;
540 :
541 :
542 :
543 :
544 :
545 :
546 :
547 :
548 : x.assocNatureExists = assocNatureExists;
549 :
550 :
551 :
552 : x.assocNature.length(assocNature.size());
553 : for (unsigned int i = 0; i < assocNature.size(); ++i) {
554 :
555 :
556 : x.assocNature[i] = assocNature.at(i);
557 :
558 :
559 : }
560 :
561 :
562 :
563 :
564 :
565 :
566 :
567 :
568 :
569 :
570 :
571 :
572 : x.antennaId.length(antennaId.size());
573 : for (unsigned int i = 0; i < antennaId.size(); ++i) {
574 :
575 : x.antennaId[i] = antennaId.at(i).toIDLTag();
576 :
577 : }
578 :
579 :
580 :
581 :
582 :
583 :
584 :
585 : x.assocConfigDescriptionIdExists = assocConfigDescriptionIdExists;
586 :
587 :
588 :
589 : x.assocConfigDescriptionId.length(assocConfigDescriptionId.size());
590 : for (unsigned int i = 0; i < assocConfigDescriptionId.size(); ++i) {
591 :
592 : x.assocConfigDescriptionId[i] = assocConfigDescriptionId.at(i).toIDLTag();
593 :
594 : }
595 :
596 :
597 :
598 :
599 :
600 :
601 :
602 :
603 : x.dataDescriptionId.length(dataDescriptionId.size());
604 : for (unsigned int i = 0; i < dataDescriptionId.size(); ++i) {
605 :
606 : x.dataDescriptionId[i] = dataDescriptionId.at(i).toIDLTag();
607 :
608 : }
609 :
610 :
611 :
612 :
613 :
614 :
615 :
616 :
617 : x.feedId.length(feedId.size());
618 : for (unsigned int i = 0; i < feedId.size(); ++i) {
619 :
620 :
621 : x.feedId[i] = feedId.at(i);
622 :
623 :
624 : }
625 :
626 :
627 :
628 :
629 :
630 :
631 :
632 :
633 :
634 : x.processorId = processorId.toIDLTag();
635 :
636 :
637 :
638 :
639 :
640 :
641 :
642 :
643 :
644 : x.switchCycleId.length(switchCycleId.size());
645 : for (unsigned int i = 0; i < switchCycleId.size(); ++i) {
646 :
647 : x.switchCycleId[i] = switchCycleId.at(i).toIDLTag();
648 :
649 : }
650 :
651 :
652 :
653 :
654 :
655 :
656 :
657 :
658 :
659 :
660 :
661 :
662 :
663 :
664 :
665 :
666 :
667 :
668 : }
669 : #endif
670 :
671 :
672 : #ifndef WITHOUT_ACS
673 : /**
674 : * Fill the values of this row from the IDL struct ConfigDescriptionRowIDL.
675 : * @param x The IDL struct containing the values used to fill this row.
676 : */
677 : void ConfigDescriptionRow::setFromIDL (ConfigDescriptionRowIDL x){
678 : try {
679 : // Fill the values from x.
680 :
681 :
682 :
683 :
684 :
685 :
686 : setNumAntenna(x.numAntenna);
687 :
688 :
689 :
690 :
691 :
692 :
693 :
694 :
695 :
696 : setNumDataDescription(x.numDataDescription);
697 :
698 :
699 :
700 :
701 :
702 :
703 :
704 :
705 :
706 : setNumFeed(x.numFeed);
707 :
708 :
709 :
710 :
711 :
712 :
713 :
714 :
715 :
716 : setCorrelationMode(x.correlationMode);
717 :
718 :
719 :
720 :
721 :
722 :
723 :
724 :
725 :
726 : setConfigDescriptionId(Tag (x.configDescriptionId));
727 :
728 :
729 :
730 :
731 :
732 :
733 :
734 :
735 :
736 : setNumAtmPhaseCorrection(x.numAtmPhaseCorrection);
737 :
738 :
739 :
740 :
741 :
742 :
743 :
744 :
745 :
746 : atmPhaseCorrection .clear();
747 : for (unsigned int i = 0; i <x.atmPhaseCorrection.length(); ++i) {
748 :
749 : atmPhaseCorrection.push_back(x.atmPhaseCorrection[i]);
750 :
751 : }
752 :
753 :
754 :
755 :
756 :
757 :
758 :
759 :
760 :
761 : setProcessorType(x.processorType);
762 :
763 :
764 :
765 :
766 :
767 :
768 :
769 : phasedArrayListExists = x.phasedArrayListExists;
770 : if (x.phasedArrayListExists) {
771 :
772 :
773 :
774 : phasedArrayList .clear();
775 : for (unsigned int i = 0; i <x.phasedArrayList.length(); ++i) {
776 :
777 : phasedArrayList.push_back(x.phasedArrayList[i]);
778 :
779 : }
780 :
781 :
782 :
783 : }
784 :
785 :
786 :
787 :
788 :
789 :
790 :
791 : setSpectralType(x.spectralType);
792 :
793 :
794 :
795 :
796 :
797 :
798 :
799 : numAssocValuesExists = x.numAssocValuesExists;
800 : if (x.numAssocValuesExists) {
801 :
802 :
803 :
804 : setNumAssocValues(x.numAssocValues);
805 :
806 :
807 :
808 : }
809 :
810 :
811 :
812 :
813 :
814 : assocNatureExists = x.assocNatureExists;
815 : if (x.assocNatureExists) {
816 :
817 :
818 :
819 : assocNature .clear();
820 : for (unsigned int i = 0; i <x.assocNature.length(); ++i) {
821 :
822 : assocNature.push_back(x.assocNature[i]);
823 :
824 : }
825 :
826 :
827 :
828 : }
829 :
830 :
831 :
832 :
833 :
834 :
835 :
836 :
837 : antennaId .clear();
838 : for (unsigned int i = 0; i <x.antennaId.length(); ++i) {
839 :
840 : antennaId.push_back(Tag (x.antennaId[i]));
841 :
842 : }
843 :
844 :
845 :
846 :
847 :
848 : assocConfigDescriptionIdExists = x.assocConfigDescriptionIdExists;
849 : if (x.assocConfigDescriptionIdExists) {
850 :
851 : assocConfigDescriptionId .clear();
852 : for (unsigned int i = 0; i <x.assocConfigDescriptionId.length(); ++i) {
853 :
854 : assocConfigDescriptionId.push_back(Tag (x.assocConfigDescriptionId[i]));
855 :
856 : }
857 :
858 : }
859 :
860 :
861 :
862 :
863 :
864 : dataDescriptionId .clear();
865 : for (unsigned int i = 0; i <x.dataDescriptionId.length(); ++i) {
866 :
867 : dataDescriptionId.push_back(Tag (x.dataDescriptionId[i]));
868 :
869 : }
870 :
871 :
872 :
873 :
874 :
875 : feedId .clear();
876 : for (unsigned int i = 0; i <x.feedId.length(); ++i) {
877 :
878 : feedId.push_back(x.feedId[i]);
879 :
880 : }
881 :
882 :
883 :
884 :
885 :
886 :
887 :
888 : setProcessorId(Tag (x.processorId));
889 :
890 :
891 :
892 :
893 :
894 :
895 :
896 : switchCycleId .clear();
897 : for (unsigned int i = 0; i <x.switchCycleId.length(); ++i) {
898 :
899 : switchCycleId.push_back(Tag (x.switchCycleId[i]));
900 :
901 : }
902 :
903 :
904 :
905 :
906 :
907 :
908 :
909 :
910 :
911 :
912 :
913 :
914 :
915 :
916 :
917 :
918 :
919 : } catch (const IllegalAccessException &err) {
920 : throw ConversionException (err.getMessage(),"ConfigDescription");
921 : }
922 : }
923 : #endif
924 :
925 : /**
926 : * Return this row in the form of an XML string.
927 : * @return The values of this row as an XML string.
928 : */
929 35 : string ConfigDescriptionRow::toXML() const {
930 35 : string buf;
931 35 : buf.append("<row> \n");
932 :
933 :
934 :
935 :
936 :
937 :
938 35 : Parser::toXML(numAntenna, "numAntenna", buf);
939 :
940 :
941 :
942 :
943 :
944 :
945 :
946 35 : Parser::toXML(numDataDescription, "numDataDescription", buf);
947 :
948 :
949 :
950 :
951 :
952 :
953 :
954 35 : Parser::toXML(numFeed, "numFeed", buf);
955 :
956 :
957 :
958 :
959 :
960 :
961 :
962 35 : buf.append(EnumerationParser::toXML("correlationMode", correlationMode));
963 :
964 :
965 :
966 :
967 :
968 :
969 :
970 35 : Parser::toXML(configDescriptionId, "configDescriptionId", buf);
971 :
972 :
973 :
974 :
975 :
976 :
977 :
978 35 : Parser::toXML(numAtmPhaseCorrection, "numAtmPhaseCorrection", buf);
979 :
980 :
981 :
982 :
983 :
984 :
985 :
986 35 : buf.append(EnumerationParser::toXML("atmPhaseCorrection", atmPhaseCorrection));
987 :
988 :
989 :
990 :
991 :
992 :
993 :
994 35 : buf.append(EnumerationParser::toXML("processorType", processorType));
995 :
996 :
997 :
998 :
999 :
1000 :
1001 35 : if (phasedArrayListExists) {
1002 :
1003 :
1004 0 : Parser::toXML(phasedArrayList, "phasedArrayList", buf);
1005 :
1006 :
1007 : }
1008 :
1009 :
1010 :
1011 :
1012 :
1013 :
1014 35 : buf.append(EnumerationParser::toXML("spectralType", spectralType));
1015 :
1016 :
1017 :
1018 :
1019 :
1020 :
1021 35 : if (numAssocValuesExists) {
1022 :
1023 :
1024 0 : Parser::toXML(numAssocValues, "numAssocValues", buf);
1025 :
1026 :
1027 : }
1028 :
1029 :
1030 :
1031 :
1032 :
1033 35 : if (assocNatureExists) {
1034 :
1035 :
1036 0 : buf.append(EnumerationParser::toXML("assocNature", assocNature));
1037 :
1038 :
1039 : }
1040 :
1041 :
1042 :
1043 :
1044 :
1045 :
1046 :
1047 :
1048 :
1049 35 : Parser::toXML(antennaId, "antennaId", buf);
1050 :
1051 :
1052 :
1053 :
1054 :
1055 :
1056 35 : if (assocConfigDescriptionIdExists) {
1057 :
1058 :
1059 0 : Parser::toXML(assocConfigDescriptionId, "assocConfigDescriptionId", buf);
1060 :
1061 :
1062 : }
1063 :
1064 :
1065 :
1066 :
1067 :
1068 :
1069 35 : Parser::toXML(dataDescriptionId, "dataDescriptionId", buf);
1070 :
1071 :
1072 :
1073 :
1074 :
1075 :
1076 :
1077 35 : Parser::toXML(feedId, "feedId", buf);
1078 :
1079 :
1080 :
1081 :
1082 :
1083 :
1084 :
1085 35 : Parser::toXML(processorId, "processorId", buf);
1086 :
1087 :
1088 :
1089 :
1090 :
1091 :
1092 :
1093 35 : Parser::toXML(switchCycleId, "switchCycleId", buf);
1094 :
1095 :
1096 :
1097 :
1098 :
1099 :
1100 :
1101 :
1102 :
1103 :
1104 :
1105 :
1106 :
1107 :
1108 :
1109 :
1110 :
1111 :
1112 :
1113 35 : buf.append("</row>\n");
1114 35 : return buf;
1115 : }
1116 :
1117 : /**
1118 : * Fill the values of this row from an XML string
1119 : * that was produced by the toXML() method.
1120 : * @param x The XML string being used to set the values of this row.
1121 : */
1122 329 : void ConfigDescriptionRow::setFromXML (string rowDoc) {
1123 658 : Parser row(rowDoc);
1124 329 : string s = "";
1125 : try {
1126 :
1127 :
1128 :
1129 :
1130 :
1131 329 : setNumAntenna(Parser::getInteger("numAntenna","ConfigDescription",rowDoc));
1132 :
1133 :
1134 :
1135 :
1136 :
1137 :
1138 :
1139 329 : setNumDataDescription(Parser::getInteger("numDataDescription","ConfigDescription",rowDoc));
1140 :
1141 :
1142 :
1143 :
1144 :
1145 :
1146 :
1147 329 : setNumFeed(Parser::getInteger("numFeed","ConfigDescription",rowDoc));
1148 :
1149 :
1150 :
1151 :
1152 :
1153 :
1154 :
1155 :
1156 329 : correlationMode = EnumerationParser::getCorrelationMode("correlationMode","ConfigDescription",rowDoc);
1157 :
1158 :
1159 :
1160 :
1161 :
1162 :
1163 :
1164 :
1165 329 : setConfigDescriptionId(Parser::getTag("configDescriptionId","ConfigDescription",rowDoc));
1166 :
1167 :
1168 :
1169 :
1170 :
1171 :
1172 :
1173 329 : setNumAtmPhaseCorrection(Parser::getInteger("numAtmPhaseCorrection","ConfigDescription",rowDoc));
1174 :
1175 :
1176 :
1177 :
1178 :
1179 :
1180 :
1181 :
1182 329 : atmPhaseCorrection = EnumerationParser::getAtmPhaseCorrection1D("atmPhaseCorrection","ConfigDescription",rowDoc);
1183 :
1184 :
1185 :
1186 :
1187 :
1188 :
1189 :
1190 :
1191 :
1192 329 : processorType = EnumerationParser::getProcessorType("processorType","ConfigDescription",rowDoc);
1193 :
1194 :
1195 :
1196 :
1197 :
1198 :
1199 :
1200 329 : if (row.isStr("<phasedArrayList>")) {
1201 :
1202 :
1203 0 : setPhasedArrayList(Parser::get1DInteger("phasedArrayList","ConfigDescription",rowDoc));
1204 :
1205 :
1206 : }
1207 :
1208 :
1209 :
1210 :
1211 :
1212 :
1213 :
1214 329 : spectralType = EnumerationParser::getSpectralResolutionType("spectralType","ConfigDescription",rowDoc);
1215 :
1216 :
1217 :
1218 :
1219 :
1220 :
1221 :
1222 329 : if (row.isStr("<numAssocValues>")) {
1223 :
1224 279 : setNumAssocValues(Parser::getInteger("numAssocValues","ConfigDescription",rowDoc));
1225 :
1226 : }
1227 :
1228 :
1229 :
1230 :
1231 :
1232 329 : if (row.isStr("<assocNature>")) {
1233 :
1234 :
1235 :
1236 274 : assocNature = EnumerationParser::getSpectralResolutionType1D("assocNature","ConfigDescription",rowDoc);
1237 :
1238 :
1239 :
1240 274 : assocNatureExists = true;
1241 : }
1242 :
1243 :
1244 :
1245 :
1246 :
1247 :
1248 :
1249 :
1250 329 : setAntennaId(Parser::get1DTag("antennaId","ConfigDescription",rowDoc));
1251 :
1252 :
1253 :
1254 :
1255 :
1256 329 : if (row.isStr("<assocConfigDescriptionId>")) {
1257 279 : setAssocConfigDescriptionId(Parser::get1DTag("assocConfigDescriptionId","ConfigDescription",rowDoc));
1258 : }
1259 :
1260 :
1261 :
1262 :
1263 :
1264 329 : setDataDescriptionId(Parser::get1DTag("dataDescriptionId","ConfigDescription",rowDoc));
1265 :
1266 :
1267 :
1268 :
1269 :
1270 329 : setFeedId(Parser::get1DInteger("feedId","ConfigDescription",rowDoc));
1271 :
1272 :
1273 :
1274 :
1275 :
1276 :
1277 329 : setProcessorId(Parser::getTag("processorId","ConfigDescription",rowDoc));
1278 :
1279 :
1280 :
1281 :
1282 :
1283 :
1284 329 : setSwitchCycleId(Parser::get1DTag("switchCycleId","ConfigDescription",rowDoc));
1285 :
1286 :
1287 :
1288 :
1289 :
1290 :
1291 :
1292 :
1293 :
1294 :
1295 :
1296 :
1297 :
1298 :
1299 :
1300 :
1301 :
1302 0 : } catch (const IllegalAccessException &err) {
1303 0 : throw ConversionException (err.getMessage(),"ConfigDescription");
1304 : }
1305 329 : }
1306 :
1307 0 : void ConfigDescriptionRow::toBin(EndianOSStream& eoss) {
1308 :
1309 :
1310 :
1311 :
1312 :
1313 0 : configDescriptionId.toBin(eoss);
1314 :
1315 :
1316 :
1317 :
1318 :
1319 :
1320 :
1321 0 : eoss.writeInt(numAntenna);
1322 :
1323 :
1324 :
1325 :
1326 :
1327 :
1328 :
1329 :
1330 0 : eoss.writeInt(numDataDescription);
1331 :
1332 :
1333 :
1334 :
1335 :
1336 :
1337 :
1338 :
1339 0 : eoss.writeInt(numFeed);
1340 :
1341 :
1342 :
1343 :
1344 :
1345 :
1346 :
1347 :
1348 0 : eoss.writeString(CCorrelationMode::name(correlationMode));
1349 : /* eoss.writeInt(correlationMode); */
1350 :
1351 :
1352 :
1353 :
1354 :
1355 :
1356 :
1357 :
1358 0 : eoss.writeInt(numAtmPhaseCorrection);
1359 :
1360 :
1361 :
1362 :
1363 :
1364 :
1365 :
1366 :
1367 :
1368 0 : eoss.writeInt((int) atmPhaseCorrection.size());
1369 0 : for (unsigned int i = 0; i < atmPhaseCorrection.size(); i++)
1370 :
1371 0 : eoss.writeString(CAtmPhaseCorrection::name(atmPhaseCorrection.at(i)));
1372 : /* eoss.writeInt(atmPhaseCorrection.at(i)); */
1373 :
1374 :
1375 :
1376 :
1377 :
1378 :
1379 :
1380 :
1381 :
1382 :
1383 0 : eoss.writeString(CProcessorType::name(processorType));
1384 : /* eoss.writeInt(processorType); */
1385 :
1386 :
1387 :
1388 :
1389 :
1390 :
1391 :
1392 :
1393 0 : eoss.writeString(CSpectralResolutionType::name(spectralType));
1394 : /* eoss.writeInt(spectralType); */
1395 :
1396 :
1397 :
1398 :
1399 :
1400 :
1401 :
1402 0 : Tag::toBin(antennaId, eoss);
1403 :
1404 :
1405 :
1406 :
1407 :
1408 :
1409 :
1410 :
1411 0 : eoss.writeInt((int) feedId.size());
1412 0 : for (unsigned int i = 0; i < feedId.size(); i++)
1413 :
1414 0 : eoss.writeInt(feedId.at(i));
1415 :
1416 :
1417 :
1418 :
1419 :
1420 :
1421 :
1422 :
1423 :
1424 0 : Tag::toBin(switchCycleId, eoss);
1425 :
1426 :
1427 :
1428 :
1429 :
1430 :
1431 0 : Tag::toBin(dataDescriptionId, eoss);
1432 :
1433 :
1434 :
1435 :
1436 :
1437 :
1438 0 : processorId.toBin(eoss);
1439 :
1440 :
1441 :
1442 :
1443 :
1444 :
1445 0 : eoss.writeBoolean(phasedArrayListExists);
1446 0 : if (phasedArrayListExists) {
1447 :
1448 :
1449 :
1450 :
1451 :
1452 :
1453 0 : eoss.writeInt((int) phasedArrayList.size());
1454 0 : for (unsigned int i = 0; i < phasedArrayList.size(); i++)
1455 :
1456 0 : eoss.writeInt(phasedArrayList.at(i));
1457 :
1458 :
1459 :
1460 :
1461 :
1462 :
1463 : }
1464 :
1465 0 : eoss.writeBoolean(numAssocValuesExists);
1466 0 : if (numAssocValuesExists) {
1467 :
1468 :
1469 :
1470 :
1471 :
1472 0 : eoss.writeInt(numAssocValues);
1473 :
1474 :
1475 :
1476 :
1477 : }
1478 :
1479 0 : eoss.writeBoolean(assocNatureExists);
1480 0 : if (assocNatureExists) {
1481 :
1482 :
1483 :
1484 :
1485 :
1486 :
1487 0 : eoss.writeInt((int) assocNature.size());
1488 0 : for (unsigned int i = 0; i < assocNature.size(); i++)
1489 :
1490 0 : eoss.writeString(CSpectralResolutionType::name(assocNature.at(i)));
1491 : /* eoss.writeInt(assocNature.at(i)); */
1492 :
1493 :
1494 :
1495 :
1496 :
1497 :
1498 : }
1499 :
1500 0 : eoss.writeBoolean(assocConfigDescriptionIdExists);
1501 0 : if (assocConfigDescriptionIdExists) {
1502 :
1503 :
1504 :
1505 :
1506 0 : Tag::toBin(assocConfigDescriptionId, eoss);
1507 :
1508 :
1509 :
1510 : }
1511 :
1512 0 : }
1513 :
1514 0 : void ConfigDescriptionRow::configDescriptionIdFromBin(EndianIStream& eis) {
1515 :
1516 :
1517 :
1518 :
1519 0 : configDescriptionId = Tag::fromBin(eis);
1520 :
1521 :
1522 :
1523 0 : }
1524 0 : void ConfigDescriptionRow::numAntennaFromBin(EndianIStream& eis) {
1525 :
1526 :
1527 :
1528 :
1529 :
1530 0 : numAntenna = eis.readInt();
1531 :
1532 :
1533 :
1534 :
1535 0 : }
1536 0 : void ConfigDescriptionRow::numDataDescriptionFromBin(EndianIStream& eis) {
1537 :
1538 :
1539 :
1540 :
1541 :
1542 0 : numDataDescription = eis.readInt();
1543 :
1544 :
1545 :
1546 :
1547 0 : }
1548 0 : void ConfigDescriptionRow::numFeedFromBin(EndianIStream& eis) {
1549 :
1550 :
1551 :
1552 :
1553 :
1554 0 : numFeed = eis.readInt();
1555 :
1556 :
1557 :
1558 :
1559 0 : }
1560 0 : void ConfigDescriptionRow::correlationModeFromBin(EndianIStream& eis) {
1561 :
1562 :
1563 :
1564 :
1565 :
1566 0 : correlationMode = CCorrelationMode::literal(eis.readString());
1567 :
1568 :
1569 :
1570 :
1571 0 : }
1572 0 : void ConfigDescriptionRow::numAtmPhaseCorrectionFromBin(EndianIStream& eis) {
1573 :
1574 :
1575 :
1576 :
1577 :
1578 0 : numAtmPhaseCorrection = eis.readInt();
1579 :
1580 :
1581 :
1582 :
1583 0 : }
1584 0 : void ConfigDescriptionRow::atmPhaseCorrectionFromBin(EndianIStream& eis) {
1585 :
1586 :
1587 :
1588 :
1589 :
1590 :
1591 0 : atmPhaseCorrection.clear();
1592 :
1593 0 : unsigned int atmPhaseCorrectionDim1 = eis.readInt();
1594 0 : for (unsigned int i = 0 ; i < atmPhaseCorrectionDim1; i++)
1595 :
1596 0 : atmPhaseCorrection.push_back(CAtmPhaseCorrection::literal(eis.readString()));
1597 :
1598 :
1599 :
1600 :
1601 :
1602 :
1603 0 : }
1604 0 : void ConfigDescriptionRow::processorTypeFromBin(EndianIStream& eis) {
1605 :
1606 :
1607 :
1608 :
1609 :
1610 0 : processorType = CProcessorType::literal(eis.readString());
1611 :
1612 :
1613 :
1614 :
1615 0 : }
1616 0 : void ConfigDescriptionRow::spectralTypeFromBin(EndianIStream& eis) {
1617 :
1618 :
1619 :
1620 :
1621 :
1622 0 : spectralType = CSpectralResolutionType::literal(eis.readString());
1623 :
1624 :
1625 :
1626 :
1627 0 : }
1628 0 : void ConfigDescriptionRow::antennaIdFromBin(EndianIStream& eis) {
1629 :
1630 :
1631 :
1632 :
1633 :
1634 :
1635 0 : antennaId = Tag::from1DBin(eis);
1636 :
1637 :
1638 :
1639 :
1640 :
1641 0 : }
1642 0 : void ConfigDescriptionRow::feedIdFromBin(EndianIStream& eis) {
1643 :
1644 :
1645 :
1646 :
1647 :
1648 :
1649 0 : feedId.clear();
1650 :
1651 0 : unsigned int feedIdDim1 = eis.readInt();
1652 0 : for (unsigned int i = 0 ; i < feedIdDim1; i++)
1653 :
1654 0 : feedId.push_back(eis.readInt());
1655 :
1656 :
1657 :
1658 :
1659 :
1660 :
1661 0 : }
1662 0 : void ConfigDescriptionRow::switchCycleIdFromBin(EndianIStream& eis) {
1663 :
1664 :
1665 :
1666 :
1667 :
1668 :
1669 0 : switchCycleId = Tag::from1DBin(eis);
1670 :
1671 :
1672 :
1673 :
1674 :
1675 0 : }
1676 0 : void ConfigDescriptionRow::dataDescriptionIdFromBin(EndianIStream& eis) {
1677 :
1678 :
1679 :
1680 :
1681 :
1682 :
1683 0 : dataDescriptionId = Tag::from1DBin(eis);
1684 :
1685 :
1686 :
1687 :
1688 :
1689 0 : }
1690 0 : void ConfigDescriptionRow::processorIdFromBin(EndianIStream& eis) {
1691 :
1692 :
1693 :
1694 :
1695 0 : processorId = Tag::fromBin(eis);
1696 :
1697 :
1698 :
1699 0 : }
1700 :
1701 0 : void ConfigDescriptionRow::phasedArrayListFromBin(EndianIStream& eis) {
1702 :
1703 0 : phasedArrayListExists = eis.readBoolean();
1704 0 : if (phasedArrayListExists) {
1705 :
1706 :
1707 :
1708 :
1709 :
1710 :
1711 0 : phasedArrayList.clear();
1712 :
1713 0 : unsigned int phasedArrayListDim1 = eis.readInt();
1714 0 : for (unsigned int i = 0 ; i < phasedArrayListDim1; i++)
1715 :
1716 0 : phasedArrayList.push_back(eis.readInt());
1717 :
1718 :
1719 :
1720 :
1721 :
1722 :
1723 : }
1724 :
1725 0 : }
1726 0 : void ConfigDescriptionRow::numAssocValuesFromBin(EndianIStream& eis) {
1727 :
1728 0 : numAssocValuesExists = eis.readBoolean();
1729 0 : if (numAssocValuesExists) {
1730 :
1731 :
1732 :
1733 :
1734 :
1735 0 : numAssocValues = eis.readInt();
1736 :
1737 :
1738 :
1739 :
1740 : }
1741 :
1742 0 : }
1743 0 : void ConfigDescriptionRow::assocNatureFromBin(EndianIStream& eis) {
1744 :
1745 0 : assocNatureExists = eis.readBoolean();
1746 0 : if (assocNatureExists) {
1747 :
1748 :
1749 :
1750 :
1751 :
1752 :
1753 0 : assocNature.clear();
1754 :
1755 0 : unsigned int assocNatureDim1 = eis.readInt();
1756 0 : for (unsigned int i = 0 ; i < assocNatureDim1; i++)
1757 :
1758 0 : assocNature.push_back(CSpectralResolutionType::literal(eis.readString()));
1759 :
1760 :
1761 :
1762 :
1763 :
1764 :
1765 : }
1766 :
1767 0 : }
1768 0 : void ConfigDescriptionRow::assocConfigDescriptionIdFromBin(EndianIStream& eis) {
1769 :
1770 0 : assocConfigDescriptionIdExists = eis.readBoolean();
1771 0 : if (assocConfigDescriptionIdExists) {
1772 :
1773 :
1774 :
1775 :
1776 :
1777 :
1778 0 : assocConfigDescriptionId = Tag::from1DBin(eis);
1779 :
1780 :
1781 :
1782 :
1783 :
1784 : }
1785 :
1786 0 : }
1787 :
1788 :
1789 0 : ConfigDescriptionRow* ConfigDescriptionRow::fromBin(EndianIStream& eis, ConfigDescriptionTable& table, const vector<string>& attributesSeq) {
1790 0 : ConfigDescriptionRow* row = new ConfigDescriptionRow(table);
1791 :
1792 0 : map<string, ConfigDescriptionAttributeFromBin>::iterator iter ;
1793 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
1794 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
1795 0 : if (iter != row->fromBinMethods.end()) {
1796 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
1797 : }
1798 : else {
1799 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
1800 0 : if (functorP)
1801 0 : (*functorP)(eis);
1802 : else
1803 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "ConfigDescriptionTable");
1804 : }
1805 :
1806 : }
1807 0 : return row;
1808 : }
1809 :
1810 : //
1811 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
1812 : // of one row.
1813 : //
1814 :
1815 : // Convert a string into an Tag
1816 0 : void ConfigDescriptionRow::configDescriptionIdFromText(const string & s) {
1817 :
1818 :
1819 0 : configDescriptionId = ASDMValuesParser::parse<Tag>(s);
1820 :
1821 :
1822 0 : }
1823 :
1824 :
1825 : // Convert a string into an int
1826 0 : void ConfigDescriptionRow::numAntennaFromText(const string & s) {
1827 :
1828 :
1829 0 : numAntenna = ASDMValuesParser::parse<int>(s);
1830 :
1831 :
1832 0 : }
1833 :
1834 :
1835 : // Convert a string into an int
1836 0 : void ConfigDescriptionRow::numDataDescriptionFromText(const string & s) {
1837 :
1838 :
1839 0 : numDataDescription = ASDMValuesParser::parse<int>(s);
1840 :
1841 :
1842 0 : }
1843 :
1844 :
1845 : // Convert a string into an int
1846 0 : void ConfigDescriptionRow::numFeedFromText(const string & s) {
1847 :
1848 :
1849 0 : numFeed = ASDMValuesParser::parse<int>(s);
1850 :
1851 :
1852 0 : }
1853 :
1854 :
1855 : // Convert a string into an CorrelationMode
1856 0 : void ConfigDescriptionRow::correlationModeFromText(const string & s) {
1857 :
1858 :
1859 0 : correlationMode = ASDMValuesParser::parse<CorrelationModeMod::CorrelationMode>(s);
1860 :
1861 :
1862 0 : }
1863 :
1864 :
1865 : // Convert a string into an int
1866 0 : void ConfigDescriptionRow::numAtmPhaseCorrectionFromText(const string & s) {
1867 :
1868 :
1869 0 : numAtmPhaseCorrection = ASDMValuesParser::parse<int>(s);
1870 :
1871 :
1872 0 : }
1873 :
1874 :
1875 : // Convert a string into an AtmPhaseCorrection
1876 0 : void ConfigDescriptionRow::atmPhaseCorrectionFromText(const string & s) {
1877 :
1878 :
1879 0 : atmPhaseCorrection = ASDMValuesParser::parse1D<AtmPhaseCorrectionMod::AtmPhaseCorrection>(s);
1880 :
1881 :
1882 0 : }
1883 :
1884 :
1885 : // Convert a string into an ProcessorType
1886 0 : void ConfigDescriptionRow::processorTypeFromText(const string & s) {
1887 :
1888 :
1889 0 : processorType = ASDMValuesParser::parse<ProcessorTypeMod::ProcessorType>(s);
1890 :
1891 :
1892 0 : }
1893 :
1894 :
1895 : // Convert a string into an SpectralResolutionType
1896 0 : void ConfigDescriptionRow::spectralTypeFromText(const string & s) {
1897 :
1898 :
1899 0 : spectralType = ASDMValuesParser::parse<SpectralResolutionTypeMod::SpectralResolutionType>(s);
1900 :
1901 :
1902 0 : }
1903 :
1904 :
1905 : // Convert a string into an Tag
1906 0 : void ConfigDescriptionRow::antennaIdFromText(const string & s) {
1907 :
1908 :
1909 0 : antennaId = ASDMValuesParser::parse1D<Tag>(s);
1910 :
1911 :
1912 0 : }
1913 :
1914 :
1915 : // Convert a string into an int
1916 0 : void ConfigDescriptionRow::feedIdFromText(const string & s) {
1917 :
1918 :
1919 0 : feedId = ASDMValuesParser::parse1D<int>(s);
1920 :
1921 :
1922 0 : }
1923 :
1924 :
1925 : // Convert a string into an Tag
1926 0 : void ConfigDescriptionRow::switchCycleIdFromText(const string & s) {
1927 :
1928 :
1929 0 : switchCycleId = ASDMValuesParser::parse1D<Tag>(s);
1930 :
1931 :
1932 0 : }
1933 :
1934 :
1935 : // Convert a string into an Tag
1936 0 : void ConfigDescriptionRow::dataDescriptionIdFromText(const string & s) {
1937 :
1938 :
1939 0 : dataDescriptionId = ASDMValuesParser::parse1D<Tag>(s);
1940 :
1941 :
1942 0 : }
1943 :
1944 :
1945 : // Convert a string into an Tag
1946 0 : void ConfigDescriptionRow::processorIdFromText(const string & s) {
1947 :
1948 :
1949 0 : processorId = ASDMValuesParser::parse<Tag>(s);
1950 :
1951 :
1952 0 : }
1953 :
1954 :
1955 :
1956 : // Convert a string into an int
1957 0 : void ConfigDescriptionRow::phasedArrayListFromText(const string & s) {
1958 0 : phasedArrayListExists = true;
1959 :
1960 :
1961 0 : phasedArrayList = ASDMValuesParser::parse1D<int>(s);
1962 :
1963 :
1964 0 : }
1965 :
1966 :
1967 : // Convert a string into an int
1968 0 : void ConfigDescriptionRow::numAssocValuesFromText(const string & s) {
1969 0 : numAssocValuesExists = true;
1970 :
1971 :
1972 0 : numAssocValues = ASDMValuesParser::parse<int>(s);
1973 :
1974 :
1975 0 : }
1976 :
1977 :
1978 : // Convert a string into an SpectralResolutionType
1979 0 : void ConfigDescriptionRow::assocNatureFromText(const string & s) {
1980 0 : assocNatureExists = true;
1981 :
1982 :
1983 0 : assocNature = ASDMValuesParser::parse1D<SpectralResolutionTypeMod::SpectralResolutionType>(s);
1984 :
1985 :
1986 0 : }
1987 :
1988 :
1989 : // Convert a string into an Tag
1990 0 : void ConfigDescriptionRow::assocConfigDescriptionIdFromText(const string & s) {
1991 0 : assocConfigDescriptionIdExists = true;
1992 :
1993 :
1994 0 : assocConfigDescriptionId = ASDMValuesParser::parse1D<Tag>(s);
1995 :
1996 :
1997 0 : }
1998 :
1999 :
2000 :
2001 0 : void ConfigDescriptionRow::fromText(const std::string& attributeName, const std::string& t) {
2002 0 : map<string, ConfigDescriptionAttributeFromText>::iterator iter;
2003 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
2004 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "ConfigDescriptionTable");
2005 0 : (this->*(iter->second))(t);
2006 0 : }
2007 :
2008 : ////////////////////////////////////////////////
2009 : // Intrinsic Table Attributes getters/setters //
2010 : ////////////////////////////////////////////////
2011 :
2012 :
2013 :
2014 :
2015 : /**
2016 : * Get numAntenna.
2017 : * @return numAntenna as int
2018 : */
2019 6257 : int ConfigDescriptionRow::getNumAntenna() const {
2020 :
2021 6257 : return numAntenna;
2022 : }
2023 :
2024 : /**
2025 : * Set numAntenna with the specified int.
2026 : * @param numAntenna The int value to which numAntenna is to be set.
2027 :
2028 :
2029 :
2030 : */
2031 5581 : void ConfigDescriptionRow::setNumAntenna (int numAntenna) {
2032 :
2033 :
2034 5581 : if (hasBeenAdded) {
2035 :
2036 : }
2037 :
2038 5581 : this->numAntenna = numAntenna;
2039 :
2040 5581 : }
2041 :
2042 :
2043 :
2044 :
2045 :
2046 :
2047 : /**
2048 : * Get numDataDescription.
2049 : * @return numDataDescription as int
2050 : */
2051 5293 : int ConfigDescriptionRow::getNumDataDescription() const {
2052 :
2053 5293 : return numDataDescription;
2054 : }
2055 :
2056 : /**
2057 : * Set numDataDescription with the specified int.
2058 : * @param numDataDescription The int value to which numDataDescription is to be set.
2059 :
2060 :
2061 :
2062 : */
2063 5581 : void ConfigDescriptionRow::setNumDataDescription (int numDataDescription) {
2064 :
2065 :
2066 5581 : if (hasBeenAdded) {
2067 :
2068 : }
2069 :
2070 5581 : this->numDataDescription = numDataDescription;
2071 :
2072 5581 : }
2073 :
2074 :
2075 :
2076 :
2077 :
2078 :
2079 : /**
2080 : * Get numFeed.
2081 : * @return numFeed as int
2082 : */
2083 5293 : int ConfigDescriptionRow::getNumFeed() const {
2084 :
2085 5293 : return numFeed;
2086 : }
2087 :
2088 : /**
2089 : * Set numFeed with the specified int.
2090 : * @param numFeed The int value to which numFeed is to be set.
2091 :
2092 :
2093 :
2094 : */
2095 5581 : void ConfigDescriptionRow::setNumFeed (int numFeed) {
2096 :
2097 :
2098 5581 : if (hasBeenAdded) {
2099 :
2100 : }
2101 :
2102 5581 : this->numFeed = numFeed;
2103 :
2104 5581 : }
2105 :
2106 :
2107 :
2108 :
2109 :
2110 :
2111 : /**
2112 : * Get correlationMode.
2113 : * @return correlationMode as CorrelationModeMod::CorrelationMode
2114 : */
2115 19753 : CorrelationModeMod::CorrelationMode ConfigDescriptionRow::getCorrelationMode() const {
2116 :
2117 19753 : return correlationMode;
2118 : }
2119 :
2120 : /**
2121 : * Set correlationMode with the specified CorrelationModeMod::CorrelationMode.
2122 : * @param correlationMode The CorrelationModeMod::CorrelationMode value to which correlationMode is to be set.
2123 :
2124 :
2125 :
2126 : */
2127 5252 : void ConfigDescriptionRow::setCorrelationMode (CorrelationModeMod::CorrelationMode correlationMode) {
2128 :
2129 :
2130 5252 : if (hasBeenAdded) {
2131 :
2132 : }
2133 :
2134 5252 : this->correlationMode = correlationMode;
2135 :
2136 5252 : }
2137 :
2138 :
2139 :
2140 :
2141 :
2142 :
2143 : /**
2144 : * Get configDescriptionId.
2145 : * @return configDescriptionId as Tag
2146 : */
2147 6544 : Tag ConfigDescriptionRow::getConfigDescriptionId() const {
2148 :
2149 6544 : return configDescriptionId;
2150 : }
2151 :
2152 : /**
2153 : * Set configDescriptionId with the specified Tag.
2154 : * @param configDescriptionId The Tag value to which configDescriptionId is to be set.
2155 :
2156 :
2157 :
2158 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2159 :
2160 : */
2161 388 : void ConfigDescriptionRow::setConfigDescriptionId (Tag configDescriptionId) {
2162 :
2163 :
2164 388 : if (hasBeenAdded) {
2165 :
2166 0 : throw IllegalAccessException("configDescriptionId", "ConfigDescription");
2167 :
2168 : }
2169 :
2170 388 : this->configDescriptionId = configDescriptionId;
2171 :
2172 388 : }
2173 :
2174 :
2175 :
2176 :
2177 :
2178 :
2179 : /**
2180 : * Get numAtmPhaseCorrection.
2181 : * @return numAtmPhaseCorrection as int
2182 : */
2183 5293 : int ConfigDescriptionRow::getNumAtmPhaseCorrection() const {
2184 :
2185 5293 : return numAtmPhaseCorrection;
2186 : }
2187 :
2188 : /**
2189 : * Set numAtmPhaseCorrection with the specified int.
2190 : * @param numAtmPhaseCorrection The int value to which numAtmPhaseCorrection is to be set.
2191 :
2192 :
2193 :
2194 : */
2195 5581 : void ConfigDescriptionRow::setNumAtmPhaseCorrection (int numAtmPhaseCorrection) {
2196 :
2197 :
2198 5581 : if (hasBeenAdded) {
2199 :
2200 : }
2201 :
2202 5581 : this->numAtmPhaseCorrection = numAtmPhaseCorrection;
2203 :
2204 5581 : }
2205 :
2206 :
2207 :
2208 :
2209 :
2210 :
2211 : /**
2212 : * Get atmPhaseCorrection.
2213 : * @return atmPhaseCorrection as std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection >
2214 : */
2215 17086 : std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection > ConfigDescriptionRow::getAtmPhaseCorrection() const {
2216 :
2217 17086 : return atmPhaseCorrection;
2218 : }
2219 :
2220 : /**
2221 : * Set atmPhaseCorrection with the specified std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection >.
2222 : * @param atmPhaseCorrection The std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection > value to which atmPhaseCorrection is to be set.
2223 :
2224 :
2225 :
2226 : */
2227 5252 : void ConfigDescriptionRow::setAtmPhaseCorrection (std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection > atmPhaseCorrection) {
2228 :
2229 :
2230 5252 : if (hasBeenAdded) {
2231 :
2232 : }
2233 :
2234 5252 : this->atmPhaseCorrection = atmPhaseCorrection;
2235 :
2236 5252 : }
2237 :
2238 :
2239 :
2240 :
2241 :
2242 :
2243 : /**
2244 : * Get processorType.
2245 : * @return processorType as ProcessorTypeMod::ProcessorType
2246 : */
2247 7489 : ProcessorTypeMod::ProcessorType ConfigDescriptionRow::getProcessorType() const {
2248 :
2249 7489 : return processorType;
2250 : }
2251 :
2252 : /**
2253 : * Set processorType with the specified ProcessorTypeMod::ProcessorType.
2254 : * @param processorType The ProcessorTypeMod::ProcessorType value to which processorType is to be set.
2255 :
2256 :
2257 :
2258 : */
2259 5252 : void ConfigDescriptionRow::setProcessorType (ProcessorTypeMod::ProcessorType processorType) {
2260 :
2261 :
2262 5252 : if (hasBeenAdded) {
2263 :
2264 : }
2265 :
2266 5252 : this->processorType = processorType;
2267 :
2268 5252 : }
2269 :
2270 :
2271 :
2272 :
2273 : /**
2274 : * The attribute phasedArrayList is optional. Return true if this attribute exists.
2275 : * @return true if and only if the phasedArrayList attribute exists.
2276 : */
2277 0 : bool ConfigDescriptionRow::isPhasedArrayListExists() const {
2278 0 : return phasedArrayListExists;
2279 : }
2280 :
2281 :
2282 :
2283 : /**
2284 : * Get phasedArrayList, which is optional.
2285 : * @return phasedArrayList as std::vector<int >
2286 : * @throw IllegalAccessException If phasedArrayList does not exist.
2287 : */
2288 0 : std::vector<int > ConfigDescriptionRow::getPhasedArrayList() const {
2289 0 : if (!phasedArrayListExists) {
2290 0 : throw IllegalAccessException("phasedArrayList", "ConfigDescription");
2291 : }
2292 :
2293 0 : return phasedArrayList;
2294 : }
2295 :
2296 : /**
2297 : * Set phasedArrayList with the specified std::vector<int >.
2298 : * @param phasedArrayList The std::vector<int > value to which phasedArrayList is to be set.
2299 :
2300 :
2301 : */
2302 0 : void ConfigDescriptionRow::setPhasedArrayList (std::vector<int > phasedArrayList) {
2303 :
2304 0 : this->phasedArrayList = phasedArrayList;
2305 :
2306 0 : phasedArrayListExists = true;
2307 :
2308 0 : }
2309 :
2310 :
2311 : /**
2312 : * Mark phasedArrayList, which is an optional field, as non-existent.
2313 : */
2314 0 : void ConfigDescriptionRow::clearPhasedArrayList () {
2315 0 : phasedArrayListExists = false;
2316 0 : }
2317 :
2318 :
2319 :
2320 :
2321 :
2322 : /**
2323 : * Get spectralType.
2324 : * @return spectralType as SpectralResolutionTypeMod::SpectralResolutionType
2325 : */
2326 5506 : SpectralResolutionTypeMod::SpectralResolutionType ConfigDescriptionRow::getSpectralType() const {
2327 :
2328 5506 : return spectralType;
2329 : }
2330 :
2331 : /**
2332 : * Set spectralType with the specified SpectralResolutionTypeMod::SpectralResolutionType.
2333 : * @param spectralType The SpectralResolutionTypeMod::SpectralResolutionType value to which spectralType is to be set.
2334 :
2335 :
2336 :
2337 : */
2338 5252 : void ConfigDescriptionRow::setSpectralType (SpectralResolutionTypeMod::SpectralResolutionType spectralType) {
2339 :
2340 :
2341 5252 : if (hasBeenAdded) {
2342 :
2343 : }
2344 :
2345 5252 : this->spectralType = spectralType;
2346 :
2347 5252 : }
2348 :
2349 :
2350 :
2351 :
2352 : /**
2353 : * The attribute numAssocValues is optional. Return true if this attribute exists.
2354 : * @return true if and only if the numAssocValues attribute exists.
2355 : */
2356 0 : bool ConfigDescriptionRow::isNumAssocValuesExists() const {
2357 0 : return numAssocValuesExists;
2358 : }
2359 :
2360 :
2361 :
2362 : /**
2363 : * Get numAssocValues, which is optional.
2364 : * @return numAssocValues as int
2365 : * @throw IllegalAccessException If numAssocValues does not exist.
2366 : */
2367 0 : int ConfigDescriptionRow::getNumAssocValues() const {
2368 0 : if (!numAssocValuesExists) {
2369 0 : throw IllegalAccessException("numAssocValues", "ConfigDescription");
2370 : }
2371 :
2372 0 : return numAssocValues;
2373 : }
2374 :
2375 : /**
2376 : * Set numAssocValues with the specified int.
2377 : * @param numAssocValues The int value to which numAssocValues is to be set.
2378 :
2379 :
2380 : */
2381 279 : void ConfigDescriptionRow::setNumAssocValues (int numAssocValues) {
2382 :
2383 279 : this->numAssocValues = numAssocValues;
2384 :
2385 279 : numAssocValuesExists = true;
2386 :
2387 279 : }
2388 :
2389 :
2390 : /**
2391 : * Mark numAssocValues, which is an optional field, as non-existent.
2392 : */
2393 0 : void ConfigDescriptionRow::clearNumAssocValues () {
2394 0 : numAssocValuesExists = false;
2395 0 : }
2396 :
2397 :
2398 :
2399 : /**
2400 : * The attribute assocNature is optional. Return true if this attribute exists.
2401 : * @return true if and only if the assocNature attribute exists.
2402 : */
2403 5079 : bool ConfigDescriptionRow::isAssocNatureExists() const {
2404 5079 : return assocNatureExists;
2405 : }
2406 :
2407 :
2408 :
2409 : /**
2410 : * Get assocNature, which is optional.
2411 : * @return assocNature as std::vector<SpectralResolutionTypeMod::SpectralResolutionType >
2412 : * @throw IllegalAccessException If assocNature does not exist.
2413 : */
2414 2182 : std::vector<SpectralResolutionTypeMod::SpectralResolutionType > ConfigDescriptionRow::getAssocNature() const {
2415 2182 : if (!assocNatureExists) {
2416 0 : throw IllegalAccessException("assocNature", "ConfigDescription");
2417 : }
2418 :
2419 2182 : return assocNature;
2420 : }
2421 :
2422 : /**
2423 : * Set assocNature with the specified std::vector<SpectralResolutionTypeMod::SpectralResolutionType >.
2424 : * @param assocNature The std::vector<SpectralResolutionTypeMod::SpectralResolutionType > value to which assocNature is to be set.
2425 :
2426 :
2427 : */
2428 0 : void ConfigDescriptionRow::setAssocNature (std::vector<SpectralResolutionTypeMod::SpectralResolutionType > assocNature) {
2429 :
2430 0 : this->assocNature = assocNature;
2431 :
2432 0 : assocNatureExists = true;
2433 :
2434 0 : }
2435 :
2436 :
2437 : /**
2438 : * Mark assocNature, which is an optional field, as non-existent.
2439 : */
2440 0 : void ConfigDescriptionRow::clearAssocNature () {
2441 0 : assocNatureExists = false;
2442 0 : }
2443 :
2444 :
2445 :
2446 : ///////////////////////////////////////////////
2447 : // Extrinsic Table Attributes getters/setters//
2448 : ///////////////////////////////////////////////
2449 :
2450 :
2451 :
2452 :
2453 : /**
2454 : * Get antennaId.
2455 : * @return antennaId as std::vector<Tag>
2456 : */
2457 8851 : std::vector<Tag> ConfigDescriptionRow::getAntennaId() const {
2458 :
2459 8851 : return antennaId;
2460 : }
2461 :
2462 : /**
2463 : * Set antennaId with the specified std::vector<Tag> .
2464 : * @param antennaId The std::vector<Tag> value to which antennaId is to be set.
2465 :
2466 :
2467 :
2468 : */
2469 5581 : void ConfigDescriptionRow::setAntennaId (std::vector<Tag> antennaId) {
2470 :
2471 :
2472 5581 : if (hasBeenAdded) {
2473 :
2474 : }
2475 :
2476 5581 : this->antennaId = antennaId;
2477 :
2478 5581 : }
2479 :
2480 :
2481 :
2482 :
2483 : /**
2484 : * The attribute assocConfigDescriptionId is optional. Return true if this attribute exists.
2485 : * @return true if and only if the assocConfigDescriptionId attribute exists.
2486 : */
2487 0 : bool ConfigDescriptionRow::isAssocConfigDescriptionIdExists() const {
2488 0 : return assocConfigDescriptionIdExists;
2489 : }
2490 :
2491 :
2492 :
2493 : /**
2494 : * Get assocConfigDescriptionId, which is optional.
2495 : * @return assocConfigDescriptionId as std::vector<Tag>
2496 : * @throw IllegalAccessException If assocConfigDescriptionId does not exist.
2497 : */
2498 0 : std::vector<Tag> ConfigDescriptionRow::getAssocConfigDescriptionId() const {
2499 0 : if (!assocConfigDescriptionIdExists) {
2500 0 : throw IllegalAccessException("assocConfigDescriptionId", "ConfigDescription");
2501 : }
2502 :
2503 0 : return assocConfigDescriptionId;
2504 : }
2505 :
2506 : /**
2507 : * Set assocConfigDescriptionId with the specified std::vector<Tag> .
2508 : * @param assocConfigDescriptionId The std::vector<Tag> value to which assocConfigDescriptionId is to be set.
2509 :
2510 :
2511 : */
2512 279 : void ConfigDescriptionRow::setAssocConfigDescriptionId (std::vector<Tag> assocConfigDescriptionId) {
2513 :
2514 279 : this->assocConfigDescriptionId = assocConfigDescriptionId;
2515 :
2516 279 : assocConfigDescriptionIdExists = true;
2517 :
2518 279 : }
2519 :
2520 :
2521 : /**
2522 : * Mark assocConfigDescriptionId, which is an optional field, as non-existent.
2523 : */
2524 0 : void ConfigDescriptionRow::clearAssocConfigDescriptionId () {
2525 0 : assocConfigDescriptionIdExists = false;
2526 0 : }
2527 :
2528 :
2529 :
2530 :
2531 :
2532 : /**
2533 : * Get dataDescriptionId.
2534 : * @return dataDescriptionId as std::vector<Tag>
2535 : */
2536 8730 : std::vector<Tag> ConfigDescriptionRow::getDataDescriptionId() const {
2537 :
2538 8730 : return dataDescriptionId;
2539 : }
2540 :
2541 : /**
2542 : * Set dataDescriptionId with the specified std::vector<Tag> .
2543 : * @param dataDescriptionId The std::vector<Tag> value to which dataDescriptionId is to be set.
2544 :
2545 :
2546 :
2547 : */
2548 5581 : void ConfigDescriptionRow::setDataDescriptionId (std::vector<Tag> dataDescriptionId) {
2549 :
2550 :
2551 5581 : if (hasBeenAdded) {
2552 :
2553 : }
2554 :
2555 5581 : this->dataDescriptionId = dataDescriptionId;
2556 :
2557 5581 : }
2558 :
2559 :
2560 :
2561 :
2562 :
2563 :
2564 : /**
2565 : * Get feedId.
2566 : * @return feedId as std::vector<int>
2567 : */
2568 7147 : std::vector<int> ConfigDescriptionRow::getFeedId() const {
2569 :
2570 7147 : return feedId;
2571 : }
2572 :
2573 : /**
2574 : * Set feedId with the specified std::vector<int> .
2575 : * @param feedId The std::vector<int> value to which feedId is to be set.
2576 :
2577 :
2578 :
2579 : */
2580 5581 : void ConfigDescriptionRow::setFeedId (std::vector<int> feedId) {
2581 :
2582 :
2583 5581 : if (hasBeenAdded) {
2584 :
2585 : }
2586 :
2587 5581 : this->feedId = feedId;
2588 :
2589 5581 : }
2590 :
2591 :
2592 :
2593 :
2594 :
2595 :
2596 : /**
2597 : * Get processorId.
2598 : * @return processorId as Tag
2599 : */
2600 13842937 : Tag ConfigDescriptionRow::getProcessorId() const {
2601 :
2602 13842937 : return processorId;
2603 : }
2604 :
2605 : /**
2606 : * Set processorId with the specified Tag.
2607 : * @param processorId The Tag value to which processorId is to be set.
2608 :
2609 :
2610 :
2611 : */
2612 5581 : void ConfigDescriptionRow::setProcessorId (Tag processorId) {
2613 :
2614 :
2615 5581 : if (hasBeenAdded) {
2616 :
2617 : }
2618 :
2619 5581 : this->processorId = processorId;
2620 :
2621 5581 : }
2622 :
2623 :
2624 :
2625 :
2626 :
2627 :
2628 : /**
2629 : * Get switchCycleId.
2630 : * @return switchCycleId as std::vector<Tag>
2631 : */
2632 5387 : std::vector<Tag> ConfigDescriptionRow::getSwitchCycleId() const {
2633 :
2634 5387 : return switchCycleId;
2635 : }
2636 :
2637 : /**
2638 : * Set switchCycleId with the specified std::vector<Tag> .
2639 : * @param switchCycleId The std::vector<Tag> value to which switchCycleId is to be set.
2640 :
2641 :
2642 :
2643 : */
2644 5581 : void ConfigDescriptionRow::setSwitchCycleId (std::vector<Tag> switchCycleId) {
2645 :
2646 :
2647 5581 : if (hasBeenAdded) {
2648 :
2649 : }
2650 :
2651 5581 : this->switchCycleId = switchCycleId;
2652 :
2653 5581 : }
2654 :
2655 :
2656 :
2657 :
2658 : //////////////////////////////////////
2659 : // Links Attributes getters/setters //
2660 : //////////////////////////////////////
2661 :
2662 :
2663 :
2664 : /**
2665 : * Set assocConfigDescriptionId[i] with the specified Tag.
2666 : * @param i The index in assocConfigDescriptionId where to set the Tag value.
2667 : * @param assocConfigDescriptionId The Tag value to which assocConfigDescriptionId[i] is to be set.
2668 : * @throws OutOfBoundsException
2669 : */
2670 0 : void ConfigDescriptionRow::setAssocConfigDescriptionId (int i, Tag assocConfigDescriptionId) {
2671 0 : if ((i < 0) || (i > ((int) this->assocConfigDescriptionId.size())))
2672 0 : throw OutOfBoundsException("Index out of bounds during a set operation on attribute assocConfigDescriptionId in table ConfigDescriptionTable");
2673 0 : std::vector<Tag> ::iterator iter = this->assocConfigDescriptionId.begin();
2674 0 : int j = 0;
2675 0 : while (j < i) {
2676 0 : j++; iter++;
2677 : }
2678 0 : this->assocConfigDescriptionId.insert(this->assocConfigDescriptionId.erase(iter), assocConfigDescriptionId);
2679 0 : }
2680 :
2681 :
2682 :
2683 :
2684 :
2685 : /**
2686 : * Append a Tag to assocConfigDescriptionId.
2687 : * @param id the Tag to be appended to assocConfigDescriptionId
2688 : */
2689 0 : void ConfigDescriptionRow::addAssocConfigDescriptionId(Tag id){
2690 0 : assocConfigDescriptionId.push_back(id);
2691 0 : }
2692 :
2693 : /**
2694 : * Append an array of Tag to assocConfigDescriptionId.
2695 : * @param id an array of Tag to be appended to assocConfigDescriptionId
2696 : */
2697 0 : void ConfigDescriptionRow::addAssocConfigDescriptionId(const std::vector<Tag> & id) {
2698 0 : for (unsigned int i=0; i < id.size(); i++)
2699 0 : assocConfigDescriptionId.push_back(id.at(i));
2700 0 : }
2701 :
2702 :
2703 : /**
2704 : * Returns the Tag stored in assocConfigDescriptionId at position i.
2705 : *
2706 : */
2707 0 : const Tag ConfigDescriptionRow::getAssocConfigDescriptionId(int i) {
2708 0 : return assocConfigDescriptionId.at(i);
2709 : }
2710 :
2711 : /**
2712 : * Returns the ConfigDescriptionRow linked to this row via the Tag stored in assocConfigDescriptionId
2713 : * at position i.
2714 : */
2715 0 : ConfigDescriptionRow* ConfigDescriptionRow::getConfigDescriptionUsingAssocConfigDescriptionId(int i) {
2716 0 : return table.getContainer().getConfigDescription().getRowByKey(assocConfigDescriptionId.at(i));
2717 : }
2718 :
2719 : /**
2720 : * Returns the vector of ConfigDescriptionRow* linked to this row via the Tags stored in assocConfigDescriptionId
2721 : *
2722 : */
2723 0 : vector<ConfigDescriptionRow *> ConfigDescriptionRow::getConfigDescriptionsUsingAssocConfigDescriptionId() {
2724 0 : vector<ConfigDescriptionRow *> result;
2725 0 : for (unsigned int i = 0; i < assocConfigDescriptionId.size(); i++)
2726 0 : result.push_back(table.getContainer().getConfigDescription().getRowByKey(assocConfigDescriptionId.at(i)));
2727 :
2728 0 : return result;
2729 : }
2730 :
2731 :
2732 :
2733 :
2734 :
2735 :
2736 : /**
2737 : * Set antennaId[i] with the specified Tag.
2738 : * @param i The index in antennaId where to set the Tag value.
2739 : * @param antennaId The Tag value to which antennaId[i] is to be set.
2740 :
2741 : * @throws IndexOutOfBoundsException
2742 : */
2743 0 : void ConfigDescriptionRow::setAntennaId (int i, Tag antennaId) {
2744 0 : if (hasBeenAdded) {
2745 :
2746 : }
2747 0 : if ((i < 0) || (i > ((int) this->antennaId.size())))
2748 0 : throw OutOfBoundsException("Index out of bounds during a set operation on attribute antennaId in table ConfigDescriptionTable");
2749 0 : std::vector<Tag> ::iterator iter = this->antennaId.begin();
2750 0 : int j = 0;
2751 0 : while (j < i) {
2752 0 : j++; iter++;
2753 : }
2754 0 : this->antennaId.insert(this->antennaId.erase(iter), antennaId);
2755 0 : }
2756 :
2757 :
2758 :
2759 :
2760 :
2761 : /**
2762 : * Append a Tag to antennaId.
2763 : * @param id the Tag to be appended to antennaId
2764 : */
2765 0 : void ConfigDescriptionRow::addAntennaId(Tag id){
2766 0 : antennaId.push_back(id);
2767 0 : }
2768 :
2769 : /**
2770 : * Append an array of Tag to antennaId.
2771 : * @param id an array of Tag to be appended to antennaId
2772 : */
2773 0 : void ConfigDescriptionRow::addAntennaId(const std::vector<Tag> & id) {
2774 0 : for (unsigned int i=0; i < id.size(); i++)
2775 0 : antennaId.push_back(id.at(i));
2776 0 : }
2777 :
2778 :
2779 : /**
2780 : * Returns the Tag stored in antennaId at position i.
2781 : *
2782 : */
2783 0 : const Tag ConfigDescriptionRow::getAntennaId(int i) {
2784 0 : return antennaId.at(i);
2785 : }
2786 :
2787 : /**
2788 : * Returns the AntennaRow linked to this row via the Tag stored in antennaId
2789 : * at position i.
2790 : */
2791 0 : AntennaRow* ConfigDescriptionRow::getAntennaUsingAntennaId(int i) {
2792 0 : return table.getContainer().getAntenna().getRowByKey(antennaId.at(i));
2793 : }
2794 :
2795 : /**
2796 : * Returns the vector of AntennaRow* linked to this row via the Tags stored in antennaId
2797 : *
2798 : */
2799 0 : vector<AntennaRow *> ConfigDescriptionRow::getAntennasUsingAntennaId() {
2800 0 : vector<AntennaRow *> result;
2801 0 : for (unsigned int i = 0; i < antennaId.size(); i++)
2802 0 : result.push_back(table.getContainer().getAntenna().getRowByKey(antennaId.at(i)));
2803 :
2804 0 : return result;
2805 : }
2806 :
2807 :
2808 :
2809 :
2810 :
2811 :
2812 : /**
2813 : * Set feedId[i] with the specified int.
2814 : * @param i The index in feedId where to set the int value.
2815 : * @param feedId The int value to which feedId[i] is to be set.
2816 :
2817 : * @throws IndexOutOfBoundsException
2818 : */
2819 0 : void ConfigDescriptionRow::setFeedId (int i, int feedId) {
2820 0 : if (hasBeenAdded) {
2821 :
2822 : }
2823 0 : if ((i < 0) || (i > ((int) this->feedId.size())))
2824 0 : throw OutOfBoundsException("Index out of bounds during a set operation on attribute feedId in table ConfigDescriptionTable");
2825 0 : std::vector<int> ::iterator iter = this->feedId.begin();
2826 0 : int j = 0;
2827 0 : while (j < i) {
2828 0 : j++; iter++;
2829 : }
2830 0 : this->feedId.insert(this->feedId.erase(iter), feedId);
2831 0 : }
2832 :
2833 :
2834 :
2835 :
2836 :
2837 :
2838 : // ===> Slices link from a row of ConfigDescription table to a collection of row of Feed table.
2839 : // vector <int> feedId;
2840 :
2841 : /*
2842 : ** Append a new id to feedId
2843 : */
2844 0 : void ConfigDescriptionRow::addFeedId(int id) {
2845 0 : feedId.push_back(id);
2846 0 : }
2847 :
2848 : /*
2849 : ** Append an array of ids to feedId
2850 : */
2851 0 : void ConfigDescriptionRow::addFeedId(vector<int> id) {
2852 0 : for (unsigned int i = 0; i < id.size(); i++)
2853 0 : feedId.push_back(id[i]);
2854 0 : }
2855 : /**
2856 : * Get the collection of rows in the Feed table having feedId == feedId[i]
2857 : */
2858 0 : const vector <FeedRow *> ConfigDescriptionRow::getFeeds(int i) {
2859 :
2860 0 : return table.getContainer().getFeed().getRowByFeedId(feedId.at(i));
2861 :
2862 : }
2863 :
2864 : /**
2865 : * Get the collection of pointers to rows in the Feed table having feedId == feedId[i]
2866 : * for any i in [O..feedId.size()-1].
2867 : */
2868 0 : const vector <FeedRow *> ConfigDescriptionRow::getFeeds() {
2869 :
2870 0 : vector <FeedRow *> result;
2871 0 : for (unsigned int i=0; i < feedId.size(); i++) {
2872 0 : vector <FeedRow *> current = table.getContainer().getFeed().getRowByFeedId(feedId.at(i));
2873 0 : for (unsigned int j = 0; j < current.size(); j++)
2874 0 : result.push_back(current.at(j));
2875 : }
2876 0 : return result;
2877 : }
2878 :
2879 :
2880 :
2881 :
2882 :
2883 :
2884 : /**
2885 : * Set switchCycleId[i] with the specified Tag.
2886 : * @param i The index in switchCycleId where to set the Tag value.
2887 : * @param switchCycleId The Tag value to which switchCycleId[i] is to be set.
2888 :
2889 : * @throws IndexOutOfBoundsException
2890 : */
2891 0 : void ConfigDescriptionRow::setSwitchCycleId (int i, Tag switchCycleId) {
2892 0 : if (hasBeenAdded) {
2893 :
2894 : }
2895 0 : if ((i < 0) || (i > ((int) this->switchCycleId.size())))
2896 0 : throw OutOfBoundsException("Index out of bounds during a set operation on attribute switchCycleId in table ConfigDescriptionTable");
2897 0 : std::vector<Tag> ::iterator iter = this->switchCycleId.begin();
2898 0 : int j = 0;
2899 0 : while (j < i) {
2900 0 : j++; iter++;
2901 : }
2902 0 : this->switchCycleId.insert(this->switchCycleId.erase(iter), switchCycleId);
2903 0 : }
2904 :
2905 :
2906 :
2907 :
2908 :
2909 : /**
2910 : * Append a Tag to switchCycleId.
2911 : * @param id the Tag to be appended to switchCycleId
2912 : */
2913 0 : void ConfigDescriptionRow::addSwitchCycleId(Tag id){
2914 0 : switchCycleId.push_back(id);
2915 0 : }
2916 :
2917 : /**
2918 : * Append an array of Tag to switchCycleId.
2919 : * @param id an array of Tag to be appended to switchCycleId
2920 : */
2921 0 : void ConfigDescriptionRow::addSwitchCycleId(const std::vector<Tag> & id) {
2922 0 : for (unsigned int i=0; i < id.size(); i++)
2923 0 : switchCycleId.push_back(id.at(i));
2924 0 : }
2925 :
2926 :
2927 : /**
2928 : * Returns the Tag stored in switchCycleId at position i.
2929 : *
2930 : */
2931 0 : const Tag ConfigDescriptionRow::getSwitchCycleId(int i) {
2932 0 : return switchCycleId.at(i);
2933 : }
2934 :
2935 : /**
2936 : * Returns the SwitchCycleRow linked to this row via the Tag stored in switchCycleId
2937 : * at position i.
2938 : */
2939 0 : SwitchCycleRow* ConfigDescriptionRow::getSwitchCycleUsingSwitchCycleId(int i) {
2940 0 : return table.getContainer().getSwitchCycle().getRowByKey(switchCycleId.at(i));
2941 : }
2942 :
2943 : /**
2944 : * Returns the vector of SwitchCycleRow* linked to this row via the Tags stored in switchCycleId
2945 : *
2946 : */
2947 272 : vector<SwitchCycleRow *> ConfigDescriptionRow::getSwitchCyclesUsingSwitchCycleId() {
2948 272 : vector<SwitchCycleRow *> result;
2949 1315 : for (unsigned int i = 0; i < switchCycleId.size(); i++)
2950 1043 : result.push_back(table.getContainer().getSwitchCycle().getRowByKey(switchCycleId.at(i)));
2951 :
2952 272 : return result;
2953 : }
2954 :
2955 :
2956 :
2957 :
2958 :
2959 :
2960 : /**
2961 : * Set dataDescriptionId[i] with the specified Tag.
2962 : * @param i The index in dataDescriptionId where to set the Tag value.
2963 : * @param dataDescriptionId The Tag value to which dataDescriptionId[i] is to be set.
2964 :
2965 : * @throws IndexOutOfBoundsException
2966 : */
2967 0 : void ConfigDescriptionRow::setDataDescriptionId (int i, Tag dataDescriptionId) {
2968 0 : if (hasBeenAdded) {
2969 :
2970 : }
2971 0 : if ((i < 0) || (i > ((int) this->dataDescriptionId.size())))
2972 0 : throw OutOfBoundsException("Index out of bounds during a set operation on attribute dataDescriptionId in table ConfigDescriptionTable");
2973 0 : std::vector<Tag> ::iterator iter = this->dataDescriptionId.begin();
2974 0 : int j = 0;
2975 0 : while (j < i) {
2976 0 : j++; iter++;
2977 : }
2978 0 : this->dataDescriptionId.insert(this->dataDescriptionId.erase(iter), dataDescriptionId);
2979 0 : }
2980 :
2981 :
2982 :
2983 :
2984 :
2985 : /**
2986 : * Append a Tag to dataDescriptionId.
2987 : * @param id the Tag to be appended to dataDescriptionId
2988 : */
2989 0 : void ConfigDescriptionRow::addDataDescriptionId(Tag id){
2990 0 : dataDescriptionId.push_back(id);
2991 0 : }
2992 :
2993 : /**
2994 : * Append an array of Tag to dataDescriptionId.
2995 : * @param id an array of Tag to be appended to dataDescriptionId
2996 : */
2997 0 : void ConfigDescriptionRow::addDataDescriptionId(const std::vector<Tag> & id) {
2998 0 : for (unsigned int i=0; i < id.size(); i++)
2999 0 : dataDescriptionId.push_back(id.at(i));
3000 0 : }
3001 :
3002 :
3003 : /**
3004 : * Returns the Tag stored in dataDescriptionId at position i.
3005 : *
3006 : */
3007 0 : const Tag ConfigDescriptionRow::getDataDescriptionId(int i) {
3008 0 : return dataDescriptionId.at(i);
3009 : }
3010 :
3011 : /**
3012 : * Returns the DataDescriptionRow linked to this row via the Tag stored in dataDescriptionId
3013 : * at position i.
3014 : */
3015 0 : DataDescriptionRow* ConfigDescriptionRow::getDataDescriptionUsingDataDescriptionId(int i) {
3016 0 : return table.getContainer().getDataDescription().getRowByKey(dataDescriptionId.at(i));
3017 : }
3018 :
3019 : /**
3020 : * Returns the vector of DataDescriptionRow* linked to this row via the Tags stored in dataDescriptionId
3021 : *
3022 : */
3023 4308 : vector<DataDescriptionRow *> ConfigDescriptionRow::getDataDescriptionsUsingDataDescriptionId() {
3024 4308 : vector<DataDescriptionRow *> result;
3025 11760 : for (unsigned int i = 0; i < dataDescriptionId.size(); i++)
3026 7452 : result.push_back(table.getContainer().getDataDescription().getRowByKey(dataDescriptionId.at(i)));
3027 :
3028 4308 : return result;
3029 : }
3030 :
3031 :
3032 :
3033 :
3034 :
3035 :
3036 :
3037 :
3038 :
3039 : /**
3040 : * Returns the pointer to the row in the Processor table having Processor.processorId == processorId
3041 : * @return a ProcessorRow*
3042 : *
3043 :
3044 : */
3045 5079 : ProcessorRow* ConfigDescriptionRow::getProcessorUsingProcessorId() {
3046 :
3047 5079 : return table.getContainer().getProcessor().getRowByKey(processorId);
3048 : }
3049 :
3050 :
3051 :
3052 :
3053 :
3054 : /**
3055 : * Create a ConfigDescriptionRow.
3056 : * <p>
3057 : * This constructor is private because only the
3058 : * table can create rows. All rows know the table
3059 : * to which they belong.
3060 : * @param table The table to which this row belongs.
3061 : */
3062 5581 : ConfigDescriptionRow::ConfigDescriptionRow (ConfigDescriptionTable &t) : table(t) {
3063 5581 : hasBeenAdded = false;
3064 :
3065 :
3066 :
3067 :
3068 :
3069 :
3070 :
3071 :
3072 :
3073 :
3074 :
3075 :
3076 :
3077 :
3078 :
3079 :
3080 :
3081 :
3082 :
3083 5581 : phasedArrayListExists = false;
3084 :
3085 :
3086 :
3087 :
3088 :
3089 5581 : numAssocValuesExists = false;
3090 :
3091 :
3092 :
3093 5581 : assocNatureExists = false;
3094 :
3095 :
3096 :
3097 :
3098 :
3099 :
3100 5581 : assocConfigDescriptionIdExists = false;
3101 :
3102 :
3103 :
3104 :
3105 :
3106 :
3107 :
3108 :
3109 :
3110 :
3111 :
3112 :
3113 :
3114 :
3115 :
3116 :
3117 :
3118 :
3119 :
3120 :
3121 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
3122 5581 : correlationMode = CCorrelationMode::from_int(0);
3123 :
3124 :
3125 :
3126 :
3127 :
3128 :
3129 :
3130 :
3131 :
3132 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
3133 5581 : processorType = CProcessorType::from_int(0);
3134 :
3135 :
3136 :
3137 :
3138 :
3139 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
3140 5581 : spectralType = CSpectralResolutionType::from_int(0);
3141 :
3142 :
3143 :
3144 :
3145 :
3146 :
3147 :
3148 :
3149 5581 : fromBinMethods["configDescriptionId"] = &ConfigDescriptionRow::configDescriptionIdFromBin;
3150 5581 : fromBinMethods["numAntenna"] = &ConfigDescriptionRow::numAntennaFromBin;
3151 5581 : fromBinMethods["numDataDescription"] = &ConfigDescriptionRow::numDataDescriptionFromBin;
3152 5581 : fromBinMethods["numFeed"] = &ConfigDescriptionRow::numFeedFromBin;
3153 5581 : fromBinMethods["correlationMode"] = &ConfigDescriptionRow::correlationModeFromBin;
3154 5581 : fromBinMethods["numAtmPhaseCorrection"] = &ConfigDescriptionRow::numAtmPhaseCorrectionFromBin;
3155 5581 : fromBinMethods["atmPhaseCorrection"] = &ConfigDescriptionRow::atmPhaseCorrectionFromBin;
3156 5581 : fromBinMethods["processorType"] = &ConfigDescriptionRow::processorTypeFromBin;
3157 5581 : fromBinMethods["spectralType"] = &ConfigDescriptionRow::spectralTypeFromBin;
3158 5581 : fromBinMethods["antennaId"] = &ConfigDescriptionRow::antennaIdFromBin;
3159 5581 : fromBinMethods["feedId"] = &ConfigDescriptionRow::feedIdFromBin;
3160 5581 : fromBinMethods["switchCycleId"] = &ConfigDescriptionRow::switchCycleIdFromBin;
3161 5581 : fromBinMethods["dataDescriptionId"] = &ConfigDescriptionRow::dataDescriptionIdFromBin;
3162 5581 : fromBinMethods["processorId"] = &ConfigDescriptionRow::processorIdFromBin;
3163 :
3164 :
3165 5581 : fromBinMethods["phasedArrayList"] = &ConfigDescriptionRow::phasedArrayListFromBin;
3166 5581 : fromBinMethods["numAssocValues"] = &ConfigDescriptionRow::numAssocValuesFromBin;
3167 5581 : fromBinMethods["assocNature"] = &ConfigDescriptionRow::assocNatureFromBin;
3168 5581 : fromBinMethods["assocConfigDescriptionId"] = &ConfigDescriptionRow::assocConfigDescriptionIdFromBin;
3169 :
3170 :
3171 :
3172 :
3173 :
3174 5581 : fromTextMethods["configDescriptionId"] = &ConfigDescriptionRow::configDescriptionIdFromText;
3175 :
3176 :
3177 :
3178 5581 : fromTextMethods["numAntenna"] = &ConfigDescriptionRow::numAntennaFromText;
3179 :
3180 :
3181 :
3182 5581 : fromTextMethods["numDataDescription"] = &ConfigDescriptionRow::numDataDescriptionFromText;
3183 :
3184 :
3185 :
3186 5581 : fromTextMethods["numFeed"] = &ConfigDescriptionRow::numFeedFromText;
3187 :
3188 :
3189 :
3190 5581 : fromTextMethods["correlationMode"] = &ConfigDescriptionRow::correlationModeFromText;
3191 :
3192 :
3193 :
3194 5581 : fromTextMethods["numAtmPhaseCorrection"] = &ConfigDescriptionRow::numAtmPhaseCorrectionFromText;
3195 :
3196 :
3197 :
3198 5581 : fromTextMethods["atmPhaseCorrection"] = &ConfigDescriptionRow::atmPhaseCorrectionFromText;
3199 :
3200 :
3201 :
3202 5581 : fromTextMethods["processorType"] = &ConfigDescriptionRow::processorTypeFromText;
3203 :
3204 :
3205 :
3206 5581 : fromTextMethods["spectralType"] = &ConfigDescriptionRow::spectralTypeFromText;
3207 :
3208 :
3209 :
3210 5581 : fromTextMethods["antennaId"] = &ConfigDescriptionRow::antennaIdFromText;
3211 :
3212 :
3213 :
3214 5581 : fromTextMethods["feedId"] = &ConfigDescriptionRow::feedIdFromText;
3215 :
3216 :
3217 :
3218 5581 : fromTextMethods["switchCycleId"] = &ConfigDescriptionRow::switchCycleIdFromText;
3219 :
3220 :
3221 :
3222 5581 : fromTextMethods["dataDescriptionId"] = &ConfigDescriptionRow::dataDescriptionIdFromText;
3223 :
3224 :
3225 :
3226 5581 : fromTextMethods["processorId"] = &ConfigDescriptionRow::processorIdFromText;
3227 :
3228 :
3229 :
3230 :
3231 :
3232 5581 : fromTextMethods["phasedArrayList"] = &ConfigDescriptionRow::phasedArrayListFromText;
3233 :
3234 :
3235 :
3236 5581 : fromTextMethods["numAssocValues"] = &ConfigDescriptionRow::numAssocValuesFromText;
3237 :
3238 :
3239 :
3240 5581 : fromTextMethods["assocNature"] = &ConfigDescriptionRow::assocNatureFromText;
3241 :
3242 :
3243 :
3244 5581 : fromTextMethods["assocConfigDescriptionId"] = &ConfigDescriptionRow::assocConfigDescriptionIdFromText;
3245 :
3246 :
3247 5581 : }
3248 :
3249 0 : ConfigDescriptionRow::ConfigDescriptionRow (ConfigDescriptionTable &t, ConfigDescriptionRow *row) : table(t) {
3250 0 : hasBeenAdded = false;
3251 :
3252 0 : if (row == 0) {
3253 :
3254 :
3255 :
3256 :
3257 :
3258 :
3259 :
3260 :
3261 :
3262 :
3263 :
3264 :
3265 :
3266 :
3267 :
3268 :
3269 :
3270 :
3271 :
3272 0 : phasedArrayListExists = false;
3273 :
3274 :
3275 :
3276 :
3277 :
3278 0 : numAssocValuesExists = false;
3279 :
3280 :
3281 :
3282 0 : assocNatureExists = false;
3283 :
3284 :
3285 :
3286 :
3287 :
3288 :
3289 0 : assocConfigDescriptionIdExists = false;
3290 :
3291 :
3292 :
3293 :
3294 :
3295 :
3296 :
3297 :
3298 :
3299 :
3300 : }
3301 : else {
3302 :
3303 :
3304 0 : configDescriptionId = row->configDescriptionId;
3305 :
3306 :
3307 :
3308 :
3309 0 : numAntenna = row->numAntenna;
3310 :
3311 0 : numDataDescription = row->numDataDescription;
3312 :
3313 0 : numFeed = row->numFeed;
3314 :
3315 0 : correlationMode = row->correlationMode;
3316 :
3317 0 : numAtmPhaseCorrection = row->numAtmPhaseCorrection;
3318 :
3319 0 : atmPhaseCorrection = row->atmPhaseCorrection;
3320 :
3321 0 : processorType = row->processorType;
3322 :
3323 0 : spectralType = row->spectralType;
3324 :
3325 0 : antennaId = row->antennaId;
3326 :
3327 0 : feedId = row->feedId;
3328 :
3329 0 : switchCycleId = row->switchCycleId;
3330 :
3331 0 : dataDescriptionId = row->dataDescriptionId;
3332 :
3333 0 : processorId = row->processorId;
3334 :
3335 :
3336 :
3337 :
3338 0 : if (row->phasedArrayListExists) {
3339 0 : phasedArrayList = row->phasedArrayList;
3340 0 : phasedArrayListExists = true;
3341 : }
3342 : else
3343 0 : phasedArrayListExists = false;
3344 :
3345 0 : if (row->numAssocValuesExists) {
3346 0 : numAssocValues = row->numAssocValues;
3347 0 : numAssocValuesExists = true;
3348 : }
3349 : else
3350 0 : numAssocValuesExists = false;
3351 :
3352 0 : if (row->assocNatureExists) {
3353 0 : assocNature = row->assocNature;
3354 0 : assocNatureExists = true;
3355 : }
3356 : else
3357 0 : assocNatureExists = false;
3358 :
3359 0 : if (row->assocConfigDescriptionIdExists) {
3360 0 : assocConfigDescriptionId = row->assocConfigDescriptionId;
3361 0 : assocConfigDescriptionIdExists = true;
3362 : }
3363 : else
3364 0 : assocConfigDescriptionIdExists = false;
3365 :
3366 : }
3367 :
3368 0 : fromBinMethods["configDescriptionId"] = &ConfigDescriptionRow::configDescriptionIdFromBin;
3369 0 : fromBinMethods["numAntenna"] = &ConfigDescriptionRow::numAntennaFromBin;
3370 0 : fromBinMethods["numDataDescription"] = &ConfigDescriptionRow::numDataDescriptionFromBin;
3371 0 : fromBinMethods["numFeed"] = &ConfigDescriptionRow::numFeedFromBin;
3372 0 : fromBinMethods["correlationMode"] = &ConfigDescriptionRow::correlationModeFromBin;
3373 0 : fromBinMethods["numAtmPhaseCorrection"] = &ConfigDescriptionRow::numAtmPhaseCorrectionFromBin;
3374 0 : fromBinMethods["atmPhaseCorrection"] = &ConfigDescriptionRow::atmPhaseCorrectionFromBin;
3375 0 : fromBinMethods["processorType"] = &ConfigDescriptionRow::processorTypeFromBin;
3376 0 : fromBinMethods["spectralType"] = &ConfigDescriptionRow::spectralTypeFromBin;
3377 0 : fromBinMethods["antennaId"] = &ConfigDescriptionRow::antennaIdFromBin;
3378 0 : fromBinMethods["feedId"] = &ConfigDescriptionRow::feedIdFromBin;
3379 0 : fromBinMethods["switchCycleId"] = &ConfigDescriptionRow::switchCycleIdFromBin;
3380 0 : fromBinMethods["dataDescriptionId"] = &ConfigDescriptionRow::dataDescriptionIdFromBin;
3381 0 : fromBinMethods["processorId"] = &ConfigDescriptionRow::processorIdFromBin;
3382 :
3383 :
3384 0 : fromBinMethods["phasedArrayList"] = &ConfigDescriptionRow::phasedArrayListFromBin;
3385 0 : fromBinMethods["numAssocValues"] = &ConfigDescriptionRow::numAssocValuesFromBin;
3386 0 : fromBinMethods["assocNature"] = &ConfigDescriptionRow::assocNatureFromBin;
3387 0 : fromBinMethods["assocConfigDescriptionId"] = &ConfigDescriptionRow::assocConfigDescriptionIdFromBin;
3388 :
3389 0 : }
3390 :
3391 :
3392 24180 : bool ConfigDescriptionRow::compareNoAutoInc(int numAntenna, int numDataDescription, int numFeed, CorrelationModeMod::CorrelationMode correlationMode, int numAtmPhaseCorrection, std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection > atmPhaseCorrection, ProcessorTypeMod::ProcessorType processorType, SpectralResolutionTypeMod::SpectralResolutionType spectralType, std::vector<Tag> antennaId, std::vector<int> feedId, std::vector<Tag> switchCycleId, std::vector<Tag> dataDescriptionId, Tag processorId) {
3393 : bool result;
3394 24180 : result = true;
3395 :
3396 :
3397 :
3398 24180 : result = result && (this->numAntenna == numAntenna);
3399 :
3400 24180 : if (!result) return false;
3401 :
3402 :
3403 :
3404 :
3405 24180 : result = result && (this->numDataDescription == numDataDescription);
3406 :
3407 24180 : if (!result) return false;
3408 :
3409 :
3410 :
3411 :
3412 24146 : result = result && (this->numFeed == numFeed);
3413 :
3414 24146 : if (!result) return false;
3415 :
3416 :
3417 :
3418 :
3419 24146 : result = result && (this->correlationMode == correlationMode);
3420 :
3421 24146 : if (!result) return false;
3422 :
3423 :
3424 :
3425 :
3426 24130 : result = result && (this->numAtmPhaseCorrection == numAtmPhaseCorrection);
3427 :
3428 24130 : if (!result) return false;
3429 :
3430 :
3431 :
3432 :
3433 24130 : result = result && (this->atmPhaseCorrection == atmPhaseCorrection);
3434 :
3435 24130 : if (!result) return false;
3436 :
3437 :
3438 :
3439 :
3440 24130 : result = result && (this->processorType == processorType);
3441 :
3442 24130 : if (!result) return false;
3443 :
3444 :
3445 :
3446 :
3447 24130 : result = result && (this->spectralType == spectralType);
3448 :
3449 24130 : if (!result) return false;
3450 :
3451 :
3452 :
3453 :
3454 24095 : result = result && (this->antennaId == antennaId);
3455 :
3456 24095 : if (!result) return false;
3457 :
3458 :
3459 :
3460 :
3461 24095 : result = result && (this->feedId == feedId);
3462 :
3463 24095 : if (!result) return false;
3464 :
3465 :
3466 :
3467 :
3468 24095 : result = result && (this->switchCycleId == switchCycleId);
3469 :
3470 24095 : if (!result) return false;
3471 :
3472 :
3473 :
3474 :
3475 24095 : result = result && (this->dataDescriptionId == dataDescriptionId);
3476 :
3477 24095 : if (!result) return false;
3478 :
3479 :
3480 :
3481 :
3482 5193 : result = result && (this->processorId == processorId);
3483 :
3484 5193 : if (!result) return false;
3485 :
3486 :
3487 5193 : return result;
3488 : }
3489 :
3490 :
3491 :
3492 0 : bool ConfigDescriptionRow::compareRequiredValue(int numAntenna, int numDataDescription, int numFeed, CorrelationModeMod::CorrelationMode correlationMode, int numAtmPhaseCorrection, std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection > atmPhaseCorrection, ProcessorTypeMod::ProcessorType processorType, SpectralResolutionTypeMod::SpectralResolutionType spectralType, std::vector<Tag> antennaId, std::vector<int> feedId, std::vector<Tag> switchCycleId, std::vector<Tag> dataDescriptionId, Tag processorId) {
3493 : bool result;
3494 0 : result = true;
3495 :
3496 :
3497 0 : if (!(this->numAntenna == numAntenna)) return false;
3498 :
3499 :
3500 :
3501 0 : if (!(this->numDataDescription == numDataDescription)) return false;
3502 :
3503 :
3504 :
3505 0 : if (!(this->numFeed == numFeed)) return false;
3506 :
3507 :
3508 :
3509 0 : if (!(this->correlationMode == correlationMode)) return false;
3510 :
3511 :
3512 :
3513 0 : if (!(this->numAtmPhaseCorrection == numAtmPhaseCorrection)) return false;
3514 :
3515 :
3516 :
3517 0 : if (!(this->atmPhaseCorrection == atmPhaseCorrection)) return false;
3518 :
3519 :
3520 :
3521 0 : if (!(this->processorType == processorType)) return false;
3522 :
3523 :
3524 :
3525 0 : if (!(this->spectralType == spectralType)) return false;
3526 :
3527 :
3528 :
3529 0 : if (!(this->antennaId == antennaId)) return false;
3530 :
3531 :
3532 :
3533 0 : if (!(this->feedId == feedId)) return false;
3534 :
3535 :
3536 :
3537 0 : if (!(this->switchCycleId == switchCycleId)) return false;
3538 :
3539 :
3540 :
3541 0 : if (!(this->dataDescriptionId == dataDescriptionId)) return false;
3542 :
3543 :
3544 :
3545 0 : if (!(this->processorId == processorId)) return false;
3546 :
3547 :
3548 0 : return result;
3549 : }
3550 :
3551 :
3552 : /**
3553 : * Return true if all required attributes of the value part are equal to their homologues
3554 : * in x and false otherwise.
3555 : *
3556 :
3557 : * @param x a pointer on the ConfigDescriptionRow whose required attributes of the value part
3558 :
3559 : * will be compared with those of this.
3560 : * @return a boolean.
3561 : */
3562 0 : bool ConfigDescriptionRow::equalByRequiredValue(ConfigDescriptionRow* x ) {
3563 :
3564 :
3565 0 : if (this->numAntenna != x->numAntenna) return false;
3566 :
3567 0 : if (this->numDataDescription != x->numDataDescription) return false;
3568 :
3569 0 : if (this->numFeed != x->numFeed) return false;
3570 :
3571 0 : if (this->correlationMode != x->correlationMode) return false;
3572 :
3573 0 : if (this->numAtmPhaseCorrection != x->numAtmPhaseCorrection) return false;
3574 :
3575 0 : if (this->atmPhaseCorrection != x->atmPhaseCorrection) return false;
3576 :
3577 0 : if (this->processorType != x->processorType) return false;
3578 :
3579 0 : if (this->spectralType != x->spectralType) return false;
3580 :
3581 0 : if (this->antennaId != x->antennaId) return false;
3582 :
3583 0 : if (this->feedId != x->feedId) return false;
3584 :
3585 0 : if (this->switchCycleId != x->switchCycleId) return false;
3586 :
3587 0 : if (this->dataDescriptionId != x->dataDescriptionId) return false;
3588 :
3589 0 : if (this->processorId != x->processorId) return false;
3590 :
3591 :
3592 0 : return true;
3593 : }
3594 :
3595 : /*
3596 : map<string, ConfigDescriptionAttributeFromBin> ConfigDescriptionRow::initFromBinMethods() {
3597 : map<string, ConfigDescriptionAttributeFromBin> result;
3598 :
3599 : result["configDescriptionId"] = &ConfigDescriptionRow::configDescriptionIdFromBin;
3600 : result["numAntenna"] = &ConfigDescriptionRow::numAntennaFromBin;
3601 : result["numDataDescription"] = &ConfigDescriptionRow::numDataDescriptionFromBin;
3602 : result["numFeed"] = &ConfigDescriptionRow::numFeedFromBin;
3603 : result["correlationMode"] = &ConfigDescriptionRow::correlationModeFromBin;
3604 : result["numAtmPhaseCorrection"] = &ConfigDescriptionRow::numAtmPhaseCorrectionFromBin;
3605 : result["atmPhaseCorrection"] = &ConfigDescriptionRow::atmPhaseCorrectionFromBin;
3606 : result["processorType"] = &ConfigDescriptionRow::processorTypeFromBin;
3607 : result["spectralType"] = &ConfigDescriptionRow::spectralTypeFromBin;
3608 : result["antennaId"] = &ConfigDescriptionRow::antennaIdFromBin;
3609 : result["feedId"] = &ConfigDescriptionRow::feedIdFromBin;
3610 : result["switchCycleId"] = &ConfigDescriptionRow::switchCycleIdFromBin;
3611 : result["dataDescriptionId"] = &ConfigDescriptionRow::dataDescriptionIdFromBin;
3612 : result["processorId"] = &ConfigDescriptionRow::processorIdFromBin;
3613 :
3614 :
3615 : result["phasedArrayList"] = &ConfigDescriptionRow::phasedArrayListFromBin;
3616 : result["numAssocValues"] = &ConfigDescriptionRow::numAssocValuesFromBin;
3617 : result["assocNature"] = &ConfigDescriptionRow::assocNatureFromBin;
3618 : result["assocConfigDescriptionId"] = &ConfigDescriptionRow::assocConfigDescriptionIdFromBin;
3619 :
3620 :
3621 : return result;
3622 : }
3623 : */
3624 : } // End namespace asdm
3625 :
|
