casa  5.7.0-16
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ConfigDescriptionRow.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 ConfigDescriptionRow.h
32  */
33 
34 #ifndef ConfigDescriptionRow_CLASS
35 #define ConfigDescriptionRow_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 
65 
66 
67 
68 
69 
70 
71 
73 
74 
75 
77 
78 
79 
80 
81 
83 
84 
85 
86 
87 
89 
90 
91 
92 
94 #include <alma/ASDM/NoSuchRow.h>
96 
98 //#include <alma/ASDM/TableStreamReader.h>
99 
100 /*\file ConfigDescription.h
101  \brief Generated from model's revision "-1", branch ""
102 */
103 
104 namespace asdm {
105 
106 //class asdm::ConfigDescriptionTable;
107 
108 
109 // class asdm::ConfigDescriptionRow;
110 class ConfigDescriptionRow;
111 
112 // class asdm::AntennaRow;
113 class AntennaRow;
114 
115 // class asdm::FeedRow;
116 class FeedRow;
117 
118 // class asdm::SwitchCycleRow;
119 class SwitchCycleRow;
120 
121 // class asdm::DataDescriptionRow;
122 class DataDescriptionRow;
123 
124 // class asdm::ProcessorRow;
125 class ProcessorRow;
126 
127 
128 class ConfigDescriptionRow;
130 typedef void (ConfigDescriptionRow::*ConfigDescriptionAttributeFromText) (const std::string& s);
131 
141 //friend class asdm::TableStreamReader<ConfigDescriptionTable, ConfigDescriptionRow>;
142 
143 public:
144 
145  virtual ~ConfigDescriptionRow();
146 
151 
156  bool isAdded() const;
157 
159  // Intrinsic Table Attributes //
161 
162 
163  // ===> Attribute numAntenna
164 
165 
166 
167 
168 
173  int getNumAntenna() const;
174 
175 
176 
177 
185  void setNumAntenna (int numAntenna);
186 
187 
188 
189 
190 
191 
192 
193  // ===> Attribute numDataDescription
194 
195 
196 
197 
198 
203  int getNumDataDescription() const;
204 
205 
206 
207 
216 
217 
218 
219 
220 
221 
222 
223  // ===> Attribute numFeed
224 
225 
226 
227 
228 
233  int getNumFeed() const;
234 
235 
236 
237 
245  void setNumFeed (int numFeed);
246 
247 
248 
249 
250 
251 
252 
253  // ===> Attribute correlationMode
254 
255 
256 
257 
258 
263  CorrelationModeMod::CorrelationMode getCorrelationMode() const;
264 
265 
266 
267 
275  void setCorrelationMode (CorrelationModeMod::CorrelationMode correlationMode);
276 
277 
278 
279 
280 
281 
282 
283  // ===> Attribute configDescriptionId
284 
285 
286 
287 
288 
293  Tag getConfigDescriptionId() const;
294 
295 
296 
297 
298 
299 
300 
301 
302 
303  // ===> Attribute numAtmPhaseCorrection
304 
305 
306 
307 
308 
313  int getNumAtmPhaseCorrection() const;
314 
315 
316 
317 
326 
327 
328 
329 
330 
331 
332 
333  // ===> Attribute atmPhaseCorrection
334 
335 
336 
337 
338 
343  std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection > getAtmPhaseCorrection() const;
344 
345 
346 
347 
355  void setAtmPhaseCorrection (std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection > atmPhaseCorrection);
356 
357 
358 
359 
360 
361 
362 
363  // ===> Attribute processorType
364 
365 
366 
367 
368 
373  ProcessorTypeMod::ProcessorType getProcessorType() const;
374 
375 
376 
377 
385  void setProcessorType (ProcessorTypeMod::ProcessorType processorType);
386 
387 
388 
389 
390 
391 
392 
393  // ===> Attribute phasedArrayList, which is optional
394 
395 
396 
401  bool isPhasedArrayListExists() const;
402 
403 
404 
410  std::vector<int > getPhasedArrayList() const;
411 
412 
413 
414 
421  void setPhasedArrayList (std::vector<int > phasedArrayList);
422 
423 
424 
425 
429  void clearPhasedArrayList ();
430 
431 
432 
433 
434  // ===> Attribute spectralType
435 
436 
437 
438 
439 
444  SpectralResolutionTypeMod::SpectralResolutionType getSpectralType() const;
445 
446 
447 
448 
456  void setSpectralType (SpectralResolutionTypeMod::SpectralResolutionType spectralType);
457 
458 
459 
460 
461 
462 
463 
464  // ===> Attribute numAssocValues, which is optional
465 
466 
467 
472  bool isNumAssocValuesExists() const;
473 
474 
475 
481  int getNumAssocValues() const;
482 
483 
484 
485 
493 
494 
495 
496 
500  void clearNumAssocValues ();
501 
502 
503 
504 
505  // ===> Attribute assocNature, which is optional
506 
507 
508 
513  bool isAssocNatureExists() const;
514 
515 
516 
522  std::vector<SpectralResolutionTypeMod::SpectralResolutionType > getAssocNature() const;
523 
524 
525 
526 
533  void setAssocNature (std::vector<SpectralResolutionTypeMod::SpectralResolutionType > assocNature);
534 
535 
536 
537 
541  void clearAssocNature ();
542 
543 
544 
546  // Extrinsic Table Attributes //
548 
549 
550  // ===> Attribute antennaId
551 
552 
553 
554 
555 
560  std::vector<Tag> getAntennaId() const;
561 
562 
563 
564 
572  void setAntennaId (std::vector<Tag> antennaId);
573 
574 
575 
576 
577 
578 
579 
580  // ===> Attribute assocConfigDescriptionId, which is optional
581 
582 
583 
589 
590 
591 
597  std::vector<Tag> getAssocConfigDescriptionId() const;
598 
599 
600 
601 
609 
610 
611 
612 
617 
618 
619 
620 
621  // ===> Attribute dataDescriptionId
622 
623 
624 
625 
626 
631  std::vector<Tag> getDataDescriptionId() const;
632 
633 
634 
635 
643  void setDataDescriptionId (std::vector<Tag> dataDescriptionId);
644 
645 
646 
647 
648 
649 
650 
651  // ===> Attribute feedId
652 
653 
654 
655 
656 
661  std::vector<int> getFeedId() const;
662 
663 
664 
665 
673  void setFeedId (std::vector<int> feedId);
674 
675 
676 
677 
678 
679 
680 
681  // ===> Attribute processorId
682 
683 
684 
685 
686 
691  Tag getProcessorId() const;
692 
693 
694 
695 
704 
705 
706 
707 
708 
709 
710 
711  // ===> Attribute switchCycleId
712 
713 
714 
715 
716 
721  std::vector<Tag> getSwitchCycleId() const;
722 
723 
724 
725 
733  void setSwitchCycleId (std::vector<Tag> switchCycleId);
734 
735 
736 
737 
738 
739 
741  // Links //
743 
744 
745 
753 
754 
755 
756 
757 
763 
768  void addAssocConfigDescriptionId(const std::vector<Tag> & id);
769 
770 
776  const Tag getAssocConfigDescriptionId(int i);
777 
786 
791  std::vector<ConfigDescriptionRow *> getConfigDescriptionsUsingAssocConfigDescriptionId();
792 
793 
794 
795 
796 
797 
805  void setAntennaId (int i, Tag antennaId);
806 
807 
808 
809 
810 
815  void addAntennaId(Tag id);
816 
821  void addAntennaId(const std::vector<Tag> & id);
822 
823 
829  const Tag getAntennaId(int i);
830 
839 
844  std::vector<AntennaRow *> getAntennasUsingAntennaId();
845 
846 
847 
848 
849 
850 
858  void setFeedId (int i, int feedId);
859 
860 
861 
862 
863 
864 
865  // ===> Slices link from a row of ConfigDescription table to a collection of row of Feed table.
866 
871  void addFeedId(int id);
872 
877  void addFeedId(std::vector<int> id);
878 
879 
884  const std::vector <FeedRow *> getFeeds(int i);
885 
886 
892  const std::vector <FeedRow *> getFeeds();
893 
894 
895 
896 
897 
898 
899 
907  void setSwitchCycleId (int i, Tag switchCycleId);
908 
909 
910 
911 
912 
917  void addSwitchCycleId(Tag id);
918 
923  void addSwitchCycleId(const std::vector<Tag> & id);
924 
925 
931  const Tag getSwitchCycleId(int i);
932 
941 
946  std::vector<SwitchCycleRow *> getSwitchCyclesUsingSwitchCycleId();
947 
948 
949 
950 
951 
952 
961 
962 
963 
964 
965 
970  void addDataDescriptionId(Tag id);
971 
976  void addDataDescriptionId(const std::vector<Tag> & id);
977 
978 
984  const Tag getDataDescriptionId(int i);
985 
994 
999  std::vector<DataDescriptionRow *> getDataDescriptionsUsingDataDescriptionId();
1000 
1001 
1002 
1003 
1004 
1005 
1006 
1007 
1015 
1016 
1017 
1018 
1019 
1020 
1021 
1053  bool compareNoAutoInc(int numAntenna, int numDataDescription, int numFeed, CorrelationModeMod::CorrelationMode correlationMode, int numAtmPhaseCorrection, std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection > atmPhaseCorrection, ProcessorTypeMod::ProcessorType processorType, SpectralResolutionTypeMod::SpectralResolutionType spectralType, std::vector<Tag> antennaId, std::vector<int> feedId, std::vector<Tag> switchCycleId, std::vector<Tag> dataDescriptionId, Tag processorId);
1054 
1055 
1056 
1057 
1089  bool compareRequiredValue(int numAntenna, int numDataDescription, int numFeed, CorrelationModeMod::CorrelationMode correlationMode, int numAtmPhaseCorrection, std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection > atmPhaseCorrection, ProcessorTypeMod::ProcessorType processorType, SpectralResolutionTypeMod::SpectralResolutionType spectralType, std::vector<Tag> antennaId, std::vector<int> feedId, std::vector<Tag> switchCycleId, std::vector<Tag> dataDescriptionId, Tag processorId);
1090 
1091 
1101 
1102 #ifndef WITHOUT_ACS
1103 
1107  asdmIDL::ConfigDescriptionRowIDL *toIDL() const;
1108 
1116  void toIDL(asdmIDL::ConfigDescriptionRowIDL& x) const;
1117 #endif
1118 
1119 #ifndef WITHOUT_ACS
1120 
1125  void setFromIDL (asdmIDL::ConfigDescriptionRowIDL x) ;
1126 #endif
1127 
1132  std::string toXML() const;
1133 
1140  void setFromXML (std::string rowDoc) ;
1141 
1144  // binary-deserialization material from an EndianIStream //
1146 
1147  std::map<std::string, ConfigDescriptionAttributeFromBin> fromBinMethods;
1149 void numAntennaFromBin( EndianIStream& eis);
1151 void numFeedFromBin( EndianIStream& eis);
1157 void antennaIdFromBin( EndianIStream& eis);
1158 void feedIdFromBin( EndianIStream& eis);
1161 void processorIdFromBin( EndianIStream& eis);
1162 
1165 void assocNatureFromBin( EndianIStream& eis);
1167 
1168 
1176  static ConfigDescriptionRow* fromBin(EndianIStream& eis, ConfigDescriptionTable& table, const std::vector<std::string>& attributesSeq);
1177 
1184  void fromText(const std::string& attributeName, const std::string& t);
1186 
1187 private:
1196 
1197  // This method is used by the Table class when this row is added to the table.
1198  void isAdded(bool added);
1199 
1200 
1210 
1229 
1231  // Intrinsic Table Attributes //
1233 
1234 
1235  // ===> Attribute numAntenna
1236 
1237 
1238 
1239  int numAntenna;
1240 
1241 
1242 
1243 
1244 
1245 
1246  // ===> Attribute numDataDescription
1247 
1248 
1249 
1251 
1252 
1253 
1254 
1255 
1256 
1257  // ===> Attribute numFeed
1258 
1259 
1260 
1261  int numFeed;
1262 
1263 
1264 
1265 
1266 
1267 
1268  // ===> Attribute correlationMode
1269 
1270 
1271 
1272  CorrelationModeMod::CorrelationMode correlationMode;
1273 
1274 
1275 
1276 
1277 
1278 
1279  // ===> Attribute configDescriptionId
1280 
1281 
1282 
1284 
1285 
1286 
1287 
1298 
1299 
1300 
1301 
1302  // ===> Attribute numAtmPhaseCorrection
1303 
1304 
1305 
1307 
1308 
1309 
1310 
1311 
1312 
1313  // ===> Attribute atmPhaseCorrection
1314 
1315 
1316 
1317  std::vector<AtmPhaseCorrectionMod::AtmPhaseCorrection > atmPhaseCorrection;
1318 
1319 
1320 
1321 
1322 
1323 
1324  // ===> Attribute processorType
1325 
1326 
1327 
1328  ProcessorTypeMod::ProcessorType processorType;
1329 
1330 
1331 
1332 
1333 
1334 
1335  // ===> Attribute phasedArrayList, which is optional
1336 
1337 
1339 
1340 
1341  std::vector<int > phasedArrayList;
1342 
1343 
1344 
1345 
1346 
1347 
1348  // ===> Attribute spectralType
1349 
1350 
1351 
1352  SpectralResolutionTypeMod::SpectralResolutionType spectralType;
1353 
1354 
1355 
1356 
1357 
1358 
1359  // ===> Attribute numAssocValues, which is optional
1360 
1361 
1363 
1364 
1366 
1367 
1368 
1369 
1370 
1371 
1372  // ===> Attribute assocNature, which is optional
1373 
1374 
1376 
1377 
1378  std::vector<SpectralResolutionTypeMod::SpectralResolutionType > assocNature;
1379 
1380 
1381 
1382 
1383 
1385  // Extrinsic Table Attributes //
1387 
1388 
1389  // ===> Attribute antennaId
1390 
1391 
1392 
1393  std::vector<Tag> antennaId;
1394 
1395 
1396 
1397 
1398 
1399 
1400  // ===> Attribute assocConfigDescriptionId, which is optional
1401 
1402 
1404 
1405 
1406  std::vector<Tag> assocConfigDescriptionId;
1407 
1408 
1409 
1410 
1411 
1412 
1413  // ===> Attribute dataDescriptionId
1414 
1415 
1416 
1417  std::vector<Tag> dataDescriptionId;
1418 
1419 
1420 
1421 
1422 
1423 
1424  // ===> Attribute feedId
1425 
1426 
1427 
1428  std::vector<int> feedId;
1429 
1430 
1431 
1432 
1433 
1434 
1435  // ===> Attribute processorId
1436 
1437 
1438 
1440 
1441 
1442 
1443 
1444 
1445 
1446  // ===> Attribute switchCycleId
1447 
1448 
1449 
1450  std::vector<Tag> switchCycleId;
1451 
1452 
1453 
1454 
1455 
1457  // Links //
1459 
1460 
1461 
1462 
1463 
1464 
1465 
1466 
1467 
1468 
1469 
1470 
1471 
1472 
1473 
1474 
1475 
1476 
1477 
1478 
1479 
1480 
1481 
1482 
1483 
1484 
1485 
1486 
1487 
1488 
1489 
1490 
1491 
1492 
1493 
1494 
1495 
1496 
1497 
1498 /*
1500  // binary-deserialization material from an EndianIStream //
1502  std::map<std::string, ConfigDescriptionAttributeFromBin> fromBinMethods;
1503 void configDescriptionIdFromBin( EndianIStream& eis);
1504 void numAntennaFromBin( EndianIStream& eis);
1505 void numDataDescriptionFromBin( EndianIStream& eis);
1506 void numFeedFromBin( EndianIStream& eis);
1507 void correlationModeFromBin( EndianIStream& eis);
1508 void numAtmPhaseCorrectionFromBin( EndianIStream& eis);
1509 void atmPhaseCorrectionFromBin( EndianIStream& eis);
1510 void processorTypeFromBin( EndianIStream& eis);
1511 void spectralTypeFromBin( EndianIStream& eis);
1512 void antennaIdFromBin( EndianIStream& eis);
1513 void feedIdFromBin( EndianIStream& eis);
1514 void switchCycleIdFromBin( EndianIStream& eis);
1515 void dataDescriptionIdFromBin( EndianIStream& eis);
1516 void processorIdFromBin( EndianIStream& eis);
1517 
1518 void phasedArrayListFromBin( EndianIStream& eis);
1519 void numAssocValuesFromBin( EndianIStream& eis);
1520 void assocNatureFromBin( EndianIStream& eis);
1521 void assocConfigDescriptionIdFromBin( EndianIStream& eis);
1522 
1523 */
1524 
1526  // text-deserialization material //
1528  std::map<std::string, ConfigDescriptionAttributeFromText> fromTextMethods;
1529 
1530 void configDescriptionIdFromText (const std::string & s);
1531 
1532 
1533 void numAntennaFromText (const std::string & s);
1534 
1535 
1536 void numDataDescriptionFromText (const std::string & s);
1537 
1538 
1539 void numFeedFromText (const std::string & s);
1540 
1541 
1542 void correlationModeFromText (const std::string & s);
1543 
1544 
1545 void numAtmPhaseCorrectionFromText (const std::string & s);
1546 
1547 
1548 void atmPhaseCorrectionFromText (const std::string & s);
1549 
1550 
1551 void processorTypeFromText (const std::string & s);
1552 
1553 
1554 void spectralTypeFromText (const std::string & s);
1555 
1556 
1557 void antennaIdFromText (const std::string & s);
1558 
1559 
1560 void feedIdFromText (const std::string & s);
1561 
1562 
1563 void switchCycleIdFromText (const std::string & s);
1564 
1565 
1566 void dataDescriptionIdFromText (const std::string & s);
1567 
1568 
1569 void processorIdFromText (const std::string & s);
1570 
1571 
1572 
1573 void phasedArrayListFromText (const std::string & s);
1574 
1575 
1576 void numAssocValuesFromText (const std::string & s);
1577 
1578 
1579 void assocNatureFromText (const std::string & s);
1580 
1581 
1582 void assocConfigDescriptionIdFromText (const std::string & s);
1583 
1584 
1585 
1590  void toBin(EndianOSStream& eoss);
1591 
1601 };
1602 
1603 } // End namespace asdm
1604 
1605 #endif /* ConfigDescription_CLASS */
std::vector< Tag > assocConfigDescriptionId
void setProcessorId(Tag processorId)
Set processorId with the specified Tag.
AntennaRow * getAntennaUsingAntennaId(int i)
Returns the AntennaRow linked to this row via the tag stored in antennaId at position i...
void switchCycleIdFromText(const std::string &s)
void assocConfigDescriptionIdFromText(const std::string &s)
void setFromIDL(asdmIDL::ConfigDescriptionRowIDL x)
Fill the values of this row from the IDL struct ConfigDescriptionRowIDL.
void setNumFeed(int numFeed)
Set numFeed with the specified int.
CorrelationModeMod::CorrelationMode correlationMode
===&gt; Attribute correlationMode
void configDescriptionIdFromText(const std::string &s)
void setAssocConfigDescriptionId(std::vector< Tag > assocConfigDescriptionId)
Set assocConfigDescriptionId with the specified std::vector&lt;Tag&gt; .
Links *binary deserialization material from an EndianIStream std::map< std::string, ConfigDescriptionAttributeFromBin > fromBinMethods
bool compareRequiredValue(int numAntenna, int numDataDescription, int numFeed, CorrelationModeMod::CorrelationMode correlationMode, int numAtmPhaseCorrection, std::vector< AtmPhaseCorrectionMod::AtmPhaseCorrection > atmPhaseCorrection, ProcessorTypeMod::ProcessorType processorType, SpectralResolutionTypeMod::SpectralResolutionType spectralType, std::vector< Tag > antennaId, std::vector< int > feedId, std::vector< Tag > switchCycleId, std::vector< Tag > dataDescriptionId, Tag processorId)
Compare each mandatory value (i.e.
int numDataDescription
===&gt; Attribute numDataDescription
void numAtmPhaseCorrectionFromText(const std::string &s)
void processorIdFromBin(EndianIStream &eis)
void correlationModeFromBin(EndianIStream &eis)
std::vector< DataDescriptionRow * > getDataDescriptionsUsingDataDescriptionId()
Returns the vector of DataDescriptionRow* linked to this row via the Tags stored in dataDescriptionId...
void addSwitchCycleId(Tag id)
Append a Tag to switchCycleId.
void numFeedFromBin(EndianIStream &eis)
Tag getProcessorId() const
===&gt; Attribute processorId
bool hasBeenAdded
Whether this row has been added to the table or not.
void numAntennaFromText(const std::string &s)
ProcessorTypeMod::ProcessorType getProcessorType() const
===&gt; Attribute processorType
void addAssocConfigDescriptionId(Tag id)
Append a Tag to assocConfigDescriptionId.
int getNumDataDescription() const
===&gt; Attribute numDataDescription
void spectralTypeFromText(const std::string &s)
DataDescriptionRow * getDataDescriptionUsingDataDescriptionId(int i)
Returns the DataDescriptionRow linked to this row via the tag stored in dataDescriptionId at position...
std::vector< AtmPhaseCorrectionMod::AtmPhaseCorrection > atmPhaseCorrection
===&gt; Attribute atmPhaseCorrection
bool compareNoAutoInc(int numAntenna, int numDataDescription, int numFeed, CorrelationModeMod::CorrelationMode correlationMode, int numAtmPhaseCorrection, std::vector< AtmPhaseCorrectionMod::AtmPhaseCorrection > atmPhaseCorrection, ProcessorTypeMod::ProcessorType processorType, SpectralResolutionTypeMod::SpectralResolutionType spectralType, std::vector< Tag > antennaId, std::vector< int > feedId, std::vector< Tag > switchCycleId, std::vector< Tag > dataDescriptionId, Tag processorId)
Compare each mandatory attribute except the autoincrementable one of this ConfigDescriptionRow with t...
bool isNumAssocValuesExists() const
===&gt; Attribute numAssocValues, which is optional
virtual ~ConfigDescriptionRow()
friend class asdm::TableStreamReader&lt;ConfigDescriptionTable, ConfigDescriptionRow&gt;; ...
ProcessorTypeMod::ProcessorType processorType
===&gt; Attribute processorType
const std::vector< FeedRow * > getFeeds()
Get the collection of rows in the Feed table having feedId == feedId[i] for any i in [O...
void atmPhaseCorrectionFromText(const std::string &s)
The ConfigDescriptionTable class is an Alma table.
void dataDescriptionIdFromBin(EndianIStream &eis)
bool assocConfigDescriptionIdExists
===&gt; Attribute assocConfigDescriptionId, which is optional
void assocNatureFromBin(EndianIStream &eis)
void setFeedId(std::vector< int > feedId)
Set feedId with the specified std::vector&lt;int&gt; .
void clearNumAssocValues()
Mark numAssocValues, which is an optional field, as non-existent.
void setAntennaId(std::vector< Tag > antennaId)
Set antennaId with the specified std::vector&lt;Tag&gt; .
std::vector< int > feedId
===&gt; Attribute feedId
void setPhasedArrayList(std::vector< int > phasedArrayList)
Set phasedArrayList with the specified std::vector&lt;int &gt;.
ConfigDescriptionRow * getConfigDescriptionUsingAssocConfigDescriptionId(int i)
Returns the ConfigDescriptionRow linked to this row via the tag stored in assocConfigDescriptionId at...
std::vector< AntennaRow * > getAntennasUsingAntennaId()
Returns the vector of AntennaRow* linked to this row via the Tags stored in antennaId.
bool numAssocValuesExists
===&gt; Attribute numAssocValues, which is optional
void setAssocNature(std::vector< SpectralResolutionTypeMod::SpectralResolutionType > assocNature)
Set assocNature with the specified std::vector&lt;SpectralResolutionTypeMod::SpectralResolutionType &gt;...
void atmPhaseCorrectionFromBin(EndianIStream &eis)
std::vector< SpectralResolutionTypeMod::SpectralResolutionType > assocNature
int getNumAtmPhaseCorrection() const
===&gt; Attribute numAtmPhaseCorrection
std::vector< int > getFeedId() const
===&gt; Attribute feedId
std::vector< Tag > dataDescriptionId
===&gt; Attribute dataDescriptionId
The SwitchCycleRow class is a row of a SwitchCycleTable.
void numAssocValuesFromBin(EndianIStream &eis)
ConfigDescriptionTable & getTable() const
Return the table to which this row belongs.
void clearAssocNature()
Mark assocNature, which is an optional field, as non-existent.
void addDataDescriptionId(Tag id)
Append a Tag to dataDescriptionId.
void clearAssocConfigDescriptionId()
Mark assocConfigDescriptionId, which is an optional field, as non-existent.
void phasedArrayListFromText(const std::string &s)
bool isAssocNatureExists() const
===&gt; Attribute assocNature, which is optional
std::vector< SpectralResolutionTypeMod::SpectralResolutionType > getAssocNature() const
Get assocNature, which is optional.
ConfigDescriptionRow(ConfigDescriptionTable &table)
Create a ConfigDescriptionRow.
void phasedArrayListFromBin(EndianIStream &eis)
std::vector< ConfigDescriptionRow * > getConfigDescriptionsUsingAssocConfigDescriptionId()
Returns the vector of ConfigDescriptionRow* linked to this row via the Tags stored in assocConfigDesc...
void numAntennaFromBin(EndianIStream &eis)
void numAtmPhaseCorrectionFromBin(EndianIStream &eis)
Tag configDescriptionId
===&gt; Attribute configDescriptionId
void toBin(EndianOSStream &eoss)
Serialize this into a stream of bytes written to an EndianOSStream.
bool assocNatureExists
===&gt; Attribute assocNature, which is optional
void assocNatureFromText(const std::string &s)
int getNumAssocValues() const
Get numAssocValues, which is optional.
void setNumAssocValues(int numAssocValues)
Set numAssocValues with the specified int.
The AntennaRow class is a row of a AntennaTable.
Definition: AntennaRow.h:120
void antennaIdFromBin(EndianIStream &eis)
bool equalByRequiredValue(ConfigDescriptionRow *x)
Return true if all required attributes of the value part are equal to their homologues in x and false...
void switchCycleIdFromBin(EndianIStream &eis)
void setAtmPhaseCorrection(std::vector< AtmPhaseCorrectionMod::AtmPhaseCorrection > atmPhaseCorrection)
Set atmPhaseCorrection with the specified std::vector&lt;AtmPhaseCorrectionMod::AtmPhaseCorrection &gt;...
std::vector< AtmPhaseCorrectionMod::AtmPhaseCorrection > getAtmPhaseCorrection() const
===&gt; Attribute atmPhaseCorrection
bool isAdded() const
Has this row been added to its table ?
CorrelationModeMod::CorrelationMode getCorrelationMode() const
===&gt; Attribute correlationMode
void setDataDescriptionId(std::vector< Tag > dataDescriptionId)
Set dataDescriptionId with the specified std::vector&lt;Tag&gt; .
SpectralResolutionTypeMod::SpectralResolutionType spectralType
===&gt; Attribute spectralType
bool isPhasedArrayListExists() const
===&gt; Attribute phasedArrayList, which is optional
ProcessorRow * getProcessorUsingProcessorId()
processorId pointer to the row in the Processor table having Processor.processorId == processorId ...
void processorTypeFromBin(EndianIStream &eis)
void setNumDataDescription(int numDataDescription)
Set numDataDescription with the specified int.
Tag processorId
===&gt; Attribute processorId
void addAntennaId(Tag id)
Append a Tag to antennaId.
std::vector< Tag > getDataDescriptionId() const
===&gt; Attribute dataDescriptionId
int numAtmPhaseCorrection
===&gt; Attribute numAtmPhaseCorrection
void setCorrelationMode(CorrelationModeMod::CorrelationMode correlationMode)
Set correlationMode with the specified CorrelationModeMod::CorrelationMode.
The Tag class is an implementation of a unique index identifying a row of an ASDM table...
Definition: Tag.h:73
The DataDescriptionRow class is a row of a DataDescriptionTable.
void(ConfigDescriptionRow::* ConfigDescriptionAttributeFromText)(const std::string &s)
void setSwitchCycleId(std::vector< Tag > switchCycleId)
Set switchCycleId with the specified std::vector&lt;Tag&gt; .
bool phasedArrayListExists
===&gt; Attribute phasedArrayList, which is optional
SpectralResolutionTypeMod::SpectralResolutionType getSpectralType() const
===&gt; Attribute spectralType
void numAssocValuesFromText(const std::string &s)
std::vector< Tag > getAssocConfigDescriptionId() const
Get assocConfigDescriptionId, which is optional.
void processorTypeFromText(const std::string &s)
void correlationModeFromText(const std::string &s)
asdmIDL::ConfigDescriptionRowIDL * toIDL() const
Return this row in the form of an IDL struct.
void setNumAntenna(int numAntenna)
Set numAntenna with the specified int.
std::vector< SwitchCycleRow * > getSwitchCyclesUsingSwitchCycleId()
Returns the vector of SwitchCycleRow* linked to this row via the Tags stored in switchCycleId.
int numFeed
===&gt; Attribute numFeed
void numDataDescriptionFromText(const std::string &s)
Tag getConfigDescriptionId() const
===&gt; Attribute configDescriptionId
The ConfigDescriptionRow class is a row of a ConfigDescriptionTable.
void processorIdFromText(const std::string &s)
void setSpectralType(SpectralResolutionTypeMod::SpectralResolutionType spectralType)
Set spectralType with the specified SpectralResolutionTypeMod::SpectralResolutionType.
bool isAssocConfigDescriptionIdExists() const
===&gt; Attribute assocConfigDescriptionId, which is optional
const Tag getAntennaId(int i)
Returns the Tag stored in antennaId at position i.
std::vector< Tag > getSwitchCycleId() const
===&gt; Attribute switchCycleId
void setFromXML(std::string rowDoc)
Fill the values of this row from an XML string that was produced by the toXML() method.
void configDescriptionIdFromBin(EndianIStream &eis)
void(ConfigDescriptionRow::* ConfigDescriptionAttributeFromBin)(EndianIStream &eis)
SwitchCycleRow * getSwitchCycleUsingSwitchCycleId(int i)
Returns the SwitchCycleRow linked to this row via the tag stored in switchCycleId at position i...
void clearPhasedArrayList()
Mark phasedArrayList, which is an optional field, as non-existent.
void setConfigDescriptionId(Tag configDescriptionId)
Set configDescriptionId with the specified Tag value.
void setProcessorType(ProcessorTypeMod::ProcessorType processorType)
Set processorType with the specified ProcessorTypeMod::ProcessorType.
void setNumAtmPhaseCorrection(int numAtmPhaseCorrection)
Set numAtmPhaseCorrection with the specified int.
std::vector< Tag > switchCycleId
===&gt; Attribute switchCycleId
void addFeedId(int id)
===&gt; Slices link from a row of ConfigDescription table to a collection of row of Feed table...
void feedIdFromBin(EndianIStream &eis)
std::vector< int > getPhasedArrayList() const
Get phasedArrayList, which is optional.
void numFeedFromText(const std::string &s)
The ProcessorRow class is a row of a ProcessorTable.
Definition: ProcessorRow.h:98
void numDataDescriptionFromBin(EndianIStream &eis)
void assocConfigDescriptionIdFromBin(EndianIStream &eis)
void feedIdFromText(const std::string &s)
int getNumFeed() const
===&gt; Attribute numFeed
void spectralTypeFromBin(EndianIStream &eis)
void dataDescriptionIdFromText(const std::string &s)
*text deserialization material std::map< std::string, ConfigDescriptionAttributeFromText > fromTextMethods
std::string toXML() const
Return this row in the form of an XML string.
ConfigDescriptionTable & table
The table to which this row belongs.
void antennaIdFromText(const std::string &s)