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 FreqOffsetRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/FreqOffsetRow.h>
39 : #include <alma/ASDM/FreqOffsetTable.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::FreqOffsetRow;
53 : using asdm::FreqOffsetTable;
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 0 : FreqOffsetRow::~FreqOffsetRow() {
76 0 : }
77 :
78 : /**
79 : * Return the table to which this row belongs.
80 : */
81 0 : FreqOffsetTable &FreqOffsetRow::getTable() const {
82 0 : return table;
83 : }
84 :
85 0 : bool FreqOffsetRow::isAdded() const {
86 0 : return hasBeenAdded;
87 : }
88 :
89 0 : void FreqOffsetRow::isAdded(bool added) {
90 0 : hasBeenAdded = added;
91 0 : }
92 :
93 : #ifndef WITHOUT_ACS
94 : using asdmIDL::FreqOffsetRowIDL;
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 FreqOffsetRowIDL struct.
101 : */
102 : FreqOffsetRowIDL *FreqOffsetRow::toIDL() const {
103 : FreqOffsetRowIDL *x = new FreqOffsetRowIDL ();
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 : x->offset = offset.toIDLFrequency();
124 :
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 :
135 :
136 :
137 : x->antennaId = antennaId.toIDLTag();
138 :
139 :
140 :
141 :
142 :
143 :
144 :
145 :
146 :
147 :
148 :
149 : x->feedId = feedId;
150 :
151 :
152 :
153 :
154 :
155 :
156 :
157 :
158 :
159 :
160 :
161 : x->spectralWindowId = spectralWindowId.toIDLTag();
162 :
163 :
164 :
165 :
166 :
167 :
168 :
169 :
170 :
171 :
172 :
173 :
174 :
175 : return x;
176 :
177 : }
178 :
179 : void FreqOffsetRow::toIDL(asdmIDL::FreqOffsetRowIDL& x) const {
180 : // Set the x's fields.
181 :
182 :
183 :
184 :
185 :
186 :
187 :
188 : x.timeInterval = timeInterval.toIDLArrayTimeInterval();
189 :
190 :
191 :
192 :
193 :
194 :
195 :
196 :
197 :
198 : x.offset = offset.toIDLFrequency();
199 :
200 :
201 :
202 :
203 :
204 :
205 :
206 :
207 :
208 :
209 :
210 :
211 :
212 : x.antennaId = antennaId.toIDLTag();
213 :
214 :
215 :
216 :
217 :
218 :
219 :
220 :
221 :
222 :
223 :
224 : x.feedId = feedId;
225 :
226 :
227 :
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 :
236 : x.spectralWindowId = spectralWindowId.toIDLTag();
237 :
238 :
239 :
240 :
241 :
242 :
243 :
244 :
245 :
246 :
247 :
248 :
249 :
250 : }
251 : #endif
252 :
253 :
254 : #ifndef WITHOUT_ACS
255 : /**
256 : * Fill the values of this row from the IDL struct FreqOffsetRowIDL.
257 : * @param x The IDL struct containing the values used to fill this row.
258 : */
259 : void FreqOffsetRow::setFromIDL (FreqOffsetRowIDL x){
260 : try {
261 : // Fill the values from x.
262 :
263 :
264 :
265 :
266 :
267 :
268 : setTimeInterval(ArrayTimeInterval (x.timeInterval));
269 :
270 :
271 :
272 :
273 :
274 :
275 :
276 :
277 :
278 : setOffset(Frequency (x.offset));
279 :
280 :
281 :
282 :
283 :
284 :
285 :
286 :
287 :
288 :
289 :
290 :
291 : setAntennaId(Tag (x.antennaId));
292 :
293 :
294 :
295 :
296 :
297 :
298 :
299 :
300 :
301 : setFeedId(x.feedId);
302 :
303 :
304 :
305 :
306 :
307 :
308 :
309 :
310 :
311 : setSpectralWindowId(Tag (x.spectralWindowId));
312 :
313 :
314 :
315 :
316 :
317 :
318 :
319 :
320 :
321 :
322 :
323 :
324 :
325 : } catch (const IllegalAccessException &err) {
326 : throw ConversionException (err.getMessage(),"FreqOffset");
327 : }
328 : }
329 : #endif
330 :
331 : /**
332 : * Return this row in the form of an XML string.
333 : * @return The values of this row as an XML string.
334 : */
335 0 : string FreqOffsetRow::toXML() const {
336 0 : string buf;
337 0 : buf.append("<row> \n");
338 :
339 :
340 :
341 :
342 :
343 :
344 0 : Parser::toXML(timeInterval, "timeInterval", buf);
345 :
346 :
347 :
348 :
349 :
350 :
351 :
352 0 : Parser::toXML(offset, "offset", buf);
353 :
354 :
355 :
356 :
357 :
358 :
359 :
360 :
361 :
362 :
363 0 : Parser::toXML(antennaId, "antennaId", buf);
364 :
365 :
366 :
367 :
368 :
369 :
370 :
371 0 : Parser::toXML(feedId, "feedId", buf);
372 :
373 :
374 :
375 :
376 :
377 :
378 :
379 0 : Parser::toXML(spectralWindowId, "spectralWindowId", buf);
380 :
381 :
382 :
383 :
384 :
385 :
386 :
387 :
388 :
389 :
390 :
391 :
392 :
393 0 : buf.append("</row>\n");
394 0 : return buf;
395 0 : }
396 :
397 : /**
398 : * Fill the values of this row from an XML string
399 : * that was produced by the toXML() method.
400 : * @param x The XML string being used to set the values of this row.
401 : */
402 0 : void FreqOffsetRow::setFromXML (string rowDoc) {
403 0 : Parser row(rowDoc);
404 0 : string s = "";
405 : try {
406 :
407 :
408 :
409 :
410 :
411 0 : setTimeInterval(Parser::getArrayTimeInterval("timeInterval","FreqOffset",rowDoc));
412 :
413 :
414 :
415 :
416 :
417 :
418 :
419 0 : setOffset(Parser::getFrequency("offset","FreqOffset",rowDoc));
420 :
421 :
422 :
423 :
424 :
425 :
426 :
427 :
428 :
429 :
430 0 : setAntennaId(Parser::getTag("antennaId","Antenna",rowDoc));
431 :
432 :
433 :
434 :
435 :
436 :
437 :
438 0 : setFeedId(Parser::getInteger("feedId","Feed",rowDoc));
439 :
440 :
441 :
442 :
443 :
444 :
445 :
446 0 : setSpectralWindowId(Parser::getTag("spectralWindowId","SpectralWindow",rowDoc));
447 :
448 :
449 :
450 :
451 :
452 :
453 :
454 :
455 :
456 :
457 :
458 :
459 0 : } catch (const IllegalAccessException &err) {
460 0 : throw ConversionException (err.getMessage(),"FreqOffset");
461 0 : }
462 0 : }
463 :
464 0 : void FreqOffsetRow::toBin(EndianOSStream& eoss) {
465 :
466 :
467 :
468 :
469 :
470 0 : antennaId.toBin(eoss);
471 :
472 :
473 :
474 :
475 :
476 :
477 0 : spectralWindowId.toBin(eoss);
478 :
479 :
480 :
481 :
482 :
483 :
484 0 : timeInterval.toBin(eoss);
485 :
486 :
487 :
488 :
489 :
490 :
491 :
492 0 : eoss.writeInt(feedId);
493 :
494 :
495 :
496 :
497 :
498 :
499 :
500 0 : offset.toBin(eoss);
501 :
502 :
503 :
504 :
505 :
506 :
507 0 : }
508 :
509 0 : void FreqOffsetRow::antennaIdFromBin(EndianIStream& eis) {
510 :
511 :
512 :
513 :
514 0 : antennaId = Tag::fromBin(eis);
515 :
516 :
517 :
518 0 : }
519 0 : void FreqOffsetRow::spectralWindowIdFromBin(EndianIStream& eis) {
520 :
521 :
522 :
523 :
524 0 : spectralWindowId = Tag::fromBin(eis);
525 :
526 :
527 :
528 0 : }
529 0 : void FreqOffsetRow::timeIntervalFromBin(EndianIStream& eis) {
530 :
531 :
532 :
533 :
534 0 : timeInterval = ArrayTimeInterval::fromBin(eis);
535 :
536 :
537 :
538 0 : }
539 0 : void FreqOffsetRow::feedIdFromBin(EndianIStream& eis) {
540 :
541 :
542 :
543 :
544 :
545 0 : feedId = eis.readInt();
546 :
547 :
548 :
549 :
550 0 : }
551 0 : void FreqOffsetRow::offsetFromBin(EndianIStream& eis) {
552 :
553 :
554 :
555 :
556 0 : offset = Frequency::fromBin(eis);
557 :
558 :
559 :
560 0 : }
561 :
562 :
563 :
564 0 : FreqOffsetRow* FreqOffsetRow::fromBin(EndianIStream& eis, FreqOffsetTable& table, const vector<string>& attributesSeq) {
565 0 : FreqOffsetRow* row = new FreqOffsetRow(table);
566 :
567 0 : map<string, FreqOffsetAttributeFromBin>::iterator iter ;
568 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
569 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
570 0 : if (iter != row->fromBinMethods.end()) {
571 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
572 : }
573 : else {
574 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
575 0 : if (functorP)
576 0 : (*functorP)(eis);
577 : else
578 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "FreqOffsetTable");
579 : }
580 :
581 : }
582 0 : return row;
583 : }
584 :
585 : //
586 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
587 : // of one row.
588 : //
589 :
590 : // Convert a string into an Tag
591 0 : void FreqOffsetRow::antennaIdFromText(const string & s) {
592 :
593 :
594 0 : antennaId = ASDMValuesParser::parse<Tag>(s);
595 :
596 :
597 0 : }
598 :
599 :
600 : // Convert a string into an Tag
601 0 : void FreqOffsetRow::spectralWindowIdFromText(const string & s) {
602 :
603 :
604 0 : spectralWindowId = ASDMValuesParser::parse<Tag>(s);
605 :
606 :
607 0 : }
608 :
609 :
610 : // Convert a string into an ArrayTimeInterval
611 0 : void FreqOffsetRow::timeIntervalFromText(const string & s) {
612 :
613 :
614 0 : timeInterval = ASDMValuesParser::parse<ArrayTimeInterval>(s);
615 :
616 :
617 0 : }
618 :
619 :
620 : // Convert a string into an int
621 0 : void FreqOffsetRow::feedIdFromText(const string & s) {
622 :
623 :
624 0 : feedId = ASDMValuesParser::parse<int>(s);
625 :
626 :
627 0 : }
628 :
629 :
630 : // Convert a string into an Frequency
631 0 : void FreqOffsetRow::offsetFromText(const string & s) {
632 :
633 :
634 0 : offset = ASDMValuesParser::parse<Frequency>(s);
635 :
636 :
637 0 : }
638 :
639 :
640 :
641 :
642 0 : void FreqOffsetRow::fromText(const std::string& attributeName, const std::string& t) {
643 0 : map<string, FreqOffsetAttributeFromText>::iterator iter;
644 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
645 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "FreqOffsetTable");
646 0 : (this->*(iter->second))(t);
647 0 : }
648 :
649 : ////////////////////////////////////////////////
650 : // Intrinsic Table Attributes getters/setters //
651 : ////////////////////////////////////////////////
652 :
653 :
654 :
655 :
656 : /**
657 : * Get timeInterval.
658 : * @return timeInterval as ArrayTimeInterval
659 : */
660 0 : ArrayTimeInterval FreqOffsetRow::getTimeInterval() const {
661 :
662 0 : return timeInterval;
663 : }
664 :
665 : /**
666 : * Set timeInterval with the specified ArrayTimeInterval.
667 : * @param timeInterval The ArrayTimeInterval value to which timeInterval is to be set.
668 :
669 :
670 :
671 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
672 :
673 : */
674 0 : void FreqOffsetRow::setTimeInterval (ArrayTimeInterval timeInterval) {
675 :
676 :
677 0 : if (hasBeenAdded) {
678 :
679 0 : throw IllegalAccessException("timeInterval", "FreqOffset");
680 :
681 : }
682 :
683 0 : this->timeInterval = timeInterval;
684 :
685 0 : }
686 :
687 :
688 :
689 :
690 :
691 :
692 : /**
693 : * Get offset.
694 : * @return offset as Frequency
695 : */
696 0 : Frequency FreqOffsetRow::getOffset() const {
697 :
698 0 : return offset;
699 : }
700 :
701 : /**
702 : * Set offset with the specified Frequency.
703 : * @param offset The Frequency value to which offset is to be set.
704 :
705 :
706 :
707 : */
708 0 : void FreqOffsetRow::setOffset (Frequency offset) {
709 :
710 :
711 0 : if (hasBeenAdded) {
712 :
713 : }
714 :
715 0 : this->offset = offset;
716 :
717 0 : }
718 :
719 :
720 :
721 :
722 : ///////////////////////////////////////////////
723 : // Extrinsic Table Attributes getters/setters//
724 : ///////////////////////////////////////////////
725 :
726 :
727 :
728 :
729 : /**
730 : * Get antennaId.
731 : * @return antennaId as Tag
732 : */
733 0 : Tag FreqOffsetRow::getAntennaId() const {
734 :
735 0 : return antennaId;
736 : }
737 :
738 : /**
739 : * Set antennaId with the specified Tag.
740 : * @param antennaId The Tag value to which antennaId is to be set.
741 :
742 :
743 :
744 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
745 :
746 : */
747 0 : void FreqOffsetRow::setAntennaId (Tag antennaId) {
748 :
749 :
750 0 : if (hasBeenAdded) {
751 :
752 0 : throw IllegalAccessException("antennaId", "FreqOffset");
753 :
754 : }
755 :
756 0 : this->antennaId = antennaId;
757 :
758 0 : }
759 :
760 :
761 :
762 :
763 :
764 :
765 : /**
766 : * Get feedId.
767 : * @return feedId as int
768 : */
769 0 : int FreqOffsetRow::getFeedId() const {
770 :
771 0 : return feedId;
772 : }
773 :
774 : /**
775 : * Set feedId with the specified int.
776 : * @param feedId The int value to which feedId is to be set.
777 :
778 :
779 :
780 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
781 :
782 : */
783 0 : void FreqOffsetRow::setFeedId (int feedId) {
784 :
785 :
786 0 : if (hasBeenAdded) {
787 :
788 0 : throw IllegalAccessException("feedId", "FreqOffset");
789 :
790 : }
791 :
792 0 : this->feedId = feedId;
793 :
794 0 : }
795 :
796 :
797 :
798 :
799 :
800 :
801 : /**
802 : * Get spectralWindowId.
803 : * @return spectralWindowId as Tag
804 : */
805 0 : Tag FreqOffsetRow::getSpectralWindowId() const {
806 :
807 0 : return spectralWindowId;
808 : }
809 :
810 : /**
811 : * Set spectralWindowId with the specified Tag.
812 : * @param spectralWindowId The Tag value to which spectralWindowId is to be set.
813 :
814 :
815 :
816 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
817 :
818 : */
819 0 : void FreqOffsetRow::setSpectralWindowId (Tag spectralWindowId) {
820 :
821 :
822 0 : if (hasBeenAdded) {
823 :
824 0 : throw IllegalAccessException("spectralWindowId", "FreqOffset");
825 :
826 : }
827 :
828 0 : this->spectralWindowId = spectralWindowId;
829 :
830 0 : }
831 :
832 :
833 :
834 :
835 : //////////////////////////////////////
836 : // Links Attributes getters/setters //
837 : //////////////////////////////////////
838 :
839 :
840 :
841 :
842 :
843 :
844 : /**
845 : * Returns the pointer to the row in the Antenna table having Antenna.antennaId == antennaId
846 : * @return a AntennaRow*
847 : *
848 :
849 : */
850 0 : AntennaRow* FreqOffsetRow::getAntennaUsingAntennaId() {
851 :
852 0 : return table.getContainer().getAntenna().getRowByKey(antennaId);
853 : }
854 :
855 :
856 :
857 :
858 :
859 :
860 :
861 :
862 :
863 : /**
864 : * Returns the pointer to the row in the SpectralWindow table having SpectralWindow.spectralWindowId == spectralWindowId
865 : * @return a SpectralWindowRow*
866 : *
867 :
868 : */
869 0 : SpectralWindowRow* FreqOffsetRow::getSpectralWindowUsingSpectralWindowId() {
870 :
871 0 : return table.getContainer().getSpectralWindow().getRowByKey(spectralWindowId);
872 : }
873 :
874 :
875 :
876 :
877 :
878 :
879 :
880 :
881 :
882 : // ===> Slice link from a row of FreqOffset table to a collection of row of Feed table.
883 :
884 : /**
885 : * Get the collection of row in the Feed table having their attribut feedId == this->feedId
886 : */
887 0 : vector <FeedRow *> FreqOffsetRow::getFeeds() {
888 :
889 0 : return table.getContainer().getFeed().getRowByFeedId(feedId);
890 :
891 : }
892 :
893 :
894 :
895 :
896 :
897 : /**
898 : * Create a FreqOffsetRow.
899 : * <p>
900 : * This constructor is private because only the
901 : * table can create rows. All rows know the table
902 : * to which they belong.
903 : * @param table The table to which this row belongs.
904 : */
905 0 : FreqOffsetRow::FreqOffsetRow (FreqOffsetTable &t) : table(t) {
906 0 : hasBeenAdded = false;
907 :
908 :
909 :
910 :
911 :
912 :
913 :
914 :
915 :
916 :
917 :
918 :
919 :
920 :
921 :
922 :
923 :
924 :
925 :
926 :
927 :
928 :
929 0 : fromBinMethods["antennaId"] = &FreqOffsetRow::antennaIdFromBin;
930 0 : fromBinMethods["spectralWindowId"] = &FreqOffsetRow::spectralWindowIdFromBin;
931 0 : fromBinMethods["timeInterval"] = &FreqOffsetRow::timeIntervalFromBin;
932 0 : fromBinMethods["feedId"] = &FreqOffsetRow::feedIdFromBin;
933 0 : fromBinMethods["offset"] = &FreqOffsetRow::offsetFromBin;
934 :
935 :
936 :
937 :
938 :
939 :
940 :
941 0 : fromTextMethods["antennaId"] = &FreqOffsetRow::antennaIdFromText;
942 :
943 :
944 :
945 0 : fromTextMethods["spectralWindowId"] = &FreqOffsetRow::spectralWindowIdFromText;
946 :
947 :
948 :
949 0 : fromTextMethods["timeInterval"] = &FreqOffsetRow::timeIntervalFromText;
950 :
951 :
952 :
953 0 : fromTextMethods["feedId"] = &FreqOffsetRow::feedIdFromText;
954 :
955 :
956 :
957 0 : fromTextMethods["offset"] = &FreqOffsetRow::offsetFromText;
958 :
959 :
960 :
961 :
962 0 : }
963 :
964 0 : FreqOffsetRow::FreqOffsetRow (FreqOffsetTable &t, FreqOffsetRow *row) : table(t) {
965 0 : hasBeenAdded = false;
966 :
967 0 : if (row == 0) {
968 :
969 :
970 :
971 :
972 :
973 :
974 :
975 :
976 :
977 :
978 :
979 :
980 :
981 : }
982 : else {
983 :
984 :
985 0 : antennaId = row->antennaId;
986 :
987 0 : spectralWindowId = row->spectralWindowId;
988 :
989 0 : timeInterval = row->timeInterval;
990 :
991 0 : feedId = row->feedId;
992 :
993 :
994 :
995 :
996 0 : offset = row->offset;
997 :
998 :
999 :
1000 :
1001 : }
1002 :
1003 0 : fromBinMethods["antennaId"] = &FreqOffsetRow::antennaIdFromBin;
1004 0 : fromBinMethods["spectralWindowId"] = &FreqOffsetRow::spectralWindowIdFromBin;
1005 0 : fromBinMethods["timeInterval"] = &FreqOffsetRow::timeIntervalFromBin;
1006 0 : fromBinMethods["feedId"] = &FreqOffsetRow::feedIdFromBin;
1007 0 : fromBinMethods["offset"] = &FreqOffsetRow::offsetFromBin;
1008 :
1009 :
1010 :
1011 0 : }
1012 :
1013 :
1014 0 : bool FreqOffsetRow::compareNoAutoInc(Tag antennaId, Tag spectralWindowId, ArrayTimeInterval timeInterval, int feedId, Frequency offset) {
1015 : bool result;
1016 0 : result = true;
1017 :
1018 :
1019 :
1020 0 : result = result && (this->antennaId == antennaId);
1021 :
1022 0 : if (!result) return false;
1023 :
1024 :
1025 :
1026 :
1027 0 : result = result && (this->spectralWindowId == spectralWindowId);
1028 :
1029 0 : if (!result) return false;
1030 :
1031 :
1032 :
1033 :
1034 0 : result = result && (this->timeInterval.overlaps(timeInterval));
1035 :
1036 0 : if (!result) return false;
1037 :
1038 :
1039 :
1040 :
1041 0 : result = result && (this->feedId == feedId);
1042 :
1043 0 : if (!result) return false;
1044 :
1045 :
1046 :
1047 :
1048 0 : result = result && (this->offset == offset);
1049 :
1050 0 : if (!result) return false;
1051 :
1052 :
1053 0 : return result;
1054 : }
1055 :
1056 :
1057 :
1058 0 : bool FreqOffsetRow::compareRequiredValue(Frequency offset) {
1059 : bool result;
1060 0 : result = true;
1061 :
1062 :
1063 0 : if (!(this->offset == offset)) return false;
1064 :
1065 :
1066 0 : return result;
1067 : }
1068 :
1069 :
1070 : /**
1071 : * Return true if all required attributes of the value part are equal to their homologues
1072 : * in x and false otherwise.
1073 : *
1074 :
1075 : * @param x a pointer on the FreqOffsetRow whose required attributes of the value part
1076 :
1077 : * will be compared with those of this.
1078 : * @return a boolean.
1079 : */
1080 0 : bool FreqOffsetRow::equalByRequiredValue(FreqOffsetRow* x ) {
1081 :
1082 :
1083 0 : if (this->offset != x->offset) return false;
1084 :
1085 :
1086 0 : return true;
1087 : }
1088 :
1089 : /*
1090 : map<string, FreqOffsetAttributeFromBin> FreqOffsetRow::initFromBinMethods() {
1091 : map<string, FreqOffsetAttributeFromBin> result;
1092 :
1093 : result["antennaId"] = &FreqOffsetRow::antennaIdFromBin;
1094 : result["spectralWindowId"] = &FreqOffsetRow::spectralWindowIdFromBin;
1095 : result["timeInterval"] = &FreqOffsetRow::timeIntervalFromBin;
1096 : result["feedId"] = &FreqOffsetRow::feedIdFromBin;
1097 : result["offset"] = &FreqOffsetRow::offsetFromBin;
1098 :
1099 :
1100 :
1101 :
1102 : return result;
1103 : }
1104 : */
1105 : } // End namespace asdm
1106 :
|
