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