casa  5.7.0-16
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AnnotationRow.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 AnnotationRow.h
32  */
33 
34 #ifndef AnnotationRow_CLASS
35 #define AnnotationRow_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 #include <stdint.h>
48 
49 
50 
51 
52 
53 #include <alma/ASDM/ArrayTime.h>
54 
55 
56 
57 #include <alma/ASDM/Tag.h>
58 
59 
60 
61 #include <alma/ASDM/Interval.h>
62 
63 
64 
65 
66 
67 
68 
69 
70 
71 
72 
73 
74 
75 
76 
77 
79 
80 
81 
82 
83 
84 
85 
86 
87 
88 
89 
90 
91 
92 
93 
94 
95 
96 
97 
98 
99 
100 
102 #include <alma/ASDM/NoSuchRow.h>
104 
106 //#include <alma/ASDM/TableStreamReader.h>
107 
108 /*\file Annotation.h
109  \brief Generated from model's revision "-1", branch ""
110 */
111 
112 namespace asdm {
113 
114 //class asdm::AnnotationTable;
115 
116 
117 // class asdm::AntennaRow;
118 class AntennaRow;
119 
120 
121 class AnnotationRow;
123 typedef void (AnnotationRow::*AnnotationAttributeFromText) (const std::string& s);
124 
134 //friend class asdm::TableStreamReader<AnnotationTable, AnnotationRow>;
135 
136 public:
137 
138  virtual ~AnnotationRow();
139 
143  AnnotationTable &getTable() const;
144 
149  bool isAdded() const;
150 
152  // Intrinsic Table Attributes //
154 
155 
156  // ===> Attribute annotationId
157 
158 
159 
160 
161 
166  Tag getAnnotationId() const;
167 
168 
169 
170 
171 
172 
173 
174 
175 
176  // ===> Attribute time
177 
178 
179 
180 
181 
186  ArrayTime getTime() const;
187 
188 
189 
190 
198  void setTime (ArrayTime time);
199 
200 
201 
202 
203 
204 
205 
206  // ===> Attribute issue
207 
208 
209 
210 
211 
216  std::string getIssue() const;
217 
218 
219 
220 
228  void setIssue (std::string issue);
229 
230 
231 
232 
233 
234 
235 
236  // ===> Attribute details
237 
238 
239 
240 
241 
246  std::string getDetails() const;
247 
248 
249 
250 
258  void setDetails (std::string details);
259 
260 
261 
262 
263 
264 
265 
266  // ===> Attribute numAntenna, which is optional
267 
268 
269 
274  bool isNumAntennaExists() const;
275 
276 
277 
283  int getNumAntenna() const;
284 
285 
286 
287 
294  void setNumAntenna (int numAntenna);
295 
296 
297 
298 
302  void clearNumAntenna ();
303 
304 
305 
306 
307  // ===> Attribute basebandName, which is optional
308 
309 
310 
315  bool isBasebandNameExists() const;
316 
317 
318 
324  std::vector<BasebandNameMod::BasebandName > getBasebandName() const;
325 
326 
327 
328 
335  void setBasebandName (std::vector<BasebandNameMod::BasebandName > basebandName);
336 
337 
338 
339 
343  void clearBasebandName ();
344 
345 
346 
347 
348  // ===> Attribute numBaseband, which is optional
349 
350 
351 
356  bool isNumBasebandExists() const;
357 
358 
359 
365  int getNumBaseband() const;
366 
367 
368 
369 
376  void setNumBaseband (int numBaseband);
377 
378 
379 
380 
384  void clearNumBaseband ();
385 
386 
387 
388 
389  // ===> Attribute interval, which is optional
390 
391 
392 
397  bool isIntervalExists() const;
398 
399 
400 
406  Interval getInterval() const;
407 
408 
409 
410 
418 
419 
420 
421 
425  void clearInterval ();
426 
427 
428 
429 
430  // ===> Attribute dValue, which is optional
431 
432 
433 
438  bool isDValueExists() const;
439 
440 
441 
447  double getDValue() const;
448 
449 
450 
451 
458  void setDValue (double dValue);
459 
460 
461 
462 
466  void clearDValue ();
467 
468 
469 
470 
471  // ===> Attribute vdValue, which is optional
472 
473 
474 
479  bool isVdValueExists() const;
480 
481 
482 
488  std::vector<double > getVdValue() const;
489 
490 
491 
492 
499  void setVdValue (std::vector<double > vdValue);
500 
501 
502 
503 
507  void clearVdValue ();
508 
509 
510 
511 
512  // ===> Attribute vvdValues, which is optional
513 
514 
515 
520  bool isVvdValuesExists() const;
521 
522 
523 
529  std::vector<std::vector<double > > getVvdValues() const;
530 
531 
532 
533 
540  void setVvdValues (std::vector<std::vector<double > > vvdValues);
541 
542 
543 
544 
548  void clearVvdValues ();
549 
550 
551 
552 
553  // ===> Attribute llValue, which is optional
554 
555 
556 
561  bool isLlValueExists() const;
562 
563 
564 
570  int64_t getLlValue() const;
571 
572 
573 
574 
581  void setLlValue (int64_t llValue);
582 
583 
584 
585 
589  void clearLlValue ();
590 
591 
592 
593 
594  // ===> Attribute vllValue, which is optional
595 
596 
597 
602  bool isVllValueExists() const;
603 
604 
605 
611  std::vector<int64_t > getVllValue() const;
612 
613 
614 
615 
622  void setVllValue (std::vector<int64_t > vllValue);
623 
624 
625 
626 
630  void clearVllValue ();
631 
632 
633 
634 
635  // ===> Attribute vvllValue, which is optional
636 
637 
638 
643  bool isVvllValueExists() const;
644 
645 
646 
652  std::vector<std::vector<int64_t > > getVvllValue() const;
653 
654 
655 
656 
663  void setVvllValue (std::vector<std::vector<int64_t > > vvllValue);
664 
665 
666 
667 
671  void clearVvllValue ();
672 
673 
674 
675 
676  // ===> Attribute sValue, which is optional
677 
678 
679 
684  bool isSValueExists() const;
685 
686 
687 
693  std::string getSValue() const;
694 
695 
696 
697 
704  void setSValue (std::string sValue);
705 
706 
707 
708 
712  void clearSValue ();
713 
714 
715 
717  // Extrinsic Table Attributes //
719 
720 
721  // ===> Attribute antennaId, which is optional
722 
723 
724 
729  bool isAntennaIdExists() const;
730 
731 
732 
738  std::vector<Tag> getAntennaId() const;
739 
740 
741 
742 
749  void setAntennaId (std::vector<Tag> antennaId);
750 
751 
752 
753 
757  void clearAntennaId ();
758 
759 
760 
762  // Links //
764 
765 
766 
773  void setAntennaId (int i, Tag antennaId) ;
774 
775 
776 
777 
778 
783  void addAntennaId(Tag id);
784 
789  void addAntennaId(const std::vector<Tag> & id);
790 
791 
797  const Tag getAntennaId(int i);
798 
807 
812  std::vector<AntennaRow *> getAntennasUsingAntennaId();
813 
814 
815 
816 
817 
818 
819 
831  bool compareNoAutoInc(ArrayTime time, std::string issue, std::string details);
832 
833 
834 
835 
847  bool compareRequiredValue(ArrayTime time, std::string issue, std::string details);
848 
849 
859 
860 #ifndef WITHOUT_ACS
861 
865  asdmIDL::AnnotationRowIDL *toIDL() const;
866 
874  void toIDL(asdmIDL::AnnotationRowIDL& x) const;
875 #endif
876 
877 #ifndef WITHOUT_ACS
878 
883  void setFromIDL (asdmIDL::AnnotationRowIDL x) ;
884 #endif
885 
890  std::string toXML() const;
891 
898  void setFromXML (std::string rowDoc) ;
899 
902  // binary-deserialization material from an EndianIStream //
904 
905  std::map<std::string, AnnotationAttributeFromBin> fromBinMethods;
907 void timeFromBin( EndianIStream& eis);
908 void issueFromBin( EndianIStream& eis);
909 void detailsFromBin( EndianIStream& eis);
910 
911 void numAntennaFromBin( EndianIStream& eis);
914 void intervalFromBin( EndianIStream& eis);
915 void dValueFromBin( EndianIStream& eis);
916 void vdValueFromBin( EndianIStream& eis);
917 void vvdValuesFromBin( EndianIStream& eis);
918 void llValueFromBin( EndianIStream& eis);
919 void vllValueFromBin( EndianIStream& eis);
920 void vvllValueFromBin( EndianIStream& eis);
921 void sValueFromBin( EndianIStream& eis);
922 void antennaIdFromBin( EndianIStream& eis);
923 
924 
932  static AnnotationRow* fromBin(EndianIStream& eis, AnnotationTable& table, const std::vector<std::string>& attributesSeq);
933 
940  void fromText(const std::string& attributeName, const std::string& t);
942 
943 private:
952 
953  // This method is used by the Table class when this row is added to the table.
954  void isAdded(bool added);
955 
956 
966 
985 
987  // Intrinsic Table Attributes //
989 
990 
991  // ===> Attribute annotationId
992 
993 
994 
995  Tag annotationId;
996 
997 
998 
999 
1009  void setAnnotationId (Tag annotationId);
1010 
1011 
1012 
1013 
1014  // ===> Attribute time
1015 
1016 
1017 
1019 
1020 
1021 
1022 
1023 
1024 
1025  // ===> Attribute issue
1026 
1027 
1028 
1029  std::string issue;
1030 
1031 
1032 
1033 
1034 
1035 
1036  // ===> Attribute details
1037 
1038 
1039 
1040  std::string details;
1041 
1042 
1043 
1044 
1045 
1046 
1047  // ===> Attribute numAntenna, which is optional
1048 
1049 
1051 
1052 
1054 
1055 
1056 
1057 
1058 
1059 
1060  // ===> Attribute basebandName, which is optional
1061 
1062 
1064 
1065 
1066  std::vector<BasebandNameMod::BasebandName > basebandName;
1067 
1068 
1069 
1070 
1071 
1072 
1073  // ===> Attribute numBaseband, which is optional
1074 
1075 
1077 
1078 
1080 
1081 
1082 
1083 
1084 
1085 
1086  // ===> Attribute interval, which is optional
1087 
1088 
1090 
1091 
1093 
1094 
1095 
1096 
1097 
1098 
1099  // ===> Attribute dValue, which is optional
1100 
1101 
1103 
1104 
1105  double dValue;
1106 
1107 
1108 
1109 
1110 
1111 
1112  // ===> Attribute vdValue, which is optional
1113 
1114 
1116 
1117 
1118  std::vector<double > vdValue;
1119 
1120 
1121 
1122 
1123 
1124 
1125  // ===> Attribute vvdValues, which is optional
1126 
1127 
1129 
1130 
1131  std::vector<std::vector<double > > vvdValues;
1132 
1133 
1134 
1135 
1136 
1137 
1138  // ===> Attribute llValue, which is optional
1139 
1140 
1142 
1143 
1144  int64_t llValue;
1145 
1146 
1147 
1148 
1149 
1150 
1151  // ===> Attribute vllValue, which is optional
1152 
1153 
1155 
1156 
1157  std::vector<int64_t > vllValue;
1158 
1159 
1160 
1161 
1162 
1163 
1164  // ===> Attribute vvllValue, which is optional
1165 
1166 
1168 
1169 
1170  std::vector<std::vector<int64_t > > vvllValue;
1171 
1172 
1173 
1174 
1175 
1176 
1177  // ===> Attribute sValue, which is optional
1178 
1179 
1181 
1182 
1183  std::string sValue;
1184 
1185 
1186 
1187 
1188 
1190  // Extrinsic Table Attributes //
1192 
1193 
1194  // ===> Attribute antennaId, which is optional
1195 
1196 
1197  bool antennaIdExists;
1198 
1199 
1200  std::vector<Tag> antennaId;
1201 
1202 
1203 
1204 
1205 
1207  // Links //
1209 
1210 
1211 
1212 
1213 
1214 
1215 
1216 
1217 /*
1219  // binary-deserialization material from an EndianIStream //
1221  std::map<std::string, AnnotationAttributeFromBin> fromBinMethods;
1222 void annotationIdFromBin( EndianIStream& eis);
1223 void timeFromBin( EndianIStream& eis);
1224 void issueFromBin( EndianIStream& eis);
1225 void detailsFromBin( EndianIStream& eis);
1226 
1227 void numAntennaFromBin( EndianIStream& eis);
1228 void basebandNameFromBin( EndianIStream& eis);
1229 void numBasebandFromBin( EndianIStream& eis);
1230 void intervalFromBin( EndianIStream& eis);
1231 void dValueFromBin( EndianIStream& eis);
1232 void vdValueFromBin( EndianIStream& eis);
1233 void vvdValuesFromBin( EndianIStream& eis);
1234 void llValueFromBin( EndianIStream& eis);
1235 void vllValueFromBin( EndianIStream& eis);
1236 void vvllValueFromBin( EndianIStream& eis);
1237 void sValueFromBin( EndianIStream& eis);
1238 void antennaIdFromBin( EndianIStream& eis);
1239 
1240 */
1241 
1243  // text-deserialization material //
1245  std::map<std::string, AnnotationAttributeFromText> fromTextMethods;
1246 
1247 void annotationIdFromText (const std::string & s);
1248 
1249 
1250 void timeFromText (const std::string & s);
1251 
1252 
1253 void issueFromText (const std::string & s);
1254 
1255 
1256 void detailsFromText (const std::string & s);
1257 
1258 
1259 
1260 void numAntennaFromText (const std::string & s);
1261 
1262 
1263 void basebandNameFromText (const std::string & s);
1264 
1265 
1266 void numBasebandFromText (const std::string & s);
1267 
1268 
1269 void intervalFromText (const std::string & s);
1270 
1271 
1272 void dValueFromText (const std::string & s);
1273 
1274 
1275 void vdValueFromText (const std::string & s);
1276 
1277 
1278 void vvdValuesFromText (const std::string & s);
1279 
1280 
1281 void llValueFromText (const std::string & s);
1282 
1283 
1284 void vllValueFromText (const std::string & s);
1285 
1286 
1287 void vvllValueFromText (const std::string & s);
1288 
1289 
1290 void sValueFromText (const std::string & s);
1291 
1292 
1293 void antennaIdFromText (const std::string & s);
1294 
1295 
1296 
1301  void toBin(EndianOSStream& eoss);
1302 
1312 };
1313 
1314 } // End namespace asdm
1315 
1316 #endif /* Annotation_CLASS */
void detailsFromText(const std::string &s)
void toBin(EndianOSStream &eoss)
Serialize this into a stream of bytes written to an EndianOSStream.
void(AnnotationRow::* AnnotationAttributeFromText)(const std::string &s)
AnnotationRow(AnnotationTable &table)
Create a AnnotationRow.
bool numAntennaExists
===&gt; Attribute numAntenna, which is optional
Interval getInterval() const
Get interval, which is optional.
The Interval class implements an interval of time in units of nanoseconds.
Definition: Interval.h:58
std::vector< int64_t > getVllValue() const
Get vllValue, which is optional.
int64_t getLlValue() const
Get llValue, which is optional.
void clearVvllValue()
Mark vvllValue, which is an optional field, as non-existent.
bool hasBeenAdded
Whether this row has been added to the table or not.
std::vector< double > vdValue
void annotationIdFromText(const std::string &s)
bool isAdded() const
Has this row been added to its table ?
void timeFromBin(EndianIStream &eis)
void clearDValue()
Mark dValue, which is an optional field, as non-existent.
bool isVdValueExists() const
===&gt; Attribute vdValue, which is optional
void clearNumAntenna()
Mark numAntenna, which is an optional field, as non-existent.
void llValueFromText(const std::string &s)
std::vector< BasebandNameMod::BasebandName > getBasebandName() const
Get basebandName, which is optional.
void setDValue(double dValue)
Set dValue with the specified double.
void setAnnotationId(Tag annotationId)
Set annotationId with the specified Tag value.
bool vllValueExists
===&gt; Attribute vllValue, which is optional
void clearVvdValues()
Mark vvdValues, which is an optional field, as non-existent.
std::vector< int64_t > vllValue
bool isLlValueExists() const
===&gt; Attribute llValue, which is optional
void intervalFromBin(EndianIStream &eis)
std::string getSValue() const
Get sValue, which is optional.
asdmIDL::AnnotationRowIDL * toIDL() const
Return this row in the form of an IDL struct.
bool isVvllValueExists() const
===&gt; Attribute vvllValue, which is optional
void dValueFromBin(EndianIStream &eis)
void antennaIdFromText(const std::string &s)
std::string details
===&gt; Attribute details
void vvllValueFromBin(EndianIStream &eis)
void clearNumBaseband()
Mark numBaseband, which is an optional field, as non-existent.
double getDValue() const
Get dValue, which is optional.
void setVllValue(std::vector< int64_t > vllValue)
Set vllValue with the specified std::vector&lt;int64_t &gt;.
void issueFromBin(EndianIStream &eis)
bool compareNoAutoInc(ArrayTime time, std::string issue, std::string details)
Compare each mandatory attribute except the autoincrementable one of this AnnotationRow with the corr...
bool vvdValuesExists
===&gt; Attribute vvdValues, which is optional
bool vvllValueExists
===&gt; Attribute vvllValue, which is optional
void setVvdValues(std::vector< std::vector< double > > vvdValues)
Set vvdValues with the specified std::vector&lt;std::vector&lt;double &gt; &gt;.
void numBasebandFromText(const std::string &s)
bool vdValueExists
===&gt; Attribute vdValue, which is optional
void setDetails(std::string details)
Set details with the specified std::string.
void basebandNameFromBin(EndianIStream &eis)
void clearVdValue()
Mark vdValue, which is an optional field, as non-existent.
int getNumBaseband() const
Get numBaseband, which is optional.
std::vector< std::vector< double > > getVvdValues() const
Get vvdValues, which is optional.
ArrayTime getTime() const
===&gt; Attribute time
void setLlValue(int64_t llValue)
Set llValue with the specified int64_t.
bool isIntervalExists() const
===&gt; Attribute interval, which is optional
std::vector< std::vector< int64_t > > vvllValue
int getNumAntenna() const
Get numAntenna, which is optional.
void setAntennaId(std::vector< Tag > antennaId)
Set antennaId with the specified std::vector&lt;Tag&gt; .
AntennaRow * getAntennaUsingAntennaId(int i)
Returns the AntennaRow linked to this row via the tag stored in antennaId at position i...
std::vector< double > getVdValue() const
Get vdValue, which is optional.
void setNumAntenna(int numAntenna)
Set numAntenna with the specified int.
void issueFromText(const std::string &s)
void numAntennaFromBin(EndianIStream &eis)
bool sValueExists
===&gt; Attribute sValue, which is optional
bool isVllValueExists() const
===&gt; Attribute vllValue, which is optional
bool compareRequiredValue(ArrayTime time, std::string issue, std::string details)
Compare each mandatory value (i.e.
The AntennaRow class is a row of a AntennaTable.
Definition: AntennaRow.h:120
void addAntennaId(Tag id)
Append a Tag to antennaId.
bool isNumBasebandExists() const
===&gt; Attribute numBaseband, which is optional
void detailsFromBin(EndianIStream &eis)
std::vector< std::vector< double > > vvdValues
void vllValueFromText(const std::string &s)
void setFromIDL(asdmIDL::AnnotationRowIDL x)
Fill the values of this row from the IDL struct AnnotationRowIDL.
void setSValue(std::string sValue)
Set sValue with the specified std::string.
void numBasebandFromBin(EndianIStream &eis)
The AnnotationRow class is a row of a AnnotationTable.
void clearVllValue()
Mark vllValue, which is an optional field, as non-existent.
void llValueFromBin(EndianIStream &eis)
The ArrayTime class implements the concept of a point in time, implemented as an Interval of time sin...
Definition: ArrayTime.h:89
std::vector< AntennaRow * > getAntennasUsingAntennaId()
Returns the vector of AntennaRow* linked to this row via the Tags stored in antennaId.
void setVvllValue(std::vector< std::vector< int64_t > > vvllValue)
Set vvllValue with the specified std::vector&lt;std::vector&lt;int64_t &gt; &gt;.
void setIssue(std::string issue)
Set issue with the specified std::string.
void vvllValueFromText(const std::string &s)
void clearLlValue()
Mark llValue, which is an optional field, as non-existent.
void intervalFromText(const std::string &s)
std::string getIssue() const
===&gt; Attribute issue
void setFromXML(std::string rowDoc)
Fill the values of this row from an XML string that was produced by the toXML() method.
The Tag class is an implementation of a unique index identifying a row of an ASDM table...
Definition: Tag.h:73
void vllValueFromBin(EndianIStream &eis)
std::vector< Tag > getAntennaId() const
Get antennaId, which is optional.
void setInterval(Interval interval)
Set interval with the specified Interval.
bool isSValueExists() const
===&gt; Attribute sValue, which is optional
Links *binary deserialization material from an EndianIStream std::map< std::string, AnnotationAttributeFromBin > fromBinMethods
void vvdValuesFromBin(EndianIStream &eis)
void setNumBaseband(int numBaseband)
Set numBaseband with the specified int.
AnnotationTable & table
The table to which this row belongs.
void vdValueFromText(const std::string &s)
bool basebandNameExists
===&gt; Attribute basebandName, which is optional
void antennaIdFromBin(EndianIStream &eis)
void dValueFromText(const std::string &s)
std::string issue
===&gt; Attribute issue
bool isVvdValuesExists() const
===&gt; Attribute vvdValues, which is optional
bool dValueExists
===&gt; Attribute dValue, which is optional
std::string toXML() const
Return this row in the form of an XML string.
void numAntennaFromText(const std::string &s)
std::string getDetails() const
===&gt; Attribute details
void vvdValuesFromText(const std::string &s)
void setVdValue(std::vector< double > vdValue)
Set vdValue with the specified std::vector&lt;double &gt;.
std::vector< BasebandNameMod::BasebandName > basebandName
void clearSValue()
Mark sValue, which is an optional field, as non-existent.
bool numBasebandExists
===&gt; Attribute numBaseband, which is optional
virtual ~AnnotationRow()
friend class asdm::TableStreamReader&lt;AnnotationTable, AnnotationRow&gt;;
bool llValueExists
===&gt; Attribute llValue, which is optional
void clearAntennaId()
Mark antennaId, which is an optional field, as non-existent.
*text deserialization material std::map< std::string, AnnotationAttributeFromText > fromTextMethods
bool equalByRequiredValue(AnnotationRow *x)
Return true if all required attributes of the value part are equal to their homologues in x and false...
void vdValueFromBin(EndianIStream &eis)
void clearInterval()
Mark interval, which is an optional field, as non-existent.
std::vector< Tag > antennaId
void(AnnotationRow::* AnnotationAttributeFromBin)(EndianIStream &eis)
void sValueFromText(const std::string &s)
void basebandNameFromText(const std::string &s)
void clearBasebandName()
Mark basebandName, which is an optional field, as non-existent.
void annotationIdFromBin(EndianIStream &eis)
void setTime(ArrayTime time)
Set time with the specified ArrayTime.
bool isBasebandNameExists() const
===&gt; Attribute basebandName, which is optional
bool intervalExists
===&gt; Attribute interval, which is optional
The AnnotationTable class is an Alma table.
bool isDValueExists() const
===&gt; Attribute dValue, which is optional
void timeFromText(const std::string &s)
void sValueFromBin(EndianIStream &eis)
bool isNumAntennaExists() const
===&gt; Attribute numAntenna, which is optional
std::vector< std::vector< int64_t > > getVvllValue() const
Get vvllValue, which is optional.
void setBasebandName(std::vector< BasebandNameMod::BasebandName > basebandName)
Set basebandName with the specified std::vector&lt;BasebandNameMod::BasebandName &gt;.
AnnotationTable & getTable() const
Return the table to which this row belongs.
ArrayTime time
===&gt; Attribute time