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 AntennaRow.cpp
32 : */
33 :
34 : #include <vector>
35 : #include <set>
36 :
37 : #include <alma/ASDM/ASDM.h>
38 : #include <alma/ASDM/AntennaRow.h>
39 : #include <alma/ASDM/AntennaTable.h>
40 :
41 : #include <alma/ASDM/AntennaTable.h>
42 : #include <alma/ASDM/AntennaRow.h>
43 :
44 : #include <alma/ASDM/StationTable.h>
45 : #include <alma/ASDM/StationRow.h>
46 :
47 :
48 : using asdm::ASDM;
49 : using asdm::AntennaRow;
50 : using asdm::AntennaTable;
51 :
52 : using asdm::AntennaTable;
53 : using asdm::AntennaRow;
54 :
55 : using asdm::StationTable;
56 : using asdm::StationRow;
57 :
58 :
59 : #include <alma/ASDM/Parser.h>
60 :
61 : #include <alma/ASDM/EnumerationParser.h>
62 : #include <alma/ASDM/ASDMValuesParser.h>
63 :
64 : #include <alma/ASDM/InvalidArgumentException.h>
65 :
66 : using namespace std;
67 :
68 : namespace asdm {
69 0 : AntennaRow::~AntennaRow() {
70 0 : }
71 :
72 : /**
73 : * Return the table to which this row belongs.
74 : */
75 0 : AntennaTable &AntennaRow::getTable() const {
76 0 : return table;
77 : }
78 :
79 0 : bool AntennaRow::isAdded() const {
80 0 : return hasBeenAdded;
81 : }
82 :
83 0 : void AntennaRow::isAdded(bool added) {
84 0 : hasBeenAdded = added;
85 0 : }
86 :
87 : #ifndef WITHOUT_ACS
88 : using asdmIDL::AntennaRowIDL;
89 : #endif
90 :
91 : #ifndef WITHOUT_ACS
92 : /**
93 : * Return this row in the form of an IDL struct.
94 : * @return The values of this row as a AntennaRowIDL struct.
95 : */
96 : AntennaRowIDL *AntennaRow::toIDL() const {
97 : AntennaRowIDL *x = new AntennaRowIDL ();
98 :
99 : // Fill the IDL structure.
100 :
101 :
102 :
103 :
104 :
105 :
106 :
107 : x->antennaId = antennaId.toIDLTag();
108 :
109 :
110 :
111 :
112 :
113 :
114 :
115 :
116 :
117 :
118 : x->name = CORBA::string_dup(name.c_str());
119 :
120 :
121 :
122 :
123 :
124 :
125 :
126 :
127 :
128 :
129 :
130 : x->antennaMake = antennaMake;
131 :
132 :
133 :
134 :
135 :
136 :
137 :
138 :
139 :
140 :
141 :
142 : x->antennaType = antennaType;
143 :
144 :
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 :
153 : x->dishDiameter = dishDiameter.toIDLLength();
154 :
155 :
156 :
157 :
158 :
159 :
160 :
161 :
162 :
163 : x->position.length(position.size());
164 : for (unsigned int i = 0; i < position.size(); ++i) {
165 :
166 : x->position[i] = position.at(i).toIDLLength();
167 :
168 : }
169 :
170 :
171 :
172 :
173 :
174 :
175 :
176 :
177 :
178 : x->offset.length(offset.size());
179 : for (unsigned int i = 0; i < offset.size(); ++i) {
180 :
181 : x->offset[i] = offset.at(i).toIDLLength();
182 :
183 : }
184 :
185 :
186 :
187 :
188 :
189 :
190 :
191 :
192 :
193 : x->time = time.toIDLArrayTime();
194 :
195 :
196 :
197 :
198 :
199 :
200 :
201 :
202 :
203 :
204 :
205 : x->assocAntennaIdExists = assocAntennaIdExists;
206 :
207 :
208 :
209 :
210 : x->assocAntennaId = assocAntennaId.toIDLTag();
211 :
212 :
213 :
214 :
215 :
216 :
217 :
218 :
219 :
220 :
221 : x->stationId = stationId.toIDLTag();
222 :
223 :
224 :
225 :
226 :
227 :
228 :
229 :
230 :
231 :
232 :
233 : return x;
234 :
235 : }
236 :
237 : void AntennaRow::toIDL(asdmIDL::AntennaRowIDL& x) const {
238 : // Set the x's fields.
239 :
240 :
241 :
242 :
243 :
244 :
245 :
246 : x.antennaId = antennaId.toIDLTag();
247 :
248 :
249 :
250 :
251 :
252 :
253 :
254 :
255 :
256 :
257 : x.name = CORBA::string_dup(name.c_str());
258 :
259 :
260 :
261 :
262 :
263 :
264 :
265 :
266 :
267 :
268 :
269 : x.antennaMake = antennaMake;
270 :
271 :
272 :
273 :
274 :
275 :
276 :
277 :
278 :
279 :
280 :
281 : x.antennaType = antennaType;
282 :
283 :
284 :
285 :
286 :
287 :
288 :
289 :
290 :
291 :
292 : x.dishDiameter = dishDiameter.toIDLLength();
293 :
294 :
295 :
296 :
297 :
298 :
299 :
300 :
301 :
302 : x.position.length(position.size());
303 : for (unsigned int i = 0; i < position.size(); ++i) {
304 :
305 : x.position[i] = position.at(i).toIDLLength();
306 :
307 : }
308 :
309 :
310 :
311 :
312 :
313 :
314 :
315 :
316 :
317 : x.offset.length(offset.size());
318 : for (unsigned int i = 0; i < offset.size(); ++i) {
319 :
320 : x.offset[i] = offset.at(i).toIDLLength();
321 :
322 : }
323 :
324 :
325 :
326 :
327 :
328 :
329 :
330 :
331 :
332 : x.time = time.toIDLArrayTime();
333 :
334 :
335 :
336 :
337 :
338 :
339 :
340 :
341 :
342 :
343 :
344 : x.assocAntennaIdExists = assocAntennaIdExists;
345 :
346 :
347 :
348 :
349 : x.assocAntennaId = assocAntennaId.toIDLTag();
350 :
351 :
352 :
353 :
354 :
355 :
356 :
357 :
358 :
359 :
360 : x.stationId = stationId.toIDLTag();
361 :
362 :
363 :
364 :
365 :
366 :
367 :
368 :
369 :
370 :
371 :
372 : }
373 : #endif
374 :
375 :
376 : #ifndef WITHOUT_ACS
377 : /**
378 : * Fill the values of this row from the IDL struct AntennaRowIDL.
379 : * @param x The IDL struct containing the values used to fill this row.
380 : */
381 : void AntennaRow::setFromIDL (AntennaRowIDL x){
382 : try {
383 : // Fill the values from x.
384 :
385 :
386 :
387 :
388 :
389 :
390 : setAntennaId(Tag (x.antennaId));
391 :
392 :
393 :
394 :
395 :
396 :
397 :
398 :
399 :
400 : setName(string (x.name));
401 :
402 :
403 :
404 :
405 :
406 :
407 :
408 :
409 :
410 : setAntennaMake(x.antennaMake);
411 :
412 :
413 :
414 :
415 :
416 :
417 :
418 :
419 :
420 : setAntennaType(x.antennaType);
421 :
422 :
423 :
424 :
425 :
426 :
427 :
428 :
429 :
430 : setDishDiameter(Length (x.dishDiameter));
431 :
432 :
433 :
434 :
435 :
436 :
437 :
438 :
439 :
440 : position .clear();
441 : for (unsigned int i = 0; i <x.position.length(); ++i) {
442 :
443 : position.push_back(Length (x.position[i]));
444 :
445 : }
446 :
447 :
448 :
449 :
450 :
451 :
452 :
453 :
454 :
455 : offset .clear();
456 : for (unsigned int i = 0; i <x.offset.length(); ++i) {
457 :
458 : offset.push_back(Length (x.offset[i]));
459 :
460 : }
461 :
462 :
463 :
464 :
465 :
466 :
467 :
468 :
469 :
470 : setTime(ArrayTime (x.time));
471 :
472 :
473 :
474 :
475 :
476 :
477 :
478 :
479 :
480 :
481 : assocAntennaIdExists = x.assocAntennaIdExists;
482 : if (x.assocAntennaIdExists) {
483 :
484 :
485 :
486 : setAssocAntennaId(Tag (x.assocAntennaId));
487 :
488 :
489 :
490 : }
491 :
492 :
493 :
494 :
495 :
496 :
497 :
498 : setStationId(Tag (x.stationId));
499 :
500 :
501 :
502 :
503 :
504 :
505 :
506 :
507 :
508 :
509 :
510 : } catch (const IllegalAccessException &err) {
511 : throw ConversionException (err.getMessage(),"Antenna");
512 : }
513 : }
514 : #endif
515 :
516 : /**
517 : * Return this row in the form of an XML string.
518 : * @return The values of this row as an XML string.
519 : */
520 0 : string AntennaRow::toXML() const {
521 0 : string buf;
522 0 : buf.append("<row> \n");
523 :
524 :
525 :
526 :
527 :
528 :
529 0 : Parser::toXML(antennaId, "antennaId", buf);
530 :
531 :
532 :
533 :
534 :
535 :
536 :
537 0 : Parser::toXML(name, "name", buf);
538 :
539 :
540 :
541 :
542 :
543 :
544 :
545 0 : buf.append(EnumerationParser::toXML("antennaMake", antennaMake));
546 :
547 :
548 :
549 :
550 :
551 :
552 :
553 0 : buf.append(EnumerationParser::toXML("antennaType", antennaType));
554 :
555 :
556 :
557 :
558 :
559 :
560 :
561 0 : Parser::toXML(dishDiameter, "dishDiameter", buf);
562 :
563 :
564 :
565 :
566 :
567 :
568 :
569 0 : Parser::toXML(position, "position", buf);
570 :
571 :
572 :
573 :
574 :
575 :
576 :
577 0 : Parser::toXML(offset, "offset", buf);
578 :
579 :
580 :
581 :
582 :
583 :
584 :
585 0 : Parser::toXML(time, "time", buf);
586 :
587 :
588 :
589 :
590 :
591 :
592 :
593 :
594 :
595 0 : if (assocAntennaIdExists) {
596 :
597 :
598 0 : Parser::toXML(assocAntennaId, "assocAntennaId", buf);
599 :
600 :
601 : }
602 :
603 :
604 :
605 :
606 :
607 :
608 0 : Parser::toXML(stationId, "stationId", buf);
609 :
610 :
611 :
612 :
613 :
614 :
615 :
616 :
617 :
618 :
619 :
620 0 : buf.append("</row>\n");
621 0 : return buf;
622 0 : }
623 :
624 : /**
625 : * Fill the values of this row from an XML string
626 : * that was produced by the toXML() method.
627 : * @param x The XML string being used to set the values of this row.
628 : */
629 0 : void AntennaRow::setFromXML (string rowDoc) {
630 0 : Parser row(rowDoc);
631 0 : string s = "";
632 : try {
633 :
634 :
635 :
636 :
637 :
638 0 : setAntennaId(Parser::getTag("antennaId","Antenna",rowDoc));
639 :
640 :
641 :
642 :
643 :
644 :
645 :
646 0 : setName(Parser::getString("name","Antenna",rowDoc));
647 :
648 :
649 :
650 :
651 :
652 :
653 :
654 :
655 0 : antennaMake = EnumerationParser::getAntennaMake("antennaMake","Antenna",rowDoc);
656 :
657 :
658 :
659 :
660 :
661 :
662 :
663 :
664 :
665 0 : antennaType = EnumerationParser::getAntennaType("antennaType","Antenna",rowDoc);
666 :
667 :
668 :
669 :
670 :
671 :
672 :
673 :
674 0 : setDishDiameter(Parser::getLength("dishDiameter","Antenna",rowDoc));
675 :
676 :
677 :
678 :
679 :
680 :
681 :
682 :
683 0 : setPosition(Parser::get1DLength("position","Antenna",rowDoc));
684 :
685 :
686 :
687 :
688 :
689 :
690 :
691 :
692 :
693 0 : setOffset(Parser::get1DLength("offset","Antenna",rowDoc));
694 :
695 :
696 :
697 :
698 :
699 :
700 :
701 :
702 0 : setTime(Parser::getArrayTime("time","Antenna",rowDoc));
703 :
704 :
705 :
706 :
707 :
708 :
709 :
710 :
711 :
712 0 : if (row.isStr("<assocAntennaId>")) {
713 :
714 0 : setAssocAntennaId(Parser::getTag("assocAntennaId","Antenna",rowDoc));
715 :
716 : }
717 :
718 :
719 :
720 :
721 :
722 :
723 0 : setStationId(Parser::getTag("stationId","Antenna",rowDoc));
724 :
725 :
726 :
727 :
728 :
729 :
730 :
731 :
732 :
733 :
734 0 : } catch (const IllegalAccessException &err) {
735 0 : throw ConversionException (err.getMessage(),"Antenna");
736 0 : }
737 0 : }
738 :
739 0 : void AntennaRow::toBin(EndianOSStream& eoss) {
740 :
741 :
742 :
743 :
744 :
745 0 : antennaId.toBin(eoss);
746 :
747 :
748 :
749 :
750 :
751 :
752 :
753 0 : eoss.writeString(name);
754 :
755 :
756 :
757 :
758 :
759 :
760 :
761 :
762 0 : eoss.writeString(CAntennaMake::name(antennaMake));
763 : /* eoss.writeInt(antennaMake); */
764 :
765 :
766 :
767 :
768 :
769 :
770 :
771 :
772 0 : eoss.writeString(CAntennaType::name(antennaType));
773 : /* eoss.writeInt(antennaType); */
774 :
775 :
776 :
777 :
778 :
779 :
780 :
781 0 : dishDiameter.toBin(eoss);
782 :
783 :
784 :
785 :
786 :
787 :
788 0 : Length::toBin(position, eoss);
789 :
790 :
791 :
792 :
793 :
794 :
795 0 : Length::toBin(offset, eoss);
796 :
797 :
798 :
799 :
800 :
801 :
802 0 : time.toBin(eoss);
803 :
804 :
805 :
806 :
807 :
808 :
809 0 : stationId.toBin(eoss);
810 :
811 :
812 :
813 :
814 :
815 :
816 0 : eoss.writeBoolean(assocAntennaIdExists);
817 0 : if (assocAntennaIdExists) {
818 :
819 :
820 :
821 :
822 0 : assocAntennaId.toBin(eoss);
823 :
824 :
825 :
826 : }
827 :
828 0 : }
829 :
830 0 : void AntennaRow::antennaIdFromBin(EndianIStream& eis) {
831 :
832 :
833 :
834 :
835 0 : antennaId = Tag::fromBin(eis);
836 :
837 :
838 :
839 0 : }
840 0 : void AntennaRow::nameFromBin(EndianIStream& eis) {
841 :
842 :
843 :
844 :
845 :
846 0 : name = eis.readString();
847 :
848 :
849 :
850 :
851 0 : }
852 0 : void AntennaRow::antennaMakeFromBin(EndianIStream& eis) {
853 :
854 :
855 :
856 :
857 :
858 0 : antennaMake = CAntennaMake::literal(eis.readString());
859 :
860 :
861 :
862 :
863 0 : }
864 0 : void AntennaRow::antennaTypeFromBin(EndianIStream& eis) {
865 :
866 :
867 :
868 :
869 :
870 0 : antennaType = CAntennaType::literal(eis.readString());
871 :
872 :
873 :
874 :
875 0 : }
876 0 : void AntennaRow::dishDiameterFromBin(EndianIStream& eis) {
877 :
878 :
879 :
880 :
881 0 : dishDiameter = Length::fromBin(eis);
882 :
883 :
884 :
885 0 : }
886 0 : void AntennaRow::positionFromBin(EndianIStream& eis) {
887 :
888 :
889 :
890 :
891 :
892 :
893 0 : position = Length::from1DBin(eis);
894 :
895 :
896 :
897 :
898 :
899 0 : }
900 0 : void AntennaRow::offsetFromBin(EndianIStream& eis) {
901 :
902 :
903 :
904 :
905 :
906 :
907 0 : offset = Length::from1DBin(eis);
908 :
909 :
910 :
911 :
912 :
913 0 : }
914 0 : void AntennaRow::timeFromBin(EndianIStream& eis) {
915 :
916 :
917 :
918 :
919 0 : time = ArrayTime::fromBin(eis);
920 :
921 :
922 :
923 0 : }
924 0 : void AntennaRow::stationIdFromBin(EndianIStream& eis) {
925 :
926 :
927 :
928 :
929 0 : stationId = Tag::fromBin(eis);
930 :
931 :
932 :
933 0 : }
934 :
935 0 : void AntennaRow::assocAntennaIdFromBin(EndianIStream& eis) {
936 :
937 0 : assocAntennaIdExists = eis.readBoolean();
938 0 : if (assocAntennaIdExists) {
939 :
940 :
941 :
942 :
943 0 : assocAntennaId = Tag::fromBin(eis);
944 :
945 :
946 :
947 : }
948 :
949 0 : }
950 :
951 :
952 0 : AntennaRow* AntennaRow::fromBin(EndianIStream& eis, AntennaTable& table, const vector<string>& attributesSeq) {
953 0 : AntennaRow* row = new AntennaRow(table);
954 :
955 0 : map<string, AntennaAttributeFromBin>::iterator iter ;
956 0 : for (unsigned int i = 0; i < attributesSeq.size(); i++) {
957 0 : iter = row->fromBinMethods.find(attributesSeq.at(i));
958 0 : if (iter != row->fromBinMethods.end()) {
959 0 : (row->*(row->fromBinMethods[ attributesSeq.at(i) ] ))(eis);
960 : }
961 : else {
962 0 : BinaryAttributeReaderFunctor* functorP = table.getUnknownAttributeBinaryReader(attributesSeq.at(i));
963 0 : if (functorP)
964 0 : (*functorP)(eis);
965 : else
966 0 : throw ConversionException("There is not method to read an attribute '"+attributesSeq.at(i)+"'.", "AntennaTable");
967 : }
968 :
969 : }
970 0 : return row;
971 : }
972 :
973 : //
974 : // A collection of methods to set the value of the attributes from their textual value in the XML representation
975 : // of one row.
976 : //
977 :
978 : // Convert a string into an Tag
979 0 : void AntennaRow::antennaIdFromText(const string & s) {
980 :
981 :
982 0 : antennaId = ASDMValuesParser::parse<Tag>(s);
983 :
984 :
985 0 : }
986 :
987 :
988 : // Convert a string into an String
989 0 : void AntennaRow::nameFromText(const string & s) {
990 :
991 :
992 0 : name = ASDMValuesParser::parse<string>(s);
993 :
994 :
995 0 : }
996 :
997 :
998 : // Convert a string into an AntennaMake
999 0 : void AntennaRow::antennaMakeFromText(const string & s) {
1000 :
1001 :
1002 0 : antennaMake = ASDMValuesParser::parse<AntennaMakeMod::AntennaMake>(s);
1003 :
1004 :
1005 0 : }
1006 :
1007 :
1008 : // Convert a string into an AntennaType
1009 0 : void AntennaRow::antennaTypeFromText(const string & s) {
1010 :
1011 :
1012 0 : antennaType = ASDMValuesParser::parse<AntennaTypeMod::AntennaType>(s);
1013 :
1014 :
1015 0 : }
1016 :
1017 :
1018 : // Convert a string into an Length
1019 0 : void AntennaRow::dishDiameterFromText(const string & s) {
1020 :
1021 :
1022 0 : dishDiameter = ASDMValuesParser::parse<Length>(s);
1023 :
1024 :
1025 0 : }
1026 :
1027 :
1028 : // Convert a string into an Length
1029 0 : void AntennaRow::positionFromText(const string & s) {
1030 :
1031 :
1032 0 : position = ASDMValuesParser::parse1D<Length>(s);
1033 :
1034 :
1035 0 : }
1036 :
1037 :
1038 : // Convert a string into an Length
1039 0 : void AntennaRow::offsetFromText(const string & s) {
1040 :
1041 :
1042 0 : offset = ASDMValuesParser::parse1D<Length>(s);
1043 :
1044 :
1045 0 : }
1046 :
1047 :
1048 : // Convert a string into an ArrayTime
1049 0 : void AntennaRow::timeFromText(const string & s) {
1050 :
1051 :
1052 0 : time = ASDMValuesParser::parse<ArrayTime>(s);
1053 :
1054 :
1055 0 : }
1056 :
1057 :
1058 : // Convert a string into an Tag
1059 0 : void AntennaRow::stationIdFromText(const string & s) {
1060 :
1061 :
1062 0 : stationId = ASDMValuesParser::parse<Tag>(s);
1063 :
1064 :
1065 0 : }
1066 :
1067 :
1068 :
1069 : // Convert a string into an Tag
1070 0 : void AntennaRow::assocAntennaIdFromText(const string & s) {
1071 0 : assocAntennaIdExists = true;
1072 :
1073 :
1074 0 : assocAntennaId = ASDMValuesParser::parse<Tag>(s);
1075 :
1076 :
1077 0 : }
1078 :
1079 :
1080 :
1081 0 : void AntennaRow::fromText(const std::string& attributeName, const std::string& t) {
1082 0 : map<string, AntennaAttributeFromText>::iterator iter;
1083 0 : if ((iter = fromTextMethods.find(attributeName)) == fromTextMethods.end())
1084 0 : throw ConversionException("I do not know what to do with '"+attributeName+"' and its content '"+t+"' (while parsing an XML document)", "AntennaTable");
1085 0 : (this->*(iter->second))(t);
1086 0 : }
1087 :
1088 : ////////////////////////////////////////////////
1089 : // Intrinsic Table Attributes getters/setters //
1090 : ////////////////////////////////////////////////
1091 :
1092 :
1093 :
1094 :
1095 : /**
1096 : * Get antennaId.
1097 : * @return antennaId as Tag
1098 : */
1099 0 : Tag AntennaRow::getAntennaId() const {
1100 :
1101 0 : return antennaId;
1102 : }
1103 :
1104 : /**
1105 : * Set antennaId with the specified Tag.
1106 : * @param antennaId The Tag value to which antennaId is to be set.
1107 :
1108 :
1109 :
1110 : * @throw IllegalAccessException If an attempt is made to change this field after is has been added to the table.
1111 :
1112 : */
1113 0 : void AntennaRow::setAntennaId (Tag antennaId) {
1114 :
1115 :
1116 0 : if (hasBeenAdded) {
1117 :
1118 0 : throw IllegalAccessException("antennaId", "Antenna");
1119 :
1120 : }
1121 :
1122 0 : this->antennaId = antennaId;
1123 :
1124 0 : }
1125 :
1126 :
1127 :
1128 :
1129 :
1130 :
1131 : /**
1132 : * Get name.
1133 : * @return name as std::string
1134 : */
1135 0 : std::string AntennaRow::getName() const {
1136 :
1137 0 : return name;
1138 : }
1139 :
1140 : /**
1141 : * Set name with the specified std::string.
1142 : * @param name The std::string value to which name is to be set.
1143 :
1144 :
1145 :
1146 : */
1147 0 : void AntennaRow::setName (std::string name) {
1148 :
1149 :
1150 0 : if (hasBeenAdded) {
1151 :
1152 : }
1153 :
1154 0 : this->name = name;
1155 :
1156 0 : }
1157 :
1158 :
1159 :
1160 :
1161 :
1162 :
1163 : /**
1164 : * Get antennaMake.
1165 : * @return antennaMake as AntennaMakeMod::AntennaMake
1166 : */
1167 0 : AntennaMakeMod::AntennaMake AntennaRow::getAntennaMake() const {
1168 :
1169 0 : return antennaMake;
1170 : }
1171 :
1172 : /**
1173 : * Set antennaMake with the specified AntennaMakeMod::AntennaMake.
1174 : * @param antennaMake The AntennaMakeMod::AntennaMake value to which antennaMake is to be set.
1175 :
1176 :
1177 :
1178 : */
1179 0 : void AntennaRow::setAntennaMake (AntennaMakeMod::AntennaMake antennaMake) {
1180 :
1181 :
1182 0 : if (hasBeenAdded) {
1183 :
1184 : }
1185 :
1186 0 : this->antennaMake = antennaMake;
1187 :
1188 0 : }
1189 :
1190 :
1191 :
1192 :
1193 :
1194 :
1195 : /**
1196 : * Get antennaType.
1197 : * @return antennaType as AntennaTypeMod::AntennaType
1198 : */
1199 0 : AntennaTypeMod::AntennaType AntennaRow::getAntennaType() const {
1200 :
1201 0 : return antennaType;
1202 : }
1203 :
1204 : /**
1205 : * Set antennaType with the specified AntennaTypeMod::AntennaType.
1206 : * @param antennaType The AntennaTypeMod::AntennaType value to which antennaType is to be set.
1207 :
1208 :
1209 :
1210 : */
1211 0 : void AntennaRow::setAntennaType (AntennaTypeMod::AntennaType antennaType) {
1212 :
1213 :
1214 0 : if (hasBeenAdded) {
1215 :
1216 : }
1217 :
1218 0 : this->antennaType = antennaType;
1219 :
1220 0 : }
1221 :
1222 :
1223 :
1224 :
1225 :
1226 :
1227 : /**
1228 : * Get dishDiameter.
1229 : * @return dishDiameter as Length
1230 : */
1231 0 : Length AntennaRow::getDishDiameter() const {
1232 :
1233 0 : return dishDiameter;
1234 : }
1235 :
1236 : /**
1237 : * Set dishDiameter with the specified Length.
1238 : * @param dishDiameter The Length value to which dishDiameter is to be set.
1239 :
1240 :
1241 :
1242 : */
1243 0 : void AntennaRow::setDishDiameter (Length dishDiameter) {
1244 :
1245 :
1246 0 : if (hasBeenAdded) {
1247 :
1248 : }
1249 :
1250 0 : this->dishDiameter = dishDiameter;
1251 :
1252 0 : }
1253 :
1254 :
1255 :
1256 :
1257 :
1258 :
1259 : /**
1260 : * Get position.
1261 : * @return position as std::vector<Length >
1262 : */
1263 0 : std::vector<Length > AntennaRow::getPosition() const {
1264 :
1265 0 : return position;
1266 : }
1267 :
1268 : /**
1269 : * Set position with the specified std::vector<Length >.
1270 : * @param position The std::vector<Length > value to which position is to be set.
1271 :
1272 :
1273 :
1274 : */
1275 0 : void AntennaRow::setPosition (std::vector<Length > position) {
1276 :
1277 :
1278 0 : if (hasBeenAdded) {
1279 :
1280 : }
1281 :
1282 0 : this->position = position;
1283 :
1284 0 : }
1285 :
1286 :
1287 :
1288 :
1289 :
1290 :
1291 : /**
1292 : * Get offset.
1293 : * @return offset as std::vector<Length >
1294 : */
1295 0 : std::vector<Length > AntennaRow::getOffset() const {
1296 :
1297 0 : return offset;
1298 : }
1299 :
1300 : /**
1301 : * Set offset with the specified std::vector<Length >.
1302 : * @param offset The std::vector<Length > value to which offset is to be set.
1303 :
1304 :
1305 :
1306 : */
1307 0 : void AntennaRow::setOffset (std::vector<Length > offset) {
1308 :
1309 :
1310 0 : if (hasBeenAdded) {
1311 :
1312 : }
1313 :
1314 0 : this->offset = offset;
1315 :
1316 0 : }
1317 :
1318 :
1319 :
1320 :
1321 :
1322 :
1323 : /**
1324 : * Get time.
1325 : * @return time as ArrayTime
1326 : */
1327 0 : ArrayTime AntennaRow::getTime() const {
1328 :
1329 0 : return time;
1330 : }
1331 :
1332 : /**
1333 : * Set time with the specified ArrayTime.
1334 : * @param time The ArrayTime value to which time is to be set.
1335 :
1336 :
1337 :
1338 : */
1339 0 : void AntennaRow::setTime (ArrayTime time) {
1340 :
1341 :
1342 0 : if (hasBeenAdded) {
1343 :
1344 : }
1345 :
1346 0 : this->time = time;
1347 :
1348 0 : }
1349 :
1350 :
1351 :
1352 :
1353 : ///////////////////////////////////////////////
1354 : // Extrinsic Table Attributes getters/setters//
1355 : ///////////////////////////////////////////////
1356 :
1357 :
1358 : /**
1359 : * The attribute assocAntennaId is optional. Return true if this attribute exists.
1360 : * @return true if and only if the assocAntennaId attribute exists.
1361 : */
1362 0 : bool AntennaRow::isAssocAntennaIdExists() const {
1363 0 : return assocAntennaIdExists;
1364 : }
1365 :
1366 :
1367 :
1368 : /**
1369 : * Get assocAntennaId, which is optional.
1370 : * @return assocAntennaId as Tag
1371 : * @throw IllegalAccessException If assocAntennaId does not exist.
1372 : */
1373 0 : Tag AntennaRow::getAssocAntennaId() const {
1374 0 : if (!assocAntennaIdExists) {
1375 0 : throw IllegalAccessException("assocAntennaId", "Antenna");
1376 : }
1377 :
1378 0 : return assocAntennaId;
1379 : }
1380 :
1381 : /**
1382 : * Set assocAntennaId with the specified Tag.
1383 : * @param assocAntennaId The Tag value to which assocAntennaId is to be set.
1384 :
1385 :
1386 : */
1387 0 : void AntennaRow::setAssocAntennaId (Tag assocAntennaId) {
1388 :
1389 0 : this->assocAntennaId = assocAntennaId;
1390 :
1391 0 : assocAntennaIdExists = true;
1392 :
1393 0 : }
1394 :
1395 :
1396 : /**
1397 : * Mark assocAntennaId, which is an optional field, as non-existent.
1398 : */
1399 0 : void AntennaRow::clearAssocAntennaId () {
1400 0 : assocAntennaIdExists = false;
1401 0 : }
1402 :
1403 :
1404 :
1405 :
1406 :
1407 : /**
1408 : * Get stationId.
1409 : * @return stationId as Tag
1410 : */
1411 0 : Tag AntennaRow::getStationId() const {
1412 :
1413 0 : return stationId;
1414 : }
1415 :
1416 : /**
1417 : * Set stationId with the specified Tag.
1418 : * @param stationId The Tag value to which stationId is to be set.
1419 :
1420 :
1421 :
1422 : */
1423 0 : void AntennaRow::setStationId (Tag stationId) {
1424 :
1425 :
1426 0 : if (hasBeenAdded) {
1427 :
1428 : }
1429 :
1430 0 : this->stationId = stationId;
1431 :
1432 0 : }
1433 :
1434 :
1435 :
1436 :
1437 : //////////////////////////////////////
1438 : // Links Attributes getters/setters //
1439 : //////////////////////////////////////
1440 :
1441 :
1442 :
1443 :
1444 :
1445 :
1446 :
1447 : // ===> Optional link from a row of Antenna table to a row of Antenna table.
1448 :
1449 : /**
1450 : * The link to table Antenna is optional. Return true if this link exists.
1451 : * @return true if and only if the Antenna link exists.
1452 : */
1453 0 : bool AntennaRow::isAssociatedAntennaExists() const {
1454 0 : return assocAntennaIdExists;
1455 : }
1456 :
1457 : /**
1458 : * Get the optional row in table Antenna by traversing the defined link to that table.
1459 : * @return A row in Antenna table.
1460 : * @throws NoSuchRow if there is no such row in table Antenna or the link does not exist.
1461 : */
1462 0 : AntennaRow *AntennaRow::getAssociatedAntenna() const {
1463 :
1464 0 : if (!assocAntennaIdExists) {
1465 0 : throw NoSuchRow("Antenna","Antenna",true);
1466 : }
1467 :
1468 0 : return table.getContainer().getAntenna().getRowByKey( antennaId );
1469 : }
1470 :
1471 : /**
1472 : * Set the values of the link attributes needed to link this row to a row in table Antenna.
1473 : */
1474 0 : void AntennaRow::setAssociatedAntennaLink(Tag assocAntennaId) {
1475 :
1476 0 : this->assocAntennaId = assocAntennaId;
1477 0 : assocAntennaIdExists = true;
1478 :
1479 0 : }
1480 :
1481 :
1482 :
1483 :
1484 :
1485 :
1486 :
1487 :
1488 :
1489 :
1490 :
1491 :
1492 : /**
1493 : * Returns the pointer to the row in the Station table having Station.stationId == stationId
1494 : * @return a StationRow*
1495 : *
1496 :
1497 : */
1498 0 : StationRow* AntennaRow::getStationUsingStationId() {
1499 :
1500 0 : return table.getContainer().getStation().getRowByKey(stationId);
1501 : }
1502 :
1503 :
1504 :
1505 :
1506 :
1507 : /**
1508 : * Create a AntennaRow.
1509 : * <p>
1510 : * This constructor is private because only the
1511 : * table can create rows. All rows know the table
1512 : * to which they belong.
1513 : * @param table The table to which this row belongs.
1514 : */
1515 0 : AntennaRow::AntennaRow (AntennaTable &t) : table(t) {
1516 0 : hasBeenAdded = false;
1517 :
1518 :
1519 :
1520 :
1521 :
1522 :
1523 :
1524 :
1525 :
1526 :
1527 :
1528 :
1529 :
1530 :
1531 :
1532 :
1533 :
1534 :
1535 :
1536 :
1537 0 : assocAntennaIdExists = false;
1538 :
1539 :
1540 :
1541 :
1542 :
1543 :
1544 :
1545 :
1546 :
1547 :
1548 :
1549 :
1550 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
1551 0 : antennaMake = CAntennaMake::from_int(0);
1552 :
1553 :
1554 :
1555 : // This attribute is scalar and has an enumeration type. Let's initialize it to some valid value (the 1st of the enumeration).
1556 0 : antennaType = CAntennaType::from_int(0);
1557 :
1558 :
1559 :
1560 :
1561 :
1562 :
1563 :
1564 :
1565 :
1566 :
1567 :
1568 :
1569 0 : fromBinMethods["antennaId"] = &AntennaRow::antennaIdFromBin;
1570 0 : fromBinMethods["name"] = &AntennaRow::nameFromBin;
1571 0 : fromBinMethods["antennaMake"] = &AntennaRow::antennaMakeFromBin;
1572 0 : fromBinMethods["antennaType"] = &AntennaRow::antennaTypeFromBin;
1573 0 : fromBinMethods["dishDiameter"] = &AntennaRow::dishDiameterFromBin;
1574 0 : fromBinMethods["position"] = &AntennaRow::positionFromBin;
1575 0 : fromBinMethods["offset"] = &AntennaRow::offsetFromBin;
1576 0 : fromBinMethods["time"] = &AntennaRow::timeFromBin;
1577 0 : fromBinMethods["stationId"] = &AntennaRow::stationIdFromBin;
1578 :
1579 :
1580 0 : fromBinMethods["assocAntennaId"] = &AntennaRow::assocAntennaIdFromBin;
1581 :
1582 :
1583 :
1584 :
1585 :
1586 0 : fromTextMethods["antennaId"] = &AntennaRow::antennaIdFromText;
1587 :
1588 :
1589 :
1590 0 : fromTextMethods["name"] = &AntennaRow::nameFromText;
1591 :
1592 :
1593 :
1594 0 : fromTextMethods["antennaMake"] = &AntennaRow::antennaMakeFromText;
1595 :
1596 :
1597 :
1598 0 : fromTextMethods["antennaType"] = &AntennaRow::antennaTypeFromText;
1599 :
1600 :
1601 :
1602 0 : fromTextMethods["dishDiameter"] = &AntennaRow::dishDiameterFromText;
1603 :
1604 :
1605 :
1606 0 : fromTextMethods["position"] = &AntennaRow::positionFromText;
1607 :
1608 :
1609 :
1610 0 : fromTextMethods["offset"] = &AntennaRow::offsetFromText;
1611 :
1612 :
1613 :
1614 0 : fromTextMethods["time"] = &AntennaRow::timeFromText;
1615 :
1616 :
1617 :
1618 0 : fromTextMethods["stationId"] = &AntennaRow::stationIdFromText;
1619 :
1620 :
1621 :
1622 :
1623 :
1624 0 : fromTextMethods["assocAntennaId"] = &AntennaRow::assocAntennaIdFromText;
1625 :
1626 :
1627 0 : }
1628 :
1629 0 : AntennaRow::AntennaRow (AntennaTable &t, AntennaRow *row) : table(t) {
1630 0 : hasBeenAdded = false;
1631 :
1632 0 : if (row == 0) {
1633 :
1634 :
1635 :
1636 :
1637 :
1638 :
1639 :
1640 :
1641 :
1642 :
1643 :
1644 :
1645 :
1646 :
1647 :
1648 :
1649 :
1650 :
1651 :
1652 :
1653 0 : assocAntennaIdExists = false;
1654 :
1655 :
1656 :
1657 :
1658 : }
1659 : else {
1660 :
1661 :
1662 0 : antennaId = row->antennaId;
1663 :
1664 :
1665 :
1666 :
1667 0 : name = row->name;
1668 :
1669 0 : antennaMake = row->antennaMake;
1670 :
1671 0 : antennaType = row->antennaType;
1672 :
1673 0 : dishDiameter = row->dishDiameter;
1674 :
1675 0 : position = row->position;
1676 :
1677 0 : offset = row->offset;
1678 :
1679 0 : time = row->time;
1680 :
1681 0 : stationId = row->stationId;
1682 :
1683 :
1684 :
1685 :
1686 0 : if (row->assocAntennaIdExists) {
1687 0 : assocAntennaId = row->assocAntennaId;
1688 0 : assocAntennaIdExists = true;
1689 : }
1690 : else
1691 0 : assocAntennaIdExists = false;
1692 :
1693 : }
1694 :
1695 0 : fromBinMethods["antennaId"] = &AntennaRow::antennaIdFromBin;
1696 0 : fromBinMethods["name"] = &AntennaRow::nameFromBin;
1697 0 : fromBinMethods["antennaMake"] = &AntennaRow::antennaMakeFromBin;
1698 0 : fromBinMethods["antennaType"] = &AntennaRow::antennaTypeFromBin;
1699 0 : fromBinMethods["dishDiameter"] = &AntennaRow::dishDiameterFromBin;
1700 0 : fromBinMethods["position"] = &AntennaRow::positionFromBin;
1701 0 : fromBinMethods["offset"] = &AntennaRow::offsetFromBin;
1702 0 : fromBinMethods["time"] = &AntennaRow::timeFromBin;
1703 0 : fromBinMethods["stationId"] = &AntennaRow::stationIdFromBin;
1704 :
1705 :
1706 0 : fromBinMethods["assocAntennaId"] = &AntennaRow::assocAntennaIdFromBin;
1707 :
1708 0 : }
1709 :
1710 :
1711 0 : bool AntennaRow::compareNoAutoInc(std::string name, AntennaMakeMod::AntennaMake antennaMake, AntennaTypeMod::AntennaType antennaType, Length dishDiameter, std::vector<Length > position, std::vector<Length > offset, ArrayTime time, Tag stationId) {
1712 : bool result;
1713 0 : result = true;
1714 :
1715 :
1716 :
1717 0 : result = result && (this->name == name);
1718 :
1719 0 : if (!result) return false;
1720 :
1721 :
1722 :
1723 :
1724 0 : result = result && (this->antennaMake == antennaMake);
1725 :
1726 0 : if (!result) return false;
1727 :
1728 :
1729 :
1730 :
1731 0 : result = result && (this->antennaType == antennaType);
1732 :
1733 0 : if (!result) return false;
1734 :
1735 :
1736 :
1737 :
1738 0 : result = result && (this->dishDiameter == dishDiameter);
1739 :
1740 0 : if (!result) return false;
1741 :
1742 :
1743 :
1744 :
1745 0 : result = result && (this->position == position);
1746 :
1747 0 : if (!result) return false;
1748 :
1749 :
1750 :
1751 :
1752 0 : result = result && (this->offset == offset);
1753 :
1754 0 : if (!result) return false;
1755 :
1756 :
1757 :
1758 :
1759 0 : result = result && (this->time == time);
1760 :
1761 0 : if (!result) return false;
1762 :
1763 :
1764 :
1765 :
1766 0 : result = result && (this->stationId == stationId);
1767 :
1768 0 : if (!result) return false;
1769 :
1770 :
1771 0 : return result;
1772 : }
1773 :
1774 :
1775 :
1776 0 : bool AntennaRow::compareRequiredValue(std::string name, AntennaMakeMod::AntennaMake antennaMake, AntennaTypeMod::AntennaType antennaType, Length dishDiameter, std::vector<Length > position, std::vector<Length > offset, ArrayTime time, Tag stationId) {
1777 : bool result;
1778 0 : result = true;
1779 :
1780 :
1781 0 : if (!(this->name == name)) return false;
1782 :
1783 :
1784 :
1785 0 : if (!(this->antennaMake == antennaMake)) return false;
1786 :
1787 :
1788 :
1789 0 : if (!(this->antennaType == antennaType)) return false;
1790 :
1791 :
1792 :
1793 0 : if (!(this->dishDiameter == dishDiameter)) return false;
1794 :
1795 :
1796 :
1797 0 : if (!(this->position == position)) return false;
1798 :
1799 :
1800 :
1801 0 : if (!(this->offset == offset)) return false;
1802 :
1803 :
1804 :
1805 0 : if (!(this->time == time)) return false;
1806 :
1807 :
1808 :
1809 0 : if (!(this->stationId == stationId)) return false;
1810 :
1811 :
1812 0 : return result;
1813 : }
1814 :
1815 :
1816 : /**
1817 : * Return true if all required attributes of the value part are equal to their homologues
1818 : * in x and false otherwise.
1819 : *
1820 :
1821 : * @param x a pointer on the AntennaRow whose required attributes of the value part
1822 :
1823 : * will be compared with those of this.
1824 : * @return a boolean.
1825 : */
1826 0 : bool AntennaRow::equalByRequiredValue(AntennaRow* x ) {
1827 :
1828 :
1829 0 : if (this->name != x->name) return false;
1830 :
1831 0 : if (this->antennaMake != x->antennaMake) return false;
1832 :
1833 0 : if (this->antennaType != x->antennaType) return false;
1834 :
1835 0 : if (this->dishDiameter != x->dishDiameter) return false;
1836 :
1837 0 : if (this->position != x->position) return false;
1838 :
1839 0 : if (this->offset != x->offset) return false;
1840 :
1841 0 : if (this->time != x->time) return false;
1842 :
1843 0 : if (this->stationId != x->stationId) return false;
1844 :
1845 :
1846 0 : return true;
1847 : }
1848 :
1849 : /*
1850 : map<string, AntennaAttributeFromBin> AntennaRow::initFromBinMethods() {
1851 : map<string, AntennaAttributeFromBin> result;
1852 :
1853 : result["antennaId"] = &AntennaRow::antennaIdFromBin;
1854 : result["name"] = &AntennaRow::nameFromBin;
1855 : result["antennaMake"] = &AntennaRow::antennaMakeFromBin;
1856 : result["antennaType"] = &AntennaRow::antennaTypeFromBin;
1857 : result["dishDiameter"] = &AntennaRow::dishDiameterFromBin;
1858 : result["position"] = &AntennaRow::positionFromBin;
1859 : result["offset"] = &AntennaRow::offsetFromBin;
1860 : result["time"] = &AntennaRow::timeFromBin;
1861 : result["stationId"] = &AntennaRow::stationIdFromBin;
1862 :
1863 :
1864 : result["assocAntennaId"] = &AntennaRow::assocAntennaIdFromBin;
1865 :
1866 :
1867 : return result;
1868 : }
1869 : */
1870 : } // End namespace asdm
1871 :
|
