casa  5.7.0-16
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PointingModelRow.h
Go to the documentation of this file.
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 PointingModelRow.h
32  */
33 
34 #ifndef PointingModelRow_CLASS
35 #define PointingModelRow_CLASS
36 
37 #include <vector>
38 #include <string>
39 #include <set>
40 
41 #ifndef WITHOUT_ACS
42 #include <asdmIDLC.h>
43 #endif
44 
45 
46 
47 
48 
49 
50 
51 #include <alma/ASDM/Tag.h>
52 
53 
54 
55 
56 
57 
58 
59 
60 
61 
62 
63 
64 
65 
67 
68 
69 
71 
72 
73 
74 
75 
76 
77 
78 
80 #include <alma/ASDM/NoSuchRow.h>
82 
84 //#include <alma/ASDM/TableStreamReader.h>
85 
86 /*\file PointingModel.h
87  \brief Generated from model's revision "-1", branch ""
88 */
89 
90 namespace asdm {
91 
92 //class asdm::PointingModelTable;
93 
94 
95 // class asdm::PointingModelRow;
96 class PointingModelRow;
97 
98 // class asdm::AntennaRow;
99 class AntennaRow;
100 
101 
102 class PointingModelRow;
104 typedef void (PointingModelRow::*PointingModelAttributeFromText) (const std::string& s);
105 
115 //friend class asdm::TableStreamReader<PointingModelTable, PointingModelRow>;
116 
117 public:
118 
119  virtual ~PointingModelRow();
120 
124  PointingModelTable &getTable() const;
125 
130  bool isAdded() const;
131 
133  // Intrinsic Table Attributes //
135 
136 
137  // ===> Attribute pointingModelId
138 
139 
140 
141 
142 
147  int getPointingModelId() const;
148 
149 
150 
151 
152 
153 
154 
155 
156 
157  // ===> Attribute numCoeff
158 
159 
160 
161 
162 
167  int getNumCoeff() const;
168 
169 
170 
171 
179  void setNumCoeff (int numCoeff);
180 
181 
182 
183 
184 
185 
186 
187  // ===> Attribute coeffName
188 
189 
190 
191 
192 
197  std::vector<std::string > getCoeffName() const;
198 
199 
200 
201 
209  void setCoeffName (std::vector<std::string > coeffName);
210 
211 
212 
213 
214 
215 
216 
217  // ===> Attribute coeffVal
218 
219 
220 
221 
222 
227  std::vector<float > getCoeffVal() const;
228 
229 
230 
231 
239  void setCoeffVal (std::vector<float > coeffVal);
240 
241 
242 
243 
244 
245 
246 
247  // ===> Attribute polarizationType
248 
249 
250 
251 
252 
257  PolarizationTypeMod::PolarizationType getPolarizationType() const;
258 
259 
260 
261 
269  void setPolarizationType (PolarizationTypeMod::PolarizationType polarizationType);
270 
271 
272 
273 
274 
275 
276 
277  // ===> Attribute receiverBand
278 
279 
280 
281 
282 
287  ReceiverBandMod::ReceiverBand getReceiverBand() const;
288 
289 
290 
291 
299  void setReceiverBand (ReceiverBandMod::ReceiverBand receiverBand);
300 
301 
302 
303 
304 
305 
306 
307  // ===> Attribute assocNature
308 
309 
310 
311 
312 
317  std::string getAssocNature() const;
318 
319 
320 
321 
329  void setAssocNature (std::string assocNature);
330 
331 
332 
333 
334 
335 
336 
337  // ===> Attribute coeffFormula, which is optional
338 
339 
340 
345  bool isCoeffFormulaExists() const;
346 
347 
348 
354  std::vector<std::string > getCoeffFormula() const;
355 
356 
357 
358 
365  void setCoeffFormula (std::vector<std::string > coeffFormula);
366 
367 
368 
369 
373  void clearCoeffFormula ();
374 
375 
376 
378  // Extrinsic Table Attributes //
380 
381 
382  // ===> Attribute antennaId
383 
384 
385 
386 
387 
392  Tag getAntennaId() const;
393 
394 
395 
396 
406  void setAntennaId (Tag antennaId);
407 
408 
409 
410 
411 
412 
413 
414  // ===> Attribute assocPointingModelId
415 
416 
417 
418 
419 
424  int getAssocPointingModelId() const;
425 
426 
427 
428 
437 
438 
439 
440 
441 
442 
444  // Links //
446 
447 
448 
449 
450 
451  // ===> Slice link from a row of PointingModel table to a collection of row of PointingModel table.
452 
458  std::vector <PointingModelRow *> getPointingModels();
459 
460 
461 
462 
463 
464 
465 
466 
467 
475 
476 
477 
478 
479 
480 
481 
503  bool compareNoAutoInc(Tag antennaId, int numCoeff, std::vector<std::string > coeffName, std::vector<float > coeffVal, PolarizationTypeMod::PolarizationType polarizationType, ReceiverBandMod::ReceiverBand receiverBand, std::string assocNature, int assocPointingModelId);
504 
505 
506 
507 
527  bool compareRequiredValue(int numCoeff, std::vector<std::string > coeffName, std::vector<float > coeffVal, PolarizationTypeMod::PolarizationType polarizationType, ReceiverBandMod::ReceiverBand receiverBand, std::string assocNature, int assocPointingModelId);
528 
529 
539 
540 #ifndef WITHOUT_ACS
541 
545  asdmIDL::PointingModelRowIDL *toIDL() const;
546 
554  void toIDL(asdmIDL::PointingModelRowIDL& x) const;
555 #endif
556 
557 #ifndef WITHOUT_ACS
558 
563  void setFromIDL (asdmIDL::PointingModelRowIDL x) ;
564 #endif
565 
570  std::string toXML() const;
571 
578  void setFromXML (std::string rowDoc) ;
579 
582  // binary-deserialization material from an EndianIStream //
584 
585  std::map<std::string, PointingModelAttributeFromBin> fromBinMethods;
586 void antennaIdFromBin( EndianIStream& eis);
588 void numCoeffFromBin( EndianIStream& eis);
589 void coeffNameFromBin( EndianIStream& eis);
590 void coeffValFromBin( EndianIStream& eis);
595 
597 
598 
606  static PointingModelRow* fromBin(EndianIStream& eis, PointingModelTable& table, const std::vector<std::string>& attributesSeq);
607 
614  void fromText(const std::string& attributeName, const std::string& t);
616 
617 private:
626 
627  // This method is used by the Table class when this row is added to the table.
628  void isAdded(bool added);
629 
630 
640 
659 
661  // Intrinsic Table Attributes //
663 
664 
665  // ===> Attribute pointingModelId
666 
667 
668 
669  int pointingModelId;
670 
671 
672 
673 
683  void setPointingModelId (int pointingModelId);
684 
685 
686 
687 
688  // ===> Attribute numCoeff
689 
690 
691 
692  int numCoeff;
693 
694 
695 
696 
697 
698 
699  // ===> Attribute coeffName
700 
701 
702 
703  std::vector<std::string > coeffName;
704 
705 
706 
707 
708 
709 
710  // ===> Attribute coeffVal
711 
712 
713 
714  std::vector<float > coeffVal;
715 
716 
717 
718 
719 
720 
721  // ===> Attribute polarizationType
722 
723 
724 
725  PolarizationTypeMod::PolarizationType polarizationType;
726 
727 
728 
729 
730 
731 
732  // ===> Attribute receiverBand
733 
734 
735 
736  ReceiverBandMod::ReceiverBand receiverBand;
737 
738 
739 
740 
741 
742 
743  // ===> Attribute assocNature
744 
745 
746 
747  std::string assocNature;
748 
749 
750 
751 
752 
753 
754  // ===> Attribute coeffFormula, which is optional
755 
756 
758 
759 
760  std::vector<std::string > coeffFormula;
761 
762 
763 
764 
765 
767  // Extrinsic Table Attributes //
769 
770 
771  // ===> Attribute antennaId
772 
773 
774 
775  Tag antennaId;
776 
777 
778 
779 
780 
781 
782  // ===> Attribute assocPointingModelId
783 
784 
785 
787 
788 
789 
790 
791 
793  // Links //
795 
796 
797 
798 
799 
800 
801 
802 
803 
804 
805 
806 
807 
808 
809 
810 /*
812  // binary-deserialization material from an EndianIStream //
814  std::map<std::string, PointingModelAttributeFromBin> fromBinMethods;
815 void antennaIdFromBin( EndianIStream& eis);
816 void pointingModelIdFromBin( EndianIStream& eis);
817 void numCoeffFromBin( EndianIStream& eis);
818 void coeffNameFromBin( EndianIStream& eis);
819 void coeffValFromBin( EndianIStream& eis);
820 void polarizationTypeFromBin( EndianIStream& eis);
821 void receiverBandFromBin( EndianIStream& eis);
822 void assocNatureFromBin( EndianIStream& eis);
823 void assocPointingModelIdFromBin( EndianIStream& eis);
824 
825 void coeffFormulaFromBin( EndianIStream& eis);
826 
827 */
828 
830  // text-deserialization material //
832  std::map<std::string, PointingModelAttributeFromText> fromTextMethods;
833 
834 void antennaIdFromText (const std::string & s);
835 
836 
837 void pointingModelIdFromText (const std::string & s);
838 
839 
840 void numCoeffFromText (const std::string & s);
841 
842 
843 void coeffNameFromText (const std::string & s);
844 
845 
846 void coeffValFromText (const std::string & s);
847 
848 
849 void polarizationTypeFromText (const std::string & s);
850 
851 
852 void receiverBandFromText (const std::string & s);
853 
854 
855 void assocNatureFromText (const std::string & s);
856 
857 
858 void assocPointingModelIdFromText (const std::string & s);
859 
860 
861 
862 void coeffFormulaFromText (const std::string & s);
863 
864 
865 
870  void toBin(EndianOSStream& eoss);
871 
881 };
882 
883 } // End namespace asdm
884 
885 #endif /* PointingModel_CLASS */
bool compareRequiredValue(int numCoeff, std::vector< std::string > coeffName, std::vector< float > coeffVal, PolarizationTypeMod::PolarizationType polarizationType, ReceiverBandMod::ReceiverBand receiverBand, std::string assocNature, int assocPointingModelId)
Compare each mandatory value (i.e.
PolarizationTypeMod::PolarizationType polarizationType
===&gt; Attribute polarizationType
void receiverBandFromText(const std::string &s)
void setFromXML(std::string rowDoc)
Fill the values of this row from an XML string that was produced by the toXML() method.
void coeffFormulaFromText(const std::string &s)
asdmIDL::PointingModelRowIDL * toIDL() const
Return this row in the form of an IDL struct.
void assocNatureFromBin(EndianIStream &eis)
std::vector< std::string > coeffFormula
void coeffNameFromText(const std::string &s)
void setPolarizationType(PolarizationTypeMod::PolarizationType polarizationType)
Set polarizationType with the specified PolarizationTypeMod::PolarizationType.
int numCoeff
===&gt; Attribute numCoeff
void coeffNameFromBin(EndianIStream &eis)
int getNumCoeff() const
===&gt; Attribute numCoeff
The PointingModelTable class is an Alma table.
void setAssocPointingModelId(int assocPointingModelId)
Set assocPointingModelId with the specified int.
void setPointingModelId(int pointingModelId)
Set pointingModelId with the specified int value.
std::string toXML() const
Return this row in the form of an XML string.
std::vector< std::string > getCoeffFormula() const
Get coeffFormula, which is optional.
void toBin(EndianOSStream &eoss)
Serialize this into a stream of bytes written to an EndianOSStream.
bool coeffFormulaExists
===&gt; Attribute coeffFormula, which is optional
void antennaIdFromText(const std::string &s)
void polarizationTypeFromText(const std::string &s)
void numCoeffFromBin(EndianIStream &eis)
PointingModelTable & table
The table to which this row belongs.
void setNumCoeff(int numCoeff)
Set numCoeff with the specified int.
ReceiverBandMod::ReceiverBand getReceiverBand() const
===&gt; Attribute receiverBand
void assocNatureFromText(const std::string &s)
void numCoeffFromText(const std::string &s)
The PointingModelRow class is a row of a PointingModelTable.
std::string getAssocNature() const
===&gt; Attribute assocNature
The AntennaRow class is a row of a AntennaTable.
Definition: AntennaRow.h:120
std::string assocNature
===&gt; Attribute assocNature
ReceiverBandMod::ReceiverBand receiverBand
===&gt; Attribute receiverBand
virtual ~PointingModelRow()
friend class asdm::TableStreamReader&lt;PointingModelTable, PointingModelRow&gt;;
PointingModelRow(PointingModelTable &table)
Create a PointingModelRow.
std::vector< std::string > getCoeffName() const
===&gt; Attribute coeffName
void receiverBandFromBin(EndianIStream &eis)
void clearCoeffFormula()
Mark coeffFormula, which is an optional field, as non-existent.
AntennaRow * getAntennaUsingAntennaId()
antennaId pointer to the row in the Antenna table having Antenna.antennaId == antennaId ...
bool isCoeffFormulaExists() const
===&gt; Attribute coeffFormula, which is optional
PolarizationTypeMod::PolarizationType getPolarizationType() const
===&gt; Attribute polarizationType
int getAssocPointingModelId() const
===&gt; Attribute assocPointingModelId
The Tag class is an implementation of a unique index identifying a row of an ASDM table...
Definition: Tag.h:73
Links *binary deserialization material from an EndianIStream std::map< std::string, PointingModelAttributeFromBin > fromBinMethods
void(PointingModelRow::* PointingModelAttributeFromBin)(EndianIStream &eis)
void(PointingModelRow::* PointingModelAttributeFromText)(const std::string &s)
void setAntennaId(Tag antennaId)
Set antennaId with the specified Tag.
void coeffFormulaFromBin(EndianIStream &eis)
void setAssocNature(std::string assocNature)
Set assocNature with the specified std::string.
bool compareNoAutoInc(Tag antennaId, int numCoeff, std::vector< std::string > coeffName, std::vector< float > coeffVal, PolarizationTypeMod::PolarizationType polarizationType, ReceiverBandMod::ReceiverBand receiverBand, std::string assocNature, int assocPointingModelId)
Compare each mandatory attribute except the autoincrementable one of this PointingModelRow with the c...
std::vector< float > coeffVal
===&gt; Attribute coeffVal
int assocPointingModelId
===&gt; Attribute assocPointingModelId
bool hasBeenAdded
Whether this row has been added to the table or not.
void setCoeffVal(std::vector< float > coeffVal)
Set coeffVal with the specified std::vector&lt;float &gt;.
PointingModelTable & getTable() const
Return the table to which this row belongs.
void setCoeffName(std::vector< std::string > coeffName)
Set coeffName with the specified std::vector&lt;std::string &gt;.
*text deserialization material std::map< std::string, PointingModelAttributeFromText > fromTextMethods
bool isAdded() const
Has this row been added to its table ?
void assocPointingModelIdFromText(const std::string &s)
std::vector< std::string > coeffName
===&gt; Attribute coeffName
std::vector< float > getCoeffVal() const
===&gt; Attribute coeffVal
void setCoeffFormula(std::vector< std::string > coeffFormula)
Set coeffFormula with the specified std::vector&lt;std::string &gt;.
void pointingModelIdFromBin(EndianIStream &eis)
bool equalByRequiredValue(PointingModelRow *x)
Return true if all required attributes of the value part are equal to their homologues in x and false...
void setReceiverBand(ReceiverBandMod::ReceiverBand receiverBand)
Set receiverBand with the specified ReceiverBandMod::ReceiverBand.
void antennaIdFromBin(EndianIStream &eis)
void pointingModelIdFromText(const std::string &s)
void assocPointingModelIdFromBin(EndianIStream &eis)
void polarizationTypeFromBin(EndianIStream &eis)
void coeffValFromText(const std::string &s)
void coeffValFromBin(EndianIStream &eis)
void setFromIDL(asdmIDL::PointingModelRowIDL x)
Fill the values of this row from the IDL struct PointingModelRowIDL.