casa  5.7.0-16
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SeeingRow.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 SeeingRow.h
32  */
33 
34 #ifndef SeeingRow_CLASS
35 #define SeeingRow_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 
52 
53 
54 
55 #include <alma/ASDM/Angle.h>
56 
57 
58 
59 #include <alma/ASDM/Length.h>
60 
61 
62 
63 
64 
65 
66 
67 
68 
69 
70 
71 
72 
73 
74 
75 
76 
77 
78 
80 #include <alma/ASDM/NoSuchRow.h>
82 
84 //#include <alma/ASDM/TableStreamReader.h>
85 
86 /*\file Seeing.h
87  \brief Generated from model's revision "-1", branch ""
88 */
89 
90 namespace asdm {
91 
92 //class asdm::SeeingTable;
93 
94 
95 
96 class SeeingRow;
98 typedef void (SeeingRow::*SeeingAttributeFromText) (const std::string& s);
99 
106 class SeeingRow {
107 friend class asdm::SeeingTable;
109 //friend class asdm::TableStreamReader<SeeingTable, SeeingRow>;
110 
111 public:
112 
113  virtual ~SeeingRow();
114 
118  SeeingTable &getTable() const;
119 
124  bool isAdded() const;
125 
127  // Intrinsic Table Attributes //
129 
130 
131  // ===> Attribute timeInterval
132 
133 
134 
135 
136 
141  ArrayTimeInterval getTimeInterval() const;
142 
143 
144 
145 
155  void setTimeInterval (ArrayTimeInterval timeInterval);
156 
157 
158 
159 
160 
161 
162 
163  // ===> Attribute numBaseLength
164 
165 
166 
167 
168 
173  int getNumBaseLength() const;
174 
175 
176 
177 
185  void setNumBaseLength (int numBaseLength);
186 
187 
188 
189 
190 
191 
192 
193  // ===> Attribute baseLength
194 
195 
196 
197 
198 
203  std::vector<Length > getBaseLength() const;
204 
205 
206 
207 
215  void setBaseLength (std::vector<Length > baseLength);
216 
217 
218 
219 
220 
221 
222 
223  // ===> Attribute phaseRms
224 
225 
226 
227 
228 
233  std::vector<Angle > getPhaseRms() const;
234 
235 
236 
237 
245  void setPhaseRms (std::vector<Angle > phaseRms);
246 
247 
248 
249 
250 
251 
252 
253  // ===> Attribute seeing
254 
255 
256 
257 
258 
263  float getSeeing() const;
264 
265 
266 
267 
275  void setSeeing (float seeing);
276 
277 
278 
279 
280 
281 
282 
283  // ===> Attribute exponent
284 
285 
286 
287 
288 
293  float getExponent() const;
294 
295 
296 
297 
305  void setExponent (float exponent);
306 
307 
308 
309 
310 
311 
313  // Extrinsic Table Attributes //
315 
317  // Links //
319 
320 
321 
322 
340  bool compareNoAutoInc(ArrayTimeInterval timeInterval, int numBaseLength, std::vector<Length > baseLength, std::vector<Angle > phaseRms, float seeing, float exponent);
341 
342 
343 
344 
360  bool compareRequiredValue(int numBaseLength, std::vector<Length > baseLength, std::vector<Angle > phaseRms, float seeing, float exponent);
361 
362 
372 
373 #ifndef WITHOUT_ACS
374 
378  asdmIDL::SeeingRowIDL *toIDL() const;
379 
387  void toIDL(asdmIDL::SeeingRowIDL& x) const;
388 #endif
389 
390 #ifndef WITHOUT_ACS
391 
396  void setFromIDL (asdmIDL::SeeingRowIDL x) ;
397 #endif
398 
403  std::string toXML() const;
404 
411  void setFromXML (std::string rowDoc) ;
412 
415  // binary-deserialization material from an EndianIStream //
417 
418  std::map<std::string, SeeingAttributeFromBin> fromBinMethods;
421 void baseLengthFromBin( EndianIStream& eis);
422 void phaseRmsFromBin( EndianIStream& eis);
423 void seeingFromBin( EndianIStream& eis);
424 void exponentFromBin( EndianIStream& eis);
425 
426 
427 
435  static SeeingRow* fromBin(EndianIStream& eis, SeeingTable& table, const std::vector<std::string>& attributesSeq);
436 
443  void fromText(const std::string& attributeName, const std::string& t);
445 
446 private:
455 
456  // This method is used by the Table class when this row is added to the table.
457  void isAdded(bool added);
458 
459 
469 
488 
490  // Intrinsic Table Attributes //
492 
493 
494  // ===> Attribute timeInterval
495 
496 
497 
498  ArrayTimeInterval timeInterval;
499 
500 
501 
502 
503 
504 
505  // ===> Attribute numBaseLength
506 
507 
508 
510 
511 
512 
513 
514 
515 
516  // ===> Attribute baseLength
517 
518 
519 
520  std::vector<Length > baseLength;
521 
522 
523 
524 
525 
526 
527  // ===> Attribute phaseRms
528 
529 
530 
531  std::vector<Angle > phaseRms;
532 
533 
534 
535 
536 
537 
538  // ===> Attribute seeing
539 
540 
541 
542  float seeing;
543 
544 
545 
546 
547 
548 
549  // ===> Attribute exponent
550 
551 
552 
553  float exponent;
554 
555 
556 
557 
558 
560  // Extrinsic Table Attributes //
562 
564  // Links //
566 
567 
568 /*
570  // binary-deserialization material from an EndianIStream //
572  std::map<std::string, SeeingAttributeFromBin> fromBinMethods;
573 void timeIntervalFromBin( EndianIStream& eis);
574 void numBaseLengthFromBin( EndianIStream& eis);
575 void baseLengthFromBin( EndianIStream& eis);
576 void phaseRmsFromBin( EndianIStream& eis);
577 void seeingFromBin( EndianIStream& eis);
578 void exponentFromBin( EndianIStream& eis);
579 
580 
581 */
582 
584  // text-deserialization material //
586  std::map<std::string, SeeingAttributeFromText> fromTextMethods;
587 
588 void timeIntervalFromText (const std::string & s);
589 
590 
591 void numBaseLengthFromText (const std::string & s);
592 
593 
594 void baseLengthFromText (const std::string & s);
595 
596 
597 void phaseRmsFromText (const std::string & s);
598 
599 
600 void seeingFromText (const std::string & s);
601 
602 
603 void exponentFromText (const std::string & s);
604 
605 
606 
607 
612  void toBin(EndianOSStream& eoss);
613 
623 };
624 
625 } // End namespace asdm
626 
627 #endif /* Seeing_CLASS */
*text deserialization material std::map< std::string, SeeingAttributeFromText > fromTextMethods
Definition: SeeingRow.h:586
SeeingTable & table
The table to which this row belongs.
Definition: SeeingRow.h:450
void timeIntervalFromBin(EndianIStream &eis)
The ArrayTimeInterval class aggregates an instance of ArrayTime and an instance of Interval...
int getNumBaseLength() const
===&gt; Attribute numBaseLength
void numBaseLengthFromText(const std::string &s)
std::vector< Angle > phaseRms
===&gt; Attribute phaseRms
Definition: SeeingRow.h:531
void(SeeingRow::* SeeingAttributeFromBin)(EndianIStream &eis)
Definition: SeeingRow.h:97
void timeIntervalFromText(const std::string &s)
void toBin(EndianOSStream &eoss)
Serialize this into a stream of bytes written to an EndianOSStream.
bool equalByRequiredValue(SeeingRow *x)
Return true if all required attributes of the value part are equal to their homologues in x and false...
float getExponent() const
===&gt; Attribute exponent
SeeingTable & getTable() const
Return the table to which this row belongs.
void numBaseLengthFromBin(EndianIStream &eis)
bool isAdded() const
Has this row been added to its table ?
void baseLengthFromText(const std::string &s)
void setExponent(float exponent)
Set exponent with the specified float.
float seeing
===&gt; Attribute seeing
Definition: SeeingRow.h:542
void exponentFromText(const std::string &s)
Extrinsic Table Attributes Links *bool compareNoAutoInc(ArrayTimeInterval timeInterval, int numBaseLength, std::vector< Length > baseLength, std::vector< Angle > phaseRms, float seeing, float exponent)
Compare each mandatory attribute except the autoincrementable one of this SeeingRow with the correspo...
float exponent
===&gt; Attribute exponent
Definition: SeeingRow.h:553
void(SeeingRow::* SeeingAttributeFromText)(const std::string &s)
Definition: SeeingRow.h:98
std::vector< Angle > getPhaseRms() const
===&gt; Attribute phaseRms
void setPhaseRms(std::vector< Angle > phaseRms)
Set phaseRms with the specified std::vector&lt;Angle &gt;.
int numBaseLength
===&gt; Attribute numBaseLength
Definition: SeeingRow.h:509
float getSeeing() const
===&gt; Attribute seeing
The SeeingTable class is an Alma table.
Definition: SeeingTable.h:162
std::vector< Length > baseLength
===&gt; Attribute baseLength
Definition: SeeingRow.h:520
void seeingFromBin(EndianIStream &eis)
void setSeeing(float seeing)
Set seeing with the specified float.
void seeingFromText(const std::string &s)
std::string toXML() const
Return this row in the form of an XML string.
The SeeingRow class is a row of a SeeingTable.
Definition: SeeingRow.h:106
void setFromXML(std::string rowDoc)
Fill the values of this row from an XML string that was produced by the toXML() method.
bool hasBeenAdded
Whether this row has been added to the table or not.
Definition: SeeingRow.h:454
std::vector< Length > getBaseLength() const
===&gt; Attribute baseLength
void setNumBaseLength(int numBaseLength)
Set numBaseLength with the specified int.
void setTimeInterval(ArrayTimeInterval timeInterval)
Set timeInterval with the specified ArrayTimeInterval.
void phaseRmsFromText(const std::string &s)
void phaseRmsFromBin(EndianIStream &eis)
bool compareRequiredValue(int numBaseLength, std::vector< Length > baseLength, std::vector< Angle > phaseRms, float seeing, float exponent)
Compare each mandatory value (i.e.
virtual ~SeeingRow()
friend class asdm::TableStreamReader&lt;SeeingTable, SeeingRow&gt;;
void setFromIDL(asdmIDL::SeeingRowIDL x)
Fill the values of this row from the IDL struct SeeingRowIDL.
void exponentFromBin(EndianIStream &eis)
Extrinsic Table Attributes Links *binary deserialization material from an EndianIStream std::map< std::string, SeeingAttributeFromBin > fromBinMethods
Definition: SeeingRow.h:572
void setBaseLength(std::vector< Length > baseLength)
Set baseLength with the specified std::vector&lt;Length &gt;.
SeeingRow(SeeingTable &table)
Create a SeeingRow.
void baseLengthFromBin(EndianIStream &eis)
asdmIDL::SeeingRowIDL * toIDL() const
Return this row in the form of an IDL struct.