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