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