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