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 PulsarRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/PulsarRow.h>
39 : #include <alma/ASDM/PulsarTable.h>
40 :
41 :
42 : using asdm::ASDM;
43 : using asdm::PulsarRow;
44 : using asdm::PulsarTable;
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 : PulsarRow::~PulsarRow() {
58 0 : }
59 :
60 : /**
61 : * Return the table to which this row belongs.
62 : */
63 0 : PulsarTable &PulsarRow::getTable() const {
64 0 : return table;
65 : }
66 :
67 0 : bool PulsarRow::isAdded() const {
68 0 : return hasBeenAdded;
69 : }
70 :
71 0 : void PulsarRow::isAdded(bool added) {
72 0 : hasBeenAdded = added;
73 0 : }
74 :
75 : #ifndef WITHOUT_ACS
76 : using asdmIDL::PulsarRowIDL;
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 PulsarRowIDL struct.
83 : */
84 : PulsarRowIDL *PulsarRow::toIDL() const {
85 : PulsarRowIDL *x = new PulsarRowIDL ();
86 :
87 : // Fill the IDL structure.
88 :
89 :
90 :
91 :
92 :
93 :
94 :
95 : x->pulsarId = pulsarId.toIDLTag();
96 :
97 :
98 :
99 :
100 :
101 :
102 :
103 :
104 :
105 : x->refTime = refTime.toIDLArrayTime();
106 :
107 :
108 :
109 :
110 :
111 :
112 :
113 :
114 :
115 : x->refPulseFreq = refPulseFreq.toIDLFrequency();
116 :
117 :
118 :
119 :
120 :
121 :
122 :
123 :
124 :
125 :
126 : x->refPhase = refPhase;
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 :
135 :
136 :
137 :
138 : x->numBin = numBin;
139 :
140 :
141 :
142 :
143 :
144 :
145 :
146 :
147 : x->numPolyExists = numPolyExists;
148 :
149 :
150 :
151 :
152 : x->numPoly = numPoly;
153 :
154 :
155 :
156 :
157 :
158 :
159 :
160 :
161 : x->phasePolyExists = phasePolyExists;
162 :
163 :
164 :
165 : x->phasePoly.length(phasePoly.size());
166 : for (unsigned int i = 0; i < phasePoly.size(); ++i) {
167 :
168 :
169 : x->phasePoly[i] = phasePoly.at(i);
170 :
171 :
172 : }
173 :
174 :
175 :
176 :
177 :
178 :
179 :
180 : x->timeSpanExists = timeSpanExists;
181 :
182 :
183 :
184 : x->timeSpan = timeSpan.toIDLInterval();
185 :
186 :
187 :
188 :
189 :
190 :
191 :
192 : x->startPhaseBinExists = startPhaseBinExists;
193 :
194 :
195 :
196 : x->startPhaseBin.length(startPhaseBin.size());
197 : for (unsigned int i = 0; i < startPhaseBin.size(); ++i) {
198 :
199 :
200 : x->startPhaseBin[i] = startPhaseBin.at(i);
201 :
202 :
203 : }
204 :
205 :
206 :
207 :
208 :
209 :
210 :
211 : x->endPhaseBinExists = endPhaseBinExists;
212 :
213 :
214 :
215 : x->endPhaseBin.length(endPhaseBin.size());
216 : for (unsigned int i = 0; i < endPhaseBin.size(); ++i) {
217 :
218 :
219 : x->endPhaseBin[i] = endPhaseBin.at(i);
220 :
221 :
222 : }
223 :
224 :
225 :
226 :
227 :
228 :
229 :
230 : x->dispersionMeasureExists = dispersionMeasureExists;
231 :
232 :
233 :
234 :
235 : x->dispersionMeasure = dispersionMeasure;
236 :
237 :
238 :
239 :
240 :
241 :
242 :
243 :
244 : x->refFrequencyExists = refFrequencyExists;
245 :
246 :
247 :
248 : x->refFrequency = refFrequency.toIDLFrequency();
249 :
250 :
251 :
252 :
253 :
254 :
255 :
256 :
257 : return x;
258 :
259 : }
260 :
261 : void PulsarRow::toIDL(asdmIDL::PulsarRowIDL& x) const {
262 : // Set the x's fields.
263 :
264 :
265 :
266 :
267 :
268 :
269 :
270 : x.pulsarId = pulsarId.toIDLTag();
271 :
272 :
273 :
274 :
275 :
276 :
277 :
278 :
279 :
280 : x.refTime = refTime.toIDLArrayTime();
281 :
282 :
283 :
284 :
285 :
286 :
287 :
288 :
289 :
290 : x.refPulseFreq = refPulseFreq.toIDLFrequency();
291 :
292 :
293 :
294 :
295 :
296 :
297 :
298 :
299 :
300 :
301 : x.refPhase = refPhase;
302 :
303 :
304 :
305 :
306 :
307 :
308 :
309 :
310 :
311 :
312 :
313 : x.numBin = numBin;
314 :
315 :
316 :
317 :
318 :
319 :
320 :
321 :
322 : x.numPolyExists = numPolyExists;
323 :
324 :
325 :
326 :
327 : x.numPoly = numPoly;
328 :
329 :
330 :
331 :
332 :
333 :
334 :
335 :
336 : x.phasePolyExists = phasePolyExists;
337 :
338 :
339 :
340 : x.phasePoly.length(phasePoly.size());
341 : for (unsigned int i = 0; i < phasePoly.size(); ++i) {
342 :
343 :
344 : x.phasePoly[i] = phasePoly.at(i);
345 :
346 :
347 : }
348 :
349 :
350 :
351 :
352 :
353 :
354 :
355 : x.timeSpanExists = timeSpanExists;
356 :
357 :
358 :
359 : x.timeSpan = timeSpan.toIDLInterval();
360 :
361 :
362 :
363 :
364 :
365 :
366 :
367 : x.startPhaseBinExists = startPhaseBinExists;
368 :
369 :
370 :
371 : x.startPhaseBin.length(startPhaseBin.size());
372 : for (unsigned int i = 0; i < startPhaseBin.size(); ++i) {
373 :
374 :
375 : x.startPhaseBin[i] = startPhaseBin.at(i);
376 :
377 :
378 : }
379 :
380 :
381 :
382 :
383 :
384 :
385 :
386 : x.endPhaseBinExists = endPhaseBinExists;
387 :
388 :
389 :
390 : x.endPhaseBin.length(endPhaseBin.size());
391 : for (unsigned int i = 0; i < endPhaseBin.size(); ++i) {
392 :
393 :
394 : x.endPhaseBin[i] = endPhaseBin.at(i);
395 :
396 :
397 : }
398 :
399 :
400 :
401 :
402 :
403 :
404 :
405 : x.dispersionMeasureExists = dispersionMeasureExists;
406 :
407 :
408 :
409 :
410 : x.dispersionMeasure = dispersionMeasure;
411 :
412 :
413 :
414 :
415 :
416 :
417 :
418 :
419 : x.refFrequencyExists = refFrequencyExists;
420 :
421 :
422 :
423 : x.refFrequency = refFrequency.toIDLFrequency();
424 :
425 :
426 :
427 :
428 :
429 :
430 :
431 :
432 : }
433 : #endif
434 :
435 :
436 : #ifndef WITHOUT_ACS
437 : /**
438 : * Fill the values of this row from the IDL struct PulsarRowIDL.
439 : * @param x The IDL struct containing the values used to fill this row.
440 : */
441 : void PulsarRow::setFromIDL (PulsarRowIDL x){
442 : try {
443 : // Fill the values from x.
444 :
445 :
446 :
447 :
448 :
449 :
450 : setPulsarId(Tag (x.pulsarId));
451 :
452 :
453 :
454 :
455 :
456 :
457 :
458 :
459 :
460 : setRefTime(ArrayTime (x.refTime));
461 :
462 :
463 :
464 :
465 :
466 :
467 :
468 :
469 :
470 : setRefPulseFreq(Frequency (x.refPulseFreq));
471 :
472 :
473 :
474 :
475 :
476 :
477 :
478 :
479 :
480 : setRefPhase(x.refPhase);
481 :
482 :
483 :
484 :
485 :
486 :
487 :
488 :
489 :
490 : setNumBin(x.numBin);
491 :
492 :
493 :
494 :
495 :
496 :
497 :
498 : numPolyExists = x.numPolyExists;
499 : if (x.numPolyExists) {
500 :
501 :
502 :
503 : setNumPoly(x.numPoly);
504 :
505 :
506 :
507 : }
508 :
509 :
510 :
511 :
512 :
513 : phasePolyExists = x.phasePolyExists;
514 : if (x.phasePolyExists) {
515 :
516 :
517 :
518 : phasePoly .clear();
519 : for (unsigned int i = 0; i <x.phasePoly.length(); ++i) {
520 :
521 : phasePoly.push_back(x.phasePoly[i]);
522 :
523 : }
524 :
525 :
526 :
527 : }
528 :
529 :
530 :
531 :
532 :
533 : timeSpanExists = x.timeSpanExists;
534 : if (x.timeSpanExists) {
535 :
536 :
537 :
538 : setTimeSpan(Interval (x.timeSpan));
539 :
540 :
541 :
542 : }
543 :
544 :
545 :
546 :
547 :
548 : startPhaseBinExists = x.startPhaseBinExists;
549 : if (x.startPhaseBinExists) {
550 :
551 :
552 :
553 : startPhaseBin .clear();
554 : for (unsigned int i = 0; i <x.startPhaseBin.length(); ++i) {
555 :
556 : startPhaseBin.push_back(x.startPhaseBin[i]);
557 :
558 : }
559 :
560 :
561 :
562 : }
563 :
564 :
565 :
566 :
567 :
568 : endPhaseBinExists = x.endPhaseBinExists;
569 : if (x.endPhaseBinExists) {
570 :
571 :
572 :
573 : endPhaseBin .clear();
574 : for (unsigned int i = 0; i <x.endPhaseBin.length(); ++i) {
575 :
576 : endPhaseBin.push_back(x.endPhaseBin[i]);
577 :
578 : }
579 :
580 :
581 :
582 : }
583 :
584 :
585 :
586 :
587 :
588 : dispersionMeasureExists = x.dispersionMeasureExists;
589 : if (x.dispersionMeasureExists) {
590 :
591 :
592 :
593 : setDispersionMeasure(x.dispersionMeasure);
594 :
595 :
596 :
597 : }
598 :
599 :
600 :
601 :
602 :
603 : refFrequencyExists = x.refFrequencyExists;
604 : if (x.refFrequencyExists) {
605 :
606 :
607 :
608 : setRefFrequency(Frequency (x.refFrequency));
609 :
610 :
611 :
612 : }
613 :
614 :
615 :
616 :
617 :
618 :
619 : } catch (const IllegalAccessException &err) {
620 : throw ConversionException (err.getMessage(),"Pulsar");
621 : }
622 : }
623 : #endif
624 :
625 : /**
626 : * Return this row in the form of an XML string.
627 : * @return The values of this row as an XML string.
628 : */
629 0 : string PulsarRow::toXML() const {
630 0 : string buf;
631 0 : buf.append("<row> \n");
632 :
633 :
634 :
635 :
636 :
637 :
638 0 : Parser::toXML(pulsarId, "pulsarId", buf);
639 :
640 :
641 :
642 :
643 :
644 :
645 :
646 0 : Parser::toXML(refTime, "refTime", buf);
647 :
648 :
649 :
650 :
651 :
652 :
653 :
654 0 : Parser::toXML(refPulseFreq, "refPulseFreq", buf);
655 :
656 :
657 :
658 :
659 :
660 :
661 :
662 0 : Parser::toXML(refPhase, "refPhase", buf);
663 :
664 :
665 :
666 :
667 :
668 :
669 :
670 0 : Parser::toXML(numBin, "numBin", buf);
671 :
672 :
673 :
674 :
675 :
676 :
677 0 : if (numPolyExists) {
678 :
679 :
680 0 : Parser::toXML(numPoly, "numPoly", buf);
681 :
682 :
683 : }
684 :
685 :
686 :
687 :
688 :
689 0 : if (phasePolyExists) {
690 :
691 :
692 0 : Parser::toXML(phasePoly, "phasePoly", buf);
693 :
694 :
695 : }
696 :
697 :
698 :
699 :
700 :
701 0 : if (timeSpanExists) {
702 :
703 :
704 0 : Parser::toXML(timeSpan, "timeSpan", buf);
705 :
706 :
707 : }
708 :
709 :
710 :
711 :
712 :
713 0 : if (startPhaseBinExists) {
714 :
715 :
716 0 : Parser::toXML(startPhaseBin, "startPhaseBin", buf);
717 :
718 :
719 : }
720 :
721 :
722 :
723 :
724 :
725 0 : if (endPhaseBinExists) {
726 :
727 :
728 0 : Parser::toXML(endPhaseBin, "endPhaseBin", buf);
729 :
730 :
731 : }
732 :
733 :
734 :
735 :
736 :
737 0 : if (dispersionMeasureExists) {
738 :
739 :
740 0 : Parser::toXML(dispersionMeasure, "dispersionMeasure", buf);
741 :
742 :
743 : }
744 :
745 :
746 :
747 :
748 :
749 0 : if (refFrequencyExists) {
750 :
751 :
752 0 : Parser::toXML(refFrequency, "refFrequency", buf);
753 :
754 :
755 : }
756 :
757 :
758 :
759 :
760 :
761 :
762 :
763 0 : buf.append("</row>\n");
764 0 : return buf;
765 0 : }
766 :
767 : /**
768 : * Fill the values of this row from an XML string
769 : * that was produced by the toXML() method.
770 : * @param x The XML string being used to set the values of this row.
771 : */
772 0 : void PulsarRow::setFromXML (string rowDoc) {
773 0 : Parser row(rowDoc);
774 0 : string s = "";
775 : try {
776 :
777 :
778 :
779 :
780 :
781 0 : setPulsarId(Parser::getTag("pulsarId","Pulsar",rowDoc));
782 :
783 :
784 :
785 :
786 :
787 :
788 :
789 0 : setRefTime(Parser::getArrayTime("refTime","Pulsar",rowDoc));
790 :
791 :
792 :
793 :
794 :
795 :
796 :
797 0 : setRefPulseFreq(Parser::getFrequency("refPulseFreq","Pulsar",rowDoc));
798 :
799 :
800 :
801 :
802 :
803 :
804 :
805 0 : setRefPhase(Parser::getDouble("refPhase","Pulsar",rowDoc));
806 :
807 :
808 :
809 :
810 :
811 :
812 :
813 0 : setNumBin(Parser::getInteger("numBin","Pulsar",rowDoc));
814 :
815 :
816 :
817 :
818 :
819 :
820 0 : if (row.isStr("<numPoly>")) {
821 :
822 0 : setNumPoly(Parser::getInteger("numPoly","Pulsar",rowDoc));
823 :
824 : }
825 :
826 :
827 :
828 :
829 :
830 0 : if (row.isStr("<phasePoly>")) {
831 :
832 :
833 0 : setPhasePoly(Parser::get1DDouble("phasePoly","Pulsar",rowDoc));
834 :
835 :
836 : }
837 :
838 :
839 :
840 :
841 :
842 0 : if (row.isStr("<timeSpan>")) {
843 :
844 0 : setTimeSpan(Parser::getInterval("timeSpan","Pulsar",rowDoc));
845 :
846 : }
847 :
848 :
849 :
850 :
851 :
852 0 : if (row.isStr("<startPhaseBin>")) {
853 :
854 :
855 0 : setStartPhaseBin(Parser::get1DFloat("startPhaseBin","Pulsar",rowDoc));
856 :
857 :
858 : }
859 :
860 :
861 :
862 :
863 :
864 0 : if (row.isStr("<endPhaseBin>")) {
865 :
866 :
867 0 : setEndPhaseBin(Parser::get1DFloat("endPhaseBin","Pulsar",rowDoc));
868 :
869 :
870 : }
871 :
872 :
873 :
874 :
875 :
876 0 : if (row.isStr("<dispersionMeasure>")) {
877 :
878 0 : setDispersionMeasure(Parser::getDouble("dispersionMeasure","Pulsar",rowDoc));
879 :
880 : }
881 :
882 :
883 :
884 :
885 :
886 0 : if (row.isStr("<refFrequency>")) {
887 :
888 0 : setRefFrequency(Parser::getFrequency("refFrequency","Pulsar",rowDoc));
889 :
890 : }
891 :
892 :
893 :
894 :
895 :
896 :
897 0 : } catch (const IllegalAccessException &err) {
898 0 : throw ConversionException (err.getMessage(),"Pulsar");
899 0 : }
900 0 : }
901 :
902 0 : void PulsarRow::toBin(EndianOSStream& eoss) {
903 :
904 :
905 :
906 :
907 :
908 0 : pulsarId.toBin(eoss);
909 :
910 :
911 :
912 :
913 :
914 :
915 0 : refTime.toBin(eoss);
916 :
917 :
918 :
919 :
920 :
921 :
922 0 : refPulseFreq.toBin(eoss);
923 :
924 :
925 :
926 :
927 :
928 :
929 :
930 0 : eoss.writeDouble(refPhase);
931 :
932 :
933 :
934 :
935 :
936 :
937 :
938 :
939 0 : eoss.writeInt(numBin);
940 :
941 :
942 :
943 :
944 :
945 :
946 :
947 0 : eoss.writeBoolean(numPolyExists);
948 0 : if (numPolyExists) {
949 :
950 :
951 :
952 :
953 :
954 0 : eoss.writeInt(numPoly);
955 :
956 :
957 :
958 :
959 : }
960 :
961 0 : eoss.writeBoolean(phasePolyExists);
962 0 : if (phasePolyExists) {
963 :
964 :
965 :
966 :
967 :
968 :
969 0 : eoss.writeInt((int) phasePoly.size());
970 0 : for (unsigned int i = 0; i < phasePoly.size(); i++)
971 :
972 0 : eoss.writeDouble(phasePoly.at(i));
973 :
974 :
975 :
976 :
977 :
978 :
979 : }
980 :
981 0 : eoss.writeBoolean(timeSpanExists);
982 0 : if (timeSpanExists) {
983 :
984 :
985 :
986 :
987 0 : timeSpan.toBin(eoss);
988 :
989 :
990 :
991 : }
992 :
993 0 : eoss.writeBoolean(startPhaseBinExists);
994 0 : if (startPhaseBinExists) {
995 :
996 :
997 :
998 :
999 :
1000 :
1001 0 : eoss.writeInt((int) startPhaseBin.size());
1002 0 : for (unsigned int i = 0; i < startPhaseBin.size(); i++)
1003 :
1004 0 : eoss.writeFloat(startPhaseBin.at(i));
1005 :
1006 :
1007 :
1008 :
1009 :
1010 :
1011 : }
1012 :
1013 0 : eoss.writeBoolean(endPhaseBinExists);
1014 0 : if (endPhaseBinExists) {
1015 :
1016 :
1017 :
1018 :
1019 :
1020 :
1021 0 : eoss.writeInt((int) endPhaseBin.size());
1022 0 : for (unsigned int i = 0; i < endPhaseBin.size(); i++)
1023 :
1024 0 : eoss.writeFloat(endPhaseBin.at(i));
1025 :
1026 :
1027 :
1028 :
1029 :
1030 :
1031 : }
1032 :
1033 0 : eoss.writeBoolean(dispersionMeasureExists);
1034 0 : if (dispersionMeasureExists) {
1035 :
1036 :
1037 :
1038 :
1039 :
1040 0 : eoss.writeDouble(dispersionMeasure);
1041 :
1042 :
1043 :
1044 :
1045 : }
1046 :
1047 0 : eoss.writeBoolean(refFrequencyExists);
1048 0 : if (refFrequencyExists) {
1049 :
1050 :
1051 :
1052 :
1053 0 : refFrequency.toBin(eoss);
1054 :
1055 :
1056 :
1057 : }
1058 :
1059 0 : }
1060 :
1061 0 : void PulsarRow::pulsarIdFromBin(EndianIStream& eis) {
1062 :
1063 :
1064 :
1065 :
1066 0 : pulsarId = Tag::fromBin(eis);
1067 :
1068 :
1069 :
1070 0 : }
1071 0 : void PulsarRow::refTimeFromBin(EndianIStream& eis) {
1072 :
1073 :
1074 :
1075 :
1076 0 : refTime = ArrayTime::fromBin(eis);
1077 :
1078 :
1079 :
1080 0 : }
1081 0 : void PulsarRow::refPulseFreqFromBin(EndianIStream& eis) {
1082 :
1083 :
1084 :
1085 :
1086 0 : refPulseFreq = Frequency::fromBin(eis);
1087 :
1088 :
1089 :
1090 0 : }
1091 0 : void PulsarRow::refPhaseFromBin(EndianIStream& eis) {
1092 :
1093 :
1094 :
1095 :
1096 :
1097 0 : refPhase = eis.readDouble();
1098 :
1099 :
1100 :
1101 :
1102 0 : }
1103 0 : void PulsarRow::numBinFromBin(EndianIStream& eis) {
1104 :
1105 :
1106 :
1107 :
1108 :
1109 0 : numBin = eis.readInt();
1110 :
1111 :
1112 :
1113 :
1114 0 : }
1115 :
1116 0 : void PulsarRow::numPolyFromBin(EndianIStream& eis) {
1117 :
1118 0 : numPolyExists = eis.readBoolean();
1119 0 : if (numPolyExists) {
1120 :
1121 :
1122 :
1123 :
1124 :
1125 0 : numPoly = eis.readInt();
1126 :
1127 :
1128 :
1129 :
1130 : }
1131 :
1132 0 : }
1133 0 : void PulsarRow::phasePolyFromBin(EndianIStream& eis) {
1134 :
1135 0 : phasePolyExists = eis.readBoolean();
1136 0 : if (phasePolyExists) {
1137 :
1138 :
1139 :
1140 :
1141 :
1142 :
1143 0 : phasePoly.clear();
1144 :
1145 0 : unsigned int phasePolyDim1 = eis.readInt();
1146 0 : for (unsigned int i = 0 ; i < phasePolyDim1; i++)
1147 :
1148 0 : phasePoly.push_back(eis.readDouble());
1149 :
1150 :
1151 :
1152 :
1153 :
1154 :
1155 : }
1156 :
1157 0 : }
1158 0 : void PulsarRow::timeSpanFromBin(EndianIStream& eis) {
1159 :
1160 0 : timeSpanExists = eis.readBoolean();
1161 0 : if (timeSpanExists) {
1162 :
1163 :
1164 :
1165 :
1166 0 : timeSpan = Interval::fromBin(eis);
1167 :
1168 :
1169 :
1170 : }
1171 :
1172 0 : }
1173 0 : void PulsarRow::startPhaseBinFromBin(EndianIStream& eis) {
1174 :
1175 0 : startPhaseBinExists = eis.readBoolean();
1176 0 : if (startPhaseBinExists) {
1177 :
1178 :
1179 :
1180 :
1181 :
1182 :
1183 0 : startPhaseBin.clear();
1184 :
1185 0 : unsigned int startPhaseBinDim1 = eis.readInt();
1186 0 : for (unsigned int i = 0 ; i < startPhaseBinDim1; i++)
1187 :
1188 0 : startPhaseBin.push_back(eis.readFloat());
1189 :
1190 :
1191 :
1192 :
1193 :
1194 :
1195 : }
1196 :
1197 0 : }
1198 0 : void PulsarRow::endPhaseBinFromBin(EndianIStream& eis) {
1199 :
1200 0 : endPhaseBinExists = eis.readBoolean();
1201 0 : if (endPhaseBinExists) {
1202 :
1203 :
1204 :
1205 :
1206 :
1207 :
1208 0 : endPhaseBin.clear();
1209 :
1210 0 : unsigned int endPhaseBinDim1 = eis.readInt();
1211 0 : for (unsigned int i = 0 ; i < endPhaseBinDim1; i++)
1212 :
1213 0 : endPhaseBin.push_back(eis.readFloat());
1214 :
1215 :
1216 :
1217 :
1218 :
1219 :
1220 : }
1221 :
1222 0 : }
1223 0 : void PulsarRow::dispersionMeasureFromBin(EndianIStream& eis) {
1224 :
1225 0 : dispersionMeasureExists = eis.readBoolean();
1226 0 : if (dispersionMeasureExists) {
1227 :
1228 :
1229 :
1230 :
1231 :
1232 0 : dispersionMeasure = eis.readDouble();
1233 :
1234 :
1235 :
1236 :
1237 : }
1238 :
1239 0 : }
1240 0 : void PulsarRow::refFrequencyFromBin(EndianIStream& eis) {
1241 :
1242 0 : refFrequencyExists = eis.readBoolean();
1243 0 : if (refFrequencyExists) {
1244 :
1245 :
1246 :
1247 :
1248 0 : refFrequency = Frequency::fromBin(eis);
1249 :
1250 :
1251 :
1252 : }
1253 :
1254 0 : }
1255 :
1256 :
1257 0 : PulsarRow* PulsarRow::fromBin(EndianIStream& eis, PulsarTable& table, const vector<string>& attributesSeq) {
1258 0 : PulsarRow* row = new PulsarRow(table);
1259 :
1260 0 : map<string, PulsarAttributeFromBin>::iterator iter ;
1261 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
1262 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
1263 0 : if (iter != row->fromBinMethods.end()) {
1264 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
1265 : }
1266 : else {
1267 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
1268 0 : if (functorP)
1269 0 : (*functorP)(eis);
1270 : else
1271 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "PulsarTable");
1272 : }
1273 :
1274 : }
1275 0 : return row;
1276 : }
1277 :
1278 : //
1279 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
1280 : // of one row.
1281 : //
1282 :
1283 : // Convert a string into an Tag
1284 0 : void PulsarRow::pulsarIdFromText(const string & s) {
1285 :
1286 :
1287 0 : pulsarId = ASDMValuesParser::parse<Tag>(s);
1288 :
1289 :
1290 0 : }
1291 :
1292 :
1293 : // Convert a string into an ArrayTime
1294 0 : void PulsarRow::refTimeFromText(const string & s) {
1295 :
1296 :
1297 0 : refTime = ASDMValuesParser::parse<ArrayTime>(s);
1298 :
1299 :
1300 0 : }
1301 :
1302 :
1303 : // Convert a string into an Frequency
1304 0 : void PulsarRow::refPulseFreqFromText(const string & s) {
1305 :
1306 :
1307 0 : refPulseFreq = ASDMValuesParser::parse<Frequency>(s);
1308 :
1309 :
1310 0 : }
1311 :
1312 :
1313 : // Convert a string into an double
1314 0 : void PulsarRow::refPhaseFromText(const string & s) {
1315 :
1316 :
1317 0 : refPhase = ASDMValuesParser::parse<double>(s);
1318 :
1319 :
1320 0 : }
1321 :
1322 :
1323 : // Convert a string into an int
1324 0 : void PulsarRow::numBinFromText(const string & s) {
1325 :
1326 :
1327 0 : numBin = ASDMValuesParser::parse<int>(s);
1328 :
1329 :
1330 0 : }
1331 :
1332 :
1333 :
1334 : // Convert a string into an int
1335 0 : void PulsarRow::numPolyFromText(const string & s) {
1336 0 : numPolyExists = true;
1337 :
1338 :
1339 0 : numPoly = ASDMValuesParser::parse<int>(s);
1340 :
1341 :
1342 0 : }
1343 :
1344 :
1345 : // Convert a string into an double
1346 0 : void PulsarRow::phasePolyFromText(const string & s) {
1347 0 : phasePolyExists = true;
1348 :
1349 :
1350 0 : phasePoly = ASDMValuesParser::parse1D<double>(s);
1351 :
1352 :
1353 0 : }
1354 :
1355 :
1356 : // Convert a string into an Interval
1357 0 : void PulsarRow::timeSpanFromText(const string & s) {
1358 0 : timeSpanExists = true;
1359 :
1360 :
1361 0 : timeSpan = ASDMValuesParser::parse<Interval>(s);
1362 :
1363 :
1364 0 : }
1365 :
1366 :
1367 : // Convert a string into an float
1368 0 : void PulsarRow::startPhaseBinFromText(const string & s) {
1369 0 : startPhaseBinExists = true;
1370 :
1371 :
1372 0 : startPhaseBin = ASDMValuesParser::parse1D<float>(s);
1373 :
1374 :
1375 0 : }
1376 :
1377 :
1378 : // Convert a string into an float
1379 0 : void PulsarRow::endPhaseBinFromText(const string & s) {
1380 0 : endPhaseBinExists = true;
1381 :
1382 :
1383 0 : endPhaseBin = ASDMValuesParser::parse1D<float>(s);
1384 :
1385 :
1386 0 : }
1387 :
1388 :
1389 : // Convert a string into an double
1390 0 : void PulsarRow::dispersionMeasureFromText(const string & s) {
1391 0 : dispersionMeasureExists = true;
1392 :
1393 :
1394 0 : dispersionMeasure = ASDMValuesParser::parse<double>(s);
1395 :
1396 :
1397 0 : }
1398 :
1399 :
1400 : // Convert a string into an Frequency
1401 0 : void PulsarRow::refFrequencyFromText(const string & s) {
1402 0 : refFrequencyExists = true;
1403 :
1404 :
1405 0 : refFrequency = ASDMValuesParser::parse<Frequency>(s);
1406 :
1407 :
1408 0 : }
1409 :
1410 :
1411 :
1412 0 : void PulsarRow::fromText(const std::string& attributeName, const std::string& t) {
1413 0 : map<string, PulsarAttributeFromText>::iterator iter;
1414 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
1415 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "PulsarTable");
1416 0 : (this->*(iter->second))(t);
1417 0 : }
1418 :
1419 : ////////////////////////////////////////////////
1420 : // Intrinsic Table Attributes getters/setters //
1421 : ////////////////////////////////////////////////
1422 :
1423 :
1424 :
1425 :
1426 : /**
1427 : * Get pulsarId.
1428 : * @return pulsarId as Tag
1429 : */
1430 0 : Tag PulsarRow::getPulsarId() const {
1431 :
1432 0 : return pulsarId;
1433 : }
1434 :
1435 : /**
1436 : * Set pulsarId with the specified Tag.
1437 : * @param pulsarId The Tag value to which pulsarId is to be set.
1438 :
1439 :
1440 :
1441 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1442 :
1443 : */
1444 0 : void PulsarRow::setPulsarId (Tag pulsarId) {
1445 :
1446 :
1447 0 : if (hasBeenAdded) {
1448 :
1449 0 : throw IllegalAccessException("pulsarId", "Pulsar");
1450 :
1451 : }
1452 :
1453 0 : this->pulsarId = pulsarId;
1454 :
1455 0 : }
1456 :
1457 :
1458 :
1459 :
1460 :
1461 :
1462 : /**
1463 : * Get refTime.
1464 : * @return refTime as ArrayTime
1465 : */
1466 0 : ArrayTime PulsarRow::getRefTime() const {
1467 :
1468 0 : return refTime;
1469 : }
1470 :
1471 : /**
1472 : * Set refTime with the specified ArrayTime.
1473 : * @param refTime The ArrayTime value to which refTime is to be set.
1474 :
1475 :
1476 :
1477 : */
1478 0 : void PulsarRow::setRefTime (ArrayTime refTime) {
1479 :
1480 :
1481 0 : if (hasBeenAdded) {
1482 :
1483 : }
1484 :
1485 0 : this->refTime = refTime;
1486 :
1487 0 : }
1488 :
1489 :
1490 :
1491 :
1492 :
1493 :
1494 : /**
1495 : * Get refPulseFreq.
1496 : * @return refPulseFreq as Frequency
1497 : */
1498 0 : Frequency PulsarRow::getRefPulseFreq() const {
1499 :
1500 0 : return refPulseFreq;
1501 : }
1502 :
1503 : /**
1504 : * Set refPulseFreq with the specified Frequency.
1505 : * @param refPulseFreq The Frequency value to which refPulseFreq is to be set.
1506 :
1507 :
1508 :
1509 : */
1510 0 : void PulsarRow::setRefPulseFreq (Frequency refPulseFreq) {
1511 :
1512 :
1513 0 : if (hasBeenAdded) {
1514 :
1515 : }
1516 :
1517 0 : this->refPulseFreq = refPulseFreq;
1518 :
1519 0 : }
1520 :
1521 :
1522 :
1523 :
1524 :
1525 :
1526 : /**
1527 : * Get refPhase.
1528 : * @return refPhase as double
1529 : */
1530 0 : double PulsarRow::getRefPhase() const {
1531 :
1532 0 : return refPhase;
1533 : }
1534 :
1535 : /**
1536 : * Set refPhase with the specified double.
1537 : * @param refPhase The double value to which refPhase is to be set.
1538 :
1539 :
1540 :
1541 : */
1542 0 : void PulsarRow::setRefPhase (double refPhase) {
1543 :
1544 :
1545 0 : if (hasBeenAdded) {
1546 :
1547 : }
1548 :
1549 0 : this->refPhase = refPhase;
1550 :
1551 0 : }
1552 :
1553 :
1554 :
1555 :
1556 :
1557 :
1558 : /**
1559 : * Get numBin.
1560 : * @return numBin as int
1561 : */
1562 0 : int PulsarRow::getNumBin() const {
1563 :
1564 0 : return numBin;
1565 : }
1566 :
1567 : /**
1568 : * Set numBin with the specified int.
1569 : * @param numBin The int value to which numBin is to be set.
1570 :
1571 :
1572 :
1573 : */
1574 0 : void PulsarRow::setNumBin (int numBin) {
1575 :
1576 :
1577 0 : if (hasBeenAdded) {
1578 :
1579 : }
1580 :
1581 0 : this->numBin = numBin;
1582 :
1583 0 : }
1584 :
1585 :
1586 :
1587 :
1588 : /**
1589 : * The attribute numPoly is optional. Return true if this attribute exists.
1590 : * @return true if and only if the numPoly attribute exists.
1591 : */
1592 0 : bool PulsarRow::isNumPolyExists() const {
1593 0 : return numPolyExists;
1594 : }
1595 :
1596 :
1597 :
1598 : /**
1599 : * Get numPoly, which is optional.
1600 : * @return numPoly as int
1601 : * @throw IllegalAccessException If numPoly does not exist.
1602 : */
1603 0 : int PulsarRow::getNumPoly() const {
1604 0 : if (!numPolyExists) {
1605 0 : throw IllegalAccessException("numPoly", "Pulsar");
1606 : }
1607 :
1608 0 : return numPoly;
1609 : }
1610 :
1611 : /**
1612 : * Set numPoly with the specified int.
1613 : * @param numPoly The int value to which numPoly is to be set.
1614 :
1615 :
1616 : */
1617 0 : void PulsarRow::setNumPoly (int numPoly) {
1618 :
1619 0 : this->numPoly = numPoly;
1620 :
1621 0 : numPolyExists = true;
1622 :
1623 0 : }
1624 :
1625 :
1626 : /**
1627 : * Mark numPoly, which is an optional field, as non-existent.
1628 : */
1629 0 : void PulsarRow::clearNumPoly () {
1630 0 : numPolyExists = false;
1631 0 : }
1632 :
1633 :
1634 :
1635 : /**
1636 : * The attribute phasePoly is optional. Return true if this attribute exists.
1637 : * @return true if and only if the phasePoly attribute exists.
1638 : */
1639 0 : bool PulsarRow::isPhasePolyExists() const {
1640 0 : return phasePolyExists;
1641 : }
1642 :
1643 :
1644 :
1645 : /**
1646 : * Get phasePoly, which is optional.
1647 : * @return phasePoly as std::vector<double >
1648 : * @throw IllegalAccessException If phasePoly does not exist.
1649 : */
1650 0 : std::vector<double > PulsarRow::getPhasePoly() const {
1651 0 : if (!phasePolyExists) {
1652 0 : throw IllegalAccessException("phasePoly", "Pulsar");
1653 : }
1654 :
1655 0 : return phasePoly;
1656 : }
1657 :
1658 : /**
1659 : * Set phasePoly with the specified std::vector<double >.
1660 : * @param phasePoly The std::vector<double > value to which phasePoly is to be set.
1661 :
1662 :
1663 : */
1664 0 : void PulsarRow::setPhasePoly (std::vector<double > phasePoly) {
1665 :
1666 0 : this->phasePoly = phasePoly;
1667 :
1668 0 : phasePolyExists = true;
1669 :
1670 0 : }
1671 :
1672 :
1673 : /**
1674 : * Mark phasePoly, which is an optional field, as non-existent.
1675 : */
1676 0 : void PulsarRow::clearPhasePoly () {
1677 0 : phasePolyExists = false;
1678 0 : }
1679 :
1680 :
1681 :
1682 : /**
1683 : * The attribute timeSpan is optional. Return true if this attribute exists.
1684 : * @return true if and only if the timeSpan attribute exists.
1685 : */
1686 0 : bool PulsarRow::isTimeSpanExists() const {
1687 0 : return timeSpanExists;
1688 : }
1689 :
1690 :
1691 :
1692 : /**
1693 : * Get timeSpan, which is optional.
1694 : * @return timeSpan as Interval
1695 : * @throw IllegalAccessException If timeSpan does not exist.
1696 : */
1697 0 : Interval PulsarRow::getTimeSpan() const {
1698 0 : if (!timeSpanExists) {
1699 0 : throw IllegalAccessException("timeSpan", "Pulsar");
1700 : }
1701 :
1702 0 : return timeSpan;
1703 : }
1704 :
1705 : /**
1706 : * Set timeSpan with the specified Interval.
1707 : * @param timeSpan The Interval value to which timeSpan is to be set.
1708 :
1709 :
1710 : */
1711 0 : void PulsarRow::setTimeSpan (Interval timeSpan) {
1712 :
1713 0 : this->timeSpan = timeSpan;
1714 :
1715 0 : timeSpanExists = true;
1716 :
1717 0 : }
1718 :
1719 :
1720 : /**
1721 : * Mark timeSpan, which is an optional field, as non-existent.
1722 : */
1723 0 : void PulsarRow::clearTimeSpan () {
1724 0 : timeSpanExists = false;
1725 0 : }
1726 :
1727 :
1728 :
1729 : /**
1730 : * The attribute startPhaseBin is optional. Return true if this attribute exists.
1731 : * @return true if and only if the startPhaseBin attribute exists.
1732 : */
1733 0 : bool PulsarRow::isStartPhaseBinExists() const {
1734 0 : return startPhaseBinExists;
1735 : }
1736 :
1737 :
1738 :
1739 : /**
1740 : * Get startPhaseBin, which is optional.
1741 : * @return startPhaseBin as std::vector<float >
1742 : * @throw IllegalAccessException If startPhaseBin does not exist.
1743 : */
1744 0 : std::vector<float > PulsarRow::getStartPhaseBin() const {
1745 0 : if (!startPhaseBinExists) {
1746 0 : throw IllegalAccessException("startPhaseBin", "Pulsar");
1747 : }
1748 :
1749 0 : return startPhaseBin;
1750 : }
1751 :
1752 : /**
1753 : * Set startPhaseBin with the specified std::vector<float >.
1754 : * @param startPhaseBin The std::vector<float > value to which startPhaseBin is to be set.
1755 :
1756 :
1757 : */
1758 0 : void PulsarRow::setStartPhaseBin (std::vector<float > startPhaseBin) {
1759 :
1760 0 : this->startPhaseBin = startPhaseBin;
1761 :
1762 0 : startPhaseBinExists = true;
1763 :
1764 0 : }
1765 :
1766 :
1767 : /**
1768 : * Mark startPhaseBin, which is an optional field, as non-existent.
1769 : */
1770 0 : void PulsarRow::clearStartPhaseBin () {
1771 0 : startPhaseBinExists = false;
1772 0 : }
1773 :
1774 :
1775 :
1776 : /**
1777 : * The attribute endPhaseBin is optional. Return true if this attribute exists.
1778 : * @return true if and only if the endPhaseBin attribute exists.
1779 : */
1780 0 : bool PulsarRow::isEndPhaseBinExists() const {
1781 0 : return endPhaseBinExists;
1782 : }
1783 :
1784 :
1785 :
1786 : /**
1787 : * Get endPhaseBin, which is optional.
1788 : * @return endPhaseBin as std::vector<float >
1789 : * @throw IllegalAccessException If endPhaseBin does not exist.
1790 : */
1791 0 : std::vector<float > PulsarRow::getEndPhaseBin() const {
1792 0 : if (!endPhaseBinExists) {
1793 0 : throw IllegalAccessException("endPhaseBin", "Pulsar");
1794 : }
1795 :
1796 0 : return endPhaseBin;
1797 : }
1798 :
1799 : /**
1800 : * Set endPhaseBin with the specified std::vector<float >.
1801 : * @param endPhaseBin The std::vector<float > value to which endPhaseBin is to be set.
1802 :
1803 :
1804 : */
1805 0 : void PulsarRow::setEndPhaseBin (std::vector<float > endPhaseBin) {
1806 :
1807 0 : this->endPhaseBin = endPhaseBin;
1808 :
1809 0 : endPhaseBinExists = true;
1810 :
1811 0 : }
1812 :
1813 :
1814 : /**
1815 : * Mark endPhaseBin, which is an optional field, as non-existent.
1816 : */
1817 0 : void PulsarRow::clearEndPhaseBin () {
1818 0 : endPhaseBinExists = false;
1819 0 : }
1820 :
1821 :
1822 :
1823 : /**
1824 : * The attribute dispersionMeasure is optional. Return true if this attribute exists.
1825 : * @return true if and only if the dispersionMeasure attribute exists.
1826 : */
1827 0 : bool PulsarRow::isDispersionMeasureExists() const {
1828 0 : return dispersionMeasureExists;
1829 : }
1830 :
1831 :
1832 :
1833 : /**
1834 : * Get dispersionMeasure, which is optional.
1835 : * @return dispersionMeasure as double
1836 : * @throw IllegalAccessException If dispersionMeasure does not exist.
1837 : */
1838 0 : double PulsarRow::getDispersionMeasure() const {
1839 0 : if (!dispersionMeasureExists) {
1840 0 : throw IllegalAccessException("dispersionMeasure", "Pulsar");
1841 : }
1842 :
1843 0 : return dispersionMeasure;
1844 : }
1845 :
1846 : /**
1847 : * Set dispersionMeasure with the specified double.
1848 : * @param dispersionMeasure The double value to which dispersionMeasure is to be set.
1849 :
1850 :
1851 : */
1852 0 : void PulsarRow::setDispersionMeasure (double dispersionMeasure) {
1853 :
1854 0 : this->dispersionMeasure = dispersionMeasure;
1855 :
1856 0 : dispersionMeasureExists = true;
1857 :
1858 0 : }
1859 :
1860 :
1861 : /**
1862 : * Mark dispersionMeasure, which is an optional field, as non-existent.
1863 : */
1864 0 : void PulsarRow::clearDispersionMeasure () {
1865 0 : dispersionMeasureExists = false;
1866 0 : }
1867 :
1868 :
1869 :
1870 : /**
1871 : * The attribute refFrequency is optional. Return true if this attribute exists.
1872 : * @return true if and only if the refFrequency attribute exists.
1873 : */
1874 0 : bool PulsarRow::isRefFrequencyExists() const {
1875 0 : return refFrequencyExists;
1876 : }
1877 :
1878 :
1879 :
1880 : /**
1881 : * Get refFrequency, which is optional.
1882 : * @return refFrequency as Frequency
1883 : * @throw IllegalAccessException If refFrequency does not exist.
1884 : */
1885 0 : Frequency PulsarRow::getRefFrequency() const {
1886 0 : if (!refFrequencyExists) {
1887 0 : throw IllegalAccessException("refFrequency", "Pulsar");
1888 : }
1889 :
1890 0 : return refFrequency;
1891 : }
1892 :
1893 : /**
1894 : * Set refFrequency with the specified Frequency.
1895 : * @param refFrequency The Frequency value to which refFrequency is to be set.
1896 :
1897 :
1898 : */
1899 0 : void PulsarRow::setRefFrequency (Frequency refFrequency) {
1900 :
1901 0 : this->refFrequency = refFrequency;
1902 :
1903 0 : refFrequencyExists = true;
1904 :
1905 0 : }
1906 :
1907 :
1908 : /**
1909 : * Mark refFrequency, which is an optional field, as non-existent.
1910 : */
1911 0 : void PulsarRow::clearRefFrequency () {
1912 0 : refFrequencyExists = false;
1913 0 : }
1914 :
1915 :
1916 :
1917 : ///////////////////////////////////////////////
1918 : // Extrinsic Table Attributes getters/setters//
1919 : ///////////////////////////////////////////////
1920 :
1921 :
1922 : //////////////////////////////////////
1923 : // Links Attributes getters/setters //
1924 : //////////////////////////////////////
1925 :
1926 :
1927 : /**
1928 : * Create a PulsarRow.
1929 : * <p>
1930 : * This constructor is private because only the
1931 : * table can create rows. All rows know the table
1932 : * to which they belong.
1933 : * @param table The table to which this row belongs.
1934 : */
1935 0 : PulsarRow::PulsarRow (PulsarTable &t) : table(t) {
1936 0 : hasBeenAdded = false;
1937 :
1938 :
1939 :
1940 :
1941 :
1942 :
1943 :
1944 :
1945 :
1946 :
1947 :
1948 :
1949 :
1950 0 : numPolyExists = false;
1951 :
1952 :
1953 :
1954 0 : phasePolyExists = false;
1955 :
1956 :
1957 :
1958 0 : timeSpanExists = false;
1959 :
1960 :
1961 :
1962 0 : startPhaseBinExists = false;
1963 :
1964 :
1965 :
1966 0 : endPhaseBinExists = false;
1967 :
1968 :
1969 :
1970 0 : dispersionMeasureExists = false;
1971 :
1972 :
1973 :
1974 0 : refFrequencyExists = false;
1975 :
1976 :
1977 :
1978 :
1979 :
1980 :
1981 :
1982 :
1983 :
1984 :
1985 :
1986 :
1987 :
1988 :
1989 :
1990 :
1991 :
1992 :
1993 :
1994 :
1995 :
1996 :
1997 :
1998 :
1999 :
2000 :
2001 :
2002 :
2003 :
2004 :
2005 :
2006 :
2007 0 : fromBinMethods["pulsarId"] = &PulsarRow::pulsarIdFromBin;
2008 0 : fromBinMethods["refTime"] = &PulsarRow::refTimeFromBin;
2009 0 : fromBinMethods["refPulseFreq"] = &PulsarRow::refPulseFreqFromBin;
2010 0 : fromBinMethods["refPhase"] = &PulsarRow::refPhaseFromBin;
2011 0 : fromBinMethods["numBin"] = &PulsarRow::numBinFromBin;
2012 :
2013 :
2014 0 : fromBinMethods["numPoly"] = &PulsarRow::numPolyFromBin;
2015 0 : fromBinMethods["phasePoly"] = &PulsarRow::phasePolyFromBin;
2016 0 : fromBinMethods["timeSpan"] = &PulsarRow::timeSpanFromBin;
2017 0 : fromBinMethods["startPhaseBin"] = &PulsarRow::startPhaseBinFromBin;
2018 0 : fromBinMethods["endPhaseBin"] = &PulsarRow::endPhaseBinFromBin;
2019 0 : fromBinMethods["dispersionMeasure"] = &PulsarRow::dispersionMeasureFromBin;
2020 0 : fromBinMethods["refFrequency"] = &PulsarRow::refFrequencyFromBin;
2021 :
2022 :
2023 :
2024 :
2025 :
2026 0 : fromTextMethods["pulsarId"] = &PulsarRow::pulsarIdFromText;
2027 :
2028 :
2029 :
2030 0 : fromTextMethods["refTime"] = &PulsarRow::refTimeFromText;
2031 :
2032 :
2033 :
2034 0 : fromTextMethods["refPulseFreq"] = &PulsarRow::refPulseFreqFromText;
2035 :
2036 :
2037 :
2038 0 : fromTextMethods["refPhase"] = &PulsarRow::refPhaseFromText;
2039 :
2040 :
2041 :
2042 0 : fromTextMethods["numBin"] = &PulsarRow::numBinFromText;
2043 :
2044 :
2045 :
2046 :
2047 :
2048 0 : fromTextMethods["numPoly"] = &PulsarRow::numPolyFromText;
2049 :
2050 :
2051 :
2052 0 : fromTextMethods["phasePoly"] = &PulsarRow::phasePolyFromText;
2053 :
2054 :
2055 :
2056 0 : fromTextMethods["timeSpan"] = &PulsarRow::timeSpanFromText;
2057 :
2058 :
2059 :
2060 0 : fromTextMethods["startPhaseBin"] = &PulsarRow::startPhaseBinFromText;
2061 :
2062 :
2063 :
2064 0 : fromTextMethods["endPhaseBin"] = &PulsarRow::endPhaseBinFromText;
2065 :
2066 :
2067 :
2068 0 : fromTextMethods["dispersionMeasure"] = &PulsarRow::dispersionMeasureFromText;
2069 :
2070 :
2071 :
2072 0 : fromTextMethods["refFrequency"] = &PulsarRow::refFrequencyFromText;
2073 :
2074 :
2075 0 : }
2076 :
2077 0 : PulsarRow::PulsarRow (PulsarTable &t, PulsarRow *row) : table(t) {
2078 0 : hasBeenAdded = false;
2079 :
2080 0 : if (row == 0) {
2081 :
2082 :
2083 :
2084 :
2085 :
2086 :
2087 :
2088 :
2089 :
2090 :
2091 :
2092 :
2093 :
2094 0 : numPolyExists = false;
2095 :
2096 :
2097 :
2098 0 : phasePolyExists = false;
2099 :
2100 :
2101 :
2102 0 : timeSpanExists = false;
2103 :
2104 :
2105 :
2106 0 : startPhaseBinExists = false;
2107 :
2108 :
2109 :
2110 0 : endPhaseBinExists = false;
2111 :
2112 :
2113 :
2114 0 : dispersionMeasureExists = false;
2115 :
2116 :
2117 :
2118 0 : refFrequencyExists = false;
2119 :
2120 :
2121 :
2122 : }
2123 : else {
2124 :
2125 :
2126 0 : pulsarId = row->pulsarId;
2127 :
2128 :
2129 :
2130 :
2131 0 : refTime = row->refTime;
2132 :
2133 0 : refPulseFreq = row->refPulseFreq;
2134 :
2135 0 : refPhase = row->refPhase;
2136 :
2137 0 : numBin = row->numBin;
2138 :
2139 :
2140 :
2141 :
2142 0 : if (row->numPolyExists) {
2143 0 : numPoly = row->numPoly;
2144 0 : numPolyExists = true;
2145 : }
2146 : else
2147 0 : numPolyExists = false;
2148 :
2149 0 : if (row->phasePolyExists) {
2150 0 : phasePoly = row->phasePoly;
2151 0 : phasePolyExists = true;
2152 : }
2153 : else
2154 0 : phasePolyExists = false;
2155 :
2156 0 : if (row->timeSpanExists) {
2157 0 : timeSpan = row->timeSpan;
2158 0 : timeSpanExists = true;
2159 : }
2160 : else
2161 0 : timeSpanExists = false;
2162 :
2163 0 : if (row->startPhaseBinExists) {
2164 0 : startPhaseBin = row->startPhaseBin;
2165 0 : startPhaseBinExists = true;
2166 : }
2167 : else
2168 0 : startPhaseBinExists = false;
2169 :
2170 0 : if (row->endPhaseBinExists) {
2171 0 : endPhaseBin = row->endPhaseBin;
2172 0 : endPhaseBinExists = true;
2173 : }
2174 : else
2175 0 : endPhaseBinExists = false;
2176 :
2177 0 : if (row->dispersionMeasureExists) {
2178 0 : dispersionMeasure = row->dispersionMeasure;
2179 0 : dispersionMeasureExists = true;
2180 : }
2181 : else
2182 0 : dispersionMeasureExists = false;
2183 :
2184 0 : if (row->refFrequencyExists) {
2185 0 : refFrequency = row->refFrequency;
2186 0 : refFrequencyExists = true;
2187 : }
2188 : else
2189 0 : refFrequencyExists = false;
2190 :
2191 : }
2192 :
2193 0 : fromBinMethods["pulsarId"] = &PulsarRow::pulsarIdFromBin;
2194 0 : fromBinMethods["refTime"] = &PulsarRow::refTimeFromBin;
2195 0 : fromBinMethods["refPulseFreq"] = &PulsarRow::refPulseFreqFromBin;
2196 0 : fromBinMethods["refPhase"] = &PulsarRow::refPhaseFromBin;
2197 0 : fromBinMethods["numBin"] = &PulsarRow::numBinFromBin;
2198 :
2199 :
2200 0 : fromBinMethods["numPoly"] = &PulsarRow::numPolyFromBin;
2201 0 : fromBinMethods["phasePoly"] = &PulsarRow::phasePolyFromBin;
2202 0 : fromBinMethods["timeSpan"] = &PulsarRow::timeSpanFromBin;
2203 0 : fromBinMethods["startPhaseBin"] = &PulsarRow::startPhaseBinFromBin;
2204 0 : fromBinMethods["endPhaseBin"] = &PulsarRow::endPhaseBinFromBin;
2205 0 : fromBinMethods["dispersionMeasure"] = &PulsarRow::dispersionMeasureFromBin;
2206 0 : fromBinMethods["refFrequency"] = &PulsarRow::refFrequencyFromBin;
2207 :
2208 0 : }
2209 :
2210 :
2211 0 : bool PulsarRow::compareNoAutoInc(ArrayTime refTime, Frequency refPulseFreq, double refPhase, int numBin) {
2212 : bool result;
2213 0 : result = true;
2214 :
2215 :
2216 :
2217 0 : result = result && (this->refTime == refTime);
2218 :
2219 0 : if (!result) return false;
2220 :
2221 :
2222 :
2223 :
2224 0 : result = result && (this->refPulseFreq == refPulseFreq);
2225 :
2226 0 : if (!result) return false;
2227 :
2228 :
2229 :
2230 :
2231 0 : result = result && (this->refPhase == refPhase);
2232 :
2233 0 : if (!result) return false;
2234 :
2235 :
2236 :
2237 :
2238 0 : result = result && (this->numBin == numBin);
2239 :
2240 0 : if (!result) return false;
2241 :
2242 :
2243 0 : return result;
2244 : }
2245 :
2246 :
2247 :
2248 0 : bool PulsarRow::compareRequiredValue(ArrayTime refTime, Frequency refPulseFreq, double refPhase, int numBin) {
2249 : bool result;
2250 0 : result = true;
2251 :
2252 :
2253 0 : if (!(this->refTime == refTime)) return false;
2254 :
2255 :
2256 :
2257 0 : if (!(this->refPulseFreq == refPulseFreq)) return false;
2258 :
2259 :
2260 :
2261 0 : if (!(this->refPhase == refPhase)) return false;
2262 :
2263 :
2264 :
2265 0 : if (!(this->numBin == numBin)) return false;
2266 :
2267 :
2268 0 : return result;
2269 : }
2270 :
2271 :
2272 : /**
2273 : * Return true if all required attributes of the value part are equal to their homologues
2274 : * in x and false otherwise.
2275 : *
2276 :
2277 : * @param x a pointer on the PulsarRow whose required attributes of the value part
2278 :
2279 : * will be compared with those of this.
2280 : * @return a boolean.
2281 : */
2282 0 : bool PulsarRow::equalByRequiredValue(PulsarRow* x ) {
2283 :
2284 :
2285 0 : if (this->refTime != x->refTime) return false;
2286 :
2287 0 : if (this->refPulseFreq != x->refPulseFreq) return false;
2288 :
2289 0 : if (this->refPhase != x->refPhase) return false;
2290 :
2291 0 : if (this->numBin != x->numBin) return false;
2292 :
2293 :
2294 0 : return true;
2295 : }
2296 :
2297 : /*
2298 : map<string, PulsarAttributeFromBin> PulsarRow::initFromBinMethods() {
2299 : map<string, PulsarAttributeFromBin> result;
2300 :
2301 : result["pulsarId"] = &PulsarRow::pulsarIdFromBin;
2302 : result["refTime"] = &PulsarRow::refTimeFromBin;
2303 : result["refPulseFreq"] = &PulsarRow::refPulseFreqFromBin;
2304 : result["refPhase"] = &PulsarRow::refPhaseFromBin;
2305 : result["numBin"] = &PulsarRow::numBinFromBin;
2306 :
2307 :
2308 : result["numPoly"] = &PulsarRow::numPolyFromBin;
2309 : result["phasePoly"] = &PulsarRow::phasePolyFromBin;
2310 : result["timeSpan"] = &PulsarRow::timeSpanFromBin;
2311 : result["startPhaseBin"] = &PulsarRow::startPhaseBinFromBin;
2312 : result["endPhaseBin"] = &PulsarRow::endPhaseBinFromBin;
2313 : result["dispersionMeasure"] = &PulsarRow::dispersionMeasureFromBin;
2314 : result["refFrequency"] = &PulsarRow::refFrequencyFromBin;
2315 :
2316 :
2317 : return result;
2318 : }
2319 : */
2320 : } // End namespace asdm
2321 :
|
