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