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