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 FieldRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/FieldRow.h>
39 : #include <alma/ASDM/FieldTable.h>
40 :
41 : #include <alma/ASDM/EphemerisTable.h>
42 : #include <alma/ASDM/EphemerisRow.h>
43 :
44 : #include <alma/ASDM/SourceTable.h>
45 : #include <alma/ASDM/SourceRow.h>
46 :
47 : #include <alma/ASDM/FieldTable.h>
48 : #include <alma/ASDM/FieldRow.h>
49 :
50 :
51 : using asdm::ASDM;
52 : using asdm::FieldRow;
53 : using asdm::FieldTable;
54 :
55 : using asdm::EphemerisTable;
56 : using asdm::EphemerisRow;
57 :
58 : using asdm::SourceTable;
59 : using asdm::SourceRow;
60 :
61 : using asdm::FieldTable;
62 : using asdm::FieldRow;
63 :
64 :
65 : #include <alma/ASDM/Parser.h>
66 :
67 : #include <alma/ASDM/EnumerationParser.h>
68 : #include <alma/ASDM/ASDMValuesParser.h>
69 :
70 : #include <alma/ASDM/InvalidArgumentException.h>
71 :
72 : using namespace std;
73 :
74 : namespace asdm {
75 956 : FieldRow::~FieldRow() {
76 956 : }
77 :
78 : /**
79 : * Return the table to which this row belongs.
80 : */
81 9 : FieldTable &FieldRow::getTable() const {
82 9 : return table;
83 : }
84 :
85 0 : bool FieldRow::isAdded() const {
86 0 : return hasBeenAdded;
87 : }
88 :
89 478 : void FieldRow::isAdded(bool added) {
90 478 : hasBeenAdded = added;
91 478 : }
92 :
93 : #ifndef WITHOUT_ACS
94 : using asdmIDL::FieldRowIDL;
95 : #endif
96 :
97 : #ifndef WITHOUT_ACS
98 : /**
99 : * Return this row in the form of an IDL struct.
100 : * @return The values of this row as a FieldRowIDL struct.
101 : */
102 : FieldRowIDL *FieldRow::toIDL() const {
103 : FieldRowIDL *x = new FieldRowIDL ();
104 :
105 : // Fill the IDL structure.
106 :
107 :
108 :
109 :
110 :
111 :
112 :
113 : x->fieldId = fieldId.toIDLTag();
114 :
115 :
116 :
117 :
118 :
119 :
120 :
121 :
122 :
123 :
124 : x->fieldName = CORBA::string_dup(fieldName.c_str());
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 :
135 :
136 : x->numPoly = numPoly;
137 :
138 :
139 :
140 :
141 :
142 :
143 :
144 :
145 :
146 :
147 : x->delayDir.length(delayDir.size());
148 : for (unsigned int i = 0; i < delayDir.size(); i++) {
149 : x->delayDir[i].length(delayDir.at(i).size());
150 : }
151 :
152 : for (unsigned int i = 0; i < delayDir.size() ; i++)
153 : for (unsigned int j = 0; j < delayDir.at(i).size(); j++)
154 :
155 : x->delayDir[i][j]= delayDir.at(i).at(j).toIDLAngle();
156 :
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 :
165 :
166 :
167 : x->phaseDir.length(phaseDir.size());
168 : for (unsigned int i = 0; i < phaseDir.size(); i++) {
169 : x->phaseDir[i].length(phaseDir.at(i).size());
170 : }
171 :
172 : for (unsigned int i = 0; i < phaseDir.size() ; i++)
173 : for (unsigned int j = 0; j < phaseDir.at(i).size(); j++)
174 :
175 : x->phaseDir[i][j]= phaseDir.at(i).at(j).toIDLAngle();
176 :
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 :
185 :
186 :
187 : x->referenceDir.length(referenceDir.size());
188 : for (unsigned int i = 0; i < referenceDir.size(); i++) {
189 : x->referenceDir[i].length(referenceDir.at(i).size());
190 : }
191 :
192 : for (unsigned int i = 0; i < referenceDir.size() ; i++)
193 : for (unsigned int j = 0; j < referenceDir.at(i).size(); j++)
194 :
195 : x->referenceDir[i][j]= referenceDir.at(i).at(j).toIDLAngle();
196 :
197 :
198 :
199 :
200 :
201 :
202 :
203 :
204 :
205 : x->timeExists = timeExists;
206 :
207 :
208 :
209 : x->time = time.toIDLArrayTime();
210 :
211 :
212 :
213 :
214 :
215 :
216 :
217 : x->codeExists = codeExists;
218 :
219 :
220 :
221 :
222 : x->code = CORBA::string_dup(code.c_str());
223 :
224 :
225 :
226 :
227 :
228 :
229 :
230 :
231 : x->directionCodeExists = directionCodeExists;
232 :
233 :
234 :
235 :
236 : x->directionCode = directionCode;
237 :
238 :
239 :
240 :
241 :
242 :
243 :
244 :
245 : x->directionEquinoxExists = directionEquinoxExists;
246 :
247 :
248 :
249 : x->directionEquinox = directionEquinox.toIDLArrayTime();
250 :
251 :
252 :
253 :
254 :
255 :
256 :
257 : x->assocNatureExists = assocNatureExists;
258 :
259 :
260 :
261 :
262 : x->assocNature = CORBA::string_dup(assocNature.c_str());
263 :
264 :
265 :
266 :
267 :
268 :
269 :
270 :
271 :
272 :
273 :
274 :
275 : x->assocFieldIdExists = assocFieldIdExists;
276 :
277 :
278 :
279 :
280 : x->assocFieldId = assocFieldId.toIDLTag();
281 :
282 :
283 :
284 :
285 :
286 :
287 :
288 :
289 : x->ephemerisIdExists = ephemerisIdExists;
290 :
291 :
292 :
293 :
294 :
295 : x->ephemerisId = ephemerisId;
296 :
297 :
298 :
299 :
300 :
301 :
302 :
303 :
304 :
305 : x->sourceIdExists = sourceIdExists;
306 :
307 :
308 :
309 :
310 :
311 : x->sourceId = sourceId;
312 :
313 :
314 :
315 :
316 :
317 :
318 :
319 :
320 :
321 :
322 :
323 :
324 :
325 :
326 : return x;
327 :
328 : }
329 :
330 : void FieldRow::toIDL(asdmIDL::FieldRowIDL& x) const {
331 : // Set the x's fields.
332 :
333 :
334 :
335 :
336 :
337 :
338 :
339 : x.fieldId = fieldId.toIDLTag();
340 :
341 :
342 :
343 :
344 :
345 :
346 :
347 :
348 :
349 :
350 : x.fieldName = CORBA::string_dup(fieldName.c_str());
351 :
352 :
353 :
354 :
355 :
356 :
357 :
358 :
359 :
360 :
361 :
362 : x.numPoly = numPoly;
363 :
364 :
365 :
366 :
367 :
368 :
369 :
370 :
371 :
372 :
373 : x.delayDir.length(delayDir.size());
374 : for (unsigned int i = 0; i < delayDir.size(); i++) {
375 : x.delayDir[i].length(delayDir.at(i).size());
376 : }
377 :
378 : for (unsigned int i = 0; i < delayDir.size() ; i++)
379 : for (unsigned int j = 0; j < delayDir.at(i).size(); j++)
380 :
381 : x.delayDir[i][j]= delayDir.at(i).at(j).toIDLAngle();
382 :
383 :
384 :
385 :
386 :
387 :
388 :
389 :
390 :
391 :
392 :
393 : x.phaseDir.length(phaseDir.size());
394 : for (unsigned int i = 0; i < phaseDir.size(); i++) {
395 : x.phaseDir[i].length(phaseDir.at(i).size());
396 : }
397 :
398 : for (unsigned int i = 0; i < phaseDir.size() ; i++)
399 : for (unsigned int j = 0; j < phaseDir.at(i).size(); j++)
400 :
401 : x.phaseDir[i][j]= phaseDir.at(i).at(j).toIDLAngle();
402 :
403 :
404 :
405 :
406 :
407 :
408 :
409 :
410 :
411 :
412 :
413 : x.referenceDir.length(referenceDir.size());
414 : for (unsigned int i = 0; i < referenceDir.size(); i++) {
415 : x.referenceDir[i].length(referenceDir.at(i).size());
416 : }
417 :
418 : for (unsigned int i = 0; i < referenceDir.size() ; i++)
419 : for (unsigned int j = 0; j < referenceDir.at(i).size(); j++)
420 :
421 : x.referenceDir[i][j]= referenceDir.at(i).at(j).toIDLAngle();
422 :
423 :
424 :
425 :
426 :
427 :
428 :
429 :
430 :
431 : x.timeExists = timeExists;
432 :
433 :
434 :
435 : x.time = time.toIDLArrayTime();
436 :
437 :
438 :
439 :
440 :
441 :
442 :
443 : x.codeExists = codeExists;
444 :
445 :
446 :
447 :
448 : x.code = CORBA::string_dup(code.c_str());
449 :
450 :
451 :
452 :
453 :
454 :
455 :
456 :
457 : x.directionCodeExists = directionCodeExists;
458 :
459 :
460 :
461 :
462 : x.directionCode = directionCode;
463 :
464 :
465 :
466 :
467 :
468 :
469 :
470 :
471 : x.directionEquinoxExists = directionEquinoxExists;
472 :
473 :
474 :
475 : x.directionEquinox = directionEquinox.toIDLArrayTime();
476 :
477 :
478 :
479 :
480 :
481 :
482 :
483 : x.assocNatureExists = assocNatureExists;
484 :
485 :
486 :
487 :
488 : x.assocNature = CORBA::string_dup(assocNature.c_str());
489 :
490 :
491 :
492 :
493 :
494 :
495 :
496 :
497 :
498 :
499 :
500 :
501 : x.assocFieldIdExists = assocFieldIdExists;
502 :
503 :
504 :
505 :
506 : x.assocFieldId = assocFieldId.toIDLTag();
507 :
508 :
509 :
510 :
511 :
512 :
513 :
514 :
515 : x.ephemerisIdExists = ephemerisIdExists;
516 :
517 :
518 :
519 :
520 :
521 : x.ephemerisId = ephemerisId;
522 :
523 :
524 :
525 :
526 :
527 :
528 :
529 :
530 :
531 : x.sourceIdExists = sourceIdExists;
532 :
533 :
534 :
535 :
536 :
537 : x.sourceId = sourceId;
538 :
539 :
540 :
541 :
542 :
543 :
544 :
545 :
546 :
547 :
548 :
549 :
550 :
551 :
552 : }
553 : #endif
554 :
555 :
556 : #ifndef WITHOUT_ACS
557 : /**
558 : * Fill the values of this row from the IDL struct FieldRowIDL.
559 : * @param x The IDL struct containing the values used to fill this row.
560 : */
561 : void FieldRow::setFromIDL (FieldRowIDL x){
562 : try {
563 : // Fill the values from x.
564 :
565 :
566 :
567 :
568 :
569 :
570 : setFieldId(Tag (x.fieldId));
571 :
572 :
573 :
574 :
575 :
576 :
577 :
578 :
579 :
580 : setFieldName(string (x.fieldName));
581 :
582 :
583 :
584 :
585 :
586 :
587 :
588 :
589 :
590 : setNumPoly(x.numPoly);
591 :
592 :
593 :
594 :
595 :
596 :
597 :
598 :
599 :
600 : delayDir .clear();
601 :
602 : vector<Angle> v_aux_delayDir;
603 :
604 : for (unsigned int i = 0; i < x.delayDir.length(); ++i) {
605 : v_aux_delayDir.clear();
606 : for (unsigned int j = 0; j < x.delayDir[0].length(); ++j) {
607 :
608 : v_aux_delayDir.push_back(Angle (x.delayDir[i][j]));
609 :
610 : }
611 : delayDir.push_back(v_aux_delayDir);
612 : }
613 :
614 :
615 :
616 :
617 :
618 :
619 :
620 :
621 :
622 : phaseDir .clear();
623 :
624 : vector<Angle> v_aux_phaseDir;
625 :
626 : for (unsigned int i = 0; i < x.phaseDir.length(); ++i) {
627 : v_aux_phaseDir.clear();
628 : for (unsigned int j = 0; j < x.phaseDir[0].length(); ++j) {
629 :
630 : v_aux_phaseDir.push_back(Angle (x.phaseDir[i][j]));
631 :
632 : }
633 : phaseDir.push_back(v_aux_phaseDir);
634 : }
635 :
636 :
637 :
638 :
639 :
640 :
641 :
642 :
643 :
644 : referenceDir .clear();
645 :
646 : vector<Angle> v_aux_referenceDir;
647 :
648 : for (unsigned int i = 0; i < x.referenceDir.length(); ++i) {
649 : v_aux_referenceDir.clear();
650 : for (unsigned int j = 0; j < x.referenceDir[0].length(); ++j) {
651 :
652 : v_aux_referenceDir.push_back(Angle (x.referenceDir[i][j]));
653 :
654 : }
655 : referenceDir.push_back(v_aux_referenceDir);
656 : }
657 :
658 :
659 :
660 :
661 :
662 :
663 :
664 : timeExists = x.timeExists;
665 : if (x.timeExists) {
666 :
667 :
668 :
669 : setTime(ArrayTime (x.time));
670 :
671 :
672 :
673 : }
674 :
675 :
676 :
677 :
678 :
679 : codeExists = x.codeExists;
680 : if (x.codeExists) {
681 :
682 :
683 :
684 : setCode(string (x.code));
685 :
686 :
687 :
688 : }
689 :
690 :
691 :
692 :
693 :
694 : directionCodeExists = x.directionCodeExists;
695 : if (x.directionCodeExists) {
696 :
697 :
698 :
699 : setDirectionCode(x.directionCode);
700 :
701 :
702 :
703 : }
704 :
705 :
706 :
707 :
708 :
709 : directionEquinoxExists = x.directionEquinoxExists;
710 : if (x.directionEquinoxExists) {
711 :
712 :
713 :
714 : setDirectionEquinox(ArrayTime (x.directionEquinox));
715 :
716 :
717 :
718 : }
719 :
720 :
721 :
722 :
723 :
724 : assocNatureExists = x.assocNatureExists;
725 : if (x.assocNatureExists) {
726 :
727 :
728 :
729 : setAssocNature(string (x.assocNature));
730 :
731 :
732 :
733 : }
734 :
735 :
736 :
737 :
738 :
739 :
740 :
741 :
742 : assocFieldIdExists = x.assocFieldIdExists;
743 : if (x.assocFieldIdExists) {
744 :
745 :
746 :
747 : setAssocFieldId(Tag (x.assocFieldId));
748 :
749 :
750 :
751 : }
752 :
753 :
754 :
755 :
756 :
757 : ephemerisIdExists = x.ephemerisIdExists;
758 : if (x.ephemerisIdExists) {
759 :
760 :
761 :
762 : setEphemerisId(x.ephemerisId);
763 :
764 :
765 :
766 : }
767 :
768 :
769 :
770 :
771 :
772 : sourceIdExists = x.sourceIdExists;
773 : if (x.sourceIdExists) {
774 :
775 :
776 :
777 : setSourceId(x.sourceId);
778 :
779 :
780 :
781 : }
782 :
783 :
784 :
785 :
786 :
787 :
788 :
789 :
790 :
791 :
792 :
793 : } catch (const IllegalAccessException &err) {
794 : throw ConversionException (err.getMessage(),"Field");
795 : }
796 : }
797 : #endif
798 :
799 : /**
800 : * Return this row in the form of an XML string.
801 : * @return The values of this row as an XML string.
802 : */
803 249 : string FieldRow::toXML() const {
804 249 : string buf;
805 249 : buf.append("<row> \n");
806 :
807 :
808 :
809 :
810 :
811 :
812 249 : Parser::toXML(fieldId, "fieldId", buf);
813 :
814 :
815 :
816 :
817 :
818 :
819 :
820 249 : Parser::toXML(fieldName, "fieldName", buf);
821 :
822 :
823 :
824 :
825 :
826 :
827 :
828 249 : Parser::toXML(numPoly, "numPoly", buf);
829 :
830 :
831 :
832 :
833 :
834 :
835 :
836 249 : Parser::toXML(delayDir, "delayDir", buf);
837 :
838 :
839 :
840 :
841 :
842 :
843 :
844 249 : Parser::toXML(phaseDir, "phaseDir", buf);
845 :
846 :
847 :
848 :
849 :
850 :
851 :
852 249 : Parser::toXML(referenceDir, "referenceDir", buf);
853 :
854 :
855 :
856 :
857 :
858 :
859 249 : if (timeExists) {
860 :
861 :
862 249 : Parser::toXML(time, "time", buf);
863 :
864 :
865 : }
866 :
867 :
868 :
869 :
870 :
871 249 : if (codeExists) {
872 :
873 :
874 249 : Parser::toXML(code, "code", buf);
875 :
876 :
877 : }
878 :
879 :
880 :
881 :
882 :
883 249 : if (directionCodeExists) {
884 :
885 :
886 249 : buf.append(EnumerationParser::toXML("directionCode", directionCode));
887 :
888 :
889 : }
890 :
891 :
892 :
893 :
894 :
895 249 : if (directionEquinoxExists) {
896 :
897 :
898 0 : Parser::toXML(directionEquinox, "directionEquinox", buf);
899 :
900 :
901 : }
902 :
903 :
904 :
905 :
906 :
907 249 : if (assocNatureExists) {
908 :
909 :
910 0 : Parser::toXML(assocNature, "assocNature", buf);
911 :
912 :
913 : }
914 :
915 :
916 :
917 :
918 :
919 :
920 :
921 :
922 249 : if (assocFieldIdExists) {
923 :
924 :
925 0 : Parser::toXML(assocFieldId, "assocFieldId", buf);
926 :
927 :
928 : }
929 :
930 :
931 :
932 :
933 :
934 249 : if (ephemerisIdExists) {
935 :
936 :
937 0 : Parser::toXML(ephemerisId, "ephemerisId", buf);
938 :
939 :
940 : }
941 :
942 :
943 :
944 :
945 :
946 249 : if (sourceIdExists) {
947 :
948 :
949 249 : Parser::toXML(sourceId, "sourceId", buf);
950 :
951 :
952 : }
953 :
954 :
955 :
956 :
957 :
958 :
959 :
960 :
961 :
962 :
963 :
964 :
965 249 : buf.append("</row>\n");
966 249 : return buf;
967 : }
968 :
969 : /**
970 : * Fill the values of this row from an XML string
971 : * that was produced by the toXML() method.
972 : * @param x The XML string being used to set the values of this row.
973 : */
974 223 : void FieldRow::setFromXML (string rowDoc) {
975 446 : Parser row(rowDoc);
976 446 : string s = "";
977 : try {
978 :
979 :
980 :
981 :
982 :
983 223 : setFieldId(Parser::getTag("fieldId","Field",rowDoc));
984 :
985 :
986 :
987 :
988 :
989 :
990 :
991 223 : setFieldName(Parser::getString("fieldName","Field",rowDoc));
992 :
993 :
994 :
995 :
996 :
997 :
998 :
999 223 : setNumPoly(Parser::getInteger("numPoly","Field",rowDoc));
1000 :
1001 :
1002 :
1003 :
1004 :
1005 :
1006 :
1007 :
1008 223 : setDelayDir(Parser::get2DAngle("delayDir","Field",rowDoc));
1009 :
1010 :
1011 :
1012 :
1013 :
1014 :
1015 :
1016 :
1017 :
1018 223 : setPhaseDir(Parser::get2DAngle("phaseDir","Field",rowDoc));
1019 :
1020 :
1021 :
1022 :
1023 :
1024 :
1025 :
1026 :
1027 :
1028 223 : setReferenceDir(Parser::get2DAngle("referenceDir","Field",rowDoc));
1029 :
1030 :
1031 :
1032 :
1033 :
1034 :
1035 :
1036 223 : if (row.isStr("<time>")) {
1037 :
1038 223 : setTime(Parser::getArrayTime("time","Field",rowDoc));
1039 :
1040 : }
1041 :
1042 :
1043 :
1044 :
1045 :
1046 223 : if (row.isStr("<code>")) {
1047 :
1048 223 : setCode(Parser::getString("code","Field",rowDoc));
1049 :
1050 : }
1051 :
1052 :
1053 :
1054 :
1055 :
1056 223 : if (row.isStr("<directionCode>")) {
1057 :
1058 :
1059 :
1060 192 : directionCode = EnumerationParser::getDirectionReferenceCode("directionCode","Field",rowDoc);
1061 :
1062 :
1063 :
1064 192 : directionCodeExists = true;
1065 : }
1066 :
1067 :
1068 :
1069 :
1070 :
1071 223 : if (row.isStr("<directionEquinox>")) {
1072 :
1073 0 : setDirectionEquinox(Parser::getArrayTime("directionEquinox","Field",rowDoc));
1074 :
1075 : }
1076 :
1077 :
1078 :
1079 :
1080 :
1081 223 : if (row.isStr("<assocNature>")) {
1082 :
1083 0 : setAssocNature(Parser::getString("assocNature","Field",rowDoc));
1084 :
1085 : }
1086 :
1087 :
1088 :
1089 :
1090 :
1091 :
1092 :
1093 :
1094 223 : if (row.isStr("<assocFieldId>")) {
1095 :
1096 0 : setAssocFieldId(Parser::getTag("assocFieldId","Field",rowDoc));
1097 :
1098 : }
1099 :
1100 :
1101 :
1102 :
1103 :
1104 223 : if (row.isStr("<ephemerisId>")) {
1105 :
1106 9 : setEphemerisId(Parser::getInteger("ephemerisId","Field",rowDoc));
1107 :
1108 : }
1109 :
1110 :
1111 :
1112 :
1113 :
1114 223 : if (row.isStr("<sourceId>")) {
1115 :
1116 223 : setSourceId(Parser::getInteger("sourceId","Field",rowDoc));
1117 :
1118 : }
1119 :
1120 :
1121 :
1122 :
1123 :
1124 :
1125 :
1126 :
1127 :
1128 :
1129 :
1130 0 : } catch (const IllegalAccessException &err) {
1131 0 : throw ConversionException (err.getMessage(),"Field");
1132 : }
1133 223 : }
1134 :
1135 0 : void FieldRow::toBin(EndianOSStream& eoss) {
1136 :
1137 :
1138 :
1139 :
1140 :
1141 0 : fieldId.toBin(eoss);
1142 :
1143 :
1144 :
1145 :
1146 :
1147 :
1148 :
1149 0 : eoss.writeString(fieldName);
1150 :
1151 :
1152 :
1153 :
1154 :
1155 :
1156 :
1157 :
1158 0 : eoss.writeInt(numPoly);
1159 :
1160 :
1161 :
1162 :
1163 :
1164 :
1165 :
1166 0 : Angle::toBin(delayDir, eoss);
1167 :
1168 :
1169 :
1170 :
1171 :
1172 :
1173 0 : Angle::toBin(phaseDir, eoss);
1174 :
1175 :
1176 :
1177 :
1178 :
1179 :
1180 0 : Angle::toBin(referenceDir, eoss);
1181 :
1182 :
1183 :
1184 :
1185 :
1186 :
1187 0 : eoss.writeBoolean(timeExists);
1188 0 : if (timeExists) {
1189 :
1190 :
1191 :
1192 :
1193 0 : time.toBin(eoss);
1194 :
1195 :
1196 :
1197 : }
1198 :
1199 0 : eoss.writeBoolean(codeExists);
1200 0 : if (codeExists) {
1201 :
1202 :
1203 :
1204 :
1205 :
1206 0 : eoss.writeString(code);
1207 :
1208 :
1209 :
1210 :
1211 : }
1212 :
1213 0 : eoss.writeBoolean(directionCodeExists);
1214 0 : if (directionCodeExists) {
1215 :
1216 :
1217 :
1218 :
1219 :
1220 0 : eoss.writeString(CDirectionReferenceCode::name(directionCode));
1221 : /* eoss.writeInt(directionCode); */
1222 :
1223 :
1224 :
1225 :
1226 : }
1227 :
1228 0 : eoss.writeBoolean(directionEquinoxExists);
1229 0 : if (directionEquinoxExists) {
1230 :
1231 :
1232 :
1233 :
1234 0 : directionEquinox.toBin(eoss);
1235 :
1236 :
1237 :
1238 : }
1239 :
1240 0 : eoss.writeBoolean(assocNatureExists);
1241 0 : if (assocNatureExists) {
1242 :
1243 :
1244 :
1245 :
1246 :
1247 0 : eoss.writeString(assocNature);
1248 :
1249 :
1250 :
1251 :
1252 : }
1253 :
1254 0 : eoss.writeBoolean(ephemerisIdExists);
1255 0 : if (ephemerisIdExists) {
1256 :
1257 :
1258 :
1259 :
1260 :
1261 0 : eoss.writeInt(ephemerisId);
1262 :
1263 :
1264 :
1265 :
1266 : }
1267 :
1268 0 : eoss.writeBoolean(sourceIdExists);
1269 0 : if (sourceIdExists) {
1270 :
1271 :
1272 :
1273 :
1274 :
1275 0 : eoss.writeInt(sourceId);
1276 :
1277 :
1278 :
1279 :
1280 : }
1281 :
1282 0 : eoss.writeBoolean(assocFieldIdExists);
1283 0 : if (assocFieldIdExists) {
1284 :
1285 :
1286 :
1287 :
1288 0 : assocFieldId.toBin(eoss);
1289 :
1290 :
1291 :
1292 : }
1293 :
1294 0 : }
1295 :
1296 0 : void FieldRow::fieldIdFromBin(EndianIStream& eis) {
1297 :
1298 :
1299 :
1300 :
1301 0 : fieldId = Tag::fromBin(eis);
1302 :
1303 :
1304 :
1305 0 : }
1306 0 : void FieldRow::fieldNameFromBin(EndianIStream& eis) {
1307 :
1308 :
1309 :
1310 :
1311 :
1312 0 : fieldName = eis.readString();
1313 :
1314 :
1315 :
1316 :
1317 0 : }
1318 0 : void FieldRow::numPolyFromBin(EndianIStream& eis) {
1319 :
1320 :
1321 :
1322 :
1323 :
1324 0 : numPoly = eis.readInt();
1325 :
1326 :
1327 :
1328 :
1329 0 : }
1330 0 : void FieldRow::delayDirFromBin(EndianIStream& eis) {
1331 :
1332 :
1333 :
1334 :
1335 :
1336 :
1337 0 : delayDir = Angle::from2DBin(eis);
1338 :
1339 :
1340 :
1341 :
1342 :
1343 0 : }
1344 0 : void FieldRow::phaseDirFromBin(EndianIStream& eis) {
1345 :
1346 :
1347 :
1348 :
1349 :
1350 :
1351 0 : phaseDir = Angle::from2DBin(eis);
1352 :
1353 :
1354 :
1355 :
1356 :
1357 0 : }
1358 0 : void FieldRow::referenceDirFromBin(EndianIStream& eis) {
1359 :
1360 :
1361 :
1362 :
1363 :
1364 :
1365 0 : referenceDir = Angle::from2DBin(eis);
1366 :
1367 :
1368 :
1369 :
1370 :
1371 0 : }
1372 :
1373 0 : void FieldRow::timeFromBin(EndianIStream& eis) {
1374 :
1375 0 : timeExists = eis.readBoolean();
1376 0 : if (timeExists) {
1377 :
1378 :
1379 :
1380 :
1381 0 : time = ArrayTime::fromBin(eis);
1382 :
1383 :
1384 :
1385 : }
1386 :
1387 0 : }
1388 0 : void FieldRow::codeFromBin(EndianIStream& eis) {
1389 :
1390 0 : codeExists = eis.readBoolean();
1391 0 : if (codeExists) {
1392 :
1393 :
1394 :
1395 :
1396 :
1397 0 : code = eis.readString();
1398 :
1399 :
1400 :
1401 :
1402 : }
1403 :
1404 0 : }
1405 0 : void FieldRow::directionCodeFromBin(EndianIStream& eis) {
1406 :
1407 0 : directionCodeExists = eis.readBoolean();
1408 0 : if (directionCodeExists) {
1409 :
1410 :
1411 :
1412 :
1413 :
1414 0 : directionCode = CDirectionReferenceCode::literal(eis.readString());
1415 :
1416 :
1417 :
1418 :
1419 : }
1420 :
1421 0 : }
1422 0 : void FieldRow::directionEquinoxFromBin(EndianIStream& eis) {
1423 :
1424 0 : directionEquinoxExists = eis.readBoolean();
1425 0 : if (directionEquinoxExists) {
1426 :
1427 :
1428 :
1429 :
1430 0 : directionEquinox = ArrayTime::fromBin(eis);
1431 :
1432 :
1433 :
1434 : }
1435 :
1436 0 : }
1437 0 : void FieldRow::assocNatureFromBin(EndianIStream& eis) {
1438 :
1439 0 : assocNatureExists = eis.readBoolean();
1440 0 : if (assocNatureExists) {
1441 :
1442 :
1443 :
1444 :
1445 :
1446 0 : assocNature = eis.readString();
1447 :
1448 :
1449 :
1450 :
1451 : }
1452 :
1453 0 : }
1454 0 : void FieldRow::ephemerisIdFromBin(EndianIStream& eis) {
1455 :
1456 0 : ephemerisIdExists = eis.readBoolean();
1457 0 : if (ephemerisIdExists) {
1458 :
1459 :
1460 :
1461 :
1462 :
1463 0 : ephemerisId = eis.readInt();
1464 :
1465 :
1466 :
1467 :
1468 : }
1469 :
1470 0 : }
1471 0 : void FieldRow::sourceIdFromBin(EndianIStream& eis) {
1472 :
1473 0 : sourceIdExists = eis.readBoolean();
1474 0 : if (sourceIdExists) {
1475 :
1476 :
1477 :
1478 :
1479 :
1480 0 : sourceId = eis.readInt();
1481 :
1482 :
1483 :
1484 :
1485 : }
1486 :
1487 0 : }
1488 0 : void FieldRow::assocFieldIdFromBin(EndianIStream& eis) {
1489 :
1490 0 : assocFieldIdExists = eis.readBoolean();
1491 0 : if (assocFieldIdExists) {
1492 :
1493 :
1494 :
1495 :
1496 0 : assocFieldId = Tag::fromBin(eis);
1497 :
1498 :
1499 :
1500 : }
1501 :
1502 0 : }
1503 :
1504 :
1505 0 : FieldRow* FieldRow::fromBin(EndianIStream& eis, FieldTable& table, const vector<string>& attributesSeq) {
1506 0 : FieldRow* row = new FieldRow(table);
1507 :
1508 0 : map<string, FieldAttributeFromBin>::iterator iter ;
1509 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
1510 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
1511 0 : if (iter != row->fromBinMethods.end()) {
1512 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
1513 : }
1514 : else {
1515 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
1516 0 : if (functorP)
1517 0 : (*functorP)(eis);
1518 : else
1519 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "FieldTable");
1520 : }
1521 :
1522 : }
1523 0 : return row;
1524 : }
1525 :
1526 : //
1527 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
1528 : // of one row.
1529 : //
1530 :
1531 : // Convert a string into an Tag
1532 0 : void FieldRow::fieldIdFromText(const string & s) {
1533 :
1534 :
1535 0 : fieldId = ASDMValuesParser::parse<Tag>(s);
1536 :
1537 :
1538 0 : }
1539 :
1540 :
1541 : // Convert a string into an String
1542 0 : void FieldRow::fieldNameFromText(const string & s) {
1543 :
1544 :
1545 0 : fieldName = ASDMValuesParser::parse<string>(s);
1546 :
1547 :
1548 0 : }
1549 :
1550 :
1551 : // Convert a string into an int
1552 0 : void FieldRow::numPolyFromText(const string & s) {
1553 :
1554 :
1555 0 : numPoly = ASDMValuesParser::parse<int>(s);
1556 :
1557 :
1558 0 : }
1559 :
1560 :
1561 : // Convert a string into an Angle
1562 0 : void FieldRow::delayDirFromText(const string & s) {
1563 :
1564 :
1565 0 : delayDir = ASDMValuesParser::parse2D<Angle>(s);
1566 :
1567 :
1568 0 : }
1569 :
1570 :
1571 : // Convert a string into an Angle
1572 0 : void FieldRow::phaseDirFromText(const string & s) {
1573 :
1574 :
1575 0 : phaseDir = ASDMValuesParser::parse2D<Angle>(s);
1576 :
1577 :
1578 0 : }
1579 :
1580 :
1581 : // Convert a string into an Angle
1582 0 : void FieldRow::referenceDirFromText(const string & s) {
1583 :
1584 :
1585 0 : referenceDir = ASDMValuesParser::parse2D<Angle>(s);
1586 :
1587 :
1588 0 : }
1589 :
1590 :
1591 :
1592 : // Convert a string into an ArrayTime
1593 0 : void FieldRow::timeFromText(const string & s) {
1594 0 : timeExists = true;
1595 :
1596 :
1597 0 : time = ASDMValuesParser::parse<ArrayTime>(s);
1598 :
1599 :
1600 0 : }
1601 :
1602 :
1603 : // Convert a string into an String
1604 0 : void FieldRow::codeFromText(const string & s) {
1605 0 : codeExists = true;
1606 :
1607 :
1608 0 : code = ASDMValuesParser::parse<string>(s);
1609 :
1610 :
1611 0 : }
1612 :
1613 :
1614 : // Convert a string into an DirectionReferenceCode
1615 0 : void FieldRow::directionCodeFromText(const string & s) {
1616 0 : directionCodeExists = true;
1617 :
1618 :
1619 0 : directionCode = ASDMValuesParser::parse<DirectionReferenceCodeMod::DirectionReferenceCode>(s);
1620 :
1621 :
1622 0 : }
1623 :
1624 :
1625 : // Convert a string into an ArrayTime
1626 0 : void FieldRow::directionEquinoxFromText(const string & s) {
1627 0 : directionEquinoxExists = true;
1628 :
1629 :
1630 0 : directionEquinox = ASDMValuesParser::parse<ArrayTime>(s);
1631 :
1632 :
1633 0 : }
1634 :
1635 :
1636 : // Convert a string into an String
1637 0 : void FieldRow::assocNatureFromText(const string & s) {
1638 0 : assocNatureExists = true;
1639 :
1640 :
1641 0 : assocNature = ASDMValuesParser::parse<string>(s);
1642 :
1643 :
1644 0 : }
1645 :
1646 :
1647 : // Convert a string into an int
1648 0 : void FieldRow::ephemerisIdFromText(const string & s) {
1649 0 : ephemerisIdExists = true;
1650 :
1651 :
1652 0 : ephemerisId = ASDMValuesParser::parse<int>(s);
1653 :
1654 :
1655 0 : }
1656 :
1657 :
1658 : // Convert a string into an int
1659 0 : void FieldRow::sourceIdFromText(const string & s) {
1660 0 : sourceIdExists = true;
1661 :
1662 :
1663 0 : sourceId = ASDMValuesParser::parse<int>(s);
1664 :
1665 :
1666 0 : }
1667 :
1668 :
1669 : // Convert a string into an Tag
1670 0 : void FieldRow::assocFieldIdFromText(const string & s) {
1671 0 : assocFieldIdExists = true;
1672 :
1673 :
1674 0 : assocFieldId = ASDMValuesParser::parse<Tag>(s);
1675 :
1676 :
1677 0 : }
1678 :
1679 :
1680 :
1681 0 : void FieldRow::fromText(const std::string& attributeName, const std::string& t) {
1682 0 : map<string, FieldAttributeFromText>::iterator iter;
1683 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
1684 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "FieldTable");
1685 0 : (this->*(iter->second))(t);
1686 0 : }
1687 :
1688 : ////////////////////////////////////////////////
1689 : // Intrinsic Table Attributes getters/setters //
1690 : ////////////////////////////////////////////////
1691 :
1692 :
1693 :
1694 :
1695 : /**
1696 : * Get fieldId.
1697 : * @return fieldId as Tag
1698 : */
1699 1175 : Tag FieldRow::getFieldId() const {
1700 :
1701 1175 : return fieldId;
1702 : }
1703 :
1704 : /**
1705 : * Set fieldId with the specified Tag.
1706 : * @param fieldId The Tag value to which fieldId is to be set.
1707 :
1708 :
1709 :
1710 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1711 :
1712 : */
1713 478 : void FieldRow::setFieldId (Tag fieldId) {
1714 :
1715 :
1716 478 : if (hasBeenAdded) {
1717 :
1718 0 : throw IllegalAccessException("fieldId", "Field");
1719 :
1720 : }
1721 :
1722 478 : this->fieldId = fieldId;
1723 :
1724 478 : }
1725 :
1726 :
1727 :
1728 :
1729 :
1730 :
1731 : /**
1732 : * Get fieldName.
1733 : * @return fieldName as std::string
1734 : */
1735 487 : std::string FieldRow::getFieldName() const {
1736 :
1737 487 : return fieldName;
1738 : }
1739 :
1740 : /**
1741 : * Set fieldName with the specified std::string.
1742 : * @param fieldName The std::string value to which fieldName is to be set.
1743 :
1744 :
1745 :
1746 : */
1747 478 : void FieldRow::setFieldName (std::string fieldName) {
1748 :
1749 :
1750 478 : if (hasBeenAdded) {
1751 :
1752 : }
1753 :
1754 478 : this->fieldName = fieldName;
1755 :
1756 478 : }
1757 :
1758 :
1759 :
1760 :
1761 :
1762 :
1763 : /**
1764 : * Get numPoly.
1765 : * @return numPoly as int
1766 : */
1767 478 : int FieldRow::getNumPoly() const {
1768 :
1769 478 : return numPoly;
1770 : }
1771 :
1772 : /**
1773 : * Set numPoly with the specified int.
1774 : * @param numPoly The int value to which numPoly is to be set.
1775 :
1776 :
1777 :
1778 : */
1779 478 : void FieldRow::setNumPoly (int numPoly) {
1780 :
1781 :
1782 478 : if (hasBeenAdded) {
1783 :
1784 : }
1785 :
1786 478 : this->numPoly = numPoly;
1787 :
1788 478 : }
1789 :
1790 :
1791 :
1792 :
1793 :
1794 :
1795 : /**
1796 : * Get delayDir.
1797 : * @return delayDir as std::vector<std::vector<Angle > >
1798 : */
1799 478 : std::vector<std::vector<Angle > > FieldRow::getDelayDir() const {
1800 :
1801 478 : return delayDir;
1802 : }
1803 :
1804 : /**
1805 : * Set delayDir with the specified std::vector<std::vector<Angle > >.
1806 : * @param delayDir The std::vector<std::vector<Angle > > value to which delayDir is to be set.
1807 :
1808 :
1809 :
1810 : */
1811 478 : void FieldRow::setDelayDir (std::vector<std::vector<Angle > > delayDir) {
1812 :
1813 :
1814 478 : if (hasBeenAdded) {
1815 :
1816 : }
1817 :
1818 478 : this->delayDir = delayDir;
1819 :
1820 478 : }
1821 :
1822 :
1823 :
1824 :
1825 :
1826 :
1827 : /**
1828 : * Get phaseDir.
1829 : * @return phaseDir as std::vector<std::vector<Angle > >
1830 : */
1831 10886 : std::vector<std::vector<Angle > > FieldRow::getPhaseDir() const {
1832 :
1833 10886 : return phaseDir;
1834 : }
1835 :
1836 : /**
1837 : * Set phaseDir with the specified std::vector<std::vector<Angle > >.
1838 : * @param phaseDir The std::vector<std::vector<Angle > > value to which phaseDir is to be set.
1839 :
1840 :
1841 :
1842 : */
1843 478 : void FieldRow::setPhaseDir (std::vector<std::vector<Angle > > phaseDir) {
1844 :
1845 :
1846 478 : if (hasBeenAdded) {
1847 :
1848 : }
1849 :
1850 478 : this->phaseDir = phaseDir;
1851 :
1852 478 : }
1853 :
1854 :
1855 :
1856 :
1857 :
1858 :
1859 : /**
1860 : * Get referenceDir.
1861 : * @return referenceDir as std::vector<std::vector<Angle > >
1862 : */
1863 478 : std::vector<std::vector<Angle > > FieldRow::getReferenceDir() const {
1864 :
1865 478 : return referenceDir;
1866 : }
1867 :
1868 : /**
1869 : * Set referenceDir with the specified std::vector<std::vector<Angle > >.
1870 : * @param referenceDir The std::vector<std::vector<Angle > > value to which referenceDir is to be set.
1871 :
1872 :
1873 :
1874 : */
1875 478 : void FieldRow::setReferenceDir (std::vector<std::vector<Angle > > referenceDir) {
1876 :
1877 :
1878 478 : if (hasBeenAdded) {
1879 :
1880 : }
1881 :
1882 478 : this->referenceDir = referenceDir;
1883 :
1884 478 : }
1885 :
1886 :
1887 :
1888 :
1889 : /**
1890 : * The attribute time is optional. Return true if this attribute exists.
1891 : * @return true if and only if the time attribute exists.
1892 : */
1893 240 : bool FieldRow::isTimeExists() const {
1894 240 : return timeExists;
1895 : }
1896 :
1897 :
1898 :
1899 : /**
1900 : * Get time, which is optional.
1901 : * @return time as ArrayTime
1902 : * @throw IllegalAccessException If time does not exist.
1903 : */
1904 231 : ArrayTime FieldRow::getTime() const {
1905 231 : if (!timeExists) {
1906 0 : throw IllegalAccessException("time", "Field");
1907 : }
1908 :
1909 231 : return time;
1910 : }
1911 :
1912 : /**
1913 : * Set time with the specified ArrayTime.
1914 : * @param time The ArrayTime value to which time is to be set.
1915 :
1916 :
1917 : */
1918 478 : void FieldRow::setTime (ArrayTime time) {
1919 :
1920 478 : this->time = time;
1921 :
1922 478 : timeExists = true;
1923 :
1924 478 : }
1925 :
1926 :
1927 : /**
1928 : * Mark time, which is an optional field, as non-existent.
1929 : */
1930 0 : void FieldRow::clearTime () {
1931 0 : timeExists = false;
1932 0 : }
1933 :
1934 :
1935 :
1936 : /**
1937 : * The attribute code is optional. Return true if this attribute exists.
1938 : * @return true if and only if the code attribute exists.
1939 : */
1940 0 : bool FieldRow::isCodeExists() const {
1941 0 : return codeExists;
1942 : }
1943 :
1944 :
1945 :
1946 : /**
1947 : * Get code, which is optional.
1948 : * @return code as std::string
1949 : * @throw IllegalAccessException If code does not exist.
1950 : */
1951 223 : std::string FieldRow::getCode() const {
1952 223 : if (!codeExists) {
1953 0 : throw IllegalAccessException("code", "Field");
1954 : }
1955 :
1956 223 : return code;
1957 : }
1958 :
1959 : /**
1960 : * Set code with the specified std::string.
1961 : * @param code The std::string value to which code is to be set.
1962 :
1963 :
1964 : */
1965 478 : void FieldRow::setCode (std::string code) {
1966 :
1967 478 : this->code = code;
1968 :
1969 478 : codeExists = true;
1970 :
1971 478 : }
1972 :
1973 :
1974 : /**
1975 : * Mark code, which is an optional field, as non-existent.
1976 : */
1977 0 : void FieldRow::clearCode () {
1978 0 : codeExists = false;
1979 0 : }
1980 :
1981 :
1982 :
1983 : /**
1984 : * The attribute directionCode is optional. Return true if this attribute exists.
1985 : * @return true if and only if the directionCode attribute exists.
1986 : */
1987 223 : bool FieldRow::isDirectionCodeExists() const {
1988 223 : return directionCodeExists;
1989 : }
1990 :
1991 :
1992 :
1993 : /**
1994 : * Get directionCode, which is optional.
1995 : * @return directionCode as DirectionReferenceCodeMod::DirectionReferenceCode
1996 : * @throw IllegalAccessException If directionCode does not exist.
1997 : */
1998 192 : DirectionReferenceCodeMod::DirectionReferenceCode FieldRow::getDirectionCode() const {
1999 192 : if (!directionCodeExists) {
2000 0 : throw IllegalAccessException("directionCode", "Field");
2001 : }
2002 :
2003 192 : return directionCode;
2004 : }
2005 :
2006 : /**
2007 : * Set directionCode with the specified DirectionReferenceCodeMod::DirectionReferenceCode.
2008 : * @param directionCode The DirectionReferenceCodeMod::DirectionReferenceCode value to which directionCode is to be set.
2009 :
2010 :
2011 : */
2012 255 : void FieldRow::setDirectionCode (DirectionReferenceCodeMod::DirectionReferenceCode directionCode) {
2013 :
2014 255 : this->directionCode = directionCode;
2015 :
2016 255 : directionCodeExists = true;
2017 :
2018 255 : }
2019 :
2020 :
2021 : /**
2022 : * Mark directionCode, which is an optional field, as non-existent.
2023 : */
2024 0 : void FieldRow::clearDirectionCode () {
2025 0 : directionCodeExists = false;
2026 0 : }
2027 :
2028 :
2029 :
2030 : /**
2031 : * The attribute directionEquinox is optional. Return true if this attribute exists.
2032 : * @return true if and only if the directionEquinox attribute exists.
2033 : */
2034 0 : bool FieldRow::isDirectionEquinoxExists() const {
2035 0 : return directionEquinoxExists;
2036 : }
2037 :
2038 :
2039 :
2040 : /**
2041 : * Get directionEquinox, which is optional.
2042 : * @return directionEquinox as ArrayTime
2043 : * @throw IllegalAccessException If directionEquinox does not exist.
2044 : */
2045 0 : ArrayTime FieldRow::getDirectionEquinox() const {
2046 0 : if (!directionEquinoxExists) {
2047 0 : throw IllegalAccessException("directionEquinox", "Field");
2048 : }
2049 :
2050 0 : return directionEquinox;
2051 : }
2052 :
2053 : /**
2054 : * Set directionEquinox with the specified ArrayTime.
2055 : * @param directionEquinox The ArrayTime value to which directionEquinox is to be set.
2056 :
2057 :
2058 : */
2059 0 : void FieldRow::setDirectionEquinox (ArrayTime directionEquinox) {
2060 :
2061 0 : this->directionEquinox = directionEquinox;
2062 :
2063 0 : directionEquinoxExists = true;
2064 :
2065 0 : }
2066 :
2067 :
2068 : /**
2069 : * Mark directionEquinox, which is an optional field, as non-existent.
2070 : */
2071 0 : void FieldRow::clearDirectionEquinox () {
2072 0 : directionEquinoxExists = false;
2073 0 : }
2074 :
2075 :
2076 :
2077 : /**
2078 : * The attribute assocNature is optional. Return true if this attribute exists.
2079 : * @return true if and only if the assocNature attribute exists.
2080 : */
2081 0 : bool FieldRow::isAssocNatureExists() const {
2082 0 : return assocNatureExists;
2083 : }
2084 :
2085 :
2086 :
2087 : /**
2088 : * Get assocNature, which is optional.
2089 : * @return assocNature as std::string
2090 : * @throw IllegalAccessException If assocNature does not exist.
2091 : */
2092 0 : std::string FieldRow::getAssocNature() const {
2093 0 : if (!assocNatureExists) {
2094 0 : throw IllegalAccessException("assocNature", "Field");
2095 : }
2096 :
2097 0 : return assocNature;
2098 : }
2099 :
2100 : /**
2101 : * Set assocNature with the specified std::string.
2102 : * @param assocNature The std::string value to which assocNature is to be set.
2103 :
2104 :
2105 : */
2106 0 : void FieldRow::setAssocNature (std::string assocNature) {
2107 :
2108 0 : this->assocNature = assocNature;
2109 :
2110 0 : assocNatureExists = true;
2111 :
2112 0 : }
2113 :
2114 :
2115 : /**
2116 : * Mark assocNature, which is an optional field, as non-existent.
2117 : */
2118 0 : void FieldRow::clearAssocNature () {
2119 0 : assocNatureExists = false;
2120 0 : }
2121 :
2122 :
2123 :
2124 : ///////////////////////////////////////////////
2125 : // Extrinsic Table Attributes getters/setters//
2126 : ///////////////////////////////////////////////
2127 :
2128 :
2129 : /**
2130 : * The attribute assocFieldId is optional. Return true if this attribute exists.
2131 : * @return true if and only if the assocFieldId attribute exists.
2132 : */
2133 0 : bool FieldRow::isAssocFieldIdExists() const {
2134 0 : return assocFieldIdExists;
2135 : }
2136 :
2137 :
2138 :
2139 : /**
2140 : * Get assocFieldId, which is optional.
2141 : * @return assocFieldId as Tag
2142 : * @throw IllegalAccessException If assocFieldId does not exist.
2143 : */
2144 0 : Tag FieldRow::getAssocFieldId() const {
2145 0 : if (!assocFieldIdExists) {
2146 0 : throw IllegalAccessException("assocFieldId", "Field");
2147 : }
2148 :
2149 0 : return assocFieldId;
2150 : }
2151 :
2152 : /**
2153 : * Set assocFieldId with the specified Tag.
2154 : * @param assocFieldId The Tag value to which assocFieldId is to be set.
2155 :
2156 :
2157 : */
2158 0 : void FieldRow::setAssocFieldId (Tag assocFieldId) {
2159 :
2160 0 : this->assocFieldId = assocFieldId;
2161 :
2162 0 : assocFieldIdExists = true;
2163 :
2164 0 : }
2165 :
2166 :
2167 : /**
2168 : * Mark assocFieldId, which is an optional field, as non-existent.
2169 : */
2170 0 : void FieldRow::clearAssocFieldId () {
2171 0 : assocFieldIdExists = false;
2172 0 : }
2173 :
2174 :
2175 :
2176 : /**
2177 : * The attribute ephemerisId is optional. Return true if this attribute exists.
2178 : * @return true if and only if the ephemerisId attribute exists.
2179 : */
2180 473 : bool FieldRow::isEphemerisIdExists() const {
2181 473 : return ephemerisIdExists;
2182 : }
2183 :
2184 :
2185 :
2186 : /**
2187 : * Get ephemerisId, which is optional.
2188 : * @return ephemerisId as int
2189 : * @throw IllegalAccessException If ephemerisId does not exist.
2190 : */
2191 36 : int FieldRow::getEphemerisId() const {
2192 36 : if (!ephemerisIdExists) {
2193 0 : throw IllegalAccessException("ephemerisId", "Field");
2194 : }
2195 :
2196 36 : return ephemerisId;
2197 : }
2198 :
2199 : /**
2200 : * Set ephemerisId with the specified int.
2201 : * @param ephemerisId The int value to which ephemerisId is to be set.
2202 :
2203 :
2204 : */
2205 9 : void FieldRow::setEphemerisId (int ephemerisId) {
2206 :
2207 9 : this->ephemerisId = ephemerisId;
2208 :
2209 9 : ephemerisIdExists = true;
2210 :
2211 9 : }
2212 :
2213 :
2214 : /**
2215 : * Mark ephemerisId, which is an optional field, as non-existent.
2216 : */
2217 0 : void FieldRow::clearEphemerisId () {
2218 0 : ephemerisIdExists = false;
2219 0 : }
2220 :
2221 :
2222 :
2223 : /**
2224 : * The attribute sourceId is optional. Return true if this attribute exists.
2225 : * @return true if and only if the sourceId attribute exists.
2226 : */
2227 223 : bool FieldRow::isSourceIdExists() const {
2228 223 : return sourceIdExists;
2229 : }
2230 :
2231 :
2232 :
2233 : /**
2234 : * Get sourceId, which is optional.
2235 : * @return sourceId as int
2236 : * @throw IllegalAccessException If sourceId does not exist.
2237 : */
2238 223 : int FieldRow::getSourceId() const {
2239 223 : if (!sourceIdExists) {
2240 0 : throw IllegalAccessException("sourceId", "Field");
2241 : }
2242 :
2243 223 : return sourceId;
2244 : }
2245 :
2246 : /**
2247 : * Set sourceId with the specified int.
2248 : * @param sourceId The int value to which sourceId is to be set.
2249 :
2250 :
2251 : */
2252 478 : void FieldRow::setSourceId (int sourceId) {
2253 :
2254 478 : this->sourceId = sourceId;
2255 :
2256 478 : sourceIdExists = true;
2257 :
2258 478 : }
2259 :
2260 :
2261 : /**
2262 : * Mark sourceId, which is an optional field, as non-existent.
2263 : */
2264 0 : void FieldRow::clearSourceId () {
2265 0 : sourceIdExists = false;
2266 0 : }
2267 :
2268 :
2269 :
2270 : //////////////////////////////////////
2271 : // Links Attributes getters/setters //
2272 : //////////////////////////////////////
2273 :
2274 :
2275 :
2276 :
2277 :
2278 :
2279 :
2280 :
2281 :
2282 :
2283 :
2284 :
2285 :
2286 :
2287 : // ===> Slice link from a row of Field table to a collection of row of Source table.
2288 :
2289 : /**
2290 : * Get the collection of row in the Source table having their attribut sourceId == this->sourceId
2291 : */
2292 0 : vector <SourceRow *> FieldRow::getSources() {
2293 :
2294 0 : if (sourceIdExists) {
2295 0 : return table.getContainer().getSource().getRowBySourceId(sourceId);
2296 : }
2297 : else
2298 0 : throw IllegalAccessException();
2299 :
2300 : }
2301 :
2302 :
2303 :
2304 :
2305 :
2306 :
2307 :
2308 :
2309 :
2310 : /**
2311 : * Returns the pointer to the row in the Field table having Field.assocFieldId == assocFieldId
2312 : * @return a FieldRow*
2313 : *
2314 :
2315 : * throws IllegalAccessException
2316 :
2317 : */
2318 0 : FieldRow* FieldRow::getFieldUsingAssocFieldId() {
2319 :
2320 0 : if (!assocFieldIdExists)
2321 0 : throw IllegalAccessException();
2322 :
2323 0 : return table.getContainer().getField().getRowByKey(assocFieldId);
2324 : }
2325 :
2326 :
2327 :
2328 :
2329 :
2330 : /**
2331 : * Create a FieldRow.
2332 : * <p>
2333 : * This constructor is private because only the
2334 : * table can create rows. All rows know the table
2335 : * to which they belong.
2336 : * @param table The table to which this row belongs.
2337 : */
2338 478 : FieldRow::FieldRow (FieldTable &t) : table(t) {
2339 478 : hasBeenAdded = false;
2340 :
2341 :
2342 :
2343 :
2344 :
2345 :
2346 :
2347 :
2348 :
2349 :
2350 :
2351 :
2352 :
2353 :
2354 :
2355 478 : timeExists = false;
2356 :
2357 :
2358 :
2359 478 : codeExists = false;
2360 :
2361 :
2362 :
2363 478 : directionCodeExists = false;
2364 :
2365 :
2366 :
2367 478 : directionEquinoxExists = false;
2368 :
2369 :
2370 :
2371 478 : assocNatureExists = false;
2372 :
2373 :
2374 :
2375 :
2376 478 : assocFieldIdExists = false;
2377 :
2378 :
2379 :
2380 478 : ephemerisIdExists = false;
2381 :
2382 :
2383 :
2384 478 : sourceIdExists = false;
2385 :
2386 :
2387 :
2388 :
2389 :
2390 :
2391 :
2392 :
2393 :
2394 :
2395 :
2396 :
2397 :
2398 :
2399 :
2400 :
2401 :
2402 :
2403 :
2404 :
2405 :
2406 :
2407 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
2408 478 : directionCode = CDirectionReferenceCode::from_int(0);
2409 :
2410 :
2411 :
2412 :
2413 :
2414 :
2415 :
2416 :
2417 478 : fromBinMethods["fieldId"] = &FieldRow::fieldIdFromBin;
2418 478 : fromBinMethods["fieldName"] = &FieldRow::fieldNameFromBin;
2419 478 : fromBinMethods["numPoly"] = &FieldRow::numPolyFromBin;
2420 478 : fromBinMethods["delayDir"] = &FieldRow::delayDirFromBin;
2421 478 : fromBinMethods["phaseDir"] = &FieldRow::phaseDirFromBin;
2422 478 : fromBinMethods["referenceDir"] = &FieldRow::referenceDirFromBin;
2423 :
2424 :
2425 478 : fromBinMethods["time"] = &FieldRow::timeFromBin;
2426 478 : fromBinMethods["code"] = &FieldRow::codeFromBin;
2427 478 : fromBinMethods["directionCode"] = &FieldRow::directionCodeFromBin;
2428 478 : fromBinMethods["directionEquinox"] = &FieldRow::directionEquinoxFromBin;
2429 478 : fromBinMethods["assocNature"] = &FieldRow::assocNatureFromBin;
2430 478 : fromBinMethods["ephemerisId"] = &FieldRow::ephemerisIdFromBin;
2431 478 : fromBinMethods["sourceId"] = &FieldRow::sourceIdFromBin;
2432 478 : fromBinMethods["assocFieldId"] = &FieldRow::assocFieldIdFromBin;
2433 :
2434 :
2435 :
2436 :
2437 :
2438 478 : fromTextMethods["fieldId"] = &FieldRow::fieldIdFromText;
2439 :
2440 :
2441 :
2442 478 : fromTextMethods["fieldName"] = &FieldRow::fieldNameFromText;
2443 :
2444 :
2445 :
2446 478 : fromTextMethods["numPoly"] = &FieldRow::numPolyFromText;
2447 :
2448 :
2449 :
2450 478 : fromTextMethods["delayDir"] = &FieldRow::delayDirFromText;
2451 :
2452 :
2453 :
2454 478 : fromTextMethods["phaseDir"] = &FieldRow::phaseDirFromText;
2455 :
2456 :
2457 :
2458 478 : fromTextMethods["referenceDir"] = &FieldRow::referenceDirFromText;
2459 :
2460 :
2461 :
2462 :
2463 :
2464 478 : fromTextMethods["time"] = &FieldRow::timeFromText;
2465 :
2466 :
2467 :
2468 478 : fromTextMethods["code"] = &FieldRow::codeFromText;
2469 :
2470 :
2471 :
2472 478 : fromTextMethods["directionCode"] = &FieldRow::directionCodeFromText;
2473 :
2474 :
2475 :
2476 478 : fromTextMethods["directionEquinox"] = &FieldRow::directionEquinoxFromText;
2477 :
2478 :
2479 :
2480 478 : fromTextMethods["assocNature"] = &FieldRow::assocNatureFromText;
2481 :
2482 :
2483 :
2484 478 : fromTextMethods["ephemerisId"] = &FieldRow::ephemerisIdFromText;
2485 :
2486 :
2487 :
2488 478 : fromTextMethods["sourceId"] = &FieldRow::sourceIdFromText;
2489 :
2490 :
2491 :
2492 478 : fromTextMethods["assocFieldId"] = &FieldRow::assocFieldIdFromText;
2493 :
2494 :
2495 478 : }
2496 :
2497 0 : FieldRow::FieldRow (FieldTable &t, FieldRow *row) : table(t) {
2498 0 : hasBeenAdded = false;
2499 :
2500 0 : if (row == 0) {
2501 :
2502 :
2503 :
2504 :
2505 :
2506 :
2507 :
2508 :
2509 :
2510 :
2511 :
2512 :
2513 :
2514 :
2515 :
2516 0 : timeExists = false;
2517 :
2518 :
2519 :
2520 0 : codeExists = false;
2521 :
2522 :
2523 :
2524 0 : directionCodeExists = false;
2525 :
2526 :
2527 :
2528 0 : directionEquinoxExists = false;
2529 :
2530 :
2531 :
2532 0 : assocNatureExists = false;
2533 :
2534 :
2535 :
2536 :
2537 0 : assocFieldIdExists = false;
2538 :
2539 :
2540 :
2541 0 : ephemerisIdExists = false;
2542 :
2543 :
2544 :
2545 0 : sourceIdExists = false;
2546 :
2547 :
2548 : }
2549 : else {
2550 :
2551 :
2552 0 : fieldId = row->fieldId;
2553 :
2554 :
2555 :
2556 :
2557 0 : fieldName = row->fieldName;
2558 :
2559 0 : numPoly = row->numPoly;
2560 :
2561 0 : delayDir = row->delayDir;
2562 :
2563 0 : phaseDir = row->phaseDir;
2564 :
2565 0 : referenceDir = row->referenceDir;
2566 :
2567 :
2568 :
2569 :
2570 0 : if (row->timeExists) {
2571 0 : time = row->time;
2572 0 : timeExists = true;
2573 : }
2574 : else
2575 0 : timeExists = false;
2576 :
2577 0 : if (row->codeExists) {
2578 0 : code = row->code;
2579 0 : codeExists = true;
2580 : }
2581 : else
2582 0 : codeExists = false;
2583 :
2584 0 : if (row->directionCodeExists) {
2585 0 : directionCode = row->directionCode;
2586 0 : directionCodeExists = true;
2587 : }
2588 : else
2589 0 : directionCodeExists = false;
2590 :
2591 0 : if (row->directionEquinoxExists) {
2592 0 : directionEquinox = row->directionEquinox;
2593 0 : directionEquinoxExists = true;
2594 : }
2595 : else
2596 0 : directionEquinoxExists = false;
2597 :
2598 0 : if (row->assocNatureExists) {
2599 0 : assocNature = row->assocNature;
2600 0 : assocNatureExists = true;
2601 : }
2602 : else
2603 0 : assocNatureExists = false;
2604 :
2605 0 : if (row->ephemerisIdExists) {
2606 0 : ephemerisId = row->ephemerisId;
2607 0 : ephemerisIdExists = true;
2608 : }
2609 : else
2610 0 : ephemerisIdExists = false;
2611 :
2612 0 : if (row->sourceIdExists) {
2613 0 : sourceId = row->sourceId;
2614 0 : sourceIdExists = true;
2615 : }
2616 : else
2617 0 : sourceIdExists = false;
2618 :
2619 0 : if (row->assocFieldIdExists) {
2620 0 : assocFieldId = row->assocFieldId;
2621 0 : assocFieldIdExists = true;
2622 : }
2623 : else
2624 0 : assocFieldIdExists = false;
2625 :
2626 : }
2627 :
2628 0 : fromBinMethods["fieldId"] = &FieldRow::fieldIdFromBin;
2629 0 : fromBinMethods["fieldName"] = &FieldRow::fieldNameFromBin;
2630 0 : fromBinMethods["numPoly"] = &FieldRow::numPolyFromBin;
2631 0 : fromBinMethods["delayDir"] = &FieldRow::delayDirFromBin;
2632 0 : fromBinMethods["phaseDir"] = &FieldRow::phaseDirFromBin;
2633 0 : fromBinMethods["referenceDir"] = &FieldRow::referenceDirFromBin;
2634 :
2635 :
2636 0 : fromBinMethods["time"] = &FieldRow::timeFromBin;
2637 0 : fromBinMethods["code"] = &FieldRow::codeFromBin;
2638 0 : fromBinMethods["directionCode"] = &FieldRow::directionCodeFromBin;
2639 0 : fromBinMethods["directionEquinox"] = &FieldRow::directionEquinoxFromBin;
2640 0 : fromBinMethods["assocNature"] = &FieldRow::assocNatureFromBin;
2641 0 : fromBinMethods["ephemerisId"] = &FieldRow::ephemerisIdFromBin;
2642 0 : fromBinMethods["sourceId"] = &FieldRow::sourceIdFromBin;
2643 0 : fromBinMethods["assocFieldId"] = &FieldRow::assocFieldIdFromBin;
2644 :
2645 0 : }
2646 :
2647 :
2648 10820 : bool FieldRow::compareNoAutoInc(std::string fieldName, int numPoly, std::vector<std::vector<Angle > > delayDir, std::vector<std::vector<Angle > > phaseDir, std::vector<std::vector<Angle > > referenceDir) {
2649 : bool result;
2650 10820 : result = true;
2651 :
2652 :
2653 :
2654 10820 : result = result && (this->fieldName == fieldName);
2655 :
2656 10820 : if (!result) return false;
2657 :
2658 :
2659 :
2660 :
2661 63 : result = result && (this->numPoly == numPoly);
2662 :
2663 63 : if (!result) return false;
2664 :
2665 :
2666 :
2667 :
2668 63 : result = result && (this->delayDir == delayDir);
2669 :
2670 63 : if (!result) return false;
2671 :
2672 :
2673 :
2674 :
2675 0 : result = result && (this->phaseDir == phaseDir);
2676 :
2677 0 : if (!result) return false;
2678 :
2679 :
2680 :
2681 :
2682 0 : result = result && (this->referenceDir == referenceDir);
2683 :
2684 0 : if (!result) return false;
2685 :
2686 :
2687 0 : return result;
2688 : }
2689 :
2690 :
2691 :
2692 0 : bool FieldRow::compareRequiredValue(std::string fieldName, int numPoly, std::vector<std::vector<Angle > > delayDir, std::vector<std::vector<Angle > > phaseDir, std::vector<std::vector<Angle > > referenceDir) {
2693 : bool result;
2694 0 : result = true;
2695 :
2696 :
2697 0 : if (!(this->fieldName == fieldName)) return false;
2698 :
2699 :
2700 :
2701 0 : if (!(this->numPoly == numPoly)) return false;
2702 :
2703 :
2704 :
2705 0 : if (!(this->delayDir == delayDir)) return false;
2706 :
2707 :
2708 :
2709 0 : if (!(this->phaseDir == phaseDir)) return false;
2710 :
2711 :
2712 :
2713 0 : if (!(this->referenceDir == referenceDir)) return false;
2714 :
2715 :
2716 0 : return result;
2717 : }
2718 :
2719 :
2720 : /**
2721 : * Return true if all required attributes of the value part are equal to their homologues
2722 : * in x and false otherwise.
2723 : *
2724 :
2725 : * @param x a pointer on the FieldRow whose required attributes of the value part
2726 :
2727 : * will be compared with those of this.
2728 : * @return a boolean.
2729 : */
2730 0 : bool FieldRow::equalByRequiredValue(FieldRow* x ) {
2731 :
2732 :
2733 0 : if (this->fieldName != x->fieldName) return false;
2734 :
2735 0 : if (this->numPoly != x->numPoly) return false;
2736 :
2737 0 : if (this->delayDir != x->delayDir) return false;
2738 :
2739 0 : if (this->phaseDir != x->phaseDir) return false;
2740 :
2741 0 : if (this->referenceDir != x->referenceDir) return false;
2742 :
2743 :
2744 0 : return true;
2745 : }
2746 :
2747 : /*
2748 : map<string, FieldAttributeFromBin> FieldRow::initFromBinMethods() {
2749 : map<string, FieldAttributeFromBin> result;
2750 :
2751 : result["fieldId"] = &FieldRow::fieldIdFromBin;
2752 : result["fieldName"] = &FieldRow::fieldNameFromBin;
2753 : result["numPoly"] = &FieldRow::numPolyFromBin;
2754 : result["delayDir"] = &FieldRow::delayDirFromBin;
2755 : result["phaseDir"] = &FieldRow::phaseDirFromBin;
2756 : result["referenceDir"] = &FieldRow::referenceDirFromBin;
2757 :
2758 :
2759 : result["time"] = &FieldRow::timeFromBin;
2760 : result["code"] = &FieldRow::codeFromBin;
2761 : result["directionCode"] = &FieldRow::directionCodeFromBin;
2762 : result["directionEquinox"] = &FieldRow::directionEquinoxFromBin;
2763 : result["assocNature"] = &FieldRow::assocNatureFromBin;
2764 : result["ephemerisId"] = &FieldRow::ephemerisIdFromBin;
2765 : result["sourceId"] = &FieldRow::sourceIdFromBin;
2766 : result["assocFieldId"] = &FieldRow::assocFieldIdFromBin;
2767 :
2768 :
2769 : return result;
2770 : }
2771 : */
2772 : } // End namespace asdm
2773 :
|
