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