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