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 AnnotationRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/AnnotationRow.h>
39 : #include <alma/ASDM/AnnotationTable.h>
40 :
41 : #include <alma/ASDM/AntennaTable.h>
42 : #include <alma/ASDM/AntennaRow.h>
43 :
44 :
45 : using asdm::ASDM;
46 : using asdm::AnnotationRow;
47 : using asdm::AnnotationTable;
48 :
49 : using asdm::AntennaTable;
50 : using asdm::AntennaRow;
51 :
52 :
53 : #include <alma/ASDM/Parser.h>
54 :
55 : #include <alma/ASDM/EnumerationParser.h>
56 : #include <alma/ASDM/ASDMValuesParser.h>
57 :
58 : #include <alma/ASDM/InvalidArgumentException.h>
59 :
60 : using namespace std;
61 :
62 : namespace asdm {
63 0 : AnnotationRow::~AnnotationRow() {
64 0 : }
65 :
66 : /**
67 : * Return the table to which this row belongs.
68 : */
69 0 : AnnotationTable &AnnotationRow::getTable() const {
70 0 : return table;
71 : }
72 :
73 0 : bool AnnotationRow::isAdded() const {
74 0 : return hasBeenAdded;
75 : }
76 :
77 0 : void AnnotationRow::isAdded(bool added) {
78 0 : hasBeenAdded = added;
79 0 : }
80 :
81 : #ifndef WITHOUT_ACS
82 : using asdmIDL::AnnotationRowIDL;
83 : #endif
84 :
85 : #ifndef WITHOUT_ACS
86 : /**
87 : * Return this row in the form of an IDL struct.
88 : * @return The values of this row as a AnnotationRowIDL struct.
89 : */
90 : AnnotationRowIDL *AnnotationRow::toIDL() const {
91 : AnnotationRowIDL *x = new AnnotationRowIDL ();
92 :
93 : // Fill the IDL structure.
94 :
95 :
96 :
97 :
98 :
99 :
100 :
101 : x->annotationId = annotationId.toIDLTag();
102 :
103 :
104 :
105 :
106 :
107 :
108 :
109 :
110 :
111 : x->time = time.toIDLArrayTime();
112 :
113 :
114 :
115 :
116 :
117 :
118 :
119 :
120 :
121 :
122 : x->issue = CORBA::string_dup(issue.c_str());
123 :
124 :
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 : x->details = CORBA::string_dup(details.c_str());
135 :
136 :
137 :
138 :
139 :
140 :
141 :
142 :
143 : x->numAntennaExists = numAntennaExists;
144 :
145 :
146 :
147 :
148 : x->numAntenna = numAntenna;
149 :
150 :
151 :
152 :
153 :
154 :
155 :
156 :
157 : x->basebandNameExists = basebandNameExists;
158 :
159 :
160 :
161 : x->basebandName.length(basebandName.size());
162 : for (unsigned int i = 0; i < basebandName.size(); ++i) {
163 :
164 :
165 : x->basebandName[i] = basebandName.at(i);
166 :
167 :
168 : }
169 :
170 :
171 :
172 :
173 :
174 :
175 :
176 : x->numBasebandExists = numBasebandExists;
177 :
178 :
179 :
180 :
181 : x->numBaseband = numBaseband;
182 :
183 :
184 :
185 :
186 :
187 :
188 :
189 :
190 : x->intervalExists = intervalExists;
191 :
192 :
193 :
194 : x->interval = interval.toIDLInterval();
195 :
196 :
197 :
198 :
199 :
200 :
201 :
202 : x->dValueExists = dValueExists;
203 :
204 :
205 :
206 :
207 : x->dValue = dValue;
208 :
209 :
210 :
211 :
212 :
213 :
214 :
215 :
216 : x->vdValueExists = vdValueExists;
217 :
218 :
219 :
220 : x->vdValue.length(vdValue.size());
221 : for (unsigned int i = 0; i < vdValue.size(); ++i) {
222 :
223 :
224 : x->vdValue[i] = vdValue.at(i);
225 :
226 :
227 : }
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 : x->vvdValuesExists = vvdValuesExists;
236 :
237 :
238 :
239 : x->vvdValues.length(vvdValues.size());
240 : for (unsigned int i = 0; i < vvdValues.size(); i++) {
241 : x->vvdValues[i].length(vvdValues.at(i).size());
242 : }
243 :
244 : for (unsigned int i = 0; i < vvdValues.size() ; i++)
245 : for (unsigned int j = 0; j < vvdValues.at(i).size(); j++)
246 :
247 :
248 : x->vvdValues[i][j] = vvdValues.at(i).at(j);
249 :
250 :
251 :
252 :
253 :
254 :
255 :
256 :
257 :
258 :
259 : x->llValueExists = llValueExists;
260 :
261 :
262 :
263 :
264 : x->llValue = llValue;
265 :
266 :
267 :
268 :
269 :
270 :
271 :
272 :
273 : x->vllValueExists = vllValueExists;
274 :
275 :
276 :
277 : x->vllValue.length(vllValue.size());
278 : for (unsigned int i = 0; i < vllValue.size(); ++i) {
279 :
280 :
281 : x->vllValue[i] = vllValue.at(i);
282 :
283 :
284 : }
285 :
286 :
287 :
288 :
289 :
290 :
291 :
292 : x->vvllValueExists = vvllValueExists;
293 :
294 :
295 :
296 : x->vvllValue.length(vvllValue.size());
297 : for (unsigned int i = 0; i < vvllValue.size(); i++) {
298 : x->vvllValue[i].length(vvllValue.at(i).size());
299 : }
300 :
301 : for (unsigned int i = 0; i < vvllValue.size() ; i++)
302 : for (unsigned int j = 0; j < vvllValue.at(i).size(); j++)
303 :
304 :
305 : x->vvllValue[i][j] = vvllValue.at(i).at(j);
306 :
307 :
308 :
309 :
310 :
311 :
312 :
313 :
314 :
315 :
316 : x->sValueExists = sValueExists;
317 :
318 :
319 :
320 :
321 : x->sValue = CORBA::string_dup(sValue.c_str());
322 :
323 :
324 :
325 :
326 :
327 :
328 :
329 :
330 :
331 :
332 :
333 :
334 : x->antennaIdExists = antennaIdExists;
335 :
336 :
337 :
338 : x->antennaId.length(antennaId.size());
339 : for (unsigned int i = 0; i < antennaId.size(); ++i) {
340 :
341 : x->antennaId[i] = antennaId.at(i).toIDLTag();
342 :
343 : }
344 :
345 :
346 :
347 :
348 :
349 :
350 :
351 :
352 : return x;
353 :
354 : }
355 :
356 : void AnnotationRow::toIDL(asdmIDL::AnnotationRowIDL& x) const {
357 : // Set the x's fields.
358 :
359 :
360 :
361 :
362 :
363 :
364 :
365 : x.annotationId = annotationId.toIDLTag();
366 :
367 :
368 :
369 :
370 :
371 :
372 :
373 :
374 :
375 : x.time = time.toIDLArrayTime();
376 :
377 :
378 :
379 :
380 :
381 :
382 :
383 :
384 :
385 :
386 : x.issue = CORBA::string_dup(issue.c_str());
387 :
388 :
389 :
390 :
391 :
392 :
393 :
394 :
395 :
396 :
397 :
398 : x.details = CORBA::string_dup(details.c_str());
399 :
400 :
401 :
402 :
403 :
404 :
405 :
406 :
407 : x.numAntennaExists = numAntennaExists;
408 :
409 :
410 :
411 :
412 : x.numAntenna = numAntenna;
413 :
414 :
415 :
416 :
417 :
418 :
419 :
420 :
421 : x.basebandNameExists = basebandNameExists;
422 :
423 :
424 :
425 : x.basebandName.length(basebandName.size());
426 : for (unsigned int i = 0; i < basebandName.size(); ++i) {
427 :
428 :
429 : x.basebandName[i] = basebandName.at(i);
430 :
431 :
432 : }
433 :
434 :
435 :
436 :
437 :
438 :
439 :
440 : x.numBasebandExists = numBasebandExists;
441 :
442 :
443 :
444 :
445 : x.numBaseband = numBaseband;
446 :
447 :
448 :
449 :
450 :
451 :
452 :
453 :
454 : x.intervalExists = intervalExists;
455 :
456 :
457 :
458 : x.interval = interval.toIDLInterval();
459 :
460 :
461 :
462 :
463 :
464 :
465 :
466 : x.dValueExists = dValueExists;
467 :
468 :
469 :
470 :
471 : x.dValue = dValue;
472 :
473 :
474 :
475 :
476 :
477 :
478 :
479 :
480 : x.vdValueExists = vdValueExists;
481 :
482 :
483 :
484 : x.vdValue.length(vdValue.size());
485 : for (unsigned int i = 0; i < vdValue.size(); ++i) {
486 :
487 :
488 : x.vdValue[i] = vdValue.at(i);
489 :
490 :
491 : }
492 :
493 :
494 :
495 :
496 :
497 :
498 :
499 : x.vvdValuesExists = vvdValuesExists;
500 :
501 :
502 :
503 : x.vvdValues.length(vvdValues.size());
504 : for (unsigned int i = 0; i < vvdValues.size(); i++) {
505 : x.vvdValues[i].length(vvdValues.at(i).size());
506 : }
507 :
508 : for (unsigned int i = 0; i < vvdValues.size() ; i++)
509 : for (unsigned int j = 0; j < vvdValues.at(i).size(); j++)
510 :
511 :
512 : x.vvdValues[i][j] = vvdValues.at(i).at(j);
513 :
514 :
515 :
516 :
517 :
518 :
519 :
520 :
521 :
522 :
523 : x.llValueExists = llValueExists;
524 :
525 :
526 :
527 :
528 : x.llValue = llValue;
529 :
530 :
531 :
532 :
533 :
534 :
535 :
536 :
537 : x.vllValueExists = vllValueExists;
538 :
539 :
540 :
541 : x.vllValue.length(vllValue.size());
542 : for (unsigned int i = 0; i < vllValue.size(); ++i) {
543 :
544 :
545 : x.vllValue[i] = vllValue.at(i);
546 :
547 :
548 : }
549 :
550 :
551 :
552 :
553 :
554 :
555 :
556 : x.vvllValueExists = vvllValueExists;
557 :
558 :
559 :
560 : x.vvllValue.length(vvllValue.size());
561 : for (unsigned int i = 0; i < vvllValue.size(); i++) {
562 : x.vvllValue[i].length(vvllValue.at(i).size());
563 : }
564 :
565 : for (unsigned int i = 0; i < vvllValue.size() ; i++)
566 : for (unsigned int j = 0; j < vvllValue.at(i).size(); j++)
567 :
568 :
569 : x.vvllValue[i][j] = vvllValue.at(i).at(j);
570 :
571 :
572 :
573 :
574 :
575 :
576 :
577 :
578 :
579 :
580 : x.sValueExists = sValueExists;
581 :
582 :
583 :
584 :
585 : x.sValue = CORBA::string_dup(sValue.c_str());
586 :
587 :
588 :
589 :
590 :
591 :
592 :
593 :
594 :
595 :
596 :
597 :
598 : x.antennaIdExists = antennaIdExists;
599 :
600 :
601 :
602 : x.antennaId.length(antennaId.size());
603 : for (unsigned int i = 0; i < antennaId.size(); ++i) {
604 :
605 : x.antennaId[i] = antennaId.at(i).toIDLTag();
606 :
607 : }
608 :
609 :
610 :
611 :
612 :
613 :
614 :
615 :
616 : }
617 : #endif
618 :
619 :
620 : #ifndef WITHOUT_ACS
621 : /**
622 : * Fill the values of this row from the IDL struct AnnotationRowIDL.
623 : * @param x The IDL struct containing the values used to fill this row.
624 : */
625 : void AnnotationRow::setFromIDL (AnnotationRowIDL x){
626 : try {
627 : // Fill the values from x.
628 :
629 :
630 :
631 :
632 :
633 :
634 : setAnnotationId(Tag (x.annotationId));
635 :
636 :
637 :
638 :
639 :
640 :
641 :
642 :
643 :
644 : setTime(ArrayTime (x.time));
645 :
646 :
647 :
648 :
649 :
650 :
651 :
652 :
653 :
654 : setIssue(string (x.issue));
655 :
656 :
657 :
658 :
659 :
660 :
661 :
662 :
663 :
664 : setDetails(string (x.details));
665 :
666 :
667 :
668 :
669 :
670 :
671 :
672 : numAntennaExists = x.numAntennaExists;
673 : if (x.numAntennaExists) {
674 :
675 :
676 :
677 : setNumAntenna(x.numAntenna);
678 :
679 :
680 :
681 : }
682 :
683 :
684 :
685 :
686 :
687 : basebandNameExists = x.basebandNameExists;
688 : if (x.basebandNameExists) {
689 :
690 :
691 :
692 : basebandName .clear();
693 : for (unsigned int i = 0; i <x.basebandName.length(); ++i) {
694 :
695 : basebandName.push_back(x.basebandName[i]);
696 :
697 : }
698 :
699 :
700 :
701 : }
702 :
703 :
704 :
705 :
706 :
707 : numBasebandExists = x.numBasebandExists;
708 : if (x.numBasebandExists) {
709 :
710 :
711 :
712 : setNumBaseband(x.numBaseband);
713 :
714 :
715 :
716 : }
717 :
718 :
719 :
720 :
721 :
722 : intervalExists = x.intervalExists;
723 : if (x.intervalExists) {
724 :
725 :
726 :
727 : setInterval(Interval (x.interval));
728 :
729 :
730 :
731 : }
732 :
733 :
734 :
735 :
736 :
737 : dValueExists = x.dValueExists;
738 : if (x.dValueExists) {
739 :
740 :
741 :
742 : setDValue(x.dValue);
743 :
744 :
745 :
746 : }
747 :
748 :
749 :
750 :
751 :
752 : vdValueExists = x.vdValueExists;
753 : if (x.vdValueExists) {
754 :
755 :
756 :
757 : vdValue .clear();
758 : for (unsigned int i = 0; i <x.vdValue.length(); ++i) {
759 :
760 : vdValue.push_back(x.vdValue[i]);
761 :
762 : }
763 :
764 :
765 :
766 : }
767 :
768 :
769 :
770 :
771 :
772 : vvdValuesExists = x.vvdValuesExists;
773 : if (x.vvdValuesExists) {
774 :
775 :
776 :
777 : vvdValues .clear();
778 :
779 : vector<double> v_aux_vvdValues;
780 :
781 : for (unsigned int i = 0; i < x.vvdValues.length(); ++i) {
782 : v_aux_vvdValues.clear();
783 : for (unsigned int j = 0; j < x.vvdValues[0].length(); ++j) {
784 :
785 : v_aux_vvdValues.push_back(x.vvdValues[i][j]);
786 :
787 : }
788 : vvdValues.push_back(v_aux_vvdValues);
789 : }
790 :
791 :
792 :
793 : }
794 :
795 :
796 :
797 :
798 :
799 : llValueExists = x.llValueExists;
800 : if (x.llValueExists) {
801 :
802 :
803 :
804 : setLlValue(x.llValue);
805 :
806 :
807 :
808 : }
809 :
810 :
811 :
812 :
813 :
814 : vllValueExists = x.vllValueExists;
815 : if (x.vllValueExists) {
816 :
817 :
818 :
819 : vllValue .clear();
820 : for (unsigned int i = 0; i <x.vllValue.length(); ++i) {
821 :
822 : vllValue.push_back(x.vllValue[i]);
823 :
824 : }
825 :
826 :
827 :
828 : }
829 :
830 :
831 :
832 :
833 :
834 : vvllValueExists = x.vvllValueExists;
835 : if (x.vvllValueExists) {
836 :
837 :
838 :
839 : vvllValue .clear();
840 :
841 : vector<int64_t> v_aux_vvllValue;
842 :
843 : for (unsigned int i = 0; i < x.vvllValue.length(); ++i) {
844 : v_aux_vvllValue.clear();
845 : for (unsigned int j = 0; j < x.vvllValue[0].length(); ++j) {
846 :
847 : v_aux_vvllValue.push_back(x.vvllValue[i][j]);
848 :
849 : }
850 : vvllValue.push_back(v_aux_vvllValue);
851 : }
852 :
853 :
854 :
855 : }
856 :
857 :
858 :
859 :
860 :
861 : sValueExists = x.sValueExists;
862 : if (x.sValueExists) {
863 :
864 :
865 :
866 : setSValue(string (x.sValue));
867 :
868 :
869 :
870 : }
871 :
872 :
873 :
874 :
875 :
876 :
877 :
878 :
879 : antennaIdExists = x.antennaIdExists;
880 : if (x.antennaIdExists) {
881 :
882 : antennaId .clear();
883 : for (unsigned int i = 0; i <x.antennaId.length(); ++i) {
884 :
885 : antennaId.push_back(Tag (x.antennaId[i]));
886 :
887 : }
888 :
889 : }
890 :
891 :
892 :
893 :
894 :
895 :
896 :
897 : } catch (const IllegalAccessException &err) {
898 : throw ConversionException (err.getMessage(),"Annotation");
899 : }
900 : }
901 : #endif
902 :
903 : /**
904 : * Return this row in the form of an XML string.
905 : * @return The values of this row as an XML string.
906 : */
907 0 : string AnnotationRow::toXML() const {
908 0 : string buf;
909 0 : buf.append("<row> \n");
910 :
911 :
912 :
913 :
914 :
915 :
916 0 : Parser::toXML(annotationId, "annotationId", buf);
917 :
918 :
919 :
920 :
921 :
922 :
923 :
924 0 : Parser::toXML(time, "time", buf);
925 :
926 :
927 :
928 :
929 :
930 :
931 :
932 0 : Parser::toXML(issue, "issue", buf);
933 :
934 :
935 :
936 :
937 :
938 :
939 :
940 0 : Parser::toXML(details, "details", buf);
941 :
942 :
943 :
944 :
945 :
946 :
947 0 : if (numAntennaExists) {
948 :
949 :
950 0 : Parser::toXML(numAntenna, "numAntenna", buf);
951 :
952 :
953 : }
954 :
955 :
956 :
957 :
958 :
959 0 : if (basebandNameExists) {
960 :
961 :
962 0 : buf.append(EnumerationParser::toXML("basebandName", basebandName));
963 :
964 :
965 : }
966 :
967 :
968 :
969 :
970 :
971 0 : if (numBasebandExists) {
972 :
973 :
974 0 : Parser::toXML(numBaseband, "numBaseband", buf);
975 :
976 :
977 : }
978 :
979 :
980 :
981 :
982 :
983 0 : if (intervalExists) {
984 :
985 :
986 0 : Parser::toXML(interval, "interval", buf);
987 :
988 :
989 : }
990 :
991 :
992 :
993 :
994 :
995 0 : if (dValueExists) {
996 :
997 :
998 0 : Parser::toXML(dValue, "dValue", buf);
999 :
1000 :
1001 : }
1002 :
1003 :
1004 :
1005 :
1006 :
1007 0 : if (vdValueExists) {
1008 :
1009 :
1010 0 : Parser::toXML(vdValue, "vdValue", buf);
1011 :
1012 :
1013 : }
1014 :
1015 :
1016 :
1017 :
1018 :
1019 0 : if (vvdValuesExists) {
1020 :
1021 :
1022 0 : Parser::toXML(vvdValues, "vvdValues", buf);
1023 :
1024 :
1025 : }
1026 :
1027 :
1028 :
1029 :
1030 :
1031 0 : if (llValueExists) {
1032 :
1033 :
1034 0 : Parser::toXML(llValue, "llValue", buf);
1035 :
1036 :
1037 : }
1038 :
1039 :
1040 :
1041 :
1042 :
1043 0 : if (vllValueExists) {
1044 :
1045 :
1046 0 : Parser::toXML(vllValue, "vllValue", buf);
1047 :
1048 :
1049 : }
1050 :
1051 :
1052 :
1053 :
1054 :
1055 0 : if (vvllValueExists) {
1056 :
1057 :
1058 0 : Parser::toXML(vvllValue, "vvllValue", buf);
1059 :
1060 :
1061 : }
1062 :
1063 :
1064 :
1065 :
1066 :
1067 0 : if (sValueExists) {
1068 :
1069 :
1070 0 : Parser::toXML(sValue, "sValue", buf);
1071 :
1072 :
1073 : }
1074 :
1075 :
1076 :
1077 :
1078 :
1079 :
1080 :
1081 :
1082 0 : if (antennaIdExists) {
1083 :
1084 :
1085 0 : Parser::toXML(antennaId, "antennaId", buf);
1086 :
1087 :
1088 : }
1089 :
1090 :
1091 :
1092 :
1093 :
1094 :
1095 :
1096 :
1097 0 : buf.append("</row>\n");
1098 0 : return buf;
1099 0 : }
1100 :
1101 : /**
1102 : * Fill the values of this row from an XML string
1103 : * that was produced by the toXML() method.
1104 : * @param x The XML string being used to set the values of this row.
1105 : */
1106 0 : void AnnotationRow::setFromXML (string rowDoc) {
1107 0 : Parser row(rowDoc);
1108 0 : string s = "";
1109 : try {
1110 :
1111 :
1112 :
1113 :
1114 :
1115 0 : setAnnotationId(Parser::getTag("annotationId","Annotation",rowDoc));
1116 :
1117 :
1118 :
1119 :
1120 :
1121 :
1122 :
1123 0 : setTime(Parser::getArrayTime("time","Annotation",rowDoc));
1124 :
1125 :
1126 :
1127 :
1128 :
1129 :
1130 :
1131 0 : setIssue(Parser::getString("issue","Annotation",rowDoc));
1132 :
1133 :
1134 :
1135 :
1136 :
1137 :
1138 :
1139 0 : setDetails(Parser::getString("details","Annotation",rowDoc));
1140 :
1141 :
1142 :
1143 :
1144 :
1145 :
1146 0 : if (row.isStr("<numAntenna>")) {
1147 :
1148 0 : setNumAntenna(Parser::getInteger("numAntenna","Annotation",rowDoc));
1149 :
1150 : }
1151 :
1152 :
1153 :
1154 :
1155 :
1156 0 : if (row.isStr("<basebandName>")) {
1157 :
1158 :
1159 :
1160 0 : basebandName = EnumerationParser::getBasebandName1D("basebandName","Annotation",rowDoc);
1161 :
1162 :
1163 :
1164 0 : basebandNameExists = true;
1165 : }
1166 :
1167 :
1168 :
1169 :
1170 :
1171 0 : if (row.isStr("<numBaseband>")) {
1172 :
1173 0 : setNumBaseband(Parser::getInteger("numBaseband","Annotation",rowDoc));
1174 :
1175 : }
1176 :
1177 :
1178 :
1179 :
1180 :
1181 0 : if (row.isStr("<interval>")) {
1182 :
1183 0 : setInterval(Parser::getInterval("interval","Annotation",rowDoc));
1184 :
1185 : }
1186 :
1187 :
1188 :
1189 :
1190 :
1191 0 : if (row.isStr("<dValue>")) {
1192 :
1193 0 : setDValue(Parser::getDouble("dValue","Annotation",rowDoc));
1194 :
1195 : }
1196 :
1197 :
1198 :
1199 :
1200 :
1201 0 : if (row.isStr("<vdValue>")) {
1202 :
1203 :
1204 0 : setVdValue(Parser::get1DDouble("vdValue","Annotation",rowDoc));
1205 :
1206 :
1207 : }
1208 :
1209 :
1210 :
1211 :
1212 :
1213 0 : if (row.isStr("<vvdValues>")) {
1214 :
1215 :
1216 0 : setVvdValues(Parser::get2DDouble("vvdValues","Annotation",rowDoc));
1217 :
1218 :
1219 : }
1220 :
1221 :
1222 :
1223 :
1224 :
1225 0 : if (row.isStr("<llValue>")) {
1226 :
1227 0 : setLlValue(Parser::getLong("llValue","Annotation",rowDoc));
1228 :
1229 : }
1230 :
1231 :
1232 :
1233 :
1234 :
1235 0 : if (row.isStr("<vllValue>")) {
1236 :
1237 :
1238 0 : setVllValue(Parser::get1DLong("vllValue","Annotation",rowDoc));
1239 :
1240 :
1241 : }
1242 :
1243 :
1244 :
1245 :
1246 :
1247 0 : if (row.isStr("<vvllValue>")) {
1248 :
1249 :
1250 0 : setVvllValue(Parser::get2DLong("vvllValue","Annotation",rowDoc));
1251 :
1252 :
1253 : }
1254 :
1255 :
1256 :
1257 :
1258 :
1259 0 : if (row.isStr("<sValue>")) {
1260 :
1261 0 : setSValue(Parser::getString("sValue","Annotation",rowDoc));
1262 :
1263 : }
1264 :
1265 :
1266 :
1267 :
1268 :
1269 :
1270 :
1271 :
1272 0 : if (row.isStr("<antennaId>")) {
1273 0 : setAntennaId(Parser::get1DTag("antennaId","Annotation",rowDoc));
1274 : }
1275 :
1276 :
1277 :
1278 :
1279 :
1280 :
1281 :
1282 0 : } catch (const IllegalAccessException &err) {
1283 0 : throw ConversionException (err.getMessage(),"Annotation");
1284 0 : }
1285 0 : }
1286 :
1287 0 : void AnnotationRow::toBin(EndianOSStream& eoss) {
1288 :
1289 :
1290 :
1291 :
1292 :
1293 0 : annotationId.toBin(eoss);
1294 :
1295 :
1296 :
1297 :
1298 :
1299 :
1300 0 : time.toBin(eoss);
1301 :
1302 :
1303 :
1304 :
1305 :
1306 :
1307 :
1308 0 : eoss.writeString(issue);
1309 :
1310 :
1311 :
1312 :
1313 :
1314 :
1315 :
1316 :
1317 0 : eoss.writeString(details);
1318 :
1319 :
1320 :
1321 :
1322 :
1323 :
1324 :
1325 0 : eoss.writeBoolean(numAntennaExists);
1326 0 : if (numAntennaExists) {
1327 :
1328 :
1329 :
1330 :
1331 :
1332 0 : eoss.writeInt(numAntenna);
1333 :
1334 :
1335 :
1336 :
1337 : }
1338 :
1339 0 : eoss.writeBoolean(basebandNameExists);
1340 0 : if (basebandNameExists) {
1341 :
1342 :
1343 :
1344 :
1345 :
1346 :
1347 0 : eoss.writeInt((int) basebandName.size());
1348 0 : for (unsigned int i = 0; i < basebandName.size(); i++)
1349 :
1350 0 : eoss.writeString(CBasebandName::name(basebandName.at(i)));
1351 : /* eoss.writeInt(basebandName.at(i)); */
1352 :
1353 :
1354 :
1355 :
1356 :
1357 :
1358 : }
1359 :
1360 0 : eoss.writeBoolean(numBasebandExists);
1361 0 : if (numBasebandExists) {
1362 :
1363 :
1364 :
1365 :
1366 :
1367 0 : eoss.writeInt(numBaseband);
1368 :
1369 :
1370 :
1371 :
1372 : }
1373 :
1374 0 : eoss.writeBoolean(intervalExists);
1375 0 : if (intervalExists) {
1376 :
1377 :
1378 :
1379 :
1380 0 : interval.toBin(eoss);
1381 :
1382 :
1383 :
1384 : }
1385 :
1386 0 : eoss.writeBoolean(dValueExists);
1387 0 : if (dValueExists) {
1388 :
1389 :
1390 :
1391 :
1392 :
1393 0 : eoss.writeDouble(dValue);
1394 :
1395 :
1396 :
1397 :
1398 : }
1399 :
1400 0 : eoss.writeBoolean(vdValueExists);
1401 0 : if (vdValueExists) {
1402 :
1403 :
1404 :
1405 :
1406 :
1407 :
1408 0 : eoss.writeInt((int) vdValue.size());
1409 0 : for (unsigned int i = 0; i < vdValue.size(); i++)
1410 :
1411 0 : eoss.writeDouble(vdValue.at(i));
1412 :
1413 :
1414 :
1415 :
1416 :
1417 :
1418 : }
1419 :
1420 0 : eoss.writeBoolean(vvdValuesExists);
1421 0 : if (vvdValuesExists) {
1422 :
1423 :
1424 :
1425 :
1426 :
1427 :
1428 0 : eoss.writeInt((int) vvdValues.size());
1429 0 : eoss.writeInt((int) vvdValues.at(0).size());
1430 0 : for (unsigned int i = 0; i < vvdValues.size(); i++)
1431 0 : for (unsigned int j = 0; j < vvdValues.at(0).size(); j++)
1432 :
1433 0 : eoss.writeDouble(vvdValues.at(i).at(j));
1434 :
1435 :
1436 :
1437 :
1438 :
1439 :
1440 : }
1441 :
1442 0 : eoss.writeBoolean(llValueExists);
1443 0 : if (llValueExists) {
1444 :
1445 :
1446 :
1447 :
1448 :
1449 0 : eoss.writeLong(llValue);
1450 :
1451 :
1452 :
1453 :
1454 : }
1455 :
1456 0 : eoss.writeBoolean(vllValueExists);
1457 0 : if (vllValueExists) {
1458 :
1459 :
1460 :
1461 :
1462 :
1463 :
1464 0 : eoss.writeInt((int) vllValue.size());
1465 0 : for (unsigned int i = 0; i < vllValue.size(); i++)
1466 :
1467 0 : eoss.writeLong(vllValue.at(i));
1468 :
1469 :
1470 :
1471 :
1472 :
1473 :
1474 : }
1475 :
1476 0 : eoss.writeBoolean(vvllValueExists);
1477 0 : if (vvllValueExists) {
1478 :
1479 :
1480 :
1481 :
1482 :
1483 :
1484 0 : eoss.writeInt((int) vvllValue.size());
1485 0 : eoss.writeInt((int) vvllValue.at(0).size());
1486 0 : for (unsigned int i = 0; i < vvllValue.size(); i++)
1487 0 : for (unsigned int j = 0; j < vvllValue.at(0).size(); j++)
1488 :
1489 0 : eoss.writeLong(vvllValue.at(i).at(j));
1490 :
1491 :
1492 :
1493 :
1494 :
1495 :
1496 : }
1497 :
1498 0 : eoss.writeBoolean(sValueExists);
1499 0 : if (sValueExists) {
1500 :
1501 :
1502 :
1503 :
1504 :
1505 0 : eoss.writeString(sValue);
1506 :
1507 :
1508 :
1509 :
1510 : }
1511 :
1512 0 : eoss.writeBoolean(antennaIdExists);
1513 0 : if (antennaIdExists) {
1514 :
1515 :
1516 :
1517 :
1518 0 : Tag::toBin(antennaId, eoss);
1519 :
1520 :
1521 :
1522 : }
1523 :
1524 0 : }
1525 :
1526 0 : void AnnotationRow::annotationIdFromBin(EndianIStream& eis) {
1527 :
1528 :
1529 :
1530 :
1531 0 : annotationId = Tag::fromBin(eis);
1532 :
1533 :
1534 :
1535 0 : }
1536 0 : void AnnotationRow::timeFromBin(EndianIStream& eis) {
1537 :
1538 :
1539 :
1540 :
1541 0 : time = ArrayTime::fromBin(eis);
1542 :
1543 :
1544 :
1545 0 : }
1546 0 : void AnnotationRow::issueFromBin(EndianIStream& eis) {
1547 :
1548 :
1549 :
1550 :
1551 :
1552 0 : issue = eis.readString();
1553 :
1554 :
1555 :
1556 :
1557 0 : }
1558 0 : void AnnotationRow::detailsFromBin(EndianIStream& eis) {
1559 :
1560 :
1561 :
1562 :
1563 :
1564 0 : details = eis.readString();
1565 :
1566 :
1567 :
1568 :
1569 0 : }
1570 :
1571 0 : void AnnotationRow::numAntennaFromBin(EndianIStream& eis) {
1572 :
1573 0 : numAntennaExists = eis.readBoolean();
1574 0 : if (numAntennaExists) {
1575 :
1576 :
1577 :
1578 :
1579 :
1580 0 : numAntenna = eis.readInt();
1581 :
1582 :
1583 :
1584 :
1585 : }
1586 :
1587 0 : }
1588 0 : void AnnotationRow::basebandNameFromBin(EndianIStream& eis) {
1589 :
1590 0 : basebandNameExists = eis.readBoolean();
1591 0 : if (basebandNameExists) {
1592 :
1593 :
1594 :
1595 :
1596 :
1597 :
1598 0 : basebandName.clear();
1599 :
1600 0 : unsigned int basebandNameDim1 = eis.readInt();
1601 0 : for (unsigned int i = 0 ; i < basebandNameDim1; i++)
1602 :
1603 0 : basebandName.push_back(CBasebandName::literal(eis.readString()));
1604 :
1605 :
1606 :
1607 :
1608 :
1609 :
1610 : }
1611 :
1612 0 : }
1613 0 : void AnnotationRow::numBasebandFromBin(EndianIStream& eis) {
1614 :
1615 0 : numBasebandExists = eis.readBoolean();
1616 0 : if (numBasebandExists) {
1617 :
1618 :
1619 :
1620 :
1621 :
1622 0 : numBaseband = eis.readInt();
1623 :
1624 :
1625 :
1626 :
1627 : }
1628 :
1629 0 : }
1630 0 : void AnnotationRow::intervalFromBin(EndianIStream& eis) {
1631 :
1632 0 : intervalExists = eis.readBoolean();
1633 0 : if (intervalExists) {
1634 :
1635 :
1636 :
1637 :
1638 0 : interval = Interval::fromBin(eis);
1639 :
1640 :
1641 :
1642 : }
1643 :
1644 0 : }
1645 0 : void AnnotationRow::dValueFromBin(EndianIStream& eis) {
1646 :
1647 0 : dValueExists = eis.readBoolean();
1648 0 : if (dValueExists) {
1649 :
1650 :
1651 :
1652 :
1653 :
1654 0 : dValue = eis.readDouble();
1655 :
1656 :
1657 :
1658 :
1659 : }
1660 :
1661 0 : }
1662 0 : void AnnotationRow::vdValueFromBin(EndianIStream& eis) {
1663 :
1664 0 : vdValueExists = eis.readBoolean();
1665 0 : if (vdValueExists) {
1666 :
1667 :
1668 :
1669 :
1670 :
1671 :
1672 0 : vdValue.clear();
1673 :
1674 0 : unsigned int vdValueDim1 = eis.readInt();
1675 0 : for (unsigned int i = 0 ; i < vdValueDim1; i++)
1676 :
1677 0 : vdValue.push_back(eis.readDouble());
1678 :
1679 :
1680 :
1681 :
1682 :
1683 :
1684 : }
1685 :
1686 0 : }
1687 0 : void AnnotationRow::vvdValuesFromBin(EndianIStream& eis) {
1688 :
1689 0 : vvdValuesExists = eis.readBoolean();
1690 0 : if (vvdValuesExists) {
1691 :
1692 :
1693 :
1694 :
1695 :
1696 :
1697 0 : vvdValues.clear();
1698 :
1699 0 : unsigned int vvdValuesDim1 = eis.readInt();
1700 0 : unsigned int vvdValuesDim2 = eis.readInt();
1701 :
1702 0 : vector <double> vvdValuesAux1;
1703 :
1704 0 : for (unsigned int i = 0; i < vvdValuesDim1; i++) {
1705 0 : vvdValuesAux1.clear();
1706 0 : for (unsigned int j = 0; j < vvdValuesDim2 ; j++)
1707 :
1708 0 : vvdValuesAux1.push_back(eis.readDouble());
1709 :
1710 0 : vvdValues.push_back(vvdValuesAux1);
1711 : }
1712 :
1713 :
1714 :
1715 :
1716 :
1717 :
1718 0 : }
1719 :
1720 0 : }
1721 0 : void AnnotationRow::llValueFromBin(EndianIStream& eis) {
1722 :
1723 0 : llValueExists = eis.readBoolean();
1724 0 : if (llValueExists) {
1725 :
1726 :
1727 :
1728 :
1729 :
1730 0 : llValue = eis.readLong();
1731 :
1732 :
1733 :
1734 :
1735 : }
1736 :
1737 0 : }
1738 0 : void AnnotationRow::vllValueFromBin(EndianIStream& eis) {
1739 :
1740 0 : vllValueExists = eis.readBoolean();
1741 0 : if (vllValueExists) {
1742 :
1743 :
1744 :
1745 :
1746 :
1747 :
1748 0 : vllValue.clear();
1749 :
1750 0 : unsigned int vllValueDim1 = eis.readInt();
1751 0 : for (unsigned int i = 0 ; i < vllValueDim1; i++)
1752 :
1753 0 : vllValue.push_back(eis.readLong());
1754 :
1755 :
1756 :
1757 :
1758 :
1759 :
1760 : }
1761 :
1762 0 : }
1763 0 : void AnnotationRow::vvllValueFromBin(EndianIStream& eis) {
1764 :
1765 0 : vvllValueExists = eis.readBoolean();
1766 0 : if (vvllValueExists) {
1767 :
1768 :
1769 :
1770 :
1771 :
1772 :
1773 0 : vvllValue.clear();
1774 :
1775 0 : unsigned int vvllValueDim1 = eis.readInt();
1776 0 : unsigned int vvllValueDim2 = eis.readInt();
1777 :
1778 0 : vector <int64_t> vvllValueAux1;
1779 :
1780 0 : for (unsigned int i = 0; i < vvllValueDim1; i++) {
1781 0 : vvllValueAux1.clear();
1782 0 : for (unsigned int j = 0; j < vvllValueDim2 ; j++)
1783 :
1784 0 : vvllValueAux1.push_back(eis.readLong());
1785 :
1786 0 : vvllValue.push_back(vvllValueAux1);
1787 : }
1788 :
1789 :
1790 :
1791 :
1792 :
1793 :
1794 0 : }
1795 :
1796 0 : }
1797 0 : void AnnotationRow::sValueFromBin(EndianIStream& eis) {
1798 :
1799 0 : sValueExists = eis.readBoolean();
1800 0 : if (sValueExists) {
1801 :
1802 :
1803 :
1804 :
1805 :
1806 0 : sValue = eis.readString();
1807 :
1808 :
1809 :
1810 :
1811 : }
1812 :
1813 0 : }
1814 0 : void AnnotationRow::antennaIdFromBin(EndianIStream& eis) {
1815 :
1816 0 : antennaIdExists = eis.readBoolean();
1817 0 : if (antennaIdExists) {
1818 :
1819 :
1820 :
1821 :
1822 :
1823 :
1824 0 : antennaId = Tag::from1DBin(eis);
1825 :
1826 :
1827 :
1828 :
1829 :
1830 : }
1831 :
1832 0 : }
1833 :
1834 :
1835 0 : AnnotationRow* AnnotationRow::fromBin(EndianIStream& eis, AnnotationTable& table, const vector<string>& attributesSeq) {
1836 0 : AnnotationRow* row = new AnnotationRow(table);
1837 :
1838 0 : map<string, AnnotationAttributeFromBin>::iterator iter ;
1839 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
1840 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
1841 0 : if (iter != row->fromBinMethods.end()) {
1842 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
1843 : }
1844 : else {
1845 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
1846 0 : if (functorP)
1847 0 : (*functorP)(eis);
1848 : else
1849 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "AnnotationTable");
1850 : }
1851 :
1852 : }
1853 0 : return row;
1854 : }
1855 :
1856 : //
1857 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
1858 : // of one row.
1859 : //
1860 :
1861 : // Convert a string into an Tag
1862 0 : void AnnotationRow::annotationIdFromText(const string & s) {
1863 :
1864 :
1865 0 : annotationId = ASDMValuesParser::parse<Tag>(s);
1866 :
1867 :
1868 0 : }
1869 :
1870 :
1871 : // Convert a string into an ArrayTime
1872 0 : void AnnotationRow::timeFromText(const string & s) {
1873 :
1874 :
1875 0 : time = ASDMValuesParser::parse<ArrayTime>(s);
1876 :
1877 :
1878 0 : }
1879 :
1880 :
1881 : // Convert a string into an String
1882 0 : void AnnotationRow::issueFromText(const string & s) {
1883 :
1884 :
1885 0 : issue = ASDMValuesParser::parse<string>(s);
1886 :
1887 :
1888 0 : }
1889 :
1890 :
1891 : // Convert a string into an String
1892 0 : void AnnotationRow::detailsFromText(const string & s) {
1893 :
1894 :
1895 0 : details = ASDMValuesParser::parse<string>(s);
1896 :
1897 :
1898 0 : }
1899 :
1900 :
1901 :
1902 : // Convert a string into an int
1903 0 : void AnnotationRow::numAntennaFromText(const string & s) {
1904 0 : numAntennaExists = true;
1905 :
1906 :
1907 0 : numAntenna = ASDMValuesParser::parse<int>(s);
1908 :
1909 :
1910 0 : }
1911 :
1912 :
1913 : // Convert a string into an BasebandName
1914 0 : void AnnotationRow::basebandNameFromText(const string & s) {
1915 0 : basebandNameExists = true;
1916 :
1917 :
1918 0 : basebandName = ASDMValuesParser::parse1D<BasebandNameMod::BasebandName>(s);
1919 :
1920 :
1921 0 : }
1922 :
1923 :
1924 : // Convert a string into an int
1925 0 : void AnnotationRow::numBasebandFromText(const string & s) {
1926 0 : numBasebandExists = true;
1927 :
1928 :
1929 0 : numBaseband = ASDMValuesParser::parse<int>(s);
1930 :
1931 :
1932 0 : }
1933 :
1934 :
1935 : // Convert a string into an Interval
1936 0 : void AnnotationRow::intervalFromText(const string & s) {
1937 0 : intervalExists = true;
1938 :
1939 :
1940 0 : interval = ASDMValuesParser::parse<Interval>(s);
1941 :
1942 :
1943 0 : }
1944 :
1945 :
1946 : // Convert a string into an double
1947 0 : void AnnotationRow::dValueFromText(const string & s) {
1948 0 : dValueExists = true;
1949 :
1950 :
1951 0 : dValue = ASDMValuesParser::parse<double>(s);
1952 :
1953 :
1954 0 : }
1955 :
1956 :
1957 : // Convert a string into an double
1958 0 : void AnnotationRow::vdValueFromText(const string & s) {
1959 0 : vdValueExists = true;
1960 :
1961 :
1962 0 : vdValue = ASDMValuesParser::parse1D<double>(s);
1963 :
1964 :
1965 0 : }
1966 :
1967 :
1968 : // Convert a string into an double
1969 0 : void AnnotationRow::vvdValuesFromText(const string & s) {
1970 0 : vvdValuesExists = true;
1971 :
1972 :
1973 0 : vvdValues = ASDMValuesParser::parse2D<double>(s);
1974 :
1975 :
1976 0 : }
1977 :
1978 :
1979 : // Convert a string into an long
1980 0 : void AnnotationRow::llValueFromText(const string & s) {
1981 0 : llValueExists = true;
1982 :
1983 :
1984 0 : llValue = ASDMValuesParser::parse<int64_t>(s);
1985 :
1986 :
1987 0 : }
1988 :
1989 :
1990 : // Convert a string into an long
1991 0 : void AnnotationRow::vllValueFromText(const string & s) {
1992 0 : vllValueExists = true;
1993 :
1994 :
1995 0 : vllValue = ASDMValuesParser::parse1D<int64_t>(s);
1996 :
1997 :
1998 0 : }
1999 :
2000 :
2001 : // Convert a string into an long
2002 0 : void AnnotationRow::vvllValueFromText(const string & s) {
2003 0 : vvllValueExists = true;
2004 :
2005 :
2006 0 : vvllValue = ASDMValuesParser::parse2D<int64_t>(s);
2007 :
2008 :
2009 0 : }
2010 :
2011 :
2012 : // Convert a string into an String
2013 0 : void AnnotationRow::sValueFromText(const string & s) {
2014 0 : sValueExists = true;
2015 :
2016 :
2017 0 : sValue = ASDMValuesParser::parse<string>(s);
2018 :
2019 :
2020 0 : }
2021 :
2022 :
2023 : // Convert a string into an Tag
2024 0 : void AnnotationRow::antennaIdFromText(const string & s) {
2025 0 : antennaIdExists = true;
2026 :
2027 :
2028 0 : antennaId = ASDMValuesParser::parse1D<Tag>(s);
2029 :
2030 :
2031 0 : }
2032 :
2033 :
2034 :
2035 0 : void AnnotationRow::fromText(const std::string& attributeName, const std::string& t) {
2036 0 : map<string, AnnotationAttributeFromText>::iterator iter;
2037 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
2038 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "AnnotationTable");
2039 0 : (this->*(iter->second))(t);
2040 0 : }
2041 :
2042 : ////////////////////////////////////////////////
2043 : // Intrinsic Table Attributes getters/setters //
2044 : ////////////////////////////////////////////////
2045 :
2046 :
2047 :
2048 :
2049 : /**
2050 : * Get annotationId.
2051 : * @return annotationId as Tag
2052 : */
2053 0 : Tag AnnotationRow::getAnnotationId() const {
2054 :
2055 0 : return annotationId;
2056 : }
2057 :
2058 : /**
2059 : * Set annotationId with the specified Tag.
2060 : * @param annotationId The Tag value to which annotationId is to be set.
2061 :
2062 :
2063 :
2064 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
2065 :
2066 : */
2067 0 : void AnnotationRow::setAnnotationId (Tag annotationId) {
2068 :
2069 :
2070 0 : if (hasBeenAdded) {
2071 :
2072 0 : throw IllegalAccessException("annotationId", "Annotation");
2073 :
2074 : }
2075 :
2076 0 : this->annotationId = annotationId;
2077 :
2078 0 : }
2079 :
2080 :
2081 :
2082 :
2083 :
2084 :
2085 : /**
2086 : * Get time.
2087 : * @return time as ArrayTime
2088 : */
2089 0 : ArrayTime AnnotationRow::getTime() const {
2090 :
2091 0 : return time;
2092 : }
2093 :
2094 : /**
2095 : * Set time with the specified ArrayTime.
2096 : * @param time The ArrayTime value to which time is to be set.
2097 :
2098 :
2099 :
2100 : */
2101 0 : void AnnotationRow::setTime (ArrayTime time) {
2102 :
2103 :
2104 0 : if (hasBeenAdded) {
2105 :
2106 : }
2107 :
2108 0 : this->time = time;
2109 :
2110 0 : }
2111 :
2112 :
2113 :
2114 :
2115 :
2116 :
2117 : /**
2118 : * Get issue.
2119 : * @return issue as std::string
2120 : */
2121 0 : std::string AnnotationRow::getIssue() const {
2122 :
2123 0 : return issue;
2124 : }
2125 :
2126 : /**
2127 : * Set issue with the specified std::string.
2128 : * @param issue The std::string value to which issue is to be set.
2129 :
2130 :
2131 :
2132 : */
2133 0 : void AnnotationRow::setIssue (std::string issue) {
2134 :
2135 :
2136 0 : if (hasBeenAdded) {
2137 :
2138 : }
2139 :
2140 0 : this->issue = issue;
2141 :
2142 0 : }
2143 :
2144 :
2145 :
2146 :
2147 :
2148 :
2149 : /**
2150 : * Get details.
2151 : * @return details as std::string
2152 : */
2153 0 : std::string AnnotationRow::getDetails() const {
2154 :
2155 0 : return details;
2156 : }
2157 :
2158 : /**
2159 : * Set details with the specified std::string.
2160 : * @param details The std::string value to which details is to be set.
2161 :
2162 :
2163 :
2164 : */
2165 0 : void AnnotationRow::setDetails (std::string details) {
2166 :
2167 :
2168 0 : if (hasBeenAdded) {
2169 :
2170 : }
2171 :
2172 0 : this->details = details;
2173 :
2174 0 : }
2175 :
2176 :
2177 :
2178 :
2179 : /**
2180 : * The attribute numAntenna is optional. Return true if this attribute exists.
2181 : * @return true if and only if the numAntenna attribute exists.
2182 : */
2183 0 : bool AnnotationRow::isNumAntennaExists() const {
2184 0 : return numAntennaExists;
2185 : }
2186 :
2187 :
2188 :
2189 : /**
2190 : * Get numAntenna, which is optional.
2191 : * @return numAntenna as int
2192 : * @throw IllegalAccessException If numAntenna does not exist.
2193 : */
2194 0 : int AnnotationRow::getNumAntenna() const {
2195 0 : if (!numAntennaExists) {
2196 0 : throw IllegalAccessException("numAntenna", "Annotation");
2197 : }
2198 :
2199 0 : return numAntenna;
2200 : }
2201 :
2202 : /**
2203 : * Set numAntenna with the specified int.
2204 : * @param numAntenna The int value to which numAntenna is to be set.
2205 :
2206 :
2207 : */
2208 0 : void AnnotationRow::setNumAntenna (int numAntenna) {
2209 :
2210 0 : this->numAntenna = numAntenna;
2211 :
2212 0 : numAntennaExists = true;
2213 :
2214 0 : }
2215 :
2216 :
2217 : /**
2218 : * Mark numAntenna, which is an optional field, as non-existent.
2219 : */
2220 0 : void AnnotationRow::clearNumAntenna () {
2221 0 : numAntennaExists = false;
2222 0 : }
2223 :
2224 :
2225 :
2226 : /**
2227 : * The attribute basebandName is optional. Return true if this attribute exists.
2228 : * @return true if and only if the basebandName attribute exists.
2229 : */
2230 0 : bool AnnotationRow::isBasebandNameExists() const {
2231 0 : return basebandNameExists;
2232 : }
2233 :
2234 :
2235 :
2236 : /**
2237 : * Get basebandName, which is optional.
2238 : * @return basebandName as std::vector<BasebandNameMod::BasebandName >
2239 : * @throw IllegalAccessException If basebandName does not exist.
2240 : */
2241 0 : std::vector<BasebandNameMod::BasebandName > AnnotationRow::getBasebandName() const {
2242 0 : if (!basebandNameExists) {
2243 0 : throw IllegalAccessException("basebandName", "Annotation");
2244 : }
2245 :
2246 0 : return basebandName;
2247 : }
2248 :
2249 : /**
2250 : * Set basebandName with the specified std::vector<BasebandNameMod::BasebandName >.
2251 : * @param basebandName The std::vector<BasebandNameMod::BasebandName > value to which basebandName is to be set.
2252 :
2253 :
2254 : */
2255 0 : void AnnotationRow::setBasebandName (std::vector<BasebandNameMod::BasebandName > basebandName) {
2256 :
2257 0 : this->basebandName = basebandName;
2258 :
2259 0 : basebandNameExists = true;
2260 :
2261 0 : }
2262 :
2263 :
2264 : /**
2265 : * Mark basebandName, which is an optional field, as non-existent.
2266 : */
2267 0 : void AnnotationRow::clearBasebandName () {
2268 0 : basebandNameExists = false;
2269 0 : }
2270 :
2271 :
2272 :
2273 : /**
2274 : * The attribute numBaseband is optional. Return true if this attribute exists.
2275 : * @return true if and only if the numBaseband attribute exists.
2276 : */
2277 0 : bool AnnotationRow::isNumBasebandExists() const {
2278 0 : return numBasebandExists;
2279 : }
2280 :
2281 :
2282 :
2283 : /**
2284 : * Get numBaseband, which is optional.
2285 : * @return numBaseband as int
2286 : * @throw IllegalAccessException If numBaseband does not exist.
2287 : */
2288 0 : int AnnotationRow::getNumBaseband() const {
2289 0 : if (!numBasebandExists) {
2290 0 : throw IllegalAccessException("numBaseband", "Annotation");
2291 : }
2292 :
2293 0 : return numBaseband;
2294 : }
2295 :
2296 : /**
2297 : * Set numBaseband with the specified int.
2298 : * @param numBaseband The int value to which numBaseband is to be set.
2299 :
2300 :
2301 : */
2302 0 : void AnnotationRow::setNumBaseband (int numBaseband) {
2303 :
2304 0 : this->numBaseband = numBaseband;
2305 :
2306 0 : numBasebandExists = true;
2307 :
2308 0 : }
2309 :
2310 :
2311 : /**
2312 : * Mark numBaseband, which is an optional field, as non-existent.
2313 : */
2314 0 : void AnnotationRow::clearNumBaseband () {
2315 0 : numBasebandExists = false;
2316 0 : }
2317 :
2318 :
2319 :
2320 : /**
2321 : * The attribute interval is optional. Return true if this attribute exists.
2322 : * @return true if and only if the interval attribute exists.
2323 : */
2324 0 : bool AnnotationRow::isIntervalExists() const {
2325 0 : return intervalExists;
2326 : }
2327 :
2328 :
2329 :
2330 : /**
2331 : * Get interval, which is optional.
2332 : * @return interval as Interval
2333 : * @throw IllegalAccessException If interval does not exist.
2334 : */
2335 0 : Interval AnnotationRow::getInterval() const {
2336 0 : if (!intervalExists) {
2337 0 : throw IllegalAccessException("interval", "Annotation");
2338 : }
2339 :
2340 0 : return interval;
2341 : }
2342 :
2343 : /**
2344 : * Set interval with the specified Interval.
2345 : * @param interval The Interval value to which interval is to be set.
2346 :
2347 :
2348 : */
2349 0 : void AnnotationRow::setInterval (Interval interval) {
2350 :
2351 0 : this->interval = interval;
2352 :
2353 0 : intervalExists = true;
2354 :
2355 0 : }
2356 :
2357 :
2358 : /**
2359 : * Mark interval, which is an optional field, as non-existent.
2360 : */
2361 0 : void AnnotationRow::clearInterval () {
2362 0 : intervalExists = false;
2363 0 : }
2364 :
2365 :
2366 :
2367 : /**
2368 : * The attribute dValue is optional. Return true if this attribute exists.
2369 : * @return true if and only if the dValue attribute exists.
2370 : */
2371 0 : bool AnnotationRow::isDValueExists() const {
2372 0 : return dValueExists;
2373 : }
2374 :
2375 :
2376 :
2377 : /**
2378 : * Get dValue, which is optional.
2379 : * @return dValue as double
2380 : * @throw IllegalAccessException If dValue does not exist.
2381 : */
2382 0 : double AnnotationRow::getDValue() const {
2383 0 : if (!dValueExists) {
2384 0 : throw IllegalAccessException("dValue", "Annotation");
2385 : }
2386 :
2387 0 : return dValue;
2388 : }
2389 :
2390 : /**
2391 : * Set dValue with the specified double.
2392 : * @param dValue The double value to which dValue is to be set.
2393 :
2394 :
2395 : */
2396 0 : void AnnotationRow::setDValue (double dValue) {
2397 :
2398 0 : this->dValue = dValue;
2399 :
2400 0 : dValueExists = true;
2401 :
2402 0 : }
2403 :
2404 :
2405 : /**
2406 : * Mark dValue, which is an optional field, as non-existent.
2407 : */
2408 0 : void AnnotationRow::clearDValue () {
2409 0 : dValueExists = false;
2410 0 : }
2411 :
2412 :
2413 :
2414 : /**
2415 : * The attribute vdValue is optional. Return true if this attribute exists.
2416 : * @return true if and only if the vdValue attribute exists.
2417 : */
2418 0 : bool AnnotationRow::isVdValueExists() const {
2419 0 : return vdValueExists;
2420 : }
2421 :
2422 :
2423 :
2424 : /**
2425 : * Get vdValue, which is optional.
2426 : * @return vdValue as std::vector<double >
2427 : * @throw IllegalAccessException If vdValue does not exist.
2428 : */
2429 0 : std::vector<double > AnnotationRow::getVdValue() const {
2430 0 : if (!vdValueExists) {
2431 0 : throw IllegalAccessException("vdValue", "Annotation");
2432 : }
2433 :
2434 0 : return vdValue;
2435 : }
2436 :
2437 : /**
2438 : * Set vdValue with the specified std::vector<double >.
2439 : * @param vdValue The std::vector<double > value to which vdValue is to be set.
2440 :
2441 :
2442 : */
2443 0 : void AnnotationRow::setVdValue (std::vector<double > vdValue) {
2444 :
2445 0 : this->vdValue = vdValue;
2446 :
2447 0 : vdValueExists = true;
2448 :
2449 0 : }
2450 :
2451 :
2452 : /**
2453 : * Mark vdValue, which is an optional field, as non-existent.
2454 : */
2455 0 : void AnnotationRow::clearVdValue () {
2456 0 : vdValueExists = false;
2457 0 : }
2458 :
2459 :
2460 :
2461 : /**
2462 : * The attribute vvdValues is optional. Return true if this attribute exists.
2463 : * @return true if and only if the vvdValues attribute exists.
2464 : */
2465 0 : bool AnnotationRow::isVvdValuesExists() const {
2466 0 : return vvdValuesExists;
2467 : }
2468 :
2469 :
2470 :
2471 : /**
2472 : * Get vvdValues, which is optional.
2473 : * @return vvdValues as std::vector<std::vector<double > >
2474 : * @throw IllegalAccessException If vvdValues does not exist.
2475 : */
2476 0 : std::vector<std::vector<double > > AnnotationRow::getVvdValues() const {
2477 0 : if (!vvdValuesExists) {
2478 0 : throw IllegalAccessException("vvdValues", "Annotation");
2479 : }
2480 :
2481 0 : return vvdValues;
2482 : }
2483 :
2484 : /**
2485 : * Set vvdValues with the specified std::vector<std::vector<double > >.
2486 : * @param vvdValues The std::vector<std::vector<double > > value to which vvdValues is to be set.
2487 :
2488 :
2489 : */
2490 0 : void AnnotationRow::setVvdValues (std::vector<std::vector<double > > vvdValues) {
2491 :
2492 0 : this->vvdValues = vvdValues;
2493 :
2494 0 : vvdValuesExists = true;
2495 :
2496 0 : }
2497 :
2498 :
2499 : /**
2500 : * Mark vvdValues, which is an optional field, as non-existent.
2501 : */
2502 0 : void AnnotationRow::clearVvdValues () {
2503 0 : vvdValuesExists = false;
2504 0 : }
2505 :
2506 :
2507 :
2508 : /**
2509 : * The attribute llValue is optional. Return true if this attribute exists.
2510 : * @return true if and only if the llValue attribute exists.
2511 : */
2512 0 : bool AnnotationRow::isLlValueExists() const {
2513 0 : return llValueExists;
2514 : }
2515 :
2516 :
2517 :
2518 : /**
2519 : * Get llValue, which is optional.
2520 : * @return llValue as int64_t
2521 : * @throw IllegalAccessException If llValue does not exist.
2522 : */
2523 0 : int64_t AnnotationRow::getLlValue() const {
2524 0 : if (!llValueExists) {
2525 0 : throw IllegalAccessException("llValue", "Annotation");
2526 : }
2527 :
2528 0 : return llValue;
2529 : }
2530 :
2531 : /**
2532 : * Set llValue with the specified int64_t.
2533 : * @param llValue The int64_t value to which llValue is to be set.
2534 :
2535 :
2536 : */
2537 0 : void AnnotationRow::setLlValue (int64_t llValue) {
2538 :
2539 0 : this->llValue = llValue;
2540 :
2541 0 : llValueExists = true;
2542 :
2543 0 : }
2544 :
2545 :
2546 : /**
2547 : * Mark llValue, which is an optional field, as non-existent.
2548 : */
2549 0 : void AnnotationRow::clearLlValue () {
2550 0 : llValueExists = false;
2551 0 : }
2552 :
2553 :
2554 :
2555 : /**
2556 : * The attribute vllValue is optional. Return true if this attribute exists.
2557 : * @return true if and only if the vllValue attribute exists.
2558 : */
2559 0 : bool AnnotationRow::isVllValueExists() const {
2560 0 : return vllValueExists;
2561 : }
2562 :
2563 :
2564 :
2565 : /**
2566 : * Get vllValue, which is optional.
2567 : * @return vllValue as std::vector<int64_t >
2568 : * @throw IllegalAccessException If vllValue does not exist.
2569 : */
2570 0 : std::vector<int64_t > AnnotationRow::getVllValue() const {
2571 0 : if (!vllValueExists) {
2572 0 : throw IllegalAccessException("vllValue", "Annotation");
2573 : }
2574 :
2575 0 : return vllValue;
2576 : }
2577 :
2578 : /**
2579 : * Set vllValue with the specified std::vector<int64_t >.
2580 : * @param vllValue The std::vector<int64_t > value to which vllValue is to be set.
2581 :
2582 :
2583 : */
2584 0 : void AnnotationRow::setVllValue (std::vector<int64_t > vllValue) {
2585 :
2586 0 : this->vllValue = vllValue;
2587 :
2588 0 : vllValueExists = true;
2589 :
2590 0 : }
2591 :
2592 :
2593 : /**
2594 : * Mark vllValue, which is an optional field, as non-existent.
2595 : */
2596 0 : void AnnotationRow::clearVllValue () {
2597 0 : vllValueExists = false;
2598 0 : }
2599 :
2600 :
2601 :
2602 : /**
2603 : * The attribute vvllValue is optional. Return true if this attribute exists.
2604 : * @return true if and only if the vvllValue attribute exists.
2605 : */
2606 0 : bool AnnotationRow::isVvllValueExists() const {
2607 0 : return vvllValueExists;
2608 : }
2609 :
2610 :
2611 :
2612 : /**
2613 : * Get vvllValue, which is optional.
2614 : * @return vvllValue as std::vector<std::vector<int64_t > >
2615 : * @throw IllegalAccessException If vvllValue does not exist.
2616 : */
2617 0 : std::vector<std::vector<int64_t > > AnnotationRow::getVvllValue() const {
2618 0 : if (!vvllValueExists) {
2619 0 : throw IllegalAccessException("vvllValue", "Annotation");
2620 : }
2621 :
2622 0 : return vvllValue;
2623 : }
2624 :
2625 : /**
2626 : * Set vvllValue with the specified std::vector<std::vector<int64_t > >.
2627 : * @param vvllValue The std::vector<std::vector<int64_t > > value to which vvllValue is to be set.
2628 :
2629 :
2630 : */
2631 0 : void AnnotationRow::setVvllValue (std::vector<std::vector<int64_t > > vvllValue) {
2632 :
2633 0 : this->vvllValue = vvllValue;
2634 :
2635 0 : vvllValueExists = true;
2636 :
2637 0 : }
2638 :
2639 :
2640 : /**
2641 : * Mark vvllValue, which is an optional field, as non-existent.
2642 : */
2643 0 : void AnnotationRow::clearVvllValue () {
2644 0 : vvllValueExists = false;
2645 0 : }
2646 :
2647 :
2648 :
2649 : /**
2650 : * The attribute sValue is optional. Return true if this attribute exists.
2651 : * @return true if and only if the sValue attribute exists.
2652 : */
2653 0 : bool AnnotationRow::isSValueExists() const {
2654 0 : return sValueExists;
2655 : }
2656 :
2657 :
2658 :
2659 : /**
2660 : * Get sValue, which is optional.
2661 : * @return sValue as std::string
2662 : * @throw IllegalAccessException If sValue does not exist.
2663 : */
2664 0 : std::string AnnotationRow::getSValue() const {
2665 0 : if (!sValueExists) {
2666 0 : throw IllegalAccessException("sValue", "Annotation");
2667 : }
2668 :
2669 0 : return sValue;
2670 : }
2671 :
2672 : /**
2673 : * Set sValue with the specified std::string.
2674 : * @param sValue The std::string value to which sValue is to be set.
2675 :
2676 :
2677 : */
2678 0 : void AnnotationRow::setSValue (std::string sValue) {
2679 :
2680 0 : this->sValue = sValue;
2681 :
2682 0 : sValueExists = true;
2683 :
2684 0 : }
2685 :
2686 :
2687 : /**
2688 : * Mark sValue, which is an optional field, as non-existent.
2689 : */
2690 0 : void AnnotationRow::clearSValue () {
2691 0 : sValueExists = false;
2692 0 : }
2693 :
2694 :
2695 :
2696 : ///////////////////////////////////////////////
2697 : // Extrinsic Table Attributes getters/setters//
2698 : ///////////////////////////////////////////////
2699 :
2700 :
2701 : /**
2702 : * The attribute antennaId is optional. Return true if this attribute exists.
2703 : * @return true if and only if the antennaId attribute exists.
2704 : */
2705 0 : bool AnnotationRow::isAntennaIdExists() const {
2706 0 : return antennaIdExists;
2707 : }
2708 :
2709 :
2710 :
2711 : /**
2712 : * Get antennaId, which is optional.
2713 : * @return antennaId as std::vector<Tag>
2714 : * @throw IllegalAccessException If antennaId does not exist.
2715 : */
2716 0 : std::vector<Tag> AnnotationRow::getAntennaId() const {
2717 0 : if (!antennaIdExists) {
2718 0 : throw IllegalAccessException("antennaId", "Annotation");
2719 : }
2720 :
2721 0 : return antennaId;
2722 : }
2723 :
2724 : /**
2725 : * Set antennaId with the specified std::vector<Tag> .
2726 : * @param antennaId The std::vector<Tag> value to which antennaId is to be set.
2727 :
2728 :
2729 : */
2730 0 : void AnnotationRow::setAntennaId (std::vector<Tag> antennaId) {
2731 :
2732 0 : this->antennaId = antennaId;
2733 :
2734 0 : antennaIdExists = true;
2735 :
2736 0 : }
2737 :
2738 :
2739 : /**
2740 : * Mark antennaId, which is an optional field, as non-existent.
2741 : */
2742 0 : void AnnotationRow::clearAntennaId () {
2743 0 : antennaIdExists = false;
2744 0 : }
2745 :
2746 :
2747 :
2748 : //////////////////////////////////////
2749 : // Links Attributes getters/setters //
2750 : //////////////////////////////////////
2751 :
2752 :
2753 :
2754 : /**
2755 : * Set antennaId[i] with the specified Tag.
2756 : * @param i The index in antennaId where to set the Tag value.
2757 : * @param antennaId The Tag value to which antennaId[i] is to be set.
2758 : * @throws OutOfBoundsException
2759 : */
2760 0 : void AnnotationRow::setAntennaId (int i, Tag antennaId) {
2761 0 : if ((i < 0) || (i > ((int) this->antennaId.size())))
2762 0 : throw OutOfBoundsException("Index out of bounds during a set operation on attribute antennaId in table AnnotationTable");
2763 0 : std::vector<Tag> ::iterator iter = this->antennaId.begin();
2764 0 : int j = 0;
2765 0 : while (j < i) {
2766 0 : j++; iter++;
2767 : }
2768 0 : this->antennaId.insert(this->antennaId.erase(iter), antennaId);
2769 0 : }
2770 :
2771 :
2772 :
2773 :
2774 :
2775 : /**
2776 : * Append a Tag to antennaId.
2777 : * @param id the Tag to be appended to antennaId
2778 : */
2779 0 : void AnnotationRow::addAntennaId(Tag id){
2780 0 : antennaId.push_back(id);
2781 0 : }
2782 :
2783 : /**
2784 : * Append an array of Tag to antennaId.
2785 : * @param id an array of Tag to be appended to antennaId
2786 : */
2787 0 : void AnnotationRow::addAntennaId(const std::vector<Tag> & id) {
2788 0 : for (unsigned int i=0; i < id.size(); i++)
2789 0 : antennaId.push_back(id.at(i));
2790 0 : }
2791 :
2792 :
2793 : /**
2794 : * Returns the Tag stored in antennaId at position i.
2795 : *
2796 : */
2797 0 : const Tag AnnotationRow::getAntennaId(int i) {
2798 0 : return antennaId.at(i);
2799 : }
2800 :
2801 : /**
2802 : * Returns the AntennaRow linked to this row via the Tag stored in antennaId
2803 : * at position i.
2804 : */
2805 0 : AntennaRow* AnnotationRow::getAntennaUsingAntennaId(int i) {
2806 0 : return table.getContainer().getAntenna().getRowByKey(antennaId.at(i));
2807 : }
2808 :
2809 : /**
2810 : * Returns the vector of AntennaRow* linked to this row via the Tags stored in antennaId
2811 : *
2812 : */
2813 0 : vector<AntennaRow *> AnnotationRow::getAntennasUsingAntennaId() {
2814 0 : vector<AntennaRow *> result;
2815 0 : for (unsigned int i = 0; i < antennaId.size(); i++)
2816 0 : result.push_back(table.getContainer().getAntenna().getRowByKey(antennaId.at(i)));
2817 :
2818 0 : return result;
2819 0 : }
2820 :
2821 :
2822 :
2823 :
2824 :
2825 : /**
2826 : * Create a AnnotationRow.
2827 : * <p>
2828 : * This constructor is private because only the
2829 : * table can create rows. All rows know the table
2830 : * to which they belong.
2831 : * @param table The table to which this row belongs.
2832 : */
2833 0 : AnnotationRow::AnnotationRow (AnnotationTable &t) : table(t) {
2834 0 : hasBeenAdded = false;
2835 :
2836 :
2837 :
2838 :
2839 :
2840 :
2841 :
2842 :
2843 :
2844 :
2845 :
2846 0 : numAntennaExists = false;
2847 :
2848 :
2849 :
2850 0 : basebandNameExists = false;
2851 :
2852 :
2853 :
2854 0 : numBasebandExists = false;
2855 :
2856 :
2857 :
2858 0 : intervalExists = false;
2859 :
2860 :
2861 :
2862 0 : dValueExists = false;
2863 :
2864 :
2865 :
2866 0 : vdValueExists = false;
2867 :
2868 :
2869 :
2870 0 : vvdValuesExists = false;
2871 :
2872 :
2873 :
2874 0 : llValueExists = false;
2875 :
2876 :
2877 :
2878 0 : vllValueExists = false;
2879 :
2880 :
2881 :
2882 0 : vvllValueExists = false;
2883 :
2884 :
2885 :
2886 0 : sValueExists = false;
2887 :
2888 :
2889 :
2890 :
2891 0 : antennaIdExists = false;
2892 :
2893 :
2894 :
2895 :
2896 :
2897 :
2898 :
2899 :
2900 :
2901 :
2902 :
2903 :
2904 :
2905 :
2906 :
2907 :
2908 :
2909 :
2910 :
2911 :
2912 :
2913 :
2914 :
2915 :
2916 :
2917 :
2918 :
2919 :
2920 :
2921 :
2922 :
2923 :
2924 :
2925 :
2926 :
2927 :
2928 :
2929 0 : fromBinMethods["annotationId"] = &AnnotationRow::annotationIdFromBin;
2930 0 : fromBinMethods["time"] = &AnnotationRow::timeFromBin;
2931 0 : fromBinMethods["issue"] = &AnnotationRow::issueFromBin;
2932 0 : fromBinMethods["details"] = &AnnotationRow::detailsFromBin;
2933 :
2934 :
2935 0 : fromBinMethods["numAntenna"] = &AnnotationRow::numAntennaFromBin;
2936 0 : fromBinMethods["basebandName"] = &AnnotationRow::basebandNameFromBin;
2937 0 : fromBinMethods["numBaseband"] = &AnnotationRow::numBasebandFromBin;
2938 0 : fromBinMethods["interval"] = &AnnotationRow::intervalFromBin;
2939 0 : fromBinMethods["dValue"] = &AnnotationRow::dValueFromBin;
2940 0 : fromBinMethods["vdValue"] = &AnnotationRow::vdValueFromBin;
2941 0 : fromBinMethods["vvdValues"] = &AnnotationRow::vvdValuesFromBin;
2942 0 : fromBinMethods["llValue"] = &AnnotationRow::llValueFromBin;
2943 0 : fromBinMethods["vllValue"] = &AnnotationRow::vllValueFromBin;
2944 0 : fromBinMethods["vvllValue"] = &AnnotationRow::vvllValueFromBin;
2945 0 : fromBinMethods["sValue"] = &AnnotationRow::sValueFromBin;
2946 0 : fromBinMethods["antennaId"] = &AnnotationRow::antennaIdFromBin;
2947 :
2948 :
2949 :
2950 :
2951 :
2952 0 : fromTextMethods["annotationId"] = &AnnotationRow::annotationIdFromText;
2953 :
2954 :
2955 :
2956 0 : fromTextMethods["time"] = &AnnotationRow::timeFromText;
2957 :
2958 :
2959 :
2960 0 : fromTextMethods["issue"] = &AnnotationRow::issueFromText;
2961 :
2962 :
2963 :
2964 0 : fromTextMethods["details"] = &AnnotationRow::detailsFromText;
2965 :
2966 :
2967 :
2968 :
2969 :
2970 0 : fromTextMethods["numAntenna"] = &AnnotationRow::numAntennaFromText;
2971 :
2972 :
2973 :
2974 0 : fromTextMethods["basebandName"] = &AnnotationRow::basebandNameFromText;
2975 :
2976 :
2977 :
2978 0 : fromTextMethods["numBaseband"] = &AnnotationRow::numBasebandFromText;
2979 :
2980 :
2981 :
2982 0 : fromTextMethods["interval"] = &AnnotationRow::intervalFromText;
2983 :
2984 :
2985 :
2986 0 : fromTextMethods["dValue"] = &AnnotationRow::dValueFromText;
2987 :
2988 :
2989 :
2990 0 : fromTextMethods["vdValue"] = &AnnotationRow::vdValueFromText;
2991 :
2992 :
2993 :
2994 0 : fromTextMethods["vvdValues"] = &AnnotationRow::vvdValuesFromText;
2995 :
2996 :
2997 :
2998 0 : fromTextMethods["llValue"] = &AnnotationRow::llValueFromText;
2999 :
3000 :
3001 :
3002 0 : fromTextMethods["vllValue"] = &AnnotationRow::vllValueFromText;
3003 :
3004 :
3005 :
3006 0 : fromTextMethods["vvllValue"] = &AnnotationRow::vvllValueFromText;
3007 :
3008 :
3009 :
3010 0 : fromTextMethods["sValue"] = &AnnotationRow::sValueFromText;
3011 :
3012 :
3013 :
3014 0 : fromTextMethods["antennaId"] = &AnnotationRow::antennaIdFromText;
3015 :
3016 :
3017 0 : }
3018 :
3019 0 : AnnotationRow::AnnotationRow (AnnotationTable &t, AnnotationRow *row) : table(t) {
3020 0 : hasBeenAdded = false;
3021 :
3022 0 : if (row == 0) {
3023 :
3024 :
3025 :
3026 :
3027 :
3028 :
3029 :
3030 :
3031 :
3032 :
3033 :
3034 0 : numAntennaExists = false;
3035 :
3036 :
3037 :
3038 0 : basebandNameExists = false;
3039 :
3040 :
3041 :
3042 0 : numBasebandExists = false;
3043 :
3044 :
3045 :
3046 0 : intervalExists = false;
3047 :
3048 :
3049 :
3050 0 : dValueExists = false;
3051 :
3052 :
3053 :
3054 0 : vdValueExists = false;
3055 :
3056 :
3057 :
3058 0 : vvdValuesExists = false;
3059 :
3060 :
3061 :
3062 0 : llValueExists = false;
3063 :
3064 :
3065 :
3066 0 : vllValueExists = false;
3067 :
3068 :
3069 :
3070 0 : vvllValueExists = false;
3071 :
3072 :
3073 :
3074 0 : sValueExists = false;
3075 :
3076 :
3077 :
3078 :
3079 0 : antennaIdExists = false;
3080 :
3081 :
3082 : }
3083 : else {
3084 :
3085 :
3086 0 : annotationId = row->annotationId;
3087 :
3088 :
3089 :
3090 :
3091 0 : time = row->time;
3092 :
3093 0 : issue = row->issue;
3094 :
3095 0 : details = row->details;
3096 :
3097 :
3098 :
3099 :
3100 0 : if (row->numAntennaExists) {
3101 0 : numAntenna = row->numAntenna;
3102 0 : numAntennaExists = true;
3103 : }
3104 : else
3105 0 : numAntennaExists = false;
3106 :
3107 0 : if (row->basebandNameExists) {
3108 0 : basebandName = row->basebandName;
3109 0 : basebandNameExists = true;
3110 : }
3111 : else
3112 0 : basebandNameExists = false;
3113 :
3114 0 : if (row->numBasebandExists) {
3115 0 : numBaseband = row->numBaseband;
3116 0 : numBasebandExists = true;
3117 : }
3118 : else
3119 0 : numBasebandExists = false;
3120 :
3121 0 : if (row->intervalExists) {
3122 0 : interval = row->interval;
3123 0 : intervalExists = true;
3124 : }
3125 : else
3126 0 : intervalExists = false;
3127 :
3128 0 : if (row->dValueExists) {
3129 0 : dValue = row->dValue;
3130 0 : dValueExists = true;
3131 : }
3132 : else
3133 0 : dValueExists = false;
3134 :
3135 0 : if (row->vdValueExists) {
3136 0 : vdValue = row->vdValue;
3137 0 : vdValueExists = true;
3138 : }
3139 : else
3140 0 : vdValueExists = false;
3141 :
3142 0 : if (row->vvdValuesExists) {
3143 0 : vvdValues = row->vvdValues;
3144 0 : vvdValuesExists = true;
3145 : }
3146 : else
3147 0 : vvdValuesExists = false;
3148 :
3149 0 : if (row->llValueExists) {
3150 0 : llValue = row->llValue;
3151 0 : llValueExists = true;
3152 : }
3153 : else
3154 0 : llValueExists = false;
3155 :
3156 0 : if (row->vllValueExists) {
3157 0 : vllValue = row->vllValue;
3158 0 : vllValueExists = true;
3159 : }
3160 : else
3161 0 : vllValueExists = false;
3162 :
3163 0 : if (row->vvllValueExists) {
3164 0 : vvllValue = row->vvllValue;
3165 0 : vvllValueExists = true;
3166 : }
3167 : else
3168 0 : vvllValueExists = false;
3169 :
3170 0 : if (row->sValueExists) {
3171 0 : sValue = row->sValue;
3172 0 : sValueExists = true;
3173 : }
3174 : else
3175 0 : sValueExists = false;
3176 :
3177 0 : if (row->antennaIdExists) {
3178 0 : antennaId = row->antennaId;
3179 0 : antennaIdExists = true;
3180 : }
3181 : else
3182 0 : antennaIdExists = false;
3183 :
3184 : }
3185 :
3186 0 : fromBinMethods["annotationId"] = &AnnotationRow::annotationIdFromBin;
3187 0 : fromBinMethods["time"] = &AnnotationRow::timeFromBin;
3188 0 : fromBinMethods["issue"] = &AnnotationRow::issueFromBin;
3189 0 : fromBinMethods["details"] = &AnnotationRow::detailsFromBin;
3190 :
3191 :
3192 0 : fromBinMethods["numAntenna"] = &AnnotationRow::numAntennaFromBin;
3193 0 : fromBinMethods["basebandName"] = &AnnotationRow::basebandNameFromBin;
3194 0 : fromBinMethods["numBaseband"] = &AnnotationRow::numBasebandFromBin;
3195 0 : fromBinMethods["interval"] = &AnnotationRow::intervalFromBin;
3196 0 : fromBinMethods["dValue"] = &AnnotationRow::dValueFromBin;
3197 0 : fromBinMethods["vdValue"] = &AnnotationRow::vdValueFromBin;
3198 0 : fromBinMethods["vvdValues"] = &AnnotationRow::vvdValuesFromBin;
3199 0 : fromBinMethods["llValue"] = &AnnotationRow::llValueFromBin;
3200 0 : fromBinMethods["vllValue"] = &AnnotationRow::vllValueFromBin;
3201 0 : fromBinMethods["vvllValue"] = &AnnotationRow::vvllValueFromBin;
3202 0 : fromBinMethods["sValue"] = &AnnotationRow::sValueFromBin;
3203 0 : fromBinMethods["antennaId"] = &AnnotationRow::antennaIdFromBin;
3204 :
3205 0 : }
3206 :
3207 :
3208 0 : bool AnnotationRow::compareNoAutoInc(ArrayTime time, std::string issue, std::string details) {
3209 : bool result;
3210 0 : result = true;
3211 :
3212 :
3213 :
3214 0 : result = result && (this->time == time);
3215 :
3216 0 : if (!result) return false;
3217 :
3218 :
3219 :
3220 :
3221 0 : result = result && (this->issue == issue);
3222 :
3223 0 : if (!result) return false;
3224 :
3225 :
3226 :
3227 :
3228 0 : result = result && (this->details == details);
3229 :
3230 0 : if (!result) return false;
3231 :
3232 :
3233 0 : return result;
3234 : }
3235 :
3236 :
3237 :
3238 0 : bool AnnotationRow::compareRequiredValue(ArrayTime time, std::string issue, std::string details) {
3239 : bool result;
3240 0 : result = true;
3241 :
3242 :
3243 0 : if (!(this->time == time)) return false;
3244 :
3245 :
3246 :
3247 0 : if (!(this->issue == issue)) return false;
3248 :
3249 :
3250 :
3251 0 : if (!(this->details == details)) return false;
3252 :
3253 :
3254 0 : return result;
3255 : }
3256 :
3257 :
3258 : /**
3259 : * Return true if all required attributes of the value part are equal to their homologues
3260 : * in x and false otherwise.
3261 : *
3262 :
3263 : * @param x a pointer on the AnnotationRow whose required attributes of the value part
3264 :
3265 : * will be compared with those of this.
3266 : * @return a boolean.
3267 : */
3268 0 : bool AnnotationRow::equalByRequiredValue(AnnotationRow* x ) {
3269 :
3270 :
3271 0 : if (this->time != x->time) return false;
3272 :
3273 0 : if (this->issue != x->issue) return false;
3274 :
3275 0 : if (this->details != x->details) return false;
3276 :
3277 :
3278 0 : return true;
3279 : }
3280 :
3281 : /*
3282 : map<string, AnnotationAttributeFromBin> AnnotationRow::initFromBinMethods() {
3283 : map<string, AnnotationAttributeFromBin> result;
3284 :
3285 : result["annotationId"] = &AnnotationRow::annotationIdFromBin;
3286 : result["time"] = &AnnotationRow::timeFromBin;
3287 : result["issue"] = &AnnotationRow::issueFromBin;
3288 : result["details"] = &AnnotationRow::detailsFromBin;
3289 :
3290 :
3291 : result["numAntenna"] = &AnnotationRow::numAntennaFromBin;
3292 : result["basebandName"] = &AnnotationRow::basebandNameFromBin;
3293 : result["numBaseband"] = &AnnotationRow::numBasebandFromBin;
3294 : result["interval"] = &AnnotationRow::intervalFromBin;
3295 : result["dValue"] = &AnnotationRow::dValueFromBin;
3296 : result["vdValue"] = &AnnotationRow::vdValueFromBin;
3297 : result["vvdValues"] = &AnnotationRow::vvdValuesFromBin;
3298 : result["llValue"] = &AnnotationRow::llValueFromBin;
3299 : result["vllValue"] = &AnnotationRow::vllValueFromBin;
3300 : result["vvllValue"] = &AnnotationRow::vvllValueFromBin;
3301 : result["sValue"] = &AnnotationRow::sValueFromBin;
3302 : result["antennaId"] = &AnnotationRow::antennaIdFromBin;
3303 :
3304 :
3305 : return result;
3306 : }
3307 : */
3308 : } // End namespace asdm
3309 :
|
