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