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