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;
85 class CImpinjLISpec;
91 class CImpinjDISpec;
107 class CImpinjTIDParity;
108 class CImpinjMarginRead;
110 class CImpinjBLEVersion;
111 
112 /*
113  * Vendor descriptor declarations.
114  */
115 
116 extern const CVendorDescriptor
117 g_vdescImpinj;
118 
119 
120 /*
121  * Namespace descriptor declarations.
122  */
123 
124 extern const CNamespaceDescriptor
125 g_nsdescImpinj;
126 
127 
128 /*
129  * Enumeration definitions and declarations of
130  * enumeration string tables.
131  */
132 
133 
165 enum EImpinjRequestedDataType
166 {
168 };
169 
170 extern const SEnumTableEntry
171 g_estImpinjRequestedDataType[];
172 
173 
207 enum EImpinjRegulatoryRegion
208 {
210 };
211 
212 extern const SEnumTableEntry
213 g_estImpinjRegulatoryRegion[];
214 
215 
230 enum EImpinjInventorySearchType
231 {
233 };
234 
235 extern const SEnumTableEntry
236 g_estImpinjInventorySearchType[];
237 
238 
249 enum EImpinjFixedFrequencyMode
250 {
252 };
253 
254 extern const SEnumTableEntry
255 g_estImpinjFixedFrequencyMode[];
256 
257 
267 enum EImpinjReducedPowerMode
268 {
270 };
271 
272 extern const SEnumTableEntry
273 g_estImpinjReducedPowerMode[];
274 
275 
285 enum EImpinjLowDutyCycleMode
286 {
288 };
289 
290 extern const SEnumTableEntry
291 g_estImpinjLowDutyCycleMode[];
292 
293 
303 enum EImpinjLinkMonitorMode
304 {
306 };
307 
308 extern const SEnumTableEntry
309 g_estImpinjLinkMonitorMode[];
310 
311 
321 enum EImpinjReportBufferMode
322 {
324 };
325 
326 extern const SEnumTableEntry
327 g_estImpinjReportBufferMode[];
328 
329 
344 enum EImpinjBlockPermalockResultType
345 {
347 };
348 
349 extern const SEnumTableEntry
350 g_estImpinjBlockPermalockResultType[];
351 
352 
366 enum EImpinjGetBlockPermalockStatusResultType
367 {
369 };
370 
371 extern const SEnumTableEntry
372 g_estImpinjGetBlockPermalockStatusResultType[];
373 
374 
385 enum EImpinjQTDataProfile
386 {
388 };
389 
390 extern const SEnumTableEntry
391 g_estImpinjQTDataProfile[];
392 
393 
404 enum EImpinjQTAccessRange
405 {
407 };
408 
409 extern const SEnumTableEntry
410 g_estImpinjQTAccessRange[];
411 
412 
423 enum EImpinjQTPersistence
424 {
426 };
427 
428 extern const SEnumTableEntry
429 g_estImpinjQTPersistence[];
430 
431 
445 enum EImpinjSetQTConfigResultType
446 {
448 };
449 
450 extern const SEnumTableEntry
451 g_estImpinjSetQTConfigResultType[];
452 
453 
466 enum EImpinjGetQTConfigResultType
467 {
469 };
470 
471 extern const SEnumTableEntry
472 g_estImpinjGetQTConfigResultType[];
473 
474 
484 enum EImpinjSerializedTIDMode
485 {
487 };
488 
489 extern const SEnumTableEntry
490 g_estImpinjSerializedTIDMode[];
491 
492 
502 enum EImpinjRFPhaseAngleMode
503 {
505 };
506 
507 extern const SEnumTableEntry
508 g_estImpinjRFPhaseAngleMode[];
509 
510 
520 enum EImpinjPeakRSSIMode
521 {
523 };
524 
525 extern const SEnumTableEntry
526 g_estImpinjPeakRSSIMode[];
527 
528 
538 enum EImpinjGPSCoordinatesMode
539 {
541 };
542 
543 extern const SEnumTableEntry
544 g_estImpinjGPSCoordinatesMode[];
545 
546 
561 enum EImpinjAdvancedGPOMode
562 {
564 };
565 
566 extern const SEnumTableEntry
567 g_estImpinjAdvancedGPOMode[];
568 
569 
579 enum EImpinjOptimizedReadMode
580 {
582 };
583 
584 extern const SEnumTableEntry
585 g_estImpinjOptimizedReadMode[];
586 
587 
597 enum EImpinjAccessSpecOrderingMode
598 {
600 };
601 
602 extern const SEnumTableEntry
603 g_estImpinjAccessSpecOrderingMode[];
604 
605 
615 enum EImpinjRFDopplerFrequencyMode
616 {
618 };
619 
620 extern const SEnumTableEntry
621 g_estImpinjRFDopplerFrequencyMode[];
622 
623 
634 enum EImpinjHubConnectedType
635 {
637 };
638 
639 extern const SEnumTableEntry
640 g_estImpinjHubConnectedType[];
641 
642 
659 enum EImpinjHubFaultType
660 {
662 };
663 
664 extern const SEnumTableEntry
665 g_estImpinjHubFaultType[];
666 
667 
678 enum EImpinjLocationReportType
679 {
681 };
682 
683 extern const SEnumTableEntry
684 g_estImpinjLocationReportType[];
685 
686 
730 enum EImpinjDirectionFieldOfView
731 {
733 };
734 
735 extern const SEnumTableEntry
736 g_estImpinjDirectionFieldOfView[];
737 
738 
773 enum EImpinjDirectionRFMode
774 {
776 };
777 
778 extern const SEnumTableEntry
779 g_estImpinjDirectionRFMode[];
780 
781 
831 enum EImpinjDirectionDiagnosticReportLevel
832 {
834 };
835 
836 extern const SEnumTableEntry
837 g_estImpinjDirectionDiagnosticReportLevel[];
838 
839 
878 enum EImpinjDirectionReportType
879 {
881 };
882 
883 extern const SEnumTableEntry
884 g_estImpinjDirectionReportType[];
885 
886 
925 enum EImpinjDirectionTagPopulationStatus
926 {
928 };
929 
930 extern const SEnumTableEntry
931 g_estImpinjDirectionTagPopulationStatus[];
932 
933 
943 enum EImpinjIntelligentAntennaMode
944 {
946 };
947 
948 extern const SEnumTableEntry
949 g_estImpinjIntelligentAntennaMode[];
950 
951 
963 enum EImpinjAntennaPolarizationType
964 {
966 };
967 
968 extern const SEnumTableEntry
969 g_estImpinjAntennaPolarizationType[];
970 
971 
988 enum EImpinjMarginReadResultType
989 {
991 };
992 
993 extern const SEnumTableEntry
994 g_estImpinjMarginReadResultType[];
995 
996 
1002 
1026 class CIMPINJ_ENABLE_EXTENSIONS : public CMessage
1027 {
1028  public:
1030  ~CIMPINJ_ENABLE_EXTENSIONS (void);
1031 
1034 
1035  static const CFieldDescriptor * const
1036  s_apFieldDescriptorTable[];
1037 
1038  static const CTypeDescriptor
1039  s_typeDescriptor;
1040 
1041  void
1042  decodeFields (
1043  CDecoderStream * pDecoderStream);
1044 
1045  void
1046  assimilateSubParameters (
1047  CErrorDetails * pError);
1048 
1049  void
1050  encode (
1051  CEncoderStream * pEncoderStream) const;
1052 
1053 
1054 
1055  static CElement *
1056  s_construct (void);
1057 
1058  static void
1059  s_decodeFields (
1060  CDecoderStream * pDecoderStream,
1061  CElement * pElement);
1063 
1064 
1065  protected:
1066  std::list<CParameter *> m_listCustom;
1067 
1068  public:
1070  inline std::list<CParameter *>::iterator
1072  {
1073  return m_listCustom.begin();
1074  }
1075 
1077  inline std::list<CParameter *>::iterator
1078  endCustom (void)
1079  {
1080  return m_listCustom.end();
1081  }
1082 
1084  inline void
1086  {
1087  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1088  }
1089 
1091  inline int
1093  {
1094  return (int) (m_listCustom.size());
1095  }
1096 
1097  EResultCode
1099  addCustom (
1100  CParameter * pValue);
1101 
1102 
1103 };
1104 
1105 
1129 class CIMPINJ_ENABLE_EXTENSIONS_RESPONSE : public CMessage
1130 {
1131  public:
1134 
1137 
1138  static const CFieldDescriptor * const
1139  s_apFieldDescriptorTable[];
1140 
1141  static const CTypeDescriptor
1142  s_typeDescriptor;
1143 
1144  void
1145  decodeFields (
1146  CDecoderStream * pDecoderStream);
1147 
1148  void
1149  assimilateSubParameters (
1150  CErrorDetails * pError);
1151 
1152  void
1153  encode (
1154  CEncoderStream * pEncoderStream) const;
1155 
1156 
1157 
1158  static CElement *
1159  s_construct (void);
1160 
1161  static void
1162  s_decodeFields (
1163  CDecoderStream * pDecoderStream,
1164  CElement * pElement);
1166 
1167 
1168  protected:
1169  CLLRPStatus * m_pLLRPStatus;
1170 
1171  public:
1173  inline CLLRPStatus *
1175  {
1176  return m_pLLRPStatus;
1177  }
1178 
1180  EResultCode
1181  setLLRPStatus (
1182  CLLRPStatus * pValue);
1183 
1184 
1185  protected:
1186  std::list<CParameter *> m_listCustom;
1187 
1188  public:
1190  inline std::list<CParameter *>::iterator
1192  {
1193  return m_listCustom.begin();
1194  }
1195 
1197  inline std::list<CParameter *>::iterator
1198  endCustom (void)
1199  {
1200  return m_listCustom.end();
1201  }
1202 
1204  inline void
1206  {
1207  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1208  }
1209 
1211  inline int
1213  {
1214  return (int) (m_listCustom.size());
1215  }
1216 
1217  EResultCode
1219  addCustom (
1220  CParameter * pValue);
1221 
1222 
1223 };
1224 
1225 
1259 class CIMPINJ_SAVE_SETTINGS : public CMessage
1260 {
1261  public:
1262  CIMPINJ_SAVE_SETTINGS (void);
1263  ~CIMPINJ_SAVE_SETTINGS (void);
1264 
1267 
1268  static const CFieldDescriptor * const
1269  s_apFieldDescriptorTable[];
1270 
1271  static const CTypeDescriptor
1272  s_typeDescriptor;
1273 
1274  void
1275  decodeFields (
1276  CDecoderStream * pDecoderStream);
1277 
1278  void
1279  assimilateSubParameters (
1280  CErrorDetails * pError);
1281 
1282  void
1283  encode (
1284  CEncoderStream * pEncoderStream) const;
1285 
1286 
1287 
1288  static CElement *
1289  s_construct (void);
1290 
1291  static void
1292  s_decodeFields (
1293  CDecoderStream * pDecoderStream,
1294  CElement * pElement);
1296 
1297 
1298  protected:
1299  llrp_u1_t m_SaveConfiguration;
1300 
1303  public:
1304  static const CFieldDescriptor
1305  s_fdSaveConfiguration;
1307 
1309  inline llrp_u1_t
1311  {
1312  return m_SaveConfiguration;
1313  }
1314 
1316  inline void
1318  llrp_u1_t value)
1319  {
1320  m_SaveConfiguration = value;
1321  }
1322 
1323 
1324  protected:
1325  std::list<CParameter *> m_listCustom;
1326 
1327  public:
1329  inline std::list<CParameter *>::iterator
1331  {
1332  return m_listCustom.begin();
1333  }
1334 
1336  inline std::list<CParameter *>::iterator
1337  endCustom (void)
1338  {
1339  return m_listCustom.end();
1340  }
1341 
1343  inline void
1345  {
1346  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1347  }
1348 
1350  inline int
1352  {
1353  return (int) (m_listCustom.size());
1354  }
1355 
1356  EResultCode
1358  addCustom (
1359  CParameter * pValue);
1360 
1361 
1362 };
1363 
1364 
1388 class CIMPINJ_SAVE_SETTINGS_RESPONSE : public CMessage
1389 {
1390  public:
1393 
1396 
1397  static const CFieldDescriptor * const
1398  s_apFieldDescriptorTable[];
1399 
1400  static const CTypeDescriptor
1401  s_typeDescriptor;
1402 
1403  void
1404  decodeFields (
1405  CDecoderStream * pDecoderStream);
1406 
1407  void
1408  assimilateSubParameters (
1409  CErrorDetails * pError);
1410 
1411  void
1412  encode (
1413  CEncoderStream * pEncoderStream) const;
1414 
1415 
1416 
1417  static CElement *
1418  s_construct (void);
1419 
1420  static void
1421  s_decodeFields (
1422  CDecoderStream * pDecoderStream,
1423  CElement * pElement);
1425 
1426 
1427  protected:
1428  CLLRPStatus * m_pLLRPStatus;
1429 
1430  public:
1432  inline CLLRPStatus *
1434  {
1435  return m_pLLRPStatus;
1436  }
1437 
1439  EResultCode
1440  setLLRPStatus (
1441  CLLRPStatus * pValue);
1442 
1443 
1444  protected:
1445  std::list<CParameter *> m_listCustom;
1446 
1447  public:
1449  inline std::list<CParameter *>::iterator
1451  {
1452  return m_listCustom.begin();
1453  }
1454 
1456  inline std::list<CParameter *>::iterator
1457  endCustom (void)
1458  {
1459  return m_listCustom.end();
1460  }
1461 
1463  inline void
1465  {
1466  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1467  }
1468 
1470  inline int
1472  {
1473  return (int) (m_listCustom.size());
1474  }
1475 
1476  EResultCode
1478  addCustom (
1479  CParameter * pValue);
1480 
1481 
1482 };
1483 
1484 
1492 
1515 class CImpinjRequestedData : public CParameter
1516 {
1517  public:
1518  CImpinjRequestedData (void);
1519  ~CImpinjRequestedData (void);
1520 
1523 
1524  static const CFieldDescriptor * const
1525  s_apFieldDescriptorTable[];
1526 
1527  static const CTypeDescriptor
1528  s_typeDescriptor;
1529 
1530  void
1531  decodeFields (
1532  CDecoderStream * pDecoderStream);
1533 
1534  void
1535  assimilateSubParameters (
1536  CErrorDetails * pError);
1537 
1538  void
1539  encode (
1540  CEncoderStream * pEncoderStream) const;
1541 
1542 
1543  llrp_bool_t
1544  isAllowedIn (
1545  const CTypeDescriptor * pEnclosingElementType) const;
1546 
1547 
1548  static CElement *
1549  s_construct (void);
1550 
1551  static void
1552  s_decodeFields (
1553  CDecoderStream * pDecoderStream,
1554  CElement * pElement);
1556 
1557 
1558  protected:
1559  EImpinjRequestedDataType m_eRequestedData;
1560 
1563  public:
1564  static const CFieldDescriptor
1565  s_fdRequestedData;
1567 
1569  inline EImpinjRequestedDataType
1571  {
1572  return m_eRequestedData;
1573  }
1574 
1576  inline void
1578  EImpinjRequestedDataType value)
1579  {
1580  m_eRequestedData = value;
1581  }
1582 
1583 
1584  protected:
1585  std::list<CParameter *> m_listCustom;
1586 
1587  public:
1589  inline std::list<CParameter *>::iterator
1591  {
1592  return m_listCustom.begin();
1593  }
1594 
1596  inline std::list<CParameter *>::iterator
1597  endCustom (void)
1598  {
1599  return m_listCustom.end();
1600  }
1601 
1603  inline void
1605  {
1606  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1607  }
1608 
1610  inline int
1612  {
1613  return (int) (m_listCustom.size());
1614  }
1615 
1616  EResultCode
1618  addCustom (
1619  CParameter * pValue);
1620 
1621 
1622 };
1623 
1624 
1653 class CImpinjSubRegulatoryRegion : public CParameter
1654 {
1655  public:
1658 
1661 
1662  static const CFieldDescriptor * const
1663  s_apFieldDescriptorTable[];
1664 
1665  static const CTypeDescriptor
1666  s_typeDescriptor;
1667 
1668  void
1669  decodeFields (
1670  CDecoderStream * pDecoderStream);
1671 
1672  void
1673  assimilateSubParameters (
1674  CErrorDetails * pError);
1675 
1676  void
1677  encode (
1678  CEncoderStream * pEncoderStream) const;
1679 
1680 
1681  llrp_bool_t
1682  isAllowedIn (
1683  const CTypeDescriptor * pEnclosingElementType) const;
1684 
1685 
1686  static CElement *
1687  s_construct (void);
1688 
1689  static void
1690  s_decodeFields (
1691  CDecoderStream * pDecoderStream,
1692  CElement * pElement);
1694 
1695 
1696  protected:
1697  EImpinjRegulatoryRegion m_eRegulatoryRegion;
1698 
1701  public:
1702  static const CFieldDescriptor
1703  s_fdRegulatoryRegion;
1705 
1707  inline EImpinjRegulatoryRegion
1709  {
1710  return m_eRegulatoryRegion;
1711  }
1712 
1714  inline void
1716  EImpinjRegulatoryRegion value)
1717  {
1718  m_eRegulatoryRegion = value;
1719  }
1720 
1721 
1722  protected:
1723  std::list<CParameter *> m_listCustom;
1724 
1725  public:
1727  inline std::list<CParameter *>::iterator
1729  {
1730  return m_listCustom.begin();
1731  }
1732 
1734  inline std::list<CParameter *>::iterator
1735  endCustom (void)
1736  {
1737  return m_listCustom.end();
1738  }
1739 
1741  inline void
1743  {
1744  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1745  }
1746 
1748  inline int
1750  {
1751  return (int) (m_listCustom.size());
1752  }
1753 
1754  EResultCode
1756  addCustom (
1757  CParameter * pValue);
1758 
1759 
1760 };
1761 
1762 
1787 class CImpinjInventorySearchMode : public CParameter
1788 {
1789  public:
1792 
1795 
1796  static const CFieldDescriptor * const
1797  s_apFieldDescriptorTable[];
1798 
1799  static const CTypeDescriptor
1800  s_typeDescriptor;
1801 
1802  void
1803  decodeFields (
1804  CDecoderStream * pDecoderStream);
1805 
1806  void
1807  assimilateSubParameters (
1808  CErrorDetails * pError);
1809 
1810  void
1811  encode (
1812  CEncoderStream * pEncoderStream) const;
1813 
1814 
1815  llrp_bool_t
1816  isAllowedIn (
1817  const CTypeDescriptor * pEnclosingElementType) const;
1818 
1819 
1820  static CElement *
1821  s_construct (void);
1822 
1823  static void
1824  s_decodeFields (
1825  CDecoderStream * pDecoderStream,
1826  CElement * pElement);
1828 
1829 
1830  protected:
1831  EImpinjInventorySearchType m_eInventorySearchMode;
1832 
1835  public:
1836  static const CFieldDescriptor
1837  s_fdInventorySearchMode;
1839 
1841  inline EImpinjInventorySearchType
1843  {
1844  return m_eInventorySearchMode;
1845  }
1846 
1848  inline void
1850  EImpinjInventorySearchType value)
1851  {
1852  m_eInventorySearchMode = value;
1853  }
1854 
1855 
1856  protected:
1857  std::list<CParameter *> m_listCustom;
1858 
1859  public:
1861  inline std::list<CParameter *>::iterator
1863  {
1864  return m_listCustom.begin();
1865  }
1866 
1868  inline std::list<CParameter *>::iterator
1869  endCustom (void)
1870  {
1871  return m_listCustom.end();
1872  }
1873 
1875  inline void
1877  {
1878  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1879  }
1880 
1882  inline int
1884  {
1885  return (int) (m_listCustom.size());
1886  }
1887 
1888  EResultCode
1890  addCustom (
1891  CParameter * pValue);
1892 
1893 
1894 };
1895 
1896 
1926 class CImpinjFixedFrequencyList : public CParameter
1927 {
1928  public:
1930  ~CImpinjFixedFrequencyList (void);
1931 
1934 
1935  static const CFieldDescriptor * const
1936  s_apFieldDescriptorTable[];
1937 
1938  static const CTypeDescriptor
1939  s_typeDescriptor;
1940 
1941  void
1942  decodeFields (
1943  CDecoderStream * pDecoderStream);
1944 
1945  void
1946  assimilateSubParameters (
1947  CErrorDetails * pError);
1948 
1949  void
1950  encode (
1951  CEncoderStream * pEncoderStream) const;
1952 
1953 
1954  llrp_bool_t
1955  isAllowedIn (
1956  const CTypeDescriptor * pEnclosingElementType) const;
1957 
1958 
1959  static CElement *
1960  s_construct (void);
1961 
1962  static void
1963  s_decodeFields (
1964  CDecoderStream * pDecoderStream,
1965  CElement * pElement);
1967 
1968 
1969  protected:
1970  EImpinjFixedFrequencyMode m_eFixedFrequencyMode;
1971 
1974  public:
1975  static const CFieldDescriptor
1976  s_fdFixedFrequencyMode;
1978 
1980  inline EImpinjFixedFrequencyMode
1982  {
1983  return m_eFixedFrequencyMode;
1984  }
1985 
1987  inline void
1989  EImpinjFixedFrequencyMode value)
1990  {
1991  m_eFixedFrequencyMode = value;
1992  }
1993 
1994 
1995  protected:
1996  llrp_u16v_t m_ChannelList;
1997 
2000  public:
2001  static const CFieldDescriptor
2002  s_fdChannelList;
2004 
2006  inline llrp_u16v_t
2008  {
2009  return m_ChannelList;
2010  }
2011 
2013  inline void
2015  llrp_u16v_t value)
2016  {
2017  m_ChannelList = value;
2018  }
2019 
2020 
2021  protected:
2022  std::list<CParameter *> m_listCustom;
2023 
2024  public:
2026  inline std::list<CParameter *>::iterator
2028  {
2029  return m_listCustom.begin();
2030  }
2031 
2033  inline std::list<CParameter *>::iterator
2034  endCustom (void)
2035  {
2036  return m_listCustom.end();
2037  }
2038 
2040  inline void
2042  {
2043  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2044  }
2045 
2047  inline int
2049  {
2050  return (int) (m_listCustom.size());
2051  }
2052 
2053  EResultCode
2055  addCustom (
2056  CParameter * pValue);
2057 
2058 
2059 };
2060 
2061 
2091 class CImpinjReducedPowerFrequencyList : public CParameter
2092 {
2093  public:
2096 
2099 
2100  static const CFieldDescriptor * const
2101  s_apFieldDescriptorTable[];
2102 
2103  static const CTypeDescriptor
2104  s_typeDescriptor;
2105 
2106  void
2107  decodeFields (
2108  CDecoderStream * pDecoderStream);
2109 
2110  void
2111  assimilateSubParameters (
2112  CErrorDetails * pError);
2113 
2114  void
2115  encode (
2116  CEncoderStream * pEncoderStream) const;
2117 
2118 
2119  llrp_bool_t
2120  isAllowedIn (
2121  const CTypeDescriptor * pEnclosingElementType) const;
2122 
2123 
2124  static CElement *
2125  s_construct (void);
2126 
2127  static void
2128  s_decodeFields (
2129  CDecoderStream * pDecoderStream,
2130  CElement * pElement);
2132 
2133 
2134  protected:
2135  EImpinjReducedPowerMode m_eReducedPowerMode;
2136 
2139  public:
2140  static const CFieldDescriptor
2141  s_fdReducedPowerMode;
2143 
2145  inline EImpinjReducedPowerMode
2147  {
2148  return m_eReducedPowerMode;
2149  }
2150 
2152  inline void
2154  EImpinjReducedPowerMode value)
2155  {
2156  m_eReducedPowerMode = value;
2157  }
2158 
2159 
2160  protected:
2161  llrp_u16v_t m_ChannelList;
2162 
2165  public:
2166  static const CFieldDescriptor
2167  s_fdChannelList;
2169 
2171  inline llrp_u16v_t
2173  {
2174  return m_ChannelList;
2175  }
2176 
2178  inline void
2180  llrp_u16v_t value)
2181  {
2182  m_ChannelList = value;
2183  }
2184 
2185 
2186  protected:
2187  std::list<CParameter *> m_listCustom;
2188 
2189  public:
2191  inline std::list<CParameter *>::iterator
2193  {
2194  return m_listCustom.begin();
2195  }
2196 
2198  inline std::list<CParameter *>::iterator
2199  endCustom (void)
2200  {
2201  return m_listCustom.end();
2202  }
2203 
2205  inline void
2207  {
2208  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2209  }
2210 
2212  inline int
2214  {
2215  return (int) (m_listCustom.size());
2216  }
2217 
2218  EResultCode
2220  addCustom (
2221  CParameter * pValue);
2222 
2223 
2224 };
2225 
2226 
2256 class CImpinjLowDutyCycle : public CParameter
2257 {
2258  public:
2259  CImpinjLowDutyCycle (void);
2260  ~CImpinjLowDutyCycle (void);
2261 
2264 
2265  static const CFieldDescriptor * const
2266  s_apFieldDescriptorTable[];
2267 
2268  static const CTypeDescriptor
2269  s_typeDescriptor;
2270 
2271  void
2272  decodeFields (
2273  CDecoderStream * pDecoderStream);
2274 
2275  void
2276  assimilateSubParameters (
2277  CErrorDetails * pError);
2278 
2279  void
2280  encode (
2281  CEncoderStream * pEncoderStream) const;
2282 
2283 
2284  llrp_bool_t
2285  isAllowedIn (
2286  const CTypeDescriptor * pEnclosingElementType) const;
2287 
2288 
2289  static CElement *
2290  s_construct (void);
2291 
2292  static void
2293  s_decodeFields (
2294  CDecoderStream * pDecoderStream,
2295  CElement * pElement);
2297 
2298 
2299  protected:
2300  EImpinjLowDutyCycleMode m_eLowDutyCycleMode;
2301 
2304  public:
2305  static const CFieldDescriptor
2306  s_fdLowDutyCycleMode;
2308 
2310  inline EImpinjLowDutyCycleMode
2312  {
2313  return m_eLowDutyCycleMode;
2314  }
2315 
2317  inline void
2319  EImpinjLowDutyCycleMode value)
2320  {
2321  m_eLowDutyCycleMode = value;
2322  }
2323 
2324 
2325  protected:
2326  llrp_u16_t m_EmptyFieldTimeout;
2327 
2330  public:
2331  static const CFieldDescriptor
2332  s_fdEmptyFieldTimeout;
2334 
2336  inline llrp_u16_t
2338  {
2339  return m_EmptyFieldTimeout;
2340  }
2341 
2343  inline void
2345  llrp_u16_t value)
2346  {
2347  m_EmptyFieldTimeout = value;
2348  }
2349 
2350 
2351  protected:
2352  llrp_u16_t m_FieldPingInterval;
2353 
2356  public:
2357  static const CFieldDescriptor
2358  s_fdFieldPingInterval;
2360 
2362  inline llrp_u16_t
2364  {
2365  return m_FieldPingInterval;
2366  }
2367 
2369  inline void
2371  llrp_u16_t value)
2372  {
2373  m_FieldPingInterval = value;
2374  }
2375 
2376 
2377  protected:
2378  std::list<CParameter *> m_listCustom;
2379 
2380  public:
2382  inline std::list<CParameter *>::iterator
2384  {
2385  return m_listCustom.begin();
2386  }
2387 
2389  inline std::list<CParameter *>::iterator
2390  endCustom (void)
2391  {
2392  return m_listCustom.end();
2393  }
2394 
2396  inline void
2398  {
2399  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2400  }
2401 
2403  inline int
2405  {
2406  return (int) (m_listCustom.size());
2407  }
2408 
2409  EResultCode
2411  addCustom (
2412  CParameter * pValue);
2413 
2414 
2415 };
2416 
2417 
2442 class CImpinjHubVersions : public CParameter
2443 {
2444  public:
2445  CImpinjHubVersions (void);
2446  ~CImpinjHubVersions (void);
2447 
2450 
2451  static const CFieldDescriptor * const
2452  s_apFieldDescriptorTable[];
2453 
2454  static const CTypeDescriptor
2455  s_typeDescriptor;
2456 
2457  void
2458  decodeFields (
2459  CDecoderStream * pDecoderStream);
2460 
2461  void
2462  assimilateSubParameters (
2463  CErrorDetails * pError);
2464 
2465  void
2466  encode (
2467  CEncoderStream * pEncoderStream) const;
2468 
2469 
2470  llrp_bool_t
2471  isAllowedIn (
2472  const CTypeDescriptor * pEnclosingElementType) const;
2473 
2474 
2475  static CElement *
2476  s_construct (void);
2477 
2478  static void
2479  s_decodeFields (
2480  CDecoderStream * pDecoderStream,
2481  CElement * pElement);
2483 
2484 
2485  protected:
2486  std::list<CImpinjArrayVersion *> m_listImpinjArrayVersion;
2487 
2488  public:
2490  inline std::list<CImpinjArrayVersion *>::iterator
2492  {
2493  return m_listImpinjArrayVersion.begin();
2494  }
2495 
2497  inline std::list<CImpinjArrayVersion *>::iterator
2499  {
2500  return m_listImpinjArrayVersion.end();
2501  }
2502 
2504  inline void
2506  {
2507  clearSubParameterList ((tListOfParameters *) &m_listImpinjArrayVersion);
2508  }
2509 
2511  inline int
2513  {
2514  return (int) (m_listImpinjArrayVersion.size());
2515  }
2516 
2517  EResultCode
2520  CImpinjArrayVersion * pValue);
2521 
2522 
2523  protected:
2524  std::list<CParameter *> m_listCustom;
2525 
2526  public:
2528  inline std::list<CParameter *>::iterator
2530  {
2531  return m_listCustom.begin();
2532  }
2533 
2535  inline std::list<CParameter *>::iterator
2536  endCustom (void)
2537  {
2538  return m_listCustom.end();
2539  }
2540 
2542  inline void
2544  {
2545  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2546  }
2547 
2549  inline int
2551  {
2552  return (int) (m_listCustom.size());
2553  }
2554 
2555  EResultCode
2557  addCustom (
2558  CParameter * pValue);
2559 
2560 
2561 };
2562 
2563 
2596 class CImpinjDetailedVersion : public CParameter
2597 {
2598  public:
2599  CImpinjDetailedVersion (void);
2600  ~CImpinjDetailedVersion (void);
2601 
2604 
2605  static const CFieldDescriptor * const
2606  s_apFieldDescriptorTable[];
2607 
2608  static const CTypeDescriptor
2609  s_typeDescriptor;
2610 
2611  void
2612  decodeFields (
2613  CDecoderStream * pDecoderStream);
2614 
2615  void
2616  assimilateSubParameters (
2617  CErrorDetails * pError);
2618 
2619  void
2620  encode (
2621  CEncoderStream * pEncoderStream) const;
2622 
2623 
2624  llrp_bool_t
2625  isAllowedIn (
2626  const CTypeDescriptor * pEnclosingElementType) const;
2627 
2628 
2629  static CElement *
2630  s_construct (void);
2631 
2632  static void
2633  s_decodeFields (
2634  CDecoderStream * pDecoderStream,
2635  CElement * pElement);
2637 
2638 
2639  protected:
2640  llrp_utf8v_t m_ModelName;
2641 
2644  public:
2645  static const CFieldDescriptor
2646  s_fdModelName;
2648 
2650  inline llrp_utf8v_t
2652  {
2653  return m_ModelName;
2654  }
2655 
2657  inline void
2659  llrp_utf8v_t value)
2660  {
2661  m_ModelName = value;
2662  }
2663 
2664 
2665  protected:
2666  llrp_utf8v_t m_SerialNumber;
2667 
2670  public:
2671  static const CFieldDescriptor
2672  s_fdSerialNumber;
2674 
2676  inline llrp_utf8v_t
2678  {
2679  return m_SerialNumber;
2680  }
2681 
2683  inline void
2685  llrp_utf8v_t value)
2686  {
2687  m_SerialNumber = value;
2688  }
2689 
2690 
2691  protected:
2692  llrp_utf8v_t m_SoftwareVersion;
2693 
2696  public:
2697  static const CFieldDescriptor
2698  s_fdSoftwareVersion;
2700 
2702  inline llrp_utf8v_t
2704  {
2705  return m_SoftwareVersion;
2706  }
2707 
2709  inline void
2711  llrp_utf8v_t value)
2712  {
2713  m_SoftwareVersion = value;
2714  }
2715 
2716 
2717  protected:
2718  llrp_utf8v_t m_FirmwareVersion;
2719 
2722  public:
2723  static const CFieldDescriptor
2724  s_fdFirmwareVersion;
2726 
2728  inline llrp_utf8v_t
2730  {
2731  return m_FirmwareVersion;
2732  }
2733 
2735  inline void
2737  llrp_utf8v_t value)
2738  {
2739  m_FirmwareVersion = value;
2740  }
2741 
2742 
2743  protected:
2744  llrp_utf8v_t m_FPGAVersion;
2745 
2748  public:
2749  static const CFieldDescriptor
2750  s_fdFPGAVersion;
2752 
2754  inline llrp_utf8v_t
2756  {
2757  return m_FPGAVersion;
2758  }
2759 
2761  inline void
2763  llrp_utf8v_t value)
2764  {
2765  m_FPGAVersion = value;
2766  }
2767 
2768 
2769  protected:
2770  llrp_utf8v_t m_PCBAVersion;
2771 
2774  public:
2775  static const CFieldDescriptor
2776  s_fdPCBAVersion;
2778 
2780  inline llrp_utf8v_t
2782  {
2783  return m_PCBAVersion;
2784  }
2785 
2787  inline void
2789  llrp_utf8v_t value)
2790  {
2791  m_PCBAVersion = value;
2792  }
2793 
2794 
2795  protected:
2796  CImpinjHubVersions * m_pImpinjHubVersions;
2797 
2798  public:
2800  inline CImpinjHubVersions *
2802  {
2803  return m_pImpinjHubVersions;
2804  }
2805 
2807  EResultCode
2809  CImpinjHubVersions * pValue);
2810 
2811 
2812  protected:
2813  CImpinjArrayVersion * m_pImpinjArrayVersion;
2814 
2815  public:
2817  inline CImpinjArrayVersion *
2819  {
2820  return m_pImpinjArrayVersion;
2821  }
2822 
2824  EResultCode
2826  CImpinjArrayVersion * pValue);
2827 
2828 
2829  protected:
2830  CImpinjBLEVersion * m_pImpinjBLEVersion;
2831 
2832  public:
2834  inline CImpinjBLEVersion *
2836  {
2837  return m_pImpinjBLEVersion;
2838  }
2839 
2841  EResultCode
2843  CImpinjBLEVersion * pValue);
2844 
2845 
2846  protected:
2847  std::list<CParameter *> m_listCustom;
2848 
2849  public:
2851  inline std::list<CParameter *>::iterator
2853  {
2854  return m_listCustom.begin();
2855  }
2856 
2858  inline std::list<CParameter *>::iterator
2859  endCustom (void)
2860  {
2861  return m_listCustom.end();
2862  }
2863 
2865  inline void
2867  {
2868  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2869  }
2870 
2872  inline int
2874  {
2875  return (int) (m_listCustom.size());
2876  }
2877 
2878  EResultCode
2880  addCustom (
2881  CParameter * pValue);
2882 
2883 
2884 };
2885 
2886 
2911 class CImpinjFrequencyCapabilities : public CParameter
2912 {
2913  public:
2916 
2919 
2920  static const CFieldDescriptor * const
2921  s_apFieldDescriptorTable[];
2922 
2923  static const CTypeDescriptor
2924  s_typeDescriptor;
2925 
2926  void
2927  decodeFields (
2928  CDecoderStream * pDecoderStream);
2929 
2930  void
2931  assimilateSubParameters (
2932  CErrorDetails * pError);
2933 
2934  void
2935  encode (
2936  CEncoderStream * pEncoderStream) const;
2937 
2938 
2939  llrp_bool_t
2940  isAllowedIn (
2941  const CTypeDescriptor * pEnclosingElementType) const;
2942 
2943 
2944  static CElement *
2945  s_construct (void);
2946 
2947  static void
2948  s_decodeFields (
2949  CDecoderStream * pDecoderStream,
2950  CElement * pElement);
2952 
2953 
2954  protected:
2955  llrp_u32v_t m_FrequencyList;
2956 
2959  public:
2960  static const CFieldDescriptor
2961  s_fdFrequencyList;
2963 
2965  inline llrp_u32v_t
2967  {
2968  return m_FrequencyList;
2969  }
2970 
2972  inline void
2974  llrp_u32v_t value)
2975  {
2976  m_FrequencyList = value;
2977  }
2978 
2979 
2980  protected:
2981  std::list<CParameter *> m_listCustom;
2982 
2983  public:
2985  inline std::list<CParameter *>::iterator
2987  {
2988  return m_listCustom.begin();
2989  }
2990 
2992  inline std::list<CParameter *>::iterator
2993  endCustom (void)
2994  {
2995  return m_listCustom.end();
2996  }
2997 
2999  inline void
3001  {
3002  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3003  }
3004 
3006  inline int
3008  {
3009  return (int) (m_listCustom.size());
3010  }
3011 
3012  EResultCode
3014  addCustom (
3015  CParameter * pValue);
3016 
3017 
3018 };
3019 
3020 
3047 class CImpinjGPIDebounceConfiguration : public CParameter
3048 {
3049  public:
3052 
3055 
3056  static const CFieldDescriptor * const
3057  s_apFieldDescriptorTable[];
3058 
3059  static const CTypeDescriptor
3060  s_typeDescriptor;
3061 
3062  void
3063  decodeFields (
3064  CDecoderStream * pDecoderStream);
3065 
3066  void
3067  assimilateSubParameters (
3068  CErrorDetails * pError);
3069 
3070  void
3071  encode (
3072  CEncoderStream * pEncoderStream) const;
3073 
3074 
3075  llrp_bool_t
3076  isAllowedIn (
3077  const CTypeDescriptor * pEnclosingElementType) const;
3078 
3079 
3080  static CElement *
3081  s_construct (void);
3082 
3083  static void
3084  s_decodeFields (
3085  CDecoderStream * pDecoderStream,
3086  CElement * pElement);
3088 
3089 
3090  protected:
3091  llrp_u16_t m_GPIPortNum;
3092 
3095  public:
3096  static const CFieldDescriptor
3097  s_fdGPIPortNum;
3099 
3101  inline llrp_u16_t
3103  {
3104  return m_GPIPortNum;
3105  }
3106 
3108  inline void
3110  llrp_u16_t value)
3111  {
3112  m_GPIPortNum = value;
3113  }
3114 
3115 
3116  protected:
3117  llrp_u32_t m_GPIDebounceTimerMSec;
3118 
3121  public:
3122  static const CFieldDescriptor
3123  s_fdGPIDebounceTimerMSec;
3125 
3127  inline llrp_u32_t
3129  {
3130  return m_GPIDebounceTimerMSec;
3131  }
3132 
3134  inline void
3136  llrp_u32_t value)
3137  {
3138  m_GPIDebounceTimerMSec = value;
3139  }
3140 
3141 
3142  protected:
3143  std::list<CParameter *> m_listCustom;
3144 
3145  public:
3147  inline std::list<CParameter *>::iterator
3149  {
3150  return m_listCustom.begin();
3151  }
3152 
3154  inline std::list<CParameter *>::iterator
3155  endCustom (void)
3156  {
3157  return m_listCustom.end();
3158  }
3159 
3161  inline void
3163  {
3164  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3165  }
3166 
3168  inline int
3170  {
3171  return (int) (m_listCustom.size());
3172  }
3173 
3174  EResultCode
3176  addCustom (
3177  CParameter * pValue);
3178 
3179 
3180 };
3181 
3182 
3207 class CImpinjReaderTemperature : public CParameter
3208 {
3209  public:
3210  CImpinjReaderTemperature (void);
3211  ~CImpinjReaderTemperature (void);
3212 
3215 
3216  static const CFieldDescriptor * const
3217  s_apFieldDescriptorTable[];
3218 
3219  static const CTypeDescriptor
3220  s_typeDescriptor;
3221 
3222  void
3223  decodeFields (
3224  CDecoderStream * pDecoderStream);
3225 
3226  void
3227  assimilateSubParameters (
3228  CErrorDetails * pError);
3229 
3230  void
3231  encode (
3232  CEncoderStream * pEncoderStream) const;
3233 
3234 
3235  llrp_bool_t
3236  isAllowedIn (
3237  const CTypeDescriptor * pEnclosingElementType) const;
3238 
3239 
3240  static CElement *
3241  s_construct (void);
3242 
3243  static void
3244  s_decodeFields (
3245  CDecoderStream * pDecoderStream,
3246  CElement * pElement);
3248 
3249 
3250  protected:
3251  llrp_s16_t m_Temperature;
3252 
3255  public:
3256  static const CFieldDescriptor
3257  s_fdTemperature;
3259 
3261  inline llrp_s16_t
3263  {
3264  return m_Temperature;
3265  }
3266 
3268  inline void
3270  llrp_s16_t value)
3271  {
3272  m_Temperature = value;
3273  }
3274 
3275 
3276  protected:
3277  std::list<CParameter *> m_listCustom;
3278 
3279  public:
3281  inline std::list<CParameter *>::iterator
3283  {
3284  return m_listCustom.begin();
3285  }
3286 
3288  inline std::list<CParameter *>::iterator
3289  endCustom (void)
3290  {
3291  return m_listCustom.end();
3292  }
3293 
3295  inline void
3297  {
3298  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3299  }
3300 
3302  inline int
3304  {
3305  return (int) (m_listCustom.size());
3306  }
3307 
3308  EResultCode
3310  addCustom (
3311  CParameter * pValue);
3312 
3313 
3314 };
3315 
3316 
3343 class CImpinjLinkMonitorConfiguration : public CParameter
3344 {
3345  public:
3348 
3351 
3352  static const CFieldDescriptor * const
3353  s_apFieldDescriptorTable[];
3354 
3355  static const CTypeDescriptor
3356  s_typeDescriptor;
3357 
3358  void
3359  decodeFields (
3360  CDecoderStream * pDecoderStream);
3361 
3362  void
3363  assimilateSubParameters (
3364  CErrorDetails * pError);
3365 
3366  void
3367  encode (
3368  CEncoderStream * pEncoderStream) const;
3369 
3370 
3371  llrp_bool_t
3372  isAllowedIn (
3373  const CTypeDescriptor * pEnclosingElementType) const;
3374 
3375 
3376  static CElement *
3377  s_construct (void);
3378 
3379  static void
3380  s_decodeFields (
3381  CDecoderStream * pDecoderStream,
3382  CElement * pElement);
3384 
3385 
3386  protected:
3387  EImpinjLinkMonitorMode m_eLinkMonitorMode;
3388 
3391  public:
3392  static const CFieldDescriptor
3393  s_fdLinkMonitorMode;
3395 
3397  inline EImpinjLinkMonitorMode
3399  {
3400  return m_eLinkMonitorMode;
3401  }
3402 
3404  inline void
3406  EImpinjLinkMonitorMode value)
3407  {
3408  m_eLinkMonitorMode = value;
3409  }
3410 
3411 
3412  protected:
3413  llrp_u16_t m_LinkDownThreshold;
3414 
3417  public:
3418  static const CFieldDescriptor
3419  s_fdLinkDownThreshold;
3421 
3423  inline llrp_u16_t
3425  {
3426  return m_LinkDownThreshold;
3427  }
3428 
3430  inline void
3432  llrp_u16_t value)
3433  {
3434  m_LinkDownThreshold = value;
3435  }
3436 
3437 
3438  protected:
3439  std::list<CParameter *> m_listCustom;
3440 
3441  public:
3443  inline std::list<CParameter *>::iterator
3445  {
3446  return m_listCustom.begin();
3447  }
3448 
3450  inline std::list<CParameter *>::iterator
3451  endCustom (void)
3452  {
3453  return m_listCustom.end();
3454  }
3455 
3457  inline void
3459  {
3460  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3461  }
3462 
3464  inline int
3466  {
3467  return (int) (m_listCustom.size());
3468  }
3469 
3470  EResultCode
3472  addCustom (
3473  CParameter * pValue);
3474 
3475 
3476 };
3477 
3478 
3504 class CImpinjReportBufferConfiguration : public CParameter
3505 {
3506  public:
3509 
3512 
3513  static const CFieldDescriptor * const
3514  s_apFieldDescriptorTable[];
3515 
3516  static const CTypeDescriptor
3517  s_typeDescriptor;
3518 
3519  void
3520  decodeFields (
3521  CDecoderStream * pDecoderStream);
3522 
3523  void
3524  assimilateSubParameters (
3525  CErrorDetails * pError);
3526 
3527  void
3528  encode (
3529  CEncoderStream * pEncoderStream) const;
3530 
3531 
3532  llrp_bool_t
3533  isAllowedIn (
3534  const CTypeDescriptor * pEnclosingElementType) const;
3535 
3536 
3537  static CElement *
3538  s_construct (void);
3539 
3540  static void
3541  s_decodeFields (
3542  CDecoderStream * pDecoderStream,
3543  CElement * pElement);
3545 
3546 
3547  protected:
3548  EImpinjReportBufferMode m_eReportBufferMode;
3549 
3552  public:
3553  static const CFieldDescriptor
3554  s_fdReportBufferMode;
3556 
3558  inline EImpinjReportBufferMode
3560  {
3561  return m_eReportBufferMode;
3562  }
3563 
3565  inline void
3567  EImpinjReportBufferMode value)
3568  {
3569  m_eReportBufferMode = value;
3570  }
3571 
3572 
3573  protected:
3574  std::list<CParameter *> m_listCustom;
3575 
3576  public:
3578  inline std::list<CParameter *>::iterator
3580  {
3581  return m_listCustom.begin();
3582  }
3583 
3585  inline std::list<CParameter *>::iterator
3586  endCustom (void)
3587  {
3588  return m_listCustom.end();
3589  }
3590 
3592  inline void
3594  {
3595  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3596  }
3597 
3599  inline int
3601  {
3602  return (int) (m_listCustom.size());
3603  }
3604 
3605  EResultCode
3607  addCustom (
3608  CParameter * pValue);
3609 
3610 
3611 };
3612 
3613 
3642 class CImpinjAccessSpecConfiguration : public CParameter
3643 {
3644  public:
3647 
3650 
3651  static const CFieldDescriptor * const
3652  s_apFieldDescriptorTable[];
3653 
3654  static const CTypeDescriptor
3655  s_typeDescriptor;
3656 
3657  void
3658  decodeFields (
3659  CDecoderStream * pDecoderStream);
3660 
3661  void
3662  assimilateSubParameters (
3663  CErrorDetails * pError);
3664 
3665  void
3666  encode (
3667  CEncoderStream * pEncoderStream) const;
3668 
3669 
3670  llrp_bool_t
3671  isAllowedIn (
3672  const CTypeDescriptor * pEnclosingElementType) const;
3673 
3674 
3675  static CElement *
3676  s_construct (void);
3677 
3678  static void
3679  s_decodeFields (
3680  CDecoderStream * pDecoderStream,
3681  CElement * pElement);
3683 
3684 
3685  protected:
3686  CImpinjBlockWriteWordCount * m_pImpinjBlockWriteWordCount;
3687 
3688  public:
3692  {
3693  return m_pImpinjBlockWriteWordCount;
3694  }
3695 
3697  EResultCode
3699  CImpinjBlockWriteWordCount * pValue);
3700 
3701 
3702  protected:
3703  CImpinjOpSpecRetryCount * m_pImpinjOpSpecRetryCount;
3704 
3705  public:
3707  inline CImpinjOpSpecRetryCount *
3709  {
3710  return m_pImpinjOpSpecRetryCount;
3711  }
3712 
3714  EResultCode
3716  CImpinjOpSpecRetryCount * pValue);
3717 
3718 
3719  protected:
3720  CImpinjAccessSpecOrdering * m_pImpinjAccessSpecOrdering;
3721 
3722  public:
3724  inline CImpinjAccessSpecOrdering *
3726  {
3727  return m_pImpinjAccessSpecOrdering;
3728  }
3729 
3731  EResultCode
3733  CImpinjAccessSpecOrdering * pValue);
3734 
3735 
3736  protected:
3737  std::list<CParameter *> m_listCustom;
3738 
3739  public:
3741  inline std::list<CParameter *>::iterator
3743  {
3744  return m_listCustom.begin();
3745  }
3746 
3748  inline std::list<CParameter *>::iterator
3749  endCustom (void)
3750  {
3751  return m_listCustom.end();
3752  }
3753 
3755  inline void
3757  {
3758  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3759  }
3760 
3762  inline int
3764  {
3765  return (int) (m_listCustom.size());
3766  }
3767 
3768  EResultCode
3770  addCustom (
3771  CParameter * pValue);
3772 
3773 
3774 };
3775 
3776 
3800 class CImpinjBlockWriteWordCount : public CParameter
3801 {
3802  public:
3805 
3808 
3809  static const CFieldDescriptor * const
3810  s_apFieldDescriptorTable[];
3811 
3812  static const CTypeDescriptor
3813  s_typeDescriptor;
3814 
3815  void
3816  decodeFields (
3817  CDecoderStream * pDecoderStream);
3818 
3819  void
3820  assimilateSubParameters (
3821  CErrorDetails * pError);
3822 
3823  void
3824  encode (
3825  CEncoderStream * pEncoderStream) const;
3826 
3827 
3828  llrp_bool_t
3829  isAllowedIn (
3830  const CTypeDescriptor * pEnclosingElementType) const;
3831 
3832 
3833  static CElement *
3834  s_construct (void);
3835 
3836  static void
3837  s_decodeFields (
3838  CDecoderStream * pDecoderStream,
3839  CElement * pElement);
3841 
3842 
3843  protected:
3844  llrp_u16_t m_WordCount;
3845 
3848  public:
3849  static const CFieldDescriptor
3850  s_fdWordCount;
3852 
3854  inline llrp_u16_t
3856  {
3857  return m_WordCount;
3858  }
3859 
3861  inline void
3863  llrp_u16_t value)
3864  {
3865  m_WordCount = value;
3866  }
3867 
3868 
3869  protected:
3870  std::list<CParameter *> m_listCustom;
3871 
3872  public:
3874  inline std::list<CParameter *>::iterator
3876  {
3877  return m_listCustom.begin();
3878  }
3879 
3881  inline std::list<CParameter *>::iterator
3882  endCustom (void)
3883  {
3884  return m_listCustom.end();
3885  }
3886 
3888  inline void
3890  {
3891  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3892  }
3893 
3895  inline int
3897  {
3898  return (int) (m_listCustom.size());
3899  }
3900 
3901  EResultCode
3903  addCustom (
3904  CParameter * pValue);
3905 
3906 
3907 };
3908 
3909 
3939 class CImpinjBlockPermalock : public CParameter
3940 {
3941  public:
3942  CImpinjBlockPermalock (void);
3943  ~CImpinjBlockPermalock (void);
3944 
3947 
3948  static const CFieldDescriptor * const
3949  s_apFieldDescriptorTable[];
3950 
3951  static const CTypeDescriptor
3952  s_typeDescriptor;
3953 
3954  void
3955  decodeFields (
3956  CDecoderStream * pDecoderStream);
3957 
3958  void
3959  assimilateSubParameters (
3960  CErrorDetails * pError);
3961 
3962  void
3963  encode (
3964  CEncoderStream * pEncoderStream) const;
3965 
3966 
3967  llrp_bool_t
3968  isAllowedIn (
3969  const CTypeDescriptor * pEnclosingElementType) const;
3970 
3971 
3972  static CElement *
3973  s_construct (void);
3974 
3975  static void
3976  s_decodeFields (
3977  CDecoderStream * pDecoderStream,
3978  CElement * pElement);
3980 
3981 
3982  protected:
3983  llrp_u16_t m_OpSpecID;
3984 
3987  public:
3988  static const CFieldDescriptor
3989  s_fdOpSpecID;
3991 
3993  inline llrp_u16_t
3995  {
3996  return m_OpSpecID;
3997  }
3998 
4000  inline void
4002  llrp_u16_t value)
4003  {
4004  m_OpSpecID = value;
4005  }
4006 
4007 
4008  protected:
4009  llrp_u32_t m_AccessPassword;
4010 
4013  public:
4014  static const CFieldDescriptor
4015  s_fdAccessPassword;
4017 
4019  inline llrp_u32_t
4021  {
4022  return m_AccessPassword;
4023  }
4024 
4026  inline void
4028  llrp_u32_t value)
4029  {
4030  m_AccessPassword = value;
4031  }
4032 
4033 
4034  protected:
4035  llrp_u2_t m_MB;
4036 
4039  public:
4040  static const CFieldDescriptor
4041  s_fdMB;
4043 
4045  inline llrp_u2_t
4046  getMB (void)
4047  {
4048  return m_MB;
4049  }
4050 
4052  inline void
4054  llrp_u2_t value)
4055  {
4056  m_MB = value;
4057  }
4058 
4059 
4060  protected:
4061  llrp_u16_t m_BlockPointer;
4062 
4065  public:
4066  static const CFieldDescriptor
4067  s_fdBlockPointer;
4069 
4071  inline llrp_u16_t
4073  {
4074  return m_BlockPointer;
4075  }
4076 
4078  inline void
4080  llrp_u16_t value)
4081  {
4082  m_BlockPointer = value;
4083  }
4084 
4085 
4086  protected:
4087  llrp_u16v_t m_BlockMask;
4088 
4091  public:
4092  static const CFieldDescriptor
4093  s_fdBlockMask;
4095 
4097  inline llrp_u16v_t
4099  {
4100  return m_BlockMask;
4101  }
4102 
4104  inline void
4106  llrp_u16v_t value)
4107  {
4108  m_BlockMask = value;
4109  }
4110 
4111 
4112  protected:
4113  std::list<CParameter *> m_listCustom;
4114 
4115  public:
4117  inline std::list<CParameter *>::iterator
4119  {
4120  return m_listCustom.begin();
4121  }
4122 
4124  inline std::list<CParameter *>::iterator
4125  endCustom (void)
4126  {
4127  return m_listCustom.end();
4128  }
4129 
4131  inline void
4133  {
4134  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4135  }
4136 
4138  inline int
4140  {
4141  return (int) (m_listCustom.size());
4142  }
4143 
4144  EResultCode
4146  addCustom (
4147  CParameter * pValue);
4148 
4149 
4150 };
4151 
4152 
4178 class CImpinjBlockPermalockOpSpecResult : public CParameter
4179 {
4180  public:
4183 
4186 
4187  static const CFieldDescriptor * const
4188  s_apFieldDescriptorTable[];
4189 
4190  static const CTypeDescriptor
4191  s_typeDescriptor;
4192 
4193  void
4194  decodeFields (
4195  CDecoderStream * pDecoderStream);
4196 
4197  void
4198  assimilateSubParameters (
4199  CErrorDetails * pError);
4200 
4201  void
4202  encode (
4203  CEncoderStream * pEncoderStream) const;
4204 
4205 
4206  llrp_bool_t
4207  isAllowedIn (
4208  const CTypeDescriptor * pEnclosingElementType) const;
4209 
4210 
4211  static CElement *
4212  s_construct (void);
4213 
4214  static void
4215  s_decodeFields (
4216  CDecoderStream * pDecoderStream,
4217  CElement * pElement);
4219 
4220 
4221  protected:
4222  EImpinjBlockPermalockResultType m_eResult;
4223 
4226  public:
4227  static const CFieldDescriptor
4228  s_fdResult;
4230 
4232  inline EImpinjBlockPermalockResultType
4233  getResult (void)
4234  {
4235  return m_eResult;
4236  }
4237 
4239  inline void
4241  EImpinjBlockPermalockResultType value)
4242  {
4243  m_eResult = value;
4244  }
4245 
4246 
4247  protected:
4248  llrp_u16_t m_OpSpecID;
4249 
4252  public:
4253  static const CFieldDescriptor
4254  s_fdOpSpecID;
4256 
4258  inline llrp_u16_t
4260  {
4261  return m_OpSpecID;
4262  }
4263 
4265  inline void
4267  llrp_u16_t value)
4268  {
4269  m_OpSpecID = value;
4270  }
4271 
4272 
4273  protected:
4274  std::list<CParameter *> m_listCustom;
4275 
4276  public:
4278  inline std::list<CParameter *>::iterator
4280  {
4281  return m_listCustom.begin();
4282  }
4283 
4285  inline std::list<CParameter *>::iterator
4286  endCustom (void)
4287  {
4288  return m_listCustom.end();
4289  }
4290 
4292  inline void
4294  {
4295  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4296  }
4297 
4299  inline int
4301  {
4302  return (int) (m_listCustom.size());
4303  }
4304 
4305  EResultCode
4307  addCustom (
4308  CParameter * pValue);
4309 
4310 
4311 };
4312 
4313 
4343 class CImpinjGetBlockPermalockStatus : public CParameter
4344 {
4345  public:
4348 
4351 
4352  static const CFieldDescriptor * const
4353  s_apFieldDescriptorTable[];
4354 
4355  static const CTypeDescriptor
4356  s_typeDescriptor;
4357 
4358  void
4359  decodeFields (
4360  CDecoderStream * pDecoderStream);
4361 
4362  void
4363  assimilateSubParameters (
4364  CErrorDetails * pError);
4365 
4366  void
4367  encode (
4368  CEncoderStream * pEncoderStream) const;
4369 
4370 
4371  llrp_bool_t
4372  isAllowedIn (
4373  const CTypeDescriptor * pEnclosingElementType) const;
4374 
4375 
4376  static CElement *
4377  s_construct (void);
4378 
4379  static void
4380  s_decodeFields (
4381  CDecoderStream * pDecoderStream,
4382  CElement * pElement);
4384 
4385 
4386  protected:
4387  llrp_u16_t m_OpSpecID;
4388 
4391  public:
4392  static const CFieldDescriptor
4393  s_fdOpSpecID;
4395 
4397  inline llrp_u16_t
4399  {
4400  return m_OpSpecID;
4401  }
4402 
4404  inline void
4406  llrp_u16_t value)
4407  {
4408  m_OpSpecID = value;
4409  }
4410 
4411 
4412  protected:
4413  llrp_u32_t m_AccessPassword;
4414 
4417  public:
4418  static const CFieldDescriptor
4419  s_fdAccessPassword;
4421 
4423  inline llrp_u32_t
4425  {
4426  return m_AccessPassword;
4427  }
4428 
4430  inline void
4432  llrp_u32_t value)
4433  {
4434  m_AccessPassword = value;
4435  }
4436 
4437 
4438  protected:
4439  llrp_u2_t m_MB;
4440 
4443  public:
4444  static const CFieldDescriptor
4445  s_fdMB;
4447 
4449  inline llrp_u2_t
4450  getMB (void)
4451  {
4452  return m_MB;
4453  }
4454 
4456  inline void
4458  llrp_u2_t value)
4459  {
4460  m_MB = value;
4461  }
4462 
4463 
4464  protected:
4465  llrp_u16_t m_BlockPointer;
4466 
4469  public:
4470  static const CFieldDescriptor
4471  s_fdBlockPointer;
4473 
4475  inline llrp_u16_t
4477  {
4478  return m_BlockPointer;
4479  }
4480 
4482  inline void
4484  llrp_u16_t value)
4485  {
4486  m_BlockPointer = value;
4487  }
4488 
4489 
4490  protected:
4491  llrp_u16_t m_BlockRange;
4492 
4495  public:
4496  static const CFieldDescriptor
4497  s_fdBlockRange;
4499 
4501  inline llrp_u16_t
4503  {
4504  return m_BlockRange;
4505  }
4506 
4508  inline void
4510  llrp_u16_t value)
4511  {
4512  m_BlockRange = value;
4513  }
4514 
4515 
4516  protected:
4517  std::list<CParameter *> m_listCustom;
4518 
4519  public:
4521  inline std::list<CParameter *>::iterator
4523  {
4524  return m_listCustom.begin();
4525  }
4526 
4528  inline std::list<CParameter *>::iterator
4529  endCustom (void)
4530  {
4531  return m_listCustom.end();
4532  }
4533 
4535  inline void
4537  {
4538  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4539  }
4540 
4542  inline int
4544  {
4545  return (int) (m_listCustom.size());
4546  }
4547 
4548  EResultCode
4550  addCustom (
4551  CParameter * pValue);
4552 
4553 
4554 };
4555 
4556 
4584 {
4585  public:
4588 
4591 
4592  static const CFieldDescriptor * const
4593  s_apFieldDescriptorTable[];
4594 
4595  static const CTypeDescriptor
4596  s_typeDescriptor;
4597 
4598  void
4599  decodeFields (
4600  CDecoderStream * pDecoderStream);
4601 
4602  void
4603  assimilateSubParameters (
4604  CErrorDetails * pError);
4605 
4606  void
4607  encode (
4608  CEncoderStream * pEncoderStream) const;
4609 
4610 
4611  llrp_bool_t
4612  isAllowedIn (
4613  const CTypeDescriptor * pEnclosingElementType) const;
4614 
4615 
4616  static CElement *
4617  s_construct (void);
4618 
4619  static void
4620  s_decodeFields (
4621  CDecoderStream * pDecoderStream,
4622  CElement * pElement);
4624 
4625 
4626  protected:
4627  EImpinjGetBlockPermalockStatusResultType m_eResult;
4628 
4631  public:
4632  static const CFieldDescriptor
4633  s_fdResult;
4635 
4637  inline EImpinjGetBlockPermalockStatusResultType
4638  getResult (void)
4639  {
4640  return m_eResult;
4641  }
4642 
4644  inline void
4646  EImpinjGetBlockPermalockStatusResultType value)
4647  {
4648  m_eResult = value;
4649  }
4650 
4651 
4652  protected:
4653  llrp_u16_t m_OpSpecID;
4654 
4657  public:
4658  static const CFieldDescriptor
4659  s_fdOpSpecID;
4661 
4663  inline llrp_u16_t
4665  {
4666  return m_OpSpecID;
4667  }
4668 
4670  inline void
4672  llrp_u16_t value)
4673  {
4674  m_OpSpecID = value;
4675  }
4676 
4677 
4678  protected:
4679  llrp_u16v_t m_PermalockStatus;
4680 
4683  public:
4684  static const CFieldDescriptor
4685  s_fdPermalockStatus;
4687 
4689  inline llrp_u16v_t
4691  {
4692  return m_PermalockStatus;
4693  }
4694 
4696  inline void
4698  llrp_u16v_t value)
4699  {
4700  m_PermalockStatus = value;
4701  }
4702 
4703 
4704  protected:
4705  std::list<CParameter *> m_listCustom;
4706 
4707  public:
4709  inline std::list<CParameter *>::iterator
4711  {
4712  return m_listCustom.begin();
4713  }
4714 
4716  inline std::list<CParameter *>::iterator
4717  endCustom (void)
4718  {
4719  return m_listCustom.end();
4720  }
4721 
4723  inline void
4725  {
4726  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4727  }
4728 
4730  inline int
4732  {
4733  return (int) (m_listCustom.size());
4734  }
4735 
4736  EResultCode
4738  addCustom (
4739  CParameter * pValue);
4740 
4741 
4742 };
4743 
4744 
4774 class CImpinjSetQTConfig : public CParameter
4775 {
4776  public:
4777  CImpinjSetQTConfig (void);
4778  ~CImpinjSetQTConfig (void);
4779 
4782 
4783  static const CFieldDescriptor * const
4784  s_apFieldDescriptorTable[];
4785 
4786  static const CTypeDescriptor
4787  s_typeDescriptor;
4788 
4789  void
4790  decodeFields (
4791  CDecoderStream * pDecoderStream);
4792 
4793  void
4794  assimilateSubParameters (
4795  CErrorDetails * pError);
4796 
4797  void
4798  encode (
4799  CEncoderStream * pEncoderStream) const;
4800 
4801 
4802  llrp_bool_t
4803  isAllowedIn (
4804  const CTypeDescriptor * pEnclosingElementType) const;
4805 
4806 
4807  static CElement *
4808  s_construct (void);
4809 
4810  static void
4811  s_decodeFields (
4812  CDecoderStream * pDecoderStream,
4813  CElement * pElement);
4815 
4816 
4817  protected:
4818  llrp_u16_t m_OpSpecID;
4819 
4822  public:
4823  static const CFieldDescriptor
4824  s_fdOpSpecID;
4826 
4828  inline llrp_u16_t
4830  {
4831  return m_OpSpecID;
4832  }
4833 
4835  inline void
4837  llrp_u16_t value)
4838  {
4839  m_OpSpecID = value;
4840  }
4841 
4842 
4843  protected:
4844  llrp_u32_t m_AccessPassword;
4845 
4848  public:
4849  static const CFieldDescriptor
4850  s_fdAccessPassword;
4852 
4854  inline llrp_u32_t
4856  {
4857  return m_AccessPassword;
4858  }
4859 
4861  inline void
4863  llrp_u32_t value)
4864  {
4865  m_AccessPassword = value;
4866  }
4867 
4868 
4869  protected:
4870  EImpinjQTDataProfile m_eDataProfile;
4871 
4874  public:
4875  static const CFieldDescriptor
4876  s_fdDataProfile;
4878 
4880  inline EImpinjQTDataProfile
4882  {
4883  return m_eDataProfile;
4884  }
4885 
4887  inline void
4889  EImpinjQTDataProfile value)
4890  {
4891  m_eDataProfile = value;
4892  }
4893 
4894 
4895  protected:
4896  EImpinjQTAccessRange m_eAccessRange;
4897 
4900  public:
4901  static const CFieldDescriptor
4902  s_fdAccessRange;
4904 
4906  inline EImpinjQTAccessRange
4908  {
4909  return m_eAccessRange;
4910  }
4911 
4913  inline void
4915  EImpinjQTAccessRange value)
4916  {
4917  m_eAccessRange = value;
4918  }
4919 
4920 
4921  protected:
4922  EImpinjQTPersistence m_ePersistence;
4923 
4926  public:
4927  static const CFieldDescriptor
4928  s_fdPersistence;
4930 
4932  inline EImpinjQTPersistence
4934  {
4935  return m_ePersistence;
4936  }
4937 
4939  inline void
4941  EImpinjQTPersistence value)
4942  {
4943  m_ePersistence = value;
4944  }
4945 
4946 
4947  protected:
4948  std::list<CParameter *> m_listCustom;
4949 
4950  public:
4952  inline std::list<CParameter *>::iterator
4954  {
4955  return m_listCustom.begin();
4956  }
4957 
4959  inline std::list<CParameter *>::iterator
4960  endCustom (void)
4961  {
4962  return m_listCustom.end();
4963  }
4964 
4966  inline void
4968  {
4969  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4970  }
4971 
4973  inline int
4975  {
4976  return (int) (m_listCustom.size());
4977  }
4978 
4979  EResultCode
4981  addCustom (
4982  CParameter * pValue);
4983 
4984 
4985 };
4986 
4987 
5013 class CImpinjSetQTConfigOpSpecResult : public CParameter
5014 {
5015  public:
5018 
5021 
5022  static const CFieldDescriptor * const
5023  s_apFieldDescriptorTable[];
5024 
5025  static const CTypeDescriptor
5026  s_typeDescriptor;
5027 
5028  void
5029  decodeFields (
5030  CDecoderStream * pDecoderStream);
5031 
5032  void
5033  assimilateSubParameters (
5034  CErrorDetails * pError);
5035 
5036  void
5037  encode (
5038  CEncoderStream * pEncoderStream) const;
5039 
5040 
5041  llrp_bool_t
5042  isAllowedIn (
5043  const CTypeDescriptor * pEnclosingElementType) const;
5044 
5045 
5046  static CElement *
5047  s_construct (void);
5048 
5049  static void
5050  s_decodeFields (
5051  CDecoderStream * pDecoderStream,
5052  CElement * pElement);
5054 
5055 
5056  protected:
5057  EImpinjSetQTConfigResultType m_eResult;
5058 
5061  public:
5062  static const CFieldDescriptor
5063  s_fdResult;
5065 
5067  inline EImpinjSetQTConfigResultType
5068  getResult (void)
5069  {
5070  return m_eResult;
5071  }
5072 
5074  inline void
5076  EImpinjSetQTConfigResultType value)
5077  {
5078  m_eResult = value;
5079  }
5080 
5081 
5082  protected:
5083  llrp_u16_t m_OpSpecID;
5084 
5087  public:
5088  static const CFieldDescriptor
5089  s_fdOpSpecID;
5091 
5093  inline llrp_u16_t
5095  {
5096  return m_OpSpecID;
5097  }
5098 
5100  inline void
5102  llrp_u16_t value)
5103  {
5104  m_OpSpecID = value;
5105  }
5106 
5107 
5108  protected:
5109  std::list<CParameter *> m_listCustom;
5110 
5111  public:
5113  inline std::list<CParameter *>::iterator
5115  {
5116  return m_listCustom.begin();
5117  }
5118 
5120  inline std::list<CParameter *>::iterator
5121  endCustom (void)
5122  {
5123  return m_listCustom.end();
5124  }
5125 
5127  inline void
5129  {
5130  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5131  }
5132 
5134  inline int
5136  {
5137  return (int) (m_listCustom.size());
5138  }
5139 
5140  EResultCode
5142  addCustom (
5143  CParameter * pValue);
5144 
5145 
5146 };
5147 
5148 
5174 class CImpinjGetQTConfig : public CParameter
5175 {
5176  public:
5177  CImpinjGetQTConfig (void);
5178  ~CImpinjGetQTConfig (void);
5179 
5182 
5183  static const CFieldDescriptor * const
5184  s_apFieldDescriptorTable[];
5185 
5186  static const CTypeDescriptor
5187  s_typeDescriptor;
5188 
5189  void
5190  decodeFields (
5191  CDecoderStream * pDecoderStream);
5192 
5193  void
5194  assimilateSubParameters (
5195  CErrorDetails * pError);
5196 
5197  void
5198  encode (
5199  CEncoderStream * pEncoderStream) const;
5200 
5201 
5202  llrp_bool_t
5203  isAllowedIn (
5204  const CTypeDescriptor * pEnclosingElementType) const;
5205 
5206 
5207  static CElement *
5208  s_construct (void);
5209 
5210  static void
5211  s_decodeFields (
5212  CDecoderStream * pDecoderStream,
5213  CElement * pElement);
5215 
5216 
5217  protected:
5218  llrp_u16_t m_OpSpecID;
5219 
5222  public:
5223  static const CFieldDescriptor
5224  s_fdOpSpecID;
5226 
5228  inline llrp_u16_t
5230  {
5231  return m_OpSpecID;
5232  }
5233 
5235  inline void
5237  llrp_u16_t value)
5238  {
5239  m_OpSpecID = value;
5240  }
5241 
5242 
5243  protected:
5244  llrp_u32_t m_AccessPassword;
5245 
5248  public:
5249  static const CFieldDescriptor
5250  s_fdAccessPassword;
5252 
5254  inline llrp_u32_t
5256  {
5257  return m_AccessPassword;
5258  }
5259 
5261  inline void
5263  llrp_u32_t value)
5264  {
5265  m_AccessPassword = value;
5266  }
5267 
5268 
5269  protected:
5270  std::list<CParameter *> m_listCustom;
5271 
5272  public:
5274  inline std::list<CParameter *>::iterator
5276  {
5277  return m_listCustom.begin();
5278  }
5279 
5281  inline std::list<CParameter *>::iterator
5282  endCustom (void)
5283  {
5284  return m_listCustom.end();
5285  }
5286 
5288  inline void
5290  {
5291  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5292  }
5293 
5295  inline int
5297  {
5298  return (int) (m_listCustom.size());
5299  }
5300 
5301  EResultCode
5303  addCustom (
5304  CParameter * pValue);
5305 
5306 
5307 };
5308 
5309 
5338 class CImpinjGetQTConfigOpSpecResult : public CParameter
5339 {
5340  public:
5343 
5346 
5347  static const CFieldDescriptor * const
5348  s_apFieldDescriptorTable[];
5349 
5350  static const CTypeDescriptor
5351  s_typeDescriptor;
5352 
5353  void
5354  decodeFields (
5355  CDecoderStream * pDecoderStream);
5356 
5357  void
5358  assimilateSubParameters (
5359  CErrorDetails * pError);
5360 
5361  void
5362  encode (
5363  CEncoderStream * pEncoderStream) const;
5364 
5365 
5366  llrp_bool_t
5367  isAllowedIn (
5368  const CTypeDescriptor * pEnclosingElementType) const;
5369 
5370 
5371  static CElement *
5372  s_construct (void);
5373 
5374  static void
5375  s_decodeFields (
5376  CDecoderStream * pDecoderStream,
5377  CElement * pElement);
5379 
5380 
5381  protected:
5382  EImpinjGetQTConfigResultType m_eResult;
5383 
5386  public:
5387  static const CFieldDescriptor
5388  s_fdResult;
5390 
5392  inline EImpinjGetQTConfigResultType
5393  getResult (void)
5394  {
5395  return m_eResult;
5396  }
5397 
5399  inline void
5401  EImpinjGetQTConfigResultType value)
5402  {
5403  m_eResult = value;
5404  }
5405 
5406 
5407  protected:
5408  llrp_u16_t m_OpSpecID;
5409 
5412  public:
5413  static const CFieldDescriptor
5414  s_fdOpSpecID;
5416 
5418  inline llrp_u16_t
5420  {
5421  return m_OpSpecID;
5422  }
5423 
5425  inline void
5427  llrp_u16_t value)
5428  {
5429  m_OpSpecID = value;
5430  }
5431 
5432 
5433  protected:
5434  EImpinjQTDataProfile m_eDataProfile;
5435 
5438  public:
5439  static const CFieldDescriptor
5440  s_fdDataProfile;
5442 
5444  inline EImpinjQTDataProfile
5446  {
5447  return m_eDataProfile;
5448  }
5449 
5451  inline void
5453  EImpinjQTDataProfile value)
5454  {
5455  m_eDataProfile = value;
5456  }
5457 
5458 
5459  protected:
5460  EImpinjQTAccessRange m_eAccessRange;
5461 
5464  public:
5465  static const CFieldDescriptor
5466  s_fdAccessRange;
5468 
5470  inline EImpinjQTAccessRange
5472  {
5473  return m_eAccessRange;
5474  }
5475 
5477  inline void
5479  EImpinjQTAccessRange value)
5480  {
5481  m_eAccessRange = value;
5482  }
5483 
5484 
5485  protected:
5486  std::list<CParameter *> m_listCustom;
5487 
5488  public:
5490  inline std::list<CParameter *>::iterator
5492  {
5493  return m_listCustom.begin();
5494  }
5495 
5497  inline std::list<CParameter *>::iterator
5498  endCustom (void)
5499  {
5500  return m_listCustom.end();
5501  }
5502 
5504  inline void
5506  {
5507  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5508  }
5509 
5511  inline int
5513  {
5514  return (int) (m_listCustom.size());
5515  }
5516 
5517  EResultCode
5519  addCustom (
5520  CParameter * pValue);
5521 
5522 
5523 };
5524 
5525 
5555 class CImpinjTagReportContentSelector : public CParameter
5556 {
5557  public:
5560 
5563 
5564  static const CFieldDescriptor * const
5565  s_apFieldDescriptorTable[];
5566 
5567  static const CTypeDescriptor
5568  s_typeDescriptor;
5569 
5570  void
5571  decodeFields (
5572  CDecoderStream * pDecoderStream);
5573 
5574  void
5575  assimilateSubParameters (
5576  CErrorDetails * pError);
5577 
5578  void
5579  encode (
5580  CEncoderStream * pEncoderStream) const;
5581 
5582 
5583  llrp_bool_t
5584  isAllowedIn (
5585  const CTypeDescriptor * pEnclosingElementType) const;
5586 
5587 
5588  static CElement *
5589  s_construct (void);
5590 
5591  static void
5592  s_decodeFields (
5593  CDecoderStream * pDecoderStream,
5594  CElement * pElement);
5596 
5597 
5598  protected:
5599  CImpinjEnableSerializedTID * m_pImpinjEnableSerializedTID;
5600 
5601  public:
5605  {
5606  return m_pImpinjEnableSerializedTID;
5607  }
5608 
5610  EResultCode
5612  CImpinjEnableSerializedTID * pValue);
5613 
5614 
5615  protected:
5616  CImpinjEnableRFPhaseAngle * m_pImpinjEnableRFPhaseAngle;
5617 
5618  public:
5620  inline CImpinjEnableRFPhaseAngle *
5622  {
5623  return m_pImpinjEnableRFPhaseAngle;
5624  }
5625 
5627  EResultCode
5629  CImpinjEnableRFPhaseAngle * pValue);
5630 
5631 
5632  protected:
5633  CImpinjEnablePeakRSSI * m_pImpinjEnablePeakRSSI;
5634 
5635  public:
5637  inline CImpinjEnablePeakRSSI *
5639  {
5640  return m_pImpinjEnablePeakRSSI;
5641  }
5642 
5644  EResultCode
5646  CImpinjEnablePeakRSSI * pValue);
5647 
5648 
5649  protected:
5650  CImpinjEnableGPSCoordinates * m_pImpinjEnableGPSCoordinates;
5651 
5652  public:
5656  {
5657  return m_pImpinjEnableGPSCoordinates;
5658  }
5659 
5661  EResultCode
5663  CImpinjEnableGPSCoordinates * pValue);
5664 
5665 
5666  protected:
5667  CImpinjEnableOptimizedRead * m_pImpinjEnableOptimizedRead;
5668 
5669  public:
5673  {
5674  return m_pImpinjEnableOptimizedRead;
5675  }
5676 
5678  EResultCode
5680  CImpinjEnableOptimizedRead * pValue);
5681 
5682 
5683  protected:
5684  CImpinjEnableRFDopplerFrequency * m_pImpinjEnableRFDopplerFrequency;
5685 
5686  public:
5690  {
5691  return m_pImpinjEnableRFDopplerFrequency;
5692  }
5693 
5695  EResultCode
5698 
5699 
5700  protected:
5701  std::list<CParameter *> m_listCustom;
5702 
5703  public:
5705  inline std::list<CParameter *>::iterator
5707  {
5708  return m_listCustom.begin();
5709  }
5710 
5712  inline std::list<CParameter *>::iterator
5713  endCustom (void)
5714  {
5715  return m_listCustom.end();
5716  }
5717 
5719  inline void
5721  {
5722  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5723  }
5724 
5726  inline int
5728  {
5729  return (int) (m_listCustom.size());
5730  }
5731 
5732  EResultCode
5734  addCustom (
5735  CParameter * pValue);
5736 
5737 
5738 };
5739 
5740 
5764 class CImpinjEnableSerializedTID : public CParameter
5765 {
5766  public:
5769 
5772 
5773  static const CFieldDescriptor * const
5774  s_apFieldDescriptorTable[];
5775 
5776  static const CTypeDescriptor
5777  s_typeDescriptor;
5778 
5779  void
5780  decodeFields (
5781  CDecoderStream * pDecoderStream);
5782 
5783  void
5784  assimilateSubParameters (
5785  CErrorDetails * pError);
5786 
5787  void
5788  encode (
5789  CEncoderStream * pEncoderStream) const;
5790 
5791 
5792  llrp_bool_t
5793  isAllowedIn (
5794  const CTypeDescriptor * pEnclosingElementType) const;
5795 
5796 
5797  static CElement *
5798  s_construct (void);
5799 
5800  static void
5801  s_decodeFields (
5802  CDecoderStream * pDecoderStream,
5803  CElement * pElement);
5805 
5806 
5807  protected:
5808  EImpinjSerializedTIDMode m_eSerializedTIDMode;
5809 
5812  public:
5813  static const CFieldDescriptor
5814  s_fdSerializedTIDMode;
5816 
5818  inline EImpinjSerializedTIDMode
5820  {
5821  return m_eSerializedTIDMode;
5822  }
5823 
5825  inline void
5827  EImpinjSerializedTIDMode value)
5828  {
5829  m_eSerializedTIDMode = value;
5830  }
5831 
5832 
5833  protected:
5834  std::list<CParameter *> m_listCustom;
5835 
5836  public:
5838  inline std::list<CParameter *>::iterator
5840  {
5841  return m_listCustom.begin();
5842  }
5843 
5845  inline std::list<CParameter *>::iterator
5846  endCustom (void)
5847  {
5848  return m_listCustom.end();
5849  }
5850 
5852  inline void
5854  {
5855  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5856  }
5857 
5859  inline int
5861  {
5862  return (int) (m_listCustom.size());
5863  }
5864 
5865  EResultCode
5867  addCustom (
5868  CParameter * pValue);
5869 
5870 
5871 };
5872 
5873 
5897 class CImpinjEnableRFPhaseAngle : public CParameter
5898 {
5899  public:
5901  ~CImpinjEnableRFPhaseAngle (void);
5902 
5905 
5906  static const CFieldDescriptor * const
5907  s_apFieldDescriptorTable[];
5908 
5909  static const CTypeDescriptor
5910  s_typeDescriptor;
5911 
5912  void
5913  decodeFields (
5914  CDecoderStream * pDecoderStream);
5915 
5916  void
5917  assimilateSubParameters (
5918  CErrorDetails * pError);
5919 
5920  void
5921  encode (
5922  CEncoderStream * pEncoderStream) const;
5923 
5924 
5925  llrp_bool_t
5926  isAllowedIn (
5927  const CTypeDescriptor * pEnclosingElementType) const;
5928 
5929 
5930  static CElement *
5931  s_construct (void);
5932 
5933  static void
5934  s_decodeFields (
5935  CDecoderStream * pDecoderStream,
5936  CElement * pElement);
5938 
5939 
5940  protected:
5941  EImpinjRFPhaseAngleMode m_eRFPhaseAngleMode;
5942 
5945  public:
5946  static const CFieldDescriptor
5947  s_fdRFPhaseAngleMode;
5949 
5951  inline EImpinjRFPhaseAngleMode
5953  {
5954  return m_eRFPhaseAngleMode;
5955  }
5956 
5958  inline void
5960  EImpinjRFPhaseAngleMode value)
5961  {
5962  m_eRFPhaseAngleMode = value;
5963  }
5964 
5965 
5966  protected:
5967  std::list<CParameter *> m_listCustom;
5968 
5969  public:
5971  inline std::list<CParameter *>::iterator
5973  {
5974  return m_listCustom.begin();
5975  }
5976 
5978  inline std::list<CParameter *>::iterator
5979  endCustom (void)
5980  {
5981  return m_listCustom.end();
5982  }
5983 
5985  inline void
5987  {
5988  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5989  }
5990 
5992  inline int
5994  {
5995  return (int) (m_listCustom.size());
5996  }
5997 
5998  EResultCode
6000  addCustom (
6001  CParameter * pValue);
6002 
6003 
6004 };
6005 
6006 
6030 class CImpinjEnablePeakRSSI : public CParameter
6031 {
6032  public:
6033  CImpinjEnablePeakRSSI (void);
6034  ~CImpinjEnablePeakRSSI (void);
6035 
6038 
6039  static const CFieldDescriptor * const
6040  s_apFieldDescriptorTable[];
6041 
6042  static const CTypeDescriptor
6043  s_typeDescriptor;
6044 
6045  void
6046  decodeFields (
6047  CDecoderStream * pDecoderStream);
6048 
6049  void
6050  assimilateSubParameters (
6051  CErrorDetails * pError);
6052 
6053  void
6054  encode (
6055  CEncoderStream * pEncoderStream) const;
6056 
6057 
6058  llrp_bool_t
6059  isAllowedIn (
6060  const CTypeDescriptor * pEnclosingElementType) const;
6061 
6062 
6063  static CElement *
6064  s_construct (void);
6065 
6066  static void
6067  s_decodeFields (
6068  CDecoderStream * pDecoderStream,
6069  CElement * pElement);
6071 
6072 
6073  protected:
6074  EImpinjPeakRSSIMode m_ePeakRSSIMode;
6075 
6078  public:
6079  static const CFieldDescriptor
6080  s_fdPeakRSSIMode;
6082 
6084  inline EImpinjPeakRSSIMode
6086  {
6087  return m_ePeakRSSIMode;
6088  }
6089 
6091  inline void
6093  EImpinjPeakRSSIMode value)
6094  {
6095  m_ePeakRSSIMode = value;
6096  }
6097 
6098 
6099  protected:
6100  std::list<CParameter *> m_listCustom;
6101 
6102  public:
6104  inline std::list<CParameter *>::iterator
6106  {
6107  return m_listCustom.begin();
6108  }
6109 
6111  inline std::list<CParameter *>::iterator
6112  endCustom (void)
6113  {
6114  return m_listCustom.end();
6115  }
6116 
6118  inline void
6120  {
6121  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6122  }
6123 
6125  inline int
6127  {
6128  return (int) (m_listCustom.size());
6129  }
6130 
6131  EResultCode
6133  addCustom (
6134  CParameter * pValue);
6135 
6136 
6137 };
6138 
6139 
6163 class CImpinjEnableGPSCoordinates : public CParameter
6164 {
6165  public:
6168 
6171 
6172  static const CFieldDescriptor * const
6173  s_apFieldDescriptorTable[];
6174 
6175  static const CTypeDescriptor
6176  s_typeDescriptor;
6177 
6178  void
6179  decodeFields (
6180  CDecoderStream * pDecoderStream);
6181 
6182  void
6183  assimilateSubParameters (
6184  CErrorDetails * pError);
6185 
6186  void
6187  encode (
6188  CEncoderStream * pEncoderStream) const;
6189 
6190 
6191  llrp_bool_t
6192  isAllowedIn (
6193  const CTypeDescriptor * pEnclosingElementType) const;
6194 
6195 
6196  static CElement *
6197  s_construct (void);
6198 
6199  static void
6200  s_decodeFields (
6201  CDecoderStream * pDecoderStream,
6202  CElement * pElement);
6204 
6205 
6206  protected:
6207  EImpinjGPSCoordinatesMode m_eGPSCoordinatesMode;
6208 
6211  public:
6212  static const CFieldDescriptor
6213  s_fdGPSCoordinatesMode;
6215 
6217  inline EImpinjGPSCoordinatesMode
6219  {
6220  return m_eGPSCoordinatesMode;
6221  }
6222 
6224  inline void
6226  EImpinjGPSCoordinatesMode value)
6227  {
6228  m_eGPSCoordinatesMode = value;
6229  }
6230 
6231 
6232  protected:
6233  std::list<CParameter *> m_listCustom;
6234 
6235  public:
6237  inline std::list<CParameter *>::iterator
6239  {
6240  return m_listCustom.begin();
6241  }
6242 
6244  inline std::list<CParameter *>::iterator
6245  endCustom (void)
6246  {
6247  return m_listCustom.end();
6248  }
6249 
6251  inline void
6253  {
6254  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6255  }
6256 
6258  inline int
6260  {
6261  return (int) (m_listCustom.size());
6262  }
6263 
6264  EResultCode
6266  addCustom (
6267  CParameter * pValue);
6268 
6269 
6270 };
6271 
6272 
6298 class CImpinjSerializedTID : public CParameter
6299 {
6300  public:
6301  CImpinjSerializedTID (void);
6302  ~CImpinjSerializedTID (void);
6303 
6306 
6307  static const CFieldDescriptor * const
6308  s_apFieldDescriptorTable[];
6309 
6310  static const CTypeDescriptor
6311  s_typeDescriptor;
6312 
6313  void
6314  decodeFields (
6315  CDecoderStream * pDecoderStream);
6316 
6317  void
6318  assimilateSubParameters (
6319  CErrorDetails * pError);
6320 
6321  void
6322  encode (
6323  CEncoderStream * pEncoderStream) const;
6324 
6325 
6326  llrp_bool_t
6327  isAllowedIn (
6328  const CTypeDescriptor * pEnclosingElementType) const;
6329 
6330 
6331  static CElement *
6332  s_construct (void);
6333 
6334  static void
6335  s_decodeFields (
6336  CDecoderStream * pDecoderStream,
6337  CElement * pElement);
6339 
6340 
6341  protected:
6342  llrp_u16v_t m_TID;
6343 
6346  public:
6347  static const CFieldDescriptor
6348  s_fdTID;
6350 
6352  inline llrp_u16v_t
6353  getTID (void)
6354  {
6355  return m_TID;
6356  }
6357 
6359  inline void
6361  llrp_u16v_t value)
6362  {
6363  m_TID = value;
6364  }
6365 
6366 
6367  protected:
6368  CImpinjTIDParity * m_pImpinjTIDParity;
6369 
6370  public:
6372  inline CImpinjTIDParity *
6374  {
6375  return m_pImpinjTIDParity;
6376  }
6377 
6379  EResultCode
6381  CImpinjTIDParity * pValue);
6382 
6383 
6384  protected:
6385  std::list<CParameter *> m_listCustom;
6386 
6387  public:
6389  inline std::list<CParameter *>::iterator
6391  {
6392  return m_listCustom.begin();
6393  }
6394 
6396  inline std::list<CParameter *>::iterator
6397  endCustom (void)
6398  {
6399  return m_listCustom.end();
6400  }
6401 
6403  inline void
6405  {
6406  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6407  }
6408 
6410  inline int
6412  {
6413  return (int) (m_listCustom.size());
6414  }
6415 
6416  EResultCode
6418  addCustom (
6419  CParameter * pValue);
6420 
6421 
6422 };
6423 
6424 
6449 class CImpinjRFPhaseAngle : public CParameter
6450 {
6451  public:
6452  CImpinjRFPhaseAngle (void);
6453  ~CImpinjRFPhaseAngle (void);
6454 
6457 
6458  static const CFieldDescriptor * const
6459  s_apFieldDescriptorTable[];
6460 
6461  static const CTypeDescriptor
6462  s_typeDescriptor;
6463 
6464  void
6465  decodeFields (
6466  CDecoderStream * pDecoderStream);
6467 
6468  void
6469  assimilateSubParameters (
6470  CErrorDetails * pError);
6471 
6472  void
6473  encode (
6474  CEncoderStream * pEncoderStream) const;
6475 
6476 
6477  llrp_bool_t
6478  isAllowedIn (
6479  const CTypeDescriptor * pEnclosingElementType) const;
6480 
6481 
6482  static CElement *
6483  s_construct (void);
6484 
6485  static void
6486  s_decodeFields (
6487  CDecoderStream * pDecoderStream,
6488  CElement * pElement);
6490 
6491 
6492  protected:
6493  llrp_u16_t m_PhaseAngle;
6494 
6497  public:
6498  static const CFieldDescriptor
6499  s_fdPhaseAngle;
6501 
6503  inline llrp_u16_t
6505  {
6506  return m_PhaseAngle;
6507  }
6508 
6510  inline void
6512  llrp_u16_t value)
6513  {
6514  m_PhaseAngle = value;
6515  }
6516 
6517 
6518  protected:
6519  std::list<CParameter *> m_listCustom;
6520 
6521  public:
6523  inline std::list<CParameter *>::iterator
6525  {
6526  return m_listCustom.begin();
6527  }
6528 
6530  inline std::list<CParameter *>::iterator
6531  endCustom (void)
6532  {
6533  return m_listCustom.end();
6534  }
6535 
6537  inline void
6539  {
6540  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6541  }
6542 
6544  inline int
6546  {
6547  return (int) (m_listCustom.size());
6548  }
6549 
6550  EResultCode
6552  addCustom (
6553  CParameter * pValue);
6554 
6555 
6556 };
6557 
6558 
6583 class CImpinjPeakRSSI : public CParameter
6584 {
6585  public:
6586  CImpinjPeakRSSI (void);
6587  ~CImpinjPeakRSSI (void);
6588 
6591 
6592  static const CFieldDescriptor * const
6593  s_apFieldDescriptorTable[];
6594 
6595  static const CTypeDescriptor
6596  s_typeDescriptor;
6597 
6598  void
6599  decodeFields (
6600  CDecoderStream * pDecoderStream);
6601 
6602  void
6603  assimilateSubParameters (
6604  CErrorDetails * pError);
6605 
6606  void
6607  encode (
6608  CEncoderStream * pEncoderStream) const;
6609 
6610 
6611  llrp_bool_t
6612  isAllowedIn (
6613  const CTypeDescriptor * pEnclosingElementType) const;
6614 
6615 
6616  static CElement *
6617  s_construct (void);
6618 
6619  static void
6620  s_decodeFields (
6621  CDecoderStream * pDecoderStream,
6622  CElement * pElement);
6624 
6625 
6626  protected:
6627  llrp_s16_t m_RSSI;
6628 
6631  public:
6632  static const CFieldDescriptor
6633  s_fdRSSI;
6635 
6637  inline llrp_s16_t
6638  getRSSI (void)
6639  {
6640  return m_RSSI;
6641  }
6642 
6644  inline void
6646  llrp_s16_t value)
6647  {
6648  m_RSSI = value;
6649  }
6650 
6651 
6652  protected:
6653  std::list<CParameter *> m_listCustom;
6654 
6655  public:
6657  inline std::list<CParameter *>::iterator
6659  {
6660  return m_listCustom.begin();
6661  }
6662 
6664  inline std::list<CParameter *>::iterator
6665  endCustom (void)
6666  {
6667  return m_listCustom.end();
6668  }
6669 
6671  inline void
6673  {
6674  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6675  }
6676 
6678  inline int
6680  {
6681  return (int) (m_listCustom.size());
6682  }
6683 
6684  EResultCode
6686  addCustom (
6687  CParameter * pValue);
6688 
6689 
6690 };
6691 
6692 
6718 class CImpinjGPSCoordinates : public CParameter
6719 {
6720  public:
6721  CImpinjGPSCoordinates (void);
6722  ~CImpinjGPSCoordinates (void);
6723 
6726 
6727  static const CFieldDescriptor * const
6728  s_apFieldDescriptorTable[];
6729 
6730  static const CTypeDescriptor
6731  s_typeDescriptor;
6732 
6733  void
6734  decodeFields (
6735  CDecoderStream * pDecoderStream);
6736 
6737  void
6738  assimilateSubParameters (
6739  CErrorDetails * pError);
6740 
6741  void
6742  encode (
6743  CEncoderStream * pEncoderStream) const;
6744 
6745 
6746  llrp_bool_t
6747  isAllowedIn (
6748  const CTypeDescriptor * pEnclosingElementType) const;
6749 
6750 
6751  static CElement *
6752  s_construct (void);
6753 
6754  static void
6755  s_decodeFields (
6756  CDecoderStream * pDecoderStream,
6757  CElement * pElement);
6759 
6760 
6761  protected:
6762  llrp_s32_t m_Latitude;
6763 
6766  public:
6767  static const CFieldDescriptor
6768  s_fdLatitude;
6770 
6772  inline llrp_s32_t
6774  {
6775  return m_Latitude;
6776  }
6777 
6779  inline void
6781  llrp_s32_t value)
6782  {
6783  m_Latitude = value;
6784  }
6785 
6786 
6787  protected:
6788  llrp_s32_t m_Longitude;
6789 
6792  public:
6793  static const CFieldDescriptor
6794  s_fdLongitude;
6796 
6798  inline llrp_s32_t
6800  {
6801  return m_Longitude;
6802  }
6803 
6805  inline void
6807  llrp_s32_t value)
6808  {
6809  m_Longitude = value;
6810  }
6811 
6812 
6813  protected:
6814  std::list<CParameter *> m_listCustom;
6815 
6816  public:
6818  inline std::list<CParameter *>::iterator
6820  {
6821  return m_listCustom.begin();
6822  }
6823 
6825  inline std::list<CParameter *>::iterator
6826  endCustom (void)
6827  {
6828  return m_listCustom.end();
6829  }
6830 
6832  inline void
6834  {
6835  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6836  }
6837 
6839  inline int
6841  {
6842  return (int) (m_listCustom.size());
6843  }
6844 
6845  EResultCode
6847  addCustom (
6848  CParameter * pValue);
6849 
6850 
6851 };
6852 
6853 
6878 class CImpinjLoopSpec : public CParameter
6879 {
6880  public:
6881  CImpinjLoopSpec (void);
6882  ~CImpinjLoopSpec (void);
6883 
6886 
6887  static const CFieldDescriptor * const
6888  s_apFieldDescriptorTable[];
6889 
6890  static const CTypeDescriptor
6891  s_typeDescriptor;
6892 
6893  void
6894  decodeFields (
6895  CDecoderStream * pDecoderStream);
6896 
6897  void
6898  assimilateSubParameters (
6899  CErrorDetails * pError);
6900 
6901  void
6902  encode (
6903  CEncoderStream * pEncoderStream) const;
6904 
6905 
6906  llrp_bool_t
6907  isAllowedIn (
6908  const CTypeDescriptor * pEnclosingElementType) const;
6909 
6910 
6911  static CElement *
6912  s_construct (void);
6913 
6914  static void
6915  s_decodeFields (
6916  CDecoderStream * pDecoderStream,
6917  CElement * pElement);
6919 
6920 
6921  protected:
6922  llrp_u32_t m_LoopCount;
6923 
6926  public:
6927  static const CFieldDescriptor
6928  s_fdLoopCount;
6930 
6932  inline llrp_u32_t
6934  {
6935  return m_LoopCount;
6936  }
6937 
6939  inline void
6941  llrp_u32_t value)
6942  {
6943  m_LoopCount = value;
6944  }
6945 
6946 
6947  protected:
6948  std::list<CParameter *> m_listCustom;
6949 
6950  public:
6952  inline std::list<CParameter *>::iterator
6954  {
6955  return m_listCustom.begin();
6956  }
6957 
6959  inline std::list<CParameter *>::iterator
6960  endCustom (void)
6961  {
6962  return m_listCustom.end();
6963  }
6964 
6966  inline void
6968  {
6969  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6970  }
6971 
6973  inline int
6975  {
6976  return (int) (m_listCustom.size());
6977  }
6978 
6979  EResultCode
6981  addCustom (
6982  CParameter * pValue);
6983 
6984 
6985 };
6986 
6987 
7013 class CImpinjGPSNMEASentences : public CParameter
7014 {
7015  public:
7016  CImpinjGPSNMEASentences (void);
7017  ~CImpinjGPSNMEASentences (void);
7018 
7021 
7022  static const CFieldDescriptor * const
7023  s_apFieldDescriptorTable[];
7024 
7025  static const CTypeDescriptor
7026  s_typeDescriptor;
7027 
7028  void
7029  decodeFields (
7030  CDecoderStream * pDecoderStream);
7031 
7032  void
7033  assimilateSubParameters (
7034  CErrorDetails * pError);
7035 
7036  void
7037  encode (
7038  CEncoderStream * pEncoderStream) const;
7039 
7040 
7041  llrp_bool_t
7042  isAllowedIn (
7043  const CTypeDescriptor * pEnclosingElementType) const;
7044 
7045 
7046  static CElement *
7047  s_construct (void);
7048 
7049  static void
7050  s_decodeFields (
7051  CDecoderStream * pDecoderStream,
7052  CElement * pElement);
7054 
7055 
7056  protected:
7057  CImpinjGGASentence * m_pImpinjGGASentence;
7058 
7059  public:
7061  inline CImpinjGGASentence *
7063  {
7064  return m_pImpinjGGASentence;
7065  }
7066 
7068  EResultCode
7070  CImpinjGGASentence * pValue);
7071 
7072 
7073  protected:
7074  CImpinjRMCSentence * m_pImpinjRMCSentence;
7075 
7076  public:
7078  inline CImpinjRMCSentence *
7080  {
7081  return m_pImpinjRMCSentence;
7082  }
7083 
7085  EResultCode
7087  CImpinjRMCSentence * pValue);
7088 
7089 
7090  protected:
7091  std::list<CParameter *> m_listCustom;
7092 
7093  public:
7095  inline std::list<CParameter *>::iterator
7097  {
7098  return m_listCustom.begin();
7099  }
7100 
7102  inline std::list<CParameter *>::iterator
7103  endCustom (void)
7104  {
7105  return m_listCustom.end();
7106  }
7107 
7109  inline void
7111  {
7112  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7113  }
7114 
7116  inline int
7118  {
7119  return (int) (m_listCustom.size());
7120  }
7121 
7122  EResultCode
7124  addCustom (
7125  CParameter * pValue);
7126 
7127 
7128 };
7129 
7130 
7154 class CImpinjGGASentence : public CParameter
7155 {
7156  public:
7157  CImpinjGGASentence (void);
7158  ~CImpinjGGASentence (void);
7159 
7162 
7163  static const CFieldDescriptor * const
7164  s_apFieldDescriptorTable[];
7165 
7166  static const CTypeDescriptor
7167  s_typeDescriptor;
7168 
7169  void
7170  decodeFields (
7171  CDecoderStream * pDecoderStream);
7172 
7173  void
7174  assimilateSubParameters (
7175  CErrorDetails * pError);
7176 
7177  void
7178  encode (
7179  CEncoderStream * pEncoderStream) const;
7180 
7181 
7182  llrp_bool_t
7183  isAllowedIn (
7184  const CTypeDescriptor * pEnclosingElementType) const;
7185 
7186 
7187  static CElement *
7188  s_construct (void);
7189 
7190  static void
7191  s_decodeFields (
7192  CDecoderStream * pDecoderStream,
7193  CElement * pElement);
7195 
7196 
7197  protected:
7198  llrp_utf8v_t m_GGASentence;
7199 
7202  public:
7203  static const CFieldDescriptor
7204  s_fdGGASentence;
7206 
7208  inline llrp_utf8v_t
7210  {
7211  return m_GGASentence;
7212  }
7213 
7215  inline void
7217  llrp_utf8v_t value)
7218  {
7219  m_GGASentence = value;
7220  }
7221 
7222 
7223  protected:
7224  std::list<CParameter *> m_listCustom;
7225 
7226  public:
7228  inline std::list<CParameter *>::iterator
7230  {
7231  return m_listCustom.begin();
7232  }
7233 
7235  inline std::list<CParameter *>::iterator
7236  endCustom (void)
7237  {
7238  return m_listCustom.end();
7239  }
7240 
7242  inline void
7244  {
7245  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7246  }
7247 
7249  inline int
7251  {
7252  return (int) (m_listCustom.size());
7253  }
7254 
7255  EResultCode
7257  addCustom (
7258  CParameter * pValue);
7259 
7260 
7261 };
7262 
7263 
7287 class CImpinjRMCSentence : public CParameter
7288 {
7289  public:
7290  CImpinjRMCSentence (void);
7291  ~CImpinjRMCSentence (void);
7292 
7295 
7296  static const CFieldDescriptor * const
7297  s_apFieldDescriptorTable[];
7298 
7299  static const CTypeDescriptor
7300  s_typeDescriptor;
7301 
7302  void
7303  decodeFields (
7304  CDecoderStream * pDecoderStream);
7305 
7306  void
7307  assimilateSubParameters (
7308  CErrorDetails * pError);
7309 
7310  void
7311  encode (
7312  CEncoderStream * pEncoderStream) const;
7313 
7314 
7315  llrp_bool_t
7316  isAllowedIn (
7317  const CTypeDescriptor * pEnclosingElementType) const;
7318 
7319 
7320  static CElement *
7321  s_construct (void);
7322 
7323  static void
7324  s_decodeFields (
7325  CDecoderStream * pDecoderStream,
7326  CElement * pElement);
7328 
7329 
7330  protected:
7331  llrp_utf8v_t m_RMCSentence;
7332 
7335  public:
7336  static const CFieldDescriptor
7337  s_fdRMCSentence;
7339 
7341  inline llrp_utf8v_t
7343  {
7344  return m_RMCSentence;
7345  }
7346 
7348  inline void
7350  llrp_utf8v_t value)
7351  {
7352  m_RMCSentence = value;
7353  }
7354 
7355 
7356  protected:
7357  std::list<CParameter *> m_listCustom;
7358 
7359  public:
7361  inline std::list<CParameter *>::iterator
7363  {
7364  return m_listCustom.begin();
7365  }
7366 
7368  inline std::list<CParameter *>::iterator
7369  endCustom (void)
7370  {
7371  return m_listCustom.end();
7372  }
7373 
7375  inline void
7377  {
7378  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7379  }
7380 
7382  inline int
7384  {
7385  return (int) (m_listCustom.size());
7386  }
7387 
7388  EResultCode
7390  addCustom (
7391  CParameter * pValue);
7392 
7393 
7394 };
7395 
7396 
7420 class CImpinjOpSpecRetryCount : public CParameter
7421 {
7422  public:
7423  CImpinjOpSpecRetryCount (void);
7424  ~CImpinjOpSpecRetryCount (void);
7425 
7428 
7429  static const CFieldDescriptor * const
7430  s_apFieldDescriptorTable[];
7431 
7432  static const CTypeDescriptor
7433  s_typeDescriptor;
7434 
7435  void
7436  decodeFields (
7437  CDecoderStream * pDecoderStream);
7438 
7439  void
7440  assimilateSubParameters (
7441  CErrorDetails * pError);
7442 
7443  void
7444  encode (
7445  CEncoderStream * pEncoderStream) const;
7446 
7447 
7448  llrp_bool_t
7449  isAllowedIn (
7450  const CTypeDescriptor * pEnclosingElementType) const;
7451 
7452 
7453  static CElement *
7454  s_construct (void);
7455 
7456  static void
7457  s_decodeFields (
7458  CDecoderStream * pDecoderStream,
7459  CElement * pElement);
7461 
7462 
7463  protected:
7464  llrp_u16_t m_RetryCount;
7465 
7468  public:
7469  static const CFieldDescriptor
7470  s_fdRetryCount;
7472 
7474  inline llrp_u16_t
7476  {
7477  return m_RetryCount;
7478  }
7479 
7481  inline void
7483  llrp_u16_t value)
7484  {
7485  m_RetryCount = value;
7486  }
7487 
7488 
7489  protected:
7490  std::list<CParameter *> m_listCustom;
7491 
7492  public:
7494  inline std::list<CParameter *>::iterator
7496  {
7497  return m_listCustom.begin();
7498  }
7499 
7501  inline std::list<CParameter *>::iterator
7502  endCustom (void)
7503  {
7504  return m_listCustom.end();
7505  }
7506 
7508  inline void
7510  {
7511  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7512  }
7513 
7515  inline int
7517  {
7518  return (int) (m_listCustom.size());
7519  }
7520 
7521  EResultCode
7523  addCustom (
7524  CParameter * pValue);
7525 
7526 
7527 };
7528 
7529 
7557 class CImpinjAdvancedGPOConfiguration : public CParameter
7558 {
7559  public:
7562 
7565 
7566  static const CFieldDescriptor * const
7567  s_apFieldDescriptorTable[];
7568 
7569  static const CTypeDescriptor
7570  s_typeDescriptor;
7571 
7572  void
7573  decodeFields (
7574  CDecoderStream * pDecoderStream);
7575 
7576  void
7577  assimilateSubParameters (
7578  CErrorDetails * pError);
7579 
7580  void
7581  encode (
7582  CEncoderStream * pEncoderStream) const;
7583 
7584 
7585  llrp_bool_t
7586  isAllowedIn (
7587  const CTypeDescriptor * pEnclosingElementType) const;
7588 
7589 
7590  static CElement *
7591  s_construct (void);
7592 
7593  static void
7594  s_decodeFields (
7595  CDecoderStream * pDecoderStream,
7596  CElement * pElement);
7598 
7599 
7600  protected:
7601  llrp_u16_t m_GPOPortNum;
7602 
7605  public:
7606  static const CFieldDescriptor
7607  s_fdGPOPortNum;
7609 
7611  inline llrp_u16_t
7613  {
7614  return m_GPOPortNum;
7615  }
7616 
7618  inline void
7620  llrp_u16_t value)
7621  {
7622  m_GPOPortNum = value;
7623  }
7624 
7625 
7626  protected:
7627  EImpinjAdvancedGPOMode m_eGPOMode;
7628 
7631  public:
7632  static const CFieldDescriptor
7633  s_fdGPOMode;
7635 
7637  inline EImpinjAdvancedGPOMode
7638  getGPOMode (void)
7639  {
7640  return m_eGPOMode;
7641  }
7642 
7644  inline void
7646  EImpinjAdvancedGPOMode value)
7647  {
7648  m_eGPOMode = value;
7649  }
7650 
7651 
7652  protected:
7653  llrp_u32_t m_GPOPulseDurationMSec;
7654 
7657  public:
7658  static const CFieldDescriptor
7659  s_fdGPOPulseDurationMSec;
7661 
7663  inline llrp_u32_t
7665  {
7666  return m_GPOPulseDurationMSec;
7667  }
7668 
7670  inline void
7672  llrp_u32_t value)
7673  {
7674  m_GPOPulseDurationMSec = value;
7675  }
7676 
7677 
7678  protected:
7679  std::list<CParameter *> m_listCustom;
7680 
7681  public:
7683  inline std::list<CParameter *>::iterator
7685  {
7686  return m_listCustom.begin();
7687  }
7688 
7690  inline std::list<CParameter *>::iterator
7691  endCustom (void)
7692  {
7693  return m_listCustom.end();
7694  }
7695 
7697  inline void
7699  {
7700  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7701  }
7702 
7704  inline int
7706  {
7707  return (int) (m_listCustom.size());
7708  }
7709 
7710  EResultCode
7712  addCustom (
7713  CParameter * pValue);
7714 
7715 
7716 };
7717 
7718 
7752 class CImpinjEnableOptimizedRead : public CParameter
7753 {
7754  public:
7757 
7760 
7761  static const CFieldDescriptor * const
7762  s_apFieldDescriptorTable[];
7763 
7764  static const CTypeDescriptor
7765  s_typeDescriptor;
7766 
7767  void
7768  decodeFields (
7769  CDecoderStream * pDecoderStream);
7770 
7771  void
7772  assimilateSubParameters (
7773  CErrorDetails * pError);
7774 
7775  void
7776  encode (
7777  CEncoderStream * pEncoderStream) const;
7778 
7779 
7780  llrp_bool_t
7781  isAllowedIn (
7782  const CTypeDescriptor * pEnclosingElementType) const;
7783 
7784 
7785  static CElement *
7786  s_construct (void);
7787 
7788  static void
7789  s_decodeFields (
7790  CDecoderStream * pDecoderStream,
7791  CElement * pElement);
7793 
7794 
7795  protected:
7796  EImpinjOptimizedReadMode m_eOptimizedReadMode;
7797 
7800  public:
7801  static const CFieldDescriptor
7802  s_fdOptimizedReadMode;
7804 
7806  inline EImpinjOptimizedReadMode
7808  {
7809  return m_eOptimizedReadMode;
7810  }
7811 
7813  inline void
7815  EImpinjOptimizedReadMode value)
7816  {
7817  m_eOptimizedReadMode = value;
7818  }
7819 
7820 
7821  protected:
7822  std::list<CC1G2Read *> m_listC1G2Read;
7823 
7824  public:
7826  inline std::list<CC1G2Read *>::iterator
7828  {
7829  return m_listC1G2Read.begin();
7830  }
7831 
7833  inline std::list<CC1G2Read *>::iterator
7835  {
7836  return m_listC1G2Read.end();
7837  }
7838 
7840  inline void
7842  {
7843  clearSubParameterList ((tListOfParameters *) &m_listC1G2Read);
7844  }
7845 
7847  inline int
7849  {
7850  return (int) (m_listC1G2Read.size());
7851  }
7852 
7853  EResultCode
7855  addC1G2Read (
7856  CC1G2Read * pValue);
7857 
7858 
7859  protected:
7860  std::list<CParameter *> m_listCustom;
7861 
7862  public:
7864  inline std::list<CParameter *>::iterator
7866  {
7867  return m_listCustom.begin();
7868  }
7869 
7871  inline std::list<CParameter *>::iterator
7872  endCustom (void)
7873  {
7874  return m_listCustom.end();
7875  }
7876 
7878  inline void
7880  {
7881  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7882  }
7883 
7885  inline int
7887  {
7888  return (int) (m_listCustom.size());
7889  }
7890 
7891  EResultCode
7893  addCustom (
7894  CParameter * pValue);
7895 
7896 
7897 };
7898 
7899 
7926 class CImpinjAccessSpecOrdering : public CParameter
7927 {
7928  public:
7930  ~CImpinjAccessSpecOrdering (void);
7931 
7934 
7935  static const CFieldDescriptor * const
7936  s_apFieldDescriptorTable[];
7937 
7938  static const CTypeDescriptor
7939  s_typeDescriptor;
7940 
7941  void
7942  decodeFields (
7943  CDecoderStream * pDecoderStream);
7944 
7945  void
7946  assimilateSubParameters (
7947  CErrorDetails * pError);
7948 
7949  void
7950  encode (
7951  CEncoderStream * pEncoderStream) const;
7952 
7953 
7954  llrp_bool_t
7955  isAllowedIn (
7956  const CTypeDescriptor * pEnclosingElementType) const;
7957 
7958 
7959  static CElement *
7960  s_construct (void);
7961 
7962  static void
7963  s_decodeFields (
7964  CDecoderStream * pDecoderStream,
7965  CElement * pElement);
7967 
7968 
7969  protected:
7970  EImpinjAccessSpecOrderingMode m_eOrderingMode;
7971 
7974  public:
7975  static const CFieldDescriptor
7976  s_fdOrderingMode;
7978 
7980  inline EImpinjAccessSpecOrderingMode
7982  {
7983  return m_eOrderingMode;
7984  }
7985 
7987  inline void
7989  EImpinjAccessSpecOrderingMode value)
7990  {
7991  m_eOrderingMode = value;
7992  }
7993 
7994 
7995  protected:
7996  std::list<CParameter *> m_listCustom;
7997 
7998  public:
8000  inline std::list<CParameter *>::iterator
8002  {
8003  return m_listCustom.begin();
8004  }
8005 
8007  inline std::list<CParameter *>::iterator
8008  endCustom (void)
8009  {
8010  return m_listCustom.end();
8011  }
8012 
8014  inline void
8016  {
8017  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8018  }
8019 
8021  inline int
8023  {
8024  return (int) (m_listCustom.size());
8025  }
8026 
8027  EResultCode
8029  addCustom (
8030  CParameter * pValue);
8031 
8032 
8033 };
8034 
8035 
8059 class CImpinjEnableRFDopplerFrequency : public CParameter
8060 {
8061  public:
8064 
8067 
8068  static const CFieldDescriptor * const
8069  s_apFieldDescriptorTable[];
8070 
8071  static const CTypeDescriptor
8072  s_typeDescriptor;
8073 
8074  void
8075  decodeFields (
8076  CDecoderStream * pDecoderStream);
8077 
8078  void
8079  assimilateSubParameters (
8080  CErrorDetails * pError);
8081 
8082  void
8083  encode (
8084  CEncoderStream * pEncoderStream) const;
8085 
8086 
8087  llrp_bool_t
8088  isAllowedIn (
8089  const CTypeDescriptor * pEnclosingElementType) const;
8090 
8091 
8092  static CElement *
8093  s_construct (void);
8094 
8095  static void
8096  s_decodeFields (
8097  CDecoderStream * pDecoderStream,
8098  CElement * pElement);
8100 
8101 
8102  protected:
8103  EImpinjRFDopplerFrequencyMode m_eRFDopplerFrequencyMode;
8104 
8107  public:
8108  static const CFieldDescriptor
8109  s_fdRFDopplerFrequencyMode;
8111 
8113  inline EImpinjRFDopplerFrequencyMode
8115  {
8116  return m_eRFDopplerFrequencyMode;
8117  }
8118 
8120  inline void
8122  EImpinjRFDopplerFrequencyMode value)
8123  {
8124  m_eRFDopplerFrequencyMode = value;
8125  }
8126 
8127 
8128  protected:
8129  std::list<CParameter *> m_listCustom;
8130 
8131  public:
8133  inline std::list<CParameter *>::iterator
8135  {
8136  return m_listCustom.begin();
8137  }
8138 
8140  inline std::list<CParameter *>::iterator
8141  endCustom (void)
8142  {
8143  return m_listCustom.end();
8144  }
8145 
8147  inline void
8149  {
8150  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8151  }
8152 
8154  inline int
8156  {
8157  return (int) (m_listCustom.size());
8158  }
8159 
8160  EResultCode
8162  addCustom (
8163  CParameter * pValue);
8164 
8165 
8166 };
8167 
8168 
8193 class CImpinjRFDopplerFrequency : public CParameter
8194 {
8195  public:
8197  ~CImpinjRFDopplerFrequency (void);
8198 
8201 
8202  static const CFieldDescriptor * const
8203  s_apFieldDescriptorTable[];
8204 
8205  static const CTypeDescriptor
8206  s_typeDescriptor;
8207 
8208  void
8209  decodeFields (
8210  CDecoderStream * pDecoderStream);
8211 
8212  void
8213  assimilateSubParameters (
8214  CErrorDetails * pError);
8215 
8216  void
8217  encode (
8218  CEncoderStream * pEncoderStream) const;
8219 
8220 
8221  llrp_bool_t
8222  isAllowedIn (
8223  const CTypeDescriptor * pEnclosingElementType) const;
8224 
8225 
8226  static CElement *
8227  s_construct (void);
8228 
8229  static void
8230  s_decodeFields (
8231  CDecoderStream * pDecoderStream,
8232  CElement * pElement);
8234 
8235 
8236  protected:
8237  llrp_s16_t m_DopplerFrequency;
8238 
8241  public:
8242  static const CFieldDescriptor
8243  s_fdDopplerFrequency;
8245 
8247  inline llrp_s16_t
8249  {
8250  return m_DopplerFrequency;
8251  }
8252 
8254  inline void
8256  llrp_s16_t value)
8257  {
8258  m_DopplerFrequency = value;
8259  }
8260 
8261 
8262  protected:
8263  std::list<CParameter *> m_listCustom;
8264 
8265  public:
8267  inline std::list<CParameter *>::iterator
8269  {
8270  return m_listCustom.begin();
8271  }
8272 
8274  inline std::list<CParameter *>::iterator
8275  endCustom (void)
8276  {
8277  return m_listCustom.end();
8278  }
8279 
8281  inline void
8283  {
8284  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8285  }
8286 
8288  inline int
8290  {
8291  return (int) (m_listCustom.size());
8292  }
8293 
8294  EResultCode
8296  addCustom (
8297  CParameter * pValue);
8298 
8299 
8300 };
8301 
8302 
8335 class CImpinjInventoryConfiguration : public CParameter
8336 {
8337  public:
8340 
8343 
8344  static const CFieldDescriptor * const
8345  s_apFieldDescriptorTable[];
8346 
8347  static const CTypeDescriptor
8348  s_typeDescriptor;
8349 
8350  void
8351  decodeFields (
8352  CDecoderStream * pDecoderStream);
8353 
8354  void
8355  assimilateSubParameters (
8356  CErrorDetails * pError);
8357 
8358  void
8359  encode (
8360  CEncoderStream * pEncoderStream) const;
8361 
8362 
8363  llrp_bool_t
8364  isAllowedIn (
8365  const CTypeDescriptor * pEnclosingElementType) const;
8366 
8367 
8368  static CElement *
8369  s_construct (void);
8370 
8371  static void
8372  s_decodeFields (
8373  CDecoderStream * pDecoderStream,
8374  CElement * pElement);
8376 
8377 
8378  protected:
8379  llrp_u1_t m_EnableAntDwellTimeLimit;
8380 
8383  public:
8384  static const CFieldDescriptor
8385  s_fdEnableAntDwellTimeLimit;
8387 
8389  inline llrp_u1_t
8391  {
8392  return m_EnableAntDwellTimeLimit;
8393  }
8394 
8396  inline void
8398  llrp_u1_t value)
8399  {
8400  m_EnableAntDwellTimeLimit = value;
8401  }
8402 
8403 
8404  protected:
8405  llrp_u1_t m_EnableSelectGapClose;
8406 
8409  public:
8410  static const CFieldDescriptor
8411  s_fdEnableSelectGapClose;
8413 
8415  inline llrp_u1_t
8417  {
8418  return m_EnableSelectGapClose;
8419  }
8420 
8422  inline void
8424  llrp_u1_t value)
8425  {
8426  m_EnableSelectGapClose = value;
8427  }
8428 
8429 
8430  protected:
8431  std::list<CParameter *> m_listCustom;
8432 
8433  public:
8435  inline std::list<CParameter *>::iterator
8437  {
8438  return m_listCustom.begin();
8439  }
8440 
8442  inline std::list<CParameter *>::iterator
8443  endCustom (void)
8444  {
8445  return m_listCustom.end();
8446  }
8447 
8449  inline void
8451  {
8452  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8453  }
8454 
8456  inline int
8458  {
8459  return (int) (m_listCustom.size());
8460  }
8461 
8462  EResultCode
8464  addCustom (
8465  CParameter * pValue);
8466 
8467 
8468 };
8469 
8470 
8497 class CImpinjArrayVersion : public CParameter
8498 {
8499  public:
8500  CImpinjArrayVersion (void);
8501  ~CImpinjArrayVersion (void);
8502 
8505 
8506  static const CFieldDescriptor * const
8507  s_apFieldDescriptorTable[];
8508 
8509  static const CTypeDescriptor
8510  s_typeDescriptor;
8511 
8512  void
8513  decodeFields (
8514  CDecoderStream * pDecoderStream);
8515 
8516  void
8517  assimilateSubParameters (
8518  CErrorDetails * pError);
8519 
8520  void
8521  encode (
8522  CEncoderStream * pEncoderStream) const;
8523 
8524 
8525  llrp_bool_t
8526  isAllowedIn (
8527  const CTypeDescriptor * pEnclosingElementType) const;
8528 
8529 
8530  static CElement *
8531  s_construct (void);
8532 
8533  static void
8534  s_decodeFields (
8535  CDecoderStream * pDecoderStream,
8536  CElement * pElement);
8538 
8539 
8540  protected:
8541  llrp_utf8v_t m_SerialNumber;
8542 
8545  public:
8546  static const CFieldDescriptor
8547  s_fdSerialNumber;
8549 
8551  inline llrp_utf8v_t
8553  {
8554  return m_SerialNumber;
8555  }
8556 
8558  inline void
8560  llrp_utf8v_t value)
8561  {
8562  m_SerialNumber = value;
8563  }
8564 
8565 
8566  protected:
8567  llrp_utf8v_t m_FirmwareVersion;
8568 
8571  public:
8572  static const CFieldDescriptor
8573  s_fdFirmwareVersion;
8575 
8577  inline llrp_utf8v_t
8579  {
8580  return m_FirmwareVersion;
8581  }
8582 
8584  inline void
8586  llrp_utf8v_t value)
8587  {
8588  m_FirmwareVersion = value;
8589  }
8590 
8591 
8592  protected:
8593  llrp_utf8v_t m_PCBAVersion;
8594 
8597  public:
8598  static const CFieldDescriptor
8599  s_fdPCBAVersion;
8601 
8603  inline llrp_utf8v_t
8605  {
8606  return m_PCBAVersion;
8607  }
8608 
8610  inline void
8612  llrp_utf8v_t value)
8613  {
8614  m_PCBAVersion = value;
8615  }
8616 
8617 
8618  protected:
8619  std::list<CParameter *> m_listCustom;
8620 
8621  public:
8623  inline std::list<CParameter *>::iterator
8625  {
8626  return m_listCustom.begin();
8627  }
8628 
8630  inline std::list<CParameter *>::iterator
8631  endCustom (void)
8632  {
8633  return m_listCustom.end();
8634  }
8635 
8637  inline void
8639  {
8640  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8641  }
8642 
8644  inline int
8646  {
8647  return (int) (m_listCustom.size());
8648  }
8649 
8650  EResultCode
8652  addCustom (
8653  CParameter * pValue);
8654 
8655 
8656 };
8657 
8658 
8691 class CImpinjxArrayCapabilities : public CParameter
8692 {
8693  public:
8695  ~CImpinjxArrayCapabilities (void);
8696 
8699 
8700  static const CFieldDescriptor * const
8701  s_apFieldDescriptorTable[];
8702 
8703  static const CTypeDescriptor
8704  s_typeDescriptor;
8705 
8706  void
8707  decodeFields (
8708  CDecoderStream * pDecoderStream);
8709 
8710  void
8711  assimilateSubParameters (
8712  CErrorDetails * pError);
8713 
8714  void
8715  encode (
8716  CEncoderStream * pEncoderStream) const;
8717 
8718 
8719  llrp_bool_t
8720  isAllowedIn (
8721  const CTypeDescriptor * pEnclosingElementType) const;
8722 
8723 
8724  static CElement *
8725  s_construct (void);
8726 
8727  static void
8728  s_decodeFields (
8729  CDecoderStream * pDecoderStream,
8730  CElement * pElement);
8732 
8733 
8734  protected:
8735  llrp_u32_t m_MaxNumSectors;
8736 
8739  public:
8740  static const CFieldDescriptor
8741  s_fdMaxNumSectors;
8743 
8745  inline llrp_u32_t
8747  {
8748  return m_MaxNumSectors;
8749  }
8750 
8752  inline void
8754  llrp_u32_t value)
8755  {
8756  m_MaxNumSectors = value;
8757  }
8758 
8759 
8760  protected:
8761  llrp_u1_t m_SupportsLISpecs;
8762 
8765  public:
8766  static const CFieldDescriptor
8767  s_fdSupportsLISpecs;
8769 
8771  inline llrp_u1_t
8773  {
8774  return m_SupportsLISpecs;
8775  }
8776 
8778  inline void
8780  llrp_u1_t value)
8781  {
8782  m_SupportsLISpecs = value;
8783  }
8784 
8785 
8786  protected:
8787  llrp_u1_t m_SupportsTISpecs;
8788 
8791  public:
8792  static const CFieldDescriptor
8793  s_fdSupportsTISpecs;
8795 
8797  inline llrp_u1_t
8799  {
8800  return m_SupportsTISpecs;
8801  }
8802 
8804  inline void
8806  llrp_u1_t value)
8807  {
8808  m_SupportsTISpecs = value;
8809  }
8810 
8811 
8812  protected:
8813  llrp_u1_t m_SupportsTSISpecs;
8814 
8817  public:
8818  static const CFieldDescriptor
8819  s_fdSupportsTSISpecs;
8821 
8823  inline llrp_u1_t
8825  {
8826  return m_SupportsTSISpecs;
8827  }
8828 
8830  inline void
8832  llrp_u1_t value)
8833  {
8834  m_SupportsTSISpecs = value;
8835  }
8836 
8837 
8838  protected:
8839  llrp_u1_t m_SupportsDISpecs;
8840 
8843  public:
8844  static const CFieldDescriptor
8845  s_fdSupportsDISpecs;
8847 
8849  inline llrp_u1_t
8851  {
8852  return m_SupportsDISpecs;
8853  }
8854 
8856  inline void
8858  llrp_u1_t value)
8859  {
8860  m_SupportsDISpecs = value;
8861  }
8862 
8863 
8864  protected:
8865  CImpinjxArrayDirectionCapabilities * m_pImpinjxArrayDirectionCapabilities;
8866 
8867  public:
8871  {
8872  return m_pImpinjxArrayDirectionCapabilities;
8873  }
8874 
8876  EResultCode
8879 
8880 
8881  protected:
8882  std::list<CParameter *> m_listCustom;
8883 
8884  public:
8886  inline std::list<CParameter *>::iterator
8888  {
8889  return m_listCustom.begin();
8890  }
8891 
8893  inline std::list<CParameter *>::iterator
8894  endCustom (void)
8895  {
8896  return m_listCustom.end();
8897  }
8898 
8900  inline void
8902  {
8903  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8904  }
8905 
8907  inline int
8909  {
8910  return (int) (m_listCustom.size());
8911  }
8912 
8913  EResultCode
8915  addCustom (
8916  CParameter * pValue);
8917 
8918 
8919 };
8920 
8921 
8949 class CImpinjTiltConfiguration : public CParameter
8950 {
8951  public:
8952  CImpinjTiltConfiguration (void);
8953  ~CImpinjTiltConfiguration (void);
8954 
8957 
8958  static const CFieldDescriptor * const
8959  s_apFieldDescriptorTable[];
8960 
8961  static const CTypeDescriptor
8962  s_typeDescriptor;
8963 
8964  void
8965  decodeFields (
8966  CDecoderStream * pDecoderStream);
8967 
8968  void
8969  assimilateSubParameters (
8970  CErrorDetails * pError);
8971 
8972  void
8973  encode (
8974  CEncoderStream * pEncoderStream) const;
8975 
8976 
8977  llrp_bool_t
8978  isAllowedIn (
8979  const CTypeDescriptor * pEnclosingElementType) const;
8980 
8981 
8982  static CElement *
8983  s_construct (void);
8984 
8985  static void
8986  s_decodeFields (
8987  CDecoderStream * pDecoderStream,
8988  CElement * pElement);
8990 
8991 
8992  protected:
8993  llrp_s32_t m_XAxis;
8994 
8997  public:
8998  static const CFieldDescriptor
8999  s_fdXAxis;
9001 
9003  inline llrp_s32_t
9004  getXAxis (void)
9005  {
9006  return m_XAxis;
9007  }
9008 
9010  inline void
9012  llrp_s32_t value)
9013  {
9014  m_XAxis = value;
9015  }
9016 
9017 
9018  protected:
9019  llrp_s32_t m_YAxis;
9020 
9023  public:
9024  static const CFieldDescriptor
9025  s_fdYAxis;
9027 
9029  inline llrp_s32_t
9030  getYAxis (void)
9031  {
9032  return m_YAxis;
9033  }
9034 
9036  inline void
9038  llrp_s32_t value)
9039  {
9040  m_YAxis = value;
9041  }
9042 
9043 
9044  protected:
9045  llrp_s32_t m_ZAxis;
9046 
9049  public:
9050  static const CFieldDescriptor
9051  s_fdZAxis;
9053 
9055  inline llrp_s32_t
9056  getZAxis (void)
9057  {
9058  return m_ZAxis;
9059  }
9060 
9062  inline void
9064  llrp_s32_t value)
9065  {
9066  m_ZAxis = value;
9067  }
9068 
9069 
9070  protected:
9071  std::list<CParameter *> m_listCustom;
9072 
9073  public:
9075  inline std::list<CParameter *>::iterator
9077  {
9078  return m_listCustom.begin();
9079  }
9080 
9082  inline std::list<CParameter *>::iterator
9083  endCustom (void)
9084  {
9085  return m_listCustom.end();
9086  }
9087 
9089  inline void
9091  {
9092  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9093  }
9094 
9096  inline int
9098  {
9099  return (int) (m_listCustom.size());
9100  }
9101 
9102  EResultCode
9104  addCustom (
9105  CParameter * pValue);
9106 
9107 
9108 };
9109 
9110 
9139 class CImpinjBeaconConfiguration : public CParameter
9140 {
9141  public:
9144 
9147 
9148  static const CFieldDescriptor * const
9149  s_apFieldDescriptorTable[];
9150 
9151  static const CTypeDescriptor
9152  s_typeDescriptor;
9153 
9154  void
9155  decodeFields (
9156  CDecoderStream * pDecoderStream);
9157 
9158  void
9159  assimilateSubParameters (
9160  CErrorDetails * pError);
9161 
9162  void
9163  encode (
9164  CEncoderStream * pEncoderStream) const;
9165 
9166 
9167  llrp_bool_t
9168  isAllowedIn (
9169  const CTypeDescriptor * pEnclosingElementType) const;
9170 
9171 
9172  static CElement *
9173  s_construct (void);
9174 
9175  static void
9176  s_decodeFields (
9177  CDecoderStream * pDecoderStream,
9178  CElement * pElement);
9180 
9181 
9182  protected:
9183  llrp_u1_t m_BeaconState;
9184 
9187  public:
9188  static const CFieldDescriptor
9189  s_fdBeaconState;
9191 
9193  inline llrp_u1_t
9195  {
9196  return m_BeaconState;
9197  }
9198 
9200  inline void
9202  llrp_u1_t value)
9203  {
9204  m_BeaconState = value;
9205  }
9206 
9207 
9208  protected:
9209  llrp_u64_t m_BeaconDurationSeconds;
9210 
9213  public:
9214  static const CFieldDescriptor
9215  s_fdBeaconDurationSeconds;
9217 
9219  inline llrp_u64_t
9221  {
9222  return m_BeaconDurationSeconds;
9223  }
9224 
9226  inline void
9228  llrp_u64_t value)
9229  {
9230  m_BeaconDurationSeconds = value;
9231  }
9232 
9233 
9234  protected:
9235  std::list<CParameter *> m_listCustom;
9236 
9237  public:
9239  inline std::list<CParameter *>::iterator
9241  {
9242  return m_listCustom.begin();
9243  }
9244 
9246  inline std::list<CParameter *>::iterator
9247  endCustom (void)
9248  {
9249  return m_listCustom.end();
9250  }
9251 
9253  inline void
9255  {
9256  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9257  }
9258 
9260  inline int
9262  {
9263  return (int) (m_listCustom.size());
9264  }
9265 
9266  EResultCode
9268  addCustom (
9269  CParameter * pValue);
9270 
9271 
9272 };
9273 
9274 
9302 class CImpinjAntennaConfiguration : public CParameter
9303 {
9304  public:
9307 
9310 
9311  static const CFieldDescriptor * const
9312  s_apFieldDescriptorTable[];
9313 
9314  static const CTypeDescriptor
9315  s_typeDescriptor;
9316 
9317  void
9318  decodeFields (
9319  CDecoderStream * pDecoderStream);
9320 
9321  void
9322  assimilateSubParameters (
9323  CErrorDetails * pError);
9324 
9325  void
9326  encode (
9327  CEncoderStream * pEncoderStream) const;
9328 
9329 
9330  llrp_bool_t
9331  isAllowedIn (
9332  const CTypeDescriptor * pEnclosingElementType) const;
9333 
9334 
9335  static CElement *
9336  s_construct (void);
9337 
9338  static void
9339  s_decodeFields (
9340  CDecoderStream * pDecoderStream,
9341  CElement * pElement);
9343 
9344 
9345  protected:
9346  CImpinjAntennaEventHysteresis * m_pImpinjAntennaEventHysteresis;
9347 
9348  public:
9352  {
9353  return m_pImpinjAntennaEventHysteresis;
9354  }
9355 
9357  EResultCode
9360 
9361 
9362  protected:
9363  CImpinjAntennaEventConfiguration * m_pImpinjAntennaEventConfiguration;
9364 
9365  public:
9369  {
9370  return m_pImpinjAntennaEventConfiguration;
9371  }
9372 
9374  EResultCode
9377 
9378 
9379  protected:
9380  std::list<CParameter *> m_listCustom;
9381 
9382  public:
9384  inline std::list<CParameter *>::iterator
9386  {
9387  return m_listCustom.begin();
9388  }
9389 
9391  inline std::list<CParameter *>::iterator
9392  endCustom (void)
9393  {
9394  return m_listCustom.end();
9395  }
9396 
9398  inline void
9400  {
9401  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9402  }
9403 
9405  inline int
9407  {
9408  return (int) (m_listCustom.size());
9409  }
9410 
9411  EResultCode
9413  addCustom (
9414  CParameter * pValue);
9415 
9416 
9417 };
9418 
9419 
9451 class CImpinjAntennaEventHysteresis : public CParameter
9452 {
9453  public:
9456 
9459 
9460  static const CFieldDescriptor * const
9461  s_apFieldDescriptorTable[];
9462 
9463  static const CTypeDescriptor
9464  s_typeDescriptor;
9465 
9466  void
9467  decodeFields (
9468  CDecoderStream * pDecoderStream);
9469 
9470  void
9471  assimilateSubParameters (
9472  CErrorDetails * pError);
9473 
9474  void
9475  encode (
9476  CEncoderStream * pEncoderStream) const;
9477 
9478 
9479  llrp_bool_t
9480  isAllowedIn (
9481  const CTypeDescriptor * pEnclosingElementType) const;
9482 
9483 
9484  static CElement *
9485  s_construct (void);
9486 
9487  static void
9488  s_decodeFields (
9489  CDecoderStream * pDecoderStream,
9490  CElement * pElement);
9492 
9493 
9494  protected:
9495  llrp_u64_t m_AntennaEventConnected;
9496 
9499  public:
9500  static const CFieldDescriptor
9501  s_fdAntennaEventConnected;
9503 
9505  inline llrp_u64_t
9507  {
9508  return m_AntennaEventConnected;
9509  }
9510 
9512  inline void
9514  llrp_u64_t value)
9515  {
9516  m_AntennaEventConnected = value;
9517  }
9518 
9519 
9520  protected:
9521  llrp_u64_t m_AntennaEventDisconnected;
9522 
9525  public:
9526  static const CFieldDescriptor
9527  s_fdAntennaEventDisconnected;
9529 
9531  inline llrp_u64_t
9533  {
9534  return m_AntennaEventDisconnected;
9535  }
9536 
9538  inline void
9540  llrp_u64_t value)
9541  {
9542  m_AntennaEventDisconnected = value;
9543  }
9544 
9545 
9546  protected:
9547  std::list<CParameter *> m_listCustom;
9548 
9549  public:
9551  inline std::list<CParameter *>::iterator
9553  {
9554  return m_listCustom.begin();
9555  }
9556 
9558  inline std::list<CParameter *>::iterator
9559  endCustom (void)
9560  {
9561  return m_listCustom.end();
9562  }
9563 
9565  inline void
9567  {
9568  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9569  }
9570 
9572  inline int
9574  {
9575  return (int) (m_listCustom.size());
9576  }
9577 
9578  EResultCode
9580  addCustom (
9581  CParameter * pValue);
9582 
9583 
9584 };
9585 
9586 
9612 class CImpinjAntennaEventConfiguration : public CParameter
9613 {
9614  public:
9617 
9620 
9621  static const CFieldDescriptor * const
9622  s_apFieldDescriptorTable[];
9623 
9624  static const CTypeDescriptor
9625  s_typeDescriptor;
9626 
9627  void
9628  decodeFields (
9629  CDecoderStream * pDecoderStream);
9630 
9631  void
9632  assimilateSubParameters (
9633  CErrorDetails * pError);
9634 
9635  void
9636  encode (
9637  CEncoderStream * pEncoderStream) const;
9638 
9639 
9640  llrp_bool_t
9641  isAllowedIn (
9642  const CTypeDescriptor * pEnclosingElementType) const;
9643 
9644 
9645  static CElement *
9646  s_construct (void);
9647 
9648  static void
9649  s_decodeFields (
9650  CDecoderStream * pDecoderStream,
9651  CElement * pElement);
9653 
9654 
9655  protected:
9656  llrp_u1_t m_EnableAntennaAttemptNotification;
9657 
9660  public:
9661  static const CFieldDescriptor
9662  s_fdEnableAntennaAttemptNotification;
9664 
9666  inline llrp_u1_t
9668  {
9669  return m_EnableAntennaAttemptNotification;
9670  }
9671 
9673  inline void
9675  llrp_u1_t value)
9676  {
9677  m_EnableAntennaAttemptNotification = value;
9678  }
9679 
9680 
9681  protected:
9682  std::list<CParameter *> m_listCustom;
9683 
9684  public:
9686  inline std::list<CParameter *>::iterator
9688  {
9689  return m_listCustom.begin();
9690  }
9691 
9693  inline std::list<CParameter *>::iterator
9694  endCustom (void)
9695  {
9696  return m_listCustom.end();
9697  }
9698 
9700  inline void
9702  {
9703  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9704  }
9705 
9707  inline int
9709  {
9710  return (int) (m_listCustom.size());
9711  }
9712 
9713  EResultCode
9715  addCustom (
9716  CParameter * pValue);
9717 
9718 
9719 };
9720 
9721 
9746 class CImpinjAntennaAttemptEvent : public CParameter
9747 {
9748  public:
9751 
9754 
9755  static const CFieldDescriptor * const
9756  s_apFieldDescriptorTable[];
9757 
9758  static const CTypeDescriptor
9759  s_typeDescriptor;
9760 
9761  void
9762  decodeFields (
9763  CDecoderStream * pDecoderStream);
9764 
9765  void
9766  assimilateSubParameters (
9767  CErrorDetails * pError);
9768 
9769  void
9770  encode (
9771  CEncoderStream * pEncoderStream) const;
9772 
9773 
9774  llrp_bool_t
9775  isAllowedIn (
9776  const CTypeDescriptor * pEnclosingElementType) const;
9777 
9778 
9779  static CElement *
9780  s_construct (void);
9781 
9782  static void
9783  s_decodeFields (
9784  CDecoderStream * pDecoderStream,
9785  CElement * pElement);
9787 
9788 
9789  protected:
9790  llrp_u16_t m_AntennaID;
9791 
9794  public:
9795  static const CFieldDescriptor
9796  s_fdAntennaID;
9798 
9800  inline llrp_u16_t
9802  {
9803  return m_AntennaID;
9804  }
9805 
9807  inline void
9809  llrp_u16_t value)
9810  {
9811  m_AntennaID = value;
9812  }
9813 
9814 
9815  protected:
9816  std::list<CParameter *> m_listCustom;
9817 
9818  public:
9820  inline std::list<CParameter *>::iterator
9822  {
9823  return m_listCustom.begin();
9824  }
9825 
9827  inline std::list<CParameter *>::iterator
9828  endCustom (void)
9829  {
9830  return m_listCustom.end();
9831  }
9832 
9834  inline void
9836  {
9837  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9838  }
9839 
9841  inline int
9843  {
9844  return (int) (m_listCustom.size());
9845  }
9846 
9847  EResultCode
9849  addCustom (
9850  CParameter * pValue);
9851 
9852 
9853 };
9854 
9855 
9883 class CImpinjHubConfiguration : public CParameter
9884 {
9885  public:
9886  CImpinjHubConfiguration (void);
9887  ~CImpinjHubConfiguration (void);
9888 
9891 
9892  static const CFieldDescriptor * const
9893  s_apFieldDescriptorTable[];
9894 
9895  static const CTypeDescriptor
9896  s_typeDescriptor;
9897 
9898  void
9899  decodeFields (
9900  CDecoderStream * pDecoderStream);
9901 
9902  void
9903  assimilateSubParameters (
9904  CErrorDetails * pError);
9905 
9906  void
9907  encode (
9908  CEncoderStream * pEncoderStream) const;
9909 
9910 
9911  llrp_bool_t
9912  isAllowedIn (
9913  const CTypeDescriptor * pEnclosingElementType) const;
9914 
9915 
9916  static CElement *
9917  s_construct (void);
9918 
9919  static void
9920  s_decodeFields (
9921  CDecoderStream * pDecoderStream,
9922  CElement * pElement);
9924 
9925 
9926  protected:
9927  llrp_u16_t m_HubID;
9928 
9931  public:
9932  static const CFieldDescriptor
9933  s_fdHubID;
9935 
9937  inline llrp_u16_t
9938  getHubID (void)
9939  {
9940  return m_HubID;
9941  }
9942 
9944  inline void
9946  llrp_u16_t value)
9947  {
9948  m_HubID = value;
9949  }
9950 
9951 
9952  protected:
9953  EImpinjHubConnectedType m_eConnected;
9954 
9957  public:
9958  static const CFieldDescriptor
9959  s_fdConnected;
9961 
9963  inline EImpinjHubConnectedType
9965  {
9966  return m_eConnected;
9967  }
9968 
9970  inline void
9972  EImpinjHubConnectedType value)
9973  {
9974  m_eConnected = value;
9975  }
9976 
9977 
9978  protected:
9979  EImpinjHubFaultType m_eFault;
9980 
9983  public:
9984  static const CFieldDescriptor
9985  s_fdFault;
9987 
9989  inline EImpinjHubFaultType
9990  getFault (void)
9991  {
9992  return m_eFault;
9993  }
9994 
9996  inline void
9998  EImpinjHubFaultType value)
9999  {
10000  m_eFault = value;
10001  }
10002 
10003 
10004  protected:
10005  std::list<CParameter *> m_listCustom;
10006 
10007  public:
10009  inline std::list<CParameter *>::iterator
10011  {
10012  return m_listCustom.begin();
10013  }
10014 
10016  inline std::list<CParameter *>::iterator
10017  endCustom (void)
10018  {
10019  return m_listCustom.end();
10020  }
10021 
10023  inline void
10025  {
10026  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10027  }
10028 
10030  inline int
10032  {
10033  return (int) (m_listCustom.size());
10034  }
10035 
10036  EResultCode
10038  addCustom (
10039  CParameter * pValue);
10040 
10041 
10042 };
10043 
10044 
10068 class CImpinjDiagnosticReport : public CParameter
10069 {
10070  public:
10071  CImpinjDiagnosticReport (void);
10072  ~CImpinjDiagnosticReport (void);
10073 
10076 
10077  static const CFieldDescriptor * const
10078  s_apFieldDescriptorTable[];
10079 
10080  static const CTypeDescriptor
10081  s_typeDescriptor;
10082 
10083  void
10084  decodeFields (
10085  CDecoderStream * pDecoderStream);
10086 
10087  void
10088  assimilateSubParameters (
10089  CErrorDetails * pError);
10090 
10091  void
10092  encode (
10093  CEncoderStream * pEncoderStream) const;
10094 
10095 
10096  llrp_bool_t
10097  isAllowedIn (
10098  const CTypeDescriptor * pEnclosingElementType) const;
10099 
10100 
10101  static CElement *
10102  s_construct (void);
10103 
10104  static void
10105  s_decodeFields (
10106  CDecoderStream * pDecoderStream,
10107  CElement * pElement);
10109 
10110 
10111  protected:
10112  llrp_u32v_t m_Metric;
10113 
10116  public:
10117  static const CFieldDescriptor
10118  s_fdMetric;
10120 
10122  inline llrp_u32v_t
10123  getMetric (void)
10124  {
10125  return m_Metric;
10126  }
10127 
10129  inline void
10131  llrp_u32v_t value)
10132  {
10133  m_Metric = value;
10134  }
10135 
10136 
10137 };
10138 
10139 
10178 class CImpinjPlacementConfiguration : public CParameter
10179 {
10180  public:
10183 
10186 
10187  static const CFieldDescriptor * const
10188  s_apFieldDescriptorTable[];
10189 
10190  static const CTypeDescriptor
10191  s_typeDescriptor;
10192 
10193  void
10194  decodeFields (
10195  CDecoderStream * pDecoderStream);
10196 
10197  void
10198  assimilateSubParameters (
10199  CErrorDetails * pError);
10200 
10201  void
10202  encode (
10203  CEncoderStream * pEncoderStream) const;
10204 
10205 
10206  llrp_bool_t
10207  isAllowedIn (
10208  const CTypeDescriptor * pEnclosingElementType) const;
10209 
10210 
10211  static CElement *
10212  s_construct (void);
10213 
10214  static void
10215  s_decodeFields (
10216  CDecoderStream * pDecoderStream,
10217  CElement * pElement);
10219 
10220 
10221  protected:
10222  llrp_u16_t m_HeightCm;
10223 
10226  public:
10227  static const CFieldDescriptor
10228  s_fdHeightCm;
10230 
10232  inline llrp_u16_t
10234  {
10235  return m_HeightCm;
10236  }
10237 
10239  inline void
10241  llrp_u16_t value)
10242  {
10243  m_HeightCm = value;
10244  }
10245 
10246 
10247  protected:
10248  llrp_s32_t m_FacilityXLocationCm;
10249 
10252  public:
10253  static const CFieldDescriptor
10254  s_fdFacilityXLocationCm;
10256 
10258  inline llrp_s32_t
10260  {
10261  return m_FacilityXLocationCm;
10262  }
10263 
10265  inline void
10267  llrp_s32_t value)
10268  {
10269  m_FacilityXLocationCm = value;
10270  }
10271 
10272 
10273  protected:
10274  llrp_s32_t m_FacilityYLocationCm;
10275 
10278  public:
10279  static const CFieldDescriptor
10280  s_fdFacilityYLocationCm;
10282 
10284  inline llrp_s32_t
10286  {
10287  return m_FacilityYLocationCm;
10288  }
10289 
10291  inline void
10293  llrp_s32_t value)
10294  {
10295  m_FacilityYLocationCm = value;
10296  }
10297 
10298 
10299  protected:
10300  llrp_s16_t m_OrientationDegrees;
10301 
10304  public:
10305  static const CFieldDescriptor
10306  s_fdOrientationDegrees;
10308 
10310  inline llrp_s16_t
10312  {
10313  return m_OrientationDegrees;
10314  }
10315 
10317  inline void
10319  llrp_s16_t value)
10320  {
10321  m_OrientationDegrees = value;
10322  }
10323 
10324 
10325  protected:
10326  std::list<CParameter *> m_listCustom;
10327 
10328  public:
10330  inline std::list<CParameter *>::iterator
10332  {
10333  return m_listCustom.begin();
10334  }
10335 
10337  inline std::list<CParameter *>::iterator
10338  endCustom (void)
10339  {
10340  return m_listCustom.end();
10341  }
10342 
10344  inline void
10346  {
10347  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10348  }
10349 
10351  inline int
10353  {
10354  return (int) (m_listCustom.size());
10355  }
10356 
10357  EResultCode
10359  addCustom (
10360  CParameter * pValue);
10361 
10362 
10363 };
10364 
10365 
10396 class CImpinjLISpec : public CParameter
10397 {
10398  public:
10399  CImpinjLISpec (void);
10400  ~CImpinjLISpec (void);
10401 
10404 
10405  static const CFieldDescriptor * const
10406  s_apFieldDescriptorTable[];
10407 
10408  static const CTypeDescriptor
10409  s_typeDescriptor;
10410 
10411  void
10412  decodeFields (
10413  CDecoderStream * pDecoderStream);
10414 
10415  void
10416  assimilateSubParameters (
10417  CErrorDetails * pError);
10418 
10419  void
10420  encode (
10421  CEncoderStream * pEncoderStream) const;
10422 
10423 
10424  llrp_bool_t
10425  isAllowedIn (
10426  const CTypeDescriptor * pEnclosingElementType) const;
10427 
10428 
10429  static CElement *
10430  s_construct (void);
10431 
10432  static void
10433  s_decodeFields (
10434  CDecoderStream * pDecoderStream,
10435  CElement * pElement);
10437 
10438 
10439  protected:
10440  CImpinjLocationConfig * m_pImpinjLocationConfig;
10441 
10442  public:
10444  inline CImpinjLocationConfig *
10446  {
10447  return m_pImpinjLocationConfig;
10448  }
10449 
10451  EResultCode
10453  CImpinjLocationConfig * pValue);
10454 
10455 
10456  protected:
10457  CImpinjC1G2LocationConfig * m_pImpinjC1G2LocationConfig;
10458 
10459  public:
10461  inline CImpinjC1G2LocationConfig *
10463  {
10464  return m_pImpinjC1G2LocationConfig;
10465  }
10466 
10468  EResultCode
10470  CImpinjC1G2LocationConfig * pValue);
10471 
10472 
10473  protected:
10474  CImpinjLocationReporting * m_pImpinjLocationReporting;
10475 
10476  public:
10478  inline CImpinjLocationReporting *
10480  {
10481  return m_pImpinjLocationReporting;
10482  }
10483 
10485  EResultCode
10487  CImpinjLocationReporting * pValue);
10488 
10489 
10490  protected:
10491  std::list<CParameter *> m_listCustom;
10492 
10493  public:
10495  inline std::list<CParameter *>::iterator
10497  {
10498  return m_listCustom.begin();
10499  }
10500 
10502  inline std::list<CParameter *>::iterator
10503  endCustom (void)
10504  {
10505  return m_listCustom.end();
10506  }
10507 
10509  inline void
10511  {
10512  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10513  }
10514 
10516  inline int
10518  {
10519  return (int) (m_listCustom.size());
10520  }
10521 
10522  EResultCode
10524  addCustom (
10525  CParameter * pValue);
10526 
10527 
10528 };
10529 
10530 
10572 class CImpinjLocationConfig : public CParameter
10573 {
10574  public:
10575  CImpinjLocationConfig (void);
10576  ~CImpinjLocationConfig (void);
10577 
10580 
10581  static const CFieldDescriptor * const
10582  s_apFieldDescriptorTable[];
10583 
10584  static const CTypeDescriptor
10585  s_typeDescriptor;
10586 
10587  void
10588  decodeFields (
10589  CDecoderStream * pDecoderStream);
10590 
10591  void
10592  assimilateSubParameters (
10593  CErrorDetails * pError);
10594 
10595  void
10596  encode (
10597  CEncoderStream * pEncoderStream) const;
10598 
10599 
10600  llrp_bool_t
10601  isAllowedIn (
10602  const CTypeDescriptor * pEnclosingElementType) const;
10603 
10604 
10605  static CElement *
10606  s_construct (void);
10607 
10608  static void
10609  s_decodeFields (
10610  CDecoderStream * pDecoderStream,
10611  CElement * pElement);
10613 
10614 
10615  protected:
10616  llrp_u16_t m_ComputeWindowSeconds;
10617 
10620  public:
10621  static const CFieldDescriptor
10622  s_fdComputeWindowSeconds;
10624 
10626  inline llrp_u16_t
10628  {
10629  return m_ComputeWindowSeconds;
10630  }
10631 
10633  inline void
10635  llrp_u16_t value)
10636  {
10637  m_ComputeWindowSeconds = value;
10638  }
10639 
10640 
10641  protected:
10642  llrp_u16_t m_TagAgeIntervalSeconds;
10643 
10646  public:
10647  static const CFieldDescriptor
10648  s_fdTagAgeIntervalSeconds;
10650 
10652  inline llrp_u16_t
10654  {
10655  return m_TagAgeIntervalSeconds;
10656  }
10657 
10659  inline void
10661  llrp_u16_t value)
10662  {
10663  m_TagAgeIntervalSeconds = value;
10664  }
10665 
10666 
10667  protected:
10668  llrp_u16_t m_UpdateIntervalSeconds;
10669 
10672  public:
10673  static const CFieldDescriptor
10674  s_fdUpdateIntervalSeconds;
10676 
10678  inline llrp_u16_t
10680  {
10681  return m_UpdateIntervalSeconds;
10682  }
10683 
10685  inline void
10687  llrp_u16_t value)
10688  {
10689  m_UpdateIntervalSeconds = value;
10690  }
10691 
10692 
10693  protected:
10694  CImpinjDisabledAntennas * m_pImpinjDisabledAntennas;
10695 
10696  public:
10698  inline CImpinjDisabledAntennas *
10700  {
10701  return m_pImpinjDisabledAntennas;
10702  }
10703 
10705  EResultCode
10707  CImpinjDisabledAntennas * pValue);
10708 
10709 
10710  protected:
10711  std::list<CParameter *> m_listCustom;
10712 
10713  public:
10715  inline std::list<CParameter *>::iterator
10717  {
10718  return m_listCustom.begin();
10719  }
10720 
10722  inline std::list<CParameter *>::iterator
10723  endCustom (void)
10724  {
10725  return m_listCustom.end();
10726  }
10727 
10729  inline void
10731  {
10732  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10733  }
10734 
10736  inline int
10738  {
10739  return (int) (m_listCustom.size());
10740  }
10741 
10742  EResultCode
10744  addCustom (
10745  CParameter * pValue);
10746 
10747 
10748 };
10749 
10750 
10793 class CImpinjC1G2LocationConfig : public CParameter
10794 {
10795  public:
10797  ~CImpinjC1G2LocationConfig (void);
10798 
10801 
10802  static const CFieldDescriptor * const
10803  s_apFieldDescriptorTable[];
10804 
10805  static const CTypeDescriptor
10806  s_typeDescriptor;
10807 
10808  void
10809  decodeFields (
10810  CDecoderStream * pDecoderStream);
10811 
10812  void
10813  assimilateSubParameters (
10814  CErrorDetails * pError);
10815 
10816  void
10817  encode (
10818  CEncoderStream * pEncoderStream) const;
10819 
10820 
10821  llrp_bool_t
10822  isAllowedIn (
10823  const CTypeDescriptor * pEnclosingElementType) const;
10824 
10825 
10826  static CElement *
10827  s_construct (void);
10828 
10829  static void
10830  s_decodeFields (
10831  CDecoderStream * pDecoderStream,
10832  CElement * pElement);
10834 
10835 
10836  protected:
10837  llrp_u16_t m_ModeIndex;
10838 
10841  public:
10842  static const CFieldDescriptor
10843  s_fdModeIndex;
10845 
10847  inline llrp_u16_t
10849  {
10850  return m_ModeIndex;
10851  }
10852 
10854  inline void
10856  llrp_u16_t value)
10857  {
10858  m_ModeIndex = value;
10859  }
10860 
10861 
10862  protected:
10863  llrp_u2_t m_Session;
10864 
10867  public:
10868  static const CFieldDescriptor
10869  s_fdSession;
10871 
10873  inline llrp_u2_t
10874  getSession (void)
10875  {
10876  return m_Session;
10877  }
10878 
10880  inline void
10882  llrp_u2_t value)
10883  {
10884  m_Session = value;
10885  }
10886 
10887 
10888  protected:
10889  std::list<CC1G2Filter *> m_listC1G2Filter;
10890 
10891  public:
10893  inline std::list<CC1G2Filter *>::iterator
10895  {
10896  return m_listC1G2Filter.begin();
10897  }
10898 
10900  inline std::list<CC1G2Filter *>::iterator
10902  {
10903  return m_listC1G2Filter.end();
10904  }
10905 
10907  inline void
10909  {
10910  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
10911  }
10912 
10914  inline int
10916  {
10917  return (int) (m_listC1G2Filter.size());
10918  }
10919 
10920  EResultCode
10922  addC1G2Filter (
10923  CC1G2Filter * pValue);
10924 
10925 
10926  protected:
10927  CImpinjTransmitPower * m_pImpinjTransmitPower;
10928 
10929  public:
10931  inline CImpinjTransmitPower *
10933  {
10934  return m_pImpinjTransmitPower;
10935  }
10936 
10938  EResultCode
10940  CImpinjTransmitPower * pValue);
10941 
10942 
10943  protected:
10944  std::list<CParameter *> m_listCustom;
10945 
10946  public:
10948  inline std::list<CParameter *>::iterator
10950  {
10951  return m_listCustom.begin();
10952  }
10953 
10955  inline std::list<CParameter *>::iterator
10956  endCustom (void)
10957  {
10958  return m_listCustom.end();
10959  }
10960 
10962  inline void
10964  {
10965  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10966  }
10967 
10969  inline int
10971  {
10972  return (int) (m_listCustom.size());
10973  }
10974 
10975  EResultCode
10977  addCustom (
10978  CParameter * pValue);
10979 
10980 
10981 };
10982 
10983 
11025 class CImpinjLocationReporting : public CParameter
11026 {
11027  public:
11028  CImpinjLocationReporting (void);
11029  ~CImpinjLocationReporting (void);
11030 
11033 
11034  static const CFieldDescriptor * const
11035  s_apFieldDescriptorTable[];
11036 
11037  static const CTypeDescriptor
11038  s_typeDescriptor;
11039 
11040  void
11041  decodeFields (
11042  CDecoderStream * pDecoderStream);
11043 
11044  void
11045  assimilateSubParameters (
11046  CErrorDetails * pError);
11047 
11048  void
11049  encode (
11050  CEncoderStream * pEncoderStream) const;
11051 
11052 
11053  llrp_bool_t
11054  isAllowedIn (
11055  const CTypeDescriptor * pEnclosingElementType) const;
11056 
11057 
11058  static CElement *
11059  s_construct (void);
11060 
11061  static void
11062  s_decodeFields (
11063  CDecoderStream * pDecoderStream,
11064  CElement * pElement);
11066 
11067 
11068  protected:
11069  llrp_u1_t m_EnableUpdateReport;
11070 
11073  public:
11074  static const CFieldDescriptor
11075  s_fdEnableUpdateReport;
11077 
11079  inline llrp_u1_t
11081  {
11082  return m_EnableUpdateReport;
11083  }
11084 
11086  inline void
11088  llrp_u1_t value)
11089  {
11090  m_EnableUpdateReport = value;
11091  }
11092 
11093 
11094  protected:
11095  llrp_u1_t m_EnableEntryReport;
11096 
11099  public:
11100  static const CFieldDescriptor
11101  s_fdEnableEntryReport;
11103 
11105  inline llrp_u1_t
11107  {
11108  return m_EnableEntryReport;
11109  }
11110 
11112  inline void
11114  llrp_u1_t value)
11115  {
11116  m_EnableEntryReport = value;
11117  }
11118 
11119 
11120  protected:
11121  llrp_u1_t m_EnableExitReport;
11122 
11125  public:
11126  static const CFieldDescriptor
11127  s_fdEnableExitReport;
11129 
11131  inline llrp_u1_t
11133  {
11134  return m_EnableExitReport;
11135  }
11136 
11138  inline void
11140  llrp_u1_t value)
11141  {
11142  m_EnableExitReport = value;
11143  }
11144 
11145 
11146  protected:
11147  llrp_u1_t m_EnableDiagnosticReport;
11148 
11151  public:
11152  static const CFieldDescriptor
11153  s_fdEnableDiagnosticReport;
11155 
11157  inline llrp_u1_t
11159  {
11160  return m_EnableDiagnosticReport;
11161  }
11162 
11164  inline void
11166  llrp_u1_t value)
11167  {
11168  m_EnableDiagnosticReport = value;
11169  }
11170 
11171 
11172  protected:
11173  std::list<CParameter *> m_listCustom;
11174 
11175  public:
11177  inline std::list<CParameter *>::iterator
11179  {
11180  return m_listCustom.begin();
11181  }
11182 
11184  inline std::list<CParameter *>::iterator
11185  endCustom (void)
11186  {
11187  return m_listCustom.end();
11188  }
11189 
11191  inline void
11193  {
11194  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11195  }
11196 
11198  inline int
11200  {
11201  return (int) (m_listCustom.size());
11202  }
11203 
11204  EResultCode
11206  addCustom (
11207  CParameter * pValue);
11208 
11209 
11210 };
11211 
11212 
11243 class CImpinjLocationConfidence : public CParameter
11244 {
11245  public:
11247  ~CImpinjLocationConfidence (void);
11248 
11251 
11252  static const CFieldDescriptor * const
11253  s_apFieldDescriptorTable[];
11254 
11255  static const CTypeDescriptor
11256  s_typeDescriptor;
11257 
11258  void
11259  decodeFields (
11260  CDecoderStream * pDecoderStream);
11261 
11262  void
11263  assimilateSubParameters (
11264  CErrorDetails * pError);
11265 
11266  void
11267  encode (
11268  CEncoderStream * pEncoderStream) const;
11269 
11270 
11271  llrp_bool_t
11272  isAllowedIn (
11273  const CTypeDescriptor * pEnclosingElementType) const;
11274 
11275 
11276  static CElement *
11277  s_construct (void);
11278 
11279  static void
11280  s_decodeFields (
11281  CDecoderStream * pDecoderStream,
11282  CElement * pElement);
11284 
11285 
11286  protected:
11287  llrp_u16_t m_ReadCount;
11288 
11291  public:
11292  static const CFieldDescriptor
11293  s_fdReadCount;
11295 
11297  inline llrp_u16_t
11299  {
11300  return m_ReadCount;
11301  }
11302 
11304  inline void
11306  llrp_u16_t value)
11307  {
11308  m_ReadCount = value;
11309  }
11310 
11311 
11312  protected:
11313  llrp_u32v_t m_ConfidenceData;
11314 
11317  public:
11318  static const CFieldDescriptor
11319  s_fdConfidenceData;
11321 
11323  inline llrp_u32v_t
11325  {
11326  return m_ConfidenceData;
11327  }
11328 
11330  inline void
11332  llrp_u32v_t value)
11333  {
11334  m_ConfidenceData = value;
11335  }
11336 
11337 
11338  protected:
11339  std::list<CParameter *> m_listCustom;
11340 
11341  public:
11343  inline std::list<CParameter *>::iterator
11345  {
11346  return m_listCustom.begin();
11347  }
11348 
11350  inline std::list<CParameter *>::iterator
11351  endCustom (void)
11352  {
11353  return m_listCustom.end();
11354  }
11355 
11357  inline void
11359  {
11360  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11361  }
11362 
11364  inline int
11366  {
11367  return (int) (m_listCustom.size());
11368  }
11369 
11370  EResultCode
11372  addCustom (
11373  CParameter * pValue);
11374 
11375 
11376 };
11377 
11378 
11416 class CImpinjLocationReportData : public CParameter
11417 {
11418  public:
11420  ~CImpinjLocationReportData (void);
11421 
11424 
11425  static const CFieldDescriptor * const
11426  s_apFieldDescriptorTable[];
11427 
11428  static const CTypeDescriptor
11429  s_typeDescriptor;
11430 
11431  void
11432  decodeFields (
11433  CDecoderStream * pDecoderStream);
11434 
11435  void
11436  assimilateSubParameters (
11437  CErrorDetails * pError);
11438 
11439  void
11440  encode (
11441  CEncoderStream * pEncoderStream) const;
11442 
11443 
11444  llrp_bool_t
11445  isAllowedIn (
11446  const CTypeDescriptor * pEnclosingElementType) const;
11447 
11448 
11449  static CElement *
11450  s_construct (void);
11451 
11452  static void
11453  s_decodeFields (
11454  CDecoderStream * pDecoderStream,
11455  CElement * pElement);
11457 
11458 
11459  protected:
11460  llrp_u64_t m_LastSeenTimestampUTC;
11461 
11464  public:
11465  static const CFieldDescriptor
11466  s_fdLastSeenTimestampUTC;
11468 
11470  inline llrp_u64_t
11472  {
11473  return m_LastSeenTimestampUTC;
11474  }
11475 
11477  inline void
11479  llrp_u64_t value)
11480  {
11481  m_LastSeenTimestampUTC = value;
11482  }
11483 
11484 
11485  protected:
11486  llrp_s32_t m_LocXCentimeters;
11487 
11490  public:
11491  static const CFieldDescriptor
11492  s_fdLocXCentimeters;
11494 
11496  inline llrp_s32_t
11498  {
11499  return m_LocXCentimeters;
11500  }
11501 
11503  inline void
11505  llrp_s32_t value)
11506  {
11507  m_LocXCentimeters = value;
11508  }
11509 
11510 
11511  protected:
11512  llrp_s32_t m_LocYCentimeters;
11513 
11516  public:
11517  static const CFieldDescriptor
11518  s_fdLocYCentimeters;
11520 
11522  inline llrp_s32_t
11524  {
11525  return m_LocYCentimeters;
11526  }
11527 
11529  inline void
11531  llrp_s32_t value)
11532  {
11533  m_LocYCentimeters = value;
11534  }
11535 
11536 
11537  protected:
11538  EImpinjLocationReportType m_eType;
11539 
11542  public:
11543  static const CFieldDescriptor
11544  s_fdType;
11546 
11548  inline EImpinjLocationReportType
11549  getType (void)
11550  {
11551  return m_eType;
11552  }
11553 
11555  inline void
11557  EImpinjLocationReportType value)
11558  {
11559  m_eType = value;
11560  }
11561 
11562 
11563  protected:
11564  CImpinjLocationConfidence * m_pImpinjLocationConfidence;
11565 
11566  public:
11568  inline CImpinjLocationConfidence *
11570  {
11571  return m_pImpinjLocationConfidence;
11572  }
11573 
11575  EResultCode
11577  CImpinjLocationConfidence * pValue);
11578 
11579 
11580  protected:
11581  std::list<CParameter *> m_listCustom;
11582 
11583  public:
11585  inline std::list<CParameter *>::iterator
11587  {
11588  return m_listCustom.begin();
11589  }
11590 
11592  inline std::list<CParameter *>::iterator
11593  endCustom (void)
11594  {
11595  return m_listCustom.end();
11596  }
11597 
11599  inline void
11601  {
11602  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11603  }
11604 
11606  inline int
11608  {
11609  return (int) (m_listCustom.size());
11610  }
11611 
11612  EResultCode
11614  addCustom (
11615  CParameter * pValue);
11616 
11617 
11618 };
11619 
11620 
11653 class CImpinjDISpec : public CParameter
11654 {
11655  public:
11656  CImpinjDISpec (void);
11657  ~CImpinjDISpec (void);
11658 
11661 
11662  static const CFieldDescriptor * const
11663  s_apFieldDescriptorTable[];
11664 
11665  static const CTypeDescriptor
11666  s_typeDescriptor;
11667 
11668  void
11669  decodeFields (
11670  CDecoderStream * pDecoderStream);
11671 
11672  void
11673  assimilateSubParameters (
11674  CErrorDetails * pError);
11675 
11676  void
11677  encode (
11678  CEncoderStream * pEncoderStream) const;
11679 
11680 
11681  llrp_bool_t
11682  isAllowedIn (
11683  const CTypeDescriptor * pEnclosingElementType) const;
11684 
11685 
11686  static CElement *
11687  s_construct (void);
11688 
11689  static void
11690  s_decodeFields (
11691  CDecoderStream * pDecoderStream,
11692  CElement * pElement);
11694 
11695 
11696  protected:
11697  CImpinjDirectionSectors * m_pImpinjDirectionSectors;
11698 
11699  public:
11701  inline CImpinjDirectionSectors *
11703  {
11704  return m_pImpinjDirectionSectors;
11705  }
11706 
11708  EResultCode
11710  CImpinjDirectionSectors * pValue);
11711 
11712 
11713  protected:
11714  CImpinjDirectionConfig * m_pImpinjDirectionConfig;
11715 
11716  public:
11718  inline CImpinjDirectionConfig *
11720  {
11721  return m_pImpinjDirectionConfig;
11722  }
11723 
11725  EResultCode
11727  CImpinjDirectionConfig * pValue);
11728 
11729 
11730  protected:
11731  CImpinjC1G2DirectionConfig * m_pImpinjC1G2DirectionConfig;
11732 
11733  public:
11737  {
11738  return m_pImpinjC1G2DirectionConfig;
11739  }
11740 
11742  EResultCode
11744  CImpinjC1G2DirectionConfig * pValue);
11745 
11746 
11747  protected:
11748  CImpinjDirectionReporting * m_pImpinjDirectionReporting;
11749 
11750  public:
11752  inline CImpinjDirectionReporting *
11754  {
11755  return m_pImpinjDirectionReporting;
11756  }
11757 
11759  EResultCode
11761  CImpinjDirectionReporting * pValue);
11762 
11763 
11764  protected:
11765  std::list<CParameter *> m_listCustom;
11766 
11767  public:
11769  inline std::list<CParameter *>::iterator
11771  {
11772  return m_listCustom.begin();
11773  }
11774 
11776  inline std::list<CParameter *>::iterator
11777  endCustom (void)
11778  {
11779  return m_listCustom.end();
11780  }
11781 
11783  inline void
11785  {
11786  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11787  }
11788 
11790  inline int
11792  {
11793  return (int) (m_listCustom.size());
11794  }
11795 
11796  EResultCode
11798  addCustom (
11799  CParameter * pValue);
11800 
11801 
11802 };
11803 
11804 
11832 class CImpinjDirectionSectors : public CParameter
11833 {
11834  public:
11835  CImpinjDirectionSectors (void);
11836  ~CImpinjDirectionSectors (void);
11837 
11840 
11841  static const CFieldDescriptor * const
11842  s_apFieldDescriptorTable[];
11843 
11844  static const CTypeDescriptor
11845  s_typeDescriptor;
11846 
11847  void
11848  decodeFields (
11849  CDecoderStream * pDecoderStream);
11850 
11851  void
11852  assimilateSubParameters (
11853  CErrorDetails * pError);
11854 
11855  void
11856  encode (
11857  CEncoderStream * pEncoderStream) const;
11858 
11859 
11860  llrp_bool_t
11861  isAllowedIn (
11862  const CTypeDescriptor * pEnclosingElementType) const;
11863 
11864 
11865  static CElement *
11866  s_construct (void);
11867 
11868  static void
11869  s_decodeFields (
11870  CDecoderStream * pDecoderStream,
11871  CElement * pElement);
11873 
11874 
11875  protected:
11876  llrp_u16v_t m_EnabledSectorIDs;
11877 
11880  public:
11881  static const CFieldDescriptor
11882  s_fdEnabledSectorIDs;
11884 
11886  inline llrp_u16v_t
11888  {
11889  return m_EnabledSectorIDs;
11890  }
11891 
11893  inline void
11895  llrp_u16v_t value)
11896  {
11897  m_EnabledSectorIDs = value;
11898  }
11899 
11900 
11901  protected:
11902  std::list<CParameter *> m_listCustom;
11903 
11904  public:
11906  inline std::list<CParameter *>::iterator
11908  {
11909  return m_listCustom.begin();
11910  }
11911 
11913  inline std::list<CParameter *>::iterator
11914  endCustom (void)
11915  {
11916  return m_listCustom.end();
11917  }
11918 
11920  inline void
11922  {
11923  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11924  }
11925 
11927  inline int
11929  {
11930  return (int) (m_listCustom.size());
11931  }
11932 
11933  EResultCode
11935  addCustom (
11936  CParameter * pValue);
11937 
11938 
11939 };
11940 
11941 
11980 class CImpinjDirectionConfig : public CParameter
11981 {
11982  public:
11983  CImpinjDirectionConfig (void);
11984  ~CImpinjDirectionConfig (void);
11985 
11988 
11989  static const CFieldDescriptor * const
11990  s_apFieldDescriptorTable[];
11991 
11992  static const CTypeDescriptor
11993  s_typeDescriptor;
11994 
11995  void
11996  decodeFields (
11997  CDecoderStream * pDecoderStream);
11998 
11999  void
12000  assimilateSubParameters (
12001  CErrorDetails * pError);
12002 
12003  void
12004  encode (
12005  CEncoderStream * pEncoderStream) const;
12006 
12007 
12008  llrp_bool_t
12009  isAllowedIn (
12010  const CTypeDescriptor * pEnclosingElementType) const;
12011 
12012 
12013  static CElement *
12014  s_construct (void);
12015 
12016  static void
12017  s_decodeFields (
12018  CDecoderStream * pDecoderStream,
12019  CElement * pElement);
12021 
12022 
12023  protected:
12024  llrp_u16_t m_TagAgeIntervalSeconds;
12025 
12028  public:
12029  static const CFieldDescriptor
12030  s_fdTagAgeIntervalSeconds;
12032 
12034  inline llrp_u16_t
12036  {
12037  return m_TagAgeIntervalSeconds;
12038  }
12039 
12041  inline void
12043  llrp_u16_t value)
12044  {
12045  m_TagAgeIntervalSeconds = value;
12046  }
12047 
12048 
12049  protected:
12050  llrp_u16_t m_UpdateIntervalSeconds;
12051 
12054  public:
12055  static const CFieldDescriptor
12056  s_fdUpdateIntervalSeconds;
12058 
12060  inline llrp_u16_t
12062  {
12063  return m_UpdateIntervalSeconds;
12064  }
12065 
12067  inline void
12069  llrp_u16_t value)
12070  {
12071  m_UpdateIntervalSeconds = value;
12072  }
12073 
12074 
12075  protected:
12076  EImpinjDirectionFieldOfView m_eFieldOfView;
12077 
12080  public:
12081  static const CFieldDescriptor
12082  s_fdFieldOfView;
12084 
12086  inline EImpinjDirectionFieldOfView
12088  {
12089  return m_eFieldOfView;
12090  }
12091 
12093  inline void
12095  EImpinjDirectionFieldOfView value)
12096  {
12097  m_eFieldOfView = value;
12098  }
12099 
12100 
12101  protected:
12102  CImpinjDirectionUserTagPopulationLimit * m_pImpinjDirectionUserTagPopulationLimit;
12103 
12104  public:
12108  {
12109  return m_pImpinjDirectionUserTagPopulationLimit;
12110  }
12111 
12113  EResultCode
12116 
12117 
12118  protected:
12119  std::list<CParameter *> m_listCustom;
12120 
12121  public:
12123  inline std::list<CParameter *>::iterator
12125  {
12126  return m_listCustom.begin();
12127  }
12128 
12130  inline std::list<CParameter *>::iterator
12131  endCustom (void)
12132  {
12133  return m_listCustom.end();
12134  }
12135 
12137  inline void
12139  {
12140  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12141  }
12142 
12144  inline int
12146  {
12147  return (int) (m_listCustom.size());
12148  }
12149 
12150  EResultCode
12152  addCustom (
12153  CParameter * pValue);
12154 
12155 
12156 };
12157 
12158 
12182 {
12183  public:
12186 
12189 
12190  static const CFieldDescriptor * const
12191  s_apFieldDescriptorTable[];
12192 
12193  static const CTypeDescriptor
12194  s_typeDescriptor;
12195 
12196  void
12197  decodeFields (
12198  CDecoderStream * pDecoderStream);
12199 
12200  void
12201  assimilateSubParameters (
12202  CErrorDetails * pError);
12203 
12204  void
12205  encode (
12206  CEncoderStream * pEncoderStream) const;
12207 
12208 
12209  llrp_bool_t
12210  isAllowedIn (
12211  const CTypeDescriptor * pEnclosingElementType) const;
12212 
12213 
12214  static CElement *
12215  s_construct (void);
12216 
12217  static void
12218  s_decodeFields (
12219  CDecoderStream * pDecoderStream,
12220  CElement * pElement);
12222 
12223 
12224  protected:
12225  llrp_u16_t m_UserTagPopulationLimit;
12226 
12229  public:
12230  static const CFieldDescriptor
12231  s_fdUserTagPopulationLimit;
12233 
12235  inline llrp_u16_t
12237  {
12238  return m_UserTagPopulationLimit;
12239  }
12240 
12242  inline void
12244  llrp_u16_t value)
12245  {
12246  m_UserTagPopulationLimit = value;
12247  }
12248 
12249 
12250 };
12251 
12252 
12290 class CImpinjC1G2DirectionConfig : public CParameter
12291 {
12292  public:
12295 
12298 
12299  static const CFieldDescriptor * const
12300  s_apFieldDescriptorTable[];
12301 
12302  static const CTypeDescriptor
12303  s_typeDescriptor;
12304 
12305  void
12306  decodeFields (
12307  CDecoderStream * pDecoderStream);
12308 
12309  void
12310  assimilateSubParameters (
12311  CErrorDetails * pError);
12312 
12313  void
12314  encode (
12315  CEncoderStream * pEncoderStream) const;
12316 
12317 
12318  llrp_bool_t
12319  isAllowedIn (
12320  const CTypeDescriptor * pEnclosingElementType) const;
12321 
12322 
12323  static CElement *
12324  s_construct (void);
12325 
12326  static void
12327  s_decodeFields (
12328  CDecoderStream * pDecoderStream,
12329  CElement * pElement);
12331 
12332 
12333  protected:
12334  EImpinjDirectionRFMode m_eRFMode;
12335 
12338  public:
12339  static const CFieldDescriptor
12340  s_fdRFMode;
12342 
12344  inline EImpinjDirectionRFMode
12345  getRFMode (void)
12346  {
12347  return m_eRFMode;
12348  }
12349 
12351  inline void
12353  EImpinjDirectionRFMode value)
12354  {
12355  m_eRFMode = value;
12356  }
12357 
12358 
12359  protected:
12360  CImpinjTransmitPower * m_pImpinjTransmitPower;
12361 
12362  public:
12364  inline CImpinjTransmitPower *
12366  {
12367  return m_pImpinjTransmitPower;
12368  }
12369 
12371  EResultCode
12373  CImpinjTransmitPower * pValue);
12374 
12375 
12376  protected:
12377  std::list<CC1G2Filter *> m_listC1G2Filter;
12378 
12379  public:
12381  inline std::list<CC1G2Filter *>::iterator
12383  {
12384  return m_listC1G2Filter.begin();
12385  }
12386 
12388  inline std::list<CC1G2Filter *>::iterator
12390  {
12391  return m_listC1G2Filter.end();
12392  }
12393 
12395  inline void
12397  {
12398  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
12399  }
12400 
12402  inline int
12404  {
12405  return (int) (m_listC1G2Filter.size());
12406  }
12407 
12408  EResultCode
12410  addC1G2Filter (
12411  CC1G2Filter * pValue);
12412 
12413 
12414  protected:
12415  std::list<CParameter *> m_listCustom;
12416 
12417  public:
12419  inline std::list<CParameter *>::iterator
12421  {
12422  return m_listCustom.begin();
12423  }
12424 
12426  inline std::list<CParameter *>::iterator
12427  endCustom (void)
12428  {
12429  return m_listCustom.end();
12430  }
12431 
12433  inline void
12435  {
12436  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12437  }
12438 
12440  inline int
12442  {
12443  return (int) (m_listCustom.size());
12444  }
12445 
12446  EResultCode
12448  addCustom (
12449  CParameter * pValue);
12450 
12451 
12452 };
12453 
12454 
12487 class CImpinjExtendedTagInformation : public CParameter
12488 {
12489  public:
12492 
12495 
12496  static const CFieldDescriptor * const
12497  s_apFieldDescriptorTable[];
12498 
12499  static const CTypeDescriptor
12500  s_typeDescriptor;
12501 
12502  void
12503  decodeFields (
12504  CDecoderStream * pDecoderStream);
12505 
12506  void
12507  assimilateSubParameters (
12508  CErrorDetails * pError);
12509 
12510  void
12511  encode (
12512  CEncoderStream * pEncoderStream) const;
12513 
12514 
12515  llrp_bool_t
12516  isAllowedIn (
12517  const CTypeDescriptor * pEnclosingElementType) const;
12518 
12519 
12520  static CElement *
12521  s_construct (void);
12522 
12523  static void
12524  s_decodeFields (
12525  CDecoderStream * pDecoderStream,
12526  CElement * pElement);
12528 
12529 
12530  protected:
12531  std::list<CEPCData *> m_listEPCData;
12532 
12533  public:
12535  inline std::list<CEPCData *>::iterator
12537  {
12538  return m_listEPCData.begin();
12539  }
12540 
12542  inline std::list<CEPCData *>::iterator
12543  endEPCData (void)
12544  {
12545  return m_listEPCData.end();
12546  }
12547 
12549  inline void
12551  {
12552  clearSubParameterList ((tListOfParameters *) &m_listEPCData);
12553  }
12554 
12556  inline int
12558  {
12559  return (int) (m_listEPCData.size());
12560  }
12561 
12562  EResultCode
12564  addEPCData (
12565  CEPCData * pValue);
12566 
12567 
12568  protected:
12569  CImpinjLocationReportData * m_pImpinjLocationReportData;
12570 
12571  public:
12573  inline CImpinjLocationReportData *
12575  {
12576  return m_pImpinjLocationReportData;
12577  }
12578 
12580  EResultCode
12582  CImpinjLocationReportData * pValue);
12583 
12584 
12585  protected:
12586  CImpinjDirectionReportData * m_pImpinjDirectionReportData;
12587 
12588  public:
12592  {
12593  return m_pImpinjDirectionReportData;
12594  }
12595 
12597  EResultCode
12599  CImpinjDirectionReportData * pValue);
12600 
12601 
12602  protected:
12603  std::list<CParameter *> m_listCustom;
12604 
12605  public:
12607  inline std::list<CParameter *>::iterator
12609  {
12610  return m_listCustom.begin();
12611  }
12612 
12614  inline std::list<CParameter *>::iterator
12615  endCustom (void)
12616  {
12617  return m_listCustom.end();
12618  }
12619 
12621  inline void
12623  {
12624  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12625  }
12626 
12628  inline int
12630  {
12631  return (int) (m_listCustom.size());
12632  }
12633 
12634  EResultCode
12636  addCustom (
12637  CParameter * pValue);
12638 
12639 
12640 };
12641 
12642 
12689 class CImpinjDirectionReporting : public CParameter
12690 {
12691  public:
12693  ~CImpinjDirectionReporting (void);
12694 
12697 
12698  static const CFieldDescriptor * const
12699  s_apFieldDescriptorTable[];
12700 
12701  static const CTypeDescriptor
12702  s_typeDescriptor;
12703 
12704  void
12705  decodeFields (
12706  CDecoderStream * pDecoderStream);
12707 
12708  void
12709  assimilateSubParameters (
12710  CErrorDetails * pError);
12711 
12712  void
12713  encode (
12714  CEncoderStream * pEncoderStream) const;
12715 
12716 
12717  llrp_bool_t
12718  isAllowedIn (
12719  const CTypeDescriptor * pEnclosingElementType) const;
12720 
12721 
12722  static CElement *
12723  s_construct (void);
12724 
12725  static void
12726  s_decodeFields (
12727  CDecoderStream * pDecoderStream,
12728  CElement * pElement);
12730 
12731 
12732  protected:
12733  llrp_u1_t m_EnableUpdateReport;
12734 
12737  public:
12738  static const CFieldDescriptor
12739  s_fdEnableUpdateReport;
12741 
12743  inline llrp_u1_t
12745  {
12746  return m_EnableUpdateReport;
12747  }
12748 
12750  inline void
12752  llrp_u1_t value)
12753  {
12754  m_EnableUpdateReport = value;
12755  }
12756 
12757 
12758  protected:
12759  llrp_u1_t m_EnableEntryReport;
12760 
12763  public:
12764  static const CFieldDescriptor
12765  s_fdEnableEntryReport;
12767 
12769  inline llrp_u1_t
12771  {
12772  return m_EnableEntryReport;
12773  }
12774 
12776  inline void
12778  llrp_u1_t value)
12779  {
12780  m_EnableEntryReport = value;
12781  }
12782 
12783 
12784  protected:
12785  llrp_u1_t m_EnableExitReport;
12786 
12789  public:
12790  static const CFieldDescriptor
12791  s_fdEnableExitReport;
12793 
12795  inline llrp_u1_t
12797  {
12798  return m_EnableExitReport;
12799  }
12800 
12802  inline void
12804  llrp_u1_t value)
12805  {
12806  m_EnableExitReport = value;
12807  }
12808 
12809 
12810  protected:
12811  llrp_u1_t m_EnableDiagnosticReport;
12812 
12815  public:
12816  static const CFieldDescriptor
12817  s_fdEnableDiagnosticReport;
12819 
12821  inline llrp_u1_t
12823  {
12824  return m_EnableDiagnosticReport;
12825  }
12826 
12828  inline void
12830  llrp_u1_t value)
12831  {
12832  m_EnableDiagnosticReport = value;
12833  }
12834 
12835 
12836  protected:
12837  EImpinjDirectionDiagnosticReportLevel m_eDiagnosticReportLevel;
12838 
12841  public:
12842  static const CFieldDescriptor
12843  s_fdDiagnosticReportLevel;
12845 
12847  inline EImpinjDirectionDiagnosticReportLevel
12849  {
12850  return m_eDiagnosticReportLevel;
12851  }
12852 
12854  inline void
12856  EImpinjDirectionDiagnosticReportLevel value)
12857  {
12858  m_eDiagnosticReportLevel = value;
12859  }
12860 
12861 
12862  protected:
12863  std::list<CParameter *> m_listCustom;
12864 
12865  public:
12867  inline std::list<CParameter *>::iterator
12869  {
12870  return m_listCustom.begin();
12871  }
12872 
12874  inline std::list<CParameter *>::iterator
12875  endCustom (void)
12876  {
12877  return m_listCustom.end();
12878  }
12879 
12881  inline void
12883  {
12884  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12885  }
12886 
12888  inline int
12890  {
12891  return (int) (m_listCustom.size());
12892  }
12893 
12894  EResultCode
12896  addCustom (
12897  CParameter * pValue);
12898 
12899 
12900 };
12901 
12902 
12950 class CImpinjDirectionReportData : public CParameter
12951 {
12952  public:
12955 
12958 
12959  static const CFieldDescriptor * const
12960  s_apFieldDescriptorTable[];
12961 
12962  static const CTypeDescriptor
12963  s_typeDescriptor;
12964 
12965  void
12966  decodeFields (
12967  CDecoderStream * pDecoderStream);
12968 
12969  void
12970  assimilateSubParameters (
12971  CErrorDetails * pError);
12972 
12973  void
12974  encode (
12975  CEncoderStream * pEncoderStream) const;
12976 
12977 
12978  llrp_bool_t
12979  isAllowedIn (
12980  const CTypeDescriptor * pEnclosingElementType) const;
12981 
12982 
12983  static CElement *
12984  s_construct (void);
12985 
12986  static void
12987  s_decodeFields (
12988  CDecoderStream * pDecoderStream,
12989  CElement * pElement);
12991 
12992 
12993  protected:
12994  EImpinjDirectionReportType m_eType;
12995 
12998  public:
12999  static const CFieldDescriptor
13000  s_fdType;
13002 
13004  inline EImpinjDirectionReportType
13005  getType (void)
13006  {
13007  return m_eType;
13008  }
13009 
13011  inline void
13013  EImpinjDirectionReportType value)
13014  {
13015  m_eType = value;
13016  }
13017 
13018 
13019  protected:
13020  EImpinjDirectionTagPopulationStatus m_eTagPopulationStatus;
13021 
13024  public:
13025  static const CFieldDescriptor
13026  s_fdTagPopulationStatus;
13028 
13030  inline EImpinjDirectionTagPopulationStatus
13032  {
13033  return m_eTagPopulationStatus;
13034  }
13035 
13037  inline void
13039  EImpinjDirectionTagPopulationStatus value)
13040  {
13041  m_eTagPopulationStatus = value;
13042  }
13043 
13044 
13045  protected:
13046  llrp_u8_t m_FirstSeenSectorID;
13047 
13050  public:
13051  static const CFieldDescriptor
13052  s_fdFirstSeenSectorID;
13054 
13056  inline llrp_u8_t
13058  {
13059  return m_FirstSeenSectorID;
13060  }
13061 
13063  inline void
13065  llrp_u8_t value)
13066  {
13067  m_FirstSeenSectorID = value;
13068  }
13069 
13070 
13071  protected:
13072  llrp_u64_t m_FirstSeenTimestampUTC;
13073 
13076  public:
13077  static const CFieldDescriptor
13078  s_fdFirstSeenTimestampUTC;
13080 
13082  inline llrp_u64_t
13084  {
13085  return m_FirstSeenTimestampUTC;
13086  }
13087 
13089  inline void
13091  llrp_u64_t value)
13092  {
13093  m_FirstSeenTimestampUTC = value;
13094  }
13095 
13096 
13097  protected:
13098  llrp_u8_t m_LastSeenSectorID;
13099 
13102  public:
13103  static const CFieldDescriptor
13104  s_fdLastSeenSectorID;
13106 
13108  inline llrp_u8_t
13110  {
13111  return m_LastSeenSectorID;
13112  }
13113 
13115  inline void
13117  llrp_u8_t value)
13118  {
13119  m_LastSeenSectorID = value;
13120  }
13121 
13122 
13123  protected:
13124  llrp_u64_t m_LastSeenTimestampUTC;
13125 
13128  public:
13129  static const CFieldDescriptor
13130  s_fdLastSeenTimestampUTC;
13132 
13134  inline llrp_u64_t
13136  {
13137  return m_LastSeenTimestampUTC;
13138  }
13139 
13141  inline void
13143  llrp_u64_t value)
13144  {
13145  m_LastSeenTimestampUTC = value;
13146  }
13147 
13148 
13149  protected:
13150  CImpinjDirectionDiagnosticData * m_pImpinjDirectionDiagnosticData;
13151 
13152  public:
13156  {
13157  return m_pImpinjDirectionDiagnosticData;
13158  }
13159 
13161  EResultCode
13164 
13165 
13166  protected:
13167  std::list<CParameter *> m_listCustom;
13168 
13169  public:
13171  inline std::list<CParameter *>::iterator
13173  {
13174  return m_listCustom.begin();
13175  }
13176 
13178  inline std::list<CParameter *>::iterator
13179  endCustom (void)
13180  {
13181  return m_listCustom.end();
13182  }
13183 
13185  inline void
13187  {
13188  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13189  }
13190 
13192  inline int
13194  {
13195  return (int) (m_listCustom.size());
13196  }
13197 
13198  EResultCode
13200  addCustom (
13201  CParameter * pValue);
13202 
13203 
13204 };
13205 
13206 
13229 class CImpinjDirectionDiagnosticData : public CParameter
13230 {
13231  public:
13234 
13237 
13238  static const CFieldDescriptor * const
13239  s_apFieldDescriptorTable[];
13240 
13241  static const CTypeDescriptor
13242  s_typeDescriptor;
13243 
13244  void
13245  decodeFields (
13246  CDecoderStream * pDecoderStream);
13247 
13248  void
13249  assimilateSubParameters (
13250  CErrorDetails * pError);
13251 
13252  void
13253  encode (
13254  CEncoderStream * pEncoderStream) const;
13255 
13256 
13257  llrp_bool_t
13258  isAllowedIn (
13259  const CTypeDescriptor * pEnclosingElementType) const;
13260 
13261 
13262  static CElement *
13263  s_construct (void);
13264 
13265  static void
13266  s_decodeFields (
13267  CDecoderStream * pDecoderStream,
13268  CElement * pElement);
13270 
13271 
13272  protected:
13273  llrp_u32v_t m_Metric;
13274 
13277  public:
13278  static const CFieldDescriptor
13279  s_fdMetric;
13281 
13283  inline llrp_u32v_t
13284  getMetric (void)
13285  {
13286  return m_Metric;
13287  }
13288 
13290  inline void
13292  llrp_u32v_t value)
13293  {
13294  m_Metric = value;
13295  }
13296 
13297 
13298 };
13299 
13300 
13325 class CImpinjxArrayDirectionCapabilities : public CParameter
13326 {
13327  public:
13330 
13333 
13334  static const CFieldDescriptor * const
13335  s_apFieldDescriptorTable[];
13336 
13337  static const CTypeDescriptor
13338  s_typeDescriptor;
13339 
13340  void
13341  decodeFields (
13342  CDecoderStream * pDecoderStream);
13343 
13344  void
13345  assimilateSubParameters (
13346  CErrorDetails * pError);
13347 
13348  void
13349  encode (
13350  CEncoderStream * pEncoderStream) const;
13351 
13352 
13353  llrp_bool_t
13354  isAllowedIn (
13355  const CTypeDescriptor * pEnclosingElementType) const;
13356 
13357 
13358  static CElement *
13359  s_construct (void);
13360 
13361  static void
13362  s_decodeFields (
13363  CDecoderStream * pDecoderStream,
13364  CElement * pElement);
13366 
13367 
13368  protected:
13369  llrp_u16_t m_SystemTagPopulationLimitHighSensitivity;
13370 
13373  public:
13374  static const CFieldDescriptor
13375  s_fdSystemTagPopulationLimitHighSensitivity;
13377 
13379  inline llrp_u16_t
13381  {
13382  return m_SystemTagPopulationLimitHighSensitivity;
13383  }
13384 
13386  inline void
13388  llrp_u16_t value)
13389  {
13390  m_SystemTagPopulationLimitHighSensitivity = value;
13391  }
13392 
13393 
13394  protected:
13395  llrp_u16_t m_SystemTagPopulationLimitHighPerformance;
13396 
13399  public:
13400  static const CFieldDescriptor
13401  s_fdSystemTagPopulationLimitHighPerformance;
13403 
13405  inline llrp_u16_t
13407  {
13408  return m_SystemTagPopulationLimitHighPerformance;
13409  }
13410 
13412  inline void
13414  llrp_u16_t value)
13415  {
13416  m_SystemTagPopulationLimitHighPerformance = value;
13417  }
13418 
13419 
13420  protected:
13421  std::list<CParameter *> m_listCustom;
13422 
13423  public:
13425  inline std::list<CParameter *>::iterator
13427  {
13428  return m_listCustom.begin();
13429  }
13430 
13432  inline std::list<CParameter *>::iterator
13433  endCustom (void)
13434  {
13435  return m_listCustom.end();
13436  }
13437 
13439  inline void
13441  {
13442  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13443  }
13444 
13446  inline int
13448  {
13449  return (int) (m_listCustom.size());
13450  }
13451 
13452  EResultCode
13454  addCustom (
13455  CParameter * pValue);
13456 
13457 
13458 };
13459 
13460 
13486 class CImpinjIntelligentAntennaManagement : public CParameter
13487 {
13488  public:
13491 
13494 
13495  static const CFieldDescriptor * const
13496  s_apFieldDescriptorTable[];
13497 
13498  static const CTypeDescriptor
13499  s_typeDescriptor;
13500 
13501  void
13502  decodeFields (
13503  CDecoderStream * pDecoderStream);
13504 
13505  void
13506  assimilateSubParameters (
13507  CErrorDetails * pError);
13508 
13509  void
13510  encode (
13511  CEncoderStream * pEncoderStream) const;
13512 
13513 
13514  llrp_bool_t
13515  isAllowedIn (
13516  const CTypeDescriptor * pEnclosingElementType) const;
13517 
13518 
13519  static CElement *
13520  s_construct (void);
13521 
13522  static void
13523  s_decodeFields (
13524  CDecoderStream * pDecoderStream,
13525  CElement * pElement);
13527 
13528 
13529  protected:
13530  EImpinjIntelligentAntennaMode m_eManagementEnabled;
13531 
13534  public:
13535  static const CFieldDescriptor
13536  s_fdManagementEnabled;
13538 
13540  inline EImpinjIntelligentAntennaMode
13542  {
13543  return m_eManagementEnabled;
13544  }
13545 
13547  inline void
13549  EImpinjIntelligentAntennaMode value)
13550  {
13551  m_eManagementEnabled = value;
13552  }
13553 
13554 
13555  protected:
13556  std::list<CParameter *> m_listCustom;
13557 
13558  public:
13560  inline std::list<CParameter *>::iterator
13562  {
13563  return m_listCustom.begin();
13564  }
13565 
13567  inline std::list<CParameter *>::iterator
13568  endCustom (void)
13569  {
13570  return m_listCustom.end();
13571  }
13572 
13574  inline void
13576  {
13577  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13578  }
13579 
13581  inline int
13583  {
13584  return (int) (m_listCustom.size());
13585  }
13586 
13587  EResultCode
13589  addCustom (
13590  CParameter * pValue);
13591 
13592 
13593 };
13594 
13595 
13622 class CImpinjTransmitPower : public CParameter
13623 {
13624  public:
13625  CImpinjTransmitPower (void);
13626  ~CImpinjTransmitPower (void);
13627 
13630 
13631  static const CFieldDescriptor * const
13632  s_apFieldDescriptorTable[];
13633 
13634  static const CTypeDescriptor
13635  s_typeDescriptor;
13636 
13637  void
13638  decodeFields (
13639  CDecoderStream * pDecoderStream);
13640 
13641  void
13642  assimilateSubParameters (
13643  CErrorDetails * pError);
13644 
13645  void
13646  encode (
13647  CEncoderStream * pEncoderStream) const;
13648 
13649 
13650  llrp_bool_t
13651  isAllowedIn (
13652  const CTypeDescriptor * pEnclosingElementType) const;
13653 
13654 
13655  static CElement *
13656  s_construct (void);
13657 
13658  static void
13659  s_decodeFields (
13660  CDecoderStream * pDecoderStream,
13661  CElement * pElement);
13663 
13664 
13665  protected:
13666  llrp_u16_t m_TransmitPower;
13667 
13670  public:
13671  static const CFieldDescriptor
13672  s_fdTransmitPower;
13674 
13676  inline llrp_u16_t
13678  {
13679  return m_TransmitPower;
13680  }
13681 
13683  inline void
13685  llrp_u16_t value)
13686  {
13687  m_TransmitPower = value;
13688  }
13689 
13690 
13691  protected:
13692  std::list<CParameter *> m_listCustom;
13693 
13694  public:
13696  inline std::list<CParameter *>::iterator
13698  {
13699  return m_listCustom.begin();
13700  }
13701 
13703  inline std::list<CParameter *>::iterator
13704  endCustom (void)
13705  {
13706  return m_listCustom.end();
13707  }
13708 
13710  inline void
13712  {
13713  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13714  }
13715 
13717  inline int
13719  {
13720  return (int) (m_listCustom.size());
13721  }
13722 
13723  EResultCode
13725  addCustom (
13726  CParameter * pValue);
13727 
13728 
13729 };
13730 
13731 
13758 class CImpinjPolarizationControl : public CParameter
13759 {
13760  public:
13763 
13766 
13767  static const CFieldDescriptor * const
13768  s_apFieldDescriptorTable[];
13769 
13770  static const CTypeDescriptor
13771  s_typeDescriptor;
13772 
13773  void
13774  decodeFields (
13775  CDecoderStream * pDecoderStream);
13776 
13777  void
13778  assimilateSubParameters (
13779  CErrorDetails * pError);
13780 
13781  void
13782  encode (
13783  CEncoderStream * pEncoderStream) const;
13784 
13785 
13786  llrp_bool_t
13787  isAllowedIn (
13788  const CTypeDescriptor * pEnclosingElementType) const;
13789 
13790 
13791  static CElement *
13792  s_construct (void);
13793 
13794  static void
13795  s_decodeFields (
13796  CDecoderStream * pDecoderStream,
13797  CElement * pElement);
13799 
13800 
13801  protected:
13802  llrp_u1_t m_PolarizationControlEnabled;
13803 
13806  public:
13807  static const CFieldDescriptor
13808  s_fdPolarizationControlEnabled;
13810 
13812  inline llrp_u1_t
13814  {
13815  return m_PolarizationControlEnabled;
13816  }
13817 
13819  inline void
13821  llrp_u1_t value)
13822  {
13823  m_PolarizationControlEnabled = value;
13824  }
13825 
13826 
13827  protected:
13828  std::list<CParameter *> m_listCustom;
13829 
13830  public:
13832  inline std::list<CParameter *>::iterator
13834  {
13835  return m_listCustom.begin();
13836  }
13837 
13839  inline std::list<CParameter *>::iterator
13840  endCustom (void)
13841  {
13842  return m_listCustom.end();
13843  }
13844 
13846  inline void
13848  {
13849  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13850  }
13851 
13853  inline int
13855  {
13856  return (int) (m_listCustom.size());
13857  }
13858 
13859  EResultCode
13861  addCustom (
13862  CParameter * pValue);
13863 
13864 
13865 };
13866 
13867 
13892 class CImpinjAntennaCapabilities : public CParameter
13893 {
13894  public:
13897 
13900 
13901  static const CFieldDescriptor * const
13902  s_apFieldDescriptorTable[];
13903 
13904  static const CTypeDescriptor
13905  s_typeDescriptor;
13906 
13907  void
13908  decodeFields (
13909  CDecoderStream * pDecoderStream);
13910 
13911  void
13912  assimilateSubParameters (
13913  CErrorDetails * pError);
13914 
13915  void
13916  encode (
13917  CEncoderStream * pEncoderStream) const;
13918 
13919 
13920  llrp_bool_t
13921  isAllowedIn (
13922  const CTypeDescriptor * pEnclosingElementType) const;
13923 
13924 
13925  static CElement *
13926  s_construct (void);
13927 
13928  static void
13929  s_decodeFields (
13930  CDecoderStream * pDecoderStream,
13931  CElement * pElement);
13933 
13934 
13935  protected:
13936  std::list<CImpinjAntennaPolarizationCapability *> m_listImpinjAntennaPolarizationCapability;
13937 
13938  public:
13940  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
13942  {
13943  return m_listImpinjAntennaPolarizationCapability.begin();
13944  }
13945 
13947  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
13949  {
13950  return m_listImpinjAntennaPolarizationCapability.end();
13951  }
13952 
13954  inline void
13956  {
13957  clearSubParameterList ((tListOfParameters *) &m_listImpinjAntennaPolarizationCapability);
13958  }
13959 
13961  inline int
13963  {
13964  return (int) (m_listImpinjAntennaPolarizationCapability.size());
13965  }
13966 
13967  EResultCode
13971 
13972 
13973  protected:
13974  std::list<CParameter *> m_listCustom;
13975 
13976  public:
13978  inline std::list<CParameter *>::iterator
13980  {
13981  return m_listCustom.begin();
13982  }
13983 
13985  inline std::list<CParameter *>::iterator
13986  endCustom (void)
13987  {
13988  return m_listCustom.end();
13989  }
13990 
13992  inline void
13994  {
13995  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13996  }
13997 
13999  inline int
14001  {
14002  return (int) (m_listCustom.size());
14003  }
14004 
14005  EResultCode
14007  addCustom (
14008  CParameter * pValue);
14009 
14010 
14011 };
14012 
14013 
14038 class CImpinjAntennaPolarizationCapability : public CParameter
14039 {
14040  public:
14043 
14046 
14047  static const CFieldDescriptor * const
14048  s_apFieldDescriptorTable[];
14049 
14050  static const CTypeDescriptor
14051  s_typeDescriptor;
14052 
14053  void
14054  decodeFields (
14055  CDecoderStream * pDecoderStream);
14056 
14057  void
14058  assimilateSubParameters (
14059  CErrorDetails * pError);
14060 
14061  void
14062  encode (
14063  CEncoderStream * pEncoderStream) const;
14064 
14065 
14066  llrp_bool_t
14067  isAllowedIn (
14068  const CTypeDescriptor * pEnclosingElementType) const;
14069 
14070 
14071  static CElement *
14072  s_construct (void);
14073 
14074  static void
14075  s_decodeFields (
14076  CDecoderStream * pDecoderStream,
14077  CElement * pElement);
14079 
14080 
14081  protected:
14082  EImpinjAntennaPolarizationType m_eType;
14083 
14086  public:
14087  static const CFieldDescriptor
14088  s_fdType;
14090 
14092  inline EImpinjAntennaPolarizationType
14093  getType (void)
14094  {
14095  return m_eType;
14096  }
14097 
14099  inline void
14101  EImpinjAntennaPolarizationType value)
14102  {
14103  m_eType = value;
14104  }
14105 
14106 
14107  protected:
14108  llrp_u16_t m_AntennaIDOffset;
14109 
14112  public:
14113  static const CFieldDescriptor
14114  s_fdAntennaIDOffset;
14116 
14118  inline llrp_u16_t
14120  {
14121  return m_AntennaIDOffset;
14122  }
14123 
14125  inline void
14127  llrp_u16_t value)
14128  {
14129  m_AntennaIDOffset = value;
14130  }
14131 
14132 
14133  protected:
14134  std::list<CParameter *> m_listCustom;
14135 
14136  public:
14138  inline std::list<CParameter *>::iterator
14140  {
14141  return m_listCustom.begin();
14142  }
14143 
14145  inline std::list<CParameter *>::iterator
14146  endCustom (void)
14147  {
14148  return m_listCustom.end();
14149  }
14150 
14152  inline void
14154  {
14155  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14156  }
14157 
14159  inline int
14161  {
14162  return (int) (m_listCustom.size());
14163  }
14164 
14165  EResultCode
14167  addCustom (
14168  CParameter * pValue);
14169 
14170 
14171 };
14172 
14173 
14197 class CImpinjDisabledAntennas : public CParameter
14198 {
14199  public:
14200  CImpinjDisabledAntennas (void);
14201  ~CImpinjDisabledAntennas (void);
14202 
14205 
14206  static const CFieldDescriptor * const
14207  s_apFieldDescriptorTable[];
14208 
14209  static const CTypeDescriptor
14210  s_typeDescriptor;
14211 
14212  void
14213  decodeFields (
14214  CDecoderStream * pDecoderStream);
14215 
14216  void
14217  assimilateSubParameters (
14218  CErrorDetails * pError);
14219 
14220  void
14221  encode (
14222  CEncoderStream * pEncoderStream) const;
14223 
14224 
14225  llrp_bool_t
14226  isAllowedIn (
14227  const CTypeDescriptor * pEnclosingElementType) const;
14228 
14229 
14230  static CElement *
14231  s_construct (void);
14232 
14233  static void
14234  s_decodeFields (
14235  CDecoderStream * pDecoderStream,
14236  CElement * pElement);
14238 
14239 
14240  protected:
14241  llrp_u16v_t m_AntennaIDs;
14242 
14245  public:
14246  static const CFieldDescriptor
14247  s_fdAntennaIDs;
14249 
14251  inline llrp_u16v_t
14253  {
14254  return m_AntennaIDs;
14255  }
14256 
14258  inline void
14260  llrp_u16v_t value)
14261  {
14262  m_AntennaIDs = value;
14263  }
14264 
14265 
14266  protected:
14267  std::list<CParameter *> m_listCustom;
14268 
14269  public:
14271  inline std::list<CParameter *>::iterator
14273  {
14274  return m_listCustom.begin();
14275  }
14276 
14278  inline std::list<CParameter *>::iterator
14279  endCustom (void)
14280  {
14281  return m_listCustom.end();
14282  }
14283 
14285  inline void
14287  {
14288  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14289  }
14290 
14292  inline int
14294  {
14295  return (int) (m_listCustom.size());
14296  }
14297 
14298  EResultCode
14300  addCustom (
14301  CParameter * pValue);
14302 
14303 
14304 };
14305 
14306 
14331 class CImpinjTIDParity : public CParameter
14332 {
14333  public:
14334  CImpinjTIDParity (void);
14335  ~CImpinjTIDParity (void);
14336 
14339 
14340  static const CFieldDescriptor * const
14341  s_apFieldDescriptorTable[];
14342 
14343  static const CTypeDescriptor
14344  s_typeDescriptor;
14345 
14346  void
14347  decodeFields (
14348  CDecoderStream * pDecoderStream);
14349 
14350  void
14351  assimilateSubParameters (
14352  CErrorDetails * pError);
14353 
14354  void
14355  encode (
14356  CEncoderStream * pEncoderStream) const;
14357 
14358 
14359  llrp_bool_t
14360  isAllowedIn (
14361  const CTypeDescriptor * pEnclosingElementType) const;
14362 
14363 
14364  static CElement *
14365  s_construct (void);
14366 
14367  static void
14368  s_decodeFields (
14369  CDecoderStream * pDecoderStream,
14370  CElement * pElement);
14372 
14373 
14374  protected:
14375  llrp_u1_t m_ParityError;
14376 
14379  public:
14380  static const CFieldDescriptor
14381  s_fdParityError;
14383 
14385  inline llrp_u1_t
14387  {
14388  return m_ParityError;
14389  }
14390 
14392  inline void
14394  llrp_u1_t value)
14395  {
14396  m_ParityError = value;
14397  }
14398 
14399 
14400  protected:
14401  std::list<CParameter *> m_listCustom;
14402 
14403  public:
14405  inline std::list<CParameter *>::iterator
14407  {
14408  return m_listCustom.begin();
14409  }
14410 
14412  inline std::list<CParameter *>::iterator
14413  endCustom (void)
14414  {
14415  return m_listCustom.end();
14416  }
14417 
14419  inline void
14421  {
14422  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14423  }
14424 
14426  inline int
14428  {
14429  return (int) (m_listCustom.size());
14430  }
14431 
14432  EResultCode
14434  addCustom (
14435  CParameter * pValue);
14436 
14437 
14438 };
14439 
14440 
14471 class CImpinjMarginRead : public CParameter
14472 {
14473  public:
14474  CImpinjMarginRead (void);
14475  ~CImpinjMarginRead (void);
14476 
14479 
14480  static const CFieldDescriptor * const
14481  s_apFieldDescriptorTable[];
14482 
14483  static const CTypeDescriptor
14484  s_typeDescriptor;
14485 
14486  void
14487  decodeFields (
14488  CDecoderStream * pDecoderStream);
14489 
14490  void
14491  assimilateSubParameters (
14492  CErrorDetails * pError);
14493 
14494  void
14495  encode (
14496  CEncoderStream * pEncoderStream) const;
14497 
14498 
14499  llrp_bool_t
14500  isAllowedIn (
14501  const CTypeDescriptor * pEnclosingElementType) const;
14502 
14503 
14504  static CElement *
14505  s_construct (void);
14506 
14507  static void
14508  s_decodeFields (
14509  CDecoderStream * pDecoderStream,
14510  CElement * pElement);
14512 
14513 
14514  protected:
14515  llrp_u16_t m_OpSpecID;
14516 
14519  public:
14520  static const CFieldDescriptor
14521  s_fdOpSpecID;
14523 
14525  inline llrp_u16_t
14527  {
14528  return m_OpSpecID;
14529  }
14530 
14532  inline void
14534  llrp_u16_t value)
14535  {
14536  m_OpSpecID = value;
14537  }
14538 
14539 
14540  protected:
14541  llrp_u32_t m_AccessPassword;
14542 
14545  public:
14546  static const CFieldDescriptor
14547  s_fdAccessPassword;
14549 
14551  inline llrp_u32_t
14553  {
14554  return m_AccessPassword;
14555  }
14556 
14558  inline void
14560  llrp_u32_t value)
14561  {
14562  m_AccessPassword = value;
14563  }
14564 
14565 
14566  protected:
14567  llrp_u2_t m_MB;
14568 
14571  public:
14572  static const CFieldDescriptor
14573  s_fdMB;
14575 
14577  inline llrp_u2_t
14578  getMB (void)
14579  {
14580  return m_MB;
14581  }
14582 
14584  inline void
14586  llrp_u2_t value)
14587  {
14588  m_MB = value;
14589  }
14590 
14591 
14592  protected:
14593  llrp_u16_t m_BitPointer;
14594 
14597  public:
14598  static const CFieldDescriptor
14599  s_fdBitPointer;
14601 
14603  inline llrp_u16_t
14605  {
14606  return m_BitPointer;
14607  }
14608 
14610  inline void
14612  llrp_u16_t value)
14613  {
14614  m_BitPointer = value;
14615  }
14616 
14617 
14618  protected:
14619  llrp_u8_t m_BitLength;
14620 
14623  public:
14624  static const CFieldDescriptor
14625  s_fdBitLength;
14627 
14629  inline llrp_u8_t
14631  {
14632  return m_BitLength;
14633  }
14634 
14636  inline void
14638  llrp_u8_t value)
14639  {
14640  m_BitLength = value;
14641  }
14642 
14643 
14644  protected:
14645  llrp_u16v_t m_Mask;
14646 
14649  public:
14650  static const CFieldDescriptor
14651  s_fdMask;
14653 
14655  inline llrp_u16v_t
14656  getMask (void)
14657  {
14658  return m_Mask;
14659  }
14660 
14662  inline void
14664  llrp_u16v_t value)
14665  {
14666  m_Mask = value;
14667  }
14668 
14669 
14670  protected:
14671  std::list<CParameter *> m_listCustom;
14672 
14673  public:
14675  inline std::list<CParameter *>::iterator
14677  {
14678  return m_listCustom.begin();
14679  }
14680 
14682  inline std::list<CParameter *>::iterator
14683  endCustom (void)
14684  {
14685  return m_listCustom.end();
14686  }
14687 
14689  inline void
14691  {
14692  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14693  }
14694 
14696  inline int
14698  {
14699  return (int) (m_listCustom.size());
14700  }
14701 
14702  EResultCode
14704  addCustom (
14705  CParameter * pValue);
14706 
14707 
14708 };
14709 
14710 
14736 class CImpinjMarginReadOpSpecResult : public CParameter
14737 {
14738  public:
14741 
14744 
14745  static const CFieldDescriptor * const
14746  s_apFieldDescriptorTable[];
14747 
14748  static const CTypeDescriptor
14749  s_typeDescriptor;
14750 
14751  void
14752  decodeFields (
14753  CDecoderStream * pDecoderStream);
14754 
14755  void
14756  assimilateSubParameters (
14757  CErrorDetails * pError);
14758 
14759  void
14760  encode (
14761  CEncoderStream * pEncoderStream) const;
14762 
14763 
14764  llrp_bool_t
14765  isAllowedIn (
14766  const CTypeDescriptor * pEnclosingElementType) const;
14767 
14768 
14769  static CElement *
14770  s_construct (void);
14771 
14772  static void
14773  s_decodeFields (
14774  CDecoderStream * pDecoderStream,
14775  CElement * pElement);
14777 
14778 
14779  protected:
14780  EImpinjMarginReadResultType m_eResult;
14781 
14784  public:
14785  static const CFieldDescriptor
14786  s_fdResult;
14788 
14790  inline EImpinjMarginReadResultType
14791  getResult (void)
14792  {
14793  return m_eResult;
14794  }
14795 
14797  inline void
14799  EImpinjMarginReadResultType value)
14800  {
14801  m_eResult = value;
14802  }
14803 
14804 
14805  protected:
14806  llrp_u16_t m_OpSpecID;
14807 
14810  public:
14811  static const CFieldDescriptor
14812  s_fdOpSpecID;
14814 
14816  inline llrp_u16_t
14818  {
14819  return m_OpSpecID;
14820  }
14821 
14823  inline void
14825  llrp_u16_t value)
14826  {
14827  m_OpSpecID = value;
14828  }
14829 
14830 
14831  protected:
14832  std::list<CParameter *> m_listCustom;
14833 
14834  public:
14836  inline std::list<CParameter *>::iterator
14838  {
14839  return m_listCustom.begin();
14840  }
14841 
14843  inline std::list<CParameter *>::iterator
14844  endCustom (void)
14845  {
14846  return m_listCustom.end();
14847  }
14848 
14850  inline void
14852  {
14853  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14854  }
14855 
14857  inline int
14859  {
14860  return (int) (m_listCustom.size());
14861  }
14862 
14863  EResultCode
14865  addCustom (
14866  CParameter * pValue);
14867 
14868 
14869 };
14870 
14871 
14896 class CImpinjBLEVersion : public CParameter
14897 {
14898  public:
14899  CImpinjBLEVersion (void);
14900  ~CImpinjBLEVersion (void);
14901 
14904 
14905  static const CFieldDescriptor * const
14906  s_apFieldDescriptorTable[];
14907 
14908  static const CTypeDescriptor
14909  s_typeDescriptor;
14910 
14911  void
14912  decodeFields (
14913  CDecoderStream * pDecoderStream);
14914 
14915  void
14916  assimilateSubParameters (
14917  CErrorDetails * pError);
14918 
14919  void
14920  encode (
14921  CEncoderStream * pEncoderStream) const;
14922 
14923 
14924  llrp_bool_t
14925  isAllowedIn (
14926  const CTypeDescriptor * pEnclosingElementType) const;
14927 
14928 
14929  static CElement *
14930  s_construct (void);
14931 
14932  static void
14933  s_decodeFields (
14934  CDecoderStream * pDecoderStream,
14935  CElement * pElement);
14937 
14938 
14939  protected:
14940  llrp_utf8v_t m_FirmwareVersion;
14941 
14944  public:
14945  static const CFieldDescriptor
14946  s_fdFirmwareVersion;
14948 
14950  inline llrp_utf8v_t
14952  {
14953  return m_FirmwareVersion;
14954  }
14955 
14957  inline void
14959  llrp_utf8v_t value)
14960  {
14961  m_FirmwareVersion = value;
14962  }
14963 
14964 
14965  protected:
14966  std::list<CParameter *> m_listCustom;
14967 
14968  public:
14970  inline std::list<CParameter *>::iterator
14972  {
14973  return m_listCustom.begin();
14974  }
14975 
14977  inline std::list<CParameter *>::iterator
14978  endCustom (void)
14979  {
14980  return m_listCustom.end();
14981  }
14982 
14984  inline void
14986  {
14987  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14988  }
14989 
14991  inline int
14993  {
14994  return (int) (m_listCustom.size());
14995  }
14996 
14997  EResultCode
14999  addCustom (
15000  CParameter * pValue);
15001 
15002 
15003 };
15004 
15005 
15020 extern void
15022  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 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.
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.
void setConnected(EImpinjHubConnectedType value)
Set accessor functions for the LLRP Connected field.
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.
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.
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.
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 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.
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.
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.
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 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.
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.
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 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 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.
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.
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.
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.
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.
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.
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.
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.
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 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.
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.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
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 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.
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.
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.
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.
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.
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.
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 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.
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.
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.
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.