LTKCPP-- LLRP Toolkit C Plus Plus Library
out_impinj_ltkcpp.h
1 
2 /*
3  * Generated file - DO NOT EDIT
4  *
5  * This is the header file for the LLRP Tool Kit (LTK)
6  * C++ (aka cpp) implementation. It is generated into a .inc file
7  * that is included by a platform specific .h header file.
8  * That .h file takes care of prerequisites needed by this file.
9  */
10 
11 
12 /*
13  * Message classes - forward decls
14  */
15 
16 
17 /* Custom messages */
18 
23 
24 /*
25  * Parameter classes - forward decls
26  */
27 
28 
29 /* Custom parameters */
30 
37 class CImpinjHubVersions;
50 class CImpinjSetQTConfig;
52 class CImpinjGetQTConfig;
61 class CImpinjPeakRSSI;
63 class CImpinjLoopSpec;
65 class CImpinjGGASentence;
66 class CImpinjRMCSentence;
75 class CImpinjTxPower;
87 class CImpinjLISpec;
93 class CImpinjDISpec;
109 class CImpinjTIDParity;
110 class CImpinjMarginRead;
112 class CImpinjBLEVersion;
114 class CImpinjRFPowerSweep;
115 
116 /*
117  * Vendor descriptor declarations.
118  */
119 
120 extern const CVendorDescriptor
121 g_vdescImpinj;
122 
123 
124 /*
125  * Namespace descriptor declarations.
126  */
127 
128 extern const CNamespaceDescriptor
129 g_nsdescImpinj;
130 
131 
132 /*
133  * Enumeration definitions and declarations of
134  * enumeration string tables.
135  */
136 
137 
169 enum EImpinjRequestedDataType
170 {
172 };
173 
174 extern const SEnumTableEntry
175 g_estImpinjRequestedDataType[];
176 
177 
211 enum EImpinjRegulatoryRegion
212 {
214 };
215 
216 extern const SEnumTableEntry
217 g_estImpinjRegulatoryRegion[];
218 
219 
234 enum EImpinjInventorySearchType
235 {
237 };
238 
239 extern const SEnumTableEntry
240 g_estImpinjInventorySearchType[];
241 
242 
253 enum EImpinjFixedFrequencyMode
254 {
256 };
257 
258 extern const SEnumTableEntry
259 g_estImpinjFixedFrequencyMode[];
260 
261 
271 enum EImpinjReducedPowerMode
272 {
274 };
275 
276 extern const SEnumTableEntry
277 g_estImpinjReducedPowerMode[];
278 
279 
289 enum EImpinjLowDutyCycleMode
290 {
292 };
293 
294 extern const SEnumTableEntry
295 g_estImpinjLowDutyCycleMode[];
296 
297 
307 enum EImpinjLinkMonitorMode
308 {
310 };
311 
312 extern const SEnumTableEntry
313 g_estImpinjLinkMonitorMode[];
314 
315 
325 enum EImpinjReportBufferMode
326 {
328 };
329 
330 extern const SEnumTableEntry
331 g_estImpinjReportBufferMode[];
332 
333 
348 enum EImpinjBlockPermalockResultType
349 {
351 };
352 
353 extern const SEnumTableEntry
354 g_estImpinjBlockPermalockResultType[];
355 
356 
370 enum EImpinjGetBlockPermalockStatusResultType
371 {
373 };
374 
375 extern const SEnumTableEntry
376 g_estImpinjGetBlockPermalockStatusResultType[];
377 
378 
389 enum EImpinjQTDataProfile
390 {
392 };
393 
394 extern const SEnumTableEntry
395 g_estImpinjQTDataProfile[];
396 
397 
408 enum EImpinjQTAccessRange
409 {
411 };
412 
413 extern const SEnumTableEntry
414 g_estImpinjQTAccessRange[];
415 
416 
427 enum EImpinjQTPersistence
428 {
430 };
431 
432 extern const SEnumTableEntry
433 g_estImpinjQTPersistence[];
434 
435 
449 enum EImpinjSetQTConfigResultType
450 {
452 };
453 
454 extern const SEnumTableEntry
455 g_estImpinjSetQTConfigResultType[];
456 
457 
470 enum EImpinjGetQTConfigResultType
471 {
473 };
474 
475 extern const SEnumTableEntry
476 g_estImpinjGetQTConfigResultType[];
477 
478 
488 enum EImpinjSerializedTIDMode
489 {
491 };
492 
493 extern const SEnumTableEntry
494 g_estImpinjSerializedTIDMode[];
495 
496 
506 enum EImpinjRFPhaseAngleMode
507 {
509 };
510 
511 extern const SEnumTableEntry
512 g_estImpinjRFPhaseAngleMode[];
513 
514 
524 enum EImpinjPeakRSSIMode
525 {
527 };
528 
529 extern const SEnumTableEntry
530 g_estImpinjPeakRSSIMode[];
531 
532 
542 enum EImpinjGPSCoordinatesMode
543 {
545 };
546 
547 extern const SEnumTableEntry
548 g_estImpinjGPSCoordinatesMode[];
549 
550 
565 enum EImpinjAdvancedGPOMode
566 {
568 };
569 
570 extern const SEnumTableEntry
571 g_estImpinjAdvancedGPOMode[];
572 
573 
583 enum EImpinjOptimizedReadMode
584 {
586 };
587 
588 extern const SEnumTableEntry
589 g_estImpinjOptimizedReadMode[];
590 
591 
601 enum EImpinjAccessSpecOrderingMode
602 {
604 };
605 
606 extern const SEnumTableEntry
607 g_estImpinjAccessSpecOrderingMode[];
608 
609 
619 enum EImpinjRFDopplerFrequencyMode
620 {
622 };
623 
624 extern const SEnumTableEntry
625 g_estImpinjRFDopplerFrequencyMode[];
626 
627 
637 enum EImpinjTxPowerReportingModeEnum
638 {
640 };
641 
642 extern const SEnumTableEntry
643 g_estImpinjTxPowerReportingModeEnum[];
644 
645 
656 enum EImpinjHubConnectedType
657 {
659 };
660 
661 extern const SEnumTableEntry
662 g_estImpinjHubConnectedType[];
663 
664 
681 enum EImpinjHubFaultType
682 {
684 };
685 
686 extern const SEnumTableEntry
687 g_estImpinjHubFaultType[];
688 
689 
700 enum EImpinjLocationReportType
701 {
703 };
704 
705 extern const SEnumTableEntry
706 g_estImpinjLocationReportType[];
707 
708 
752 enum EImpinjDirectionFieldOfView
753 {
755 };
756 
757 extern const SEnumTableEntry
758 g_estImpinjDirectionFieldOfView[];
759 
760 
795 enum EImpinjDirectionRFMode
796 {
798 };
799 
800 extern const SEnumTableEntry
801 g_estImpinjDirectionRFMode[];
802 
803 
853 enum EImpinjDirectionDiagnosticReportLevel
854 {
856 };
857 
858 extern const SEnumTableEntry
859 g_estImpinjDirectionDiagnosticReportLevel[];
860 
861 
900 enum EImpinjDirectionReportType
901 {
903 };
904 
905 extern const SEnumTableEntry
906 g_estImpinjDirectionReportType[];
907 
908 
947 enum EImpinjDirectionTagPopulationStatus
948 {
950 };
951 
952 extern const SEnumTableEntry
953 g_estImpinjDirectionTagPopulationStatus[];
954 
955 
965 enum EImpinjIntelligentAntennaMode
966 {
968 };
969 
970 extern const SEnumTableEntry
971 g_estImpinjIntelligentAntennaMode[];
972 
973 
985 enum EImpinjAntennaPolarizationType
986 {
988 };
989 
990 extern const SEnumTableEntry
991 g_estImpinjAntennaPolarizationType[];
992 
993 
1010 enum EImpinjMarginReadResultType
1011 {
1013 };
1014 
1015 extern const SEnumTableEntry
1016 g_estImpinjMarginReadResultType[];
1017 
1018 
1024 
1048 class CIMPINJ_ENABLE_EXTENSIONS : public CMessage
1049 {
1050  public:
1052  ~CIMPINJ_ENABLE_EXTENSIONS (void);
1053 
1056 
1057  static const CFieldDescriptor * const
1058  s_apFieldDescriptorTable[];
1059 
1060  static const CTypeDescriptor
1061  s_typeDescriptor;
1062 
1063  void
1064  decodeFields (
1065  CDecoderStream * pDecoderStream);
1066 
1067  void
1068  assimilateSubParameters (
1069  CErrorDetails * pError);
1070 
1071  void
1072  encode (
1073  CEncoderStream * pEncoderStream) const;
1074 
1075 
1076 
1077  static CElement *
1078  s_construct (void);
1079 
1080  static void
1081  s_decodeFields (
1082  CDecoderStream * pDecoderStream,
1083  CElement * pElement);
1085 
1086 
1087  protected:
1088  std::list<CParameter *> m_listCustom;
1089 
1090  public:
1092  inline std::list<CParameter *>::iterator
1094  {
1095  return m_listCustom.begin();
1096  }
1097 
1099  inline std::list<CParameter *>::iterator
1100  endCustom (void)
1101  {
1102  return m_listCustom.end();
1103  }
1104 
1106  inline void
1108  {
1109  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1110  }
1111 
1113  inline int
1115  {
1116  return (int) (m_listCustom.size());
1117  }
1118 
1119  EResultCode
1121  addCustom (
1122  CParameter * pValue);
1123 
1124 
1125 };
1126 
1127 
1151 class CIMPINJ_ENABLE_EXTENSIONS_RESPONSE : public CMessage
1152 {
1153  public:
1156 
1159 
1160  static const CFieldDescriptor * const
1161  s_apFieldDescriptorTable[];
1162 
1163  static const CTypeDescriptor
1164  s_typeDescriptor;
1165 
1166  void
1167  decodeFields (
1168  CDecoderStream * pDecoderStream);
1169 
1170  void
1171  assimilateSubParameters (
1172  CErrorDetails * pError);
1173 
1174  void
1175  encode (
1176  CEncoderStream * pEncoderStream) const;
1177 
1178 
1179 
1180  static CElement *
1181  s_construct (void);
1182 
1183  static void
1184  s_decodeFields (
1185  CDecoderStream * pDecoderStream,
1186  CElement * pElement);
1188 
1189 
1190  protected:
1191  CLLRPStatus * m_pLLRPStatus;
1192 
1193  public:
1195  inline CLLRPStatus *
1197  {
1198  return m_pLLRPStatus;
1199  }
1200 
1202  EResultCode
1203  setLLRPStatus (
1204  CLLRPStatus * pValue);
1205 
1206 
1207  protected:
1208  std::list<CParameter *> m_listCustom;
1209 
1210  public:
1212  inline std::list<CParameter *>::iterator
1214  {
1215  return m_listCustom.begin();
1216  }
1217 
1219  inline std::list<CParameter *>::iterator
1220  endCustom (void)
1221  {
1222  return m_listCustom.end();
1223  }
1224 
1226  inline void
1228  {
1229  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1230  }
1231 
1233  inline int
1235  {
1236  return (int) (m_listCustom.size());
1237  }
1238 
1239  EResultCode
1241  addCustom (
1242  CParameter * pValue);
1243 
1244 
1245 };
1246 
1247 
1281 class CIMPINJ_SAVE_SETTINGS : public CMessage
1282 {
1283  public:
1284  CIMPINJ_SAVE_SETTINGS (void);
1285  ~CIMPINJ_SAVE_SETTINGS (void);
1286 
1289 
1290  static const CFieldDescriptor * const
1291  s_apFieldDescriptorTable[];
1292 
1293  static const CTypeDescriptor
1294  s_typeDescriptor;
1295 
1296  void
1297  decodeFields (
1298  CDecoderStream * pDecoderStream);
1299 
1300  void
1301  assimilateSubParameters (
1302  CErrorDetails * pError);
1303 
1304  void
1305  encode (
1306  CEncoderStream * pEncoderStream) const;
1307 
1308 
1309 
1310  static CElement *
1311  s_construct (void);
1312 
1313  static void
1314  s_decodeFields (
1315  CDecoderStream * pDecoderStream,
1316  CElement * pElement);
1318 
1319 
1320  protected:
1321  llrp_u1_t m_SaveConfiguration;
1322 
1325  public:
1326  static const CFieldDescriptor
1327  s_fdSaveConfiguration;
1329 
1331  inline llrp_u1_t
1333  {
1334  return m_SaveConfiguration;
1335  }
1336 
1338  inline void
1340  llrp_u1_t value)
1341  {
1342  m_SaveConfiguration = value;
1343  }
1344 
1345 
1346  protected:
1347  std::list<CParameter *> m_listCustom;
1348 
1349  public:
1351  inline std::list<CParameter *>::iterator
1353  {
1354  return m_listCustom.begin();
1355  }
1356 
1358  inline std::list<CParameter *>::iterator
1359  endCustom (void)
1360  {
1361  return m_listCustom.end();
1362  }
1363 
1365  inline void
1367  {
1368  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1369  }
1370 
1372  inline int
1374  {
1375  return (int) (m_listCustom.size());
1376  }
1377 
1378  EResultCode
1380  addCustom (
1381  CParameter * pValue);
1382 
1383 
1384 };
1385 
1386 
1410 class CIMPINJ_SAVE_SETTINGS_RESPONSE : public CMessage
1411 {
1412  public:
1415 
1418 
1419  static const CFieldDescriptor * const
1420  s_apFieldDescriptorTable[];
1421 
1422  static const CTypeDescriptor
1423  s_typeDescriptor;
1424 
1425  void
1426  decodeFields (
1427  CDecoderStream * pDecoderStream);
1428 
1429  void
1430  assimilateSubParameters (
1431  CErrorDetails * pError);
1432 
1433  void
1434  encode (
1435  CEncoderStream * pEncoderStream) const;
1436 
1437 
1438 
1439  static CElement *
1440  s_construct (void);
1441 
1442  static void
1443  s_decodeFields (
1444  CDecoderStream * pDecoderStream,
1445  CElement * pElement);
1447 
1448 
1449  protected:
1450  CLLRPStatus * m_pLLRPStatus;
1451 
1452  public:
1454  inline CLLRPStatus *
1456  {
1457  return m_pLLRPStatus;
1458  }
1459 
1461  EResultCode
1462  setLLRPStatus (
1463  CLLRPStatus * pValue);
1464 
1465 
1466  protected:
1467  std::list<CParameter *> m_listCustom;
1468 
1469  public:
1471  inline std::list<CParameter *>::iterator
1473  {
1474  return m_listCustom.begin();
1475  }
1476 
1478  inline std::list<CParameter *>::iterator
1479  endCustom (void)
1480  {
1481  return m_listCustom.end();
1482  }
1483 
1485  inline void
1487  {
1488  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1489  }
1490 
1492  inline int
1494  {
1495  return (int) (m_listCustom.size());
1496  }
1497 
1498  EResultCode
1500  addCustom (
1501  CParameter * pValue);
1502 
1503 
1504 };
1505 
1506 
1514 
1537 class CImpinjRequestedData : public CParameter
1538 {
1539  public:
1540  CImpinjRequestedData (void);
1541  ~CImpinjRequestedData (void);
1542 
1545 
1546  static const CFieldDescriptor * const
1547  s_apFieldDescriptorTable[];
1548 
1549  static const CTypeDescriptor
1550  s_typeDescriptor;
1551 
1552  void
1553  decodeFields (
1554  CDecoderStream * pDecoderStream);
1555 
1556  void
1557  assimilateSubParameters (
1558  CErrorDetails * pError);
1559 
1560  void
1561  encode (
1562  CEncoderStream * pEncoderStream) const;
1563 
1564 
1565  llrp_bool_t
1566  isAllowedIn (
1567  const CTypeDescriptor * pEnclosingElementType) const;
1568 
1569 
1570  static CElement *
1571  s_construct (void);
1572 
1573  static void
1574  s_decodeFields (
1575  CDecoderStream * pDecoderStream,
1576  CElement * pElement);
1578 
1579 
1580  protected:
1581  EImpinjRequestedDataType m_eRequestedData;
1582 
1585  public:
1586  static const CFieldDescriptor
1587  s_fdRequestedData;
1589 
1591  inline EImpinjRequestedDataType
1593  {
1594  return m_eRequestedData;
1595  }
1596 
1598  inline void
1600  EImpinjRequestedDataType value)
1601  {
1602  m_eRequestedData = value;
1603  }
1604 
1605 
1606  protected:
1607  std::list<CParameter *> m_listCustom;
1608 
1609  public:
1611  inline std::list<CParameter *>::iterator
1613  {
1614  return m_listCustom.begin();
1615  }
1616 
1618  inline std::list<CParameter *>::iterator
1619  endCustom (void)
1620  {
1621  return m_listCustom.end();
1622  }
1623 
1625  inline void
1627  {
1628  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1629  }
1630 
1632  inline int
1634  {
1635  return (int) (m_listCustom.size());
1636  }
1637 
1638  EResultCode
1640  addCustom (
1641  CParameter * pValue);
1642 
1643 
1644 };
1645 
1646 
1675 class CImpinjSubRegulatoryRegion : public CParameter
1676 {
1677  public:
1680 
1683 
1684  static const CFieldDescriptor * const
1685  s_apFieldDescriptorTable[];
1686 
1687  static const CTypeDescriptor
1688  s_typeDescriptor;
1689 
1690  void
1691  decodeFields (
1692  CDecoderStream * pDecoderStream);
1693 
1694  void
1695  assimilateSubParameters (
1696  CErrorDetails * pError);
1697 
1698  void
1699  encode (
1700  CEncoderStream * pEncoderStream) const;
1701 
1702 
1703  llrp_bool_t
1704  isAllowedIn (
1705  const CTypeDescriptor * pEnclosingElementType) const;
1706 
1707 
1708  static CElement *
1709  s_construct (void);
1710 
1711  static void
1712  s_decodeFields (
1713  CDecoderStream * pDecoderStream,
1714  CElement * pElement);
1716 
1717 
1718  protected:
1719  EImpinjRegulatoryRegion m_eRegulatoryRegion;
1720 
1723  public:
1724  static const CFieldDescriptor
1725  s_fdRegulatoryRegion;
1727 
1729  inline EImpinjRegulatoryRegion
1731  {
1732  return m_eRegulatoryRegion;
1733  }
1734 
1736  inline void
1738  EImpinjRegulatoryRegion value)
1739  {
1740  m_eRegulatoryRegion = value;
1741  }
1742 
1743 
1744  protected:
1745  std::list<CParameter *> m_listCustom;
1746 
1747  public:
1749  inline std::list<CParameter *>::iterator
1751  {
1752  return m_listCustom.begin();
1753  }
1754 
1756  inline std::list<CParameter *>::iterator
1757  endCustom (void)
1758  {
1759  return m_listCustom.end();
1760  }
1761 
1763  inline void
1765  {
1766  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1767  }
1768 
1770  inline int
1772  {
1773  return (int) (m_listCustom.size());
1774  }
1775 
1776  EResultCode
1778  addCustom (
1779  CParameter * pValue);
1780 
1781 
1782 };
1783 
1784 
1809 class CImpinjInventorySearchMode : public CParameter
1810 {
1811  public:
1814 
1817 
1818  static const CFieldDescriptor * const
1819  s_apFieldDescriptorTable[];
1820 
1821  static const CTypeDescriptor
1822  s_typeDescriptor;
1823 
1824  void
1825  decodeFields (
1826  CDecoderStream * pDecoderStream);
1827 
1828  void
1829  assimilateSubParameters (
1830  CErrorDetails * pError);
1831 
1832  void
1833  encode (
1834  CEncoderStream * pEncoderStream) const;
1835 
1836 
1837  llrp_bool_t
1838  isAllowedIn (
1839  const CTypeDescriptor * pEnclosingElementType) const;
1840 
1841 
1842  static CElement *
1843  s_construct (void);
1844 
1845  static void
1846  s_decodeFields (
1847  CDecoderStream * pDecoderStream,
1848  CElement * pElement);
1850 
1851 
1852  protected:
1853  EImpinjInventorySearchType m_eInventorySearchMode;
1854 
1857  public:
1858  static const CFieldDescriptor
1859  s_fdInventorySearchMode;
1861 
1863  inline EImpinjInventorySearchType
1865  {
1866  return m_eInventorySearchMode;
1867  }
1868 
1870  inline void
1872  EImpinjInventorySearchType value)
1873  {
1874  m_eInventorySearchMode = value;
1875  }
1876 
1877 
1878  protected:
1879  std::list<CParameter *> m_listCustom;
1880 
1881  public:
1883  inline std::list<CParameter *>::iterator
1885  {
1886  return m_listCustom.begin();
1887  }
1888 
1890  inline std::list<CParameter *>::iterator
1891  endCustom (void)
1892  {
1893  return m_listCustom.end();
1894  }
1895 
1897  inline void
1899  {
1900  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1901  }
1902 
1904  inline int
1906  {
1907  return (int) (m_listCustom.size());
1908  }
1909 
1910  EResultCode
1912  addCustom (
1913  CParameter * pValue);
1914 
1915 
1916 };
1917 
1918 
1948 class CImpinjFixedFrequencyList : public CParameter
1949 {
1950  public:
1952  ~CImpinjFixedFrequencyList (void);
1953 
1956 
1957  static const CFieldDescriptor * const
1958  s_apFieldDescriptorTable[];
1959 
1960  static const CTypeDescriptor
1961  s_typeDescriptor;
1962 
1963  void
1964  decodeFields (
1965  CDecoderStream * pDecoderStream);
1966 
1967  void
1968  assimilateSubParameters (
1969  CErrorDetails * pError);
1970 
1971  void
1972  encode (
1973  CEncoderStream * pEncoderStream) const;
1974 
1975 
1976  llrp_bool_t
1977  isAllowedIn (
1978  const CTypeDescriptor * pEnclosingElementType) const;
1979 
1980 
1981  static CElement *
1982  s_construct (void);
1983 
1984  static void
1985  s_decodeFields (
1986  CDecoderStream * pDecoderStream,
1987  CElement * pElement);
1989 
1990 
1991  protected:
1992  EImpinjFixedFrequencyMode m_eFixedFrequencyMode;
1993 
1996  public:
1997  static const CFieldDescriptor
1998  s_fdFixedFrequencyMode;
2000 
2002  inline EImpinjFixedFrequencyMode
2004  {
2005  return m_eFixedFrequencyMode;
2006  }
2007 
2009  inline void
2011  EImpinjFixedFrequencyMode value)
2012  {
2013  m_eFixedFrequencyMode = value;
2014  }
2015 
2016 
2017  protected:
2018  llrp_u16v_t m_ChannelList;
2019 
2022  public:
2023  static const CFieldDescriptor
2024  s_fdChannelList;
2026 
2028  inline llrp_u16v_t
2030  {
2031  return m_ChannelList;
2032  }
2033 
2035  inline void
2037  llrp_u16v_t value)
2038  {
2039  m_ChannelList = value;
2040  }
2041 
2042 
2043  protected:
2044  std::list<CParameter *> m_listCustom;
2045 
2046  public:
2048  inline std::list<CParameter *>::iterator
2050  {
2051  return m_listCustom.begin();
2052  }
2053 
2055  inline std::list<CParameter *>::iterator
2056  endCustom (void)
2057  {
2058  return m_listCustom.end();
2059  }
2060 
2062  inline void
2064  {
2065  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2066  }
2067 
2069  inline int
2071  {
2072  return (int) (m_listCustom.size());
2073  }
2074 
2075  EResultCode
2077  addCustom (
2078  CParameter * pValue);
2079 
2080 
2081 };
2082 
2083 
2113 class CImpinjReducedPowerFrequencyList : public CParameter
2114 {
2115  public:
2118 
2121 
2122  static const CFieldDescriptor * const
2123  s_apFieldDescriptorTable[];
2124 
2125  static const CTypeDescriptor
2126  s_typeDescriptor;
2127 
2128  void
2129  decodeFields (
2130  CDecoderStream * pDecoderStream);
2131 
2132  void
2133  assimilateSubParameters (
2134  CErrorDetails * pError);
2135 
2136  void
2137  encode (
2138  CEncoderStream * pEncoderStream) const;
2139 
2140 
2141  llrp_bool_t
2142  isAllowedIn (
2143  const CTypeDescriptor * pEnclosingElementType) const;
2144 
2145 
2146  static CElement *
2147  s_construct (void);
2148 
2149  static void
2150  s_decodeFields (
2151  CDecoderStream * pDecoderStream,
2152  CElement * pElement);
2154 
2155 
2156  protected:
2157  EImpinjReducedPowerMode m_eReducedPowerMode;
2158 
2161  public:
2162  static const CFieldDescriptor
2163  s_fdReducedPowerMode;
2165 
2167  inline EImpinjReducedPowerMode
2169  {
2170  return m_eReducedPowerMode;
2171  }
2172 
2174  inline void
2176  EImpinjReducedPowerMode value)
2177  {
2178  m_eReducedPowerMode = value;
2179  }
2180 
2181 
2182  protected:
2183  llrp_u16v_t m_ChannelList;
2184 
2187  public:
2188  static const CFieldDescriptor
2189  s_fdChannelList;
2191 
2193  inline llrp_u16v_t
2195  {
2196  return m_ChannelList;
2197  }
2198 
2200  inline void
2202  llrp_u16v_t value)
2203  {
2204  m_ChannelList = value;
2205  }
2206 
2207 
2208  protected:
2209  std::list<CParameter *> m_listCustom;
2210 
2211  public:
2213  inline std::list<CParameter *>::iterator
2215  {
2216  return m_listCustom.begin();
2217  }
2218 
2220  inline std::list<CParameter *>::iterator
2221  endCustom (void)
2222  {
2223  return m_listCustom.end();
2224  }
2225 
2227  inline void
2229  {
2230  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2231  }
2232 
2234  inline int
2236  {
2237  return (int) (m_listCustom.size());
2238  }
2239 
2240  EResultCode
2242  addCustom (
2243  CParameter * pValue);
2244 
2245 
2246 };
2247 
2248 
2278 class CImpinjLowDutyCycle : public CParameter
2279 {
2280  public:
2281  CImpinjLowDutyCycle (void);
2282  ~CImpinjLowDutyCycle (void);
2283 
2286 
2287  static const CFieldDescriptor * const
2288  s_apFieldDescriptorTable[];
2289 
2290  static const CTypeDescriptor
2291  s_typeDescriptor;
2292 
2293  void
2294  decodeFields (
2295  CDecoderStream * pDecoderStream);
2296 
2297  void
2298  assimilateSubParameters (
2299  CErrorDetails * pError);
2300 
2301  void
2302  encode (
2303  CEncoderStream * pEncoderStream) const;
2304 
2305 
2306  llrp_bool_t
2307  isAllowedIn (
2308  const CTypeDescriptor * pEnclosingElementType) const;
2309 
2310 
2311  static CElement *
2312  s_construct (void);
2313 
2314  static void
2315  s_decodeFields (
2316  CDecoderStream * pDecoderStream,
2317  CElement * pElement);
2319 
2320 
2321  protected:
2322  EImpinjLowDutyCycleMode m_eLowDutyCycleMode;
2323 
2326  public:
2327  static const CFieldDescriptor
2328  s_fdLowDutyCycleMode;
2330 
2332  inline EImpinjLowDutyCycleMode
2334  {
2335  return m_eLowDutyCycleMode;
2336  }
2337 
2339  inline void
2341  EImpinjLowDutyCycleMode value)
2342  {
2343  m_eLowDutyCycleMode = value;
2344  }
2345 
2346 
2347  protected:
2348  llrp_u16_t m_EmptyFieldTimeout;
2349 
2352  public:
2353  static const CFieldDescriptor
2354  s_fdEmptyFieldTimeout;
2356 
2358  inline llrp_u16_t
2360  {
2361  return m_EmptyFieldTimeout;
2362  }
2363 
2365  inline void
2367  llrp_u16_t value)
2368  {
2369  m_EmptyFieldTimeout = value;
2370  }
2371 
2372 
2373  protected:
2374  llrp_u16_t m_FieldPingInterval;
2375 
2378  public:
2379  static const CFieldDescriptor
2380  s_fdFieldPingInterval;
2382 
2384  inline llrp_u16_t
2386  {
2387  return m_FieldPingInterval;
2388  }
2389 
2391  inline void
2393  llrp_u16_t value)
2394  {
2395  m_FieldPingInterval = value;
2396  }
2397 
2398 
2399  protected:
2400  std::list<CParameter *> m_listCustom;
2401 
2402  public:
2404  inline std::list<CParameter *>::iterator
2406  {
2407  return m_listCustom.begin();
2408  }
2409 
2411  inline std::list<CParameter *>::iterator
2412  endCustom (void)
2413  {
2414  return m_listCustom.end();
2415  }
2416 
2418  inline void
2420  {
2421  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2422  }
2423 
2425  inline int
2427  {
2428  return (int) (m_listCustom.size());
2429  }
2430 
2431  EResultCode
2433  addCustom (
2434  CParameter * pValue);
2435 
2436 
2437 };
2438 
2439 
2464 class CImpinjHubVersions : public CParameter
2465 {
2466  public:
2467  CImpinjHubVersions (void);
2468  ~CImpinjHubVersions (void);
2469 
2472 
2473  static const CFieldDescriptor * const
2474  s_apFieldDescriptorTable[];
2475 
2476  static const CTypeDescriptor
2477  s_typeDescriptor;
2478 
2479  void
2480  decodeFields (
2481  CDecoderStream * pDecoderStream);
2482 
2483  void
2484  assimilateSubParameters (
2485  CErrorDetails * pError);
2486 
2487  void
2488  encode (
2489  CEncoderStream * pEncoderStream) const;
2490 
2491 
2492  llrp_bool_t
2493  isAllowedIn (
2494  const CTypeDescriptor * pEnclosingElementType) const;
2495 
2496 
2497  static CElement *
2498  s_construct (void);
2499 
2500  static void
2501  s_decodeFields (
2502  CDecoderStream * pDecoderStream,
2503  CElement * pElement);
2505 
2506 
2507  protected:
2508  std::list<CImpinjArrayVersion *> m_listImpinjArrayVersion;
2509 
2510  public:
2512  inline std::list<CImpinjArrayVersion *>::iterator
2514  {
2515  return m_listImpinjArrayVersion.begin();
2516  }
2517 
2519  inline std::list<CImpinjArrayVersion *>::iterator
2521  {
2522  return m_listImpinjArrayVersion.end();
2523  }
2524 
2526  inline void
2528  {
2529  clearSubParameterList ((tListOfParameters *) &m_listImpinjArrayVersion);
2530  }
2531 
2533  inline int
2535  {
2536  return (int) (m_listImpinjArrayVersion.size());
2537  }
2538 
2539  EResultCode
2542  CImpinjArrayVersion * pValue);
2543 
2544 
2545  protected:
2546  std::list<CParameter *> m_listCustom;
2547 
2548  public:
2550  inline std::list<CParameter *>::iterator
2552  {
2553  return m_listCustom.begin();
2554  }
2555 
2557  inline std::list<CParameter *>::iterator
2558  endCustom (void)
2559  {
2560  return m_listCustom.end();
2561  }
2562 
2564  inline void
2566  {
2567  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2568  }
2569 
2571  inline int
2573  {
2574  return (int) (m_listCustom.size());
2575  }
2576 
2577  EResultCode
2579  addCustom (
2580  CParameter * pValue);
2581 
2582 
2583 };
2584 
2585 
2618 class CImpinjDetailedVersion : public CParameter
2619 {
2620  public:
2621  CImpinjDetailedVersion (void);
2622  ~CImpinjDetailedVersion (void);
2623 
2626 
2627  static const CFieldDescriptor * const
2628  s_apFieldDescriptorTable[];
2629 
2630  static const CTypeDescriptor
2631  s_typeDescriptor;
2632 
2633  void
2634  decodeFields (
2635  CDecoderStream * pDecoderStream);
2636 
2637  void
2638  assimilateSubParameters (
2639  CErrorDetails * pError);
2640 
2641  void
2642  encode (
2643  CEncoderStream * pEncoderStream) const;
2644 
2645 
2646  llrp_bool_t
2647  isAllowedIn (
2648  const CTypeDescriptor * pEnclosingElementType) const;
2649 
2650 
2651  static CElement *
2652  s_construct (void);
2653 
2654  static void
2655  s_decodeFields (
2656  CDecoderStream * pDecoderStream,
2657  CElement * pElement);
2659 
2660 
2661  protected:
2662  llrp_utf8v_t m_ModelName;
2663 
2666  public:
2667  static const CFieldDescriptor
2668  s_fdModelName;
2670 
2672  inline llrp_utf8v_t
2674  {
2675  return m_ModelName;
2676  }
2677 
2679  inline void
2681  llrp_utf8v_t value)
2682  {
2683  m_ModelName = value;
2684  }
2685 
2686 
2687  protected:
2688  llrp_utf8v_t m_SerialNumber;
2689 
2692  public:
2693  static const CFieldDescriptor
2694  s_fdSerialNumber;
2696 
2698  inline llrp_utf8v_t
2700  {
2701  return m_SerialNumber;
2702  }
2703 
2705  inline void
2707  llrp_utf8v_t value)
2708  {
2709  m_SerialNumber = value;
2710  }
2711 
2712 
2713  protected:
2714  llrp_utf8v_t m_SoftwareVersion;
2715 
2718  public:
2719  static const CFieldDescriptor
2720  s_fdSoftwareVersion;
2722 
2724  inline llrp_utf8v_t
2726  {
2727  return m_SoftwareVersion;
2728  }
2729 
2731  inline void
2733  llrp_utf8v_t value)
2734  {
2735  m_SoftwareVersion = value;
2736  }
2737 
2738 
2739  protected:
2740  llrp_utf8v_t m_FirmwareVersion;
2741 
2744  public:
2745  static const CFieldDescriptor
2746  s_fdFirmwareVersion;
2748 
2750  inline llrp_utf8v_t
2752  {
2753  return m_FirmwareVersion;
2754  }
2755 
2757  inline void
2759  llrp_utf8v_t value)
2760  {
2761  m_FirmwareVersion = value;
2762  }
2763 
2764 
2765  protected:
2766  llrp_utf8v_t m_FPGAVersion;
2767 
2770  public:
2771  static const CFieldDescriptor
2772  s_fdFPGAVersion;
2774 
2776  inline llrp_utf8v_t
2778  {
2779  return m_FPGAVersion;
2780  }
2781 
2783  inline void
2785  llrp_utf8v_t value)
2786  {
2787  m_FPGAVersion = value;
2788  }
2789 
2790 
2791  protected:
2792  llrp_utf8v_t m_PCBAVersion;
2793 
2796  public:
2797  static const CFieldDescriptor
2798  s_fdPCBAVersion;
2800 
2802  inline llrp_utf8v_t
2804  {
2805  return m_PCBAVersion;
2806  }
2807 
2809  inline void
2811  llrp_utf8v_t value)
2812  {
2813  m_PCBAVersion = value;
2814  }
2815 
2816 
2817  protected:
2818  CImpinjHubVersions * m_pImpinjHubVersions;
2819 
2820  public:
2822  inline CImpinjHubVersions *
2824  {
2825  return m_pImpinjHubVersions;
2826  }
2827 
2829  EResultCode
2831  CImpinjHubVersions * pValue);
2832 
2833 
2834  protected:
2835  CImpinjArrayVersion * m_pImpinjArrayVersion;
2836 
2837  public:
2839  inline CImpinjArrayVersion *
2841  {
2842  return m_pImpinjArrayVersion;
2843  }
2844 
2846  EResultCode
2848  CImpinjArrayVersion * pValue);
2849 
2850 
2851  protected:
2852  CImpinjBLEVersion * m_pImpinjBLEVersion;
2853 
2854  public:
2856  inline CImpinjBLEVersion *
2858  {
2859  return m_pImpinjBLEVersion;
2860  }
2861 
2863  EResultCode
2865  CImpinjBLEVersion * pValue);
2866 
2867 
2868  protected:
2869  std::list<CParameter *> m_listCustom;
2870 
2871  public:
2873  inline std::list<CParameter *>::iterator
2875  {
2876  return m_listCustom.begin();
2877  }
2878 
2880  inline std::list<CParameter *>::iterator
2881  endCustom (void)
2882  {
2883  return m_listCustom.end();
2884  }
2885 
2887  inline void
2889  {
2890  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2891  }
2892 
2894  inline int
2896  {
2897  return (int) (m_listCustom.size());
2898  }
2899 
2900  EResultCode
2902  addCustom (
2903  CParameter * pValue);
2904 
2905 
2906 };
2907 
2908 
2933 class CImpinjFrequencyCapabilities : public CParameter
2934 {
2935  public:
2938 
2941 
2942  static const CFieldDescriptor * const
2943  s_apFieldDescriptorTable[];
2944 
2945  static const CTypeDescriptor
2946  s_typeDescriptor;
2947 
2948  void
2949  decodeFields (
2950  CDecoderStream * pDecoderStream);
2951 
2952  void
2953  assimilateSubParameters (
2954  CErrorDetails * pError);
2955 
2956  void
2957  encode (
2958  CEncoderStream * pEncoderStream) const;
2959 
2960 
2961  llrp_bool_t
2962  isAllowedIn (
2963  const CTypeDescriptor * pEnclosingElementType) const;
2964 
2965 
2966  static CElement *
2967  s_construct (void);
2968 
2969  static void
2970  s_decodeFields (
2971  CDecoderStream * pDecoderStream,
2972  CElement * pElement);
2974 
2975 
2976  protected:
2977  llrp_u32v_t m_FrequencyList;
2978 
2981  public:
2982  static const CFieldDescriptor
2983  s_fdFrequencyList;
2985 
2987  inline llrp_u32v_t
2989  {
2990  return m_FrequencyList;
2991  }
2992 
2994  inline void
2996  llrp_u32v_t value)
2997  {
2998  m_FrequencyList = value;
2999  }
3000 
3001 
3002  protected:
3003  std::list<CParameter *> m_listCustom;
3004 
3005  public:
3007  inline std::list<CParameter *>::iterator
3009  {
3010  return m_listCustom.begin();
3011  }
3012 
3014  inline std::list<CParameter *>::iterator
3015  endCustom (void)
3016  {
3017  return m_listCustom.end();
3018  }
3019 
3021  inline void
3023  {
3024  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3025  }
3026 
3028  inline int
3030  {
3031  return (int) (m_listCustom.size());
3032  }
3033 
3034  EResultCode
3036  addCustom (
3037  CParameter * pValue);
3038 
3039 
3040 };
3041 
3042 
3069 class CImpinjGPIDebounceConfiguration : public CParameter
3070 {
3071  public:
3074 
3077 
3078  static const CFieldDescriptor * const
3079  s_apFieldDescriptorTable[];
3080 
3081  static const CTypeDescriptor
3082  s_typeDescriptor;
3083 
3084  void
3085  decodeFields (
3086  CDecoderStream * pDecoderStream);
3087 
3088  void
3089  assimilateSubParameters (
3090  CErrorDetails * pError);
3091 
3092  void
3093  encode (
3094  CEncoderStream * pEncoderStream) const;
3095 
3096 
3097  llrp_bool_t
3098  isAllowedIn (
3099  const CTypeDescriptor * pEnclosingElementType) const;
3100 
3101 
3102  static CElement *
3103  s_construct (void);
3104 
3105  static void
3106  s_decodeFields (
3107  CDecoderStream * pDecoderStream,
3108  CElement * pElement);
3110 
3111 
3112  protected:
3113  llrp_u16_t m_GPIPortNum;
3114 
3117  public:
3118  static const CFieldDescriptor
3119  s_fdGPIPortNum;
3121 
3123  inline llrp_u16_t
3125  {
3126  return m_GPIPortNum;
3127  }
3128 
3130  inline void
3132  llrp_u16_t value)
3133  {
3134  m_GPIPortNum = value;
3135  }
3136 
3137 
3138  protected:
3139  llrp_u32_t m_GPIDebounceTimerMSec;
3140 
3143  public:
3144  static const CFieldDescriptor
3145  s_fdGPIDebounceTimerMSec;
3147 
3149  inline llrp_u32_t
3151  {
3152  return m_GPIDebounceTimerMSec;
3153  }
3154 
3156  inline void
3158  llrp_u32_t value)
3159  {
3160  m_GPIDebounceTimerMSec = value;
3161  }
3162 
3163 
3164  protected:
3165  std::list<CParameter *> m_listCustom;
3166 
3167  public:
3169  inline std::list<CParameter *>::iterator
3171  {
3172  return m_listCustom.begin();
3173  }
3174 
3176  inline std::list<CParameter *>::iterator
3177  endCustom (void)
3178  {
3179  return m_listCustom.end();
3180  }
3181 
3183  inline void
3185  {
3186  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3187  }
3188 
3190  inline int
3192  {
3193  return (int) (m_listCustom.size());
3194  }
3195 
3196  EResultCode
3198  addCustom (
3199  CParameter * pValue);
3200 
3201 
3202 };
3203 
3204 
3229 class CImpinjReaderTemperature : public CParameter
3230 {
3231  public:
3232  CImpinjReaderTemperature (void);
3233  ~CImpinjReaderTemperature (void);
3234 
3237 
3238  static const CFieldDescriptor * const
3239  s_apFieldDescriptorTable[];
3240 
3241  static const CTypeDescriptor
3242  s_typeDescriptor;
3243 
3244  void
3245  decodeFields (
3246  CDecoderStream * pDecoderStream);
3247 
3248  void
3249  assimilateSubParameters (
3250  CErrorDetails * pError);
3251 
3252  void
3253  encode (
3254  CEncoderStream * pEncoderStream) const;
3255 
3256 
3257  llrp_bool_t
3258  isAllowedIn (
3259  const CTypeDescriptor * pEnclosingElementType) const;
3260 
3261 
3262  static CElement *
3263  s_construct (void);
3264 
3265  static void
3266  s_decodeFields (
3267  CDecoderStream * pDecoderStream,
3268  CElement * pElement);
3270 
3271 
3272  protected:
3273  llrp_s16_t m_Temperature;
3274 
3277  public:
3278  static const CFieldDescriptor
3279  s_fdTemperature;
3281 
3283  inline llrp_s16_t
3285  {
3286  return m_Temperature;
3287  }
3288 
3290  inline void
3292  llrp_s16_t value)
3293  {
3294  m_Temperature = value;
3295  }
3296 
3297 
3298  protected:
3299  std::list<CParameter *> m_listCustom;
3300 
3301  public:
3303  inline std::list<CParameter *>::iterator
3305  {
3306  return m_listCustom.begin();
3307  }
3308 
3310  inline std::list<CParameter *>::iterator
3311  endCustom (void)
3312  {
3313  return m_listCustom.end();
3314  }
3315 
3317  inline void
3319  {
3320  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3321  }
3322 
3324  inline int
3326  {
3327  return (int) (m_listCustom.size());
3328  }
3329 
3330  EResultCode
3332  addCustom (
3333  CParameter * pValue);
3334 
3335 
3336 };
3337 
3338 
3365 class CImpinjLinkMonitorConfiguration : public CParameter
3366 {
3367  public:
3370 
3373 
3374  static const CFieldDescriptor * const
3375  s_apFieldDescriptorTable[];
3376 
3377  static const CTypeDescriptor
3378  s_typeDescriptor;
3379 
3380  void
3381  decodeFields (
3382  CDecoderStream * pDecoderStream);
3383 
3384  void
3385  assimilateSubParameters (
3386  CErrorDetails * pError);
3387 
3388  void
3389  encode (
3390  CEncoderStream * pEncoderStream) const;
3391 
3392 
3393  llrp_bool_t
3394  isAllowedIn (
3395  const CTypeDescriptor * pEnclosingElementType) const;
3396 
3397 
3398  static CElement *
3399  s_construct (void);
3400 
3401  static void
3402  s_decodeFields (
3403  CDecoderStream * pDecoderStream,
3404  CElement * pElement);
3406 
3407 
3408  protected:
3409  EImpinjLinkMonitorMode m_eLinkMonitorMode;
3410 
3413  public:
3414  static const CFieldDescriptor
3415  s_fdLinkMonitorMode;
3417 
3419  inline EImpinjLinkMonitorMode
3421  {
3422  return m_eLinkMonitorMode;
3423  }
3424 
3426  inline void
3428  EImpinjLinkMonitorMode value)
3429  {
3430  m_eLinkMonitorMode = value;
3431  }
3432 
3433 
3434  protected:
3435  llrp_u16_t m_LinkDownThreshold;
3436 
3439  public:
3440  static const CFieldDescriptor
3441  s_fdLinkDownThreshold;
3443 
3445  inline llrp_u16_t
3447  {
3448  return m_LinkDownThreshold;
3449  }
3450 
3452  inline void
3454  llrp_u16_t value)
3455  {
3456  m_LinkDownThreshold = value;
3457  }
3458 
3459 
3460  protected:
3461  std::list<CParameter *> m_listCustom;
3462 
3463  public:
3465  inline std::list<CParameter *>::iterator
3467  {
3468  return m_listCustom.begin();
3469  }
3470 
3472  inline std::list<CParameter *>::iterator
3473  endCustom (void)
3474  {
3475  return m_listCustom.end();
3476  }
3477 
3479  inline void
3481  {
3482  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3483  }
3484 
3486  inline int
3488  {
3489  return (int) (m_listCustom.size());
3490  }
3491 
3492  EResultCode
3494  addCustom (
3495  CParameter * pValue);
3496 
3497 
3498 };
3499 
3500 
3526 class CImpinjReportBufferConfiguration : public CParameter
3527 {
3528  public:
3531 
3534 
3535  static const CFieldDescriptor * const
3536  s_apFieldDescriptorTable[];
3537 
3538  static const CTypeDescriptor
3539  s_typeDescriptor;
3540 
3541  void
3542  decodeFields (
3543  CDecoderStream * pDecoderStream);
3544 
3545  void
3546  assimilateSubParameters (
3547  CErrorDetails * pError);
3548 
3549  void
3550  encode (
3551  CEncoderStream * pEncoderStream) const;
3552 
3553 
3554  llrp_bool_t
3555  isAllowedIn (
3556  const CTypeDescriptor * pEnclosingElementType) const;
3557 
3558 
3559  static CElement *
3560  s_construct (void);
3561 
3562  static void
3563  s_decodeFields (
3564  CDecoderStream * pDecoderStream,
3565  CElement * pElement);
3567 
3568 
3569  protected:
3570  EImpinjReportBufferMode m_eReportBufferMode;
3571 
3574  public:
3575  static const CFieldDescriptor
3576  s_fdReportBufferMode;
3578 
3580  inline EImpinjReportBufferMode
3582  {
3583  return m_eReportBufferMode;
3584  }
3585 
3587  inline void
3589  EImpinjReportBufferMode value)
3590  {
3591  m_eReportBufferMode = value;
3592  }
3593 
3594 
3595  protected:
3596  std::list<CParameter *> m_listCustom;
3597 
3598  public:
3600  inline std::list<CParameter *>::iterator
3602  {
3603  return m_listCustom.begin();
3604  }
3605 
3607  inline std::list<CParameter *>::iterator
3608  endCustom (void)
3609  {
3610  return m_listCustom.end();
3611  }
3612 
3614  inline void
3616  {
3617  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3618  }
3619 
3621  inline int
3623  {
3624  return (int) (m_listCustom.size());
3625  }
3626 
3627  EResultCode
3629  addCustom (
3630  CParameter * pValue);
3631 
3632 
3633 };
3634 
3635 
3664 class CImpinjAccessSpecConfiguration : public CParameter
3665 {
3666  public:
3669 
3672 
3673  static const CFieldDescriptor * const
3674  s_apFieldDescriptorTable[];
3675 
3676  static const CTypeDescriptor
3677  s_typeDescriptor;
3678 
3679  void
3680  decodeFields (
3681  CDecoderStream * pDecoderStream);
3682 
3683  void
3684  assimilateSubParameters (
3685  CErrorDetails * pError);
3686 
3687  void
3688  encode (
3689  CEncoderStream * pEncoderStream) const;
3690 
3691 
3692  llrp_bool_t
3693  isAllowedIn (
3694  const CTypeDescriptor * pEnclosingElementType) const;
3695 
3696 
3697  static CElement *
3698  s_construct (void);
3699 
3700  static void
3701  s_decodeFields (
3702  CDecoderStream * pDecoderStream,
3703  CElement * pElement);
3705 
3706 
3707  protected:
3708  CImpinjBlockWriteWordCount * m_pImpinjBlockWriteWordCount;
3709 
3710  public:
3714  {
3715  return m_pImpinjBlockWriteWordCount;
3716  }
3717 
3719  EResultCode
3721  CImpinjBlockWriteWordCount * pValue);
3722 
3723 
3724  protected:
3725  CImpinjOpSpecRetryCount * m_pImpinjOpSpecRetryCount;
3726 
3727  public:
3729  inline CImpinjOpSpecRetryCount *
3731  {
3732  return m_pImpinjOpSpecRetryCount;
3733  }
3734 
3736  EResultCode
3738  CImpinjOpSpecRetryCount * pValue);
3739 
3740 
3741  protected:
3742  CImpinjAccessSpecOrdering * m_pImpinjAccessSpecOrdering;
3743 
3744  public:
3746  inline CImpinjAccessSpecOrdering *
3748  {
3749  return m_pImpinjAccessSpecOrdering;
3750  }
3751 
3753  EResultCode
3755  CImpinjAccessSpecOrdering * pValue);
3756 
3757 
3758  protected:
3759  std::list<CParameter *> m_listCustom;
3760 
3761  public:
3763  inline std::list<CParameter *>::iterator
3765  {
3766  return m_listCustom.begin();
3767  }
3768 
3770  inline std::list<CParameter *>::iterator
3771  endCustom (void)
3772  {
3773  return m_listCustom.end();
3774  }
3775 
3777  inline void
3779  {
3780  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3781  }
3782 
3784  inline int
3786  {
3787  return (int) (m_listCustom.size());
3788  }
3789 
3790  EResultCode
3792  addCustom (
3793  CParameter * pValue);
3794 
3795 
3796 };
3797 
3798 
3822 class CImpinjBlockWriteWordCount : public CParameter
3823 {
3824  public:
3827 
3830 
3831  static const CFieldDescriptor * const
3832  s_apFieldDescriptorTable[];
3833 
3834  static const CTypeDescriptor
3835  s_typeDescriptor;
3836 
3837  void
3838  decodeFields (
3839  CDecoderStream * pDecoderStream);
3840 
3841  void
3842  assimilateSubParameters (
3843  CErrorDetails * pError);
3844 
3845  void
3846  encode (
3847  CEncoderStream * pEncoderStream) const;
3848 
3849 
3850  llrp_bool_t
3851  isAllowedIn (
3852  const CTypeDescriptor * pEnclosingElementType) const;
3853 
3854 
3855  static CElement *
3856  s_construct (void);
3857 
3858  static void
3859  s_decodeFields (
3860  CDecoderStream * pDecoderStream,
3861  CElement * pElement);
3863 
3864 
3865  protected:
3866  llrp_u16_t m_WordCount;
3867 
3870  public:
3871  static const CFieldDescriptor
3872  s_fdWordCount;
3874 
3876  inline llrp_u16_t
3878  {
3879  return m_WordCount;
3880  }
3881 
3883  inline void
3885  llrp_u16_t value)
3886  {
3887  m_WordCount = value;
3888  }
3889 
3890 
3891  protected:
3892  std::list<CParameter *> m_listCustom;
3893 
3894  public:
3896  inline std::list<CParameter *>::iterator
3898  {
3899  return m_listCustom.begin();
3900  }
3901 
3903  inline std::list<CParameter *>::iterator
3904  endCustom (void)
3905  {
3906  return m_listCustom.end();
3907  }
3908 
3910  inline void
3912  {
3913  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3914  }
3915 
3917  inline int
3919  {
3920  return (int) (m_listCustom.size());
3921  }
3922 
3923  EResultCode
3925  addCustom (
3926  CParameter * pValue);
3927 
3928 
3929 };
3930 
3931 
3961 class CImpinjBlockPermalock : public CParameter
3962 {
3963  public:
3964  CImpinjBlockPermalock (void);
3965  ~CImpinjBlockPermalock (void);
3966 
3969 
3970  static const CFieldDescriptor * const
3971  s_apFieldDescriptorTable[];
3972 
3973  static const CTypeDescriptor
3974  s_typeDescriptor;
3975 
3976  void
3977  decodeFields (
3978  CDecoderStream * pDecoderStream);
3979 
3980  void
3981  assimilateSubParameters (
3982  CErrorDetails * pError);
3983 
3984  void
3985  encode (
3986  CEncoderStream * pEncoderStream) const;
3987 
3988 
3989  llrp_bool_t
3990  isAllowedIn (
3991  const CTypeDescriptor * pEnclosingElementType) const;
3992 
3993 
3994  static CElement *
3995  s_construct (void);
3996 
3997  static void
3998  s_decodeFields (
3999  CDecoderStream * pDecoderStream,
4000  CElement * pElement);
4002 
4003 
4004  protected:
4005  llrp_u16_t m_OpSpecID;
4006 
4009  public:
4010  static const CFieldDescriptor
4011  s_fdOpSpecID;
4013 
4015  inline llrp_u16_t
4017  {
4018  return m_OpSpecID;
4019  }
4020 
4022  inline void
4024  llrp_u16_t value)
4025  {
4026  m_OpSpecID = value;
4027  }
4028 
4029 
4030  protected:
4031  llrp_u32_t m_AccessPassword;
4032 
4035  public:
4036  static const CFieldDescriptor
4037  s_fdAccessPassword;
4039 
4041  inline llrp_u32_t
4043  {
4044  return m_AccessPassword;
4045  }
4046 
4048  inline void
4050  llrp_u32_t value)
4051  {
4052  m_AccessPassword = value;
4053  }
4054 
4055 
4056  protected:
4057  llrp_u2_t m_MB;
4058 
4061  public:
4062  static const CFieldDescriptor
4063  s_fdMB;
4065 
4067  inline llrp_u2_t
4068  getMB (void)
4069  {
4070  return m_MB;
4071  }
4072 
4074  inline void
4076  llrp_u2_t value)
4077  {
4078  m_MB = value;
4079  }
4080 
4081 
4082  protected:
4083  llrp_u16_t m_BlockPointer;
4084 
4087  public:
4088  static const CFieldDescriptor
4089  s_fdBlockPointer;
4091 
4093  inline llrp_u16_t
4095  {
4096  return m_BlockPointer;
4097  }
4098 
4100  inline void
4102  llrp_u16_t value)
4103  {
4104  m_BlockPointer = value;
4105  }
4106 
4107 
4108  protected:
4109  llrp_u16v_t m_BlockMask;
4110 
4113  public:
4114  static const CFieldDescriptor
4115  s_fdBlockMask;
4117 
4119  inline llrp_u16v_t
4121  {
4122  return m_BlockMask;
4123  }
4124 
4126  inline void
4128  llrp_u16v_t value)
4129  {
4130  m_BlockMask = value;
4131  }
4132 
4133 
4134  protected:
4135  std::list<CParameter *> m_listCustom;
4136 
4137  public:
4139  inline std::list<CParameter *>::iterator
4141  {
4142  return m_listCustom.begin();
4143  }
4144 
4146  inline std::list<CParameter *>::iterator
4147  endCustom (void)
4148  {
4149  return m_listCustom.end();
4150  }
4151 
4153  inline void
4155  {
4156  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4157  }
4158 
4160  inline int
4162  {
4163  return (int) (m_listCustom.size());
4164  }
4165 
4166  EResultCode
4168  addCustom (
4169  CParameter * pValue);
4170 
4171 
4172 };
4173 
4174 
4200 class CImpinjBlockPermalockOpSpecResult : public CParameter
4201 {
4202  public:
4205 
4208 
4209  static const CFieldDescriptor * const
4210  s_apFieldDescriptorTable[];
4211 
4212  static const CTypeDescriptor
4213  s_typeDescriptor;
4214 
4215  void
4216  decodeFields (
4217  CDecoderStream * pDecoderStream);
4218 
4219  void
4220  assimilateSubParameters (
4221  CErrorDetails * pError);
4222 
4223  void
4224  encode (
4225  CEncoderStream * pEncoderStream) const;
4226 
4227 
4228  llrp_bool_t
4229  isAllowedIn (
4230  const CTypeDescriptor * pEnclosingElementType) const;
4231 
4232 
4233  static CElement *
4234  s_construct (void);
4235 
4236  static void
4237  s_decodeFields (
4238  CDecoderStream * pDecoderStream,
4239  CElement * pElement);
4241 
4242 
4243  protected:
4244  EImpinjBlockPermalockResultType m_eResult;
4245 
4248  public:
4249  static const CFieldDescriptor
4250  s_fdResult;
4252 
4254  inline EImpinjBlockPermalockResultType
4255  getResult (void)
4256  {
4257  return m_eResult;
4258  }
4259 
4261  inline void
4263  EImpinjBlockPermalockResultType value)
4264  {
4265  m_eResult = value;
4266  }
4267 
4268 
4269  protected:
4270  llrp_u16_t m_OpSpecID;
4271 
4274  public:
4275  static const CFieldDescriptor
4276  s_fdOpSpecID;
4278 
4280  inline llrp_u16_t
4282  {
4283  return m_OpSpecID;
4284  }
4285 
4287  inline void
4289  llrp_u16_t value)
4290  {
4291  m_OpSpecID = value;
4292  }
4293 
4294 
4295  protected:
4296  std::list<CParameter *> m_listCustom;
4297 
4298  public:
4300  inline std::list<CParameter *>::iterator
4302  {
4303  return m_listCustom.begin();
4304  }
4305 
4307  inline std::list<CParameter *>::iterator
4308  endCustom (void)
4309  {
4310  return m_listCustom.end();
4311  }
4312 
4314  inline void
4316  {
4317  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4318  }
4319 
4321  inline int
4323  {
4324  return (int) (m_listCustom.size());
4325  }
4326 
4327  EResultCode
4329  addCustom (
4330  CParameter * pValue);
4331 
4332 
4333 };
4334 
4335 
4365 class CImpinjGetBlockPermalockStatus : public CParameter
4366 {
4367  public:
4370 
4373 
4374  static const CFieldDescriptor * const
4375  s_apFieldDescriptorTable[];
4376 
4377  static const CTypeDescriptor
4378  s_typeDescriptor;
4379 
4380  void
4381  decodeFields (
4382  CDecoderStream * pDecoderStream);
4383 
4384  void
4385  assimilateSubParameters (
4386  CErrorDetails * pError);
4387 
4388  void
4389  encode (
4390  CEncoderStream * pEncoderStream) const;
4391 
4392 
4393  llrp_bool_t
4394  isAllowedIn (
4395  const CTypeDescriptor * pEnclosingElementType) const;
4396 
4397 
4398  static CElement *
4399  s_construct (void);
4400 
4401  static void
4402  s_decodeFields (
4403  CDecoderStream * pDecoderStream,
4404  CElement * pElement);
4406 
4407 
4408  protected:
4409  llrp_u16_t m_OpSpecID;
4410 
4413  public:
4414  static const CFieldDescriptor
4415  s_fdOpSpecID;
4417 
4419  inline llrp_u16_t
4421  {
4422  return m_OpSpecID;
4423  }
4424 
4426  inline void
4428  llrp_u16_t value)
4429  {
4430  m_OpSpecID = value;
4431  }
4432 
4433 
4434  protected:
4435  llrp_u32_t m_AccessPassword;
4436 
4439  public:
4440  static const CFieldDescriptor
4441  s_fdAccessPassword;
4443 
4445  inline llrp_u32_t
4447  {
4448  return m_AccessPassword;
4449  }
4450 
4452  inline void
4454  llrp_u32_t value)
4455  {
4456  m_AccessPassword = value;
4457  }
4458 
4459 
4460  protected:
4461  llrp_u2_t m_MB;
4462 
4465  public:
4466  static const CFieldDescriptor
4467  s_fdMB;
4469 
4471  inline llrp_u2_t
4472  getMB (void)
4473  {
4474  return m_MB;
4475  }
4476 
4478  inline void
4480  llrp_u2_t value)
4481  {
4482  m_MB = value;
4483  }
4484 
4485 
4486  protected:
4487  llrp_u16_t m_BlockPointer;
4488 
4491  public:
4492  static const CFieldDescriptor
4493  s_fdBlockPointer;
4495 
4497  inline llrp_u16_t
4499  {
4500  return m_BlockPointer;
4501  }
4502 
4504  inline void
4506  llrp_u16_t value)
4507  {
4508  m_BlockPointer = value;
4509  }
4510 
4511 
4512  protected:
4513  llrp_u16_t m_BlockRange;
4514 
4517  public:
4518  static const CFieldDescriptor
4519  s_fdBlockRange;
4521 
4523  inline llrp_u16_t
4525  {
4526  return m_BlockRange;
4527  }
4528 
4530  inline void
4532  llrp_u16_t value)
4533  {
4534  m_BlockRange = value;
4535  }
4536 
4537 
4538  protected:
4539  std::list<CParameter *> m_listCustom;
4540 
4541  public:
4543  inline std::list<CParameter *>::iterator
4545  {
4546  return m_listCustom.begin();
4547  }
4548 
4550  inline std::list<CParameter *>::iterator
4551  endCustom (void)
4552  {
4553  return m_listCustom.end();
4554  }
4555 
4557  inline void
4559  {
4560  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4561  }
4562 
4564  inline int
4566  {
4567  return (int) (m_listCustom.size());
4568  }
4569 
4570  EResultCode
4572  addCustom (
4573  CParameter * pValue);
4574 
4575 
4576 };
4577 
4578 
4606 {
4607  public:
4610 
4613 
4614  static const CFieldDescriptor * const
4615  s_apFieldDescriptorTable[];
4616 
4617  static const CTypeDescriptor
4618  s_typeDescriptor;
4619 
4620  void
4621  decodeFields (
4622  CDecoderStream * pDecoderStream);
4623 
4624  void
4625  assimilateSubParameters (
4626  CErrorDetails * pError);
4627 
4628  void
4629  encode (
4630  CEncoderStream * pEncoderStream) const;
4631 
4632 
4633  llrp_bool_t
4634  isAllowedIn (
4635  const CTypeDescriptor * pEnclosingElementType) const;
4636 
4637 
4638  static CElement *
4639  s_construct (void);
4640 
4641  static void
4642  s_decodeFields (
4643  CDecoderStream * pDecoderStream,
4644  CElement * pElement);
4646 
4647 
4648  protected:
4649  EImpinjGetBlockPermalockStatusResultType m_eResult;
4650 
4653  public:
4654  static const CFieldDescriptor
4655  s_fdResult;
4657 
4659  inline EImpinjGetBlockPermalockStatusResultType
4660  getResult (void)
4661  {
4662  return m_eResult;
4663  }
4664 
4666  inline void
4668  EImpinjGetBlockPermalockStatusResultType value)
4669  {
4670  m_eResult = value;
4671  }
4672 
4673 
4674  protected:
4675  llrp_u16_t m_OpSpecID;
4676 
4679  public:
4680  static const CFieldDescriptor
4681  s_fdOpSpecID;
4683 
4685  inline llrp_u16_t
4687  {
4688  return m_OpSpecID;
4689  }
4690 
4692  inline void
4694  llrp_u16_t value)
4695  {
4696  m_OpSpecID = value;
4697  }
4698 
4699 
4700  protected:
4701  llrp_u16v_t m_PermalockStatus;
4702 
4705  public:
4706  static const CFieldDescriptor
4707  s_fdPermalockStatus;
4709 
4711  inline llrp_u16v_t
4713  {
4714  return m_PermalockStatus;
4715  }
4716 
4718  inline void
4720  llrp_u16v_t value)
4721  {
4722  m_PermalockStatus = value;
4723  }
4724 
4725 
4726  protected:
4727  std::list<CParameter *> m_listCustom;
4728 
4729  public:
4731  inline std::list<CParameter *>::iterator
4733  {
4734  return m_listCustom.begin();
4735  }
4736 
4738  inline std::list<CParameter *>::iterator
4739  endCustom (void)
4740  {
4741  return m_listCustom.end();
4742  }
4743 
4745  inline void
4747  {
4748  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4749  }
4750 
4752  inline int
4754  {
4755  return (int) (m_listCustom.size());
4756  }
4757 
4758  EResultCode
4760  addCustom (
4761  CParameter * pValue);
4762 
4763 
4764 };
4765 
4766 
4796 class CImpinjSetQTConfig : public CParameter
4797 {
4798  public:
4799  CImpinjSetQTConfig (void);
4800  ~CImpinjSetQTConfig (void);
4801 
4804 
4805  static const CFieldDescriptor * const
4806  s_apFieldDescriptorTable[];
4807 
4808  static const CTypeDescriptor
4809  s_typeDescriptor;
4810 
4811  void
4812  decodeFields (
4813  CDecoderStream * pDecoderStream);
4814 
4815  void
4816  assimilateSubParameters (
4817  CErrorDetails * pError);
4818 
4819  void
4820  encode (
4821  CEncoderStream * pEncoderStream) const;
4822 
4823 
4824  llrp_bool_t
4825  isAllowedIn (
4826  const CTypeDescriptor * pEnclosingElementType) const;
4827 
4828 
4829  static CElement *
4830  s_construct (void);
4831 
4832  static void
4833  s_decodeFields (
4834  CDecoderStream * pDecoderStream,
4835  CElement * pElement);
4837 
4838 
4839  protected:
4840  llrp_u16_t m_OpSpecID;
4841 
4844  public:
4845  static const CFieldDescriptor
4846  s_fdOpSpecID;
4848 
4850  inline llrp_u16_t
4852  {
4853  return m_OpSpecID;
4854  }
4855 
4857  inline void
4859  llrp_u16_t value)
4860  {
4861  m_OpSpecID = value;
4862  }
4863 
4864 
4865  protected:
4866  llrp_u32_t m_AccessPassword;
4867 
4870  public:
4871  static const CFieldDescriptor
4872  s_fdAccessPassword;
4874 
4876  inline llrp_u32_t
4878  {
4879  return m_AccessPassword;
4880  }
4881 
4883  inline void
4885  llrp_u32_t value)
4886  {
4887  m_AccessPassword = value;
4888  }
4889 
4890 
4891  protected:
4892  EImpinjQTDataProfile m_eDataProfile;
4893 
4896  public:
4897  static const CFieldDescriptor
4898  s_fdDataProfile;
4900 
4902  inline EImpinjQTDataProfile
4904  {
4905  return m_eDataProfile;
4906  }
4907 
4909  inline void
4911  EImpinjQTDataProfile value)
4912  {
4913  m_eDataProfile = value;
4914  }
4915 
4916 
4917  protected:
4918  EImpinjQTAccessRange m_eAccessRange;
4919 
4922  public:
4923  static const CFieldDescriptor
4924  s_fdAccessRange;
4926 
4928  inline EImpinjQTAccessRange
4930  {
4931  return m_eAccessRange;
4932  }
4933 
4935  inline void
4937  EImpinjQTAccessRange value)
4938  {
4939  m_eAccessRange = value;
4940  }
4941 
4942 
4943  protected:
4944  EImpinjQTPersistence m_ePersistence;
4945 
4948  public:
4949  static const CFieldDescriptor
4950  s_fdPersistence;
4952 
4954  inline EImpinjQTPersistence
4956  {
4957  return m_ePersistence;
4958  }
4959 
4961  inline void
4963  EImpinjQTPersistence value)
4964  {
4965  m_ePersistence = value;
4966  }
4967 
4968 
4969  protected:
4970  std::list<CParameter *> m_listCustom;
4971 
4972  public:
4974  inline std::list<CParameter *>::iterator
4976  {
4977  return m_listCustom.begin();
4978  }
4979 
4981  inline std::list<CParameter *>::iterator
4982  endCustom (void)
4983  {
4984  return m_listCustom.end();
4985  }
4986 
4988  inline void
4990  {
4991  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4992  }
4993 
4995  inline int
4997  {
4998  return (int) (m_listCustom.size());
4999  }
5000 
5001  EResultCode
5003  addCustom (
5004  CParameter * pValue);
5005 
5006 
5007 };
5008 
5009 
5035 class CImpinjSetQTConfigOpSpecResult : public CParameter
5036 {
5037  public:
5040 
5043 
5044  static const CFieldDescriptor * const
5045  s_apFieldDescriptorTable[];
5046 
5047  static const CTypeDescriptor
5048  s_typeDescriptor;
5049 
5050  void
5051  decodeFields (
5052  CDecoderStream * pDecoderStream);
5053 
5054  void
5055  assimilateSubParameters (
5056  CErrorDetails * pError);
5057 
5058  void
5059  encode (
5060  CEncoderStream * pEncoderStream) const;
5061 
5062 
5063  llrp_bool_t
5064  isAllowedIn (
5065  const CTypeDescriptor * pEnclosingElementType) const;
5066 
5067 
5068  static CElement *
5069  s_construct (void);
5070 
5071  static void
5072  s_decodeFields (
5073  CDecoderStream * pDecoderStream,
5074  CElement * pElement);
5076 
5077 
5078  protected:
5079  EImpinjSetQTConfigResultType m_eResult;
5080 
5083  public:
5084  static const CFieldDescriptor
5085  s_fdResult;
5087 
5089  inline EImpinjSetQTConfigResultType
5090  getResult (void)
5091  {
5092  return m_eResult;
5093  }
5094 
5096  inline void
5098  EImpinjSetQTConfigResultType value)
5099  {
5100  m_eResult = value;
5101  }
5102 
5103 
5104  protected:
5105  llrp_u16_t m_OpSpecID;
5106 
5109  public:
5110  static const CFieldDescriptor
5111  s_fdOpSpecID;
5113 
5115  inline llrp_u16_t
5117  {
5118  return m_OpSpecID;
5119  }
5120 
5122  inline void
5124  llrp_u16_t value)
5125  {
5126  m_OpSpecID = value;
5127  }
5128 
5129 
5130  protected:
5131  std::list<CParameter *> m_listCustom;
5132 
5133  public:
5135  inline std::list<CParameter *>::iterator
5137  {
5138  return m_listCustom.begin();
5139  }
5140 
5142  inline std::list<CParameter *>::iterator
5143  endCustom (void)
5144  {
5145  return m_listCustom.end();
5146  }
5147 
5149  inline void
5151  {
5152  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5153  }
5154 
5156  inline int
5158  {
5159  return (int) (m_listCustom.size());
5160  }
5161 
5162  EResultCode
5164  addCustom (
5165  CParameter * pValue);
5166 
5167 
5168 };
5169 
5170 
5196 class CImpinjGetQTConfig : public CParameter
5197 {
5198  public:
5199  CImpinjGetQTConfig (void);
5200  ~CImpinjGetQTConfig (void);
5201 
5204 
5205  static const CFieldDescriptor * const
5206  s_apFieldDescriptorTable[];
5207 
5208  static const CTypeDescriptor
5209  s_typeDescriptor;
5210 
5211  void
5212  decodeFields (
5213  CDecoderStream * pDecoderStream);
5214 
5215  void
5216  assimilateSubParameters (
5217  CErrorDetails * pError);
5218 
5219  void
5220  encode (
5221  CEncoderStream * pEncoderStream) const;
5222 
5223 
5224  llrp_bool_t
5225  isAllowedIn (
5226  const CTypeDescriptor * pEnclosingElementType) const;
5227 
5228 
5229  static CElement *
5230  s_construct (void);
5231 
5232  static void
5233  s_decodeFields (
5234  CDecoderStream * pDecoderStream,
5235  CElement * pElement);
5237 
5238 
5239  protected:
5240  llrp_u16_t m_OpSpecID;
5241 
5244  public:
5245  static const CFieldDescriptor
5246  s_fdOpSpecID;
5248 
5250  inline llrp_u16_t
5252  {
5253  return m_OpSpecID;
5254  }
5255 
5257  inline void
5259  llrp_u16_t value)
5260  {
5261  m_OpSpecID = value;
5262  }
5263 
5264 
5265  protected:
5266  llrp_u32_t m_AccessPassword;
5267 
5270  public:
5271  static const CFieldDescriptor
5272  s_fdAccessPassword;
5274 
5276  inline llrp_u32_t
5278  {
5279  return m_AccessPassword;
5280  }
5281 
5283  inline void
5285  llrp_u32_t value)
5286  {
5287  m_AccessPassword = value;
5288  }
5289 
5290 
5291  protected:
5292  std::list<CParameter *> m_listCustom;
5293 
5294  public:
5296  inline std::list<CParameter *>::iterator
5298  {
5299  return m_listCustom.begin();
5300  }
5301 
5303  inline std::list<CParameter *>::iterator
5304  endCustom (void)
5305  {
5306  return m_listCustom.end();
5307  }
5308 
5310  inline void
5312  {
5313  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5314  }
5315 
5317  inline int
5319  {
5320  return (int) (m_listCustom.size());
5321  }
5322 
5323  EResultCode
5325  addCustom (
5326  CParameter * pValue);
5327 
5328 
5329 };
5330 
5331 
5360 class CImpinjGetQTConfigOpSpecResult : public CParameter
5361 {
5362  public:
5365 
5368 
5369  static const CFieldDescriptor * const
5370  s_apFieldDescriptorTable[];
5371 
5372  static const CTypeDescriptor
5373  s_typeDescriptor;
5374 
5375  void
5376  decodeFields (
5377  CDecoderStream * pDecoderStream);
5378 
5379  void
5380  assimilateSubParameters (
5381  CErrorDetails * pError);
5382 
5383  void
5384  encode (
5385  CEncoderStream * pEncoderStream) const;
5386 
5387 
5388  llrp_bool_t
5389  isAllowedIn (
5390  const CTypeDescriptor * pEnclosingElementType) const;
5391 
5392 
5393  static CElement *
5394  s_construct (void);
5395 
5396  static void
5397  s_decodeFields (
5398  CDecoderStream * pDecoderStream,
5399  CElement * pElement);
5401 
5402 
5403  protected:
5404  EImpinjGetQTConfigResultType m_eResult;
5405 
5408  public:
5409  static const CFieldDescriptor
5410  s_fdResult;
5412 
5414  inline EImpinjGetQTConfigResultType
5415  getResult (void)
5416  {
5417  return m_eResult;
5418  }
5419 
5421  inline void
5423  EImpinjGetQTConfigResultType value)
5424  {
5425  m_eResult = value;
5426  }
5427 
5428 
5429  protected:
5430  llrp_u16_t m_OpSpecID;
5431 
5434  public:
5435  static const CFieldDescriptor
5436  s_fdOpSpecID;
5438 
5440  inline llrp_u16_t
5442  {
5443  return m_OpSpecID;
5444  }
5445 
5447  inline void
5449  llrp_u16_t value)
5450  {
5451  m_OpSpecID = value;
5452  }
5453 
5454 
5455  protected:
5456  EImpinjQTDataProfile m_eDataProfile;
5457 
5460  public:
5461  static const CFieldDescriptor
5462  s_fdDataProfile;
5464 
5466  inline EImpinjQTDataProfile
5468  {
5469  return m_eDataProfile;
5470  }
5471 
5473  inline void
5475  EImpinjQTDataProfile value)
5476  {
5477  m_eDataProfile = value;
5478  }
5479 
5480 
5481  protected:
5482  EImpinjQTAccessRange m_eAccessRange;
5483 
5486  public:
5487  static const CFieldDescriptor
5488  s_fdAccessRange;
5490 
5492  inline EImpinjQTAccessRange
5494  {
5495  return m_eAccessRange;
5496  }
5497 
5499  inline void
5501  EImpinjQTAccessRange value)
5502  {
5503  m_eAccessRange = value;
5504  }
5505 
5506 
5507  protected:
5508  std::list<CParameter *> m_listCustom;
5509 
5510  public:
5512  inline std::list<CParameter *>::iterator
5514  {
5515  return m_listCustom.begin();
5516  }
5517 
5519  inline std::list<CParameter *>::iterator
5520  endCustom (void)
5521  {
5522  return m_listCustom.end();
5523  }
5524 
5526  inline void
5528  {
5529  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5530  }
5531 
5533  inline int
5535  {
5536  return (int) (m_listCustom.size());
5537  }
5538 
5539  EResultCode
5541  addCustom (
5542  CParameter * pValue);
5543 
5544 
5545 };
5546 
5547 
5578 class CImpinjTagReportContentSelector : public CParameter
5579 {
5580  public:
5583 
5586 
5587  static const CFieldDescriptor * const
5588  s_apFieldDescriptorTable[];
5589 
5590  static const CTypeDescriptor
5591  s_typeDescriptor;
5592 
5593  void
5594  decodeFields (
5595  CDecoderStream * pDecoderStream);
5596 
5597  void
5598  assimilateSubParameters (
5599  CErrorDetails * pError);
5600 
5601  void
5602  encode (
5603  CEncoderStream * pEncoderStream) const;
5604 
5605 
5606  llrp_bool_t
5607  isAllowedIn (
5608  const CTypeDescriptor * pEnclosingElementType) const;
5609 
5610 
5611  static CElement *
5612  s_construct (void);
5613 
5614  static void
5615  s_decodeFields (
5616  CDecoderStream * pDecoderStream,
5617  CElement * pElement);
5619 
5620 
5621  protected:
5622  CImpinjEnableSerializedTID * m_pImpinjEnableSerializedTID;
5623 
5624  public:
5628  {
5629  return m_pImpinjEnableSerializedTID;
5630  }
5631 
5633  EResultCode
5635  CImpinjEnableSerializedTID * pValue);
5636 
5637 
5638  protected:
5639  CImpinjEnableRFPhaseAngle * m_pImpinjEnableRFPhaseAngle;
5640 
5641  public:
5643  inline CImpinjEnableRFPhaseAngle *
5645  {
5646  return m_pImpinjEnableRFPhaseAngle;
5647  }
5648 
5650  EResultCode
5652  CImpinjEnableRFPhaseAngle * pValue);
5653 
5654 
5655  protected:
5656  CImpinjEnablePeakRSSI * m_pImpinjEnablePeakRSSI;
5657 
5658  public:
5660  inline CImpinjEnablePeakRSSI *
5662  {
5663  return m_pImpinjEnablePeakRSSI;
5664  }
5665 
5667  EResultCode
5669  CImpinjEnablePeakRSSI * pValue);
5670 
5671 
5672  protected:
5673  CImpinjEnableGPSCoordinates * m_pImpinjEnableGPSCoordinates;
5674 
5675  public:
5679  {
5680  return m_pImpinjEnableGPSCoordinates;
5681  }
5682 
5684  EResultCode
5686  CImpinjEnableGPSCoordinates * pValue);
5687 
5688 
5689  protected:
5690  CImpinjEnableOptimizedRead * m_pImpinjEnableOptimizedRead;
5691 
5692  public:
5696  {
5697  return m_pImpinjEnableOptimizedRead;
5698  }
5699 
5701  EResultCode
5703  CImpinjEnableOptimizedRead * pValue);
5704 
5705 
5706  protected:
5707  CImpinjEnableRFDopplerFrequency * m_pImpinjEnableRFDopplerFrequency;
5708 
5709  public:
5713  {
5714  return m_pImpinjEnableRFDopplerFrequency;
5715  }
5716 
5718  EResultCode
5721 
5722 
5723  protected:
5724  CImpinjEnableTxPower * m_pImpinjEnableTxPower;
5725 
5726  public:
5728  inline CImpinjEnableTxPower *
5730  {
5731  return m_pImpinjEnableTxPower;
5732  }
5733 
5735  EResultCode
5737  CImpinjEnableTxPower * pValue);
5738 
5739 
5740  protected:
5741  std::list<CParameter *> m_listCustom;
5742 
5743  public:
5745  inline std::list<CParameter *>::iterator
5747  {
5748  return m_listCustom.begin();
5749  }
5750 
5752  inline std::list<CParameter *>::iterator
5753  endCustom (void)
5754  {
5755  return m_listCustom.end();
5756  }
5757 
5759  inline void
5761  {
5762  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5763  }
5764 
5766  inline int
5768  {
5769  return (int) (m_listCustom.size());
5770  }
5771 
5772  EResultCode
5774  addCustom (
5775  CParameter * pValue);
5776 
5777 
5778 };
5779 
5780 
5804 class CImpinjEnableSerializedTID : public CParameter
5805 {
5806  public:
5809 
5812 
5813  static const CFieldDescriptor * const
5814  s_apFieldDescriptorTable[];
5815 
5816  static const CTypeDescriptor
5817  s_typeDescriptor;
5818 
5819  void
5820  decodeFields (
5821  CDecoderStream * pDecoderStream);
5822 
5823  void
5824  assimilateSubParameters (
5825  CErrorDetails * pError);
5826 
5827  void
5828  encode (
5829  CEncoderStream * pEncoderStream) const;
5830 
5831 
5832  llrp_bool_t
5833  isAllowedIn (
5834  const CTypeDescriptor * pEnclosingElementType) const;
5835 
5836 
5837  static CElement *
5838  s_construct (void);
5839 
5840  static void
5841  s_decodeFields (
5842  CDecoderStream * pDecoderStream,
5843  CElement * pElement);
5845 
5846 
5847  protected:
5848  EImpinjSerializedTIDMode m_eSerializedTIDMode;
5849 
5852  public:
5853  static const CFieldDescriptor
5854  s_fdSerializedTIDMode;
5856 
5858  inline EImpinjSerializedTIDMode
5860  {
5861  return m_eSerializedTIDMode;
5862  }
5863 
5865  inline void
5867  EImpinjSerializedTIDMode value)
5868  {
5869  m_eSerializedTIDMode = value;
5870  }
5871 
5872 
5873  protected:
5874  std::list<CParameter *> m_listCustom;
5875 
5876  public:
5878  inline std::list<CParameter *>::iterator
5880  {
5881  return m_listCustom.begin();
5882  }
5883 
5885  inline std::list<CParameter *>::iterator
5886  endCustom (void)
5887  {
5888  return m_listCustom.end();
5889  }
5890 
5892  inline void
5894  {
5895  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5896  }
5897 
5899  inline int
5901  {
5902  return (int) (m_listCustom.size());
5903  }
5904 
5905  EResultCode
5907  addCustom (
5908  CParameter * pValue);
5909 
5910 
5911 };
5912 
5913 
5937 class CImpinjEnableRFPhaseAngle : public CParameter
5938 {
5939  public:
5941  ~CImpinjEnableRFPhaseAngle (void);
5942 
5945 
5946  static const CFieldDescriptor * const
5947  s_apFieldDescriptorTable[];
5948 
5949  static const CTypeDescriptor
5950  s_typeDescriptor;
5951 
5952  void
5953  decodeFields (
5954  CDecoderStream * pDecoderStream);
5955 
5956  void
5957  assimilateSubParameters (
5958  CErrorDetails * pError);
5959 
5960  void
5961  encode (
5962  CEncoderStream * pEncoderStream) const;
5963 
5964 
5965  llrp_bool_t
5966  isAllowedIn (
5967  const CTypeDescriptor * pEnclosingElementType) const;
5968 
5969 
5970  static CElement *
5971  s_construct (void);
5972 
5973  static void
5974  s_decodeFields (
5975  CDecoderStream * pDecoderStream,
5976  CElement * pElement);
5978 
5979 
5980  protected:
5981  EImpinjRFPhaseAngleMode m_eRFPhaseAngleMode;
5982 
5985  public:
5986  static const CFieldDescriptor
5987  s_fdRFPhaseAngleMode;
5989 
5991  inline EImpinjRFPhaseAngleMode
5993  {
5994  return m_eRFPhaseAngleMode;
5995  }
5996 
5998  inline void
6000  EImpinjRFPhaseAngleMode value)
6001  {
6002  m_eRFPhaseAngleMode = value;
6003  }
6004 
6005 
6006  protected:
6007  std::list<CParameter *> m_listCustom;
6008 
6009  public:
6011  inline std::list<CParameter *>::iterator
6013  {
6014  return m_listCustom.begin();
6015  }
6016 
6018  inline std::list<CParameter *>::iterator
6019  endCustom (void)
6020  {
6021  return m_listCustom.end();
6022  }
6023 
6025  inline void
6027  {
6028  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6029  }
6030 
6032  inline int
6034  {
6035  return (int) (m_listCustom.size());
6036  }
6037 
6038  EResultCode
6040  addCustom (
6041  CParameter * pValue);
6042 
6043 
6044 };
6045 
6046 
6070 class CImpinjEnablePeakRSSI : public CParameter
6071 {
6072  public:
6073  CImpinjEnablePeakRSSI (void);
6074  ~CImpinjEnablePeakRSSI (void);
6075 
6078 
6079  static const CFieldDescriptor * const
6080  s_apFieldDescriptorTable[];
6081 
6082  static const CTypeDescriptor
6083  s_typeDescriptor;
6084 
6085  void
6086  decodeFields (
6087  CDecoderStream * pDecoderStream);
6088 
6089  void
6090  assimilateSubParameters (
6091  CErrorDetails * pError);
6092 
6093  void
6094  encode (
6095  CEncoderStream * pEncoderStream) const;
6096 
6097 
6098  llrp_bool_t
6099  isAllowedIn (
6100  const CTypeDescriptor * pEnclosingElementType) const;
6101 
6102 
6103  static CElement *
6104  s_construct (void);
6105 
6106  static void
6107  s_decodeFields (
6108  CDecoderStream * pDecoderStream,
6109  CElement * pElement);
6111 
6112 
6113  protected:
6114  EImpinjPeakRSSIMode m_ePeakRSSIMode;
6115 
6118  public:
6119  static const CFieldDescriptor
6120  s_fdPeakRSSIMode;
6122 
6124  inline EImpinjPeakRSSIMode
6126  {
6127  return m_ePeakRSSIMode;
6128  }
6129 
6131  inline void
6133  EImpinjPeakRSSIMode value)
6134  {
6135  m_ePeakRSSIMode = value;
6136  }
6137 
6138 
6139  protected:
6140  std::list<CParameter *> m_listCustom;
6141 
6142  public:
6144  inline std::list<CParameter *>::iterator
6146  {
6147  return m_listCustom.begin();
6148  }
6149 
6151  inline std::list<CParameter *>::iterator
6152  endCustom (void)
6153  {
6154  return m_listCustom.end();
6155  }
6156 
6158  inline void
6160  {
6161  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6162  }
6163 
6165  inline int
6167  {
6168  return (int) (m_listCustom.size());
6169  }
6170 
6171  EResultCode
6173  addCustom (
6174  CParameter * pValue);
6175 
6176 
6177 };
6178 
6179 
6203 class CImpinjEnableGPSCoordinates : public CParameter
6204 {
6205  public:
6208 
6211 
6212  static const CFieldDescriptor * const
6213  s_apFieldDescriptorTable[];
6214 
6215  static const CTypeDescriptor
6216  s_typeDescriptor;
6217 
6218  void
6219  decodeFields (
6220  CDecoderStream * pDecoderStream);
6221 
6222  void
6223  assimilateSubParameters (
6224  CErrorDetails * pError);
6225 
6226  void
6227  encode (
6228  CEncoderStream * pEncoderStream) const;
6229 
6230 
6231  llrp_bool_t
6232  isAllowedIn (
6233  const CTypeDescriptor * pEnclosingElementType) const;
6234 
6235 
6236  static CElement *
6237  s_construct (void);
6238 
6239  static void
6240  s_decodeFields (
6241  CDecoderStream * pDecoderStream,
6242  CElement * pElement);
6244 
6245 
6246  protected:
6247  EImpinjGPSCoordinatesMode m_eGPSCoordinatesMode;
6248 
6251  public:
6252  static const CFieldDescriptor
6253  s_fdGPSCoordinatesMode;
6255 
6257  inline EImpinjGPSCoordinatesMode
6259  {
6260  return m_eGPSCoordinatesMode;
6261  }
6262 
6264  inline void
6266  EImpinjGPSCoordinatesMode value)
6267  {
6268  m_eGPSCoordinatesMode = value;
6269  }
6270 
6271 
6272  protected:
6273  std::list<CParameter *> m_listCustom;
6274 
6275  public:
6277  inline std::list<CParameter *>::iterator
6279  {
6280  return m_listCustom.begin();
6281  }
6282 
6284  inline std::list<CParameter *>::iterator
6285  endCustom (void)
6286  {
6287  return m_listCustom.end();
6288  }
6289 
6291  inline void
6293  {
6294  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6295  }
6296 
6298  inline int
6300  {
6301  return (int) (m_listCustom.size());
6302  }
6303 
6304  EResultCode
6306  addCustom (
6307  CParameter * pValue);
6308 
6309 
6310 };
6311 
6312 
6338 class CImpinjSerializedTID : public CParameter
6339 {
6340  public:
6341  CImpinjSerializedTID (void);
6342  ~CImpinjSerializedTID (void);
6343 
6346 
6347  static const CFieldDescriptor * const
6348  s_apFieldDescriptorTable[];
6349 
6350  static const CTypeDescriptor
6351  s_typeDescriptor;
6352 
6353  void
6354  decodeFields (
6355  CDecoderStream * pDecoderStream);
6356 
6357  void
6358  assimilateSubParameters (
6359  CErrorDetails * pError);
6360 
6361  void
6362  encode (
6363  CEncoderStream * pEncoderStream) const;
6364 
6365 
6366  llrp_bool_t
6367  isAllowedIn (
6368  const CTypeDescriptor * pEnclosingElementType) const;
6369 
6370 
6371  static CElement *
6372  s_construct (void);
6373 
6374  static void
6375  s_decodeFields (
6376  CDecoderStream * pDecoderStream,
6377  CElement * pElement);
6379 
6380 
6381  protected:
6382  llrp_u16v_t m_TID;
6383 
6386  public:
6387  static const CFieldDescriptor
6388  s_fdTID;
6390 
6392  inline llrp_u16v_t
6393  getTID (void)
6394  {
6395  return m_TID;
6396  }
6397 
6399  inline void
6401  llrp_u16v_t value)
6402  {
6403  m_TID = value;
6404  }
6405 
6406 
6407  protected:
6408  CImpinjTIDParity * m_pImpinjTIDParity;
6409 
6410  public:
6412  inline CImpinjTIDParity *
6414  {
6415  return m_pImpinjTIDParity;
6416  }
6417 
6419  EResultCode
6421  CImpinjTIDParity * pValue);
6422 
6423 
6424  protected:
6425  std::list<CParameter *> m_listCustom;
6426 
6427  public:
6429  inline std::list<CParameter *>::iterator
6431  {
6432  return m_listCustom.begin();
6433  }
6434 
6436  inline std::list<CParameter *>::iterator
6437  endCustom (void)
6438  {
6439  return m_listCustom.end();
6440  }
6441 
6443  inline void
6445  {
6446  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6447  }
6448 
6450  inline int
6452  {
6453  return (int) (m_listCustom.size());
6454  }
6455 
6456  EResultCode
6458  addCustom (
6459  CParameter * pValue);
6460 
6461 
6462 };
6463 
6464 
6489 class CImpinjRFPhaseAngle : public CParameter
6490 {
6491  public:
6492  CImpinjRFPhaseAngle (void);
6493  ~CImpinjRFPhaseAngle (void);
6494 
6497 
6498  static const CFieldDescriptor * const
6499  s_apFieldDescriptorTable[];
6500 
6501  static const CTypeDescriptor
6502  s_typeDescriptor;
6503 
6504  void
6505  decodeFields (
6506  CDecoderStream * pDecoderStream);
6507 
6508  void
6509  assimilateSubParameters (
6510  CErrorDetails * pError);
6511 
6512  void
6513  encode (
6514  CEncoderStream * pEncoderStream) const;
6515 
6516 
6517  llrp_bool_t
6518  isAllowedIn (
6519  const CTypeDescriptor * pEnclosingElementType) const;
6520 
6521 
6522  static CElement *
6523  s_construct (void);
6524 
6525  static void
6526  s_decodeFields (
6527  CDecoderStream * pDecoderStream,
6528  CElement * pElement);
6530 
6531 
6532  protected:
6533  llrp_u16_t m_PhaseAngle;
6534 
6537  public:
6538  static const CFieldDescriptor
6539  s_fdPhaseAngle;
6541 
6543  inline llrp_u16_t
6545  {
6546  return m_PhaseAngle;
6547  }
6548 
6550  inline void
6552  llrp_u16_t value)
6553  {
6554  m_PhaseAngle = value;
6555  }
6556 
6557 
6558  protected:
6559  std::list<CParameter *> m_listCustom;
6560 
6561  public:
6563  inline std::list<CParameter *>::iterator
6565  {
6566  return m_listCustom.begin();
6567  }
6568 
6570  inline std::list<CParameter *>::iterator
6571  endCustom (void)
6572  {
6573  return m_listCustom.end();
6574  }
6575 
6577  inline void
6579  {
6580  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6581  }
6582 
6584  inline int
6586  {
6587  return (int) (m_listCustom.size());
6588  }
6589 
6590  EResultCode
6592  addCustom (
6593  CParameter * pValue);
6594 
6595 
6596 };
6597 
6598 
6623 class CImpinjPeakRSSI : public CParameter
6624 {
6625  public:
6626  CImpinjPeakRSSI (void);
6627  ~CImpinjPeakRSSI (void);
6628 
6631 
6632  static const CFieldDescriptor * const
6633  s_apFieldDescriptorTable[];
6634 
6635  static const CTypeDescriptor
6636  s_typeDescriptor;
6637 
6638  void
6639  decodeFields (
6640  CDecoderStream * pDecoderStream);
6641 
6642  void
6643  assimilateSubParameters (
6644  CErrorDetails * pError);
6645 
6646  void
6647  encode (
6648  CEncoderStream * pEncoderStream) const;
6649 
6650 
6651  llrp_bool_t
6652  isAllowedIn (
6653  const CTypeDescriptor * pEnclosingElementType) const;
6654 
6655 
6656  static CElement *
6657  s_construct (void);
6658 
6659  static void
6660  s_decodeFields (
6661  CDecoderStream * pDecoderStream,
6662  CElement * pElement);
6664 
6665 
6666  protected:
6667  llrp_s16_t m_RSSI;
6668 
6671  public:
6672  static const CFieldDescriptor
6673  s_fdRSSI;
6675 
6677  inline llrp_s16_t
6678  getRSSI (void)
6679  {
6680  return m_RSSI;
6681  }
6682 
6684  inline void
6686  llrp_s16_t value)
6687  {
6688  m_RSSI = value;
6689  }
6690 
6691 
6692  protected:
6693  std::list<CParameter *> m_listCustom;
6694 
6695  public:
6697  inline std::list<CParameter *>::iterator
6699  {
6700  return m_listCustom.begin();
6701  }
6702 
6704  inline std::list<CParameter *>::iterator
6705  endCustom (void)
6706  {
6707  return m_listCustom.end();
6708  }
6709 
6711  inline void
6713  {
6714  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6715  }
6716 
6718  inline int
6720  {
6721  return (int) (m_listCustom.size());
6722  }
6723 
6724  EResultCode
6726  addCustom (
6727  CParameter * pValue);
6728 
6729 
6730 };
6731 
6732 
6758 class CImpinjGPSCoordinates : public CParameter
6759 {
6760  public:
6761  CImpinjGPSCoordinates (void);
6762  ~CImpinjGPSCoordinates (void);
6763 
6766 
6767  static const CFieldDescriptor * const
6768  s_apFieldDescriptorTable[];
6769 
6770  static const CTypeDescriptor
6771  s_typeDescriptor;
6772 
6773  void
6774  decodeFields (
6775  CDecoderStream * pDecoderStream);
6776 
6777  void
6778  assimilateSubParameters (
6779  CErrorDetails * pError);
6780 
6781  void
6782  encode (
6783  CEncoderStream * pEncoderStream) const;
6784 
6785 
6786  llrp_bool_t
6787  isAllowedIn (
6788  const CTypeDescriptor * pEnclosingElementType) const;
6789 
6790 
6791  static CElement *
6792  s_construct (void);
6793 
6794  static void
6795  s_decodeFields (
6796  CDecoderStream * pDecoderStream,
6797  CElement * pElement);
6799 
6800 
6801  protected:
6802  llrp_s32_t m_Latitude;
6803 
6806  public:
6807  static const CFieldDescriptor
6808  s_fdLatitude;
6810 
6812  inline llrp_s32_t
6814  {
6815  return m_Latitude;
6816  }
6817 
6819  inline void
6821  llrp_s32_t value)
6822  {
6823  m_Latitude = value;
6824  }
6825 
6826 
6827  protected:
6828  llrp_s32_t m_Longitude;
6829 
6832  public:
6833  static const CFieldDescriptor
6834  s_fdLongitude;
6836 
6838  inline llrp_s32_t
6840  {
6841  return m_Longitude;
6842  }
6843 
6845  inline void
6847  llrp_s32_t value)
6848  {
6849  m_Longitude = value;
6850  }
6851 
6852 
6853  protected:
6854  std::list<CParameter *> m_listCustom;
6855 
6856  public:
6858  inline std::list<CParameter *>::iterator
6860  {
6861  return m_listCustom.begin();
6862  }
6863 
6865  inline std::list<CParameter *>::iterator
6866  endCustom (void)
6867  {
6868  return m_listCustom.end();
6869  }
6870 
6872  inline void
6874  {
6875  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6876  }
6877 
6879  inline int
6881  {
6882  return (int) (m_listCustom.size());
6883  }
6884 
6885  EResultCode
6887  addCustom (
6888  CParameter * pValue);
6889 
6890 
6891 };
6892 
6893 
6918 class CImpinjLoopSpec : public CParameter
6919 {
6920  public:
6921  CImpinjLoopSpec (void);
6922  ~CImpinjLoopSpec (void);
6923 
6926 
6927  static const CFieldDescriptor * const
6928  s_apFieldDescriptorTable[];
6929 
6930  static const CTypeDescriptor
6931  s_typeDescriptor;
6932 
6933  void
6934  decodeFields (
6935  CDecoderStream * pDecoderStream);
6936 
6937  void
6938  assimilateSubParameters (
6939  CErrorDetails * pError);
6940 
6941  void
6942  encode (
6943  CEncoderStream * pEncoderStream) const;
6944 
6945 
6946  llrp_bool_t
6947  isAllowedIn (
6948  const CTypeDescriptor * pEnclosingElementType) const;
6949 
6950 
6951  static CElement *
6952  s_construct (void);
6953 
6954  static void
6955  s_decodeFields (
6956  CDecoderStream * pDecoderStream,
6957  CElement * pElement);
6959 
6960 
6961  protected:
6962  llrp_u32_t m_LoopCount;
6963 
6966  public:
6967  static const CFieldDescriptor
6968  s_fdLoopCount;
6970 
6972  inline llrp_u32_t
6974  {
6975  return m_LoopCount;
6976  }
6977 
6979  inline void
6981  llrp_u32_t value)
6982  {
6983  m_LoopCount = value;
6984  }
6985 
6986 
6987  protected:
6988  std::list<CParameter *> m_listCustom;
6989 
6990  public:
6992  inline std::list<CParameter *>::iterator
6994  {
6995  return m_listCustom.begin();
6996  }
6997 
6999  inline std::list<CParameter *>::iterator
7000  endCustom (void)
7001  {
7002  return m_listCustom.end();
7003  }
7004 
7006  inline void
7008  {
7009  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7010  }
7011 
7013  inline int
7015  {
7016  return (int) (m_listCustom.size());
7017  }
7018 
7019  EResultCode
7021  addCustom (
7022  CParameter * pValue);
7023 
7024 
7025 };
7026 
7027 
7053 class CImpinjGPSNMEASentences : public CParameter
7054 {
7055  public:
7056  CImpinjGPSNMEASentences (void);
7057  ~CImpinjGPSNMEASentences (void);
7058 
7061 
7062  static const CFieldDescriptor * const
7063  s_apFieldDescriptorTable[];
7064 
7065  static const CTypeDescriptor
7066  s_typeDescriptor;
7067 
7068  void
7069  decodeFields (
7070  CDecoderStream * pDecoderStream);
7071 
7072  void
7073  assimilateSubParameters (
7074  CErrorDetails * pError);
7075 
7076  void
7077  encode (
7078  CEncoderStream * pEncoderStream) const;
7079 
7080 
7081  llrp_bool_t
7082  isAllowedIn (
7083  const CTypeDescriptor * pEnclosingElementType) const;
7084 
7085 
7086  static CElement *
7087  s_construct (void);
7088 
7089  static void
7090  s_decodeFields (
7091  CDecoderStream * pDecoderStream,
7092  CElement * pElement);
7094 
7095 
7096  protected:
7097  CImpinjGGASentence * m_pImpinjGGASentence;
7098 
7099  public:
7101  inline CImpinjGGASentence *
7103  {
7104  return m_pImpinjGGASentence;
7105  }
7106 
7108  EResultCode
7110  CImpinjGGASentence * pValue);
7111 
7112 
7113  protected:
7114  CImpinjRMCSentence * m_pImpinjRMCSentence;
7115 
7116  public:
7118  inline CImpinjRMCSentence *
7120  {
7121  return m_pImpinjRMCSentence;
7122  }
7123 
7125  EResultCode
7127  CImpinjRMCSentence * pValue);
7128 
7129 
7130  protected:
7131  std::list<CParameter *> m_listCustom;
7132 
7133  public:
7135  inline std::list<CParameter *>::iterator
7137  {
7138  return m_listCustom.begin();
7139  }
7140 
7142  inline std::list<CParameter *>::iterator
7143  endCustom (void)
7144  {
7145  return m_listCustom.end();
7146  }
7147 
7149  inline void
7151  {
7152  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7153  }
7154 
7156  inline int
7158  {
7159  return (int) (m_listCustom.size());
7160  }
7161 
7162  EResultCode
7164  addCustom (
7165  CParameter * pValue);
7166 
7167 
7168 };
7169 
7170 
7194 class CImpinjGGASentence : public CParameter
7195 {
7196  public:
7197  CImpinjGGASentence (void);
7198  ~CImpinjGGASentence (void);
7199 
7202 
7203  static const CFieldDescriptor * const
7204  s_apFieldDescriptorTable[];
7205 
7206  static const CTypeDescriptor
7207  s_typeDescriptor;
7208 
7209  void
7210  decodeFields (
7211  CDecoderStream * pDecoderStream);
7212 
7213  void
7214  assimilateSubParameters (
7215  CErrorDetails * pError);
7216 
7217  void
7218  encode (
7219  CEncoderStream * pEncoderStream) const;
7220 
7221 
7222  llrp_bool_t
7223  isAllowedIn (
7224  const CTypeDescriptor * pEnclosingElementType) const;
7225 
7226 
7227  static CElement *
7228  s_construct (void);
7229 
7230  static void
7231  s_decodeFields (
7232  CDecoderStream * pDecoderStream,
7233  CElement * pElement);
7235 
7236 
7237  protected:
7238  llrp_utf8v_t m_GGASentence;
7239 
7242  public:
7243  static const CFieldDescriptor
7244  s_fdGGASentence;
7246 
7248  inline llrp_utf8v_t
7250  {
7251  return m_GGASentence;
7252  }
7253 
7255  inline void
7257  llrp_utf8v_t value)
7258  {
7259  m_GGASentence = value;
7260  }
7261 
7262 
7263  protected:
7264  std::list<CParameter *> m_listCustom;
7265 
7266  public:
7268  inline std::list<CParameter *>::iterator
7270  {
7271  return m_listCustom.begin();
7272  }
7273 
7275  inline std::list<CParameter *>::iterator
7276  endCustom (void)
7277  {
7278  return m_listCustom.end();
7279  }
7280 
7282  inline void
7284  {
7285  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7286  }
7287 
7289  inline int
7291  {
7292  return (int) (m_listCustom.size());
7293  }
7294 
7295  EResultCode
7297  addCustom (
7298  CParameter * pValue);
7299 
7300 
7301 };
7302 
7303 
7327 class CImpinjRMCSentence : public CParameter
7328 {
7329  public:
7330  CImpinjRMCSentence (void);
7331  ~CImpinjRMCSentence (void);
7332 
7335 
7336  static const CFieldDescriptor * const
7337  s_apFieldDescriptorTable[];
7338 
7339  static const CTypeDescriptor
7340  s_typeDescriptor;
7341 
7342  void
7343  decodeFields (
7344  CDecoderStream * pDecoderStream);
7345 
7346  void
7347  assimilateSubParameters (
7348  CErrorDetails * pError);
7349 
7350  void
7351  encode (
7352  CEncoderStream * pEncoderStream) const;
7353 
7354 
7355  llrp_bool_t
7356  isAllowedIn (
7357  const CTypeDescriptor * pEnclosingElementType) const;
7358 
7359 
7360  static CElement *
7361  s_construct (void);
7362 
7363  static void
7364  s_decodeFields (
7365  CDecoderStream * pDecoderStream,
7366  CElement * pElement);
7368 
7369 
7370  protected:
7371  llrp_utf8v_t m_RMCSentence;
7372 
7375  public:
7376  static const CFieldDescriptor
7377  s_fdRMCSentence;
7379 
7381  inline llrp_utf8v_t
7383  {
7384  return m_RMCSentence;
7385  }
7386 
7388  inline void
7390  llrp_utf8v_t value)
7391  {
7392  m_RMCSentence = value;
7393  }
7394 
7395 
7396  protected:
7397  std::list<CParameter *> m_listCustom;
7398 
7399  public:
7401  inline std::list<CParameter *>::iterator
7403  {
7404  return m_listCustom.begin();
7405  }
7406 
7408  inline std::list<CParameter *>::iterator
7409  endCustom (void)
7410  {
7411  return m_listCustom.end();
7412  }
7413 
7415  inline void
7417  {
7418  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7419  }
7420 
7422  inline int
7424  {
7425  return (int) (m_listCustom.size());
7426  }
7427 
7428  EResultCode
7430  addCustom (
7431  CParameter * pValue);
7432 
7433 
7434 };
7435 
7436 
7460 class CImpinjOpSpecRetryCount : public CParameter
7461 {
7462  public:
7463  CImpinjOpSpecRetryCount (void);
7464  ~CImpinjOpSpecRetryCount (void);
7465 
7468 
7469  static const CFieldDescriptor * const
7470  s_apFieldDescriptorTable[];
7471 
7472  static const CTypeDescriptor
7473  s_typeDescriptor;
7474 
7475  void
7476  decodeFields (
7477  CDecoderStream * pDecoderStream);
7478 
7479  void
7480  assimilateSubParameters (
7481  CErrorDetails * pError);
7482 
7483  void
7484  encode (
7485  CEncoderStream * pEncoderStream) const;
7486 
7487 
7488  llrp_bool_t
7489  isAllowedIn (
7490  const CTypeDescriptor * pEnclosingElementType) const;
7491 
7492 
7493  static CElement *
7494  s_construct (void);
7495 
7496  static void
7497  s_decodeFields (
7498  CDecoderStream * pDecoderStream,
7499  CElement * pElement);
7501 
7502 
7503  protected:
7504  llrp_u16_t m_RetryCount;
7505 
7508  public:
7509  static const CFieldDescriptor
7510  s_fdRetryCount;
7512 
7514  inline llrp_u16_t
7516  {
7517  return m_RetryCount;
7518  }
7519 
7521  inline void
7523  llrp_u16_t value)
7524  {
7525  m_RetryCount = value;
7526  }
7527 
7528 
7529  protected:
7530  std::list<CParameter *> m_listCustom;
7531 
7532  public:
7534  inline std::list<CParameter *>::iterator
7536  {
7537  return m_listCustom.begin();
7538  }
7539 
7541  inline std::list<CParameter *>::iterator
7542  endCustom (void)
7543  {
7544  return m_listCustom.end();
7545  }
7546 
7548  inline void
7550  {
7551  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7552  }
7553 
7555  inline int
7557  {
7558  return (int) (m_listCustom.size());
7559  }
7560 
7561  EResultCode
7563  addCustom (
7564  CParameter * pValue);
7565 
7566 
7567 };
7568 
7569 
7597 class CImpinjAdvancedGPOConfiguration : public CParameter
7598 {
7599  public:
7602 
7605 
7606  static const CFieldDescriptor * const
7607  s_apFieldDescriptorTable[];
7608 
7609  static const CTypeDescriptor
7610  s_typeDescriptor;
7611 
7612  void
7613  decodeFields (
7614  CDecoderStream * pDecoderStream);
7615 
7616  void
7617  assimilateSubParameters (
7618  CErrorDetails * pError);
7619 
7620  void
7621  encode (
7622  CEncoderStream * pEncoderStream) const;
7623 
7624 
7625  llrp_bool_t
7626  isAllowedIn (
7627  const CTypeDescriptor * pEnclosingElementType) const;
7628 
7629 
7630  static CElement *
7631  s_construct (void);
7632 
7633  static void
7634  s_decodeFields (
7635  CDecoderStream * pDecoderStream,
7636  CElement * pElement);
7638 
7639 
7640  protected:
7641  llrp_u16_t m_GPOPortNum;
7642 
7645  public:
7646  static const CFieldDescriptor
7647  s_fdGPOPortNum;
7649 
7651  inline llrp_u16_t
7653  {
7654  return m_GPOPortNum;
7655  }
7656 
7658  inline void
7660  llrp_u16_t value)
7661  {
7662  m_GPOPortNum = value;
7663  }
7664 
7665 
7666  protected:
7667  EImpinjAdvancedGPOMode m_eGPOMode;
7668 
7671  public:
7672  static const CFieldDescriptor
7673  s_fdGPOMode;
7675 
7677  inline EImpinjAdvancedGPOMode
7678  getGPOMode (void)
7679  {
7680  return m_eGPOMode;
7681  }
7682 
7684  inline void
7686  EImpinjAdvancedGPOMode value)
7687  {
7688  m_eGPOMode = value;
7689  }
7690 
7691 
7692  protected:
7693  llrp_u32_t m_GPOPulseDurationMSec;
7694 
7697  public:
7698  static const CFieldDescriptor
7699  s_fdGPOPulseDurationMSec;
7701 
7703  inline llrp_u32_t
7705  {
7706  return m_GPOPulseDurationMSec;
7707  }
7708 
7710  inline void
7712  llrp_u32_t value)
7713  {
7714  m_GPOPulseDurationMSec = value;
7715  }
7716 
7717 
7718  protected:
7719  std::list<CParameter *> m_listCustom;
7720 
7721  public:
7723  inline std::list<CParameter *>::iterator
7725  {
7726  return m_listCustom.begin();
7727  }
7728 
7730  inline std::list<CParameter *>::iterator
7731  endCustom (void)
7732  {
7733  return m_listCustom.end();
7734  }
7735 
7737  inline void
7739  {
7740  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7741  }
7742 
7744  inline int
7746  {
7747  return (int) (m_listCustom.size());
7748  }
7749 
7750  EResultCode
7752  addCustom (
7753  CParameter * pValue);
7754 
7755 
7756 };
7757 
7758 
7792 class CImpinjEnableOptimizedRead : public CParameter
7793 {
7794  public:
7797 
7800 
7801  static const CFieldDescriptor * const
7802  s_apFieldDescriptorTable[];
7803 
7804  static const CTypeDescriptor
7805  s_typeDescriptor;
7806 
7807  void
7808  decodeFields (
7809  CDecoderStream * pDecoderStream);
7810 
7811  void
7812  assimilateSubParameters (
7813  CErrorDetails * pError);
7814 
7815  void
7816  encode (
7817  CEncoderStream * pEncoderStream) const;
7818 
7819 
7820  llrp_bool_t
7821  isAllowedIn (
7822  const CTypeDescriptor * pEnclosingElementType) const;
7823 
7824 
7825  static CElement *
7826  s_construct (void);
7827 
7828  static void
7829  s_decodeFields (
7830  CDecoderStream * pDecoderStream,
7831  CElement * pElement);
7833 
7834 
7835  protected:
7836  EImpinjOptimizedReadMode m_eOptimizedReadMode;
7837 
7840  public:
7841  static const CFieldDescriptor
7842  s_fdOptimizedReadMode;
7844 
7846  inline EImpinjOptimizedReadMode
7848  {
7849  return m_eOptimizedReadMode;
7850  }
7851 
7853  inline void
7855  EImpinjOptimizedReadMode value)
7856  {
7857  m_eOptimizedReadMode = value;
7858  }
7859 
7860 
7861  protected:
7862  std::list<CC1G2Read *> m_listC1G2Read;
7863 
7864  public:
7866  inline std::list<CC1G2Read *>::iterator
7868  {
7869  return m_listC1G2Read.begin();
7870  }
7871 
7873  inline std::list<CC1G2Read *>::iterator
7875  {
7876  return m_listC1G2Read.end();
7877  }
7878 
7880  inline void
7882  {
7883  clearSubParameterList ((tListOfParameters *) &m_listC1G2Read);
7884  }
7885 
7887  inline int
7889  {
7890  return (int) (m_listC1G2Read.size());
7891  }
7892 
7893  EResultCode
7895  addC1G2Read (
7896  CC1G2Read * pValue);
7897 
7898 
7899  protected:
7900  std::list<CParameter *> m_listCustom;
7901 
7902  public:
7904  inline std::list<CParameter *>::iterator
7906  {
7907  return m_listCustom.begin();
7908  }
7909 
7911  inline std::list<CParameter *>::iterator
7912  endCustom (void)
7913  {
7914  return m_listCustom.end();
7915  }
7916 
7918  inline void
7920  {
7921  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7922  }
7923 
7925  inline int
7927  {
7928  return (int) (m_listCustom.size());
7929  }
7930 
7931  EResultCode
7933  addCustom (
7934  CParameter * pValue);
7935 
7936 
7937 };
7938 
7939 
7966 class CImpinjAccessSpecOrdering : public CParameter
7967 {
7968  public:
7970  ~CImpinjAccessSpecOrdering (void);
7971 
7974 
7975  static const CFieldDescriptor * const
7976  s_apFieldDescriptorTable[];
7977 
7978  static const CTypeDescriptor
7979  s_typeDescriptor;
7980 
7981  void
7982  decodeFields (
7983  CDecoderStream * pDecoderStream);
7984 
7985  void
7986  assimilateSubParameters (
7987  CErrorDetails * pError);
7988 
7989  void
7990  encode (
7991  CEncoderStream * pEncoderStream) const;
7992 
7993 
7994  llrp_bool_t
7995  isAllowedIn (
7996  const CTypeDescriptor * pEnclosingElementType) const;
7997 
7998 
7999  static CElement *
8000  s_construct (void);
8001 
8002  static void
8003  s_decodeFields (
8004  CDecoderStream * pDecoderStream,
8005  CElement * pElement);
8007 
8008 
8009  protected:
8010  EImpinjAccessSpecOrderingMode m_eOrderingMode;
8011 
8014  public:
8015  static const CFieldDescriptor
8016  s_fdOrderingMode;
8018 
8020  inline EImpinjAccessSpecOrderingMode
8022  {
8023  return m_eOrderingMode;
8024  }
8025 
8027  inline void
8029  EImpinjAccessSpecOrderingMode value)
8030  {
8031  m_eOrderingMode = value;
8032  }
8033 
8034 
8035  protected:
8036  std::list<CParameter *> m_listCustom;
8037 
8038  public:
8040  inline std::list<CParameter *>::iterator
8042  {
8043  return m_listCustom.begin();
8044  }
8045 
8047  inline std::list<CParameter *>::iterator
8048  endCustom (void)
8049  {
8050  return m_listCustom.end();
8051  }
8052 
8054  inline void
8056  {
8057  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8058  }
8059 
8061  inline int
8063  {
8064  return (int) (m_listCustom.size());
8065  }
8066 
8067  EResultCode
8069  addCustom (
8070  CParameter * pValue);
8071 
8072 
8073 };
8074 
8075 
8099 class CImpinjEnableRFDopplerFrequency : public CParameter
8100 {
8101  public:
8104 
8107 
8108  static const CFieldDescriptor * const
8109  s_apFieldDescriptorTable[];
8110 
8111  static const CTypeDescriptor
8112  s_typeDescriptor;
8113 
8114  void
8115  decodeFields (
8116  CDecoderStream * pDecoderStream);
8117 
8118  void
8119  assimilateSubParameters (
8120  CErrorDetails * pError);
8121 
8122  void
8123  encode (
8124  CEncoderStream * pEncoderStream) const;
8125 
8126 
8127  llrp_bool_t
8128  isAllowedIn (
8129  const CTypeDescriptor * pEnclosingElementType) const;
8130 
8131 
8132  static CElement *
8133  s_construct (void);
8134 
8135  static void
8136  s_decodeFields (
8137  CDecoderStream * pDecoderStream,
8138  CElement * pElement);
8140 
8141 
8142  protected:
8143  EImpinjRFDopplerFrequencyMode m_eRFDopplerFrequencyMode;
8144 
8147  public:
8148  static const CFieldDescriptor
8149  s_fdRFDopplerFrequencyMode;
8151 
8153  inline EImpinjRFDopplerFrequencyMode
8155  {
8156  return m_eRFDopplerFrequencyMode;
8157  }
8158 
8160  inline void
8162  EImpinjRFDopplerFrequencyMode value)
8163  {
8164  m_eRFDopplerFrequencyMode = value;
8165  }
8166 
8167 
8168  protected:
8169  std::list<CParameter *> m_listCustom;
8170 
8171  public:
8173  inline std::list<CParameter *>::iterator
8175  {
8176  return m_listCustom.begin();
8177  }
8178 
8180  inline std::list<CParameter *>::iterator
8181  endCustom (void)
8182  {
8183  return m_listCustom.end();
8184  }
8185 
8187  inline void
8189  {
8190  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8191  }
8192 
8194  inline int
8196  {
8197  return (int) (m_listCustom.size());
8198  }
8199 
8200  EResultCode
8202  addCustom (
8203  CParameter * pValue);
8204 
8205 
8206 };
8207 
8208 
8233 class CImpinjRFDopplerFrequency : public CParameter
8234 {
8235  public:
8237  ~CImpinjRFDopplerFrequency (void);
8238 
8241 
8242  static const CFieldDescriptor * const
8243  s_apFieldDescriptorTable[];
8244 
8245  static const CTypeDescriptor
8246  s_typeDescriptor;
8247 
8248  void
8249  decodeFields (
8250  CDecoderStream * pDecoderStream);
8251 
8252  void
8253  assimilateSubParameters (
8254  CErrorDetails * pError);
8255 
8256  void
8257  encode (
8258  CEncoderStream * pEncoderStream) const;
8259 
8260 
8261  llrp_bool_t
8262  isAllowedIn (
8263  const CTypeDescriptor * pEnclosingElementType) const;
8264 
8265 
8266  static CElement *
8267  s_construct (void);
8268 
8269  static void
8270  s_decodeFields (
8271  CDecoderStream * pDecoderStream,
8272  CElement * pElement);
8274 
8275 
8276  protected:
8277  llrp_s16_t m_DopplerFrequency;
8278 
8281  public:
8282  static const CFieldDescriptor
8283  s_fdDopplerFrequency;
8285 
8287  inline llrp_s16_t
8289  {
8290  return m_DopplerFrequency;
8291  }
8292 
8294  inline void
8296  llrp_s16_t value)
8297  {
8298  m_DopplerFrequency = value;
8299  }
8300 
8301 
8302  protected:
8303  std::list<CParameter *> m_listCustom;
8304 
8305  public:
8307  inline std::list<CParameter *>::iterator
8309  {
8310  return m_listCustom.begin();
8311  }
8312 
8314  inline std::list<CParameter *>::iterator
8315  endCustom (void)
8316  {
8317  return m_listCustom.end();
8318  }
8319 
8321  inline void
8323  {
8324  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8325  }
8326 
8328  inline int
8330  {
8331  return (int) (m_listCustom.size());
8332  }
8333 
8334  EResultCode
8336  addCustom (
8337  CParameter * pValue);
8338 
8339 
8340 };
8341 
8342 
8375 class CImpinjInventoryConfiguration : public CParameter
8376 {
8377  public:
8380 
8383 
8384  static const CFieldDescriptor * const
8385  s_apFieldDescriptorTable[];
8386 
8387  static const CTypeDescriptor
8388  s_typeDescriptor;
8389 
8390  void
8391  decodeFields (
8392  CDecoderStream * pDecoderStream);
8393 
8394  void
8395  assimilateSubParameters (
8396  CErrorDetails * pError);
8397 
8398  void
8399  encode (
8400  CEncoderStream * pEncoderStream) const;
8401 
8402 
8403  llrp_bool_t
8404  isAllowedIn (
8405  const CTypeDescriptor * pEnclosingElementType) const;
8406 
8407 
8408  static CElement *
8409  s_construct (void);
8410 
8411  static void
8412  s_decodeFields (
8413  CDecoderStream * pDecoderStream,
8414  CElement * pElement);
8416 
8417 
8418  protected:
8419  llrp_u1_t m_EnableAntDwellTimeLimit;
8420 
8423  public:
8424  static const CFieldDescriptor
8425  s_fdEnableAntDwellTimeLimit;
8427 
8429  inline llrp_u1_t
8431  {
8432  return m_EnableAntDwellTimeLimit;
8433  }
8434 
8436  inline void
8438  llrp_u1_t value)
8439  {
8440  m_EnableAntDwellTimeLimit = value;
8441  }
8442 
8443 
8444  protected:
8445  llrp_u1_t m_EnableSelectGapClose;
8446 
8449  public:
8450  static const CFieldDescriptor
8451  s_fdEnableSelectGapClose;
8453 
8455  inline llrp_u1_t
8457  {
8458  return m_EnableSelectGapClose;
8459  }
8460 
8462  inline void
8464  llrp_u1_t value)
8465  {
8466  m_EnableSelectGapClose = value;
8467  }
8468 
8469 
8470  protected:
8471  std::list<CParameter *> m_listCustom;
8472 
8473  public:
8475  inline std::list<CParameter *>::iterator
8477  {
8478  return m_listCustom.begin();
8479  }
8480 
8482  inline std::list<CParameter *>::iterator
8483  endCustom (void)
8484  {
8485  return m_listCustom.end();
8486  }
8487 
8489  inline void
8491  {
8492  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8493  }
8494 
8496  inline int
8498  {
8499  return (int) (m_listCustom.size());
8500  }
8501 
8502  EResultCode
8504  addCustom (
8505  CParameter * pValue);
8506 
8507 
8508 };
8509 
8510 
8534 class CImpinjEnableTxPower : public CParameter
8535 {
8536  public:
8537  CImpinjEnableTxPower (void);
8538  ~CImpinjEnableTxPower (void);
8539 
8542 
8543  static const CFieldDescriptor * const
8544  s_apFieldDescriptorTable[];
8545 
8546  static const CTypeDescriptor
8547  s_typeDescriptor;
8548 
8549  void
8550  decodeFields (
8551  CDecoderStream * pDecoderStream);
8552 
8553  void
8554  assimilateSubParameters (
8555  CErrorDetails * pError);
8556 
8557  void
8558  encode (
8559  CEncoderStream * pEncoderStream) const;
8560 
8561 
8562  llrp_bool_t
8563  isAllowedIn (
8564  const CTypeDescriptor * pEnclosingElementType) const;
8565 
8566 
8567  static CElement *
8568  s_construct (void);
8569 
8570  static void
8571  s_decodeFields (
8572  CDecoderStream * pDecoderStream,
8573  CElement * pElement);
8575 
8576 
8577  protected:
8578  EImpinjTxPowerReportingModeEnum m_eTxPowerReportingMode;
8579 
8582  public:
8583  static const CFieldDescriptor
8584  s_fdTxPowerReportingMode;
8586 
8588  inline EImpinjTxPowerReportingModeEnum
8590  {
8591  return m_eTxPowerReportingMode;
8592  }
8593 
8595  inline void
8597  EImpinjTxPowerReportingModeEnum value)
8598  {
8599  m_eTxPowerReportingMode = value;
8600  }
8601 
8602 
8603  protected:
8604  std::list<CParameter *> m_listCustom;
8605 
8606  public:
8608  inline std::list<CParameter *>::iterator
8610  {
8611  return m_listCustom.begin();
8612  }
8613 
8615  inline std::list<CParameter *>::iterator
8616  endCustom (void)
8617  {
8618  return m_listCustom.end();
8619  }
8620 
8622  inline void
8624  {
8625  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8626  }
8627 
8629  inline int
8631  {
8632  return (int) (m_listCustom.size());
8633  }
8634 
8635  EResultCode
8637  addCustom (
8638  CParameter * pValue);
8639 
8640 
8641 };
8642 
8643 
8668 class CImpinjTxPower : public CParameter
8669 {
8670  public:
8671  CImpinjTxPower (void);
8672  ~CImpinjTxPower (void);
8673 
8676 
8677  static const CFieldDescriptor * const
8678  s_apFieldDescriptorTable[];
8679 
8680  static const CTypeDescriptor
8681  s_typeDescriptor;
8682 
8683  void
8684  decodeFields (
8685  CDecoderStream * pDecoderStream);
8686 
8687  void
8688  assimilateSubParameters (
8689  CErrorDetails * pError);
8690 
8691  void
8692  encode (
8693  CEncoderStream * pEncoderStream) const;
8694 
8695 
8696  llrp_bool_t
8697  isAllowedIn (
8698  const CTypeDescriptor * pEnclosingElementType) const;
8699 
8700 
8701  static CElement *
8702  s_construct (void);
8703 
8704  static void
8705  s_decodeFields (
8706  CDecoderStream * pDecoderStream,
8707  CElement * pElement);
8709 
8710 
8711  protected:
8712  llrp_u16_t m_TxPower;
8713 
8716  public:
8717  static const CFieldDescriptor
8718  s_fdTxPower;
8720 
8722  inline llrp_u16_t
8723  getTxPower (void)
8724  {
8725  return m_TxPower;
8726  }
8727 
8729  inline void
8731  llrp_u16_t value)
8732  {
8733  m_TxPower = value;
8734  }
8735 
8736 
8737  protected:
8738  std::list<CParameter *> m_listCustom;
8739 
8740  public:
8742  inline std::list<CParameter *>::iterator
8744  {
8745  return m_listCustom.begin();
8746  }
8747 
8749  inline std::list<CParameter *>::iterator
8750  endCustom (void)
8751  {
8752  return m_listCustom.end();
8753  }
8754 
8756  inline void
8758  {
8759  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8760  }
8761 
8763  inline int
8765  {
8766  return (int) (m_listCustom.size());
8767  }
8768 
8769  EResultCode
8771  addCustom (
8772  CParameter * pValue);
8773 
8774 
8775 };
8776 
8777 
8804 class CImpinjArrayVersion : public CParameter
8805 {
8806  public:
8807  CImpinjArrayVersion (void);
8808  ~CImpinjArrayVersion (void);
8809 
8812 
8813  static const CFieldDescriptor * const
8814  s_apFieldDescriptorTable[];
8815 
8816  static const CTypeDescriptor
8817  s_typeDescriptor;
8818 
8819  void
8820  decodeFields (
8821  CDecoderStream * pDecoderStream);
8822 
8823  void
8824  assimilateSubParameters (
8825  CErrorDetails * pError);
8826 
8827  void
8828  encode (
8829  CEncoderStream * pEncoderStream) const;
8830 
8831 
8832  llrp_bool_t
8833  isAllowedIn (
8834  const CTypeDescriptor * pEnclosingElementType) const;
8835 
8836 
8837  static CElement *
8838  s_construct (void);
8839 
8840  static void
8841  s_decodeFields (
8842  CDecoderStream * pDecoderStream,
8843  CElement * pElement);
8845 
8846 
8847  protected:
8848  llrp_utf8v_t m_SerialNumber;
8849 
8852  public:
8853  static const CFieldDescriptor
8854  s_fdSerialNumber;
8856 
8858  inline llrp_utf8v_t
8860  {
8861  return m_SerialNumber;
8862  }
8863 
8865  inline void
8867  llrp_utf8v_t value)
8868  {
8869  m_SerialNumber = value;
8870  }
8871 
8872 
8873  protected:
8874  llrp_utf8v_t m_FirmwareVersion;
8875 
8878  public:
8879  static const CFieldDescriptor
8880  s_fdFirmwareVersion;
8882 
8884  inline llrp_utf8v_t
8886  {
8887  return m_FirmwareVersion;
8888  }
8889 
8891  inline void
8893  llrp_utf8v_t value)
8894  {
8895  m_FirmwareVersion = value;
8896  }
8897 
8898 
8899  protected:
8900  llrp_utf8v_t m_PCBAVersion;
8901 
8904  public:
8905  static const CFieldDescriptor
8906  s_fdPCBAVersion;
8908 
8910  inline llrp_utf8v_t
8912  {
8913  return m_PCBAVersion;
8914  }
8915 
8917  inline void
8919  llrp_utf8v_t value)
8920  {
8921  m_PCBAVersion = value;
8922  }
8923 
8924 
8925  protected:
8926  std::list<CParameter *> m_listCustom;
8927 
8928  public:
8930  inline std::list<CParameter *>::iterator
8932  {
8933  return m_listCustom.begin();
8934  }
8935 
8937  inline std::list<CParameter *>::iterator
8938  endCustom (void)
8939  {
8940  return m_listCustom.end();
8941  }
8942 
8944  inline void
8946  {
8947  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8948  }
8949 
8951  inline int
8953  {
8954  return (int) (m_listCustom.size());
8955  }
8956 
8957  EResultCode
8959  addCustom (
8960  CParameter * pValue);
8961 
8962 
8963 };
8964 
8965 
8998 class CImpinjxArrayCapabilities : public CParameter
8999 {
9000  public:
9002  ~CImpinjxArrayCapabilities (void);
9003 
9006 
9007  static const CFieldDescriptor * const
9008  s_apFieldDescriptorTable[];
9009 
9010  static const CTypeDescriptor
9011  s_typeDescriptor;
9012 
9013  void
9014  decodeFields (
9015  CDecoderStream * pDecoderStream);
9016 
9017  void
9018  assimilateSubParameters (
9019  CErrorDetails * pError);
9020 
9021  void
9022  encode (
9023  CEncoderStream * pEncoderStream) const;
9024 
9025 
9026  llrp_bool_t
9027  isAllowedIn (
9028  const CTypeDescriptor * pEnclosingElementType) const;
9029 
9030 
9031  static CElement *
9032  s_construct (void);
9033 
9034  static void
9035  s_decodeFields (
9036  CDecoderStream * pDecoderStream,
9037  CElement * pElement);
9039 
9040 
9041  protected:
9042  llrp_u32_t m_MaxNumSectors;
9043 
9046  public:
9047  static const CFieldDescriptor
9048  s_fdMaxNumSectors;
9050 
9052  inline llrp_u32_t
9054  {
9055  return m_MaxNumSectors;
9056  }
9057 
9059  inline void
9061  llrp_u32_t value)
9062  {
9063  m_MaxNumSectors = value;
9064  }
9065 
9066 
9067  protected:
9068  llrp_u1_t m_SupportsLISpecs;
9069 
9072  public:
9073  static const CFieldDescriptor
9074  s_fdSupportsLISpecs;
9076 
9078  inline llrp_u1_t
9080  {
9081  return m_SupportsLISpecs;
9082  }
9083 
9085  inline void
9087  llrp_u1_t value)
9088  {
9089  m_SupportsLISpecs = value;
9090  }
9091 
9092 
9093  protected:
9094  llrp_u1_t m_SupportsTISpecs;
9095 
9098  public:
9099  static const CFieldDescriptor
9100  s_fdSupportsTISpecs;
9102 
9104  inline llrp_u1_t
9106  {
9107  return m_SupportsTISpecs;
9108  }
9109 
9111  inline void
9113  llrp_u1_t value)
9114  {
9115  m_SupportsTISpecs = value;
9116  }
9117 
9118 
9119  protected:
9120  llrp_u1_t m_SupportsTSISpecs;
9121 
9124  public:
9125  static const CFieldDescriptor
9126  s_fdSupportsTSISpecs;
9128 
9130  inline llrp_u1_t
9132  {
9133  return m_SupportsTSISpecs;
9134  }
9135 
9137  inline void
9139  llrp_u1_t value)
9140  {
9141  m_SupportsTSISpecs = value;
9142  }
9143 
9144 
9145  protected:
9146  llrp_u1_t m_SupportsDISpecs;
9147 
9150  public:
9151  static const CFieldDescriptor
9152  s_fdSupportsDISpecs;
9154 
9156  inline llrp_u1_t
9158  {
9159  return m_SupportsDISpecs;
9160  }
9161 
9163  inline void
9165  llrp_u1_t value)
9166  {
9167  m_SupportsDISpecs = value;
9168  }
9169 
9170 
9171  protected:
9172  CImpinjxArrayDirectionCapabilities * m_pImpinjxArrayDirectionCapabilities;
9173 
9174  public:
9178  {
9179  return m_pImpinjxArrayDirectionCapabilities;
9180  }
9181 
9183  EResultCode
9186 
9187 
9188  protected:
9189  std::list<CParameter *> m_listCustom;
9190 
9191  public:
9193  inline std::list<CParameter *>::iterator
9195  {
9196  return m_listCustom.begin();
9197  }
9198 
9200  inline std::list<CParameter *>::iterator
9201  endCustom (void)
9202  {
9203  return m_listCustom.end();
9204  }
9205 
9207  inline void
9209  {
9210  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9211  }
9212 
9214  inline int
9216  {
9217  return (int) (m_listCustom.size());
9218  }
9219 
9220  EResultCode
9222  addCustom (
9223  CParameter * pValue);
9224 
9225 
9226 };
9227 
9228 
9256 class CImpinjTiltConfiguration : public CParameter
9257 {
9258  public:
9259  CImpinjTiltConfiguration (void);
9260  ~CImpinjTiltConfiguration (void);
9261 
9264 
9265  static const CFieldDescriptor * const
9266  s_apFieldDescriptorTable[];
9267 
9268  static const CTypeDescriptor
9269  s_typeDescriptor;
9270 
9271  void
9272  decodeFields (
9273  CDecoderStream * pDecoderStream);
9274 
9275  void
9276  assimilateSubParameters (
9277  CErrorDetails * pError);
9278 
9279  void
9280  encode (
9281  CEncoderStream * pEncoderStream) const;
9282 
9283 
9284  llrp_bool_t
9285  isAllowedIn (
9286  const CTypeDescriptor * pEnclosingElementType) const;
9287 
9288 
9289  static CElement *
9290  s_construct (void);
9291 
9292  static void
9293  s_decodeFields (
9294  CDecoderStream * pDecoderStream,
9295  CElement * pElement);
9297 
9298 
9299  protected:
9300  llrp_s32_t m_XAxis;
9301 
9304  public:
9305  static const CFieldDescriptor
9306  s_fdXAxis;
9308 
9310  inline llrp_s32_t
9311  getXAxis (void)
9312  {
9313  return m_XAxis;
9314  }
9315 
9317  inline void
9319  llrp_s32_t value)
9320  {
9321  m_XAxis = value;
9322  }
9323 
9324 
9325  protected:
9326  llrp_s32_t m_YAxis;
9327 
9330  public:
9331  static const CFieldDescriptor
9332  s_fdYAxis;
9334 
9336  inline llrp_s32_t
9337  getYAxis (void)
9338  {
9339  return m_YAxis;
9340  }
9341 
9343  inline void
9345  llrp_s32_t value)
9346  {
9347  m_YAxis = value;
9348  }
9349 
9350 
9351  protected:
9352  llrp_s32_t m_ZAxis;
9353 
9356  public:
9357  static const CFieldDescriptor
9358  s_fdZAxis;
9360 
9362  inline llrp_s32_t
9363  getZAxis (void)
9364  {
9365  return m_ZAxis;
9366  }
9367 
9369  inline void
9371  llrp_s32_t value)
9372  {
9373  m_ZAxis = value;
9374  }
9375 
9376 
9377  protected:
9378  std::list<CParameter *> m_listCustom;
9379 
9380  public:
9382  inline std::list<CParameter *>::iterator
9384  {
9385  return m_listCustom.begin();
9386  }
9387 
9389  inline std::list<CParameter *>::iterator
9390  endCustom (void)
9391  {
9392  return m_listCustom.end();
9393  }
9394 
9396  inline void
9398  {
9399  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9400  }
9401 
9403  inline int
9405  {
9406  return (int) (m_listCustom.size());
9407  }
9408 
9409  EResultCode
9411  addCustom (
9412  CParameter * pValue);
9413 
9414 
9415 };
9416 
9417 
9446 class CImpinjBeaconConfiguration : public CParameter
9447 {
9448  public:
9451 
9454 
9455  static const CFieldDescriptor * const
9456  s_apFieldDescriptorTable[];
9457 
9458  static const CTypeDescriptor
9459  s_typeDescriptor;
9460 
9461  void
9462  decodeFields (
9463  CDecoderStream * pDecoderStream);
9464 
9465  void
9466  assimilateSubParameters (
9467  CErrorDetails * pError);
9468 
9469  void
9470  encode (
9471  CEncoderStream * pEncoderStream) const;
9472 
9473 
9474  llrp_bool_t
9475  isAllowedIn (
9476  const CTypeDescriptor * pEnclosingElementType) const;
9477 
9478 
9479  static CElement *
9480  s_construct (void);
9481 
9482  static void
9483  s_decodeFields (
9484  CDecoderStream * pDecoderStream,
9485  CElement * pElement);
9487 
9488 
9489  protected:
9490  llrp_u1_t m_BeaconState;
9491 
9494  public:
9495  static const CFieldDescriptor
9496  s_fdBeaconState;
9498 
9500  inline llrp_u1_t
9502  {
9503  return m_BeaconState;
9504  }
9505 
9507  inline void
9509  llrp_u1_t value)
9510  {
9511  m_BeaconState = value;
9512  }
9513 
9514 
9515  protected:
9516  llrp_u64_t m_BeaconDurationSeconds;
9517 
9520  public:
9521  static const CFieldDescriptor
9522  s_fdBeaconDurationSeconds;
9524 
9526  inline llrp_u64_t
9528  {
9529  return m_BeaconDurationSeconds;
9530  }
9531 
9533  inline void
9535  llrp_u64_t value)
9536  {
9537  m_BeaconDurationSeconds = value;
9538  }
9539 
9540 
9541  protected:
9542  std::list<CParameter *> m_listCustom;
9543 
9544  public:
9546  inline std::list<CParameter *>::iterator
9548  {
9549  return m_listCustom.begin();
9550  }
9551 
9553  inline std::list<CParameter *>::iterator
9554  endCustom (void)
9555  {
9556  return m_listCustom.end();
9557  }
9558 
9560  inline void
9562  {
9563  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9564  }
9565 
9567  inline int
9569  {
9570  return (int) (m_listCustom.size());
9571  }
9572 
9573  EResultCode
9575  addCustom (
9576  CParameter * pValue);
9577 
9578 
9579 };
9580 
9581 
9609 class CImpinjAntennaConfiguration : public CParameter
9610 {
9611  public:
9614 
9617 
9618  static const CFieldDescriptor * const
9619  s_apFieldDescriptorTable[];
9620 
9621  static const CTypeDescriptor
9622  s_typeDescriptor;
9623 
9624  void
9625  decodeFields (
9626  CDecoderStream * pDecoderStream);
9627 
9628  void
9629  assimilateSubParameters (
9630  CErrorDetails * pError);
9631 
9632  void
9633  encode (
9634  CEncoderStream * pEncoderStream) const;
9635 
9636 
9637  llrp_bool_t
9638  isAllowedIn (
9639  const CTypeDescriptor * pEnclosingElementType) const;
9640 
9641 
9642  static CElement *
9643  s_construct (void);
9644 
9645  static void
9646  s_decodeFields (
9647  CDecoderStream * pDecoderStream,
9648  CElement * pElement);
9650 
9651 
9652  protected:
9653  CImpinjAntennaEventHysteresis * m_pImpinjAntennaEventHysteresis;
9654 
9655  public:
9659  {
9660  return m_pImpinjAntennaEventHysteresis;
9661  }
9662 
9664  EResultCode
9667 
9668 
9669  protected:
9670  CImpinjAntennaEventConfiguration * m_pImpinjAntennaEventConfiguration;
9671 
9672  public:
9676  {
9677  return m_pImpinjAntennaEventConfiguration;
9678  }
9679 
9681  EResultCode
9684 
9685 
9686  protected:
9687  std::list<CParameter *> m_listCustom;
9688 
9689  public:
9691  inline std::list<CParameter *>::iterator
9693  {
9694  return m_listCustom.begin();
9695  }
9696 
9698  inline std::list<CParameter *>::iterator
9699  endCustom (void)
9700  {
9701  return m_listCustom.end();
9702  }
9703 
9705  inline void
9707  {
9708  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9709  }
9710 
9712  inline int
9714  {
9715  return (int) (m_listCustom.size());
9716  }
9717 
9718  EResultCode
9720  addCustom (
9721  CParameter * pValue);
9722 
9723 
9724 };
9725 
9726 
9758 class CImpinjAntennaEventHysteresis : public CParameter
9759 {
9760  public:
9763 
9766 
9767  static const CFieldDescriptor * const
9768  s_apFieldDescriptorTable[];
9769 
9770  static const CTypeDescriptor
9771  s_typeDescriptor;
9772 
9773  void
9774  decodeFields (
9775  CDecoderStream * pDecoderStream);
9776 
9777  void
9778  assimilateSubParameters (
9779  CErrorDetails * pError);
9780 
9781  void
9782  encode (
9783  CEncoderStream * pEncoderStream) const;
9784 
9785 
9786  llrp_bool_t
9787  isAllowedIn (
9788  const CTypeDescriptor * pEnclosingElementType) const;
9789 
9790 
9791  static CElement *
9792  s_construct (void);
9793 
9794  static void
9795  s_decodeFields (
9796  CDecoderStream * pDecoderStream,
9797  CElement * pElement);
9799 
9800 
9801  protected:
9802  llrp_u64_t m_AntennaEventConnected;
9803 
9806  public:
9807  static const CFieldDescriptor
9808  s_fdAntennaEventConnected;
9810 
9812  inline llrp_u64_t
9814  {
9815  return m_AntennaEventConnected;
9816  }
9817 
9819  inline void
9821  llrp_u64_t value)
9822  {
9823  m_AntennaEventConnected = value;
9824  }
9825 
9826 
9827  protected:
9828  llrp_u64_t m_AntennaEventDisconnected;
9829 
9832  public:
9833  static const CFieldDescriptor
9834  s_fdAntennaEventDisconnected;
9836 
9838  inline llrp_u64_t
9840  {
9841  return m_AntennaEventDisconnected;
9842  }
9843 
9845  inline void
9847  llrp_u64_t value)
9848  {
9849  m_AntennaEventDisconnected = value;
9850  }
9851 
9852 
9853  protected:
9854  std::list<CParameter *> m_listCustom;
9855 
9856  public:
9858  inline std::list<CParameter *>::iterator
9860  {
9861  return m_listCustom.begin();
9862  }
9863 
9865  inline std::list<CParameter *>::iterator
9866  endCustom (void)
9867  {
9868  return m_listCustom.end();
9869  }
9870 
9872  inline void
9874  {
9875  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9876  }
9877 
9879  inline int
9881  {
9882  return (int) (m_listCustom.size());
9883  }
9884 
9885  EResultCode
9887  addCustom (
9888  CParameter * pValue);
9889 
9890 
9891 };
9892 
9893 
9919 class CImpinjAntennaEventConfiguration : public CParameter
9920 {
9921  public:
9924 
9927 
9928  static const CFieldDescriptor * const
9929  s_apFieldDescriptorTable[];
9930 
9931  static const CTypeDescriptor
9932  s_typeDescriptor;
9933 
9934  void
9935  decodeFields (
9936  CDecoderStream * pDecoderStream);
9937 
9938  void
9939  assimilateSubParameters (
9940  CErrorDetails * pError);
9941 
9942  void
9943  encode (
9944  CEncoderStream * pEncoderStream) const;
9945 
9946 
9947  llrp_bool_t
9948  isAllowedIn (
9949  const CTypeDescriptor * pEnclosingElementType) const;
9950 
9951 
9952  static CElement *
9953  s_construct (void);
9954 
9955  static void
9956  s_decodeFields (
9957  CDecoderStream * pDecoderStream,
9958  CElement * pElement);
9960 
9961 
9962  protected:
9963  llrp_u1_t m_EnableAntennaAttemptNotification;
9964 
9967  public:
9968  static const CFieldDescriptor
9969  s_fdEnableAntennaAttemptNotification;
9971 
9973  inline llrp_u1_t
9975  {
9976  return m_EnableAntennaAttemptNotification;
9977  }
9978 
9980  inline void
9982  llrp_u1_t value)
9983  {
9984  m_EnableAntennaAttemptNotification = value;
9985  }
9986 
9987 
9988  protected:
9989  std::list<CParameter *> m_listCustom;
9990 
9991  public:
9993  inline std::list<CParameter *>::iterator
9995  {
9996  return m_listCustom.begin();
9997  }
9998 
10000  inline std::list<CParameter *>::iterator
10001  endCustom (void)
10002  {
10003  return m_listCustom.end();
10004  }
10005 
10007  inline void
10009  {
10010  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10011  }
10012 
10014  inline int
10016  {
10017  return (int) (m_listCustom.size());
10018  }
10019 
10020  EResultCode
10022  addCustom (
10023  CParameter * pValue);
10024 
10025 
10026 };
10027 
10028 
10053 class CImpinjAntennaAttemptEvent : public CParameter
10054 {
10055  public:
10058 
10061 
10062  static const CFieldDescriptor * const
10063  s_apFieldDescriptorTable[];
10064 
10065  static const CTypeDescriptor
10066  s_typeDescriptor;
10067 
10068  void
10069  decodeFields (
10070  CDecoderStream * pDecoderStream);
10071 
10072  void
10073  assimilateSubParameters (
10074  CErrorDetails * pError);
10075 
10076  void
10077  encode (
10078  CEncoderStream * pEncoderStream) const;
10079 
10080 
10081  llrp_bool_t
10082  isAllowedIn (
10083  const CTypeDescriptor * pEnclosingElementType) const;
10084 
10085 
10086  static CElement *
10087  s_construct (void);
10088 
10089  static void
10090  s_decodeFields (
10091  CDecoderStream * pDecoderStream,
10092  CElement * pElement);
10094 
10095 
10096  protected:
10097  llrp_u16_t m_AntennaID;
10098 
10101  public:
10102  static const CFieldDescriptor
10103  s_fdAntennaID;
10105 
10107  inline llrp_u16_t
10109  {
10110  return m_AntennaID;
10111  }
10112 
10114  inline void
10116  llrp_u16_t value)
10117  {
10118  m_AntennaID = value;
10119  }
10120 
10121 
10122  protected:
10123  std::list<CParameter *> m_listCustom;
10124 
10125  public:
10127  inline std::list<CParameter *>::iterator
10129  {
10130  return m_listCustom.begin();
10131  }
10132 
10134  inline std::list<CParameter *>::iterator
10135  endCustom (void)
10136  {
10137  return m_listCustom.end();
10138  }
10139 
10141  inline void
10143  {
10144  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10145  }
10146 
10148  inline int
10150  {
10151  return (int) (m_listCustom.size());
10152  }
10153 
10154  EResultCode
10156  addCustom (
10157  CParameter * pValue);
10158 
10159 
10160 };
10161 
10162 
10190 class CImpinjHubConfiguration : public CParameter
10191 {
10192  public:
10193  CImpinjHubConfiguration (void);
10194  ~CImpinjHubConfiguration (void);
10195 
10198 
10199  static const CFieldDescriptor * const
10200  s_apFieldDescriptorTable[];
10201 
10202  static const CTypeDescriptor
10203  s_typeDescriptor;
10204 
10205  void
10206  decodeFields (
10207  CDecoderStream * pDecoderStream);
10208 
10209  void
10210  assimilateSubParameters (
10211  CErrorDetails * pError);
10212 
10213  void
10214  encode (
10215  CEncoderStream * pEncoderStream) const;
10216 
10217 
10218  llrp_bool_t
10219  isAllowedIn (
10220  const CTypeDescriptor * pEnclosingElementType) const;
10221 
10222 
10223  static CElement *
10224  s_construct (void);
10225 
10226  static void
10227  s_decodeFields (
10228  CDecoderStream * pDecoderStream,
10229  CElement * pElement);
10231 
10232 
10233  protected:
10234  llrp_u16_t m_HubID;
10235 
10238  public:
10239  static const CFieldDescriptor
10240  s_fdHubID;
10242 
10244  inline llrp_u16_t
10245  getHubID (void)
10246  {
10247  return m_HubID;
10248  }
10249 
10251  inline void
10253  llrp_u16_t value)
10254  {
10255  m_HubID = value;
10256  }
10257 
10258 
10259  protected:
10260  EImpinjHubConnectedType m_eConnected;
10261 
10264  public:
10265  static const CFieldDescriptor
10266  s_fdConnected;
10268 
10270  inline EImpinjHubConnectedType
10272  {
10273  return m_eConnected;
10274  }
10275 
10277  inline void
10279  EImpinjHubConnectedType value)
10280  {
10281  m_eConnected = value;
10282  }
10283 
10284 
10285  protected:
10286  EImpinjHubFaultType m_eFault;
10287 
10290  public:
10291  static const CFieldDescriptor
10292  s_fdFault;
10294 
10296  inline EImpinjHubFaultType
10297  getFault (void)
10298  {
10299  return m_eFault;
10300  }
10301 
10303  inline void
10305  EImpinjHubFaultType value)
10306  {
10307  m_eFault = value;
10308  }
10309 
10310 
10311  protected:
10312  std::list<CParameter *> m_listCustom;
10313 
10314  public:
10316  inline std::list<CParameter *>::iterator
10318  {
10319  return m_listCustom.begin();
10320  }
10321 
10323  inline std::list<CParameter *>::iterator
10324  endCustom (void)
10325  {
10326  return m_listCustom.end();
10327  }
10328 
10330  inline void
10332  {
10333  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10334  }
10335 
10337  inline int
10339  {
10340  return (int) (m_listCustom.size());
10341  }
10342 
10343  EResultCode
10345  addCustom (
10346  CParameter * pValue);
10347 
10348 
10349 };
10350 
10351 
10375 class CImpinjDiagnosticReport : public CParameter
10376 {
10377  public:
10378  CImpinjDiagnosticReport (void);
10379  ~CImpinjDiagnosticReport (void);
10380 
10383 
10384  static const CFieldDescriptor * const
10385  s_apFieldDescriptorTable[];
10386 
10387  static const CTypeDescriptor
10388  s_typeDescriptor;
10389 
10390  void
10391  decodeFields (
10392  CDecoderStream * pDecoderStream);
10393 
10394  void
10395  assimilateSubParameters (
10396  CErrorDetails * pError);
10397 
10398  void
10399  encode (
10400  CEncoderStream * pEncoderStream) const;
10401 
10402 
10403  llrp_bool_t
10404  isAllowedIn (
10405  const CTypeDescriptor * pEnclosingElementType) const;
10406 
10407 
10408  static CElement *
10409  s_construct (void);
10410 
10411  static void
10412  s_decodeFields (
10413  CDecoderStream * pDecoderStream,
10414  CElement * pElement);
10416 
10417 
10418  protected:
10419  llrp_u32v_t m_Metric;
10420 
10423  public:
10424  static const CFieldDescriptor
10425  s_fdMetric;
10427 
10429  inline llrp_u32v_t
10430  getMetric (void)
10431  {
10432  return m_Metric;
10433  }
10434 
10436  inline void
10438  llrp_u32v_t value)
10439  {
10440  m_Metric = value;
10441  }
10442 
10443 
10444 };
10445 
10446 
10485 class CImpinjPlacementConfiguration : public CParameter
10486 {
10487  public:
10490 
10493 
10494  static const CFieldDescriptor * const
10495  s_apFieldDescriptorTable[];
10496 
10497  static const CTypeDescriptor
10498  s_typeDescriptor;
10499 
10500  void
10501  decodeFields (
10502  CDecoderStream * pDecoderStream);
10503 
10504  void
10505  assimilateSubParameters (
10506  CErrorDetails * pError);
10507 
10508  void
10509  encode (
10510  CEncoderStream * pEncoderStream) const;
10511 
10512 
10513  llrp_bool_t
10514  isAllowedIn (
10515  const CTypeDescriptor * pEnclosingElementType) const;
10516 
10517 
10518  static CElement *
10519  s_construct (void);
10520 
10521  static void
10522  s_decodeFields (
10523  CDecoderStream * pDecoderStream,
10524  CElement * pElement);
10526 
10527 
10528  protected:
10529  llrp_u16_t m_HeightCm;
10530 
10533  public:
10534  static const CFieldDescriptor
10535  s_fdHeightCm;
10537 
10539  inline llrp_u16_t
10541  {
10542  return m_HeightCm;
10543  }
10544 
10546  inline void
10548  llrp_u16_t value)
10549  {
10550  m_HeightCm = value;
10551  }
10552 
10553 
10554  protected:
10555  llrp_s32_t m_FacilityXLocationCm;
10556 
10559  public:
10560  static const CFieldDescriptor
10561  s_fdFacilityXLocationCm;
10563 
10565  inline llrp_s32_t
10567  {
10568  return m_FacilityXLocationCm;
10569  }
10570 
10572  inline void
10574  llrp_s32_t value)
10575  {
10576  m_FacilityXLocationCm = value;
10577  }
10578 
10579 
10580  protected:
10581  llrp_s32_t m_FacilityYLocationCm;
10582 
10585  public:
10586  static const CFieldDescriptor
10587  s_fdFacilityYLocationCm;
10589 
10591  inline llrp_s32_t
10593  {
10594  return m_FacilityYLocationCm;
10595  }
10596 
10598  inline void
10600  llrp_s32_t value)
10601  {
10602  m_FacilityYLocationCm = value;
10603  }
10604 
10605 
10606  protected:
10607  llrp_s16_t m_OrientationDegrees;
10608 
10611  public:
10612  static const CFieldDescriptor
10613  s_fdOrientationDegrees;
10615 
10617  inline llrp_s16_t
10619  {
10620  return m_OrientationDegrees;
10621  }
10622 
10624  inline void
10626  llrp_s16_t value)
10627  {
10628  m_OrientationDegrees = value;
10629  }
10630 
10631 
10632  protected:
10633  std::list<CParameter *> m_listCustom;
10634 
10635  public:
10637  inline std::list<CParameter *>::iterator
10639  {
10640  return m_listCustom.begin();
10641  }
10642 
10644  inline std::list<CParameter *>::iterator
10645  endCustom (void)
10646  {
10647  return m_listCustom.end();
10648  }
10649 
10651  inline void
10653  {
10654  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10655  }
10656 
10658  inline int
10660  {
10661  return (int) (m_listCustom.size());
10662  }
10663 
10664  EResultCode
10666  addCustom (
10667  CParameter * pValue);
10668 
10669 
10670 };
10671 
10672 
10703 class CImpinjLISpec : public CParameter
10704 {
10705  public:
10706  CImpinjLISpec (void);
10707  ~CImpinjLISpec (void);
10708 
10711 
10712  static const CFieldDescriptor * const
10713  s_apFieldDescriptorTable[];
10714 
10715  static const CTypeDescriptor
10716  s_typeDescriptor;
10717 
10718  void
10719  decodeFields (
10720  CDecoderStream * pDecoderStream);
10721 
10722  void
10723  assimilateSubParameters (
10724  CErrorDetails * pError);
10725 
10726  void
10727  encode (
10728  CEncoderStream * pEncoderStream) const;
10729 
10730 
10731  llrp_bool_t
10732  isAllowedIn (
10733  const CTypeDescriptor * pEnclosingElementType) const;
10734 
10735 
10736  static CElement *
10737  s_construct (void);
10738 
10739  static void
10740  s_decodeFields (
10741  CDecoderStream * pDecoderStream,
10742  CElement * pElement);
10744 
10745 
10746  protected:
10747  CImpinjLocationConfig * m_pImpinjLocationConfig;
10748 
10749  public:
10751  inline CImpinjLocationConfig *
10753  {
10754  return m_pImpinjLocationConfig;
10755  }
10756 
10758  EResultCode
10760  CImpinjLocationConfig * pValue);
10761 
10762 
10763  protected:
10764  CImpinjC1G2LocationConfig * m_pImpinjC1G2LocationConfig;
10765 
10766  public:
10768  inline CImpinjC1G2LocationConfig *
10770  {
10771  return m_pImpinjC1G2LocationConfig;
10772  }
10773 
10775  EResultCode
10777  CImpinjC1G2LocationConfig * pValue);
10778 
10779 
10780  protected:
10781  CImpinjLocationReporting * m_pImpinjLocationReporting;
10782 
10783  public:
10785  inline CImpinjLocationReporting *
10787  {
10788  return m_pImpinjLocationReporting;
10789  }
10790 
10792  EResultCode
10794  CImpinjLocationReporting * pValue);
10795 
10796 
10797  protected:
10798  std::list<CParameter *> m_listCustom;
10799 
10800  public:
10802  inline std::list<CParameter *>::iterator
10804  {
10805  return m_listCustom.begin();
10806  }
10807 
10809  inline std::list<CParameter *>::iterator
10810  endCustom (void)
10811  {
10812  return m_listCustom.end();
10813  }
10814 
10816  inline void
10818  {
10819  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10820  }
10821 
10823  inline int
10825  {
10826  return (int) (m_listCustom.size());
10827  }
10828 
10829  EResultCode
10831  addCustom (
10832  CParameter * pValue);
10833 
10834 
10835 };
10836 
10837 
10883 class CImpinjLocationConfig : public CParameter
10884 {
10885  public:
10886  CImpinjLocationConfig (void);
10887  ~CImpinjLocationConfig (void);
10888 
10891 
10892  static const CFieldDescriptor * const
10893  s_apFieldDescriptorTable[];
10894 
10895  static const CTypeDescriptor
10896  s_typeDescriptor;
10897 
10898  void
10899  decodeFields (
10900  CDecoderStream * pDecoderStream);
10901 
10902  void
10903  assimilateSubParameters (
10904  CErrorDetails * pError);
10905 
10906  void
10907  encode (
10908  CEncoderStream * pEncoderStream) const;
10909 
10910 
10911  llrp_bool_t
10912  isAllowedIn (
10913  const CTypeDescriptor * pEnclosingElementType) const;
10914 
10915 
10916  static CElement *
10917  s_construct (void);
10918 
10919  static void
10920  s_decodeFields (
10921  CDecoderStream * pDecoderStream,
10922  CElement * pElement);
10924 
10925 
10926  protected:
10927  llrp_u16_t m_ComputeWindowSeconds;
10928 
10931  public:
10932  static const CFieldDescriptor
10933  s_fdComputeWindowSeconds;
10935 
10937  inline llrp_u16_t
10939  {
10940  return m_ComputeWindowSeconds;
10941  }
10942 
10944  inline void
10946  llrp_u16_t value)
10947  {
10948  m_ComputeWindowSeconds = value;
10949  }
10950 
10951 
10952  protected:
10953  llrp_u16_t m_TagAgeIntervalSeconds;
10954 
10957  public:
10958  static const CFieldDescriptor
10959  s_fdTagAgeIntervalSeconds;
10961 
10963  inline llrp_u16_t
10965  {
10966  return m_TagAgeIntervalSeconds;
10967  }
10968 
10970  inline void
10972  llrp_u16_t value)
10973  {
10974  m_TagAgeIntervalSeconds = value;
10975  }
10976 
10977 
10978  protected:
10979  llrp_u16_t m_UpdateIntervalSeconds;
10980 
10983  public:
10984  static const CFieldDescriptor
10985  s_fdUpdateIntervalSeconds;
10987 
10989  inline llrp_u16_t
10991  {
10992  return m_UpdateIntervalSeconds;
10993  }
10994 
10996  inline void
10998  llrp_u16_t value)
10999  {
11000  m_UpdateIntervalSeconds = value;
11001  }
11002 
11003 
11004  protected:
11005  CImpinjDisabledAntennas * m_pImpinjDisabledAntennas;
11006 
11007  public:
11009  inline CImpinjDisabledAntennas *
11011  {
11012  return m_pImpinjDisabledAntennas;
11013  }
11014 
11016  EResultCode
11018  CImpinjDisabledAntennas * pValue);
11019 
11020 
11021  protected:
11022  CImpinjLocationAlgorithmControl * m_pImpinjLocationAlgorithmControl;
11023 
11024  public:
11028  {
11029  return m_pImpinjLocationAlgorithmControl;
11030  }
11031 
11033  EResultCode
11036 
11037 
11038  protected:
11039  std::list<CParameter *> m_listCustom;
11040 
11041  public:
11043  inline std::list<CParameter *>::iterator
11045  {
11046  return m_listCustom.begin();
11047  }
11048 
11050  inline std::list<CParameter *>::iterator
11051  endCustom (void)
11052  {
11053  return m_listCustom.end();
11054  }
11055 
11057  inline void
11059  {
11060  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11061  }
11062 
11064  inline int
11066  {
11067  return (int) (m_listCustom.size());
11068  }
11069 
11070  EResultCode
11072  addCustom (
11073  CParameter * pValue);
11074 
11075 
11076 };
11077 
11078 
11121 class CImpinjC1G2LocationConfig : public CParameter
11122 {
11123  public:
11125  ~CImpinjC1G2LocationConfig (void);
11126 
11129 
11130  static const CFieldDescriptor * const
11131  s_apFieldDescriptorTable[];
11132 
11133  static const CTypeDescriptor
11134  s_typeDescriptor;
11135 
11136  void
11137  decodeFields (
11138  CDecoderStream * pDecoderStream);
11139 
11140  void
11141  assimilateSubParameters (
11142  CErrorDetails * pError);
11143 
11144  void
11145  encode (
11146  CEncoderStream * pEncoderStream) const;
11147 
11148 
11149  llrp_bool_t
11150  isAllowedIn (
11151  const CTypeDescriptor * pEnclosingElementType) const;
11152 
11153 
11154  static CElement *
11155  s_construct (void);
11156 
11157  static void
11158  s_decodeFields (
11159  CDecoderStream * pDecoderStream,
11160  CElement * pElement);
11162 
11163 
11164  protected:
11165  llrp_u16_t m_ModeIndex;
11166 
11169  public:
11170  static const CFieldDescriptor
11171  s_fdModeIndex;
11173 
11175  inline llrp_u16_t
11177  {
11178  return m_ModeIndex;
11179  }
11180 
11182  inline void
11184  llrp_u16_t value)
11185  {
11186  m_ModeIndex = value;
11187  }
11188 
11189 
11190  protected:
11191  llrp_u2_t m_Session;
11192 
11195  public:
11196  static const CFieldDescriptor
11197  s_fdSession;
11199 
11201  inline llrp_u2_t
11202  getSession (void)
11203  {
11204  return m_Session;
11205  }
11206 
11208  inline void
11210  llrp_u2_t value)
11211  {
11212  m_Session = value;
11213  }
11214 
11215 
11216  protected:
11217  std::list<CC1G2Filter *> m_listC1G2Filter;
11218 
11219  public:
11221  inline std::list<CC1G2Filter *>::iterator
11223  {
11224  return m_listC1G2Filter.begin();
11225  }
11226 
11228  inline std::list<CC1G2Filter *>::iterator
11230  {
11231  return m_listC1G2Filter.end();
11232  }
11233 
11235  inline void
11237  {
11238  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
11239  }
11240 
11242  inline int
11244  {
11245  return (int) (m_listC1G2Filter.size());
11246  }
11247 
11248  EResultCode
11250  addC1G2Filter (
11251  CC1G2Filter * pValue);
11252 
11253 
11254  protected:
11255  CImpinjTransmitPower * m_pImpinjTransmitPower;
11256 
11257  public:
11259  inline CImpinjTransmitPower *
11261  {
11262  return m_pImpinjTransmitPower;
11263  }
11264 
11266  EResultCode
11268  CImpinjTransmitPower * pValue);
11269 
11270 
11271  protected:
11272  std::list<CParameter *> m_listCustom;
11273 
11274  public:
11276  inline std::list<CParameter *>::iterator
11278  {
11279  return m_listCustom.begin();
11280  }
11281 
11283  inline std::list<CParameter *>::iterator
11284  endCustom (void)
11285  {
11286  return m_listCustom.end();
11287  }
11288 
11290  inline void
11292  {
11293  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11294  }
11295 
11297  inline int
11299  {
11300  return (int) (m_listCustom.size());
11301  }
11302 
11303  EResultCode
11305  addCustom (
11306  CParameter * pValue);
11307 
11308 
11309 };
11310 
11311 
11353 class CImpinjLocationReporting : public CParameter
11354 {
11355  public:
11356  CImpinjLocationReporting (void);
11357  ~CImpinjLocationReporting (void);
11358 
11361 
11362  static const CFieldDescriptor * const
11363  s_apFieldDescriptorTable[];
11364 
11365  static const CTypeDescriptor
11366  s_typeDescriptor;
11367 
11368  void
11369  decodeFields (
11370  CDecoderStream * pDecoderStream);
11371 
11372  void
11373  assimilateSubParameters (
11374  CErrorDetails * pError);
11375 
11376  void
11377  encode (
11378  CEncoderStream * pEncoderStream) const;
11379 
11380 
11381  llrp_bool_t
11382  isAllowedIn (
11383  const CTypeDescriptor * pEnclosingElementType) const;
11384 
11385 
11386  static CElement *
11387  s_construct (void);
11388 
11389  static void
11390  s_decodeFields (
11391  CDecoderStream * pDecoderStream,
11392  CElement * pElement);
11394 
11395 
11396  protected:
11397  llrp_u1_t m_EnableUpdateReport;
11398 
11401  public:
11402  static const CFieldDescriptor
11403  s_fdEnableUpdateReport;
11405 
11407  inline llrp_u1_t
11409  {
11410  return m_EnableUpdateReport;
11411  }
11412 
11414  inline void
11416  llrp_u1_t value)
11417  {
11418  m_EnableUpdateReport = value;
11419  }
11420 
11421 
11422  protected:
11423  llrp_u1_t m_EnableEntryReport;
11424 
11427  public:
11428  static const CFieldDescriptor
11429  s_fdEnableEntryReport;
11431 
11433  inline llrp_u1_t
11435  {
11436  return m_EnableEntryReport;
11437  }
11438 
11440  inline void
11442  llrp_u1_t value)
11443  {
11444  m_EnableEntryReport = value;
11445  }
11446 
11447 
11448  protected:
11449  llrp_u1_t m_EnableExitReport;
11450 
11453  public:
11454  static const CFieldDescriptor
11455  s_fdEnableExitReport;
11457 
11459  inline llrp_u1_t
11461  {
11462  return m_EnableExitReport;
11463  }
11464 
11466  inline void
11468  llrp_u1_t value)
11469  {
11470  m_EnableExitReport = value;
11471  }
11472 
11473 
11474  protected:
11475  llrp_u1_t m_EnableDiagnosticReport;
11476 
11479  public:
11480  static const CFieldDescriptor
11481  s_fdEnableDiagnosticReport;
11483 
11485  inline llrp_u1_t
11487  {
11488  return m_EnableDiagnosticReport;
11489  }
11490 
11492  inline void
11494  llrp_u1_t value)
11495  {
11496  m_EnableDiagnosticReport = value;
11497  }
11498 
11499 
11500  protected:
11501  std::list<CParameter *> m_listCustom;
11502 
11503  public:
11505  inline std::list<CParameter *>::iterator
11507  {
11508  return m_listCustom.begin();
11509  }
11510 
11512  inline std::list<CParameter *>::iterator
11513  endCustom (void)
11514  {
11515  return m_listCustom.end();
11516  }
11517 
11519  inline void
11521  {
11522  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11523  }
11524 
11526  inline int
11528  {
11529  return (int) (m_listCustom.size());
11530  }
11531 
11532  EResultCode
11534  addCustom (
11535  CParameter * pValue);
11536 
11537 
11538 };
11539 
11540 
11571 class CImpinjLocationConfidence : public CParameter
11572 {
11573  public:
11575  ~CImpinjLocationConfidence (void);
11576 
11579 
11580  static const CFieldDescriptor * const
11581  s_apFieldDescriptorTable[];
11582 
11583  static const CTypeDescriptor
11584  s_typeDescriptor;
11585 
11586  void
11587  decodeFields (
11588  CDecoderStream * pDecoderStream);
11589 
11590  void
11591  assimilateSubParameters (
11592  CErrorDetails * pError);
11593 
11594  void
11595  encode (
11596  CEncoderStream * pEncoderStream) const;
11597 
11598 
11599  llrp_bool_t
11600  isAllowedIn (
11601  const CTypeDescriptor * pEnclosingElementType) const;
11602 
11603 
11604  static CElement *
11605  s_construct (void);
11606 
11607  static void
11608  s_decodeFields (
11609  CDecoderStream * pDecoderStream,
11610  CElement * pElement);
11612 
11613 
11614  protected:
11615  llrp_u16_t m_ReadCount;
11616 
11619  public:
11620  static const CFieldDescriptor
11621  s_fdReadCount;
11623 
11625  inline llrp_u16_t
11627  {
11628  return m_ReadCount;
11629  }
11630 
11632  inline void
11634  llrp_u16_t value)
11635  {
11636  m_ReadCount = value;
11637  }
11638 
11639 
11640  protected:
11641  llrp_u32v_t m_ConfidenceData;
11642 
11645  public:
11646  static const CFieldDescriptor
11647  s_fdConfidenceData;
11649 
11651  inline llrp_u32v_t
11653  {
11654  return m_ConfidenceData;
11655  }
11656 
11658  inline void
11660  llrp_u32v_t value)
11661  {
11662  m_ConfidenceData = value;
11663  }
11664 
11665 
11666  protected:
11667  std::list<CParameter *> m_listCustom;
11668 
11669  public:
11671  inline std::list<CParameter *>::iterator
11673  {
11674  return m_listCustom.begin();
11675  }
11676 
11678  inline std::list<CParameter *>::iterator
11679  endCustom (void)
11680  {
11681  return m_listCustom.end();
11682  }
11683 
11685  inline void
11687  {
11688  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11689  }
11690 
11692  inline int
11694  {
11695  return (int) (m_listCustom.size());
11696  }
11697 
11698  EResultCode
11700  addCustom (
11701  CParameter * pValue);
11702 
11703 
11704 };
11705 
11706 
11744 class CImpinjLocationReportData : public CParameter
11745 {
11746  public:
11748  ~CImpinjLocationReportData (void);
11749 
11752 
11753  static const CFieldDescriptor * const
11754  s_apFieldDescriptorTable[];
11755 
11756  static const CTypeDescriptor
11757  s_typeDescriptor;
11758 
11759  void
11760  decodeFields (
11761  CDecoderStream * pDecoderStream);
11762 
11763  void
11764  assimilateSubParameters (
11765  CErrorDetails * pError);
11766 
11767  void
11768  encode (
11769  CEncoderStream * pEncoderStream) const;
11770 
11771 
11772  llrp_bool_t
11773  isAllowedIn (
11774  const CTypeDescriptor * pEnclosingElementType) const;
11775 
11776 
11777  static CElement *
11778  s_construct (void);
11779 
11780  static void
11781  s_decodeFields (
11782  CDecoderStream * pDecoderStream,
11783  CElement * pElement);
11785 
11786 
11787  protected:
11788  llrp_u64_t m_LastSeenTimestampUTC;
11789 
11792  public:
11793  static const CFieldDescriptor
11794  s_fdLastSeenTimestampUTC;
11796 
11798  inline llrp_u64_t
11800  {
11801  return m_LastSeenTimestampUTC;
11802  }
11803 
11805  inline void
11807  llrp_u64_t value)
11808  {
11809  m_LastSeenTimestampUTC = value;
11810  }
11811 
11812 
11813  protected:
11814  llrp_s32_t m_LocXCentimeters;
11815 
11818  public:
11819  static const CFieldDescriptor
11820  s_fdLocXCentimeters;
11822 
11824  inline llrp_s32_t
11826  {
11827  return m_LocXCentimeters;
11828  }
11829 
11831  inline void
11833  llrp_s32_t value)
11834  {
11835  m_LocXCentimeters = value;
11836  }
11837 
11838 
11839  protected:
11840  llrp_s32_t m_LocYCentimeters;
11841 
11844  public:
11845  static const CFieldDescriptor
11846  s_fdLocYCentimeters;
11848 
11850  inline llrp_s32_t
11852  {
11853  return m_LocYCentimeters;
11854  }
11855 
11857  inline void
11859  llrp_s32_t value)
11860  {
11861  m_LocYCentimeters = value;
11862  }
11863 
11864 
11865  protected:
11866  EImpinjLocationReportType m_eType;
11867 
11870  public:
11871  static const CFieldDescriptor
11872  s_fdType;
11874 
11876  inline EImpinjLocationReportType
11877  getType (void)
11878  {
11879  return m_eType;
11880  }
11881 
11883  inline void
11885  EImpinjLocationReportType value)
11886  {
11887  m_eType = value;
11888  }
11889 
11890 
11891  protected:
11892  CImpinjLocationConfidence * m_pImpinjLocationConfidence;
11893 
11894  public:
11896  inline CImpinjLocationConfidence *
11898  {
11899  return m_pImpinjLocationConfidence;
11900  }
11901 
11903  EResultCode
11905  CImpinjLocationConfidence * pValue);
11906 
11907 
11908  protected:
11909  std::list<CParameter *> m_listCustom;
11910 
11911  public:
11913  inline std::list<CParameter *>::iterator
11915  {
11916  return m_listCustom.begin();
11917  }
11918 
11920  inline std::list<CParameter *>::iterator
11921  endCustom (void)
11922  {
11923  return m_listCustom.end();
11924  }
11925 
11927  inline void
11929  {
11930  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11931  }
11932 
11934  inline int
11936  {
11937  return (int) (m_listCustom.size());
11938  }
11939 
11940  EResultCode
11942  addCustom (
11943  CParameter * pValue);
11944 
11945 
11946 };
11947 
11948 
11981 class CImpinjDISpec : public CParameter
11982 {
11983  public:
11984  CImpinjDISpec (void);
11985  ~CImpinjDISpec (void);
11986 
11989 
11990  static const CFieldDescriptor * const
11991  s_apFieldDescriptorTable[];
11992 
11993  static const CTypeDescriptor
11994  s_typeDescriptor;
11995 
11996  void
11997  decodeFields (
11998  CDecoderStream * pDecoderStream);
11999 
12000  void
12001  assimilateSubParameters (
12002  CErrorDetails * pError);
12003 
12004  void
12005  encode (
12006  CEncoderStream * pEncoderStream) const;
12007 
12008 
12009  llrp_bool_t
12010  isAllowedIn (
12011  const CTypeDescriptor * pEnclosingElementType) const;
12012 
12013 
12014  static CElement *
12015  s_construct (void);
12016 
12017  static void
12018  s_decodeFields (
12019  CDecoderStream * pDecoderStream,
12020  CElement * pElement);
12022 
12023 
12024  protected:
12025  CImpinjDirectionSectors * m_pImpinjDirectionSectors;
12026 
12027  public:
12029  inline CImpinjDirectionSectors *
12031  {
12032  return m_pImpinjDirectionSectors;
12033  }
12034 
12036  EResultCode
12038  CImpinjDirectionSectors * pValue);
12039 
12040 
12041  protected:
12042  CImpinjDirectionConfig * m_pImpinjDirectionConfig;
12043 
12044  public:
12046  inline CImpinjDirectionConfig *
12048  {
12049  return m_pImpinjDirectionConfig;
12050  }
12051 
12053  EResultCode
12055  CImpinjDirectionConfig * pValue);
12056 
12057 
12058  protected:
12059  CImpinjC1G2DirectionConfig * m_pImpinjC1G2DirectionConfig;
12060 
12061  public:
12065  {
12066  return m_pImpinjC1G2DirectionConfig;
12067  }
12068 
12070  EResultCode
12072  CImpinjC1G2DirectionConfig * pValue);
12073 
12074 
12075  protected:
12076  CImpinjDirectionReporting * m_pImpinjDirectionReporting;
12077 
12078  public:
12080  inline CImpinjDirectionReporting *
12082  {
12083  return m_pImpinjDirectionReporting;
12084  }
12085 
12087  EResultCode
12089  CImpinjDirectionReporting * pValue);
12090 
12091 
12092  protected:
12093  std::list<CParameter *> m_listCustom;
12094 
12095  public:
12097  inline std::list<CParameter *>::iterator
12099  {
12100  return m_listCustom.begin();
12101  }
12102 
12104  inline std::list<CParameter *>::iterator
12105  endCustom (void)
12106  {
12107  return m_listCustom.end();
12108  }
12109 
12111  inline void
12113  {
12114  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12115  }
12116 
12118  inline int
12120  {
12121  return (int) (m_listCustom.size());
12122  }
12123 
12124  EResultCode
12126  addCustom (
12127  CParameter * pValue);
12128 
12129 
12130 };
12131 
12132 
12160 class CImpinjDirectionSectors : public CParameter
12161 {
12162  public:
12163  CImpinjDirectionSectors (void);
12164  ~CImpinjDirectionSectors (void);
12165 
12168 
12169  static const CFieldDescriptor * const
12170  s_apFieldDescriptorTable[];
12171 
12172  static const CTypeDescriptor
12173  s_typeDescriptor;
12174 
12175  void
12176  decodeFields (
12177  CDecoderStream * pDecoderStream);
12178 
12179  void
12180  assimilateSubParameters (
12181  CErrorDetails * pError);
12182 
12183  void
12184  encode (
12185  CEncoderStream * pEncoderStream) const;
12186 
12187 
12188  llrp_bool_t
12189  isAllowedIn (
12190  const CTypeDescriptor * pEnclosingElementType) const;
12191 
12192 
12193  static CElement *
12194  s_construct (void);
12195 
12196  static void
12197  s_decodeFields (
12198  CDecoderStream * pDecoderStream,
12199  CElement * pElement);
12201 
12202 
12203  protected:
12204  llrp_u16v_t m_EnabledSectorIDs;
12205 
12208  public:
12209  static const CFieldDescriptor
12210  s_fdEnabledSectorIDs;
12212 
12214  inline llrp_u16v_t
12216  {
12217  return m_EnabledSectorIDs;
12218  }
12219 
12221  inline void
12223  llrp_u16v_t value)
12224  {
12225  m_EnabledSectorIDs = value;
12226  }
12227 
12228 
12229  protected:
12230  std::list<CParameter *> m_listCustom;
12231 
12232  public:
12234  inline std::list<CParameter *>::iterator
12236  {
12237  return m_listCustom.begin();
12238  }
12239 
12241  inline std::list<CParameter *>::iterator
12242  endCustom (void)
12243  {
12244  return m_listCustom.end();
12245  }
12246 
12248  inline void
12250  {
12251  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12252  }
12253 
12255  inline int
12257  {
12258  return (int) (m_listCustom.size());
12259  }
12260 
12261  EResultCode
12263  addCustom (
12264  CParameter * pValue);
12265 
12266 
12267 };
12268 
12269 
12308 class CImpinjDirectionConfig : public CParameter
12309 {
12310  public:
12311  CImpinjDirectionConfig (void);
12312  ~CImpinjDirectionConfig (void);
12313 
12316 
12317  static const CFieldDescriptor * const
12318  s_apFieldDescriptorTable[];
12319 
12320  static const CTypeDescriptor
12321  s_typeDescriptor;
12322 
12323  void
12324  decodeFields (
12325  CDecoderStream * pDecoderStream);
12326 
12327  void
12328  assimilateSubParameters (
12329  CErrorDetails * pError);
12330 
12331  void
12332  encode (
12333  CEncoderStream * pEncoderStream) const;
12334 
12335 
12336  llrp_bool_t
12337  isAllowedIn (
12338  const CTypeDescriptor * pEnclosingElementType) const;
12339 
12340 
12341  static CElement *
12342  s_construct (void);
12343 
12344  static void
12345  s_decodeFields (
12346  CDecoderStream * pDecoderStream,
12347  CElement * pElement);
12349 
12350 
12351  protected:
12352  llrp_u16_t m_TagAgeIntervalSeconds;
12353 
12356  public:
12357  static const CFieldDescriptor
12358  s_fdTagAgeIntervalSeconds;
12360 
12362  inline llrp_u16_t
12364  {
12365  return m_TagAgeIntervalSeconds;
12366  }
12367 
12369  inline void
12371  llrp_u16_t value)
12372  {
12373  m_TagAgeIntervalSeconds = value;
12374  }
12375 
12376 
12377  protected:
12378  llrp_u16_t m_UpdateIntervalSeconds;
12379 
12382  public:
12383  static const CFieldDescriptor
12384  s_fdUpdateIntervalSeconds;
12386 
12388  inline llrp_u16_t
12390  {
12391  return m_UpdateIntervalSeconds;
12392  }
12393 
12395  inline void
12397  llrp_u16_t value)
12398  {
12399  m_UpdateIntervalSeconds = value;
12400  }
12401 
12402 
12403  protected:
12404  EImpinjDirectionFieldOfView m_eFieldOfView;
12405 
12408  public:
12409  static const CFieldDescriptor
12410  s_fdFieldOfView;
12412 
12414  inline EImpinjDirectionFieldOfView
12416  {
12417  return m_eFieldOfView;
12418  }
12419 
12421  inline void
12423  EImpinjDirectionFieldOfView value)
12424  {
12425  m_eFieldOfView = value;
12426  }
12427 
12428 
12429  protected:
12430  CImpinjDirectionUserTagPopulationLimit * m_pImpinjDirectionUserTagPopulationLimit;
12431 
12432  public:
12436  {
12437  return m_pImpinjDirectionUserTagPopulationLimit;
12438  }
12439 
12441  EResultCode
12444 
12445 
12446  protected:
12447  std::list<CParameter *> m_listCustom;
12448 
12449  public:
12451  inline std::list<CParameter *>::iterator
12453  {
12454  return m_listCustom.begin();
12455  }
12456 
12458  inline std::list<CParameter *>::iterator
12459  endCustom (void)
12460  {
12461  return m_listCustom.end();
12462  }
12463 
12465  inline void
12467  {
12468  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12469  }
12470 
12472  inline int
12474  {
12475  return (int) (m_listCustom.size());
12476  }
12477 
12478  EResultCode
12480  addCustom (
12481  CParameter * pValue);
12482 
12483 
12484 };
12485 
12486 
12510 {
12511  public:
12514 
12517 
12518  static const CFieldDescriptor * const
12519  s_apFieldDescriptorTable[];
12520 
12521  static const CTypeDescriptor
12522  s_typeDescriptor;
12523 
12524  void
12525  decodeFields (
12526  CDecoderStream * pDecoderStream);
12527 
12528  void
12529  assimilateSubParameters (
12530  CErrorDetails * pError);
12531 
12532  void
12533  encode (
12534  CEncoderStream * pEncoderStream) const;
12535 
12536 
12537  llrp_bool_t
12538  isAllowedIn (
12539  const CTypeDescriptor * pEnclosingElementType) const;
12540 
12541 
12542  static CElement *
12543  s_construct (void);
12544 
12545  static void
12546  s_decodeFields (
12547  CDecoderStream * pDecoderStream,
12548  CElement * pElement);
12550 
12551 
12552  protected:
12553  llrp_u16_t m_UserTagPopulationLimit;
12554 
12557  public:
12558  static const CFieldDescriptor
12559  s_fdUserTagPopulationLimit;
12561 
12563  inline llrp_u16_t
12565  {
12566  return m_UserTagPopulationLimit;
12567  }
12568 
12570  inline void
12572  llrp_u16_t value)
12573  {
12574  m_UserTagPopulationLimit = value;
12575  }
12576 
12577 
12578 };
12579 
12580 
12618 class CImpinjC1G2DirectionConfig : public CParameter
12619 {
12620  public:
12623 
12626 
12627  static const CFieldDescriptor * const
12628  s_apFieldDescriptorTable[];
12629 
12630  static const CTypeDescriptor
12631  s_typeDescriptor;
12632 
12633  void
12634  decodeFields (
12635  CDecoderStream * pDecoderStream);
12636 
12637  void
12638  assimilateSubParameters (
12639  CErrorDetails * pError);
12640 
12641  void
12642  encode (
12643  CEncoderStream * pEncoderStream) const;
12644 
12645 
12646  llrp_bool_t
12647  isAllowedIn (
12648  const CTypeDescriptor * pEnclosingElementType) const;
12649 
12650 
12651  static CElement *
12652  s_construct (void);
12653 
12654  static void
12655  s_decodeFields (
12656  CDecoderStream * pDecoderStream,
12657  CElement * pElement);
12659 
12660 
12661  protected:
12662  EImpinjDirectionRFMode m_eRFMode;
12663 
12666  public:
12667  static const CFieldDescriptor
12668  s_fdRFMode;
12670 
12672  inline EImpinjDirectionRFMode
12673  getRFMode (void)
12674  {
12675  return m_eRFMode;
12676  }
12677 
12679  inline void
12681  EImpinjDirectionRFMode value)
12682  {
12683  m_eRFMode = value;
12684  }
12685 
12686 
12687  protected:
12688  CImpinjTransmitPower * m_pImpinjTransmitPower;
12689 
12690  public:
12692  inline CImpinjTransmitPower *
12694  {
12695  return m_pImpinjTransmitPower;
12696  }
12697 
12699  EResultCode
12701  CImpinjTransmitPower * pValue);
12702 
12703 
12704  protected:
12705  std::list<CC1G2Filter *> m_listC1G2Filter;
12706 
12707  public:
12709  inline std::list<CC1G2Filter *>::iterator
12711  {
12712  return m_listC1G2Filter.begin();
12713  }
12714 
12716  inline std::list<CC1G2Filter *>::iterator
12718  {
12719  return m_listC1G2Filter.end();
12720  }
12721 
12723  inline void
12725  {
12726  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
12727  }
12728 
12730  inline int
12732  {
12733  return (int) (m_listC1G2Filter.size());
12734  }
12735 
12736  EResultCode
12738  addC1G2Filter (
12739  CC1G2Filter * pValue);
12740 
12741 
12742  protected:
12743  std::list<CParameter *> m_listCustom;
12744 
12745  public:
12747  inline std::list<CParameter *>::iterator
12749  {
12750  return m_listCustom.begin();
12751  }
12752 
12754  inline std::list<CParameter *>::iterator
12755  endCustom (void)
12756  {
12757  return m_listCustom.end();
12758  }
12759 
12761  inline void
12763  {
12764  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12765  }
12766 
12768  inline int
12770  {
12771  return (int) (m_listCustom.size());
12772  }
12773 
12774  EResultCode
12776  addCustom (
12777  CParameter * pValue);
12778 
12779 
12780 };
12781 
12782 
12815 class CImpinjExtendedTagInformation : public CParameter
12816 {
12817  public:
12820 
12823 
12824  static const CFieldDescriptor * const
12825  s_apFieldDescriptorTable[];
12826 
12827  static const CTypeDescriptor
12828  s_typeDescriptor;
12829 
12830  void
12831  decodeFields (
12832  CDecoderStream * pDecoderStream);
12833 
12834  void
12835  assimilateSubParameters (
12836  CErrorDetails * pError);
12837 
12838  void
12839  encode (
12840  CEncoderStream * pEncoderStream) const;
12841 
12842 
12843  llrp_bool_t
12844  isAllowedIn (
12845  const CTypeDescriptor * pEnclosingElementType) const;
12846 
12847 
12848  static CElement *
12849  s_construct (void);
12850 
12851  static void
12852  s_decodeFields (
12853  CDecoderStream * pDecoderStream,
12854  CElement * pElement);
12856 
12857 
12858  protected:
12859  std::list<CEPCData *> m_listEPCData;
12860 
12861  public:
12863  inline std::list<CEPCData *>::iterator
12865  {
12866  return m_listEPCData.begin();
12867  }
12868 
12870  inline std::list<CEPCData *>::iterator
12871  endEPCData (void)
12872  {
12873  return m_listEPCData.end();
12874  }
12875 
12877  inline void
12879  {
12880  clearSubParameterList ((tListOfParameters *) &m_listEPCData);
12881  }
12882 
12884  inline int
12886  {
12887  return (int) (m_listEPCData.size());
12888  }
12889 
12890  EResultCode
12892  addEPCData (
12893  CEPCData * pValue);
12894 
12895 
12896  protected:
12897  CImpinjLocationReportData * m_pImpinjLocationReportData;
12898 
12899  public:
12901  inline CImpinjLocationReportData *
12903  {
12904  return m_pImpinjLocationReportData;
12905  }
12906 
12908  EResultCode
12910  CImpinjLocationReportData * pValue);
12911 
12912 
12913  protected:
12914  CImpinjDirectionReportData * m_pImpinjDirectionReportData;
12915 
12916  public:
12920  {
12921  return m_pImpinjDirectionReportData;
12922  }
12923 
12925  EResultCode
12927  CImpinjDirectionReportData * pValue);
12928 
12929 
12930  protected:
12931  std::list<CParameter *> m_listCustom;
12932 
12933  public:
12935  inline std::list<CParameter *>::iterator
12937  {
12938  return m_listCustom.begin();
12939  }
12940 
12942  inline std::list<CParameter *>::iterator
12943  endCustom (void)
12944  {
12945  return m_listCustom.end();
12946  }
12947 
12949  inline void
12951  {
12952  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12953  }
12954 
12956  inline int
12958  {
12959  return (int) (m_listCustom.size());
12960  }
12961 
12962  EResultCode
12964  addCustom (
12965  CParameter * pValue);
12966 
12967 
12968 };
12969 
12970 
13017 class CImpinjDirectionReporting : public CParameter
13018 {
13019  public:
13021  ~CImpinjDirectionReporting (void);
13022 
13025 
13026  static const CFieldDescriptor * const
13027  s_apFieldDescriptorTable[];
13028 
13029  static const CTypeDescriptor
13030  s_typeDescriptor;
13031 
13032  void
13033  decodeFields (
13034  CDecoderStream * pDecoderStream);
13035 
13036  void
13037  assimilateSubParameters (
13038  CErrorDetails * pError);
13039 
13040  void
13041  encode (
13042  CEncoderStream * pEncoderStream) const;
13043 
13044 
13045  llrp_bool_t
13046  isAllowedIn (
13047  const CTypeDescriptor * pEnclosingElementType) const;
13048 
13049 
13050  static CElement *
13051  s_construct (void);
13052 
13053  static void
13054  s_decodeFields (
13055  CDecoderStream * pDecoderStream,
13056  CElement * pElement);
13058 
13059 
13060  protected:
13061  llrp_u1_t m_EnableUpdateReport;
13062 
13065  public:
13066  static const CFieldDescriptor
13067  s_fdEnableUpdateReport;
13069 
13071  inline llrp_u1_t
13073  {
13074  return m_EnableUpdateReport;
13075  }
13076 
13078  inline void
13080  llrp_u1_t value)
13081  {
13082  m_EnableUpdateReport = value;
13083  }
13084 
13085 
13086  protected:
13087  llrp_u1_t m_EnableEntryReport;
13088 
13091  public:
13092  static const CFieldDescriptor
13093  s_fdEnableEntryReport;
13095 
13097  inline llrp_u1_t
13099  {
13100  return m_EnableEntryReport;
13101  }
13102 
13104  inline void
13106  llrp_u1_t value)
13107  {
13108  m_EnableEntryReport = value;
13109  }
13110 
13111 
13112  protected:
13113  llrp_u1_t m_EnableExitReport;
13114 
13117  public:
13118  static const CFieldDescriptor
13119  s_fdEnableExitReport;
13121 
13123  inline llrp_u1_t
13125  {
13126  return m_EnableExitReport;
13127  }
13128 
13130  inline void
13132  llrp_u1_t value)
13133  {
13134  m_EnableExitReport = value;
13135  }
13136 
13137 
13138  protected:
13139  llrp_u1_t m_EnableDiagnosticReport;
13140 
13143  public:
13144  static const CFieldDescriptor
13145  s_fdEnableDiagnosticReport;
13147 
13149  inline llrp_u1_t
13151  {
13152  return m_EnableDiagnosticReport;
13153  }
13154 
13156  inline void
13158  llrp_u1_t value)
13159  {
13160  m_EnableDiagnosticReport = value;
13161  }
13162 
13163 
13164  protected:
13165  EImpinjDirectionDiagnosticReportLevel m_eDiagnosticReportLevel;
13166 
13169  public:
13170  static const CFieldDescriptor
13171  s_fdDiagnosticReportLevel;
13173 
13175  inline EImpinjDirectionDiagnosticReportLevel
13177  {
13178  return m_eDiagnosticReportLevel;
13179  }
13180 
13182  inline void
13184  EImpinjDirectionDiagnosticReportLevel value)
13185  {
13186  m_eDiagnosticReportLevel = value;
13187  }
13188 
13189 
13190  protected:
13191  std::list<CParameter *> m_listCustom;
13192 
13193  public:
13195  inline std::list<CParameter *>::iterator
13197  {
13198  return m_listCustom.begin();
13199  }
13200 
13202  inline std::list<CParameter *>::iterator
13203  endCustom (void)
13204  {
13205  return m_listCustom.end();
13206  }
13207 
13209  inline void
13211  {
13212  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13213  }
13214 
13216  inline int
13218  {
13219  return (int) (m_listCustom.size());
13220  }
13221 
13222  EResultCode
13224  addCustom (
13225  CParameter * pValue);
13226 
13227 
13228 };
13229 
13230 
13278 class CImpinjDirectionReportData : public CParameter
13279 {
13280  public:
13283 
13286 
13287  static const CFieldDescriptor * const
13288  s_apFieldDescriptorTable[];
13289 
13290  static const CTypeDescriptor
13291  s_typeDescriptor;
13292 
13293  void
13294  decodeFields (
13295  CDecoderStream * pDecoderStream);
13296 
13297  void
13298  assimilateSubParameters (
13299  CErrorDetails * pError);
13300 
13301  void
13302  encode (
13303  CEncoderStream * pEncoderStream) const;
13304 
13305 
13306  llrp_bool_t
13307  isAllowedIn (
13308  const CTypeDescriptor * pEnclosingElementType) const;
13309 
13310 
13311  static CElement *
13312  s_construct (void);
13313 
13314  static void
13315  s_decodeFields (
13316  CDecoderStream * pDecoderStream,
13317  CElement * pElement);
13319 
13320 
13321  protected:
13322  EImpinjDirectionReportType m_eType;
13323 
13326  public:
13327  static const CFieldDescriptor
13328  s_fdType;
13330 
13332  inline EImpinjDirectionReportType
13333  getType (void)
13334  {
13335  return m_eType;
13336  }
13337 
13339  inline void
13341  EImpinjDirectionReportType value)
13342  {
13343  m_eType = value;
13344  }
13345 
13346 
13347  protected:
13348  EImpinjDirectionTagPopulationStatus m_eTagPopulationStatus;
13349 
13352  public:
13353  static const CFieldDescriptor
13354  s_fdTagPopulationStatus;
13356 
13358  inline EImpinjDirectionTagPopulationStatus
13360  {
13361  return m_eTagPopulationStatus;
13362  }
13363 
13365  inline void
13367  EImpinjDirectionTagPopulationStatus value)
13368  {
13369  m_eTagPopulationStatus = value;
13370  }
13371 
13372 
13373  protected:
13374  llrp_u8_t m_FirstSeenSectorID;
13375 
13378  public:
13379  static const CFieldDescriptor
13380  s_fdFirstSeenSectorID;
13382 
13384  inline llrp_u8_t
13386  {
13387  return m_FirstSeenSectorID;
13388  }
13389 
13391  inline void
13393  llrp_u8_t value)
13394  {
13395  m_FirstSeenSectorID = value;
13396  }
13397 
13398 
13399  protected:
13400  llrp_u64_t m_FirstSeenTimestampUTC;
13401 
13404  public:
13405  static const CFieldDescriptor
13406  s_fdFirstSeenTimestampUTC;
13408 
13410  inline llrp_u64_t
13412  {
13413  return m_FirstSeenTimestampUTC;
13414  }
13415 
13417  inline void
13419  llrp_u64_t value)
13420  {
13421  m_FirstSeenTimestampUTC = value;
13422  }
13423 
13424 
13425  protected:
13426  llrp_u8_t m_LastSeenSectorID;
13427 
13430  public:
13431  static const CFieldDescriptor
13432  s_fdLastSeenSectorID;
13434 
13436  inline llrp_u8_t
13438  {
13439  return m_LastSeenSectorID;
13440  }
13441 
13443  inline void
13445  llrp_u8_t value)
13446  {
13447  m_LastSeenSectorID = value;
13448  }
13449 
13450 
13451  protected:
13452  llrp_u64_t m_LastSeenTimestampUTC;
13453 
13456  public:
13457  static const CFieldDescriptor
13458  s_fdLastSeenTimestampUTC;
13460 
13462  inline llrp_u64_t
13464  {
13465  return m_LastSeenTimestampUTC;
13466  }
13467 
13469  inline void
13471  llrp_u64_t value)
13472  {
13473  m_LastSeenTimestampUTC = value;
13474  }
13475 
13476 
13477  protected:
13478  CImpinjDirectionDiagnosticData * m_pImpinjDirectionDiagnosticData;
13479 
13480  public:
13484  {
13485  return m_pImpinjDirectionDiagnosticData;
13486  }
13487 
13489  EResultCode
13492 
13493 
13494  protected:
13495  std::list<CParameter *> m_listCustom;
13496 
13497  public:
13499  inline std::list<CParameter *>::iterator
13501  {
13502  return m_listCustom.begin();
13503  }
13504 
13506  inline std::list<CParameter *>::iterator
13507  endCustom (void)
13508  {
13509  return m_listCustom.end();
13510  }
13511 
13513  inline void
13515  {
13516  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13517  }
13518 
13520  inline int
13522  {
13523  return (int) (m_listCustom.size());
13524  }
13525 
13526  EResultCode
13528  addCustom (
13529  CParameter * pValue);
13530 
13531 
13532 };
13533 
13534 
13557 class CImpinjDirectionDiagnosticData : public CParameter
13558 {
13559  public:
13562 
13565 
13566  static const CFieldDescriptor * const
13567  s_apFieldDescriptorTable[];
13568 
13569  static const CTypeDescriptor
13570  s_typeDescriptor;
13571 
13572  void
13573  decodeFields (
13574  CDecoderStream * pDecoderStream);
13575 
13576  void
13577  assimilateSubParameters (
13578  CErrorDetails * pError);
13579 
13580  void
13581  encode (
13582  CEncoderStream * pEncoderStream) const;
13583 
13584 
13585  llrp_bool_t
13586  isAllowedIn (
13587  const CTypeDescriptor * pEnclosingElementType) const;
13588 
13589 
13590  static CElement *
13591  s_construct (void);
13592 
13593  static void
13594  s_decodeFields (
13595  CDecoderStream * pDecoderStream,
13596  CElement * pElement);
13598 
13599 
13600  protected:
13601  llrp_u32v_t m_Metric;
13602 
13605  public:
13606  static const CFieldDescriptor
13607  s_fdMetric;
13609 
13611  inline llrp_u32v_t
13612  getMetric (void)
13613  {
13614  return m_Metric;
13615  }
13616 
13618  inline void
13620  llrp_u32v_t value)
13621  {
13622  m_Metric = value;
13623  }
13624 
13625 
13626 };
13627 
13628 
13653 class CImpinjxArrayDirectionCapabilities : public CParameter
13654 {
13655  public:
13658 
13661 
13662  static const CFieldDescriptor * const
13663  s_apFieldDescriptorTable[];
13664 
13665  static const CTypeDescriptor
13666  s_typeDescriptor;
13667 
13668  void
13669  decodeFields (
13670  CDecoderStream * pDecoderStream);
13671 
13672  void
13673  assimilateSubParameters (
13674  CErrorDetails * pError);
13675 
13676  void
13677  encode (
13678  CEncoderStream * pEncoderStream) const;
13679 
13680 
13681  llrp_bool_t
13682  isAllowedIn (
13683  const CTypeDescriptor * pEnclosingElementType) const;
13684 
13685 
13686  static CElement *
13687  s_construct (void);
13688 
13689  static void
13690  s_decodeFields (
13691  CDecoderStream * pDecoderStream,
13692  CElement * pElement);
13694 
13695 
13696  protected:
13697  llrp_u16_t m_SystemTagPopulationLimitHighSensitivity;
13698 
13701  public:
13702  static const CFieldDescriptor
13703  s_fdSystemTagPopulationLimitHighSensitivity;
13705 
13707  inline llrp_u16_t
13709  {
13710  return m_SystemTagPopulationLimitHighSensitivity;
13711  }
13712 
13714  inline void
13716  llrp_u16_t value)
13717  {
13718  m_SystemTagPopulationLimitHighSensitivity = value;
13719  }
13720 
13721 
13722  protected:
13723  llrp_u16_t m_SystemTagPopulationLimitHighPerformance;
13724 
13727  public:
13728  static const CFieldDescriptor
13729  s_fdSystemTagPopulationLimitHighPerformance;
13731 
13733  inline llrp_u16_t
13735  {
13736  return m_SystemTagPopulationLimitHighPerformance;
13737  }
13738 
13740  inline void
13742  llrp_u16_t value)
13743  {
13744  m_SystemTagPopulationLimitHighPerformance = value;
13745  }
13746 
13747 
13748  protected:
13749  std::list<CParameter *> m_listCustom;
13750 
13751  public:
13753  inline std::list<CParameter *>::iterator
13755  {
13756  return m_listCustom.begin();
13757  }
13758 
13760  inline std::list<CParameter *>::iterator
13761  endCustom (void)
13762  {
13763  return m_listCustom.end();
13764  }
13765 
13767  inline void
13769  {
13770  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13771  }
13772 
13774  inline int
13776  {
13777  return (int) (m_listCustom.size());
13778  }
13779 
13780  EResultCode
13782  addCustom (
13783  CParameter * pValue);
13784 
13785 
13786 };
13787 
13788 
13814 class CImpinjIntelligentAntennaManagement : public CParameter
13815 {
13816  public:
13819 
13822 
13823  static const CFieldDescriptor * const
13824  s_apFieldDescriptorTable[];
13825 
13826  static const CTypeDescriptor
13827  s_typeDescriptor;
13828 
13829  void
13830  decodeFields (
13831  CDecoderStream * pDecoderStream);
13832 
13833  void
13834  assimilateSubParameters (
13835  CErrorDetails * pError);
13836 
13837  void
13838  encode (
13839  CEncoderStream * pEncoderStream) const;
13840 
13841 
13842  llrp_bool_t
13843  isAllowedIn (
13844  const CTypeDescriptor * pEnclosingElementType) const;
13845 
13846 
13847  static CElement *
13848  s_construct (void);
13849 
13850  static void
13851  s_decodeFields (
13852  CDecoderStream * pDecoderStream,
13853  CElement * pElement);
13855 
13856 
13857  protected:
13858  EImpinjIntelligentAntennaMode m_eManagementEnabled;
13859 
13862  public:
13863  static const CFieldDescriptor
13864  s_fdManagementEnabled;
13866 
13868  inline EImpinjIntelligentAntennaMode
13870  {
13871  return m_eManagementEnabled;
13872  }
13873 
13875  inline void
13877  EImpinjIntelligentAntennaMode value)
13878  {
13879  m_eManagementEnabled = value;
13880  }
13881 
13882 
13883  protected:
13884  std::list<CParameter *> m_listCustom;
13885 
13886  public:
13888  inline std::list<CParameter *>::iterator
13890  {
13891  return m_listCustom.begin();
13892  }
13893 
13895  inline std::list<CParameter *>::iterator
13896  endCustom (void)
13897  {
13898  return m_listCustom.end();
13899  }
13900 
13902  inline void
13904  {
13905  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13906  }
13907 
13909  inline int
13911  {
13912  return (int) (m_listCustom.size());
13913  }
13914 
13915  EResultCode
13917  addCustom (
13918  CParameter * pValue);
13919 
13920 
13921 };
13922 
13923 
13950 class CImpinjTransmitPower : public CParameter
13951 {
13952  public:
13953  CImpinjTransmitPower (void);
13954  ~CImpinjTransmitPower (void);
13955 
13958 
13959  static const CFieldDescriptor * const
13960  s_apFieldDescriptorTable[];
13961 
13962  static const CTypeDescriptor
13963  s_typeDescriptor;
13964 
13965  void
13966  decodeFields (
13967  CDecoderStream * pDecoderStream);
13968 
13969  void
13970  assimilateSubParameters (
13971  CErrorDetails * pError);
13972 
13973  void
13974  encode (
13975  CEncoderStream * pEncoderStream) const;
13976 
13977 
13978  llrp_bool_t
13979  isAllowedIn (
13980  const CTypeDescriptor * pEnclosingElementType) const;
13981 
13982 
13983  static CElement *
13984  s_construct (void);
13985 
13986  static void
13987  s_decodeFields (
13988  CDecoderStream * pDecoderStream,
13989  CElement * pElement);
13991 
13992 
13993  protected:
13994  llrp_u16_t m_TransmitPower;
13995 
13998  public:
13999  static const CFieldDescriptor
14000  s_fdTransmitPower;
14002 
14004  inline llrp_u16_t
14006  {
14007  return m_TransmitPower;
14008  }
14009 
14011  inline void
14013  llrp_u16_t value)
14014  {
14015  m_TransmitPower = value;
14016  }
14017 
14018 
14019  protected:
14020  std::list<CParameter *> m_listCustom;
14021 
14022  public:
14024  inline std::list<CParameter *>::iterator
14026  {
14027  return m_listCustom.begin();
14028  }
14029 
14031  inline std::list<CParameter *>::iterator
14032  endCustom (void)
14033  {
14034  return m_listCustom.end();
14035  }
14036 
14038  inline void
14040  {
14041  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14042  }
14043 
14045  inline int
14047  {
14048  return (int) (m_listCustom.size());
14049  }
14050 
14051  EResultCode
14053  addCustom (
14054  CParameter * pValue);
14055 
14056 
14057 };
14058 
14059 
14086 class CImpinjPolarizationControl : public CParameter
14087 {
14088  public:
14091 
14094 
14095  static const CFieldDescriptor * const
14096  s_apFieldDescriptorTable[];
14097 
14098  static const CTypeDescriptor
14099  s_typeDescriptor;
14100 
14101  void
14102  decodeFields (
14103  CDecoderStream * pDecoderStream);
14104 
14105  void
14106  assimilateSubParameters (
14107  CErrorDetails * pError);
14108 
14109  void
14110  encode (
14111  CEncoderStream * pEncoderStream) const;
14112 
14113 
14114  llrp_bool_t
14115  isAllowedIn (
14116  const CTypeDescriptor * pEnclosingElementType) const;
14117 
14118 
14119  static CElement *
14120  s_construct (void);
14121 
14122  static void
14123  s_decodeFields (
14124  CDecoderStream * pDecoderStream,
14125  CElement * pElement);
14127 
14128 
14129  protected:
14130  llrp_u1_t m_PolarizationControlEnabled;
14131 
14134  public:
14135  static const CFieldDescriptor
14136  s_fdPolarizationControlEnabled;
14138 
14140  inline llrp_u1_t
14142  {
14143  return m_PolarizationControlEnabled;
14144  }
14145 
14147  inline void
14149  llrp_u1_t value)
14150  {
14151  m_PolarizationControlEnabled = value;
14152  }
14153 
14154 
14155  protected:
14156  std::list<CParameter *> m_listCustom;
14157 
14158  public:
14160  inline std::list<CParameter *>::iterator
14162  {
14163  return m_listCustom.begin();
14164  }
14165 
14167  inline std::list<CParameter *>::iterator
14168  endCustom (void)
14169  {
14170  return m_listCustom.end();
14171  }
14172 
14174  inline void
14176  {
14177  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14178  }
14179 
14181  inline int
14183  {
14184  return (int) (m_listCustom.size());
14185  }
14186 
14187  EResultCode
14189  addCustom (
14190  CParameter * pValue);
14191 
14192 
14193 };
14194 
14195 
14220 class CImpinjAntennaCapabilities : public CParameter
14221 {
14222  public:
14225 
14228 
14229  static const CFieldDescriptor * const
14230  s_apFieldDescriptorTable[];
14231 
14232  static const CTypeDescriptor
14233  s_typeDescriptor;
14234 
14235  void
14236  decodeFields (
14237  CDecoderStream * pDecoderStream);
14238 
14239  void
14240  assimilateSubParameters (
14241  CErrorDetails * pError);
14242 
14243  void
14244  encode (
14245  CEncoderStream * pEncoderStream) const;
14246 
14247 
14248  llrp_bool_t
14249  isAllowedIn (
14250  const CTypeDescriptor * pEnclosingElementType) const;
14251 
14252 
14253  static CElement *
14254  s_construct (void);
14255 
14256  static void
14257  s_decodeFields (
14258  CDecoderStream * pDecoderStream,
14259  CElement * pElement);
14261 
14262 
14263  protected:
14264  std::list<CImpinjAntennaPolarizationCapability *> m_listImpinjAntennaPolarizationCapability;
14265 
14266  public:
14268  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
14270  {
14271  return m_listImpinjAntennaPolarizationCapability.begin();
14272  }
14273 
14275  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
14277  {
14278  return m_listImpinjAntennaPolarizationCapability.end();
14279  }
14280 
14282  inline void
14284  {
14285  clearSubParameterList ((tListOfParameters *) &m_listImpinjAntennaPolarizationCapability);
14286  }
14287 
14289  inline int
14291  {
14292  return (int) (m_listImpinjAntennaPolarizationCapability.size());
14293  }
14294 
14295  EResultCode
14299 
14300 
14301  protected:
14302  std::list<CParameter *> m_listCustom;
14303 
14304  public:
14306  inline std::list<CParameter *>::iterator
14308  {
14309  return m_listCustom.begin();
14310  }
14311 
14313  inline std::list<CParameter *>::iterator
14314  endCustom (void)
14315  {
14316  return m_listCustom.end();
14317  }
14318 
14320  inline void
14322  {
14323  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14324  }
14325 
14327  inline int
14329  {
14330  return (int) (m_listCustom.size());
14331  }
14332 
14333  EResultCode
14335  addCustom (
14336  CParameter * pValue);
14337 
14338 
14339 };
14340 
14341 
14366 class CImpinjAntennaPolarizationCapability : public CParameter
14367 {
14368  public:
14371 
14374 
14375  static const CFieldDescriptor * const
14376  s_apFieldDescriptorTable[];
14377 
14378  static const CTypeDescriptor
14379  s_typeDescriptor;
14380 
14381  void
14382  decodeFields (
14383  CDecoderStream * pDecoderStream);
14384 
14385  void
14386  assimilateSubParameters (
14387  CErrorDetails * pError);
14388 
14389  void
14390  encode (
14391  CEncoderStream * pEncoderStream) const;
14392 
14393 
14394  llrp_bool_t
14395  isAllowedIn (
14396  const CTypeDescriptor * pEnclosingElementType) const;
14397 
14398 
14399  static CElement *
14400  s_construct (void);
14401 
14402  static void
14403  s_decodeFields (
14404  CDecoderStream * pDecoderStream,
14405  CElement * pElement);
14407 
14408 
14409  protected:
14410  EImpinjAntennaPolarizationType m_eType;
14411 
14414  public:
14415  static const CFieldDescriptor
14416  s_fdType;
14418 
14420  inline EImpinjAntennaPolarizationType
14421  getType (void)
14422  {
14423  return m_eType;
14424  }
14425 
14427  inline void
14429  EImpinjAntennaPolarizationType value)
14430  {
14431  m_eType = value;
14432  }
14433 
14434 
14435  protected:
14436  llrp_u16_t m_AntennaIDOffset;
14437 
14440  public:
14441  static const CFieldDescriptor
14442  s_fdAntennaIDOffset;
14444 
14446  inline llrp_u16_t
14448  {
14449  return m_AntennaIDOffset;
14450  }
14451 
14453  inline void
14455  llrp_u16_t value)
14456  {
14457  m_AntennaIDOffset = value;
14458  }
14459 
14460 
14461  protected:
14462  std::list<CParameter *> m_listCustom;
14463 
14464  public:
14466  inline std::list<CParameter *>::iterator
14468  {
14469  return m_listCustom.begin();
14470  }
14471 
14473  inline std::list<CParameter *>::iterator
14474  endCustom (void)
14475  {
14476  return m_listCustom.end();
14477  }
14478 
14480  inline void
14482  {
14483  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14484  }
14485 
14487  inline int
14489  {
14490  return (int) (m_listCustom.size());
14491  }
14492 
14493  EResultCode
14495  addCustom (
14496  CParameter * pValue);
14497 
14498 
14499 };
14500 
14501 
14525 class CImpinjDisabledAntennas : public CParameter
14526 {
14527  public:
14528  CImpinjDisabledAntennas (void);
14529  ~CImpinjDisabledAntennas (void);
14530 
14533 
14534  static const CFieldDescriptor * const
14535  s_apFieldDescriptorTable[];
14536 
14537  static const CTypeDescriptor
14538  s_typeDescriptor;
14539 
14540  void
14541  decodeFields (
14542  CDecoderStream * pDecoderStream);
14543 
14544  void
14545  assimilateSubParameters (
14546  CErrorDetails * pError);
14547 
14548  void
14549  encode (
14550  CEncoderStream * pEncoderStream) const;
14551 
14552 
14553  llrp_bool_t
14554  isAllowedIn (
14555  const CTypeDescriptor * pEnclosingElementType) const;
14556 
14557 
14558  static CElement *
14559  s_construct (void);
14560 
14561  static void
14562  s_decodeFields (
14563  CDecoderStream * pDecoderStream,
14564  CElement * pElement);
14566 
14567 
14568  protected:
14569  llrp_u16v_t m_AntennaIDs;
14570 
14573  public:
14574  static const CFieldDescriptor
14575  s_fdAntennaIDs;
14577 
14579  inline llrp_u16v_t
14581  {
14582  return m_AntennaIDs;
14583  }
14584 
14586  inline void
14588  llrp_u16v_t value)
14589  {
14590  m_AntennaIDs = value;
14591  }
14592 
14593 
14594  protected:
14595  std::list<CParameter *> m_listCustom;
14596 
14597  public:
14599  inline std::list<CParameter *>::iterator
14601  {
14602  return m_listCustom.begin();
14603  }
14604 
14606  inline std::list<CParameter *>::iterator
14607  endCustom (void)
14608  {
14609  return m_listCustom.end();
14610  }
14611 
14613  inline void
14615  {
14616  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14617  }
14618 
14620  inline int
14622  {
14623  return (int) (m_listCustom.size());
14624  }
14625 
14626  EResultCode
14628  addCustom (
14629  CParameter * pValue);
14630 
14631 
14632 };
14633 
14634 
14659 class CImpinjTIDParity : public CParameter
14660 {
14661  public:
14662  CImpinjTIDParity (void);
14663  ~CImpinjTIDParity (void);
14664 
14667 
14668  static const CFieldDescriptor * const
14669  s_apFieldDescriptorTable[];
14670 
14671  static const CTypeDescriptor
14672  s_typeDescriptor;
14673 
14674  void
14675  decodeFields (
14676  CDecoderStream * pDecoderStream);
14677 
14678  void
14679  assimilateSubParameters (
14680  CErrorDetails * pError);
14681 
14682  void
14683  encode (
14684  CEncoderStream * pEncoderStream) const;
14685 
14686 
14687  llrp_bool_t
14688  isAllowedIn (
14689  const CTypeDescriptor * pEnclosingElementType) const;
14690 
14691 
14692  static CElement *
14693  s_construct (void);
14694 
14695  static void
14696  s_decodeFields (
14697  CDecoderStream * pDecoderStream,
14698  CElement * pElement);
14700 
14701 
14702  protected:
14703  llrp_u1_t m_ParityError;
14704 
14707  public:
14708  static const CFieldDescriptor
14709  s_fdParityError;
14711 
14713  inline llrp_u1_t
14715  {
14716  return m_ParityError;
14717  }
14718 
14720  inline void
14722  llrp_u1_t value)
14723  {
14724  m_ParityError = value;
14725  }
14726 
14727 
14728  protected:
14729  std::list<CParameter *> m_listCustom;
14730 
14731  public:
14733  inline std::list<CParameter *>::iterator
14735  {
14736  return m_listCustom.begin();
14737  }
14738 
14740  inline std::list<CParameter *>::iterator
14741  endCustom (void)
14742  {
14743  return m_listCustom.end();
14744  }
14745 
14747  inline void
14749  {
14750  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14751  }
14752 
14754  inline int
14756  {
14757  return (int) (m_listCustom.size());
14758  }
14759 
14760  EResultCode
14762  addCustom (
14763  CParameter * pValue);
14764 
14765 
14766 };
14767 
14768 
14799 class CImpinjMarginRead : public CParameter
14800 {
14801  public:
14802  CImpinjMarginRead (void);
14803  ~CImpinjMarginRead (void);
14804 
14807 
14808  static const CFieldDescriptor * const
14809  s_apFieldDescriptorTable[];
14810 
14811  static const CTypeDescriptor
14812  s_typeDescriptor;
14813 
14814  void
14815  decodeFields (
14816  CDecoderStream * pDecoderStream);
14817 
14818  void
14819  assimilateSubParameters (
14820  CErrorDetails * pError);
14821 
14822  void
14823  encode (
14824  CEncoderStream * pEncoderStream) const;
14825 
14826 
14827  llrp_bool_t
14828  isAllowedIn (
14829  const CTypeDescriptor * pEnclosingElementType) const;
14830 
14831 
14832  static CElement *
14833  s_construct (void);
14834 
14835  static void
14836  s_decodeFields (
14837  CDecoderStream * pDecoderStream,
14838  CElement * pElement);
14840 
14841 
14842  protected:
14843  llrp_u16_t m_OpSpecID;
14844 
14847  public:
14848  static const CFieldDescriptor
14849  s_fdOpSpecID;
14851 
14853  inline llrp_u16_t
14855  {
14856  return m_OpSpecID;
14857  }
14858 
14860  inline void
14862  llrp_u16_t value)
14863  {
14864  m_OpSpecID = value;
14865  }
14866 
14867 
14868  protected:
14869  llrp_u32_t m_AccessPassword;
14870 
14873  public:
14874  static const CFieldDescriptor
14875  s_fdAccessPassword;
14877 
14879  inline llrp_u32_t
14881  {
14882  return m_AccessPassword;
14883  }
14884 
14886  inline void
14888  llrp_u32_t value)
14889  {
14890  m_AccessPassword = value;
14891  }
14892 
14893 
14894  protected:
14895  llrp_u2_t m_MB;
14896 
14899  public:
14900  static const CFieldDescriptor
14901  s_fdMB;
14903 
14905  inline llrp_u2_t
14906  getMB (void)
14907  {
14908  return m_MB;
14909  }
14910 
14912  inline void
14914  llrp_u2_t value)
14915  {
14916  m_MB = value;
14917  }
14918 
14919 
14920  protected:
14921  llrp_u16_t m_BitPointer;
14922 
14925  public:
14926  static const CFieldDescriptor
14927  s_fdBitPointer;
14929 
14931  inline llrp_u16_t
14933  {
14934  return m_BitPointer;
14935  }
14936 
14938  inline void
14940  llrp_u16_t value)
14941  {
14942  m_BitPointer = value;
14943  }
14944 
14945 
14946  protected:
14947  llrp_u8_t m_BitLength;
14948 
14951  public:
14952  static const CFieldDescriptor
14953  s_fdBitLength;
14955 
14957  inline llrp_u8_t
14959  {
14960  return m_BitLength;
14961  }
14962 
14964  inline void
14966  llrp_u8_t value)
14967  {
14968  m_BitLength = value;
14969  }
14970 
14971 
14972  protected:
14973  llrp_u16v_t m_Mask;
14974 
14977  public:
14978  static const CFieldDescriptor
14979  s_fdMask;
14981 
14983  inline llrp_u16v_t
14984  getMask (void)
14985  {
14986  return m_Mask;
14987  }
14988 
14990  inline void
14992  llrp_u16v_t value)
14993  {
14994  m_Mask = value;
14995  }
14996 
14997 
14998  protected:
14999  std::list<CParameter *> m_listCustom;
15000 
15001  public:
15003  inline std::list<CParameter *>::iterator
15005  {
15006  return m_listCustom.begin();
15007  }
15008 
15010  inline std::list<CParameter *>::iterator
15011  endCustom (void)
15012  {
15013  return m_listCustom.end();
15014  }
15015 
15017  inline void
15019  {
15020  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15021  }
15022 
15024  inline int
15026  {
15027  return (int) (m_listCustom.size());
15028  }
15029 
15030  EResultCode
15032  addCustom (
15033  CParameter * pValue);
15034 
15035 
15036 };
15037 
15038 
15064 class CImpinjMarginReadOpSpecResult : public CParameter
15065 {
15066  public:
15069 
15072 
15073  static const CFieldDescriptor * const
15074  s_apFieldDescriptorTable[];
15075 
15076  static const CTypeDescriptor
15077  s_typeDescriptor;
15078 
15079  void
15080  decodeFields (
15081  CDecoderStream * pDecoderStream);
15082 
15083  void
15084  assimilateSubParameters (
15085  CErrorDetails * pError);
15086 
15087  void
15088  encode (
15089  CEncoderStream * pEncoderStream) const;
15090 
15091 
15092  llrp_bool_t
15093  isAllowedIn (
15094  const CTypeDescriptor * pEnclosingElementType) const;
15095 
15096 
15097  static CElement *
15098  s_construct (void);
15099 
15100  static void
15101  s_decodeFields (
15102  CDecoderStream * pDecoderStream,
15103  CElement * pElement);
15105 
15106 
15107  protected:
15108  EImpinjMarginReadResultType m_eResult;
15109 
15112  public:
15113  static const CFieldDescriptor
15114  s_fdResult;
15116 
15118  inline EImpinjMarginReadResultType
15119  getResult (void)
15120  {
15121  return m_eResult;
15122  }
15123 
15125  inline void
15127  EImpinjMarginReadResultType value)
15128  {
15129  m_eResult = value;
15130  }
15131 
15132 
15133  protected:
15134  llrp_u16_t m_OpSpecID;
15135 
15138  public:
15139  static const CFieldDescriptor
15140  s_fdOpSpecID;
15142 
15144  inline llrp_u16_t
15146  {
15147  return m_OpSpecID;
15148  }
15149 
15151  inline void
15153  llrp_u16_t value)
15154  {
15155  m_OpSpecID = value;
15156  }
15157 
15158 
15159  protected:
15160  std::list<CParameter *> m_listCustom;
15161 
15162  public:
15164  inline std::list<CParameter *>::iterator
15166  {
15167  return m_listCustom.begin();
15168  }
15169 
15171  inline std::list<CParameter *>::iterator
15172  endCustom (void)
15173  {
15174  return m_listCustom.end();
15175  }
15176 
15178  inline void
15180  {
15181  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15182  }
15183 
15185  inline int
15187  {
15188  return (int) (m_listCustom.size());
15189  }
15190 
15191  EResultCode
15193  addCustom (
15194  CParameter * pValue);
15195 
15196 
15197 };
15198 
15199 
15224 class CImpinjBLEVersion : public CParameter
15225 {
15226  public:
15227  CImpinjBLEVersion (void);
15228  ~CImpinjBLEVersion (void);
15229 
15232 
15233  static const CFieldDescriptor * const
15234  s_apFieldDescriptorTable[];
15235 
15236  static const CTypeDescriptor
15237  s_typeDescriptor;
15238 
15239  void
15240  decodeFields (
15241  CDecoderStream * pDecoderStream);
15242 
15243  void
15244  assimilateSubParameters (
15245  CErrorDetails * pError);
15246 
15247  void
15248  encode (
15249  CEncoderStream * pEncoderStream) const;
15250 
15251 
15252  llrp_bool_t
15253  isAllowedIn (
15254  const CTypeDescriptor * pEnclosingElementType) const;
15255 
15256 
15257  static CElement *
15258  s_construct (void);
15259 
15260  static void
15261  s_decodeFields (
15262  CDecoderStream * pDecoderStream,
15263  CElement * pElement);
15265 
15266 
15267  protected:
15268  llrp_utf8v_t m_FirmwareVersion;
15269 
15272  public:
15273  static const CFieldDescriptor
15274  s_fdFirmwareVersion;
15276 
15278  inline llrp_utf8v_t
15280  {
15281  return m_FirmwareVersion;
15282  }
15283 
15285  inline void
15287  llrp_utf8v_t value)
15288  {
15289  m_FirmwareVersion = value;
15290  }
15291 
15292 
15293  protected:
15294  std::list<CParameter *> m_listCustom;
15295 
15296  public:
15298  inline std::list<CParameter *>::iterator
15300  {
15301  return m_listCustom.begin();
15302  }
15303 
15305  inline std::list<CParameter *>::iterator
15306  endCustom (void)
15307  {
15308  return m_listCustom.end();
15309  }
15310 
15312  inline void
15314  {
15315  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15316  }
15317 
15319  inline int
15321  {
15322  return (int) (m_listCustom.size());
15323  }
15324 
15325  EResultCode
15327  addCustom (
15328  CParameter * pValue);
15329 
15330 
15331 };
15332 
15333 
15357 class CImpinjLocationAlgorithmControl : public CParameter
15358 {
15359  public:
15362 
15365 
15366  static const CFieldDescriptor * const
15367  s_apFieldDescriptorTable[];
15368 
15369  static const CTypeDescriptor
15370  s_typeDescriptor;
15371 
15372  void
15373  decodeFields (
15374  CDecoderStream * pDecoderStream);
15375 
15376  void
15377  assimilateSubParameters (
15378  CErrorDetails * pError);
15379 
15380  void
15381  encode (
15382  CEncoderStream * pEncoderStream) const;
15383 
15384 
15385  llrp_bool_t
15386  isAllowedIn (
15387  const CTypeDescriptor * pEnclosingElementType) const;
15388 
15389 
15390  static CElement *
15391  s_construct (void);
15392 
15393  static void
15394  s_decodeFields (
15395  CDecoderStream * pDecoderStream,
15396  CElement * pElement);
15398 
15399 
15400  protected:
15401  llrp_u32v_t m_ControlData;
15402 
15405  public:
15406  static const CFieldDescriptor
15407  s_fdControlData;
15409 
15411  inline llrp_u32v_t
15413  {
15414  return m_ControlData;
15415  }
15416 
15418  inline void
15420  llrp_u32v_t value)
15421  {
15422  m_ControlData = value;
15423  }
15424 
15425 
15426  protected:
15427  std::list<CParameter *> m_listCustom;
15428 
15429  public:
15431  inline std::list<CParameter *>::iterator
15433  {
15434  return m_listCustom.begin();
15435  }
15436 
15438  inline std::list<CParameter *>::iterator
15439  endCustom (void)
15440  {
15441  return m_listCustom.end();
15442  }
15443 
15445  inline void
15447  {
15448  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15449  }
15450 
15452  inline int
15454  {
15455  return (int) (m_listCustom.size());
15456  }
15457 
15458  EResultCode
15460  addCustom (
15461  CParameter * pValue);
15462 
15463 
15464 };
15465 
15466 
15503 class CImpinjRFPowerSweep : public CParameter
15504 {
15505  public:
15506  CImpinjRFPowerSweep (void);
15507  ~CImpinjRFPowerSweep (void);
15508 
15511 
15512  static const CFieldDescriptor * const
15513  s_apFieldDescriptorTable[];
15514 
15515  static const CTypeDescriptor
15516  s_typeDescriptor;
15517 
15518  void
15519  decodeFields (
15520  CDecoderStream * pDecoderStream);
15521 
15522  void
15523  assimilateSubParameters (
15524  CErrorDetails * pError);
15525 
15526  void
15527  encode (
15528  CEncoderStream * pEncoderStream) const;
15529 
15530 
15531  llrp_bool_t
15532  isAllowedIn (
15533  const CTypeDescriptor * pEnclosingElementType) const;
15534 
15535 
15536  static CElement *
15537  s_construct (void);
15538 
15539  static void
15540  s_decodeFields (
15541  CDecoderStream * pDecoderStream,
15542  CElement * pElement);
15544 
15545 
15546  protected:
15547  llrp_u1_t m_EnableRFPowerSweep;
15548 
15551  public:
15552  static const CFieldDescriptor
15553  s_fdEnableRFPowerSweep;
15555 
15557  inline llrp_u1_t
15559  {
15560  return m_EnableRFPowerSweep;
15561  }
15562 
15564  inline void
15566  llrp_u1_t value)
15567  {
15568  m_EnableRFPowerSweep = value;
15569  }
15570 
15571 
15572  protected:
15573  llrp_u16_t m_MinimumPowerLevel;
15574 
15577  public:
15578  static const CFieldDescriptor
15579  s_fdMinimumPowerLevel;
15581 
15583  inline llrp_u16_t
15585  {
15586  return m_MinimumPowerLevel;
15587  }
15588 
15590  inline void
15592  llrp_u16_t value)
15593  {
15594  m_MinimumPowerLevel = value;
15595  }
15596 
15597 
15598  protected:
15599  llrp_u16_t m_PowerLevelStepSize;
15600 
15603  public:
15604  static const CFieldDescriptor
15605  s_fdPowerLevelStepSize;
15607 
15609  inline llrp_u16_t
15611  {
15612  return m_PowerLevelStepSize;
15613  }
15614 
15616  inline void
15618  llrp_u16_t value)
15619  {
15620  m_PowerLevelStepSize = value;
15621  }
15622 
15623 
15624  protected:
15625  std::list<CParameter *> m_listCustom;
15626 
15627  public:
15629  inline std::list<CParameter *>::iterator
15631  {
15632  return m_listCustom.begin();
15633  }
15634 
15636  inline std::list<CParameter *>::iterator
15637  endCustom (void)
15638  {
15639  return m_listCustom.end();
15640  }
15641 
15643  inline void
15645  {
15646  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15647  }
15648 
15650  inline int
15652  {
15653  return (int) (m_listCustom.size());
15654  }
15655 
15656  EResultCode
15658  addCustom (
15659  CParameter * pValue);
15660 
15661 
15662 };
15663 
15664 
15679 extern void
15681  CTypeRegistry * pTypeRegistry);
EResultCode setImpinjHubVersions(CImpinjHubVersions *pValue)
Set accessor functions for the LLRP ImpinjHubVersions sub-parameter.
CImpinjOpSpecRetryCount * getImpinjOpSpecRetryCount(void)
Get accessor functions for the LLRP ImpinjOpSpecRetryCount sub-parameter.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjLowDutyCycleMode getLowDutyCycleMode(void)
Get accessor functions for the LLRP LowDutyCycleMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjAccessSpecOrderingMode getOrderingMode(void)
Get accessor functions for the LLRP OrderingMode field.
void setSystemTagPopulationLimitHighSensitivity(llrp_u16_t value)
Set accessor functions for the LLRP SystemTagPopulationLimitHighSensitivity field.
Class Definition CImpinjTagReportContentSelector for LLRP parameter ImpinjTagReportContentSelector.
llrp_u16_t getGPOPortNum(void)
Get accessor functions for the LLRP GPOPortNum field.
llrp_u1_t getEnableExitReport(void)
Get accessor functions for the LLRP EnableExitReport field.
Class Definition CImpinjPlacementConfiguration for LLRP parameter ImpinjPlacementConfiguration.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjIntelligentAntennaManagement for LLRP parameter ImpinjIntelligentAntennaManag...
CImpinjHubVersions * getImpinjHubVersions(void)
Get accessor functions for the LLRP ImpinjHubVersions sub-parameter.
llrp_utf8v_t getRMCSentence(void)
Get accessor functions for the LLRP RMCSentence field.
void setTagAgeIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP TagAgeIntervalSeconds field.
llrp_u16_t getRetryCount(void)
Get accessor functions for the LLRP RetryCount field.
llrp_u1_t getParityError(void)
Get accessor functions for the LLRP ParityError field.
CImpinjArrayVersion * getImpinjArrayVersion(void)
Get accessor functions for the LLRP ImpinjArrayVersion sub-parameter.
Class Definition CImpinjGetQTConfigOpSpecResult for LLRP parameter ImpinjGetQTConfigOpSpecResult.
void setTxPower(llrp_u16_t value)
Set accessor functions for the LLRP TxPower field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setFieldOfView(EImpinjDirectionFieldOfView value)
Set accessor functions for the LLRP FieldOfView field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getBeaconState(void)
Get accessor functions for the LLRP BeaconState field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_s32_t getFacilityYLocationCm(void)
Get accessor functions for the LLRP FacilityYLocationCm field.
llrp_u16_t getTransmitPower(void)
Get accessor functions for the LLRP TransmitPower field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
Class Definition CImpinjInventoryConfiguration for LLRP parameter ImpinjInventoryConfiguration.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode setImpinjDirectionUserTagPopulationLimit(CImpinjDirectionUserTagPopulationLimit *pValue)
Set accessor functions for the LLRP ImpinjDirectionUserTagPopulationLimit sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjHubConnectedType getConnected(void)
Get accessor functions for the LLRP Connected field.
llrp_u16_t getBitPointer(void)
Get accessor functions for the LLRP BitPointer field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setType(EImpinjAntennaPolarizationType value)
Set accessor functions for the LLRP Type field.
Class Definition CImpinjLoopSpec for LLRP parameter ImpinjLoopSpec.
Class Definition CImpinjSubRegulatoryRegion for LLRP parameter ImpinjSubRegulatoryRegion.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjTransmitPower for LLRP parameter ImpinjTransmitPower.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u32v_t getControlData(void)
Get accessor functions for the LLRP ControlData field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s32_t getYAxis(void)
Get accessor functions for the LLRP YAxis field.
llrp_u64_t getLastSeenTimestampUTC(void)
Get accessor functions for the LLRP LastSeenTimestampUTC field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u8_t getLastSeenSectorID(void)
Get accessor functions for the LLRP LastSeenSectorID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setConnected(EImpinjHubConnectedType value)
Set accessor functions for the LLRP Connected field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setModelName(llrp_utf8v_t value)
Set accessor functions for the LLRP ModelName field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setBeaconState(llrp_u1_t value)
Set accessor functions for the LLRP BeaconState field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjFixedFrequencyList for LLRP parameter ImpinjFixedFrequencyList.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode setImpinjDisabledAntennas(CImpinjDisabledAntennas *pValue)
Set accessor functions for the LLRP ImpinjDisabledAntennas sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CIMPINJ_ENABLE_EXTENSIONS_RESPONSE for LLRP message IMPINJ_ENABLE_EXTENSIONS_RESPONS...
Class Definition CImpinjTiltConfiguration for LLRP parameter ImpinjTiltConfiguration.
llrp_u16v_t getTID(void)
Get accessor functions for the LLRP TID field.
EResultCode setImpinjEnableGPSCoordinates(CImpinjEnableGPSCoordinates *pValue)
Set accessor functions for the LLRP ImpinjEnableGPSCoordinates sub-parameter.
EResultCode setImpinjDirectionReporting(CImpinjDirectionReporting *pValue)
Set accessor functions for the LLRP ImpinjDirectionReporting sub-parameter.
void setSupportsTISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsTISpecs field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u1_t getEnableExitReport(void)
Get accessor functions for the LLRP EnableExitReport field.
llrp_s32_t getZAxis(void)
Get accessor functions for the LLRP ZAxis field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16_t getReadCount(void)
Get accessor functions for the LLRP ReadCount field.
void setRFMode(EImpinjDirectionRFMode value)
Set accessor functions for the LLRP RFMode field.
void setResult(EImpinjMarginReadResultType value)
Set accessor functions for the LLRP Result field.
llrp_utf8v_t getPCBAVersion(void)
Get accessor functions for the LLRP PCBAVersion field.
CImpinjEnableRFPhaseAngle * getImpinjEnableRFPhaseAngle(void)
Get accessor functions for the LLRP ImpinjEnableRFPhaseAngle sub-parameter.
void clearImpinjArrayVersion(void)
Clears the LLRP ImpinjArrayVersion sub-parameter list.
EImpinjDirectionFieldOfView getFieldOfView(void)
Get accessor functions for the LLRP FieldOfView field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setEnableAntennaAttemptNotification(llrp_u1_t value)
Set accessor functions for the LLRP EnableAntennaAttemptNotification field.
llrp_u16_t getTagAgeIntervalSeconds(void)
Get accessor functions for the LLRP TagAgeIntervalSeconds field.
llrp_u16v_t getEnabledSectorIDs(void)
Get accessor functions for the LLRP EnabledSectorIDs field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setModeIndex(llrp_u16_t value)
Set accessor functions for the LLRP ModeIndex field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setAntennaEventDisconnected(llrp_u64_t value)
Set accessor functions for the LLRP AntennaEventDisconnected field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjRFPowerSweep for LLRP parameter ImpinjRFPowerSweep.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setRFDopplerFrequencyMode(EImpinjRFDopplerFrequencyMode value)
Set accessor functions for the LLRP RFDopplerFrequencyMode field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
void setPCBAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP PCBAVersion field.
Class Definition CImpinjAntennaPolarizationCapability for LLRP parameter ImpinjAntennaPolarizationCap...
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
CImpinjGGASentence * getImpinjGGASentence(void)
Get accessor functions for the LLRP ImpinjGGASentence sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setSupportsDISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsDISpecs field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjReducedPowerMode getReducedPowerMode(void)
Get accessor functions for the LLRP ReducedPowerMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjDisabledAntennas * getImpinjDisabledAntennas(void)
Get accessor functions for the LLRP ImpinjDisabledAntennas sub-parameter.
void setResult(EImpinjGetBlockPermalockStatusResultType value)
Set accessor functions for the LLRP Result field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjTxPower for LLRP parameter ImpinjTxPower.
llrp_u16_t getUserTagPopulationLimit(void)
Get accessor functions for the LLRP UserTagPopulationLimit field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_utf8v_t getModelName(void)
Get accessor functions for the LLRP ModelName field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjLocationAlgorithmControl for LLRP parameter ImpinjLocationAlgorithmControl.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setMaxNumSectors(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumSectors field.
void setXAxis(llrp_s32_t value)
Set accessor functions for the LLRP XAxis field.
EResultCode setImpinjBlockWriteWordCount(CImpinjBlockWriteWordCount *pValue)
Set accessor functions for the LLRP ImpinjBlockWriteWordCount sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u8_t getFirstSeenSectorID(void)
Get accessor functions for the LLRP FirstSeenSectorID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjLISpec for LLRP parameter ImpinjLISpec.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode setImpinjDirectionSectors(CImpinjDirectionSectors *pValue)
Set accessor functions for the LLRP ImpinjDirectionSectors sub-parameter.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getLatitude(void)
Get accessor functions for the LLRP Latitude field.
EResultCode setImpinjTransmitPower(CImpinjTransmitPower *pValue)
Set accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setSerializedTIDMode(EImpinjSerializedTIDMode value)
Set accessor functions for the LLRP SerializedTIDMode field.
EResultCode setImpinjTransmitPower(CImpinjTransmitPower *pValue)
Set accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
Class Definition CImpinjDirectionReportData for LLRP parameter ImpinjDirectionReportData.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setFieldPingInterval(llrp_u16_t value)
Set accessor functions for the LLRP FieldPingInterval field.
llrp_u1_t getEnableAntennaAttemptNotification(void)
Get accessor functions for the LLRP EnableAntennaAttemptNotification field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjBLEVersion for LLRP parameter ImpinjBLEVersion.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode setImpinjLocationConfidence(CImpinjLocationConfidence *pValue)
Set accessor functions for the LLRP ImpinjLocationConfidence sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjLocationReportData for LLRP parameter ImpinjLocationReportData.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjLinkMonitorMode getLinkMonitorMode(void)
Get accessor functions for the LLRP LinkMonitorMode field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setTxPowerReportingMode(EImpinjTxPowerReportingModeEnum value)
Set accessor functions for the LLRP TxPowerReportingMode field.
void setGPIDebounceTimerMSec(llrp_u32_t value)
Set accessor functions for the LLRP GPIDebounceTimerMSec field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u1_t getEnableRFPowerSweep(void)
Get accessor functions for the LLRP EnableRFPowerSweep field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjRFPhaseAngleMode getRFPhaseAngleMode(void)
Get accessor functions for the LLRP RFPhaseAngleMode field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EImpinjTxPowerReportingModeEnum getTxPowerReportingMode(void)
Get accessor functions for the LLRP TxPowerReportingMode field.
Class Definition CImpinjDirectionConfig for LLRP parameter ImpinjDirectionConfig. ...
void setWordCount(llrp_u16_t value)
Set accessor functions for the LLRP WordCount field.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode setImpinjBLEVersion(CImpinjBLEVersion *pValue)
Set accessor functions for the LLRP ImpinjBLEVersion sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjGetQTConfigResultType getResult(void)
Get accessor functions for the LLRP Result field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjPolarizationControl for LLRP parameter ImpinjPolarizationControl.
void setFixedFrequencyMode(EImpinjFixedFrequencyMode value)
Set accessor functions for the LLRP FixedFrequencyMode field.
Class Definition CImpinjReportBufferConfiguration for LLRP parameter ImpinjReportBufferConfiguration...
void enrollImpinjTypesIntoRegistry(CTypeRegistry *pTypeRegistry)
Enrolls the types for Impinj into the LTKCPP registry.
llrp_u16_t getPowerLevelStepSize(void)
Get accessor functions for the LLRP PowerLevelStepSize field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode setImpinjC1G2LocationConfig(CImpinjC1G2LocationConfig *pValue)
Set accessor functions for the LLRP ImpinjC1G2LocationConfig sub-parameter.
void setEnableSelectGapClose(llrp_u1_t value)
Set accessor functions for the LLRP EnableSelectGapClose field.
void setFacilityYLocationCm(llrp_s32_t value)
Set accessor functions for the LLRP FacilityYLocationCm field.
CImpinjDirectionReporting * getImpinjDirectionReporting(void)
Get accessor functions for the LLRP ImpinjDirectionReporting sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setReadCount(llrp_u16_t value)
Set accessor functions for the LLRP ReadCount field.
void setEnableDiagnosticReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableDiagnosticReport field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32v_t getMetric(void)
Get accessor functions for the LLRP Metric field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode setImpinjEnableSerializedTID(CImpinjEnableSerializedTID *pValue)
Set accessor functions for the LLRP ImpinjEnableSerializedTID sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjAntennaEventHysteresis for LLRP parameter ImpinjAntennaEventHysteresis.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjLowDutyCycle for LLRP parameter ImpinjLowDutyCycle.
void setPhaseAngle(llrp_u16_t value)
Set accessor functions for the LLRP PhaseAngle field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode
Error result codes for LTK operations.
Definition: ltkcpp_base.h:583
EImpinjDirectionReportType getType(void)
Get accessor functions for the LLRP Type field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setMask(llrp_u16v_t value)
Set accessor functions for the LLRP Mask field.
std::list< CImpinjArrayVersion * >::iterator beginImpinjArrayVersion(void)
Returns the first element of the ImpinjArrayVersion sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setBlockPointer(llrp_u16_t value)
Set accessor functions for the LLRP BlockPointer field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setFacilityXLocationCm(llrp_s32_t value)
Set accessor functions for the LLRP FacilityXLocationCm field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjTIDParity * getImpinjTIDParity(void)
Get accessor functions for the LLRP ImpinjTIDParity sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjPeakRSSI for LLRP parameter ImpinjPeakRSSI.
CImpinjLocationReportData * getImpinjLocationReportData(void)
Get accessor functions for the LLRP ImpinjLocationReportData sub-parameter.
llrp_u16_t getEmptyFieldTimeout(void)
Get accessor functions for the LLRP EmptyFieldTimeout field.
void setYAxis(llrp_s32_t value)
Set accessor functions for the LLRP YAxis field.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjAdvancedGPOMode getGPOMode(void)
Get accessor functions for the LLRP GPOMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setRMCSentence(llrp_utf8v_t value)
Set accessor functions for the LLRP RMCSentence field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setSession(llrp_u2_t value)
Set accessor functions for the LLRP Session field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setResult(EImpinjBlockPermalockResultType value)
Set accessor functions for the LLRP Result field.
CImpinjDirectionReportData * getImpinjDirectionReportData(void)
Get accessor functions for the LLRP ImpinjDirectionReportData sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setTagAgeIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP TagAgeIntervalSeconds field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u1_t getEnableDiagnosticReport(void)
Get accessor functions for the LLRP EnableDiagnosticReport field.
EResultCode setImpinjRMCSentence(CImpinjRMCSentence *pValue)
Set accessor functions for the LLRP ImpinjRMCSentence sub-parameter.
void setZAxis(llrp_s32_t value)
Set accessor functions for the LLRP ZAxis field.
llrp_u32_t getGPOPulseDurationMSec(void)
Get accessor functions for the LLRP GPOPulseDurationMSec field.
void setReportBufferMode(EImpinjReportBufferMode value)
Set accessor functions for the LLRP ReportBufferMode field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjBlockWriteWordCount for LLRP parameter ImpinjBlockWriteWordCount.
void setFirstSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP FirstSeenTimestampUTC field.
void setLongitude(llrp_s32_t value)
Set accessor functions for the LLRP Longitude field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CImpinjAntennaPolarizationCapability * >::iterator beginImpinjAntennaPolarizationCapability(void)
Returns the first element of the ImpinjAntennaPolarizationCapability sub-parameter list...
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
CImpinjDirectionUserTagPopulationLimit * getImpinjDirectionUserTagPopulationLimit(void)
Get accessor functions for the LLRP ImpinjDirectionUserTagPopulationLimit sub-parameter.
Class Definition CImpinjGGASentence for LLRP parameter ImpinjGGASentence.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16_t getSystemTagPopulationLimitHighPerformance(void)
Get accessor functions for the LLRP SystemTagPopulationLimitHighPerformance field.
int countC1G2Filter(void)
Count of the LLRP C1G2Filter sub-parameter list.
Class Definition CImpinjLocationReporting for LLRP parameter ImpinjLocationReporting.
Class Definition CImpinjDisabledAntennas for LLRP parameter ImpinjDisabledAntennas.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjRFPhaseAngle for LLRP parameter ImpinjRFPhaseAngle.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearC1G2Read(void)
Clears the LLRP C1G2Read sub-parameter list.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s16_t getTemperature(void)
Get accessor functions for the LLRP Temperature field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode addImpinjArrayVersion(CImpinjArrayVersion *pValue)
Add a ImpinjArrayVersion to the LLRP sub-parameter list.
void setGPIPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPIPortNum field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CIMPINJ_SAVE_SETTINGS for LLRP message IMPINJ_SAVE_SETTINGS.
void setPolarizationControlEnabled(llrp_u1_t value)
Set accessor functions for the LLRP PolarizationControlEnabled field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setRFPhaseAngleMode(EImpinjRFPhaseAngleMode value)
Set accessor functions for the LLRP RFPhaseAngleMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setResult(EImpinjGetQTConfigResultType value)
Set accessor functions for the LLRP Result field.
Class Definition CImpinjEnablePeakRSSI for LLRP parameter ImpinjEnablePeakRSSI.
Class Definition CImpinjBeaconConfiguration for LLRP parameter ImpinjBeaconConfiguration.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode setImpinjEnablePeakRSSI(CImpinjEnablePeakRSSI *pValue)
Set accessor functions for the LLRP ImpinjEnablePeakRSSI sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjC1G2LocationConfig * getImpinjC1G2LocationConfig(void)
Get accessor functions for the LLRP ImpinjC1G2LocationConfig sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setMetric(llrp_u32v_t value)
Set accessor functions for the LLRP Metric field.
CImpinjBlockWriteWordCount * getImpinjBlockWriteWordCount(void)
Get accessor functions for the LLRP ImpinjBlockWriteWordCount sub-parameter.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
void setLinkDownThreshold(llrp_u16_t value)
Set accessor functions for the LLRP LinkDownThreshold field.
Class Definition CImpinjGPSNMEASentences for LLRP parameter ImpinjGPSNMEASentences.
Class Definition CImpinjDiagnosticReport for LLRP parameter ImpinjDiagnosticReport.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjDirectionTagPopulationStatus getTagPopulationStatus(void)
Get accessor functions for the LLRP TagPopulationStatus field.
void setPersistence(EImpinjQTPersistence value)
Set accessor functions for the LLRP Persistence field.
llrp_u1_t getEnableUpdateReport(void)
Get accessor functions for the LLRP EnableUpdateReport field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setLocYCentimeters(llrp_s32_t value)
Set accessor functions for the LLRP LocYCentimeters field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getBlockPointer(void)
Get accessor functions for the LLRP BlockPointer field.
llrp_u32v_t getConfidenceData(void)
Get accessor functions for the LLRP ConfidenceData field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setLowDutyCycleMode(EImpinjLowDutyCycleMode value)
Set accessor functions for the LLRP LowDutyCycleMode field.
llrp_u16v_t getMask(void)
Get accessor functions for the LLRP Mask field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EImpinjIntelligentAntennaMode getManagementEnabled(void)
Get accessor functions for the LLRP ManagementEnabled field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjxArrayCapabilities for LLRP parameter ImpinjxArrayCapabilities.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setUpdateIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP UpdateIntervalSeconds field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjBlockPermalockOpSpecResult for LLRP parameter ImpinjBlockPermalockOpSpecResul...
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
CImpinjRMCSentence * getImpinjRMCSentence(void)
Get accessor functions for the LLRP ImpinjRMCSentence sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode setImpinjLocationConfig(CImpinjLocationConfig *pValue)
Set accessor functions for the LLRP ImpinjLocationConfig sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjArrayVersion for LLRP parameter ImpinjArrayVersion.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getMinimumPowerLevel(void)
Get accessor functions for the LLRP MinimumPowerLevel field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjBlockPermalock for LLRP parameter ImpinjBlockPermalock.
void setBitPointer(llrp_u16_t value)
Set accessor functions for the LLRP BitPointer field.
llrp_u64_t getAntennaEventConnected(void)
Get accessor functions for the LLRP AntennaEventConnected field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
EImpinjQTDataProfile getDataProfile(void)
Get accessor functions for the LLRP DataProfile field.
llrp_u1_t getSupportsTISpecs(void)
Get accessor functions for the LLRP SupportsTISpecs field.
Class Definition CImpinjInventorySearchMode for LLRP parameter ImpinjInventorySearchMode.
llrp_u16_t getSystemTagPopulationLimitHighSensitivity(void)
Get accessor functions for the LLRP SystemTagPopulationLimitHighSensitivity field.
Class Definition CImpinjSetQTConfig for LLRP parameter ImpinjSetQTConfig.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getModeIndex(void)
Get accessor functions for the LLRP ModeIndex field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableDiagnosticReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableDiagnosticReport field.
void setSerialNumber(llrp_utf8v_t value)
Set accessor functions for the LLRP SerialNumber field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u1_t getEnableEntryReport(void)
Get accessor functions for the LLRP EnableEntryReport field.
void setDopplerFrequency(llrp_s16_t value)
Set accessor functions for the LLRP DopplerFrequency field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setEnableRFPowerSweep(llrp_u1_t value)
Set accessor functions for the LLRP EnableRFPowerSweep field.
llrp_u16v_t getPermalockStatus(void)
Get accessor functions for the LLRP PermalockStatus field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setHeightCm(llrp_u16_t value)
Set accessor functions for the LLRP HeightCm field.
llrp_u1_t getSupportsDISpecs(void)
Get accessor functions for the LLRP SupportsDISpecs field.
llrp_u32_t getMaxNumSectors(void)
Get accessor functions for the LLRP MaxNumSectors field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setInventorySearchMode(EImpinjInventorySearchType value)
Set accessor functions for the LLRP InventorySearchMode field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setSerialNumber(llrp_utf8v_t value)
Set accessor functions for the LLRP SerialNumber field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjRequestedDataType getRequestedData(void)
Get accessor functions for the LLRP RequestedData field.
void setControlData(llrp_u32v_t value)
Set accessor functions for the LLRP ControlData field.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
Class Definition CImpinjLocationConfig for LLRP parameter ImpinjLocationConfig.
Class Definition CLLRPStatus for LLRP parameter LLRPStatus.
Definition: out_ltkcpp.h:18888
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableEntryReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableEntryReport field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setPCBAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP PCBAVersion field.
void setAntennaIDOffset(llrp_u16_t value)
Set accessor functions for the LLRP AntennaIDOffset field.
void setFPGAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FPGAVersion field.
void setLatitude(llrp_s32_t value)
Set accessor functions for the LLRP Latitude field.
void setRequestedData(EImpinjRequestedDataType value)
Set accessor functions for the LLRP RequestedData field.
EResultCode setImpinjEnableTxPower(CImpinjEnableTxPower *pValue)
Set accessor functions for the LLRP ImpinjEnableTxPower sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u8_t getBitLength(void)
Get accessor functions for the LLRP BitLength field.
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void setEnableAntDwellTimeLimit(llrp_u1_t value)
Set accessor functions for the LLRP EnableAntDwellTimeLimit field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
Class Definition CEPCData for LLRP parameter EPCData.
Definition: out_ltkcpp.h:14802
llrp_u16_t getComputeWindowSeconds(void)
Get accessor functions for the LLRP ComputeWindowSeconds field.
void setType(EImpinjLocationReportType value)
Set accessor functions for the LLRP Type field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_s16_t getDopplerFrequency(void)
Get accessor functions for the LLRP DopplerFrequency field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setUpdateIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP UpdateIntervalSeconds field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setPowerLevelStepSize(llrp_u16_t value)
Set accessor functions for the LLRP PowerLevelStepSize field.
EImpinjMarginReadResultType getResult(void)
Get accessor functions for the LLRP Result field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getAntennaIDOffset(void)
Get accessor functions for the LLRP AntennaIDOffset field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setGPOMode(EImpinjAdvancedGPOMode value)
Set accessor functions for the LLRP GPOMode field.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setLocXCentimeters(llrp_s32_t value)
Set accessor functions for the LLRP LocXCentimeters field.
EResultCode setImpinjAntennaEventHysteresis(CImpinjAntennaEventHysteresis *pValue)
Set accessor functions for the LLRP ImpinjAntennaEventHysteresis sub-parameter.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
int countC1G2Read(void)
Count of the LLRP C1G2Read sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CC1G2Read * >::iterator beginC1G2Read(void)
Returns the first element of the C1G2Read sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjDirectionConfig * getImpinjDirectionConfig(void)
Get accessor functions for the LLRP ImpinjDirectionConfig sub-parameter.
llrp_u16_t getLinkDownThreshold(void)
Get accessor functions for the LLRP LinkDownThreshold field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setSaveConfiguration(llrp_u1_t value)
Set accessor functions for the LLRP SaveConfiguration field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjLocationConfig * getImpinjLocationConfig(void)
Get accessor functions for the LLRP ImpinjLocationConfig sub-parameter.
llrp_u64_t getAntennaEventDisconnected(void)
Get accessor functions for the LLRP AntennaEventDisconnected field.
void setPermalockStatus(llrp_u16v_t value)
Set accessor functions for the LLRP PermalockStatus field.
Class Definition CImpinjEnableTxPower for LLRP parameter ImpinjEnableTxPower.
llrp_u16_t getFieldPingInterval(void)
Get accessor functions for the LLRP FieldPingInterval field.
Class Definition CImpinjEnableSerializedTID for LLRP parameter ImpinjEnableSerializedTID.
llrp_u16v_t getChannelList(void)
Get accessor functions for the LLRP ChannelList field.
void setEnableExitReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableExitReport field.
llrp_u16_t getTxPower(void)
Get accessor functions for the LLRP TxPower field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode setImpinjC1G2DirectionConfig(CImpinjC1G2DirectionConfig *pValue)
Set accessor functions for the LLRP ImpinjC1G2DirectionConfig sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u16_t getHubID(void)
Get accessor functions for the LLRP HubID field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setOrderingMode(EImpinjAccessSpecOrderingMode value)
Set accessor functions for the LLRP OrderingMode field.
llrp_u16_t getPhaseAngle(void)
Get accessor functions for the LLRP PhaseAngle field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setAccessRange(EImpinjQTAccessRange value)
Set accessor functions for the LLRP AccessRange field.
llrp_utf8v_t getSerialNumber(void)
Get accessor functions for the LLRP SerialNumber field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode setImpinjDirectionReportData(CImpinjDirectionReportData *pValue)
Set accessor functions for the LLRP ImpinjDirectionReportData sub-parameter.
llrp_u16_t getWordCount(void)
Get accessor functions for the LLRP WordCount field.
CImpinjC1G2DirectionConfig * getImpinjC1G2DirectionConfig(void)
Get accessor functions for the LLRP ImpinjC1G2DirectionConfig sub-parameter.
llrp_u16_t getBlockRange(void)
Get accessor functions for the LLRP BlockRange field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CImpinjAntennaPolarizationCapability * >::iterator endImpinjAntennaPolarizationCapability(void)
Returns the last element of the ImpinjAntennaPolarizationCapability sub-parameter list...
llrp_u1_t getPolarizationControlEnabled(void)
Get accessor functions for the LLRP PolarizationControlEnabled field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setRSSI(llrp_s16_t value)
Set accessor functions for the LLRP RSSI field.
Class Definition CImpinjDetailedVersion for LLRP parameter ImpinjDetailedVersion. ...
std::list< CC1G2Filter * >::iterator beginC1G2Filter(void)
Returns the first element of the C1G2Filter sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjGPSCoordinates for LLRP parameter ImpinjGPSCoordinates.
llrp_u32v_t getMetric(void)
Get accessor functions for the LLRP Metric field.
Class Definition CImpinjReaderTemperature for LLRP parameter ImpinjReaderTemperature.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setLastSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP LastSeenTimestampUTC field.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjEnableRFDopplerFrequency for LLRP parameter ImpinjEnableRFDopplerFrequency.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjHubVersions for LLRP parameter ImpinjHubVersions.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjFixedFrequencyMode getFixedFrequencyMode(void)
Get accessor functions for the LLRP FixedFrequencyMode field.
Class Definition CImpinjOpSpecRetryCount for LLRP parameter ImpinjOpSpecRetryCount.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setChannelList(llrp_u16v_t value)
Set accessor functions for the LLRP ChannelList field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode setImpinjDirectionConfig(CImpinjDirectionConfig *pValue)
Set accessor functions for the LLRP ImpinjDirectionConfig sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjxArrayDirectionCapabilities * getImpinjxArrayDirectionCapabilities(void)
Get accessor functions for the LLRP ImpinjxArrayDirectionCapabilities sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
llrp_utf8v_t getPCBAVersion(void)
Get accessor functions for the LLRP PCBAVersion field.
void setSupportsTSISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsTSISpecs field.
void setTagPopulationStatus(EImpinjDirectionTagPopulationStatus value)
Set accessor functions for the LLRP TagPopulationStatus field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16v_t getAntennaIDs(void)
Get accessor functions for the LLRP AntennaIDs field.
int countEPCData(void)
Count of the LLRP EPCData sub-parameter list.
void setFrequencyList(llrp_u32v_t value)
Set accessor functions for the LLRP FrequencyList field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjDirectionReporting for LLRP parameter ImpinjDirectionReporting.
void setTransmitPower(llrp_u16_t value)
Set accessor functions for the LLRP TransmitPower field.
llrp_u32_t getLoopCount(void)
Get accessor functions for the LLRP LoopCount field.
llrp_u1_t getEnableUpdateReport(void)
Get accessor functions for the LLRP EnableUpdateReport field.
llrp_u1_t getSaveConfiguration(void)
Get accessor functions for the LLRP SaveConfiguration field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
Class Definition CImpinjGetBlockPermalockStatus for LLRP parameter ImpinjGetBlockPermalockStatus.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setDiagnosticReportLevel(EImpinjDirectionDiagnosticReportLevel value)
Set accessor functions for the LLRP DiagnosticReportLevel field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearEPCData(void)
Clears the LLRP EPCData sub-parameter list.
std::list< CImpinjArrayVersion * >::iterator endImpinjArrayVersion(void)
Returns the last element of the ImpinjArrayVersion sub-parameter list.
Class Definition CImpinjTIDParity for LLRP parameter ImpinjTIDParity.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countImpinjArrayVersion(void)
Count of the LLRP ImpinjArrayVersion sub-parameter list.
llrp_utf8v_t getGGASentence(void)
Get accessor functions for the LLRP GGASentence field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjGetBlockPermalockStatusResultType getResult(void)
Get accessor functions for the LLRP Result field.
llrp_u1_t getEnableSelectGapClose(void)
Get accessor functions for the LLRP EnableSelectGapClose field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u64_t getBeaconDurationSeconds(void)
Get accessor functions for the LLRP BeaconDurationSeconds field.
void setBeaconDurationSeconds(llrp_u64_t value)
Set accessor functions for the LLRP BeaconDurationSeconds field.
void setRetryCount(llrp_u16_t value)
Set accessor functions for the LLRP RetryCount field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addEPCData(CEPCData *pValue)
Add a EPCData to the LLRP sub-parameter list.
void setMinimumPowerLevel(llrp_u16_t value)
Set accessor functions for the LLRP MinimumPowerLevel field.
EImpinjQTPersistence getPersistence(void)
Get accessor functions for the LLRP Persistence field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CC1G2Filter * >::iterator endC1G2Filter(void)
Returns the last element of the C1G2Filter sub-parameter list.
void setFault(EImpinjHubFaultType value)
Set accessor functions for the LLRP Fault field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjSerializedTIDMode getSerializedTIDMode(void)
Get accessor functions for the LLRP SerializedTIDMode field.
Class Definition CC1G2Read for LLRP parameter C1G2Read.
Definition: out_ltkcpp.h:21571
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
CImpinjLocationReporting * getImpinjLocationReporting(void)
Get accessor functions for the LLRP ImpinjLocationReporting sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setComputeWindowSeconds(llrp_u16_t value)
Set accessor functions for the LLRP ComputeWindowSeconds field.
void setGGASentence(llrp_utf8v_t value)
Set accessor functions for the LLRP GGASentence field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setConfidenceData(llrp_u32v_t value)
Set accessor functions for the LLRP ConfidenceData field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjAntennaAttemptEvent for LLRP parameter ImpinjAntennaAttemptEvent.
void setEnableExitReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableExitReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjDirectionSectors for LLRP parameter ImpinjDirectionSectors.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setGPSCoordinatesMode(EImpinjGPSCoordinatesMode value)
Set accessor functions for the LLRP GPSCoordinatesMode field.
EImpinjSetQTConfigResultType getResult(void)
Get accessor functions for the LLRP Result field.
CImpinjDirectionDiagnosticData * getImpinjDirectionDiagnosticData(void)
Get accessor functions for the LLRP ImpinjDirectionDiagnosticData sub-parameter.
void setBlockMask(llrp_u16v_t value)
Set accessor functions for the LLRP BlockMask field.
void setSoftwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP SoftwareVersion field.
llrp_u64_t getFirstSeenTimestampUTC(void)
Get accessor functions for the LLRP FirstSeenTimestampUTC field.
llrp_s32_t getLongitude(void)
Get accessor functions for the LLRP Longitude field.
EResultCode setImpinjLocationAlgorithmControl(CImpinjLocationAlgorithmControl *pValue)
Set accessor functions for the LLRP ImpinjLocationAlgorithmControl sub-parameter. ...
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u1_t getEnableAntDwellTimeLimit(void)
Get accessor functions for the LLRP EnableAntDwellTimeLimit field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
CImpinjEnableGPSCoordinates * getImpinjEnableGPSCoordinates(void)
Get accessor functions for the LLRP ImpinjEnableGPSCoordinates sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setOrientationDegrees(llrp_s16_t value)
Set accessor functions for the LLRP OrientationDegrees field.
void setAccessRange(EImpinjQTAccessRange value)
Set accessor functions for the LLRP AccessRange field.
llrp_u16_t getTagAgeIntervalSeconds(void)
Get accessor functions for the LLRP TagAgeIntervalSeconds field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setHubID(llrp_u16_t value)
Set accessor functions for the LLRP HubID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjEnableOptimizedRead * getImpinjEnableOptimizedRead(void)
Get accessor functions for the LLRP ImpinjEnableOptimizedRead sub-parameter.
llrp_u2_t getSession(void)
Get accessor functions for the LLRP Session field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
llrp_utf8v_t getFPGAVersion(void)
Get accessor functions for the LLRP FPGAVersion field.
CImpinjDirectionSectors * getImpinjDirectionSectors(void)
Get accessor functions for the LLRP ImpinjDirectionSectors sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EImpinjRegulatoryRegion getRegulatoryRegion(void)
Get accessor functions for the LLRP RegulatoryRegion field.
Class Definition CImpinjAdvancedGPOConfiguration for LLRP parameter ImpinjAdvancedGPOConfiguration.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode setImpinjAccessSpecOrdering(CImpinjAccessSpecOrdering *pValue)
Set accessor functions for the LLRP ImpinjAccessSpecOrdering sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_utf8v_t getSerialNumber(void)
Get accessor functions for the LLRP SerialNumber field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearC1G2Filter(void)
Clears the LLRP C1G2Filter sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32_t getGPIDebounceTimerMSec(void)
Get accessor functions for the LLRP GPIDebounceTimerMSec field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setResult(EImpinjSetQTConfigResultType value)
Set accessor functions for the LLRP Result field.
Class Definition CImpinjLocationConfidence for LLRP parameter ImpinjLocationConfidence.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
Class Definition CImpinjRFDopplerFrequency for LLRP parameter ImpinjRFDopplerFrequency.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void setDataProfile(EImpinjQTDataProfile value)
Set accessor functions for the LLRP DataProfile field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setUserTagPopulationLimit(llrp_u16_t value)
Set accessor functions for the LLRP UserTagPopulationLimit field.
llrp_utf8v_t getSoftwareVersion(void)
Get accessor functions for the LLRP SoftwareVersion field.
EImpinjLocationReportType getType(void)
Get accessor functions for the LLRP Type field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_u16v_t getBlockMask(void)
Get accessor functions for the LLRP BlockMask field.
EImpinjBlockPermalockResultType getResult(void)
Get accessor functions for the LLRP Result field.
EImpinjAntennaPolarizationType getType(void)
Get accessor functions for the LLRP Type field.
Class Definition CImpinjDirectionUserTagPopulationLimit for LLRP parameter ImpinjDirectionUserTagPopu...
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s32_t getLocXCentimeters(void)
Get accessor functions for the LLRP LocXCentimeters field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setAntennaIDs(llrp_u16v_t value)
Set accessor functions for the LLRP AntennaIDs field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode addImpinjAntennaPolarizationCapability(CImpinjAntennaPolarizationCapability *pValue)
Add a ImpinjAntennaPolarizationCapability to the LLRP sub-parameter list.
std::list< CC1G2Read * >::iterator endC1G2Read(void)
Returns the last element of the C1G2Read sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
Class Definition CImpinjSetQTConfigOpSpecResult for LLRP parameter ImpinjSetQTConfigOpSpecResult.
Class Definition CIMPINJ_ENABLE_EXTENSIONS for LLRP message IMPINJ_ENABLE_EXTENSIONS.
void setSystemTagPopulationLimitHighPerformance(llrp_u16_t value)
Set accessor functions for the LLRP SystemTagPopulationLimitHighPerformance field.
EImpinjQTAccessRange getAccessRange(void)
Get accessor functions for the LLRP AccessRange field.
std::list< CC1G2Filter * >::iterator endC1G2Filter(void)
Returns the last element of the C1G2Filter sub-parameter list.
EResultCode setImpinjGGASentence(CImpinjGGASentence *pValue)
Set accessor functions for the LLRP ImpinjGGASentence sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjGetQTConfig for LLRP parameter ImpinjGetQTConfig.
int countC1G2Filter(void)
Count of the LLRP C1G2Filter sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjAccessSpecConfiguration for LLRP parameter ImpinjAccessSpecConfiguration.
Class Definition CImpinjFrequencyCapabilities for LLRP parameter ImpinjFrequencyCapabilities.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setEnabledSectorIDs(llrp_u16v_t value)
Set accessor functions for the LLRP EnabledSectorIDs field.
void clearImpinjAntennaPolarizationCapability(void)
Clears the LLRP ImpinjAntennaPolarizationCapability sub-parameter list.
Class Definition CImpinjLinkMonitorConfiguration for LLRP parameter ImpinjLinkMonitorConfiguration.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CEPCData * >::iterator endEPCData(void)
Returns the last element of the EPCData sub-parameter list.
CImpinjLocationConfidence * getImpinjLocationConfidence(void)
Get accessor functions for the LLRP ImpinjLocationConfidence sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjMarginReadOpSpecResult for LLRP parameter ImpinjMarginReadOpSpecResult.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setManagementEnabled(EImpinjIntelligentAntennaMode value)
Set accessor functions for the LLRP ManagementEnabled field.
void setGPOPulseDurationMSec(llrp_u32_t value)
Set accessor functions for the LLRP GPOPulseDurationMSec field.
Class Definition CImpinjxArrayDirectionCapabilities for LLRP parameter ImpinjxArrayDirectionCapabilit...
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjAntennaConfiguration for LLRP parameter ImpinjAntennaConfiguration.
EImpinjGPSCoordinatesMode getGPSCoordinatesMode(void)
Get accessor functions for the LLRP GPSCoordinatesMode field.
CImpinjAntennaEventConfiguration * getImpinjAntennaEventConfiguration(void)
Get accessor functions for the LLRP ImpinjAntennaEventConfiguration sub-parameter.
EResultCode addC1G2Read(CC1G2Read *pValue)
Add a C1G2Read to the LLRP sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
llrp_u16_t getBlockPointer(void)
Get accessor functions for the LLRP BlockPointer field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjHubConfiguration for LLRP parameter ImpinjHubConfiguration.
llrp_u16_t getUpdateIntervalSeconds(void)
Get accessor functions for the LLRP UpdateIntervalSeconds field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setBitLength(llrp_u8_t value)
Set accessor functions for the LLRP BitLength field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u1_t getSupportsTSISpecs(void)
Get accessor functions for the LLRP SupportsTSISpecs field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjReportBufferMode getReportBufferMode(void)
Get accessor functions for the LLRP ReportBufferMode field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getXAxis(void)
Get accessor functions for the LLRP XAxis field.
Class Definition CImpinjDirectionDiagnosticData for LLRP parameter ImpinjDirectionDiagnosticData.
void setLinkMonitorMode(EImpinjLinkMonitorMode value)
Set accessor functions for the LLRP LinkMonitorMode field.
Class Definition CImpinjEnableRFPhaseAngle for LLRP parameter ImpinjEnableRFPhaseAngle.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
Class Definition CIMPINJ_SAVE_SETTINGS_RESPONSE for LLRP message IMPINJ_SAVE_SETTINGS_RESPONSE.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_s16_t getOrientationDegrees(void)
Get accessor functions for the LLRP OrientationDegrees field.
Class Definition CImpinjExtendedTagInformation for LLRP parameter ImpinjExtendedTagInformation.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjDirectionDiagnosticReportLevel getDiagnosticReportLevel(void)
Get accessor functions for the LLRP DiagnosticReportLevel field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjRFDopplerFrequencyMode getRFDopplerFrequencyMode(void)
Get accessor functions for the LLRP RFDopplerFrequencyMode field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableUpdateReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableUpdateReport field.
EImpinjInventorySearchType getInventorySearchMode(void)
Get accessor functions for the LLRP InventorySearchMode field.
Class Definition CImpinjGetBlockPermalockStatusOpSpecResult for LLRP parameter ImpinjGetBlockPermaloc...
CImpinjEnableSerializedTID * getImpinjEnableSerializedTID(void)
Get accessor functions for the LLRP ImpinjEnableSerializedTID sub-parameter.
void setMetric(llrp_u32v_t value)
Set accessor functions for the LLRP Metric field.
EResultCode addC1G2Filter(CC1G2Filter *pValue)
Add a C1G2Filter to the LLRP sub-parameter list.
Class Definition CImpinjAntennaEventConfiguration for LLRP parameter ImpinjAntennaEventConfiguration...
CImpinjBLEVersion * getImpinjBLEVersion(void)
Get accessor functions for the LLRP ImpinjBLEVersion sub-parameter.
EResultCode addC1G2Filter(CC1G2Filter *pValue)
Add a C1G2Filter to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode setImpinjLocationReportData(CImpinjLocationReportData *pValue)
Set accessor functions for the LLRP ImpinjLocationReportData sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode setImpinjEnableOptimizedRead(CImpinjEnableOptimizedRead *pValue)
Set accessor functions for the LLRP ImpinjEnableOptimizedRead sub-parameter.
CImpinjTransmitPower * getImpinjTransmitPower(void)
Get accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
void setSupportsLISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsLISpecs field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getLocYCentimeters(void)
Get accessor functions for the LLRP LocYCentimeters field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setLastSeenSectorID(llrp_u8_t value)
Set accessor functions for the LLRP LastSeenSectorID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setRegulatoryRegion(EImpinjRegulatoryRegion value)
Set accessor functions for the LLRP RegulatoryRegion field.
EResultCode setImpinjxArrayDirectionCapabilities(CImpinjxArrayDirectionCapabilities *pValue)
Set accessor functions for the LLRP ImpinjxArrayDirectionCapabilities sub-parameter.
void setTID(llrp_u16v_t value)
Set accessor functions for the LLRP TID field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EImpinjQTDataProfile getDataProfile(void)
Get accessor functions for the LLRP DataProfile field.
Class Definition CImpinjAccessSpecOrdering for LLRP parameter ImpinjAccessSpecOrdering.
Class Definition CImpinjAntennaCapabilities for LLRP parameter ImpinjAntennaCapabilities.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode setImpinjLocationReporting(CImpinjLocationReporting *pValue)
Set accessor functions for the LLRP ImpinjLocationReporting sub-parameter.
Class Definition CImpinjSerializedTID for LLRP parameter ImpinjSerializedTID.
llrp_s32_t getFacilityXLocationCm(void)
Get accessor functions for the LLRP FacilityXLocationCm field.
Class Definition CImpinjGPIDebounceConfiguration for LLRP parameter ImpinjGPIDebounceConfiguration.
EResultCode setImpinjOpSpecRetryCount(CImpinjOpSpecRetryCount *pValue)
Set accessor functions for the LLRP ImpinjOpSpecRetryCount sub-parameter.
llrp_u1_t getEnableEntryReport(void)
Get accessor functions for the LLRP EnableEntryReport field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EImpinjOptimizedReadMode getOptimizedReadMode(void)
Get accessor functions for the LLRP OptimizedReadMode field.
llrp_u1_t getSupportsLISpecs(void)
Get accessor functions for the LLRP SupportsLISpecs field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
CImpinjEnableRFDopplerFrequency * getImpinjEnableRFDopplerFrequency(void)
Get accessor functions for the LLRP ImpinjEnableRFDopplerFrequency sub-parameter. ...
llrp_s16_t getRSSI(void)
Get accessor functions for the LLRP RSSI field.
void setGPOPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPOPortNum field.
void setFirstSeenSectorID(llrp_u8_t value)
Set accessor functions for the LLRP FirstSeenSectorID field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjQTAccessRange getAccessRange(void)
Get accessor functions for the LLRP AccessRange field.
void setLastSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP LastSeenTimestampUTC field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjAccessSpecOrdering * getImpinjAccessSpecOrdering(void)
Get accessor functions for the LLRP ImpinjAccessSpecOrdering sub-parameter.
void clearC1G2Filter(void)
Clears the LLRP C1G2Filter sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getHeightCm(void)
Get accessor functions for the LLRP HeightCm field.
void setParityError(llrp_u1_t value)
Set accessor functions for the LLRP ParityError field.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode setImpinjEnableRFDopplerFrequency(CImpinjEnableRFDopplerFrequency *pValue)
Set accessor functions for the LLRP ImpinjEnableRFDopplerFrequency sub-parameter. ...
void setOptimizedReadMode(EImpinjOptimizedReadMode value)
Set accessor functions for the LLRP OptimizedReadMode field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
void setType(EImpinjDirectionReportType value)
Set accessor functions for the LLRP Type field.
void setBlockPointer(llrp_u16_t value)
Set accessor functions for the LLRP BlockPointer field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u32v_t getFrequencyList(void)
Get accessor functions for the LLRP FrequencyList field.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
EResultCode setImpinjArrayVersion(CImpinjArrayVersion *pValue)
Set accessor functions for the LLRP ImpinjArrayVersion sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CEPCData * >::iterator beginEPCData(void)
Returns the first element of the EPCData sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjC1G2DirectionConfig for LLRP parameter ImpinjC1G2DirectionConfig.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getGPIPortNum(void)
Get accessor functions for the LLRP GPIPortNum field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u16_t getUpdateIntervalSeconds(void)
Get accessor functions for the LLRP UpdateIntervalSeconds field.
void setTemperature(llrp_s16_t value)
Set accessor functions for the LLRP Temperature field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
CImpinjEnablePeakRSSI * getImpinjEnablePeakRSSI(void)
Get accessor functions for the LLRP ImpinjEnablePeakRSSI sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setEnableUpdateReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableUpdateReport field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
EResultCode setImpinjDirectionDiagnosticData(CImpinjDirectionDiagnosticData *pValue)
Set accessor functions for the LLRP ImpinjDirectionDiagnosticData sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
CImpinjEnableTxPower * getImpinjEnableTxPower(void)
Get accessor functions for the LLRP ImpinjEnableTxPower sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjAntennaEventHysteresis * getImpinjAntennaEventHysteresis(void)
Get accessor functions for the LLRP ImpinjAntennaEventHysteresis sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setLoopCount(llrp_u32_t value)
Set accessor functions for the LLRP LoopCount field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u64_t getLastSeenTimestampUTC(void)
Get accessor functions for the LLRP LastSeenTimestampUTC field.
Class Definition CImpinjReducedPowerFrequencyList for LLRP parameter ImpinjReducedPowerFrequencyList...
Class Definition CC1G2Filter for LLRP parameter C1G2Filter.
Definition: out_ltkcpp.h:20216
EResultCode setImpinjAntennaEventConfiguration(CImpinjAntennaEventConfiguration *pValue)
Set accessor functions for the LLRP ImpinjAntennaEventConfiguration sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16v_t getChannelList(void)
Get accessor functions for the LLRP ChannelList field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode setImpinjTIDParity(CImpinjTIDParity *pValue)
Set accessor functions for the LLRP ImpinjTIDParity sub-parameter.
Class Definition CImpinjDISpec for LLRP parameter ImpinjDISpec.
void setBlockRange(llrp_u16_t value)
Set accessor functions for the LLRP BlockRange field.
void setReducedPowerMode(EImpinjReducedPowerMode value)
Set accessor functions for the LLRP ReducedPowerMode field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Class Definition CImpinjRMCSentence for LLRP parameter ImpinjRMCSentence.
EImpinjDirectionRFMode getRFMode(void)
Get accessor functions for the LLRP RFMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countImpinjAntennaPolarizationCapability(void)
Count of the LLRP ImpinjAntennaPolarizationCapability sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CC1G2Filter * >::iterator beginC1G2Filter(void)
Returns the first element of the C1G2Filter sub-parameter list.
void setDataProfile(EImpinjQTDataProfile value)
Set accessor functions for the LLRP DataProfile field.
Class Definition CImpinjEnableGPSCoordinates for LLRP parameter ImpinjEnableGPSCoordinates.
Class Definition CImpinjMarginRead for LLRP parameter ImpinjMarginRead.
void setPeakRSSIMode(EImpinjPeakRSSIMode value)
Set accessor functions for the LLRP PeakRSSIMode field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setChannelList(llrp_u16v_t value)
Set accessor functions for the LLRP ChannelList field.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
CImpinjTransmitPower * getImpinjTransmitPower(void)
Get accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
Class Definition CImpinjC1G2LocationConfig for LLRP parameter ImpinjC1G2LocationConfig.
EResultCode setImpinjEnableRFPhaseAngle(CImpinjEnableRFPhaseAngle *pValue)
Set accessor functions for the LLRP ImpinjEnableRFPhaseAngle sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjHubFaultType getFault(void)
Get accessor functions for the LLRP Fault field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEmptyFieldTimeout(llrp_u16_t value)
Set accessor functions for the LLRP EmptyFieldTimeout field.
void setAntennaEventConnected(llrp_u64_t value)
Set accessor functions for the LLRP AntennaEventConnected field.
llrp_u1_t getEnableDiagnosticReport(void)
Get accessor functions for the LLRP EnableDiagnosticReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjLocationAlgorithmControl * getImpinjLocationAlgorithmControl(void)
Get accessor functions for the LLRP ImpinjLocationAlgorithmControl sub-parameter. ...
Class Definition CImpinjEnableOptimizedRead for LLRP parameter ImpinjEnableOptimizedRead.
Class Definition CImpinjRequestedData for LLRP parameter ImpinjRequestedData.
EImpinjPeakRSSIMode getPeakRSSIMode(void)
Get accessor functions for the LLRP PeakRSSIMode field.
void setEnableEntryReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableEntryReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.