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 SpectralWindowRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/SpectralWindowRow.h>
39 : #include <alma/ASDM/SpectralWindowTable.h>
40 :
41 : #include <alma/ASDM/SpectralWindowTable.h>
42 : #include <alma/ASDM/SpectralWindowRow.h>
43 :
44 : #include <alma/ASDM/SpectralWindowTable.h>
45 : #include <alma/ASDM/SpectralWindowRow.h>
46 :
47 : #include <alma/ASDM/DopplerTable.h>
48 : #include <alma/ASDM/DopplerRow.h>
49 :
50 :
51 : using asdm::ASDM;
52 : using asdm::SpectralWindowRow;
53 : using asdm::SpectralWindowTable;
54 :
55 : using asdm::SpectralWindowTable;
56 : using asdm::SpectralWindowRow;
57 :
58 : using asdm::SpectralWindowTable;
59 : using asdm::SpectralWindowRow;
60 :
61 : using asdm::DopplerTable;
62 : using asdm::DopplerRow;
63 :
64 :
65 : #include <alma/ASDM/Parser.h>
66 :
67 : #include <alma/ASDM/EnumerationParser.h>
68 : #include <alma/ASDM/ASDMValuesParser.h>
69 :
70 : #include <alma/ASDM/InvalidArgumentException.h>
71 :
72 : using namespace std;
73 :
74 : namespace asdm {
75 4798 : SpectralWindowRow::~SpectralWindowRow() {
76 4798 : }
77 :
78 : /**
79 : * Return the table to which this row belongs.
80 : */
81 0 : SpectralWindowTable &SpectralWindowRow::getTable() const {
82 0 : return table;
83 : }
84 :
85 0 : bool SpectralWindowRow::isAdded() const {
86 0 : return hasBeenAdded;
87 : }
88 :
89 2399 : void SpectralWindowRow::isAdded(bool added) {
90 2399 : hasBeenAdded = added;
91 2399 : }
92 :
93 : #ifndef WITHOUT_ACS
94 : using asdmIDL::SpectralWindowRowIDL;
95 : #endif
96 :
97 : #ifndef WITHOUT_ACS
98 : /**
99 : * Return this row in the form of an IDL struct.
100 : * @return The values of this row as a SpectralWindowRowIDL struct.
101 : */
102 : SpectralWindowRowIDL *SpectralWindowRow::toIDL() const {
103 : SpectralWindowRowIDL *x = new SpectralWindowRowIDL ();
104 :
105 : // Fill the IDL structure.
106 :
107 :
108 :
109 :
110 :
111 :
112 :
113 : x->spectralWindowId = spectralWindowId.toIDLTag();
114 :
115 :
116 :
117 :
118 :
119 :
120 :
121 :
122 :
123 :
124 : x->basebandName = basebandName;
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 :
135 :
136 : x->netSideband = netSideband;
137 :
138 :
139 :
140 :
141 :
142 :
143 :
144 :
145 :
146 :
147 :
148 : x->numChan = numChan;
149 :
150 :
151 :
152 :
153 :
154 :
155 :
156 :
157 : x->numBinExists = numBinExists;
158 :
159 :
160 :
161 :
162 : x->numBin = numBin;
163 :
164 :
165 :
166 :
167 :
168 :
169 :
170 :
171 :
172 :
173 : x->refFreq = refFreq.toIDLFrequency();
174 :
175 :
176 :
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 : x->sidebandProcessingMode = sidebandProcessingMode;
185 :
186 :
187 :
188 :
189 :
190 :
191 :
192 :
193 :
194 :
195 : x->totBandwidth = totBandwidth.toIDLFrequency();
196 :
197 :
198 :
199 :
200 :
201 :
202 :
203 :
204 :
205 :
206 : x->windowFunction = windowFunction;
207 :
208 :
209 :
210 :
211 :
212 :
213 :
214 :
215 : x->chanFreqStartExists = chanFreqStartExists;
216 :
217 :
218 :
219 : x->chanFreqStart = chanFreqStart.toIDLFrequency();
220 :
221 :
222 :
223 :
224 :
225 :
226 :
227 : x->chanFreqStepExists = chanFreqStepExists;
228 :
229 :
230 :
231 : x->chanFreqStep = chanFreqStep.toIDLFrequency();
232 :
233 :
234 :
235 :
236 :
237 :
238 :
239 : x->chanFreqArrayExists = chanFreqArrayExists;
240 :
241 :
242 :
243 : x->chanFreqArray.length(chanFreqArray.size());
244 : for (unsigned int i = 0; i < chanFreqArray.size(); ++i) {
245 :
246 : x->chanFreqArray[i] = chanFreqArray.at(i).toIDLFrequency();
247 :
248 : }
249 :
250 :
251 :
252 :
253 :
254 :
255 :
256 : x->chanWidthExists = chanWidthExists;
257 :
258 :
259 :
260 : x->chanWidth = chanWidth.toIDLFrequency();
261 :
262 :
263 :
264 :
265 :
266 :
267 :
268 : x->chanWidthArrayExists = chanWidthArrayExists;
269 :
270 :
271 :
272 : x->chanWidthArray.length(chanWidthArray.size());
273 : for (unsigned int i = 0; i < chanWidthArray.size(); ++i) {
274 :
275 : x->chanWidthArray[i] = chanWidthArray.at(i).toIDLFrequency();
276 :
277 : }
278 :
279 :
280 :
281 :
282 :
283 :
284 :
285 : x->correlationBitExists = correlationBitExists;
286 :
287 :
288 :
289 :
290 : x->correlationBit = correlationBit;
291 :
292 :
293 :
294 :
295 :
296 :
297 :
298 :
299 : x->effectiveBwExists = effectiveBwExists;
300 :
301 :
302 :
303 : x->effectiveBw = effectiveBw.toIDLFrequency();
304 :
305 :
306 :
307 :
308 :
309 :
310 :
311 : x->effectiveBwArrayExists = effectiveBwArrayExists;
312 :
313 :
314 :
315 : x->effectiveBwArray.length(effectiveBwArray.size());
316 : for (unsigned int i = 0; i < effectiveBwArray.size(); ++i) {
317 :
318 : x->effectiveBwArray[i] = effectiveBwArray.at(i).toIDLFrequency();
319 :
320 : }
321 :
322 :
323 :
324 :
325 :
326 :
327 :
328 : x->freqGroupExists = freqGroupExists;
329 :
330 :
331 :
332 :
333 : x->freqGroup = freqGroup;
334 :
335 :
336 :
337 :
338 :
339 :
340 :
341 :
342 : x->freqGroupNameExists = freqGroupNameExists;
343 :
344 :
345 :
346 :
347 : x->freqGroupName = CORBA::string_dup(freqGroupName.c_str());
348 :
349 :
350 :
351 :
352 :
353 :
354 :
355 :
356 : x->lineArrayExists = lineArrayExists;
357 :
358 :
359 :
360 : x->lineArray.length(lineArray.size());
361 : for (unsigned int i = 0; i < lineArray.size(); ++i) {
362 :
363 :
364 : x->lineArray[i] = lineArray.at(i);
365 :
366 :
367 : }
368 :
369 :
370 :
371 :
372 :
373 :
374 :
375 : x->measFreqRefExists = measFreqRefExists;
376 :
377 :
378 :
379 :
380 : x->measFreqRef = measFreqRef;
381 :
382 :
383 :
384 :
385 :
386 :
387 :
388 :
389 : x->nameExists = nameExists;
390 :
391 :
392 :
393 :
394 : x->name = CORBA::string_dup(name.c_str());
395 :
396 :
397 :
398 :
399 :
400 :
401 :
402 :
403 : x->oversamplingExists = oversamplingExists;
404 :
405 :
406 :
407 :
408 : x->oversampling = oversampling;
409 :
410 :
411 :
412 :
413 :
414 :
415 :
416 :
417 : x->quantizationExists = quantizationExists;
418 :
419 :
420 :
421 :
422 : x->quantization = quantization;
423 :
424 :
425 :
426 :
427 :
428 :
429 :
430 :
431 : x->refChanExists = refChanExists;
432 :
433 :
434 :
435 :
436 : x->refChan = refChan;
437 :
438 :
439 :
440 :
441 :
442 :
443 :
444 :
445 : x->resolutionExists = resolutionExists;
446 :
447 :
448 :
449 : x->resolution = resolution.toIDLFrequency();
450 :
451 :
452 :
453 :
454 :
455 :
456 :
457 : x->resolutionArrayExists = resolutionArrayExists;
458 :
459 :
460 :
461 : x->resolutionArray.length(resolutionArray.size());
462 : for (unsigned int i = 0; i < resolutionArray.size(); ++i) {
463 :
464 : x->resolutionArray[i] = resolutionArray.at(i).toIDLFrequency();
465 :
466 : }
467 :
468 :
469 :
470 :
471 :
472 :
473 :
474 : x->numAssocValuesExists = numAssocValuesExists;
475 :
476 :
477 :
478 :
479 : x->numAssocValues = numAssocValues;
480 :
481 :
482 :
483 :
484 :
485 :
486 :
487 :
488 : x->assocNatureExists = assocNatureExists;
489 :
490 :
491 :
492 : x->assocNature.length(assocNature.size());
493 : for (unsigned int i = 0; i < assocNature.size(); ++i) {
494 :
495 :
496 : x->assocNature[i] = assocNature.at(i);
497 :
498 :
499 : }
500 :
501 :
502 :
503 :
504 :
505 :
506 :
507 :
508 :
509 :
510 :
511 : x->assocSpectralWindowIdExists = assocSpectralWindowIdExists;
512 :
513 :
514 :
515 : x->assocSpectralWindowId.length(assocSpectralWindowId.size());
516 : for (unsigned int i = 0; i < assocSpectralWindowId.size(); ++i) {
517 :
518 : x->assocSpectralWindowId[i] = assocSpectralWindowId.at(i).toIDLTag();
519 :
520 : }
521 :
522 :
523 :
524 :
525 :
526 :
527 :
528 : x->dopplerIdExists = dopplerIdExists;
529 :
530 :
531 :
532 :
533 :
534 : x->dopplerId = dopplerId;
535 :
536 :
537 :
538 :
539 :
540 :
541 :
542 :
543 :
544 : x->imageSpectralWindowIdExists = imageSpectralWindowIdExists;
545 :
546 :
547 :
548 :
549 : x->imageSpectralWindowId = imageSpectralWindowId.toIDLTag();
550 :
551 :
552 :
553 :
554 :
555 :
556 :
557 :
558 :
559 :
560 :
561 :
562 :
563 : return x;
564 :
565 : }
566 :
567 : void SpectralWindowRow::toIDL(asdmIDL::SpectralWindowRowIDL& x) const {
568 : // Set the x's fields.
569 :
570 :
571 :
572 :
573 :
574 :
575 :
576 : x.spectralWindowId = spectralWindowId.toIDLTag();
577 :
578 :
579 :
580 :
581 :
582 :
583 :
584 :
585 :
586 :
587 : x.basebandName = basebandName;
588 :
589 :
590 :
591 :
592 :
593 :
594 :
595 :
596 :
597 :
598 :
599 : x.netSideband = netSideband;
600 :
601 :
602 :
603 :
604 :
605 :
606 :
607 :
608 :
609 :
610 :
611 : x.numChan = numChan;
612 :
613 :
614 :
615 :
616 :
617 :
618 :
619 :
620 : x.numBinExists = numBinExists;
621 :
622 :
623 :
624 :
625 : x.numBin = numBin;
626 :
627 :
628 :
629 :
630 :
631 :
632 :
633 :
634 :
635 :
636 : x.refFreq = refFreq.toIDLFrequency();
637 :
638 :
639 :
640 :
641 :
642 :
643 :
644 :
645 :
646 :
647 : x.sidebandProcessingMode = sidebandProcessingMode;
648 :
649 :
650 :
651 :
652 :
653 :
654 :
655 :
656 :
657 :
658 : x.totBandwidth = totBandwidth.toIDLFrequency();
659 :
660 :
661 :
662 :
663 :
664 :
665 :
666 :
667 :
668 :
669 : x.windowFunction = windowFunction;
670 :
671 :
672 :
673 :
674 :
675 :
676 :
677 :
678 : x.chanFreqStartExists = chanFreqStartExists;
679 :
680 :
681 :
682 : x.chanFreqStart = chanFreqStart.toIDLFrequency();
683 :
684 :
685 :
686 :
687 :
688 :
689 :
690 : x.chanFreqStepExists = chanFreqStepExists;
691 :
692 :
693 :
694 : x.chanFreqStep = chanFreqStep.toIDLFrequency();
695 :
696 :
697 :
698 :
699 :
700 :
701 :
702 : x.chanFreqArrayExists = chanFreqArrayExists;
703 :
704 :
705 :
706 : x.chanFreqArray.length(chanFreqArray.size());
707 : for (unsigned int i = 0; i < chanFreqArray.size(); ++i) {
708 :
709 : x.chanFreqArray[i] = chanFreqArray.at(i).toIDLFrequency();
710 :
711 : }
712 :
713 :
714 :
715 :
716 :
717 :
718 :
719 : x.chanWidthExists = chanWidthExists;
720 :
721 :
722 :
723 : x.chanWidth = chanWidth.toIDLFrequency();
724 :
725 :
726 :
727 :
728 :
729 :
730 :
731 : x.chanWidthArrayExists = chanWidthArrayExists;
732 :
733 :
734 :
735 : x.chanWidthArray.length(chanWidthArray.size());
736 : for (unsigned int i = 0; i < chanWidthArray.size(); ++i) {
737 :
738 : x.chanWidthArray[i] = chanWidthArray.at(i).toIDLFrequency();
739 :
740 : }
741 :
742 :
743 :
744 :
745 :
746 :
747 :
748 : x.correlationBitExists = correlationBitExists;
749 :
750 :
751 :
752 :
753 : x.correlationBit = correlationBit;
754 :
755 :
756 :
757 :
758 :
759 :
760 :
761 :
762 : x.effectiveBwExists = effectiveBwExists;
763 :
764 :
765 :
766 : x.effectiveBw = effectiveBw.toIDLFrequency();
767 :
768 :
769 :
770 :
771 :
772 :
773 :
774 : x.effectiveBwArrayExists = effectiveBwArrayExists;
775 :
776 :
777 :
778 : x.effectiveBwArray.length(effectiveBwArray.size());
779 : for (unsigned int i = 0; i < effectiveBwArray.size(); ++i) {
780 :
781 : x.effectiveBwArray[i] = effectiveBwArray.at(i).toIDLFrequency();
782 :
783 : }
784 :
785 :
786 :
787 :
788 :
789 :
790 :
791 : x.freqGroupExists = freqGroupExists;
792 :
793 :
794 :
795 :
796 : x.freqGroup = freqGroup;
797 :
798 :
799 :
800 :
801 :
802 :
803 :
804 :
805 : x.freqGroupNameExists = freqGroupNameExists;
806 :
807 :
808 :
809 :
810 : x.freqGroupName = CORBA::string_dup(freqGroupName.c_str());
811 :
812 :
813 :
814 :
815 :
816 :
817 :
818 :
819 : x.lineArrayExists = lineArrayExists;
820 :
821 :
822 :
823 : x.lineArray.length(lineArray.size());
824 : for (unsigned int i = 0; i < lineArray.size(); ++i) {
825 :
826 :
827 : x.lineArray[i] = lineArray.at(i);
828 :
829 :
830 : }
831 :
832 :
833 :
834 :
835 :
836 :
837 :
838 : x.measFreqRefExists = measFreqRefExists;
839 :
840 :
841 :
842 :
843 : x.measFreqRef = measFreqRef;
844 :
845 :
846 :
847 :
848 :
849 :
850 :
851 :
852 : x.nameExists = nameExists;
853 :
854 :
855 :
856 :
857 : x.name = CORBA::string_dup(name.c_str());
858 :
859 :
860 :
861 :
862 :
863 :
864 :
865 :
866 : x.oversamplingExists = oversamplingExists;
867 :
868 :
869 :
870 :
871 : x.oversampling = oversampling;
872 :
873 :
874 :
875 :
876 :
877 :
878 :
879 :
880 : x.quantizationExists = quantizationExists;
881 :
882 :
883 :
884 :
885 : x.quantization = quantization;
886 :
887 :
888 :
889 :
890 :
891 :
892 :
893 :
894 : x.refChanExists = refChanExists;
895 :
896 :
897 :
898 :
899 : x.refChan = refChan;
900 :
901 :
902 :
903 :
904 :
905 :
906 :
907 :
908 : x.resolutionExists = resolutionExists;
909 :
910 :
911 :
912 : x.resolution = resolution.toIDLFrequency();
913 :
914 :
915 :
916 :
917 :
918 :
919 :
920 : x.resolutionArrayExists = resolutionArrayExists;
921 :
922 :
923 :
924 : x.resolutionArray.length(resolutionArray.size());
925 : for (unsigned int i = 0; i < resolutionArray.size(); ++i) {
926 :
927 : x.resolutionArray[i] = resolutionArray.at(i).toIDLFrequency();
928 :
929 : }
930 :
931 :
932 :
933 :
934 :
935 :
936 :
937 : x.numAssocValuesExists = numAssocValuesExists;
938 :
939 :
940 :
941 :
942 : x.numAssocValues = numAssocValues;
943 :
944 :
945 :
946 :
947 :
948 :
949 :
950 :
951 : x.assocNatureExists = assocNatureExists;
952 :
953 :
954 :
955 : x.assocNature.length(assocNature.size());
956 : for (unsigned int i = 0; i < assocNature.size(); ++i) {
957 :
958 :
959 : x.assocNature[i] = assocNature.at(i);
960 :
961 :
962 : }
963 :
964 :
965 :
966 :
967 :
968 :
969 :
970 :
971 :
972 :
973 :
974 : x.assocSpectralWindowIdExists = assocSpectralWindowIdExists;
975 :
976 :
977 :
978 : x.assocSpectralWindowId.length(assocSpectralWindowId.size());
979 : for (unsigned int i = 0; i < assocSpectralWindowId.size(); ++i) {
980 :
981 : x.assocSpectralWindowId[i] = assocSpectralWindowId.at(i).toIDLTag();
982 :
983 : }
984 :
985 :
986 :
987 :
988 :
989 :
990 :
991 : x.dopplerIdExists = dopplerIdExists;
992 :
993 :
994 :
995 :
996 :
997 : x.dopplerId = dopplerId;
998 :
999 :
1000 :
1001 :
1002 :
1003 :
1004 :
1005 :
1006 :
1007 : x.imageSpectralWindowIdExists = imageSpectralWindowIdExists;
1008 :
1009 :
1010 :
1011 :
1012 : x.imageSpectralWindowId = imageSpectralWindowId.toIDLTag();
1013 :
1014 :
1015 :
1016 :
1017 :
1018 :
1019 :
1020 :
1021 :
1022 :
1023 :
1024 :
1025 :
1026 : }
1027 : #endif
1028 :
1029 :
1030 : #ifndef WITHOUT_ACS
1031 : /**
1032 : * Fill the values of this row from the IDL struct SpectralWindowRowIDL.
1033 : * @param x The IDL struct containing the values used to fill this row.
1034 : */
1035 : void SpectralWindowRow::setFromIDL (SpectralWindowRowIDL x){
1036 : try {
1037 : // Fill the values from x.
1038 :
1039 :
1040 :
1041 :
1042 :
1043 :
1044 : setSpectralWindowId(Tag (x.spectralWindowId));
1045 :
1046 :
1047 :
1048 :
1049 :
1050 :
1051 :
1052 :
1053 :
1054 : setBasebandName(x.basebandName);
1055 :
1056 :
1057 :
1058 :
1059 :
1060 :
1061 :
1062 :
1063 :
1064 : setNetSideband(x.netSideband);
1065 :
1066 :
1067 :
1068 :
1069 :
1070 :
1071 :
1072 :
1073 :
1074 : setNumChan(x.numChan);
1075 :
1076 :
1077 :
1078 :
1079 :
1080 :
1081 :
1082 : numBinExists = x.numBinExists;
1083 : if (x.numBinExists) {
1084 :
1085 :
1086 :
1087 : setNumBin(x.numBin);
1088 :
1089 :
1090 :
1091 : }
1092 :
1093 :
1094 :
1095 :
1096 :
1097 :
1098 :
1099 : setRefFreq(Frequency (x.refFreq));
1100 :
1101 :
1102 :
1103 :
1104 :
1105 :
1106 :
1107 :
1108 :
1109 : setSidebandProcessingMode(x.sidebandProcessingMode);
1110 :
1111 :
1112 :
1113 :
1114 :
1115 :
1116 :
1117 :
1118 :
1119 : setTotBandwidth(Frequency (x.totBandwidth));
1120 :
1121 :
1122 :
1123 :
1124 :
1125 :
1126 :
1127 :
1128 :
1129 : setWindowFunction(x.windowFunction);
1130 :
1131 :
1132 :
1133 :
1134 :
1135 :
1136 :
1137 : chanFreqStartExists = x.chanFreqStartExists;
1138 : if (x.chanFreqStartExists) {
1139 :
1140 :
1141 :
1142 : setChanFreqStart(Frequency (x.chanFreqStart));
1143 :
1144 :
1145 :
1146 : }
1147 :
1148 :
1149 :
1150 :
1151 :
1152 : chanFreqStepExists = x.chanFreqStepExists;
1153 : if (x.chanFreqStepExists) {
1154 :
1155 :
1156 :
1157 : setChanFreqStep(Frequency (x.chanFreqStep));
1158 :
1159 :
1160 :
1161 : }
1162 :
1163 :
1164 :
1165 :
1166 :
1167 : chanFreqArrayExists = x.chanFreqArrayExists;
1168 : if (x.chanFreqArrayExists) {
1169 :
1170 :
1171 :
1172 : chanFreqArray .clear();
1173 : for (unsigned int i = 0; i <x.chanFreqArray.length(); ++i) {
1174 :
1175 : chanFreqArray.push_back(Frequency (x.chanFreqArray[i]));
1176 :
1177 : }
1178 :
1179 :
1180 :
1181 : }
1182 :
1183 :
1184 :
1185 :
1186 :
1187 : chanWidthExists = x.chanWidthExists;
1188 : if (x.chanWidthExists) {
1189 :
1190 :
1191 :
1192 : setChanWidth(Frequency (x.chanWidth));
1193 :
1194 :
1195 :
1196 : }
1197 :
1198 :
1199 :
1200 :
1201 :
1202 : chanWidthArrayExists = x.chanWidthArrayExists;
1203 : if (x.chanWidthArrayExists) {
1204 :
1205 :
1206 :
1207 : chanWidthArray .clear();
1208 : for (unsigned int i = 0; i <x.chanWidthArray.length(); ++i) {
1209 :
1210 : chanWidthArray.push_back(Frequency (x.chanWidthArray[i]));
1211 :
1212 : }
1213 :
1214 :
1215 :
1216 : }
1217 :
1218 :
1219 :
1220 :
1221 :
1222 : correlationBitExists = x.correlationBitExists;
1223 : if (x.correlationBitExists) {
1224 :
1225 :
1226 :
1227 : setCorrelationBit(x.correlationBit);
1228 :
1229 :
1230 :
1231 : }
1232 :
1233 :
1234 :
1235 :
1236 :
1237 : effectiveBwExists = x.effectiveBwExists;
1238 : if (x.effectiveBwExists) {
1239 :
1240 :
1241 :
1242 : setEffectiveBw(Frequency (x.effectiveBw));
1243 :
1244 :
1245 :
1246 : }
1247 :
1248 :
1249 :
1250 :
1251 :
1252 : effectiveBwArrayExists = x.effectiveBwArrayExists;
1253 : if (x.effectiveBwArrayExists) {
1254 :
1255 :
1256 :
1257 : effectiveBwArray .clear();
1258 : for (unsigned int i = 0; i <x.effectiveBwArray.length(); ++i) {
1259 :
1260 : effectiveBwArray.push_back(Frequency (x.effectiveBwArray[i]));
1261 :
1262 : }
1263 :
1264 :
1265 :
1266 : }
1267 :
1268 :
1269 :
1270 :
1271 :
1272 : freqGroupExists = x.freqGroupExists;
1273 : if (x.freqGroupExists) {
1274 :
1275 :
1276 :
1277 : setFreqGroup(x.freqGroup);
1278 :
1279 :
1280 :
1281 : }
1282 :
1283 :
1284 :
1285 :
1286 :
1287 : freqGroupNameExists = x.freqGroupNameExists;
1288 : if (x.freqGroupNameExists) {
1289 :
1290 :
1291 :
1292 : setFreqGroupName(string (x.freqGroupName));
1293 :
1294 :
1295 :
1296 : }
1297 :
1298 :
1299 :
1300 :
1301 :
1302 : lineArrayExists = x.lineArrayExists;
1303 : if (x.lineArrayExists) {
1304 :
1305 :
1306 :
1307 : lineArray .clear();
1308 : for (unsigned int i = 0; i <x.lineArray.length(); ++i) {
1309 :
1310 : lineArray.push_back(x.lineArray[i]);
1311 :
1312 : }
1313 :
1314 :
1315 :
1316 : }
1317 :
1318 :
1319 :
1320 :
1321 :
1322 : measFreqRefExists = x.measFreqRefExists;
1323 : if (x.measFreqRefExists) {
1324 :
1325 :
1326 :
1327 : setMeasFreqRef(x.measFreqRef);
1328 :
1329 :
1330 :
1331 : }
1332 :
1333 :
1334 :
1335 :
1336 :
1337 : nameExists = x.nameExists;
1338 : if (x.nameExists) {
1339 :
1340 :
1341 :
1342 : setName(string (x.name));
1343 :
1344 :
1345 :
1346 : }
1347 :
1348 :
1349 :
1350 :
1351 :
1352 : oversamplingExists = x.oversamplingExists;
1353 : if (x.oversamplingExists) {
1354 :
1355 :
1356 :
1357 : setOversampling(x.oversampling);
1358 :
1359 :
1360 :
1361 : }
1362 :
1363 :
1364 :
1365 :
1366 :
1367 : quantizationExists = x.quantizationExists;
1368 : if (x.quantizationExists) {
1369 :
1370 :
1371 :
1372 : setQuantization(x.quantization);
1373 :
1374 :
1375 :
1376 : }
1377 :
1378 :
1379 :
1380 :
1381 :
1382 : refChanExists = x.refChanExists;
1383 : if (x.refChanExists) {
1384 :
1385 :
1386 :
1387 : setRefChan(x.refChan);
1388 :
1389 :
1390 :
1391 : }
1392 :
1393 :
1394 :
1395 :
1396 :
1397 : resolutionExists = x.resolutionExists;
1398 : if (x.resolutionExists) {
1399 :
1400 :
1401 :
1402 : setResolution(Frequency (x.resolution));
1403 :
1404 :
1405 :
1406 : }
1407 :
1408 :
1409 :
1410 :
1411 :
1412 : resolutionArrayExists = x.resolutionArrayExists;
1413 : if (x.resolutionArrayExists) {
1414 :
1415 :
1416 :
1417 : resolutionArray .clear();
1418 : for (unsigned int i = 0; i <x.resolutionArray.length(); ++i) {
1419 :
1420 : resolutionArray.push_back(Frequency (x.resolutionArray[i]));
1421 :
1422 : }
1423 :
1424 :
1425 :
1426 : }
1427 :
1428 :
1429 :
1430 :
1431 :
1432 : numAssocValuesExists = x.numAssocValuesExists;
1433 : if (x.numAssocValuesExists) {
1434 :
1435 :
1436 :
1437 : setNumAssocValues(x.numAssocValues);
1438 :
1439 :
1440 :
1441 : }
1442 :
1443 :
1444 :
1445 :
1446 :
1447 : assocNatureExists = x.assocNatureExists;
1448 : if (x.assocNatureExists) {
1449 :
1450 :
1451 :
1452 : assocNature .clear();
1453 : for (unsigned int i = 0; i <x.assocNature.length(); ++i) {
1454 :
1455 : assocNature.push_back(x.assocNature[i]);
1456 :
1457 : }
1458 :
1459 :
1460 :
1461 : }
1462 :
1463 :
1464 :
1465 :
1466 :
1467 :
1468 :
1469 :
1470 : assocSpectralWindowIdExists = x.assocSpectralWindowIdExists;
1471 : if (x.assocSpectralWindowIdExists) {
1472 :
1473 : assocSpectralWindowId .clear();
1474 : for (unsigned int i = 0; i <x.assocSpectralWindowId.length(); ++i) {
1475 :
1476 : assocSpectralWindowId.push_back(Tag (x.assocSpectralWindowId[i]));
1477 :
1478 : }
1479 :
1480 : }
1481 :
1482 :
1483 :
1484 :
1485 :
1486 : dopplerIdExists = x.dopplerIdExists;
1487 : if (x.dopplerIdExists) {
1488 :
1489 :
1490 :
1491 : setDopplerId(x.dopplerId);
1492 :
1493 :
1494 :
1495 : }
1496 :
1497 :
1498 :
1499 :
1500 :
1501 : imageSpectralWindowIdExists = x.imageSpectralWindowIdExists;
1502 : if (x.imageSpectralWindowIdExists) {
1503 :
1504 :
1505 :
1506 : setImageSpectralWindowId(Tag (x.imageSpectralWindowId));
1507 :
1508 :
1509 :
1510 : }
1511 :
1512 :
1513 :
1514 :
1515 :
1516 :
1517 :
1518 :
1519 :
1520 :
1521 :
1522 : } catch (const IllegalAccessException &err) {
1523 : throw ConversionException (err.getMessage(),"SpectralWindow");
1524 : }
1525 : }
1526 : #endif
1527 :
1528 : /**
1529 : * Return this row in the form of an XML string.
1530 : * @return The values of this row as an XML string.
1531 : */
1532 83 : string SpectralWindowRow::toXML() const {
1533 83 : string buf;
1534 83 : buf.append("<row> \n");
1535 :
1536 :
1537 :
1538 :
1539 :
1540 :
1541 83 : Parser::toXML(spectralWindowId, "spectralWindowId", buf);
1542 :
1543 :
1544 :
1545 :
1546 :
1547 :
1548 :
1549 83 : buf.append(EnumerationParser::toXML("basebandName", basebandName));
1550 :
1551 :
1552 :
1553 :
1554 :
1555 :
1556 :
1557 83 : buf.append(EnumerationParser::toXML("netSideband", netSideband));
1558 :
1559 :
1560 :
1561 :
1562 :
1563 :
1564 :
1565 83 : Parser::toXML(numChan, "numChan", buf);
1566 :
1567 :
1568 :
1569 :
1570 :
1571 :
1572 83 : if (numBinExists) {
1573 :
1574 :
1575 0 : Parser::toXML(numBin, "numBin", buf);
1576 :
1577 :
1578 : }
1579 :
1580 :
1581 :
1582 :
1583 :
1584 :
1585 83 : Parser::toXML(refFreq, "refFreq", buf);
1586 :
1587 :
1588 :
1589 :
1590 :
1591 :
1592 :
1593 83 : buf.append(EnumerationParser::toXML("sidebandProcessingMode", sidebandProcessingMode));
1594 :
1595 :
1596 :
1597 :
1598 :
1599 :
1600 :
1601 83 : Parser::toXML(totBandwidth, "totBandwidth", buf);
1602 :
1603 :
1604 :
1605 :
1606 :
1607 :
1608 :
1609 83 : buf.append(EnumerationParser::toXML("windowFunction", windowFunction));
1610 :
1611 :
1612 :
1613 :
1614 :
1615 :
1616 83 : if (chanFreqStartExists) {
1617 :
1618 :
1619 0 : Parser::toXML(chanFreqStart, "chanFreqStart", buf);
1620 :
1621 :
1622 : }
1623 :
1624 :
1625 :
1626 :
1627 :
1628 83 : if (chanFreqStepExists) {
1629 :
1630 :
1631 0 : Parser::toXML(chanFreqStep, "chanFreqStep", buf);
1632 :
1633 :
1634 : }
1635 :
1636 :
1637 :
1638 :
1639 :
1640 83 : if (chanFreqArrayExists) {
1641 :
1642 :
1643 83 : Parser::toXML(chanFreqArray, "chanFreqArray", buf);
1644 :
1645 :
1646 : }
1647 :
1648 :
1649 :
1650 :
1651 :
1652 83 : if (chanWidthExists) {
1653 :
1654 :
1655 0 : Parser::toXML(chanWidth, "chanWidth", buf);
1656 :
1657 :
1658 : }
1659 :
1660 :
1661 :
1662 :
1663 :
1664 83 : if (chanWidthArrayExists) {
1665 :
1666 :
1667 83 : Parser::toXML(chanWidthArray, "chanWidthArray", buf);
1668 :
1669 :
1670 : }
1671 :
1672 :
1673 :
1674 :
1675 :
1676 83 : if (correlationBitExists) {
1677 :
1678 :
1679 0 : buf.append(EnumerationParser::toXML("correlationBit", correlationBit));
1680 :
1681 :
1682 : }
1683 :
1684 :
1685 :
1686 :
1687 :
1688 83 : if (effectiveBwExists) {
1689 :
1690 :
1691 0 : Parser::toXML(effectiveBw, "effectiveBw", buf);
1692 :
1693 :
1694 : }
1695 :
1696 :
1697 :
1698 :
1699 :
1700 83 : if (effectiveBwArrayExists) {
1701 :
1702 :
1703 83 : Parser::toXML(effectiveBwArray, "effectiveBwArray", buf);
1704 :
1705 :
1706 : }
1707 :
1708 :
1709 :
1710 :
1711 :
1712 83 : if (freqGroupExists) {
1713 :
1714 :
1715 83 : Parser::toXML(freqGroup, "freqGroup", buf);
1716 :
1717 :
1718 : }
1719 :
1720 :
1721 :
1722 :
1723 :
1724 83 : if (freqGroupNameExists) {
1725 :
1726 :
1727 83 : Parser::toXML(freqGroupName, "freqGroupName", buf);
1728 :
1729 :
1730 : }
1731 :
1732 :
1733 :
1734 :
1735 :
1736 83 : if (lineArrayExists) {
1737 :
1738 :
1739 0 : Parser::toXML(lineArray, "lineArray", buf);
1740 :
1741 :
1742 : }
1743 :
1744 :
1745 :
1746 :
1747 :
1748 83 : if (measFreqRefExists) {
1749 :
1750 :
1751 83 : buf.append(EnumerationParser::toXML("measFreqRef", measFreqRef));
1752 :
1753 :
1754 : }
1755 :
1756 :
1757 :
1758 :
1759 :
1760 83 : if (nameExists) {
1761 :
1762 :
1763 0 : Parser::toXML(name, "name", buf);
1764 :
1765 :
1766 : }
1767 :
1768 :
1769 :
1770 :
1771 :
1772 83 : if (oversamplingExists) {
1773 :
1774 :
1775 0 : Parser::toXML(oversampling, "oversampling", buf);
1776 :
1777 :
1778 : }
1779 :
1780 :
1781 :
1782 :
1783 :
1784 83 : if (quantizationExists) {
1785 :
1786 :
1787 0 : Parser::toXML(quantization, "quantization", buf);
1788 :
1789 :
1790 : }
1791 :
1792 :
1793 :
1794 :
1795 :
1796 83 : if (refChanExists) {
1797 :
1798 :
1799 0 : Parser::toXML(refChan, "refChan", buf);
1800 :
1801 :
1802 : }
1803 :
1804 :
1805 :
1806 :
1807 :
1808 83 : if (resolutionExists) {
1809 :
1810 :
1811 0 : Parser::toXML(resolution, "resolution", buf);
1812 :
1813 :
1814 : }
1815 :
1816 :
1817 :
1818 :
1819 :
1820 83 : if (resolutionArrayExists) {
1821 :
1822 :
1823 83 : Parser::toXML(resolutionArray, "resolutionArray", buf);
1824 :
1825 :
1826 : }
1827 :
1828 :
1829 :
1830 :
1831 :
1832 83 : if (numAssocValuesExists) {
1833 :
1834 :
1835 0 : Parser::toXML(numAssocValues, "numAssocValues", buf);
1836 :
1837 :
1838 : }
1839 :
1840 :
1841 :
1842 :
1843 :
1844 83 : if (assocNatureExists) {
1845 :
1846 :
1847 0 : buf.append(EnumerationParser::toXML("assocNature", assocNature));
1848 :
1849 :
1850 : }
1851 :
1852 :
1853 :
1854 :
1855 :
1856 :
1857 :
1858 :
1859 83 : if (assocSpectralWindowIdExists) {
1860 :
1861 :
1862 0 : Parser::toXML(assocSpectralWindowId, "assocSpectralWindowId", buf);
1863 :
1864 :
1865 : }
1866 :
1867 :
1868 :
1869 :
1870 :
1871 83 : if (dopplerIdExists) {
1872 :
1873 :
1874 0 : Parser::toXML(dopplerId, "dopplerId", buf);
1875 :
1876 :
1877 : }
1878 :
1879 :
1880 :
1881 :
1882 :
1883 83 : if (imageSpectralWindowIdExists) {
1884 :
1885 :
1886 0 : Parser::toXML(imageSpectralWindowId, "imageSpectralWindowId", buf);
1887 :
1888 :
1889 : }
1890 :
1891 :
1892 :
1893 :
1894 :
1895 :
1896 :
1897 :
1898 :
1899 :
1900 :
1901 :
1902 83 : buf.append("</row>\n");
1903 83 : return buf;
1904 0 : }
1905 :
1906 : /**
1907 : * Fill the values of this row from an XML string
1908 : * that was produced by the toXML() method.
1909 : * @param x The XML string being used to set the values of this row.
1910 : */
1911 2292 : void SpectralWindowRow::setFromXML (string rowDoc) {
1912 2292 : Parser row(rowDoc);
1913 2292 : string s = "";
1914 : try {
1915 :
1916 :
1917 :
1918 :
1919 :
1920 2292 : setSpectralWindowId(Parser::getTag("spectralWindowId","SpectralWindow",rowDoc));
1921 :
1922 :
1923 :
1924 :
1925 :
1926 :
1927 :
1928 :
1929 2292 : basebandName = EnumerationParser::getBasebandName("basebandName","SpectralWindow",rowDoc);
1930 :
1931 :
1932 :
1933 :
1934 :
1935 :
1936 :
1937 :
1938 :
1939 2292 : netSideband = EnumerationParser::getNetSideband("netSideband","SpectralWindow",rowDoc);
1940 :
1941 :
1942 :
1943 :
1944 :
1945 :
1946 :
1947 :
1948 2292 : setNumChan(Parser::getInteger("numChan","SpectralWindow",rowDoc));
1949 :
1950 :
1951 :
1952 :
1953 :
1954 :
1955 2292 : if (row.isStr("<numBin>")) {
1956 :
1957 217 : setNumBin(Parser::getInteger("numBin","SpectralWindow",rowDoc));
1958 :
1959 : }
1960 :
1961 :
1962 :
1963 :
1964 :
1965 :
1966 2292 : setRefFreq(Parser::getFrequency("refFreq","SpectralWindow",rowDoc));
1967 :
1968 :
1969 :
1970 :
1971 :
1972 :
1973 :
1974 :
1975 2292 : sidebandProcessingMode = EnumerationParser::getSidebandProcessingMode("sidebandProcessingMode","SpectralWindow",rowDoc);
1976 :
1977 :
1978 :
1979 :
1980 :
1981 :
1982 :
1983 :
1984 2292 : setTotBandwidth(Parser::getFrequency("totBandwidth","SpectralWindow",rowDoc));
1985 :
1986 :
1987 :
1988 :
1989 :
1990 :
1991 :
1992 :
1993 2292 : windowFunction = EnumerationParser::getWindowFunction("windowFunction","SpectralWindow",rowDoc);
1994 :
1995 :
1996 :
1997 :
1998 :
1999 :
2000 :
2001 2292 : if (row.isStr("<chanFreqStart>")) {
2002 :
2003 731 : setChanFreqStart(Parser::getFrequency("chanFreqStart","SpectralWindow",rowDoc));
2004 :
2005 : }
2006 :
2007 :
2008 :
2009 :
2010 :
2011 2292 : if (row.isStr("<chanFreqStep>")) {
2012 :
2013 731 : setChanFreqStep(Parser::getFrequency("chanFreqStep","SpectralWindow",rowDoc));
2014 :
2015 : }
2016 :
2017 :
2018 :
2019 :
2020 :
2021 2292 : if (row.isStr("<chanFreqArray>")) {
2022 :
2023 :
2024 1561 : setChanFreqArray(Parser::get1DFrequency("chanFreqArray","SpectralWindow",rowDoc));
2025 :
2026 :
2027 : }
2028 :
2029 :
2030 :
2031 :
2032 :
2033 2292 : if (row.isStr("<chanWidth>")) {
2034 :
2035 779 : setChanWidth(Parser::getFrequency("chanWidth","SpectralWindow",rowDoc));
2036 :
2037 : }
2038 :
2039 :
2040 :
2041 :
2042 :
2043 2292 : if (row.isStr("<chanWidthArray>")) {
2044 :
2045 :
2046 1513 : setChanWidthArray(Parser::get1DFrequency("chanWidthArray","SpectralWindow",rowDoc));
2047 :
2048 :
2049 : }
2050 :
2051 :
2052 :
2053 :
2054 :
2055 2292 : if (row.isStr("<correlationBit>")) {
2056 :
2057 :
2058 :
2059 298 : correlationBit = EnumerationParser::getCorrelationBit("correlationBit","SpectralWindow",rowDoc);
2060 :
2061 :
2062 :
2063 298 : correlationBitExists = true;
2064 : }
2065 :
2066 :
2067 :
2068 :
2069 :
2070 2292 : if (row.isStr("<effectiveBw>")) {
2071 :
2072 779 : setEffectiveBw(Parser::getFrequency("effectiveBw","SpectralWindow",rowDoc));
2073 :
2074 : }
2075 :
2076 :
2077 :
2078 :
2079 :
2080 2292 : if (row.isStr("<effectiveBwArray>")) {
2081 :
2082 :
2083 1513 : setEffectiveBwArray(Parser::get1DFrequency("effectiveBwArray","SpectralWindow",rowDoc));
2084 :
2085 :
2086 : }
2087 :
2088 :
2089 :
2090 :
2091 :
2092 2292 : if (row.isStr("<freqGroup>")) {
2093 :
2094 4 : setFreqGroup(Parser::getInteger("freqGroup","SpectralWindow",rowDoc));
2095 :
2096 : }
2097 :
2098 :
2099 :
2100 :
2101 :
2102 2292 : if (row.isStr("<freqGroupName>")) {
2103 :
2104 4 : setFreqGroupName(Parser::getString("freqGroupName","SpectralWindow",rowDoc));
2105 :
2106 : }
2107 :
2108 :
2109 :
2110 :
2111 :
2112 2292 : if (row.isStr("<lineArray>")) {
2113 :
2114 :
2115 0 : setLineArray(Parser::get1DBoolean("lineArray","SpectralWindow",rowDoc));
2116 :
2117 :
2118 : }
2119 :
2120 :
2121 :
2122 :
2123 :
2124 2292 : if (row.isStr("<measFreqRef>")) {
2125 :
2126 :
2127 :
2128 4 : measFreqRef = EnumerationParser::getFrequencyReferenceCode("measFreqRef","SpectralWindow",rowDoc);
2129 :
2130 :
2131 :
2132 4 : measFreqRefExists = true;
2133 : }
2134 :
2135 :
2136 :
2137 :
2138 :
2139 2292 : if (row.isStr("<name>")) {
2140 :
2141 2278 : setName(Parser::getString("name","SpectralWindow",rowDoc));
2142 :
2143 : }
2144 :
2145 :
2146 :
2147 :
2148 :
2149 2292 : if (row.isStr("<oversampling>")) {
2150 :
2151 298 : setOversampling(Parser::getBoolean("oversampling","SpectralWindow",rowDoc));
2152 :
2153 : }
2154 :
2155 :
2156 :
2157 :
2158 :
2159 2292 : if (row.isStr("<quantization>")) {
2160 :
2161 1164 : setQuantization(Parser::getBoolean("quantization","SpectralWindow",rowDoc));
2162 :
2163 : }
2164 :
2165 :
2166 :
2167 :
2168 :
2169 2292 : if (row.isStr("<refChan>")) {
2170 :
2171 861 : setRefChan(Parser::getDouble("refChan","SpectralWindow",rowDoc));
2172 :
2173 : }
2174 :
2175 :
2176 :
2177 :
2178 :
2179 2292 : if (row.isStr("<resolution>")) {
2180 :
2181 779 : setResolution(Parser::getFrequency("resolution","SpectralWindow",rowDoc));
2182 :
2183 : }
2184 :
2185 :
2186 :
2187 :
2188 :
2189 2292 : if (row.isStr("<resolutionArray>")) {
2190 :
2191 :
2192 1513 : setResolutionArray(Parser::get1DFrequency("resolutionArray","SpectralWindow",rowDoc));
2193 :
2194 :
2195 : }
2196 :
2197 :
2198 :
2199 :
2200 :
2201 2292 : if (row.isStr("<numAssocValues>")) {
2202 :
2203 1974 : setNumAssocValues(Parser::getInteger("numAssocValues","SpectralWindow",rowDoc));
2204 :
2205 : }
2206 :
2207 :
2208 :
2209 :
2210 :
2211 2292 : if (row.isStr("<assocNature>")) {
2212 :
2213 :
2214 :
2215 1974 : assocNature = EnumerationParser::getSpectralResolutionType1D("assocNature","SpectralWindow",rowDoc);
2216 :
2217 :
2218 :
2219 1974 : assocNatureExists = true;
2220 : }
2221 :
2222 :
2223 :
2224 :
2225 :
2226 :
2227 :
2228 :
2229 2292 : if (row.isStr("<assocSpectralWindowId>")) {
2230 1974 : setAssocSpectralWindowId(Parser::get1DTag("assocSpectralWindowId","SpectralWindow",rowDoc));
2231 : }
2232 :
2233 :
2234 :
2235 :
2236 :
2237 2292 : if (row.isStr("<dopplerId>")) {
2238 :
2239 0 : setDopplerId(Parser::getInteger("dopplerId","SpectralWindow",rowDoc));
2240 :
2241 : }
2242 :
2243 :
2244 :
2245 :
2246 :
2247 2292 : if (row.isStr("<imageSpectralWindowId>")) {
2248 :
2249 0 : setImageSpectralWindowId(Parser::getTag("imageSpectralWindowId","SpectralWindow",rowDoc));
2250 :
2251 : }
2252 :
2253 :
2254 :
2255 :
2256 :
2257 :
2258 :
2259 :
2260 :
2261 :
2262 :
2263 0 : } catch (const IllegalAccessException &err) {
2264 0 : throw ConversionException (err.getMessage(),"SpectralWindow");
2265 0 : }
2266 2292 : }
2267 :
2268 0 : void SpectralWindowRow::toBin(EndianOSStream& eoss) {
2269 :
2270 :
2271 :
2272 :
2273 :
2274 0 : spectralWindowId.toBin(eoss);
2275 :
2276 :
2277 :
2278 :
2279 :
2280 :
2281 :
2282 0 : eoss.writeString(CBasebandName::name(basebandName));
2283 : /* eoss.writeInt(basebandName); */
2284 :
2285 :
2286 :
2287 :
2288 :
2289 :
2290 :
2291 :
2292 0 : eoss.writeString(CNetSideband::name(netSideband));
2293 : /* eoss.writeInt(netSideband); */
2294 :
2295 :
2296 :
2297 :
2298 :
2299 :
2300 :
2301 :
2302 0 : eoss.writeInt(numChan);
2303 :
2304 :
2305 :
2306 :
2307 :
2308 :
2309 :
2310 0 : refFreq.toBin(eoss);
2311 :
2312 :
2313 :
2314 :
2315 :
2316 :
2317 :
2318 0 : eoss.writeString(CSidebandProcessingMode::name(sidebandProcessingMode));
2319 : /* eoss.writeInt(sidebandProcessingMode); */
2320 :
2321 :
2322 :
2323 :
2324 :
2325 :
2326 :
2327 0 : totBandwidth.toBin(eoss);
2328 :
2329 :
2330 :
2331 :
2332 :
2333 :
2334 :
2335 0 : eoss.writeString(CWindowFunction::name(windowFunction));
2336 : /* eoss.writeInt(windowFunction); */
2337 :
2338 :
2339 :
2340 :
2341 :
2342 :
2343 :
2344 0 : eoss.writeBoolean(numBinExists);
2345 0 : if (numBinExists) {
2346 :
2347 :
2348 :
2349 :
2350 :
2351 0 : eoss.writeInt(numBin);
2352 :
2353 :
2354 :
2355 :
2356 : }
2357 :
2358 0 : eoss.writeBoolean(chanFreqStartExists);
2359 0 : if (chanFreqStartExists) {
2360 :
2361 :
2362 :
2363 :
2364 0 : chanFreqStart.toBin(eoss);
2365 :
2366 :
2367 :
2368 : }
2369 :
2370 0 : eoss.writeBoolean(chanFreqStepExists);
2371 0 : if (chanFreqStepExists) {
2372 :
2373 :
2374 :
2375 :
2376 0 : chanFreqStep.toBin(eoss);
2377 :
2378 :
2379 :
2380 : }
2381 :
2382 0 : eoss.writeBoolean(chanFreqArrayExists);
2383 0 : if (chanFreqArrayExists) {
2384 :
2385 :
2386 :
2387 :
2388 0 : Frequency::toBin(chanFreqArray, eoss);
2389 :
2390 :
2391 :
2392 : }
2393 :
2394 0 : eoss.writeBoolean(chanWidthExists);
2395 0 : if (chanWidthExists) {
2396 :
2397 :
2398 :
2399 :
2400 0 : chanWidth.toBin(eoss);
2401 :
2402 :
2403 :
2404 : }
2405 :
2406 0 : eoss.writeBoolean(chanWidthArrayExists);
2407 0 : if (chanWidthArrayExists) {
2408 :
2409 :
2410 :
2411 :
2412 0 : Frequency::toBin(chanWidthArray, eoss);
2413 :
2414 :
2415 :
2416 : }
2417 :
2418 0 : eoss.writeBoolean(correlationBitExists);
2419 0 : if (correlationBitExists) {
2420 :
2421 :
2422 :
2423 :
2424 :
2425 0 : eoss.writeString(CCorrelationBit::name(correlationBit));
2426 : /* eoss.writeInt(correlationBit); */
2427 :
2428 :
2429 :
2430 :
2431 : }
2432 :
2433 0 : eoss.writeBoolean(effectiveBwExists);
2434 0 : if (effectiveBwExists) {
2435 :
2436 :
2437 :
2438 :
2439 0 : effectiveBw.toBin(eoss);
2440 :
2441 :
2442 :
2443 : }
2444 :
2445 0 : eoss.writeBoolean(effectiveBwArrayExists);
2446 0 : if (effectiveBwArrayExists) {
2447 :
2448 :
2449 :
2450 :
2451 0 : Frequency::toBin(effectiveBwArray, eoss);
2452 :
2453 :
2454 :
2455 : }
2456 :
2457 0 : eoss.writeBoolean(freqGroupExists);
2458 0 : if (freqGroupExists) {
2459 :
2460 :
2461 :
2462 :
2463 :
2464 0 : eoss.writeInt(freqGroup);
2465 :
2466 :
2467 :
2468 :
2469 : }
2470 :
2471 0 : eoss.writeBoolean(freqGroupNameExists);
2472 0 : if (freqGroupNameExists) {
2473 :
2474 :
2475 :
2476 :
2477 :
2478 0 : eoss.writeString(freqGroupName);
2479 :
2480 :
2481 :
2482 :
2483 : }
2484 :
2485 0 : eoss.writeBoolean(lineArrayExists);
2486 0 : if (lineArrayExists) {
2487 :
2488 :
2489 :
2490 :
2491 :
2492 :
2493 0 : eoss.writeInt((int) lineArray.size());
2494 0 : for (unsigned int i = 0; i < lineArray.size(); i++)
2495 :
2496 0 : eoss.writeBoolean(lineArray.at(i));
2497 :
2498 :
2499 :
2500 :
2501 :
2502 :
2503 : }
2504 :
2505 0 : eoss.writeBoolean(measFreqRefExists);
2506 0 : if (measFreqRefExists) {
2507 :
2508 :
2509 :
2510 :
2511 :
2512 0 : eoss.writeString(CFrequencyReferenceCode::name(measFreqRef));
2513 : /* eoss.writeInt(measFreqRef); */
2514 :
2515 :
2516 :
2517 :
2518 : }
2519 :
2520 0 : eoss.writeBoolean(nameExists);
2521 0 : if (nameExists) {
2522 :
2523 :
2524 :
2525 :
2526 :
2527 0 : eoss.writeString(name);
2528 :
2529 :
2530 :
2531 :
2532 : }
2533 :
2534 0 : eoss.writeBoolean(oversamplingExists);
2535 0 : if (oversamplingExists) {
2536 :
2537 :
2538 :
2539 :
2540 :
2541 0 : eoss.writeBoolean(oversampling);
2542 :
2543 :
2544 :
2545 :
2546 : }
2547 :
2548 0 : eoss.writeBoolean(quantizationExists);
2549 0 : if (quantizationExists) {
2550 :
2551 :
2552 :
2553 :
2554 :
2555 0 : eoss.writeBoolean(quantization);
2556 :
2557 :
2558 :
2559 :
2560 : }
2561 :
2562 0 : eoss.writeBoolean(refChanExists);
2563 0 : if (refChanExists) {
2564 :
2565 :
2566 :
2567 :
2568 :
2569 0 : eoss.writeDouble(refChan);
2570 :
2571 :
2572 :
2573 :
2574 : }
2575 :
2576 0 : eoss.writeBoolean(resolutionExists);
2577 0 : if (resolutionExists) {
2578 :
2579 :
2580 :
2581 :
2582 0 : resolution.toBin(eoss);
2583 :
2584 :
2585 :
2586 : }
2587 :
2588 0 : eoss.writeBoolean(resolutionArrayExists);
2589 0 : if (resolutionArrayExists) {
2590 :
2591 :
2592 :
2593 :
2594 0 : Frequency::toBin(resolutionArray, eoss);
2595 :
2596 :
2597 :
2598 : }
2599 :
2600 0 : eoss.writeBoolean(numAssocValuesExists);
2601 0 : if (numAssocValuesExists) {
2602 :
2603 :
2604 :
2605 :
2606 :
2607 0 : eoss.writeInt(numAssocValues);
2608 :
2609 :
2610 :
2611 :
2612 : }
2613 :
2614 0 : eoss.writeBoolean(assocNatureExists);
2615 0 : if (assocNatureExists) {
2616 :
2617 :
2618 :
2619 :
2620 :
2621 :
2622 0 : eoss.writeInt((int) assocNature.size());
2623 0 : for (unsigned int i = 0; i < assocNature.size(); i++)
2624 :
2625 0 : eoss.writeString(CSpectralResolutionType::name(assocNature.at(i)));
2626 : /* eoss.writeInt(assocNature.at(i)); */
2627 :
2628 :
2629 :
2630 :
2631 :
2632 :
2633 : }
2634 :
2635 0 : eoss.writeBoolean(assocSpectralWindowIdExists);
2636 0 : if (assocSpectralWindowIdExists) {
2637 :
2638 :
2639 :
2640 :
2641 0 : Tag::toBin(assocSpectralWindowId, eoss);
2642 :
2643 :
2644 :
2645 : }
2646 :
2647 0 : eoss.writeBoolean(imageSpectralWindowIdExists);
2648 0 : if (imageSpectralWindowIdExists) {
2649 :
2650 :
2651 :
2652 :
2653 0 : imageSpectralWindowId.toBin(eoss);
2654 :
2655 :
2656 :
2657 : }
2658 :
2659 0 : eoss.writeBoolean(dopplerIdExists);
2660 0 : if (dopplerIdExists) {
2661 :
2662 :
2663 :
2664 :
2665 :
2666 0 : eoss.writeInt(dopplerId);
2667 :
2668 :
2669 :
2670 :
2671 : }
2672 :
2673 0 : }
2674 :
2675 0 : void SpectralWindowRow::spectralWindowIdFromBin(EndianIStream& eis) {
2676 :
2677 :
2678 :
2679 :
2680 0 : spectralWindowId = Tag::fromBin(eis);
2681 :
2682 :
2683 :
2684 0 : }
2685 0 : void SpectralWindowRow::basebandNameFromBin(EndianIStream& eis) {
2686 :
2687 :
2688 :
2689 :
2690 :
2691 0 : basebandName = CBasebandName::literal(eis.readString());
2692 :
2693 :
2694 :
2695 :
2696 0 : }
2697 0 : void SpectralWindowRow::netSidebandFromBin(EndianIStream& eis) {
2698 :
2699 :
2700 :
2701 :
2702 :
2703 0 : netSideband = CNetSideband::literal(eis.readString());
2704 :
2705 :
2706 :
2707 :
2708 0 : }
2709 0 : void SpectralWindowRow::numChanFromBin(EndianIStream& eis) {
2710 :
2711 :
2712 :
2713 :
2714 :
2715 0 : numChan = eis.readInt();
2716 :
2717 :
2718 :
2719 :
2720 0 : }
2721 0 : void SpectralWindowRow::refFreqFromBin(EndianIStream& eis) {
2722 :
2723 :
2724 :
2725 :
2726 0 : refFreq = Frequency::fromBin(eis);
2727 :
2728 :
2729 :
2730 0 : }
2731 0 : void SpectralWindowRow::sidebandProcessingModeFromBin(EndianIStream& eis) {
2732 :
2733 :
2734 :
2735 :
2736 :
2737 0 : sidebandProcessingMode = CSidebandProcessingMode::literal(eis.readString());
2738 :
2739 :
2740 :
2741 :
2742 0 : }
2743 0 : void SpectralWindowRow::totBandwidthFromBin(EndianIStream& eis) {
2744 :
2745 :
2746 :
2747 :
2748 0 : totBandwidth = Frequency::fromBin(eis);
2749 :
2750 :
2751 :
2752 0 : }
2753 0 : void SpectralWindowRow::windowFunctionFromBin(EndianIStream& eis) {
2754 :
2755 :
2756 :
2757 :
2758 :
2759 0 : windowFunction = CWindowFunction::literal(eis.readString());
2760 :
2761 :
2762 :
2763 :
2764 0 : }
2765 :
2766 0 : void SpectralWindowRow::numBinFromBin(EndianIStream& eis) {
2767 :
2768 0 : numBinExists = eis.readBoolean();
2769 0 : if (numBinExists) {
2770 :
2771 :
2772 :
2773 :
2774 :
2775 0 : numBin = eis.readInt();
2776 :
2777 :
2778 :
2779 :
2780 : }
2781 :
2782 0 : }
2783 0 : void SpectralWindowRow::chanFreqStartFromBin(EndianIStream& eis) {
2784 :
2785 0 : chanFreqStartExists = eis.readBoolean();
2786 0 : if (chanFreqStartExists) {
2787 :
2788 :
2789 :
2790 :
2791 0 : chanFreqStart = Frequency::fromBin(eis);
2792 :
2793 :
2794 :
2795 : }
2796 :
2797 0 : }
2798 0 : void SpectralWindowRow::chanFreqStepFromBin(EndianIStream& eis) {
2799 :
2800 0 : chanFreqStepExists = eis.readBoolean();
2801 0 : if (chanFreqStepExists) {
2802 :
2803 :
2804 :
2805 :
2806 0 : chanFreqStep = Frequency::fromBin(eis);
2807 :
2808 :
2809 :
2810 : }
2811 :
2812 0 : }
2813 0 : void SpectralWindowRow::chanFreqArrayFromBin(EndianIStream& eis) {
2814 :
2815 0 : chanFreqArrayExists = eis.readBoolean();
2816 0 : if (chanFreqArrayExists) {
2817 :
2818 :
2819 :
2820 :
2821 :
2822 :
2823 0 : chanFreqArray = Frequency::from1DBin(eis);
2824 :
2825 :
2826 :
2827 :
2828 :
2829 : }
2830 :
2831 0 : }
2832 0 : void SpectralWindowRow::chanWidthFromBin(EndianIStream& eis) {
2833 :
2834 0 : chanWidthExists = eis.readBoolean();
2835 0 : if (chanWidthExists) {
2836 :
2837 :
2838 :
2839 :
2840 0 : chanWidth = Frequency::fromBin(eis);
2841 :
2842 :
2843 :
2844 : }
2845 :
2846 0 : }
2847 0 : void SpectralWindowRow::chanWidthArrayFromBin(EndianIStream& eis) {
2848 :
2849 0 : chanWidthArrayExists = eis.readBoolean();
2850 0 : if (chanWidthArrayExists) {
2851 :
2852 :
2853 :
2854 :
2855 :
2856 :
2857 0 : chanWidthArray = Frequency::from1DBin(eis);
2858 :
2859 :
2860 :
2861 :
2862 :
2863 : }
2864 :
2865 0 : }
2866 0 : void SpectralWindowRow::correlationBitFromBin(EndianIStream& eis) {
2867 :
2868 0 : correlationBitExists = eis.readBoolean();
2869 0 : if (correlationBitExists) {
2870 :
2871 :
2872 :
2873 :
2874 :
2875 0 : correlationBit = CCorrelationBit::literal(eis.readString());
2876 :
2877 :
2878 :
2879 :
2880 : }
2881 :
2882 0 : }
2883 0 : void SpectralWindowRow::effectiveBwFromBin(EndianIStream& eis) {
2884 :
2885 0 : effectiveBwExists = eis.readBoolean();
2886 0 : if (effectiveBwExists) {
2887 :
2888 :
2889 :
2890 :
2891 0 : effectiveBw = Frequency::fromBin(eis);
2892 :
2893 :
2894 :
2895 : }
2896 :
2897 0 : }
2898 0 : void SpectralWindowRow::effectiveBwArrayFromBin(EndianIStream& eis) {
2899 :
2900 0 : effectiveBwArrayExists = eis.readBoolean();
2901 0 : if (effectiveBwArrayExists) {
2902 :
2903 :
2904 :
2905 :
2906 :
2907 :
2908 0 : effectiveBwArray = Frequency::from1DBin(eis);
2909 :
2910 :
2911 :
2912 :
2913 :
2914 : }
2915 :
2916 0 : }
2917 0 : void SpectralWindowRow::freqGroupFromBin(EndianIStream& eis) {
2918 :
2919 0 : freqGroupExists = eis.readBoolean();
2920 0 : if (freqGroupExists) {
2921 :
2922 :
2923 :
2924 :
2925 :
2926 0 : freqGroup = eis.readInt();
2927 :
2928 :
2929 :
2930 :
2931 : }
2932 :
2933 0 : }
2934 0 : void SpectralWindowRow::freqGroupNameFromBin(EndianIStream& eis) {
2935 :
2936 0 : freqGroupNameExists = eis.readBoolean();
2937 0 : if (freqGroupNameExists) {
2938 :
2939 :
2940 :
2941 :
2942 :
2943 0 : freqGroupName = eis.readString();
2944 :
2945 :
2946 :
2947 :
2948 : }
2949 :
2950 0 : }
2951 0 : void SpectralWindowRow::lineArrayFromBin(EndianIStream& eis) {
2952 :
2953 0 : lineArrayExists = eis.readBoolean();
2954 0 : if (lineArrayExists) {
2955 :
2956 :
2957 :
2958 :
2959 :
2960 :
2961 0 : lineArray.clear();
2962 :
2963 0 : unsigned int lineArrayDim1 = eis.readInt();
2964 0 : for (unsigned int i = 0 ; i < lineArrayDim1; i++)
2965 :
2966 0 : lineArray.push_back(eis.readBoolean());
2967 :
2968 :
2969 :
2970 :
2971 :
2972 :
2973 : }
2974 :
2975 0 : }
2976 0 : void SpectralWindowRow::measFreqRefFromBin(EndianIStream& eis) {
2977 :
2978 0 : measFreqRefExists = eis.readBoolean();
2979 0 : if (measFreqRefExists) {
2980 :
2981 :
2982 :
2983 :
2984 :
2985 0 : measFreqRef = CFrequencyReferenceCode::literal(eis.readString());
2986 :
2987 :
2988 :
2989 :
2990 : }
2991 :
2992 0 : }
2993 0 : void SpectralWindowRow::nameFromBin(EndianIStream& eis) {
2994 :
2995 0 : nameExists = eis.readBoolean();
2996 0 : if (nameExists) {
2997 :
2998 :
2999 :
3000 :
3001 :
3002 0 : name = eis.readString();
3003 :
3004 :
3005 :
3006 :
3007 : }
3008 :
3009 0 : }
3010 0 : void SpectralWindowRow::oversamplingFromBin(EndianIStream& eis) {
3011 :
3012 0 : oversamplingExists = eis.readBoolean();
3013 0 : if (oversamplingExists) {
3014 :
3015 :
3016 :
3017 :
3018 :
3019 0 : oversampling = eis.readBoolean();
3020 :
3021 :
3022 :
3023 :
3024 : }
3025 :
3026 0 : }
3027 0 : void SpectralWindowRow::quantizationFromBin(EndianIStream& eis) {
3028 :
3029 0 : quantizationExists = eis.readBoolean();
3030 0 : if (quantizationExists) {
3031 :
3032 :
3033 :
3034 :
3035 :
3036 0 : quantization = eis.readBoolean();
3037 :
3038 :
3039 :
3040 :
3041 : }
3042 :
3043 0 : }
3044 0 : void SpectralWindowRow::refChanFromBin(EndianIStream& eis) {
3045 :
3046 0 : refChanExists = eis.readBoolean();
3047 0 : if (refChanExists) {
3048 :
3049 :
3050 :
3051 :
3052 :
3053 0 : refChan = eis.readDouble();
3054 :
3055 :
3056 :
3057 :
3058 : }
3059 :
3060 0 : }
3061 0 : void SpectralWindowRow::resolutionFromBin(EndianIStream& eis) {
3062 :
3063 0 : resolutionExists = eis.readBoolean();
3064 0 : if (resolutionExists) {
3065 :
3066 :
3067 :
3068 :
3069 0 : resolution = Frequency::fromBin(eis);
3070 :
3071 :
3072 :
3073 : }
3074 :
3075 0 : }
3076 0 : void SpectralWindowRow::resolutionArrayFromBin(EndianIStream& eis) {
3077 :
3078 0 : resolutionArrayExists = eis.readBoolean();
3079 0 : if (resolutionArrayExists) {
3080 :
3081 :
3082 :
3083 :
3084 :
3085 :
3086 0 : resolutionArray = Frequency::from1DBin(eis);
3087 :
3088 :
3089 :
3090 :
3091 :
3092 : }
3093 :
3094 0 : }
3095 0 : void SpectralWindowRow::numAssocValuesFromBin(EndianIStream& eis) {
3096 :
3097 0 : numAssocValuesExists = eis.readBoolean();
3098 0 : if (numAssocValuesExists) {
3099 :
3100 :
3101 :
3102 :
3103 :
3104 0 : numAssocValues = eis.readInt();
3105 :
3106 :
3107 :
3108 :
3109 : }
3110 :
3111 0 : }
3112 0 : void SpectralWindowRow::assocNatureFromBin(EndianIStream& eis) {
3113 :
3114 0 : assocNatureExists = eis.readBoolean();
3115 0 : if (assocNatureExists) {
3116 :
3117 :
3118 :
3119 :
3120 :
3121 :
3122 0 : assocNature.clear();
3123 :
3124 0 : unsigned int assocNatureDim1 = eis.readInt();
3125 0 : for (unsigned int i = 0 ; i < assocNatureDim1; i++)
3126 :
3127 0 : assocNature.push_back(CSpectralResolutionType::literal(eis.readString()));
3128 :
3129 :
3130 :
3131 :
3132 :
3133 :
3134 : }
3135 :
3136 0 : }
3137 0 : void SpectralWindowRow::assocSpectralWindowIdFromBin(EndianIStream& eis) {
3138 :
3139 0 : assocSpectralWindowIdExists = eis.readBoolean();
3140 0 : if (assocSpectralWindowIdExists) {
3141 :
3142 :
3143 :
3144 :
3145 :
3146 :
3147 0 : assocSpectralWindowId = Tag::from1DBin(eis);
3148 :
3149 :
3150 :
3151 :
3152 :
3153 : }
3154 :
3155 0 : }
3156 0 : void SpectralWindowRow::imageSpectralWindowIdFromBin(EndianIStream& eis) {
3157 :
3158 0 : imageSpectralWindowIdExists = eis.readBoolean();
3159 0 : if (imageSpectralWindowIdExists) {
3160 :
3161 :
3162 :
3163 :
3164 0 : imageSpectralWindowId = Tag::fromBin(eis);
3165 :
3166 :
3167 :
3168 : }
3169 :
3170 0 : }
3171 0 : void SpectralWindowRow::dopplerIdFromBin(EndianIStream& eis) {
3172 :
3173 0 : dopplerIdExists = eis.readBoolean();
3174 0 : if (dopplerIdExists) {
3175 :
3176 :
3177 :
3178 :
3179 :
3180 0 : dopplerId = eis.readInt();
3181 :
3182 :
3183 :
3184 :
3185 : }
3186 :
3187 0 : }
3188 :
3189 :
3190 0 : SpectralWindowRow* SpectralWindowRow::fromBin(EndianIStream& eis, SpectralWindowTable& table, const vector<string>& attributesSeq) {
3191 0 : SpectralWindowRow* row = new SpectralWindowRow(table);
3192 :
3193 0 : map<string, SpectralWindowAttributeFromBin>::iterator iter ;
3194 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
3195 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
3196 0 : if (iter != row->fromBinMethods.end()) {
3197 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
3198 : }
3199 : else {
3200 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
3201 0 : if (functorP)
3202 0 : (*functorP)(eis);
3203 : else
3204 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "SpectralWindowTable");
3205 : }
3206 :
3207 : }
3208 0 : return row;
3209 : }
3210 :
3211 : //
3212 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
3213 : // of one row.
3214 : //
3215 :
3216 : // Convert a string into an Tag
3217 0 : void SpectralWindowRow::spectralWindowIdFromText(const string & s) {
3218 :
3219 :
3220 0 : spectralWindowId = ASDMValuesParser::parse<Tag>(s);
3221 :
3222 :
3223 0 : }
3224 :
3225 :
3226 : // Convert a string into an BasebandName
3227 0 : void SpectralWindowRow::basebandNameFromText(const string & s) {
3228 :
3229 :
3230 0 : basebandName = ASDMValuesParser::parse<BasebandNameMod::BasebandName>(s);
3231 :
3232 :
3233 0 : }
3234 :
3235 :
3236 : // Convert a string into an NetSideband
3237 0 : void SpectralWindowRow::netSidebandFromText(const string & s) {
3238 :
3239 :
3240 0 : netSideband = ASDMValuesParser::parse<NetSidebandMod::NetSideband>(s);
3241 :
3242 :
3243 0 : }
3244 :
3245 :
3246 : // Convert a string into an int
3247 0 : void SpectralWindowRow::numChanFromText(const string & s) {
3248 :
3249 :
3250 0 : numChan = ASDMValuesParser::parse<int>(s);
3251 :
3252 :
3253 0 : }
3254 :
3255 :
3256 : // Convert a string into an Frequency
3257 0 : void SpectralWindowRow::refFreqFromText(const string & s) {
3258 :
3259 :
3260 0 : refFreq = ASDMValuesParser::parse<Frequency>(s);
3261 :
3262 :
3263 0 : }
3264 :
3265 :
3266 : // Convert a string into an SidebandProcessingMode
3267 0 : void SpectralWindowRow::sidebandProcessingModeFromText(const string & s) {
3268 :
3269 :
3270 0 : sidebandProcessingMode = ASDMValuesParser::parse<SidebandProcessingModeMod::SidebandProcessingMode>(s);
3271 :
3272 :
3273 0 : }
3274 :
3275 :
3276 : // Convert a string into an Frequency
3277 0 : void SpectralWindowRow::totBandwidthFromText(const string & s) {
3278 :
3279 :
3280 0 : totBandwidth = ASDMValuesParser::parse<Frequency>(s);
3281 :
3282 :
3283 0 : }
3284 :
3285 :
3286 : // Convert a string into an WindowFunction
3287 0 : void SpectralWindowRow::windowFunctionFromText(const string & s) {
3288 :
3289 :
3290 0 : windowFunction = ASDMValuesParser::parse<WindowFunctionMod::WindowFunction>(s);
3291 :
3292 :
3293 0 : }
3294 :
3295 :
3296 :
3297 : // Convert a string into an int
3298 0 : void SpectralWindowRow::numBinFromText(const string & s) {
3299 0 : numBinExists = true;
3300 :
3301 :
3302 0 : numBin = ASDMValuesParser::parse<int>(s);
3303 :
3304 :
3305 0 : }
3306 :
3307 :
3308 : // Convert a string into an Frequency
3309 0 : void SpectralWindowRow::chanFreqStartFromText(const string & s) {
3310 0 : chanFreqStartExists = true;
3311 :
3312 :
3313 0 : chanFreqStart = ASDMValuesParser::parse<Frequency>(s);
3314 :
3315 :
3316 0 : }
3317 :
3318 :
3319 : // Convert a string into an Frequency
3320 0 : void SpectralWindowRow::chanFreqStepFromText(const string & s) {
3321 0 : chanFreqStepExists = true;
3322 :
3323 :
3324 0 : chanFreqStep = ASDMValuesParser::parse<Frequency>(s);
3325 :
3326 :
3327 0 : }
3328 :
3329 :
3330 : // Convert a string into an Frequency
3331 0 : void SpectralWindowRow::chanFreqArrayFromText(const string & s) {
3332 0 : chanFreqArrayExists = true;
3333 :
3334 :
3335 0 : chanFreqArray = ASDMValuesParser::parse1D<Frequency>(s);
3336 :
3337 :
3338 0 : }
3339 :
3340 :
3341 : // Convert a string into an Frequency
3342 0 : void SpectralWindowRow::chanWidthFromText(const string & s) {
3343 0 : chanWidthExists = true;
3344 :
3345 :
3346 0 : chanWidth = ASDMValuesParser::parse<Frequency>(s);
3347 :
3348 :
3349 0 : }
3350 :
3351 :
3352 : // Convert a string into an Frequency
3353 0 : void SpectralWindowRow::chanWidthArrayFromText(const string & s) {
3354 0 : chanWidthArrayExists = true;
3355 :
3356 :
3357 0 : chanWidthArray = ASDMValuesParser::parse1D<Frequency>(s);
3358 :
3359 :
3360 0 : }
3361 :
3362 :
3363 : // Convert a string into an CorrelationBit
3364 0 : void SpectralWindowRow::correlationBitFromText(const string & s) {
3365 0 : correlationBitExists = true;
3366 :
3367 :
3368 0 : correlationBit = ASDMValuesParser::parse<CorrelationBitMod::CorrelationBit>(s);
3369 :
3370 :
3371 0 : }
3372 :
3373 :
3374 : // Convert a string into an Frequency
3375 0 : void SpectralWindowRow::effectiveBwFromText(const string & s) {
3376 0 : effectiveBwExists = true;
3377 :
3378 :
3379 0 : effectiveBw = ASDMValuesParser::parse<Frequency>(s);
3380 :
3381 :
3382 0 : }
3383 :
3384 :
3385 : // Convert a string into an Frequency
3386 0 : void SpectralWindowRow::effectiveBwArrayFromText(const string & s) {
3387 0 : effectiveBwArrayExists = true;
3388 :
3389 :
3390 0 : effectiveBwArray = ASDMValuesParser::parse1D<Frequency>(s);
3391 :
3392 :
3393 0 : }
3394 :
3395 :
3396 : // Convert a string into an int
3397 0 : void SpectralWindowRow::freqGroupFromText(const string & s) {
3398 0 : freqGroupExists = true;
3399 :
3400 :
3401 0 : freqGroup = ASDMValuesParser::parse<int>(s);
3402 :
3403 :
3404 0 : }
3405 :
3406 :
3407 : // Convert a string into an String
3408 0 : void SpectralWindowRow::freqGroupNameFromText(const string & s) {
3409 0 : freqGroupNameExists = true;
3410 :
3411 :
3412 0 : freqGroupName = ASDMValuesParser::parse<string>(s);
3413 :
3414 :
3415 0 : }
3416 :
3417 :
3418 : // Convert a string into an boolean
3419 0 : void SpectralWindowRow::lineArrayFromText(const string & s) {
3420 0 : lineArrayExists = true;
3421 :
3422 :
3423 0 : lineArray = ASDMValuesParser::parse1D<bool>(s);
3424 :
3425 :
3426 0 : }
3427 :
3428 :
3429 : // Convert a string into an FrequencyReferenceCode
3430 0 : void SpectralWindowRow::measFreqRefFromText(const string & s) {
3431 0 : measFreqRefExists = true;
3432 :
3433 :
3434 0 : measFreqRef = ASDMValuesParser::parse<FrequencyReferenceCodeMod::FrequencyReferenceCode>(s);
3435 :
3436 :
3437 0 : }
3438 :
3439 :
3440 : // Convert a string into an String
3441 0 : void SpectralWindowRow::nameFromText(const string & s) {
3442 0 : nameExists = true;
3443 :
3444 :
3445 0 : name = ASDMValuesParser::parse<string>(s);
3446 :
3447 :
3448 0 : }
3449 :
3450 :
3451 : // Convert a string into an boolean
3452 0 : void SpectralWindowRow::oversamplingFromText(const string & s) {
3453 0 : oversamplingExists = true;
3454 :
3455 :
3456 0 : oversampling = ASDMValuesParser::parse<bool>(s);
3457 :
3458 :
3459 0 : }
3460 :
3461 :
3462 : // Convert a string into an boolean
3463 0 : void SpectralWindowRow::quantizationFromText(const string & s) {
3464 0 : quantizationExists = true;
3465 :
3466 :
3467 0 : quantization = ASDMValuesParser::parse<bool>(s);
3468 :
3469 :
3470 0 : }
3471 :
3472 :
3473 : // Convert a string into an double
3474 0 : void SpectralWindowRow::refChanFromText(const string & s) {
3475 0 : refChanExists = true;
3476 :
3477 :
3478 0 : refChan = ASDMValuesParser::parse<double>(s);
3479 :
3480 :
3481 0 : }
3482 :
3483 :
3484 : // Convert a string into an Frequency
3485 0 : void SpectralWindowRow::resolutionFromText(const string & s) {
3486 0 : resolutionExists = true;
3487 :
3488 :
3489 0 : resolution = ASDMValuesParser::parse<Frequency>(s);
3490 :
3491 :
3492 0 : }
3493 :
3494 :
3495 : // Convert a string into an Frequency
3496 0 : void SpectralWindowRow::resolutionArrayFromText(const string & s) {
3497 0 : resolutionArrayExists = true;
3498 :
3499 :
3500 0 : resolutionArray = ASDMValuesParser::parse1D<Frequency>(s);
3501 :
3502 :
3503 0 : }
3504 :
3505 :
3506 : // Convert a string into an int
3507 0 : void SpectralWindowRow::numAssocValuesFromText(const string & s) {
3508 0 : numAssocValuesExists = true;
3509 :
3510 :
3511 0 : numAssocValues = ASDMValuesParser::parse<int>(s);
3512 :
3513 :
3514 0 : }
3515 :
3516 :
3517 : // Convert a string into an SpectralResolutionType
3518 0 : void SpectralWindowRow::assocNatureFromText(const string & s) {
3519 0 : assocNatureExists = true;
3520 :
3521 :
3522 0 : assocNature = ASDMValuesParser::parse1D<SpectralResolutionTypeMod::SpectralResolutionType>(s);
3523 :
3524 :
3525 0 : }
3526 :
3527 :
3528 : // Convert a string into an Tag
3529 0 : void SpectralWindowRow::assocSpectralWindowIdFromText(const string & s) {
3530 0 : assocSpectralWindowIdExists = true;
3531 :
3532 :
3533 0 : assocSpectralWindowId = ASDMValuesParser::parse1D<Tag>(s);
3534 :
3535 :
3536 0 : }
3537 :
3538 :
3539 : // Convert a string into an Tag
3540 0 : void SpectralWindowRow::imageSpectralWindowIdFromText(const string & s) {
3541 0 : imageSpectralWindowIdExists = true;
3542 :
3543 :
3544 0 : imageSpectralWindowId = ASDMValuesParser::parse<Tag>(s);
3545 :
3546 :
3547 0 : }
3548 :
3549 :
3550 : // Convert a string into an int
3551 0 : void SpectralWindowRow::dopplerIdFromText(const string & s) {
3552 0 : dopplerIdExists = true;
3553 :
3554 :
3555 0 : dopplerId = ASDMValuesParser::parse<int>(s);
3556 :
3557 :
3558 0 : }
3559 :
3560 :
3561 :
3562 0 : void SpectralWindowRow::fromText(const std::string& attributeName, const std::string& t) {
3563 0 : map<string, SpectralWindowAttributeFromText>::iterator iter;
3564 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
3565 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "SpectralWindowTable");
3566 0 : (this->*(iter->second))(t);
3567 0 : }
3568 :
3569 : ////////////////////////////////////////////////
3570 : // Intrinsic Table Attributes getters/setters //
3571 : ////////////////////////////////////////////////
3572 :
3573 :
3574 :
3575 :
3576 : /**
3577 : * Get spectralWindowId.
3578 : * @return spectralWindowId as Tag
3579 : */
3580 9893 : Tag SpectralWindowRow::getSpectralWindowId() const {
3581 :
3582 9893 : return spectralWindowId;
3583 : }
3584 :
3585 : /**
3586 : * Set spectralWindowId with the specified Tag.
3587 : * @param spectralWindowId The Tag value to which spectralWindowId is to be set.
3588 :
3589 :
3590 :
3591 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
3592 :
3593 : */
3594 2399 : void SpectralWindowRow::setSpectralWindowId (Tag spectralWindowId) {
3595 :
3596 :
3597 2399 : if (hasBeenAdded) {
3598 :
3599 0 : throw IllegalAccessException("spectralWindowId", "SpectralWindow");
3600 :
3601 : }
3602 :
3603 2399 : this->spectralWindowId = spectralWindowId;
3604 :
3605 2399 : }
3606 :
3607 :
3608 :
3609 :
3610 :
3611 :
3612 : /**
3613 : * Get basebandName.
3614 : * @return basebandName as BasebandNameMod::BasebandName
3615 : */
3616 2755 : BasebandNameMod::BasebandName SpectralWindowRow::getBasebandName() const {
3617 :
3618 2755 : return basebandName;
3619 : }
3620 :
3621 : /**
3622 : * Set basebandName with the specified BasebandNameMod::BasebandName.
3623 : * @param basebandName The BasebandNameMod::BasebandName value to which basebandName is to be set.
3624 :
3625 :
3626 :
3627 : */
3628 107 : void SpectralWindowRow::setBasebandName (BasebandNameMod::BasebandName basebandName) {
3629 :
3630 :
3631 107 : if (hasBeenAdded) {
3632 :
3633 : }
3634 :
3635 107 : this->basebandName = basebandName;
3636 :
3637 107 : }
3638 :
3639 :
3640 :
3641 :
3642 :
3643 :
3644 : /**
3645 : * Get netSideband.
3646 : * @return netSideband as NetSidebandMod::NetSideband
3647 : */
3648 2316 : NetSidebandMod::NetSideband SpectralWindowRow::getNetSideband() const {
3649 :
3650 2316 : return netSideband;
3651 : }
3652 :
3653 : /**
3654 : * Set netSideband with the specified NetSidebandMod::NetSideband.
3655 : * @param netSideband The NetSidebandMod::NetSideband value to which netSideband is to be set.
3656 :
3657 :
3658 :
3659 : */
3660 107 : void SpectralWindowRow::setNetSideband (NetSidebandMod::NetSideband netSideband) {
3661 :
3662 :
3663 107 : if (hasBeenAdded) {
3664 :
3665 : }
3666 :
3667 107 : this->netSideband = netSideband;
3668 :
3669 107 : }
3670 :
3671 :
3672 :
3673 :
3674 :
3675 :
3676 : /**
3677 : * Get numChan.
3678 : * @return numChan as int
3679 : */
3680 468476 : int SpectralWindowRow::getNumChan() const {
3681 :
3682 468476 : return numChan;
3683 : }
3684 :
3685 : /**
3686 : * Set numChan with the specified int.
3687 : * @param numChan The int value to which numChan is to be set.
3688 :
3689 :
3690 :
3691 : */
3692 2399 : void SpectralWindowRow::setNumChan (int numChan) {
3693 :
3694 :
3695 2399 : if (hasBeenAdded) {
3696 :
3697 : }
3698 :
3699 2399 : this->numChan = numChan;
3700 :
3701 2399 : }
3702 :
3703 :
3704 :
3705 :
3706 : /**
3707 : * The attribute numBin is optional. Return true if this attribute exists.
3708 : * @return true if and only if the numBin attribute exists.
3709 : */
3710 2320 : bool SpectralWindowRow::isNumBinExists() const {
3711 2320 : return numBinExists;
3712 : }
3713 :
3714 :
3715 :
3716 : /**
3717 : * Get numBin, which is optional.
3718 : * @return numBin as int
3719 : * @throw IllegalAccessException If numBin does not exist.
3720 : */
3721 217 : int SpectralWindowRow::getNumBin() const {
3722 217 : if (!numBinExists) {
3723 0 : throw IllegalAccessException("numBin", "SpectralWindow");
3724 : }
3725 :
3726 217 : return numBin;
3727 : }
3728 :
3729 : /**
3730 : * Set numBin with the specified int.
3731 : * @param numBin The int value to which numBin is to be set.
3732 :
3733 :
3734 : */
3735 217 : void SpectralWindowRow::setNumBin (int numBin) {
3736 :
3737 217 : this->numBin = numBin;
3738 :
3739 217 : numBinExists = true;
3740 :
3741 217 : }
3742 :
3743 :
3744 : /**
3745 : * Mark numBin, which is an optional field, as non-existent.
3746 : */
3747 0 : void SpectralWindowRow::clearNumBin () {
3748 0 : numBinExists = false;
3749 0 : }
3750 :
3751 :
3752 :
3753 :
3754 :
3755 : /**
3756 : * Get refFreq.
3757 : * @return refFreq as Frequency
3758 : */
3759 3183 : Frequency SpectralWindowRow::getRefFreq() const {
3760 :
3761 3183 : return refFreq;
3762 : }
3763 :
3764 : /**
3765 : * Set refFreq with the specified Frequency.
3766 : * @param refFreq The Frequency value to which refFreq is to be set.
3767 :
3768 :
3769 :
3770 : */
3771 2399 : void SpectralWindowRow::setRefFreq (Frequency refFreq) {
3772 :
3773 :
3774 2399 : if (hasBeenAdded) {
3775 :
3776 : }
3777 :
3778 2399 : this->refFreq = refFreq;
3779 :
3780 2399 : }
3781 :
3782 :
3783 :
3784 :
3785 :
3786 :
3787 : /**
3788 : * Get sidebandProcessingMode.
3789 : * @return sidebandProcessingMode as SidebandProcessingModeMod::SidebandProcessingMode
3790 : */
3791 107 : SidebandProcessingModeMod::SidebandProcessingMode SpectralWindowRow::getSidebandProcessingMode() const {
3792 :
3793 107 : return sidebandProcessingMode;
3794 : }
3795 :
3796 : /**
3797 : * Set sidebandProcessingMode with the specified SidebandProcessingModeMod::SidebandProcessingMode.
3798 : * @param sidebandProcessingMode The SidebandProcessingModeMod::SidebandProcessingMode value to which sidebandProcessingMode is to be set.
3799 :
3800 :
3801 :
3802 : */
3803 107 : void SpectralWindowRow::setSidebandProcessingMode (SidebandProcessingModeMod::SidebandProcessingMode sidebandProcessingMode) {
3804 :
3805 :
3806 107 : if (hasBeenAdded) {
3807 :
3808 : }
3809 :
3810 107 : this->sidebandProcessingMode = sidebandProcessingMode;
3811 :
3812 107 : }
3813 :
3814 :
3815 :
3816 :
3817 :
3818 :
3819 : /**
3820 : * Get totBandwidth.
3821 : * @return totBandwidth as Frequency
3822 : */
3823 2316 : Frequency SpectralWindowRow::getTotBandwidth() const {
3824 :
3825 2316 : return totBandwidth;
3826 : }
3827 :
3828 : /**
3829 : * Set totBandwidth with the specified Frequency.
3830 : * @param totBandwidth The Frequency value to which totBandwidth is to be set.
3831 :
3832 :
3833 :
3834 : */
3835 2399 : void SpectralWindowRow::setTotBandwidth (Frequency totBandwidth) {
3836 :
3837 :
3838 2399 : if (hasBeenAdded) {
3839 :
3840 : }
3841 :
3842 2399 : this->totBandwidth = totBandwidth;
3843 :
3844 2399 : }
3845 :
3846 :
3847 :
3848 :
3849 :
3850 :
3851 : /**
3852 : * Get windowFunction.
3853 : * @return windowFunction as WindowFunctionMod::WindowFunction
3854 : */
3855 2726 : WindowFunctionMod::WindowFunction SpectralWindowRow::getWindowFunction() const {
3856 :
3857 2726 : return windowFunction;
3858 : }
3859 :
3860 : /**
3861 : * Set windowFunction with the specified WindowFunctionMod::WindowFunction.
3862 : * @param windowFunction The WindowFunctionMod::WindowFunction value to which windowFunction is to be set.
3863 :
3864 :
3865 :
3866 : */
3867 107 : void SpectralWindowRow::setWindowFunction (WindowFunctionMod::WindowFunction windowFunction) {
3868 :
3869 :
3870 107 : if (hasBeenAdded) {
3871 :
3872 : }
3873 :
3874 107 : this->windowFunction = windowFunction;
3875 :
3876 107 : }
3877 :
3878 :
3879 :
3880 :
3881 : /**
3882 : * The attribute chanFreqStart is optional. Return true if this attribute exists.
3883 : * @return true if and only if the chanFreqStart attribute exists.
3884 : */
3885 2969 : bool SpectralWindowRow::isChanFreqStartExists() const {
3886 2969 : return chanFreqStartExists;
3887 : }
3888 :
3889 :
3890 :
3891 : /**
3892 : * Get chanFreqStart, which is optional.
3893 : * @return chanFreqStart as Frequency
3894 : * @throw IllegalAccessException If chanFreqStart does not exist.
3895 : */
3896 1092 : Frequency SpectralWindowRow::getChanFreqStart() const {
3897 1092 : if (!chanFreqStartExists) {
3898 0 : throw IllegalAccessException("chanFreqStart", "SpectralWindow");
3899 : }
3900 :
3901 1092 : return chanFreqStart;
3902 : }
3903 :
3904 : /**
3905 : * Set chanFreqStart with the specified Frequency.
3906 : * @param chanFreqStart The Frequency value to which chanFreqStart is to be set.
3907 :
3908 :
3909 : */
3910 731 : void SpectralWindowRow::setChanFreqStart (Frequency chanFreqStart) {
3911 :
3912 731 : this->chanFreqStart = chanFreqStart;
3913 :
3914 731 : chanFreqStartExists = true;
3915 :
3916 731 : }
3917 :
3918 :
3919 : /**
3920 : * Mark chanFreqStart, which is an optional field, as non-existent.
3921 : */
3922 0 : void SpectralWindowRow::clearChanFreqStart () {
3923 0 : chanFreqStartExists = false;
3924 0 : }
3925 :
3926 :
3927 :
3928 : /**
3929 : * The attribute chanFreqStep is optional. Return true if this attribute exists.
3930 : * @return true if and only if the chanFreqStep attribute exists.
3931 : */
3932 704 : bool SpectralWindowRow::isChanFreqStepExists() const {
3933 704 : return chanFreqStepExists;
3934 : }
3935 :
3936 :
3937 :
3938 : /**
3939 : * Get chanFreqStep, which is optional.
3940 : * @return chanFreqStep as Frequency
3941 : * @throw IllegalAccessException If chanFreqStep does not exist.
3942 : */
3943 704 : Frequency SpectralWindowRow::getChanFreqStep() const {
3944 704 : if (!chanFreqStepExists) {
3945 0 : throw IllegalAccessException("chanFreqStep", "SpectralWindow");
3946 : }
3947 :
3948 704 : return chanFreqStep;
3949 : }
3950 :
3951 : /**
3952 : * Set chanFreqStep with the specified Frequency.
3953 : * @param chanFreqStep The Frequency value to which chanFreqStep is to be set.
3954 :
3955 :
3956 : */
3957 731 : void SpectralWindowRow::setChanFreqStep (Frequency chanFreqStep) {
3958 :
3959 731 : this->chanFreqStep = chanFreqStep;
3960 :
3961 731 : chanFreqStepExists = true;
3962 :
3963 731 : }
3964 :
3965 :
3966 : /**
3967 : * Mark chanFreqStep, which is an optional field, as non-existent.
3968 : */
3969 0 : void SpectralWindowRow::clearChanFreqStep () {
3970 0 : chanFreqStepExists = false;
3971 0 : }
3972 :
3973 :
3974 :
3975 : /**
3976 : * The attribute chanFreqArray is optional. Return true if this attribute exists.
3977 : * @return true if and only if the chanFreqArray attribute exists.
3978 : */
3979 2581 : bool SpectralWindowRow::isChanFreqArrayExists() const {
3980 2581 : return chanFreqArrayExists;
3981 : }
3982 :
3983 :
3984 :
3985 : /**
3986 : * Get chanFreqArray, which is optional.
3987 : * @return chanFreqArray as std::vector<Frequency >
3988 : * @throw IllegalAccessException If chanFreqArray does not exist.
3989 : */
3990 1877 : std::vector<Frequency > SpectralWindowRow::getChanFreqArray() const {
3991 1877 : if (!chanFreqArrayExists) {
3992 0 : throw IllegalAccessException("chanFreqArray", "SpectralWindow");
3993 : }
3994 :
3995 1877 : return chanFreqArray;
3996 : }
3997 :
3998 : /**
3999 : * Set chanFreqArray with the specified std::vector<Frequency >.
4000 : * @param chanFreqArray The std::vector<Frequency > value to which chanFreqArray is to be set.
4001 :
4002 :
4003 : */
4004 1668 : void SpectralWindowRow::setChanFreqArray (std::vector<Frequency > chanFreqArray) {
4005 :
4006 1668 : this->chanFreqArray = chanFreqArray;
4007 :
4008 1668 : chanFreqArrayExists = true;
4009 :
4010 1668 : }
4011 :
4012 :
4013 : /**
4014 : * Mark chanFreqArray, which is an optional field, as non-existent.
4015 : */
4016 0 : void SpectralWindowRow::clearChanFreqArray () {
4017 0 : chanFreqArrayExists = false;
4018 0 : }
4019 :
4020 :
4021 :
4022 : /**
4023 : * The attribute chanWidth is optional. Return true if this attribute exists.
4024 : * @return true if and only if the chanWidth attribute exists.
4025 : */
4026 4589 : bool SpectralWindowRow::isChanWidthExists() const {
4027 4589 : return chanWidthExists;
4028 : }
4029 :
4030 :
4031 :
4032 : /**
4033 : * Get chanWidth, which is optional.
4034 : * @return chanWidth as Frequency
4035 : * @throw IllegalAccessException If chanWidth does not exist.
4036 : */
4037 1735 : Frequency SpectralWindowRow::getChanWidth() const {
4038 1735 : if (!chanWidthExists) {
4039 0 : throw IllegalAccessException("chanWidth", "SpectralWindow");
4040 : }
4041 :
4042 1735 : return chanWidth;
4043 : }
4044 :
4045 : /**
4046 : * Set chanWidth with the specified Frequency.
4047 : * @param chanWidth The Frequency value to which chanWidth is to be set.
4048 :
4049 :
4050 : */
4051 779 : void SpectralWindowRow::setChanWidth (Frequency chanWidth) {
4052 :
4053 779 : this->chanWidth = chanWidth;
4054 :
4055 779 : chanWidthExists = true;
4056 :
4057 779 : }
4058 :
4059 :
4060 : /**
4061 : * Mark chanWidth, which is an optional field, as non-existent.
4062 : */
4063 0 : void SpectralWindowRow::clearChanWidth () {
4064 0 : chanWidthExists = false;
4065 0 : }
4066 :
4067 :
4068 :
4069 : /**
4070 : * The attribute chanWidthArray is optional. Return true if this attribute exists.
4071 : * @return true if and only if the chanWidthArray attribute exists.
4072 : */
4073 4426 : bool SpectralWindowRow::isChanWidthArrayExists() const {
4074 4426 : return chanWidthArrayExists;
4075 : }
4076 :
4077 :
4078 :
4079 : /**
4080 : * Get chanWidthArray, which is optional.
4081 : * @return chanWidthArray as std::vector<Frequency >
4082 : * @throw IllegalAccessException If chanWidthArray does not exist.
4083 : */
4084 1829 : std::vector<Frequency > SpectralWindowRow::getChanWidthArray() const {
4085 1829 : if (!chanWidthArrayExists) {
4086 0 : throw IllegalAccessException("chanWidthArray", "SpectralWindow");
4087 : }
4088 :
4089 1829 : return chanWidthArray;
4090 : }
4091 :
4092 : /**
4093 : * Set chanWidthArray with the specified std::vector<Frequency >.
4094 : * @param chanWidthArray The std::vector<Frequency > value to which chanWidthArray is to be set.
4095 :
4096 :
4097 : */
4098 1620 : void SpectralWindowRow::setChanWidthArray (std::vector<Frequency > chanWidthArray) {
4099 :
4100 1620 : this->chanWidthArray = chanWidthArray;
4101 :
4102 1620 : chanWidthArrayExists = true;
4103 :
4104 1620 : }
4105 :
4106 :
4107 : /**
4108 : * Mark chanWidthArray, which is an optional field, as non-existent.
4109 : */
4110 0 : void SpectralWindowRow::clearChanWidthArray () {
4111 0 : chanWidthArrayExists = false;
4112 0 : }
4113 :
4114 :
4115 :
4116 : /**
4117 : * The attribute correlationBit is optional. Return true if this attribute exists.
4118 : * @return true if and only if the correlationBit attribute exists.
4119 : */
4120 2209 : bool SpectralWindowRow::isCorrelationBitExists() const {
4121 2209 : return correlationBitExists;
4122 : }
4123 :
4124 :
4125 :
4126 : /**
4127 : * Get correlationBit, which is optional.
4128 : * @return correlationBit as CorrelationBitMod::CorrelationBit
4129 : * @throw IllegalAccessException If correlationBit does not exist.
4130 : */
4131 296 : CorrelationBitMod::CorrelationBit SpectralWindowRow::getCorrelationBit() const {
4132 296 : if (!correlationBitExists) {
4133 0 : throw IllegalAccessException("correlationBit", "SpectralWindow");
4134 : }
4135 :
4136 296 : return correlationBit;
4137 : }
4138 :
4139 : /**
4140 : * Set correlationBit with the specified CorrelationBitMod::CorrelationBit.
4141 : * @param correlationBit The CorrelationBitMod::CorrelationBit value to which correlationBit is to be set.
4142 :
4143 :
4144 : */
4145 0 : void SpectralWindowRow::setCorrelationBit (CorrelationBitMod::CorrelationBit correlationBit) {
4146 :
4147 0 : this->correlationBit = correlationBit;
4148 :
4149 0 : correlationBitExists = true;
4150 :
4151 0 : }
4152 :
4153 :
4154 : /**
4155 : * Mark correlationBit, which is an optional field, as non-existent.
4156 : */
4157 0 : void SpectralWindowRow::clearCorrelationBit () {
4158 0 : correlationBitExists = false;
4159 0 : }
4160 :
4161 :
4162 :
4163 : /**
4164 : * The attribute effectiveBw is optional. Return true if this attribute exists.
4165 : * @return true if and only if the effectiveBw attribute exists.
4166 : */
4167 2587 : bool SpectralWindowRow::isEffectiveBwExists() const {
4168 2587 : return effectiveBwExists;
4169 : }
4170 :
4171 :
4172 :
4173 : /**
4174 : * Get effectiveBw, which is optional.
4175 : * @return effectiveBw as Frequency
4176 : * @throw IllegalAccessException If effectiveBw does not exist.
4177 : */
4178 778 : Frequency SpectralWindowRow::getEffectiveBw() const {
4179 778 : if (!effectiveBwExists) {
4180 0 : throw IllegalAccessException("effectiveBw", "SpectralWindow");
4181 : }
4182 :
4183 778 : return effectiveBw;
4184 : }
4185 :
4186 : /**
4187 : * Set effectiveBw with the specified Frequency.
4188 : * @param effectiveBw The Frequency value to which effectiveBw is to be set.
4189 :
4190 :
4191 : */
4192 779 : void SpectralWindowRow::setEffectiveBw (Frequency effectiveBw) {
4193 :
4194 779 : this->effectiveBw = effectiveBw;
4195 :
4196 779 : effectiveBwExists = true;
4197 :
4198 779 : }
4199 :
4200 :
4201 : /**
4202 : * Mark effectiveBw, which is an optional field, as non-existent.
4203 : */
4204 0 : void SpectralWindowRow::clearEffectiveBw () {
4205 0 : effectiveBwExists = false;
4206 0 : }
4207 :
4208 :
4209 :
4210 : /**
4211 : * The attribute effectiveBwArray is optional. Return true if this attribute exists.
4212 : * @return true if and only if the effectiveBwArray attribute exists.
4213 : */
4214 3666 : bool SpectralWindowRow::isEffectiveBwArrayExists() const {
4215 3666 : return effectiveBwArrayExists;
4216 : }
4217 :
4218 :
4219 :
4220 : /**
4221 : * Get effectiveBwArray, which is optional.
4222 : * @return effectiveBwArray as std::vector<Frequency >
4223 : * @throw IllegalAccessException If effectiveBwArray does not exist.
4224 : */
4225 1457 : std::vector<Frequency > SpectralWindowRow::getEffectiveBwArray() const {
4226 1457 : if (!effectiveBwArrayExists) {
4227 0 : throw IllegalAccessException("effectiveBwArray", "SpectralWindow");
4228 : }
4229 :
4230 1457 : return effectiveBwArray;
4231 : }
4232 :
4233 : /**
4234 : * Set effectiveBwArray with the specified std::vector<Frequency >.
4235 : * @param effectiveBwArray The std::vector<Frequency > value to which effectiveBwArray is to be set.
4236 :
4237 :
4238 : */
4239 1620 : void SpectralWindowRow::setEffectiveBwArray (std::vector<Frequency > effectiveBwArray) {
4240 :
4241 1620 : this->effectiveBwArray = effectiveBwArray;
4242 :
4243 1620 : effectiveBwArrayExists = true;
4244 :
4245 1620 : }
4246 :
4247 :
4248 : /**
4249 : * Mark effectiveBwArray, which is an optional field, as non-existent.
4250 : */
4251 0 : void SpectralWindowRow::clearEffectiveBwArray () {
4252 0 : effectiveBwArrayExists = false;
4253 0 : }
4254 :
4255 :
4256 :
4257 : /**
4258 : * The attribute freqGroup is optional. Return true if this attribute exists.
4259 : * @return true if and only if the freqGroup attribute exists.
4260 : */
4261 2209 : bool SpectralWindowRow::isFreqGroupExists() const {
4262 2209 : return freqGroupExists;
4263 : }
4264 :
4265 :
4266 :
4267 : /**
4268 : * Get freqGroup, which is optional.
4269 : * @return freqGroup as int
4270 : * @throw IllegalAccessException If freqGroup does not exist.
4271 : */
4272 4 : int SpectralWindowRow::getFreqGroup() const {
4273 4 : if (!freqGroupExists) {
4274 0 : throw IllegalAccessException("freqGroup", "SpectralWindow");
4275 : }
4276 :
4277 4 : return freqGroup;
4278 : }
4279 :
4280 : /**
4281 : * Set freqGroup with the specified int.
4282 : * @param freqGroup The int value to which freqGroup is to be set.
4283 :
4284 :
4285 : */
4286 111 : void SpectralWindowRow::setFreqGroup (int freqGroup) {
4287 :
4288 111 : this->freqGroup = freqGroup;
4289 :
4290 111 : freqGroupExists = true;
4291 :
4292 111 : }
4293 :
4294 :
4295 : /**
4296 : * Mark freqGroup, which is an optional field, as non-existent.
4297 : */
4298 0 : void SpectralWindowRow::clearFreqGroup () {
4299 0 : freqGroupExists = false;
4300 0 : }
4301 :
4302 :
4303 :
4304 : /**
4305 : * The attribute freqGroupName is optional. Return true if this attribute exists.
4306 : * @return true if and only if the freqGroupName attribute exists.
4307 : */
4308 2209 : bool SpectralWindowRow::isFreqGroupNameExists() const {
4309 2209 : return freqGroupNameExists;
4310 : }
4311 :
4312 :
4313 :
4314 : /**
4315 : * Get freqGroupName, which is optional.
4316 : * @return freqGroupName as std::string
4317 : * @throw IllegalAccessException If freqGroupName does not exist.
4318 : */
4319 4 : std::string SpectralWindowRow::getFreqGroupName() const {
4320 4 : if (!freqGroupNameExists) {
4321 0 : throw IllegalAccessException("freqGroupName", "SpectralWindow");
4322 : }
4323 :
4324 4 : return freqGroupName;
4325 : }
4326 :
4327 : /**
4328 : * Set freqGroupName with the specified std::string.
4329 : * @param freqGroupName The std::string value to which freqGroupName is to be set.
4330 :
4331 :
4332 : */
4333 111 : void SpectralWindowRow::setFreqGroupName (std::string freqGroupName) {
4334 :
4335 111 : this->freqGroupName = freqGroupName;
4336 :
4337 111 : freqGroupNameExists = true;
4338 :
4339 111 : }
4340 :
4341 :
4342 : /**
4343 : * Mark freqGroupName, which is an optional field, as non-existent.
4344 : */
4345 0 : void SpectralWindowRow::clearFreqGroupName () {
4346 0 : freqGroupNameExists = false;
4347 0 : }
4348 :
4349 :
4350 :
4351 : /**
4352 : * The attribute lineArray is optional. Return true if this attribute exists.
4353 : * @return true if and only if the lineArray attribute exists.
4354 : */
4355 0 : bool SpectralWindowRow::isLineArrayExists() const {
4356 0 : return lineArrayExists;
4357 : }
4358 :
4359 :
4360 :
4361 : /**
4362 : * Get lineArray, which is optional.
4363 : * @return lineArray as std::vector<bool >
4364 : * @throw IllegalAccessException If lineArray does not exist.
4365 : */
4366 0 : std::vector<bool > SpectralWindowRow::getLineArray() const {
4367 0 : if (!lineArrayExists) {
4368 0 : throw IllegalAccessException("lineArray", "SpectralWindow");
4369 : }
4370 :
4371 0 : return lineArray;
4372 : }
4373 :
4374 : /**
4375 : * Set lineArray with the specified std::vector<bool >.
4376 : * @param lineArray The std::vector<bool > value to which lineArray is to be set.
4377 :
4378 :
4379 : */
4380 0 : void SpectralWindowRow::setLineArray (std::vector<bool > lineArray) {
4381 :
4382 0 : this->lineArray = lineArray;
4383 :
4384 0 : lineArrayExists = true;
4385 :
4386 0 : }
4387 :
4388 :
4389 : /**
4390 : * Mark lineArray, which is an optional field, as non-existent.
4391 : */
4392 0 : void SpectralWindowRow::clearLineArray () {
4393 0 : lineArrayExists = false;
4394 0 : }
4395 :
4396 :
4397 :
4398 : /**
4399 : * The attribute measFreqRef is optional. Return true if this attribute exists.
4400 : * @return true if and only if the measFreqRef attribute exists.
4401 : */
4402 2969 : bool SpectralWindowRow::isMeasFreqRefExists() const {
4403 2969 : return measFreqRefExists;
4404 : }
4405 :
4406 :
4407 :
4408 : /**
4409 : * Get measFreqRef, which is optional.
4410 : * @return measFreqRef as FrequencyReferenceCodeMod::FrequencyReferenceCode
4411 : * @throw IllegalAccessException If measFreqRef does not exist.
4412 : */
4413 4 : FrequencyReferenceCodeMod::FrequencyReferenceCode SpectralWindowRow::getMeasFreqRef() const {
4414 4 : if (!measFreqRefExists) {
4415 0 : throw IllegalAccessException("measFreqRef", "SpectralWindow");
4416 : }
4417 :
4418 4 : return measFreqRef;
4419 : }
4420 :
4421 : /**
4422 : * Set measFreqRef with the specified FrequencyReferenceCodeMod::FrequencyReferenceCode.
4423 : * @param measFreqRef The FrequencyReferenceCodeMod::FrequencyReferenceCode value to which measFreqRef is to be set.
4424 :
4425 :
4426 : */
4427 107 : void SpectralWindowRow::setMeasFreqRef (FrequencyReferenceCodeMod::FrequencyReferenceCode measFreqRef) {
4428 :
4429 107 : this->measFreqRef = measFreqRef;
4430 :
4431 107 : measFreqRefExists = true;
4432 :
4433 107 : }
4434 :
4435 :
4436 : /**
4437 : * Mark measFreqRef, which is an optional field, as non-existent.
4438 : */
4439 0 : void SpectralWindowRow::clearMeasFreqRef () {
4440 0 : measFreqRefExists = false;
4441 0 : }
4442 :
4443 :
4444 :
4445 : /**
4446 : * The attribute name is optional. Return true if this attribute exists.
4447 : * @return true if and only if the name attribute exists.
4448 : */
4449 2209 : bool SpectralWindowRow::isNameExists() const {
4450 2209 : return nameExists;
4451 : }
4452 :
4453 :
4454 :
4455 : /**
4456 : * Get name, which is optional.
4457 : * @return name as std::string
4458 : * @throw IllegalAccessException If name does not exist.
4459 : */
4460 2197 : std::string SpectralWindowRow::getName() const {
4461 2197 : if (!nameExists) {
4462 0 : throw IllegalAccessException("name", "SpectralWindow");
4463 : }
4464 :
4465 2197 : return name;
4466 : }
4467 :
4468 : /**
4469 : * Set name with the specified std::string.
4470 : * @param name The std::string value to which name is to be set.
4471 :
4472 :
4473 : */
4474 2278 : void SpectralWindowRow::setName (std::string name) {
4475 :
4476 2278 : this->name = name;
4477 :
4478 2278 : nameExists = true;
4479 :
4480 2278 : }
4481 :
4482 :
4483 : /**
4484 : * Mark name, which is an optional field, as non-existent.
4485 : */
4486 0 : void SpectralWindowRow::clearName () {
4487 0 : nameExists = false;
4488 0 : }
4489 :
4490 :
4491 :
4492 : /**
4493 : * The attribute oversampling is optional. Return true if this attribute exists.
4494 : * @return true if and only if the oversampling attribute exists.
4495 : */
4496 0 : bool SpectralWindowRow::isOversamplingExists() const {
4497 0 : return oversamplingExists;
4498 : }
4499 :
4500 :
4501 :
4502 : /**
4503 : * Get oversampling, which is optional.
4504 : * @return oversampling as bool
4505 : * @throw IllegalAccessException If oversampling does not exist.
4506 : */
4507 0 : bool SpectralWindowRow::getOversampling() const {
4508 0 : if (!oversamplingExists) {
4509 0 : throw IllegalAccessException("oversampling", "SpectralWindow");
4510 : }
4511 :
4512 0 : return oversampling;
4513 : }
4514 :
4515 : /**
4516 : * Set oversampling with the specified bool.
4517 : * @param oversampling The bool value to which oversampling is to be set.
4518 :
4519 :
4520 : */
4521 298 : void SpectralWindowRow::setOversampling (bool oversampling) {
4522 :
4523 298 : this->oversampling = oversampling;
4524 :
4525 298 : oversamplingExists = true;
4526 :
4527 298 : }
4528 :
4529 :
4530 : /**
4531 : * Mark oversampling, which is an optional field, as non-existent.
4532 : */
4533 0 : void SpectralWindowRow::clearOversampling () {
4534 0 : oversamplingExists = false;
4535 0 : }
4536 :
4537 :
4538 :
4539 : /**
4540 : * The attribute quantization is optional. Return true if this attribute exists.
4541 : * @return true if and only if the quantization attribute exists.
4542 : */
4543 0 : bool SpectralWindowRow::isQuantizationExists() const {
4544 0 : return quantizationExists;
4545 : }
4546 :
4547 :
4548 :
4549 : /**
4550 : * Get quantization, which is optional.
4551 : * @return quantization as bool
4552 : * @throw IllegalAccessException If quantization does not exist.
4553 : */
4554 0 : bool SpectralWindowRow::getQuantization() const {
4555 0 : if (!quantizationExists) {
4556 0 : throw IllegalAccessException("quantization", "SpectralWindow");
4557 : }
4558 :
4559 0 : return quantization;
4560 : }
4561 :
4562 : /**
4563 : * Set quantization with the specified bool.
4564 : * @param quantization The bool value to which quantization is to be set.
4565 :
4566 :
4567 : */
4568 1164 : void SpectralWindowRow::setQuantization (bool quantization) {
4569 :
4570 1164 : this->quantization = quantization;
4571 :
4572 1164 : quantizationExists = true;
4573 :
4574 1164 : }
4575 :
4576 :
4577 : /**
4578 : * Mark quantization, which is an optional field, as non-existent.
4579 : */
4580 0 : void SpectralWindowRow::clearQuantization () {
4581 0 : quantizationExists = false;
4582 0 : }
4583 :
4584 :
4585 :
4586 : /**
4587 : * The attribute refChan is optional. Return true if this attribute exists.
4588 : * @return true if and only if the refChan attribute exists.
4589 : */
4590 0 : bool SpectralWindowRow::isRefChanExists() const {
4591 0 : return refChanExists;
4592 : }
4593 :
4594 :
4595 :
4596 : /**
4597 : * Get refChan, which is optional.
4598 : * @return refChan as double
4599 : * @throw IllegalAccessException If refChan does not exist.
4600 : */
4601 0 : double SpectralWindowRow::getRefChan() const {
4602 0 : if (!refChanExists) {
4603 0 : throw IllegalAccessException("refChan", "SpectralWindow");
4604 : }
4605 :
4606 0 : return refChan;
4607 : }
4608 :
4609 : /**
4610 : * Set refChan with the specified double.
4611 : * @param refChan The double value to which refChan is to be set.
4612 :
4613 :
4614 : */
4615 861 : void SpectralWindowRow::setRefChan (double refChan) {
4616 :
4617 861 : this->refChan = refChan;
4618 :
4619 861 : refChanExists = true;
4620 :
4621 861 : }
4622 :
4623 :
4624 : /**
4625 : * Mark refChan, which is an optional field, as non-existent.
4626 : */
4627 0 : void SpectralWindowRow::clearRefChan () {
4628 0 : refChanExists = false;
4629 0 : }
4630 :
4631 :
4632 :
4633 : /**
4634 : * The attribute resolution is optional. Return true if this attribute exists.
4635 : * @return true if and only if the resolution attribute exists.
4636 : */
4637 2856 : bool SpectralWindowRow::isResolutionExists() const {
4638 2856 : return resolutionExists;
4639 : }
4640 :
4641 :
4642 :
4643 : /**
4644 : * Get resolution, which is optional.
4645 : * @return resolution as Frequency
4646 : * @throw IllegalAccessException If resolution does not exist.
4647 : */
4648 1347 : Frequency SpectralWindowRow::getResolution() const {
4649 1347 : if (!resolutionExists) {
4650 0 : throw IllegalAccessException("resolution", "SpectralWindow");
4651 : }
4652 :
4653 1347 : return resolution;
4654 : }
4655 :
4656 : /**
4657 : * Set resolution with the specified Frequency.
4658 : * @param resolution The Frequency value to which resolution is to be set.
4659 :
4660 :
4661 : */
4662 779 : void SpectralWindowRow::setResolution (Frequency resolution) {
4663 :
4664 779 : this->resolution = resolution;
4665 :
4666 779 : resolutionExists = true;
4667 :
4668 779 : }
4669 :
4670 :
4671 : /**
4672 : * Mark resolution, which is an optional field, as non-existent.
4673 : */
4674 0 : void SpectralWindowRow::clearResolution () {
4675 0 : resolutionExists = false;
4676 0 : }
4677 :
4678 :
4679 :
4680 : /**
4681 : * The attribute resolutionArray is optional. Return true if this attribute exists.
4682 : * @return true if and only if the resolutionArray attribute exists.
4683 : */
4684 3666 : bool SpectralWindowRow::isResolutionArrayExists() const {
4685 3666 : return resolutionArrayExists;
4686 : }
4687 :
4688 :
4689 :
4690 : /**
4691 : * Get resolutionArray, which is optional.
4692 : * @return resolutionArray as std::vector<Frequency >
4693 : * @throw IllegalAccessException If resolutionArray does not exist.
4694 : */
4695 1457 : std::vector<Frequency > SpectralWindowRow::getResolutionArray() const {
4696 1457 : if (!resolutionArrayExists) {
4697 0 : throw IllegalAccessException("resolutionArray", "SpectralWindow");
4698 : }
4699 :
4700 1457 : return resolutionArray;
4701 : }
4702 :
4703 : /**
4704 : * Set resolutionArray with the specified std::vector<Frequency >.
4705 : * @param resolutionArray The std::vector<Frequency > value to which resolutionArray is to be set.
4706 :
4707 :
4708 : */
4709 1620 : void SpectralWindowRow::setResolutionArray (std::vector<Frequency > resolutionArray) {
4710 :
4711 1620 : this->resolutionArray = resolutionArray;
4712 :
4713 1620 : resolutionArrayExists = true;
4714 :
4715 1620 : }
4716 :
4717 :
4718 : /**
4719 : * Mark resolutionArray, which is an optional field, as non-existent.
4720 : */
4721 0 : void SpectralWindowRow::clearResolutionArray () {
4722 0 : resolutionArrayExists = false;
4723 0 : }
4724 :
4725 :
4726 :
4727 : /**
4728 : * The attribute numAssocValues is optional. Return true if this attribute exists.
4729 : * @return true if and only if the numAssocValues attribute exists.
4730 : */
4731 2209 : bool SpectralWindowRow::isNumAssocValuesExists() const {
4732 2209 : return numAssocValuesExists;
4733 : }
4734 :
4735 :
4736 :
4737 : /**
4738 : * Get numAssocValues, which is optional.
4739 : * @return numAssocValues as int
4740 : * @throw IllegalAccessException If numAssocValues does not exist.
4741 : */
4742 1893 : int SpectralWindowRow::getNumAssocValues() const {
4743 1893 : if (!numAssocValuesExists) {
4744 0 : throw IllegalAccessException("numAssocValues", "SpectralWindow");
4745 : }
4746 :
4747 1893 : return numAssocValues;
4748 : }
4749 :
4750 : /**
4751 : * Set numAssocValues with the specified int.
4752 : * @param numAssocValues The int value to which numAssocValues is to be set.
4753 :
4754 :
4755 : */
4756 1974 : void SpectralWindowRow::setNumAssocValues (int numAssocValues) {
4757 :
4758 1974 : this->numAssocValues = numAssocValues;
4759 :
4760 1974 : numAssocValuesExists = true;
4761 :
4762 1974 : }
4763 :
4764 :
4765 : /**
4766 : * Mark numAssocValues, which is an optional field, as non-existent.
4767 : */
4768 0 : void SpectralWindowRow::clearNumAssocValues () {
4769 0 : numAssocValuesExists = false;
4770 0 : }
4771 :
4772 :
4773 :
4774 : /**
4775 : * The attribute assocNature is optional. Return true if this attribute exists.
4776 : * @return true if and only if the assocNature attribute exists.
4777 : */
4778 4418 : bool SpectralWindowRow::isAssocNatureExists() const {
4779 4418 : return assocNatureExists;
4780 : }
4781 :
4782 :
4783 :
4784 : /**
4785 : * Get assocNature, which is optional.
4786 : * @return assocNature as std::vector<SpectralResolutionTypeMod::SpectralResolutionType >
4787 : * @throw IllegalAccessException If assocNature does not exist.
4788 : */
4789 3786 : std::vector<SpectralResolutionTypeMod::SpectralResolutionType > SpectralWindowRow::getAssocNature() const {
4790 3786 : if (!assocNatureExists) {
4791 0 : throw IllegalAccessException("assocNature", "SpectralWindow");
4792 : }
4793 :
4794 3786 : return assocNature;
4795 : }
4796 :
4797 : /**
4798 : * Set assocNature with the specified std::vector<SpectralResolutionTypeMod::SpectralResolutionType >.
4799 : * @param assocNature The std::vector<SpectralResolutionTypeMod::SpectralResolutionType > value to which assocNature is to be set.
4800 :
4801 :
4802 : */
4803 0 : void SpectralWindowRow::setAssocNature (std::vector<SpectralResolutionTypeMod::SpectralResolutionType > assocNature) {
4804 :
4805 0 : this->assocNature = assocNature;
4806 :
4807 0 : assocNatureExists = true;
4808 :
4809 0 : }
4810 :
4811 :
4812 : /**
4813 : * Mark assocNature, which is an optional field, as non-existent.
4814 : */
4815 0 : void SpectralWindowRow::clearAssocNature () {
4816 0 : assocNatureExists = false;
4817 0 : }
4818 :
4819 :
4820 :
4821 : ///////////////////////////////////////////////
4822 : // Extrinsic Table Attributes getters/setters//
4823 : ///////////////////////////////////////////////
4824 :
4825 :
4826 : /**
4827 : * The attribute assocSpectralWindowId is optional. Return true if this attribute exists.
4828 : * @return true if and only if the assocSpectralWindowId attribute exists.
4829 : */
4830 4418 : bool SpectralWindowRow::isAssocSpectralWindowIdExists() const {
4831 4418 : return assocSpectralWindowIdExists;
4832 : }
4833 :
4834 :
4835 :
4836 : /**
4837 : * Get assocSpectralWindowId, which is optional.
4838 : * @return assocSpectralWindowId as std::vector<Tag>
4839 : * @throw IllegalAccessException If assocSpectralWindowId does not exist.
4840 : */
4841 1893 : std::vector<Tag> SpectralWindowRow::getAssocSpectralWindowId() const {
4842 1893 : if (!assocSpectralWindowIdExists) {
4843 0 : throw IllegalAccessException("assocSpectralWindowId", "SpectralWindow");
4844 : }
4845 :
4846 1893 : return assocSpectralWindowId;
4847 : }
4848 :
4849 : /**
4850 : * Set assocSpectralWindowId with the specified std::vector<Tag> .
4851 : * @param assocSpectralWindowId The std::vector<Tag> value to which assocSpectralWindowId is to be set.
4852 :
4853 :
4854 : */
4855 1974 : void SpectralWindowRow::setAssocSpectralWindowId (std::vector<Tag> assocSpectralWindowId) {
4856 :
4857 1974 : this->assocSpectralWindowId = assocSpectralWindowId;
4858 :
4859 1974 : assocSpectralWindowIdExists = true;
4860 :
4861 1974 : }
4862 :
4863 :
4864 : /**
4865 : * Mark assocSpectralWindowId, which is an optional field, as non-existent.
4866 : */
4867 0 : void SpectralWindowRow::clearAssocSpectralWindowId () {
4868 0 : assocSpectralWindowIdExists = false;
4869 0 : }
4870 :
4871 :
4872 :
4873 : /**
4874 : * The attribute dopplerId is optional. Return true if this attribute exists.
4875 : * @return true if and only if the dopplerId attribute exists.
4876 : */
4877 0 : bool SpectralWindowRow::isDopplerIdExists() const {
4878 0 : return dopplerIdExists;
4879 : }
4880 :
4881 :
4882 :
4883 : /**
4884 : * Get dopplerId, which is optional.
4885 : * @return dopplerId as int
4886 : * @throw IllegalAccessException If dopplerId does not exist.
4887 : */
4888 0 : int SpectralWindowRow::getDopplerId() const {
4889 0 : if (!dopplerIdExists) {
4890 0 : throw IllegalAccessException("dopplerId", "SpectralWindow");
4891 : }
4892 :
4893 0 : return dopplerId;
4894 : }
4895 :
4896 : /**
4897 : * Set dopplerId with the specified int.
4898 : * @param dopplerId The int value to which dopplerId is to be set.
4899 :
4900 :
4901 : */
4902 0 : void SpectralWindowRow::setDopplerId (int dopplerId) {
4903 :
4904 0 : this->dopplerId = dopplerId;
4905 :
4906 0 : dopplerIdExists = true;
4907 :
4908 0 : }
4909 :
4910 :
4911 : /**
4912 : * Mark dopplerId, which is an optional field, as non-existent.
4913 : */
4914 0 : void SpectralWindowRow::clearDopplerId () {
4915 0 : dopplerIdExists = false;
4916 0 : }
4917 :
4918 :
4919 :
4920 : /**
4921 : * The attribute imageSpectralWindowId is optional. Return true if this attribute exists.
4922 : * @return true if and only if the imageSpectralWindowId attribute exists.
4923 : */
4924 0 : bool SpectralWindowRow::isImageSpectralWindowIdExists() const {
4925 0 : return imageSpectralWindowIdExists;
4926 : }
4927 :
4928 :
4929 :
4930 : /**
4931 : * Get imageSpectralWindowId, which is optional.
4932 : * @return imageSpectralWindowId as Tag
4933 : * @throw IllegalAccessException If imageSpectralWindowId does not exist.
4934 : */
4935 0 : Tag SpectralWindowRow::getImageSpectralWindowId() const {
4936 0 : if (!imageSpectralWindowIdExists) {
4937 0 : throw IllegalAccessException("imageSpectralWindowId", "SpectralWindow");
4938 : }
4939 :
4940 0 : return imageSpectralWindowId;
4941 : }
4942 :
4943 : /**
4944 : * Set imageSpectralWindowId with the specified Tag.
4945 : * @param imageSpectralWindowId The Tag value to which imageSpectralWindowId is to be set.
4946 :
4947 :
4948 : */
4949 0 : void SpectralWindowRow::setImageSpectralWindowId (Tag imageSpectralWindowId) {
4950 :
4951 0 : this->imageSpectralWindowId = imageSpectralWindowId;
4952 :
4953 0 : imageSpectralWindowIdExists = true;
4954 :
4955 0 : }
4956 :
4957 :
4958 : /**
4959 : * Mark imageSpectralWindowId, which is an optional field, as non-existent.
4960 : */
4961 0 : void SpectralWindowRow::clearImageSpectralWindowId () {
4962 0 : imageSpectralWindowIdExists = false;
4963 0 : }
4964 :
4965 :
4966 :
4967 : //////////////////////////////////////
4968 : // Links Attributes getters/setters //
4969 : //////////////////////////////////////
4970 :
4971 :
4972 :
4973 : /**
4974 : * Set assocSpectralWindowId[i] with the specified Tag.
4975 : * @param i The index in assocSpectralWindowId where to set the Tag value.
4976 : * @param assocSpectralWindowId The Tag value to which assocSpectralWindowId[i] is to be set.
4977 : * @throws OutOfBoundsException
4978 : */
4979 0 : void SpectralWindowRow::setAssocSpectralWindowId (int i, Tag assocSpectralWindowId) {
4980 0 : if ((i < 0) || (i > ((int) this->assocSpectralWindowId.size())))
4981 0 : throw OutOfBoundsException("Index out of bounds during a set operation on attribute assocSpectralWindowId in table SpectralWindowTable");
4982 0 : std::vector<Tag> ::iterator iter = this->assocSpectralWindowId.begin();
4983 0 : int j = 0;
4984 0 : while (j < i) {
4985 0 : j++; iter++;
4986 : }
4987 0 : this->assocSpectralWindowId.insert(this->assocSpectralWindowId.erase(iter), assocSpectralWindowId);
4988 0 : }
4989 :
4990 :
4991 :
4992 :
4993 :
4994 : /**
4995 : * Append a Tag to assocSpectralWindowId.
4996 : * @param id the Tag to be appended to assocSpectralWindowId
4997 : */
4998 0 : void SpectralWindowRow::addAssocSpectralWindowId(Tag id){
4999 0 : assocSpectralWindowId.push_back(id);
5000 0 : }
5001 :
5002 : /**
5003 : * Append an array of Tag to assocSpectralWindowId.
5004 : * @param id an array of Tag to be appended to assocSpectralWindowId
5005 : */
5006 0 : void SpectralWindowRow::addAssocSpectralWindowId(const std::vector<Tag> & id) {
5007 0 : for (unsigned int i=0; i < id.size(); i++)
5008 0 : assocSpectralWindowId.push_back(id.at(i));
5009 0 : }
5010 :
5011 :
5012 : /**
5013 : * Returns the Tag stored in assocSpectralWindowId at position i.
5014 : *
5015 : */
5016 0 : const Tag SpectralWindowRow::getAssocSpectralWindowId(int i) {
5017 0 : return assocSpectralWindowId.at(i);
5018 : }
5019 :
5020 : /**
5021 : * Returns the SpectralWindowRow linked to this row via the Tag stored in assocSpectralWindowId
5022 : * at position i.
5023 : */
5024 0 : SpectralWindowRow* SpectralWindowRow::getSpectralWindowUsingAssocSpectralWindowId(int i) {
5025 0 : return table.getContainer().getSpectralWindow().getRowByKey(assocSpectralWindowId.at(i));
5026 : }
5027 :
5028 : /**
5029 : * Returns the vector of SpectralWindowRow* linked to this row via the Tags stored in assocSpectralWindowId
5030 : *
5031 : */
5032 0 : vector<SpectralWindowRow *> SpectralWindowRow::getSpectralWindowsUsingAssocSpectralWindowId() {
5033 0 : vector<SpectralWindowRow *> result;
5034 0 : for (unsigned int i = 0; i < assocSpectralWindowId.size(); i++)
5035 0 : result.push_back(table.getContainer().getSpectralWindow().getRowByKey(assocSpectralWindowId.at(i)));
5036 :
5037 0 : return result;
5038 0 : }
5039 :
5040 :
5041 :
5042 :
5043 :
5044 :
5045 :
5046 :
5047 :
5048 : /**
5049 : * Returns the pointer to the row in the SpectralWindow table having SpectralWindow.imageSpectralWindowId == imageSpectralWindowId
5050 : * @return a SpectralWindowRow*
5051 : *
5052 :
5053 : * throws IllegalAccessException
5054 :
5055 : */
5056 0 : SpectralWindowRow* SpectralWindowRow::getSpectralWindowUsingImageSpectralWindowId() {
5057 :
5058 0 : if (!imageSpectralWindowIdExists)
5059 0 : throw IllegalAccessException();
5060 :
5061 0 : return table.getContainer().getSpectralWindow().getRowByKey(imageSpectralWindowId);
5062 : }
5063 :
5064 :
5065 :
5066 :
5067 :
5068 :
5069 :
5070 :
5071 :
5072 : // ===> Slice link from a row of SpectralWindow table to a collection of row of Doppler table.
5073 :
5074 : /**
5075 : * Get the collection of row in the Doppler table having their attribut dopplerId == this->dopplerId
5076 : */
5077 0 : vector <DopplerRow *> SpectralWindowRow::getDopplers() {
5078 :
5079 0 : if (dopplerIdExists) {
5080 0 : return table.getContainer().getDoppler().getRowByDopplerId(dopplerId);
5081 : }
5082 : else
5083 0 : throw IllegalAccessException();
5084 :
5085 : }
5086 :
5087 :
5088 :
5089 :
5090 :
5091 : /**
5092 : * Create a SpectralWindowRow.
5093 : * <p>
5094 : * This constructor is private because only the
5095 : * table can create rows. All rows know the table
5096 : * to which they belong.
5097 : * @param table The table to which this row belongs.
5098 : */
5099 2399 : SpectralWindowRow::SpectralWindowRow (SpectralWindowTable &t) : table(t) {
5100 2399 : hasBeenAdded = false;
5101 :
5102 :
5103 :
5104 :
5105 :
5106 :
5107 :
5108 :
5109 :
5110 :
5111 :
5112 2399 : numBinExists = false;
5113 :
5114 :
5115 :
5116 :
5117 :
5118 :
5119 :
5120 :
5121 :
5122 :
5123 :
5124 2399 : chanFreqStartExists = false;
5125 :
5126 :
5127 :
5128 2399 : chanFreqStepExists = false;
5129 :
5130 :
5131 :
5132 2399 : chanFreqArrayExists = false;
5133 :
5134 :
5135 :
5136 2399 : chanWidthExists = false;
5137 :
5138 :
5139 :
5140 2399 : chanWidthArrayExists = false;
5141 :
5142 :
5143 :
5144 2399 : correlationBitExists = false;
5145 :
5146 :
5147 :
5148 2399 : effectiveBwExists = false;
5149 :
5150 :
5151 :
5152 2399 : effectiveBwArrayExists = false;
5153 :
5154 :
5155 :
5156 2399 : freqGroupExists = false;
5157 :
5158 :
5159 :
5160 2399 : freqGroupNameExists = false;
5161 :
5162 :
5163 :
5164 2399 : lineArrayExists = false;
5165 :
5166 :
5167 :
5168 2399 : measFreqRefExists = false;
5169 :
5170 :
5171 :
5172 2399 : nameExists = false;
5173 :
5174 :
5175 :
5176 2399 : oversamplingExists = false;
5177 :
5178 :
5179 :
5180 2399 : quantizationExists = false;
5181 :
5182 :
5183 :
5184 2399 : refChanExists = false;
5185 :
5186 :
5187 :
5188 2399 : resolutionExists = false;
5189 :
5190 :
5191 :
5192 2399 : resolutionArrayExists = false;
5193 :
5194 :
5195 :
5196 2399 : numAssocValuesExists = false;
5197 :
5198 :
5199 :
5200 2399 : assocNatureExists = false;
5201 :
5202 :
5203 :
5204 :
5205 2399 : assocSpectralWindowIdExists = false;
5206 :
5207 :
5208 :
5209 2399 : dopplerIdExists = false;
5210 :
5211 :
5212 :
5213 2399 : imageSpectralWindowIdExists = false;
5214 :
5215 :
5216 :
5217 :
5218 :
5219 :
5220 :
5221 :
5222 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
5223 2399 : basebandName = CBasebandName::from_int(0);
5224 :
5225 :
5226 :
5227 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
5228 2399 : netSideband = CNetSideband::from_int(0);
5229 :
5230 :
5231 :
5232 :
5233 :
5234 :
5235 :
5236 :
5237 :
5238 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
5239 2399 : sidebandProcessingMode = CSidebandProcessingMode::from_int(0);
5240 :
5241 :
5242 :
5243 :
5244 :
5245 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
5246 2399 : windowFunction = CWindowFunction::from_int(0);
5247 :
5248 :
5249 :
5250 :
5251 :
5252 :
5253 :
5254 :
5255 :
5256 :
5257 :
5258 :
5259 :
5260 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
5261 2399 : correlationBit = CCorrelationBit::from_int(0);
5262 :
5263 :
5264 :
5265 :
5266 :
5267 :
5268 :
5269 :
5270 :
5271 :
5272 :
5273 :
5274 :
5275 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
5276 2399 : measFreqRef = CFrequencyReferenceCode::from_int(0);
5277 :
5278 :
5279 :
5280 :
5281 :
5282 :
5283 :
5284 :
5285 :
5286 :
5287 :
5288 :
5289 :
5290 :
5291 :
5292 :
5293 :
5294 :
5295 :
5296 :
5297 2399 : fromBinMethods["spectralWindowId"] = &SpectralWindowRow::spectralWindowIdFromBin;
5298 2399 : fromBinMethods["basebandName"] = &SpectralWindowRow::basebandNameFromBin;
5299 2399 : fromBinMethods["netSideband"] = &SpectralWindowRow::netSidebandFromBin;
5300 2399 : fromBinMethods["numChan"] = &SpectralWindowRow::numChanFromBin;
5301 2399 : fromBinMethods["refFreq"] = &SpectralWindowRow::refFreqFromBin;
5302 2399 : fromBinMethods["sidebandProcessingMode"] = &SpectralWindowRow::sidebandProcessingModeFromBin;
5303 2399 : fromBinMethods["totBandwidth"] = &SpectralWindowRow::totBandwidthFromBin;
5304 2399 : fromBinMethods["windowFunction"] = &SpectralWindowRow::windowFunctionFromBin;
5305 :
5306 :
5307 2399 : fromBinMethods["numBin"] = &SpectralWindowRow::numBinFromBin;
5308 2399 : fromBinMethods["chanFreqStart"] = &SpectralWindowRow::chanFreqStartFromBin;
5309 2399 : fromBinMethods["chanFreqStep"] = &SpectralWindowRow::chanFreqStepFromBin;
5310 2399 : fromBinMethods["chanFreqArray"] = &SpectralWindowRow::chanFreqArrayFromBin;
5311 2399 : fromBinMethods["chanWidth"] = &SpectralWindowRow::chanWidthFromBin;
5312 2399 : fromBinMethods["chanWidthArray"] = &SpectralWindowRow::chanWidthArrayFromBin;
5313 2399 : fromBinMethods["correlationBit"] = &SpectralWindowRow::correlationBitFromBin;
5314 2399 : fromBinMethods["effectiveBw"] = &SpectralWindowRow::effectiveBwFromBin;
5315 2399 : fromBinMethods["effectiveBwArray"] = &SpectralWindowRow::effectiveBwArrayFromBin;
5316 2399 : fromBinMethods["freqGroup"] = &SpectralWindowRow::freqGroupFromBin;
5317 2399 : fromBinMethods["freqGroupName"] = &SpectralWindowRow::freqGroupNameFromBin;
5318 2399 : fromBinMethods["lineArray"] = &SpectralWindowRow::lineArrayFromBin;
5319 2399 : fromBinMethods["measFreqRef"] = &SpectralWindowRow::measFreqRefFromBin;
5320 2399 : fromBinMethods["name"] = &SpectralWindowRow::nameFromBin;
5321 2399 : fromBinMethods["oversampling"] = &SpectralWindowRow::oversamplingFromBin;
5322 2399 : fromBinMethods["quantization"] = &SpectralWindowRow::quantizationFromBin;
5323 2399 : fromBinMethods["refChan"] = &SpectralWindowRow::refChanFromBin;
5324 2399 : fromBinMethods["resolution"] = &SpectralWindowRow::resolutionFromBin;
5325 2399 : fromBinMethods["resolutionArray"] = &SpectralWindowRow::resolutionArrayFromBin;
5326 2399 : fromBinMethods["numAssocValues"] = &SpectralWindowRow::numAssocValuesFromBin;
5327 2399 : fromBinMethods["assocNature"] = &SpectralWindowRow::assocNatureFromBin;
5328 2399 : fromBinMethods["assocSpectralWindowId"] = &SpectralWindowRow::assocSpectralWindowIdFromBin;
5329 2399 : fromBinMethods["imageSpectralWindowId"] = &SpectralWindowRow::imageSpectralWindowIdFromBin;
5330 2399 : fromBinMethods["dopplerId"] = &SpectralWindowRow::dopplerIdFromBin;
5331 :
5332 :
5333 :
5334 :
5335 :
5336 2399 : fromTextMethods["spectralWindowId"] = &SpectralWindowRow::spectralWindowIdFromText;
5337 :
5338 :
5339 :
5340 2399 : fromTextMethods["basebandName"] = &SpectralWindowRow::basebandNameFromText;
5341 :
5342 :
5343 :
5344 2399 : fromTextMethods["netSideband"] = &SpectralWindowRow::netSidebandFromText;
5345 :
5346 :
5347 :
5348 2399 : fromTextMethods["numChan"] = &SpectralWindowRow::numChanFromText;
5349 :
5350 :
5351 :
5352 2399 : fromTextMethods["refFreq"] = &SpectralWindowRow::refFreqFromText;
5353 :
5354 :
5355 :
5356 2399 : fromTextMethods["sidebandProcessingMode"] = &SpectralWindowRow::sidebandProcessingModeFromText;
5357 :
5358 :
5359 :
5360 2399 : fromTextMethods["totBandwidth"] = &SpectralWindowRow::totBandwidthFromText;
5361 :
5362 :
5363 :
5364 2399 : fromTextMethods["windowFunction"] = &SpectralWindowRow::windowFunctionFromText;
5365 :
5366 :
5367 :
5368 :
5369 :
5370 2399 : fromTextMethods["numBin"] = &SpectralWindowRow::numBinFromText;
5371 :
5372 :
5373 :
5374 2399 : fromTextMethods["chanFreqStart"] = &SpectralWindowRow::chanFreqStartFromText;
5375 :
5376 :
5377 :
5378 2399 : fromTextMethods["chanFreqStep"] = &SpectralWindowRow::chanFreqStepFromText;
5379 :
5380 :
5381 :
5382 2399 : fromTextMethods["chanFreqArray"] = &SpectralWindowRow::chanFreqArrayFromText;
5383 :
5384 :
5385 :
5386 2399 : fromTextMethods["chanWidth"] = &SpectralWindowRow::chanWidthFromText;
5387 :
5388 :
5389 :
5390 2399 : fromTextMethods["chanWidthArray"] = &SpectralWindowRow::chanWidthArrayFromText;
5391 :
5392 :
5393 :
5394 2399 : fromTextMethods["correlationBit"] = &SpectralWindowRow::correlationBitFromText;
5395 :
5396 :
5397 :
5398 2399 : fromTextMethods["effectiveBw"] = &SpectralWindowRow::effectiveBwFromText;
5399 :
5400 :
5401 :
5402 2399 : fromTextMethods["effectiveBwArray"] = &SpectralWindowRow::effectiveBwArrayFromText;
5403 :
5404 :
5405 :
5406 2399 : fromTextMethods["freqGroup"] = &SpectralWindowRow::freqGroupFromText;
5407 :
5408 :
5409 :
5410 2399 : fromTextMethods["freqGroupName"] = &SpectralWindowRow::freqGroupNameFromText;
5411 :
5412 :
5413 :
5414 2399 : fromTextMethods["lineArray"] = &SpectralWindowRow::lineArrayFromText;
5415 :
5416 :
5417 :
5418 2399 : fromTextMethods["measFreqRef"] = &SpectralWindowRow::measFreqRefFromText;
5419 :
5420 :
5421 :
5422 2399 : fromTextMethods["name"] = &SpectralWindowRow::nameFromText;
5423 :
5424 :
5425 :
5426 2399 : fromTextMethods["oversampling"] = &SpectralWindowRow::oversamplingFromText;
5427 :
5428 :
5429 :
5430 2399 : fromTextMethods["quantization"] = &SpectralWindowRow::quantizationFromText;
5431 :
5432 :
5433 :
5434 2399 : fromTextMethods["refChan"] = &SpectralWindowRow::refChanFromText;
5435 :
5436 :
5437 :
5438 2399 : fromTextMethods["resolution"] = &SpectralWindowRow::resolutionFromText;
5439 :
5440 :
5441 :
5442 2399 : fromTextMethods["resolutionArray"] = &SpectralWindowRow::resolutionArrayFromText;
5443 :
5444 :
5445 :
5446 2399 : fromTextMethods["numAssocValues"] = &SpectralWindowRow::numAssocValuesFromText;
5447 :
5448 :
5449 :
5450 2399 : fromTextMethods["assocNature"] = &SpectralWindowRow::assocNatureFromText;
5451 :
5452 :
5453 :
5454 2399 : fromTextMethods["assocSpectralWindowId"] = &SpectralWindowRow::assocSpectralWindowIdFromText;
5455 :
5456 :
5457 :
5458 2399 : fromTextMethods["imageSpectralWindowId"] = &SpectralWindowRow::imageSpectralWindowIdFromText;
5459 :
5460 :
5461 :
5462 2399 : fromTextMethods["dopplerId"] = &SpectralWindowRow::dopplerIdFromText;
5463 :
5464 :
5465 2399 : }
5466 :
5467 0 : SpectralWindowRow::SpectralWindowRow (SpectralWindowTable &t, SpectralWindowRow *row) : table(t) {
5468 0 : hasBeenAdded = false;
5469 :
5470 0 : if (row == 0) {
5471 :
5472 :
5473 :
5474 :
5475 :
5476 :
5477 :
5478 :
5479 :
5480 :
5481 :
5482 0 : numBinExists = false;
5483 :
5484 :
5485 :
5486 :
5487 :
5488 :
5489 :
5490 :
5491 :
5492 :
5493 :
5494 0 : chanFreqStartExists = false;
5495 :
5496 :
5497 :
5498 0 : chanFreqStepExists = false;
5499 :
5500 :
5501 :
5502 0 : chanFreqArrayExists = false;
5503 :
5504 :
5505 :
5506 0 : chanWidthExists = false;
5507 :
5508 :
5509 :
5510 0 : chanWidthArrayExists = false;
5511 :
5512 :
5513 :
5514 0 : correlationBitExists = false;
5515 :
5516 :
5517 :
5518 0 : effectiveBwExists = false;
5519 :
5520 :
5521 :
5522 0 : effectiveBwArrayExists = false;
5523 :
5524 :
5525 :
5526 0 : freqGroupExists = false;
5527 :
5528 :
5529 :
5530 0 : freqGroupNameExists = false;
5531 :
5532 :
5533 :
5534 0 : lineArrayExists = false;
5535 :
5536 :
5537 :
5538 0 : measFreqRefExists = false;
5539 :
5540 :
5541 :
5542 0 : nameExists = false;
5543 :
5544 :
5545 :
5546 0 : oversamplingExists = false;
5547 :
5548 :
5549 :
5550 0 : quantizationExists = false;
5551 :
5552 :
5553 :
5554 0 : refChanExists = false;
5555 :
5556 :
5557 :
5558 0 : resolutionExists = false;
5559 :
5560 :
5561 :
5562 0 : resolutionArrayExists = false;
5563 :
5564 :
5565 :
5566 0 : numAssocValuesExists = false;
5567 :
5568 :
5569 :
5570 0 : assocNatureExists = false;
5571 :
5572 :
5573 :
5574 :
5575 0 : assocSpectralWindowIdExists = false;
5576 :
5577 :
5578 :
5579 0 : dopplerIdExists = false;
5580 :
5581 :
5582 :
5583 0 : imageSpectralWindowIdExists = false;
5584 :
5585 :
5586 : }
5587 : else {
5588 :
5589 :
5590 0 : spectralWindowId = row->spectralWindowId;
5591 :
5592 :
5593 :
5594 :
5595 0 : basebandName = row->basebandName;
5596 :
5597 0 : netSideband = row->netSideband;
5598 :
5599 0 : numChan = row->numChan;
5600 :
5601 0 : refFreq = row->refFreq;
5602 :
5603 0 : sidebandProcessingMode = row->sidebandProcessingMode;
5604 :
5605 0 : totBandwidth = row->totBandwidth;
5606 :
5607 0 : windowFunction = row->windowFunction;
5608 :
5609 :
5610 :
5611 :
5612 0 : if (row->numBinExists) {
5613 0 : numBin = row->numBin;
5614 0 : numBinExists = true;
5615 : }
5616 : else
5617 0 : numBinExists = false;
5618 :
5619 0 : if (row->chanFreqStartExists) {
5620 0 : chanFreqStart = row->chanFreqStart;
5621 0 : chanFreqStartExists = true;
5622 : }
5623 : else
5624 0 : chanFreqStartExists = false;
5625 :
5626 0 : if (row->chanFreqStepExists) {
5627 0 : chanFreqStep = row->chanFreqStep;
5628 0 : chanFreqStepExists = true;
5629 : }
5630 : else
5631 0 : chanFreqStepExists = false;
5632 :
5633 0 : if (row->chanFreqArrayExists) {
5634 0 : chanFreqArray = row->chanFreqArray;
5635 0 : chanFreqArrayExists = true;
5636 : }
5637 : else
5638 0 : chanFreqArrayExists = false;
5639 :
5640 0 : if (row->chanWidthExists) {
5641 0 : chanWidth = row->chanWidth;
5642 0 : chanWidthExists = true;
5643 : }
5644 : else
5645 0 : chanWidthExists = false;
5646 :
5647 0 : if (row->chanWidthArrayExists) {
5648 0 : chanWidthArray = row->chanWidthArray;
5649 0 : chanWidthArrayExists = true;
5650 : }
5651 : else
5652 0 : chanWidthArrayExists = false;
5653 :
5654 0 : if (row->correlationBitExists) {
5655 0 : correlationBit = row->correlationBit;
5656 0 : correlationBitExists = true;
5657 : }
5658 : else
5659 0 : correlationBitExists = false;
5660 :
5661 0 : if (row->effectiveBwExists) {
5662 0 : effectiveBw = row->effectiveBw;
5663 0 : effectiveBwExists = true;
5664 : }
5665 : else
5666 0 : effectiveBwExists = false;
5667 :
5668 0 : if (row->effectiveBwArrayExists) {
5669 0 : effectiveBwArray = row->effectiveBwArray;
5670 0 : effectiveBwArrayExists = true;
5671 : }
5672 : else
5673 0 : effectiveBwArrayExists = false;
5674 :
5675 0 : if (row->freqGroupExists) {
5676 0 : freqGroup = row->freqGroup;
5677 0 : freqGroupExists = true;
5678 : }
5679 : else
5680 0 : freqGroupExists = false;
5681 :
5682 0 : if (row->freqGroupNameExists) {
5683 0 : freqGroupName = row->freqGroupName;
5684 0 : freqGroupNameExists = true;
5685 : }
5686 : else
5687 0 : freqGroupNameExists = false;
5688 :
5689 0 : if (row->lineArrayExists) {
5690 0 : lineArray = row->lineArray;
5691 0 : lineArrayExists = true;
5692 : }
5693 : else
5694 0 : lineArrayExists = false;
5695 :
5696 0 : if (row->measFreqRefExists) {
5697 0 : measFreqRef = row->measFreqRef;
5698 0 : measFreqRefExists = true;
5699 : }
5700 : else
5701 0 : measFreqRefExists = false;
5702 :
5703 0 : if (row->nameExists) {
5704 0 : name = row->name;
5705 0 : nameExists = true;
5706 : }
5707 : else
5708 0 : nameExists = false;
5709 :
5710 0 : if (row->oversamplingExists) {
5711 0 : oversampling = row->oversampling;
5712 0 : oversamplingExists = true;
5713 : }
5714 : else
5715 0 : oversamplingExists = false;
5716 :
5717 0 : if (row->quantizationExists) {
5718 0 : quantization = row->quantization;
5719 0 : quantizationExists = true;
5720 : }
5721 : else
5722 0 : quantizationExists = false;
5723 :
5724 0 : if (row->refChanExists) {
5725 0 : refChan = row->refChan;
5726 0 : refChanExists = true;
5727 : }
5728 : else
5729 0 : refChanExists = false;
5730 :
5731 0 : if (row->resolutionExists) {
5732 0 : resolution = row->resolution;
5733 0 : resolutionExists = true;
5734 : }
5735 : else
5736 0 : resolutionExists = false;
5737 :
5738 0 : if (row->resolutionArrayExists) {
5739 0 : resolutionArray = row->resolutionArray;
5740 0 : resolutionArrayExists = true;
5741 : }
5742 : else
5743 0 : resolutionArrayExists = false;
5744 :
5745 0 : if (row->numAssocValuesExists) {
5746 0 : numAssocValues = row->numAssocValues;
5747 0 : numAssocValuesExists = true;
5748 : }
5749 : else
5750 0 : numAssocValuesExists = false;
5751 :
5752 0 : if (row->assocNatureExists) {
5753 0 : assocNature = row->assocNature;
5754 0 : assocNatureExists = true;
5755 : }
5756 : else
5757 0 : assocNatureExists = false;
5758 :
5759 0 : if (row->assocSpectralWindowIdExists) {
5760 0 : assocSpectralWindowId = row->assocSpectralWindowId;
5761 0 : assocSpectralWindowIdExists = true;
5762 : }
5763 : else
5764 0 : assocSpectralWindowIdExists = false;
5765 :
5766 0 : if (row->imageSpectralWindowIdExists) {
5767 0 : imageSpectralWindowId = row->imageSpectralWindowId;
5768 0 : imageSpectralWindowIdExists = true;
5769 : }
5770 : else
5771 0 : imageSpectralWindowIdExists = false;
5772 :
5773 0 : if (row->dopplerIdExists) {
5774 0 : dopplerId = row->dopplerId;
5775 0 : dopplerIdExists = true;
5776 : }
5777 : else
5778 0 : dopplerIdExists = false;
5779 :
5780 : }
5781 :
5782 0 : fromBinMethods["spectralWindowId"] = &SpectralWindowRow::spectralWindowIdFromBin;
5783 0 : fromBinMethods["basebandName"] = &SpectralWindowRow::basebandNameFromBin;
5784 0 : fromBinMethods["netSideband"] = &SpectralWindowRow::netSidebandFromBin;
5785 0 : fromBinMethods["numChan"] = &SpectralWindowRow::numChanFromBin;
5786 0 : fromBinMethods["refFreq"] = &SpectralWindowRow::refFreqFromBin;
5787 0 : fromBinMethods["sidebandProcessingMode"] = &SpectralWindowRow::sidebandProcessingModeFromBin;
5788 0 : fromBinMethods["totBandwidth"] = &SpectralWindowRow::totBandwidthFromBin;
5789 0 : fromBinMethods["windowFunction"] = &SpectralWindowRow::windowFunctionFromBin;
5790 :
5791 :
5792 0 : fromBinMethods["numBin"] = &SpectralWindowRow::numBinFromBin;
5793 0 : fromBinMethods["chanFreqStart"] = &SpectralWindowRow::chanFreqStartFromBin;
5794 0 : fromBinMethods["chanFreqStep"] = &SpectralWindowRow::chanFreqStepFromBin;
5795 0 : fromBinMethods["chanFreqArray"] = &SpectralWindowRow::chanFreqArrayFromBin;
5796 0 : fromBinMethods["chanWidth"] = &SpectralWindowRow::chanWidthFromBin;
5797 0 : fromBinMethods["chanWidthArray"] = &SpectralWindowRow::chanWidthArrayFromBin;
5798 0 : fromBinMethods["correlationBit"] = &SpectralWindowRow::correlationBitFromBin;
5799 0 : fromBinMethods["effectiveBw"] = &SpectralWindowRow::effectiveBwFromBin;
5800 0 : fromBinMethods["effectiveBwArray"] = &SpectralWindowRow::effectiveBwArrayFromBin;
5801 0 : fromBinMethods["freqGroup"] = &SpectralWindowRow::freqGroupFromBin;
5802 0 : fromBinMethods["freqGroupName"] = &SpectralWindowRow::freqGroupNameFromBin;
5803 0 : fromBinMethods["lineArray"] = &SpectralWindowRow::lineArrayFromBin;
5804 0 : fromBinMethods["measFreqRef"] = &SpectralWindowRow::measFreqRefFromBin;
5805 0 : fromBinMethods["name"] = &SpectralWindowRow::nameFromBin;
5806 0 : fromBinMethods["oversampling"] = &SpectralWindowRow::oversamplingFromBin;
5807 0 : fromBinMethods["quantization"] = &SpectralWindowRow::quantizationFromBin;
5808 0 : fromBinMethods["refChan"] = &SpectralWindowRow::refChanFromBin;
5809 0 : fromBinMethods["resolution"] = &SpectralWindowRow::resolutionFromBin;
5810 0 : fromBinMethods["resolutionArray"] = &SpectralWindowRow::resolutionArrayFromBin;
5811 0 : fromBinMethods["numAssocValues"] = &SpectralWindowRow::numAssocValuesFromBin;
5812 0 : fromBinMethods["assocNature"] = &SpectralWindowRow::assocNatureFromBin;
5813 0 : fromBinMethods["assocSpectralWindowId"] = &SpectralWindowRow::assocSpectralWindowIdFromBin;
5814 0 : fromBinMethods["imageSpectralWindowId"] = &SpectralWindowRow::imageSpectralWindowIdFromBin;
5815 0 : fromBinMethods["dopplerId"] = &SpectralWindowRow::dopplerIdFromBin;
5816 :
5817 0 : }
5818 :
5819 :
5820 1105 : bool SpectralWindowRow::compareNoAutoInc(BasebandNameMod::BasebandName basebandName, NetSidebandMod::NetSideband netSideband, int numChan, Frequency refFreq, SidebandProcessingModeMod::SidebandProcessingMode sidebandProcessingMode, Frequency totBandwidth, WindowFunctionMod::WindowFunction windowFunction) {
5821 : bool result;
5822 1105 : result = true;
5823 :
5824 :
5825 :
5826 1105 : result = result && (this->basebandName == basebandName);
5827 :
5828 1105 : if (!result) return false;
5829 :
5830 :
5831 :
5832 :
5833 457 : result = result && (this->netSideband == netSideband);
5834 :
5835 457 : if (!result) return false;
5836 :
5837 :
5838 :
5839 :
5840 457 : result = result && (this->numChan == numChan);
5841 :
5842 457 : if (!result) return false;
5843 :
5844 :
5845 :
5846 :
5847 316 : result = result && (this->refFreq == refFreq);
5848 :
5849 316 : if (!result) return false;
5850 :
5851 :
5852 :
5853 :
5854 0 : result = result && (this->sidebandProcessingMode == sidebandProcessingMode);
5855 :
5856 0 : if (!result) return false;
5857 :
5858 :
5859 :
5860 :
5861 0 : result = result && (this->totBandwidth == totBandwidth);
5862 :
5863 0 : if (!result) return false;
5864 :
5865 :
5866 :
5867 :
5868 0 : result = result && (this->windowFunction == windowFunction);
5869 :
5870 0 : if (!result) return false;
5871 :
5872 :
5873 0 : return result;
5874 : }
5875 :
5876 :
5877 :
5878 0 : bool SpectralWindowRow::compareRequiredValue(BasebandNameMod::BasebandName basebandName, NetSidebandMod::NetSideband netSideband, int numChan, Frequency refFreq, SidebandProcessingModeMod::SidebandProcessingMode sidebandProcessingMode, Frequency totBandwidth, WindowFunctionMod::WindowFunction windowFunction) {
5879 : bool result;
5880 0 : result = true;
5881 :
5882 :
5883 0 : if (!(this->basebandName == basebandName)) return false;
5884 :
5885 :
5886 :
5887 0 : if (!(this->netSideband == netSideband)) return false;
5888 :
5889 :
5890 :
5891 0 : if (!(this->numChan == numChan)) return false;
5892 :
5893 :
5894 :
5895 0 : if (!(this->refFreq == refFreq)) return false;
5896 :
5897 :
5898 :
5899 0 : if (!(this->sidebandProcessingMode == sidebandProcessingMode)) return false;
5900 :
5901 :
5902 :
5903 0 : if (!(this->totBandwidth == totBandwidth)) return false;
5904 :
5905 :
5906 :
5907 0 : if (!(this->windowFunction == windowFunction)) return false;
5908 :
5909 :
5910 0 : return result;
5911 : }
5912 :
5913 :
5914 : /**
5915 : * Return true if all required attributes of the value part are equal to their homologues
5916 : * in x and false otherwise.
5917 : *
5918 :
5919 : * @param x a pointer on the SpectralWindowRow whose required attributes of the value part
5920 :
5921 : * will be compared with those of this.
5922 : * @return a boolean.
5923 : */
5924 0 : bool SpectralWindowRow::equalByRequiredValue(SpectralWindowRow* x ) {
5925 :
5926 :
5927 0 : if (this->basebandName != x->basebandName) return false;
5928 :
5929 0 : if (this->netSideband != x->netSideband) return false;
5930 :
5931 0 : if (this->numChan != x->numChan) return false;
5932 :
5933 0 : if (this->refFreq != x->refFreq) return false;
5934 :
5935 0 : if (this->sidebandProcessingMode != x->sidebandProcessingMode) return false;
5936 :
5937 0 : if (this->totBandwidth != x->totBandwidth) return false;
5938 :
5939 0 : if (this->windowFunction != x->windowFunction) return false;
5940 :
5941 :
5942 0 : return true;
5943 : }
5944 :
5945 : /*
5946 : map<string, SpectralWindowAttributeFromBin> SpectralWindowRow::initFromBinMethods() {
5947 : map<string, SpectralWindowAttributeFromBin> result;
5948 :
5949 : result["spectralWindowId"] = &SpectralWindowRow::spectralWindowIdFromBin;
5950 : result["basebandName"] = &SpectralWindowRow::basebandNameFromBin;
5951 : result["netSideband"] = &SpectralWindowRow::netSidebandFromBin;
5952 : result["numChan"] = &SpectralWindowRow::numChanFromBin;
5953 : result["refFreq"] = &SpectralWindowRow::refFreqFromBin;
5954 : result["sidebandProcessingMode"] = &SpectralWindowRow::sidebandProcessingModeFromBin;
5955 : result["totBandwidth"] = &SpectralWindowRow::totBandwidthFromBin;
5956 : result["windowFunction"] = &SpectralWindowRow::windowFunctionFromBin;
5957 :
5958 :
5959 : result["numBin"] = &SpectralWindowRow::numBinFromBin;
5960 : result["chanFreqStart"] = &SpectralWindowRow::chanFreqStartFromBin;
5961 : result["chanFreqStep"] = &SpectralWindowRow::chanFreqStepFromBin;
5962 : result["chanFreqArray"] = &SpectralWindowRow::chanFreqArrayFromBin;
5963 : result["chanWidth"] = &SpectralWindowRow::chanWidthFromBin;
5964 : result["chanWidthArray"] = &SpectralWindowRow::chanWidthArrayFromBin;
5965 : result["correlationBit"] = &SpectralWindowRow::correlationBitFromBin;
5966 : result["effectiveBw"] = &SpectralWindowRow::effectiveBwFromBin;
5967 : result["effectiveBwArray"] = &SpectralWindowRow::effectiveBwArrayFromBin;
5968 : result["freqGroup"] = &SpectralWindowRow::freqGroupFromBin;
5969 : result["freqGroupName"] = &SpectralWindowRow::freqGroupNameFromBin;
5970 : result["lineArray"] = &SpectralWindowRow::lineArrayFromBin;
5971 : result["measFreqRef"] = &SpectralWindowRow::measFreqRefFromBin;
5972 : result["name"] = &SpectralWindowRow::nameFromBin;
5973 : result["oversampling"] = &SpectralWindowRow::oversamplingFromBin;
5974 : result["quantization"] = &SpectralWindowRow::quantizationFromBin;
5975 : result["refChan"] = &SpectralWindowRow::refChanFromBin;
5976 : result["resolution"] = &SpectralWindowRow::resolutionFromBin;
5977 : result["resolutionArray"] = &SpectralWindowRow::resolutionArrayFromBin;
5978 : result["numAssocValues"] = &SpectralWindowRow::numAssocValuesFromBin;
5979 : result["assocNature"] = &SpectralWindowRow::assocNatureFromBin;
5980 : result["assocSpectralWindowId"] = &SpectralWindowRow::assocSpectralWindowIdFromBin;
5981 : result["imageSpectralWindowId"] = &SpectralWindowRow::imageSpectralWindowIdFromBin;
5982 : result["dopplerId"] = &SpectralWindowRow::dopplerIdFromBin;
5983 :
5984 :
5985 : return result;
5986 : }
5987 : */
5988 : } // End namespace asdm
5989 :
|
