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;
112 
113 /*
114  * Vendor descriptor declarations.
115  */
116 
117 extern const CVendorDescriptor
118 g_vdescImpinj;
119 
120 
121 /*
122  * Namespace descriptor declarations.
123  */
124 
125 extern const CNamespaceDescriptor
126 g_nsdescImpinj;
127 
128 
129 /*
130  * Enumeration definitions and declarations of
131  * enumeration string tables.
132  */
133 
134 
166 enum EImpinjRequestedDataType
167 {
169 };
170 
171 extern const SEnumTableEntry
172 g_estImpinjRequestedDataType[];
173 
174 
208 enum EImpinjRegulatoryRegion
209 {
211 };
212 
213 extern const SEnumTableEntry
214 g_estImpinjRegulatoryRegion[];
215 
216 
231 enum EImpinjInventorySearchType
232 {
234 };
235 
236 extern const SEnumTableEntry
237 g_estImpinjInventorySearchType[];
238 
239 
250 enum EImpinjFixedFrequencyMode
251 {
253 };
254 
255 extern const SEnumTableEntry
256 g_estImpinjFixedFrequencyMode[];
257 
258 
268 enum EImpinjReducedPowerMode
269 {
271 };
272 
273 extern const SEnumTableEntry
274 g_estImpinjReducedPowerMode[];
275 
276 
286 enum EImpinjLowDutyCycleMode
287 {
289 };
290 
291 extern const SEnumTableEntry
292 g_estImpinjLowDutyCycleMode[];
293 
294 
304 enum EImpinjLinkMonitorMode
305 {
307 };
308 
309 extern const SEnumTableEntry
310 g_estImpinjLinkMonitorMode[];
311 
312 
322 enum EImpinjReportBufferMode
323 {
325 };
326 
327 extern const SEnumTableEntry
328 g_estImpinjReportBufferMode[];
329 
330 
345 enum EImpinjBlockPermalockResultType
346 {
348 };
349 
350 extern const SEnumTableEntry
351 g_estImpinjBlockPermalockResultType[];
352 
353 
367 enum EImpinjGetBlockPermalockStatusResultType
368 {
370 };
371 
372 extern const SEnumTableEntry
373 g_estImpinjGetBlockPermalockStatusResultType[];
374 
375 
386 enum EImpinjQTDataProfile
387 {
389 };
390 
391 extern const SEnumTableEntry
392 g_estImpinjQTDataProfile[];
393 
394 
405 enum EImpinjQTAccessRange
406 {
408 };
409 
410 extern const SEnumTableEntry
411 g_estImpinjQTAccessRange[];
412 
413 
424 enum EImpinjQTPersistence
425 {
427 };
428 
429 extern const SEnumTableEntry
430 g_estImpinjQTPersistence[];
431 
432 
446 enum EImpinjSetQTConfigResultType
447 {
449 };
450 
451 extern const SEnumTableEntry
452 g_estImpinjSetQTConfigResultType[];
453 
454 
467 enum EImpinjGetQTConfigResultType
468 {
470 };
471 
472 extern const SEnumTableEntry
473 g_estImpinjGetQTConfigResultType[];
474 
475 
485 enum EImpinjSerializedTIDMode
486 {
488 };
489 
490 extern const SEnumTableEntry
491 g_estImpinjSerializedTIDMode[];
492 
493 
503 enum EImpinjRFPhaseAngleMode
504 {
506 };
507 
508 extern const SEnumTableEntry
509 g_estImpinjRFPhaseAngleMode[];
510 
511 
521 enum EImpinjPeakRSSIMode
522 {
524 };
525 
526 extern const SEnumTableEntry
527 g_estImpinjPeakRSSIMode[];
528 
529 
539 enum EImpinjGPSCoordinatesMode
540 {
542 };
543 
544 extern const SEnumTableEntry
545 g_estImpinjGPSCoordinatesMode[];
546 
547 
562 enum EImpinjAdvancedGPOMode
563 {
565 };
566 
567 extern const SEnumTableEntry
568 g_estImpinjAdvancedGPOMode[];
569 
570 
580 enum EImpinjOptimizedReadMode
581 {
583 };
584 
585 extern const SEnumTableEntry
586 g_estImpinjOptimizedReadMode[];
587 
588 
598 enum EImpinjAccessSpecOrderingMode
599 {
601 };
602 
603 extern const SEnumTableEntry
604 g_estImpinjAccessSpecOrderingMode[];
605 
606 
616 enum EImpinjRFDopplerFrequencyMode
617 {
619 };
620 
621 extern const SEnumTableEntry
622 g_estImpinjRFDopplerFrequencyMode[];
623 
624 
635 enum EImpinjHubConnectedType
636 {
638 };
639 
640 extern const SEnumTableEntry
641 g_estImpinjHubConnectedType[];
642 
643 
660 enum EImpinjHubFaultType
661 {
663 };
664 
665 extern const SEnumTableEntry
666 g_estImpinjHubFaultType[];
667 
668 
679 enum EImpinjLocationReportType
680 {
682 };
683 
684 extern const SEnumTableEntry
685 g_estImpinjLocationReportType[];
686 
687 
731 enum EImpinjDirectionFieldOfView
732 {
734 };
735 
736 extern const SEnumTableEntry
737 g_estImpinjDirectionFieldOfView[];
738 
739 
774 enum EImpinjDirectionRFMode
775 {
777 };
778 
779 extern const SEnumTableEntry
780 g_estImpinjDirectionRFMode[];
781 
782 
832 enum EImpinjDirectionDiagnosticReportLevel
833 {
835 };
836 
837 extern const SEnumTableEntry
838 g_estImpinjDirectionDiagnosticReportLevel[];
839 
840 
879 enum EImpinjDirectionReportType
880 {
882 };
883 
884 extern const SEnumTableEntry
885 g_estImpinjDirectionReportType[];
886 
887 
926 enum EImpinjDirectionTagPopulationStatus
927 {
929 };
930 
931 extern const SEnumTableEntry
932 g_estImpinjDirectionTagPopulationStatus[];
933 
934 
944 enum EImpinjIntelligentAntennaMode
945 {
947 };
948 
949 extern const SEnumTableEntry
950 g_estImpinjIntelligentAntennaMode[];
951 
952 
964 enum EImpinjAntennaPolarizationType
965 {
967 };
968 
969 extern const SEnumTableEntry
970 g_estImpinjAntennaPolarizationType[];
971 
972 
989 enum EImpinjMarginReadResultType
990 {
992 };
993 
994 extern const SEnumTableEntry
995 g_estImpinjMarginReadResultType[];
996 
997 
1003 
1027 class CIMPINJ_ENABLE_EXTENSIONS : public CMessage
1028 {
1029  public:
1031  ~CIMPINJ_ENABLE_EXTENSIONS (void);
1032 
1035 
1036  static const CFieldDescriptor * const
1037  s_apFieldDescriptorTable[];
1038 
1039  static const CTypeDescriptor
1040  s_typeDescriptor;
1041 
1042  void
1043  decodeFields (
1044  CDecoderStream * pDecoderStream);
1045 
1046  void
1047  assimilateSubParameters (
1048  CErrorDetails * pError);
1049 
1050  void
1051  encode (
1052  CEncoderStream * pEncoderStream) const;
1053 
1054 
1055 
1056  static CElement *
1057  s_construct (void);
1058 
1059  static void
1060  s_decodeFields (
1061  CDecoderStream * pDecoderStream,
1062  CElement * pElement);
1064 
1065 
1066  protected:
1067  std::list<CParameter *> m_listCustom;
1068 
1069  public:
1071  inline std::list<CParameter *>::iterator
1073  {
1074  return m_listCustom.begin();
1075  }
1076 
1078  inline std::list<CParameter *>::iterator
1079  endCustom (void)
1080  {
1081  return m_listCustom.end();
1082  }
1083 
1085  inline void
1087  {
1088  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1089  }
1090 
1092  inline int
1094  {
1095  return (int) (m_listCustom.size());
1096  }
1097 
1098  EResultCode
1100  addCustom (
1101  CParameter * pValue);
1102 
1103 
1104 };
1105 
1106 
1130 class CIMPINJ_ENABLE_EXTENSIONS_RESPONSE : public CMessage
1131 {
1132  public:
1135 
1138 
1139  static const CFieldDescriptor * const
1140  s_apFieldDescriptorTable[];
1141 
1142  static const CTypeDescriptor
1143  s_typeDescriptor;
1144 
1145  void
1146  decodeFields (
1147  CDecoderStream * pDecoderStream);
1148 
1149  void
1150  assimilateSubParameters (
1151  CErrorDetails * pError);
1152 
1153  void
1154  encode (
1155  CEncoderStream * pEncoderStream) const;
1156 
1157 
1158 
1159  static CElement *
1160  s_construct (void);
1161 
1162  static void
1163  s_decodeFields (
1164  CDecoderStream * pDecoderStream,
1165  CElement * pElement);
1167 
1168 
1169  protected:
1170  CLLRPStatus * m_pLLRPStatus;
1171 
1172  public:
1174  inline CLLRPStatus *
1176  {
1177  return m_pLLRPStatus;
1178  }
1179 
1181  EResultCode
1182  setLLRPStatus (
1183  CLLRPStatus * pValue);
1184 
1185 
1186  protected:
1187  std::list<CParameter *> m_listCustom;
1188 
1189  public:
1191  inline std::list<CParameter *>::iterator
1193  {
1194  return m_listCustom.begin();
1195  }
1196 
1198  inline std::list<CParameter *>::iterator
1199  endCustom (void)
1200  {
1201  return m_listCustom.end();
1202  }
1203 
1205  inline void
1207  {
1208  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1209  }
1210 
1212  inline int
1214  {
1215  return (int) (m_listCustom.size());
1216  }
1217 
1218  EResultCode
1220  addCustom (
1221  CParameter * pValue);
1222 
1223 
1224 };
1225 
1226 
1260 class CIMPINJ_SAVE_SETTINGS : public CMessage
1261 {
1262  public:
1263  CIMPINJ_SAVE_SETTINGS (void);
1264  ~CIMPINJ_SAVE_SETTINGS (void);
1265 
1268 
1269  static const CFieldDescriptor * const
1270  s_apFieldDescriptorTable[];
1271 
1272  static const CTypeDescriptor
1273  s_typeDescriptor;
1274 
1275  void
1276  decodeFields (
1277  CDecoderStream * pDecoderStream);
1278 
1279  void
1280  assimilateSubParameters (
1281  CErrorDetails * pError);
1282 
1283  void
1284  encode (
1285  CEncoderStream * pEncoderStream) const;
1286 
1287 
1288 
1289  static CElement *
1290  s_construct (void);
1291 
1292  static void
1293  s_decodeFields (
1294  CDecoderStream * pDecoderStream,
1295  CElement * pElement);
1297 
1298 
1299  protected:
1300  llrp_u1_t m_SaveConfiguration;
1301 
1304  public:
1305  static const CFieldDescriptor
1306  s_fdSaveConfiguration;
1308 
1310  inline llrp_u1_t
1312  {
1313  return m_SaveConfiguration;
1314  }
1315 
1317  inline void
1319  llrp_u1_t value)
1320  {
1321  m_SaveConfiguration = value;
1322  }
1323 
1324 
1325  protected:
1326  std::list<CParameter *> m_listCustom;
1327 
1328  public:
1330  inline std::list<CParameter *>::iterator
1332  {
1333  return m_listCustom.begin();
1334  }
1335 
1337  inline std::list<CParameter *>::iterator
1338  endCustom (void)
1339  {
1340  return m_listCustom.end();
1341  }
1342 
1344  inline void
1346  {
1347  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1348  }
1349 
1351  inline int
1353  {
1354  return (int) (m_listCustom.size());
1355  }
1356 
1357  EResultCode
1359  addCustom (
1360  CParameter * pValue);
1361 
1362 
1363 };
1364 
1365 
1389 class CIMPINJ_SAVE_SETTINGS_RESPONSE : public CMessage
1390 {
1391  public:
1394 
1397 
1398  static const CFieldDescriptor * const
1399  s_apFieldDescriptorTable[];
1400 
1401  static const CTypeDescriptor
1402  s_typeDescriptor;
1403 
1404  void
1405  decodeFields (
1406  CDecoderStream * pDecoderStream);
1407 
1408  void
1409  assimilateSubParameters (
1410  CErrorDetails * pError);
1411 
1412  void
1413  encode (
1414  CEncoderStream * pEncoderStream) const;
1415 
1416 
1417 
1418  static CElement *
1419  s_construct (void);
1420 
1421  static void
1422  s_decodeFields (
1423  CDecoderStream * pDecoderStream,
1424  CElement * pElement);
1426 
1427 
1428  protected:
1429  CLLRPStatus * m_pLLRPStatus;
1430 
1431  public:
1433  inline CLLRPStatus *
1435  {
1436  return m_pLLRPStatus;
1437  }
1438 
1440  EResultCode
1441  setLLRPStatus (
1442  CLLRPStatus * pValue);
1443 
1444 
1445  protected:
1446  std::list<CParameter *> m_listCustom;
1447 
1448  public:
1450  inline std::list<CParameter *>::iterator
1452  {
1453  return m_listCustom.begin();
1454  }
1455 
1457  inline std::list<CParameter *>::iterator
1458  endCustom (void)
1459  {
1460  return m_listCustom.end();
1461  }
1462 
1464  inline void
1466  {
1467  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1468  }
1469 
1471  inline int
1473  {
1474  return (int) (m_listCustom.size());
1475  }
1476 
1477  EResultCode
1479  addCustom (
1480  CParameter * pValue);
1481 
1482 
1483 };
1484 
1485 
1493 
1516 class CImpinjRequestedData : public CParameter
1517 {
1518  public:
1519  CImpinjRequestedData (void);
1520  ~CImpinjRequestedData (void);
1521 
1524 
1525  static const CFieldDescriptor * const
1526  s_apFieldDescriptorTable[];
1527 
1528  static const CTypeDescriptor
1529  s_typeDescriptor;
1530 
1531  void
1532  decodeFields (
1533  CDecoderStream * pDecoderStream);
1534 
1535  void
1536  assimilateSubParameters (
1537  CErrorDetails * pError);
1538 
1539  void
1540  encode (
1541  CEncoderStream * pEncoderStream) const;
1542 
1543 
1544  llrp_bool_t
1545  isAllowedIn (
1546  const CTypeDescriptor * pEnclosingElementType) const;
1547 
1548 
1549  static CElement *
1550  s_construct (void);
1551 
1552  static void
1553  s_decodeFields (
1554  CDecoderStream * pDecoderStream,
1555  CElement * pElement);
1557 
1558 
1559  protected:
1560  EImpinjRequestedDataType m_eRequestedData;
1561 
1564  public:
1565  static const CFieldDescriptor
1566  s_fdRequestedData;
1568 
1570  inline EImpinjRequestedDataType
1572  {
1573  return m_eRequestedData;
1574  }
1575 
1577  inline void
1579  EImpinjRequestedDataType value)
1580  {
1581  m_eRequestedData = value;
1582  }
1583 
1584 
1585  protected:
1586  std::list<CParameter *> m_listCustom;
1587 
1588  public:
1590  inline std::list<CParameter *>::iterator
1592  {
1593  return m_listCustom.begin();
1594  }
1595 
1597  inline std::list<CParameter *>::iterator
1598  endCustom (void)
1599  {
1600  return m_listCustom.end();
1601  }
1602 
1604  inline void
1606  {
1607  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1608  }
1609 
1611  inline int
1613  {
1614  return (int) (m_listCustom.size());
1615  }
1616 
1617  EResultCode
1619  addCustom (
1620  CParameter * pValue);
1621 
1622 
1623 };
1624 
1625 
1654 class CImpinjSubRegulatoryRegion : public CParameter
1655 {
1656  public:
1659 
1662 
1663  static const CFieldDescriptor * const
1664  s_apFieldDescriptorTable[];
1665 
1666  static const CTypeDescriptor
1667  s_typeDescriptor;
1668 
1669  void
1670  decodeFields (
1671  CDecoderStream * pDecoderStream);
1672 
1673  void
1674  assimilateSubParameters (
1675  CErrorDetails * pError);
1676 
1677  void
1678  encode (
1679  CEncoderStream * pEncoderStream) const;
1680 
1681 
1682  llrp_bool_t
1683  isAllowedIn (
1684  const CTypeDescriptor * pEnclosingElementType) const;
1685 
1686 
1687  static CElement *
1688  s_construct (void);
1689 
1690  static void
1691  s_decodeFields (
1692  CDecoderStream * pDecoderStream,
1693  CElement * pElement);
1695 
1696 
1697  protected:
1698  EImpinjRegulatoryRegion m_eRegulatoryRegion;
1699 
1702  public:
1703  static const CFieldDescriptor
1704  s_fdRegulatoryRegion;
1706 
1708  inline EImpinjRegulatoryRegion
1710  {
1711  return m_eRegulatoryRegion;
1712  }
1713 
1715  inline void
1717  EImpinjRegulatoryRegion value)
1718  {
1719  m_eRegulatoryRegion = value;
1720  }
1721 
1722 
1723  protected:
1724  std::list<CParameter *> m_listCustom;
1725 
1726  public:
1728  inline std::list<CParameter *>::iterator
1730  {
1731  return m_listCustom.begin();
1732  }
1733 
1735  inline std::list<CParameter *>::iterator
1736  endCustom (void)
1737  {
1738  return m_listCustom.end();
1739  }
1740 
1742  inline void
1744  {
1745  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1746  }
1747 
1749  inline int
1751  {
1752  return (int) (m_listCustom.size());
1753  }
1754 
1755  EResultCode
1757  addCustom (
1758  CParameter * pValue);
1759 
1760 
1761 };
1762 
1763 
1788 class CImpinjInventorySearchMode : public CParameter
1789 {
1790  public:
1793 
1796 
1797  static const CFieldDescriptor * const
1798  s_apFieldDescriptorTable[];
1799 
1800  static const CTypeDescriptor
1801  s_typeDescriptor;
1802 
1803  void
1804  decodeFields (
1805  CDecoderStream * pDecoderStream);
1806 
1807  void
1808  assimilateSubParameters (
1809  CErrorDetails * pError);
1810 
1811  void
1812  encode (
1813  CEncoderStream * pEncoderStream) const;
1814 
1815 
1816  llrp_bool_t
1817  isAllowedIn (
1818  const CTypeDescriptor * pEnclosingElementType) const;
1819 
1820 
1821  static CElement *
1822  s_construct (void);
1823 
1824  static void
1825  s_decodeFields (
1826  CDecoderStream * pDecoderStream,
1827  CElement * pElement);
1829 
1830 
1831  protected:
1832  EImpinjInventorySearchType m_eInventorySearchMode;
1833 
1836  public:
1837  static const CFieldDescriptor
1838  s_fdInventorySearchMode;
1840 
1842  inline EImpinjInventorySearchType
1844  {
1845  return m_eInventorySearchMode;
1846  }
1847 
1849  inline void
1851  EImpinjInventorySearchType value)
1852  {
1853  m_eInventorySearchMode = value;
1854  }
1855 
1856 
1857  protected:
1858  std::list<CParameter *> m_listCustom;
1859 
1860  public:
1862  inline std::list<CParameter *>::iterator
1864  {
1865  return m_listCustom.begin();
1866  }
1867 
1869  inline std::list<CParameter *>::iterator
1870  endCustom (void)
1871  {
1872  return m_listCustom.end();
1873  }
1874 
1876  inline void
1878  {
1879  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1880  }
1881 
1883  inline int
1885  {
1886  return (int) (m_listCustom.size());
1887  }
1888 
1889  EResultCode
1891  addCustom (
1892  CParameter * pValue);
1893 
1894 
1895 };
1896 
1897 
1927 class CImpinjFixedFrequencyList : public CParameter
1928 {
1929  public:
1931  ~CImpinjFixedFrequencyList (void);
1932 
1935 
1936  static const CFieldDescriptor * const
1937  s_apFieldDescriptorTable[];
1938 
1939  static const CTypeDescriptor
1940  s_typeDescriptor;
1941 
1942  void
1943  decodeFields (
1944  CDecoderStream * pDecoderStream);
1945 
1946  void
1947  assimilateSubParameters (
1948  CErrorDetails * pError);
1949 
1950  void
1951  encode (
1952  CEncoderStream * pEncoderStream) const;
1953 
1954 
1955  llrp_bool_t
1956  isAllowedIn (
1957  const CTypeDescriptor * pEnclosingElementType) const;
1958 
1959 
1960  static CElement *
1961  s_construct (void);
1962 
1963  static void
1964  s_decodeFields (
1965  CDecoderStream * pDecoderStream,
1966  CElement * pElement);
1968 
1969 
1970  protected:
1971  EImpinjFixedFrequencyMode m_eFixedFrequencyMode;
1972 
1975  public:
1976  static const CFieldDescriptor
1977  s_fdFixedFrequencyMode;
1979 
1981  inline EImpinjFixedFrequencyMode
1983  {
1984  return m_eFixedFrequencyMode;
1985  }
1986 
1988  inline void
1990  EImpinjFixedFrequencyMode value)
1991  {
1992  m_eFixedFrequencyMode = value;
1993  }
1994 
1995 
1996  protected:
1997  llrp_u16v_t m_ChannelList;
1998 
2001  public:
2002  static const CFieldDescriptor
2003  s_fdChannelList;
2005 
2007  inline llrp_u16v_t
2009  {
2010  return m_ChannelList;
2011  }
2012 
2014  inline void
2016  llrp_u16v_t value)
2017  {
2018  m_ChannelList = value;
2019  }
2020 
2021 
2022  protected:
2023  std::list<CParameter *> m_listCustom;
2024 
2025  public:
2027  inline std::list<CParameter *>::iterator
2029  {
2030  return m_listCustom.begin();
2031  }
2032 
2034  inline std::list<CParameter *>::iterator
2035  endCustom (void)
2036  {
2037  return m_listCustom.end();
2038  }
2039 
2041  inline void
2043  {
2044  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2045  }
2046 
2048  inline int
2050  {
2051  return (int) (m_listCustom.size());
2052  }
2053 
2054  EResultCode
2056  addCustom (
2057  CParameter * pValue);
2058 
2059 
2060 };
2061 
2062 
2092 class CImpinjReducedPowerFrequencyList : public CParameter
2093 {
2094  public:
2097 
2100 
2101  static const CFieldDescriptor * const
2102  s_apFieldDescriptorTable[];
2103 
2104  static const CTypeDescriptor
2105  s_typeDescriptor;
2106 
2107  void
2108  decodeFields (
2109  CDecoderStream * pDecoderStream);
2110 
2111  void
2112  assimilateSubParameters (
2113  CErrorDetails * pError);
2114 
2115  void
2116  encode (
2117  CEncoderStream * pEncoderStream) const;
2118 
2119 
2120  llrp_bool_t
2121  isAllowedIn (
2122  const CTypeDescriptor * pEnclosingElementType) const;
2123 
2124 
2125  static CElement *
2126  s_construct (void);
2127 
2128  static void
2129  s_decodeFields (
2130  CDecoderStream * pDecoderStream,
2131  CElement * pElement);
2133 
2134 
2135  protected:
2136  EImpinjReducedPowerMode m_eReducedPowerMode;
2137 
2140  public:
2141  static const CFieldDescriptor
2142  s_fdReducedPowerMode;
2144 
2146  inline EImpinjReducedPowerMode
2148  {
2149  return m_eReducedPowerMode;
2150  }
2151 
2153  inline void
2155  EImpinjReducedPowerMode value)
2156  {
2157  m_eReducedPowerMode = value;
2158  }
2159 
2160 
2161  protected:
2162  llrp_u16v_t m_ChannelList;
2163 
2166  public:
2167  static const CFieldDescriptor
2168  s_fdChannelList;
2170 
2172  inline llrp_u16v_t
2174  {
2175  return m_ChannelList;
2176  }
2177 
2179  inline void
2181  llrp_u16v_t value)
2182  {
2183  m_ChannelList = value;
2184  }
2185 
2186 
2187  protected:
2188  std::list<CParameter *> m_listCustom;
2189 
2190  public:
2192  inline std::list<CParameter *>::iterator
2194  {
2195  return m_listCustom.begin();
2196  }
2197 
2199  inline std::list<CParameter *>::iterator
2200  endCustom (void)
2201  {
2202  return m_listCustom.end();
2203  }
2204 
2206  inline void
2208  {
2209  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2210  }
2211 
2213  inline int
2215  {
2216  return (int) (m_listCustom.size());
2217  }
2218 
2219  EResultCode
2221  addCustom (
2222  CParameter * pValue);
2223 
2224 
2225 };
2226 
2227 
2257 class CImpinjLowDutyCycle : public CParameter
2258 {
2259  public:
2260  CImpinjLowDutyCycle (void);
2261  ~CImpinjLowDutyCycle (void);
2262 
2265 
2266  static const CFieldDescriptor * const
2267  s_apFieldDescriptorTable[];
2268 
2269  static const CTypeDescriptor
2270  s_typeDescriptor;
2271 
2272  void
2273  decodeFields (
2274  CDecoderStream * pDecoderStream);
2275 
2276  void
2277  assimilateSubParameters (
2278  CErrorDetails * pError);
2279 
2280  void
2281  encode (
2282  CEncoderStream * pEncoderStream) const;
2283 
2284 
2285  llrp_bool_t
2286  isAllowedIn (
2287  const CTypeDescriptor * pEnclosingElementType) const;
2288 
2289 
2290  static CElement *
2291  s_construct (void);
2292 
2293  static void
2294  s_decodeFields (
2295  CDecoderStream * pDecoderStream,
2296  CElement * pElement);
2298 
2299 
2300  protected:
2301  EImpinjLowDutyCycleMode m_eLowDutyCycleMode;
2302 
2305  public:
2306  static const CFieldDescriptor
2307  s_fdLowDutyCycleMode;
2309 
2311  inline EImpinjLowDutyCycleMode
2313  {
2314  return m_eLowDutyCycleMode;
2315  }
2316 
2318  inline void
2320  EImpinjLowDutyCycleMode value)
2321  {
2322  m_eLowDutyCycleMode = value;
2323  }
2324 
2325 
2326  protected:
2327  llrp_u16_t m_EmptyFieldTimeout;
2328 
2331  public:
2332  static const CFieldDescriptor
2333  s_fdEmptyFieldTimeout;
2335 
2337  inline llrp_u16_t
2339  {
2340  return m_EmptyFieldTimeout;
2341  }
2342 
2344  inline void
2346  llrp_u16_t value)
2347  {
2348  m_EmptyFieldTimeout = value;
2349  }
2350 
2351 
2352  protected:
2353  llrp_u16_t m_FieldPingInterval;
2354 
2357  public:
2358  static const CFieldDescriptor
2359  s_fdFieldPingInterval;
2361 
2363  inline llrp_u16_t
2365  {
2366  return m_FieldPingInterval;
2367  }
2368 
2370  inline void
2372  llrp_u16_t value)
2373  {
2374  m_FieldPingInterval = value;
2375  }
2376 
2377 
2378  protected:
2379  std::list<CParameter *> m_listCustom;
2380 
2381  public:
2383  inline std::list<CParameter *>::iterator
2385  {
2386  return m_listCustom.begin();
2387  }
2388 
2390  inline std::list<CParameter *>::iterator
2391  endCustom (void)
2392  {
2393  return m_listCustom.end();
2394  }
2395 
2397  inline void
2399  {
2400  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2401  }
2402 
2404  inline int
2406  {
2407  return (int) (m_listCustom.size());
2408  }
2409 
2410  EResultCode
2412  addCustom (
2413  CParameter * pValue);
2414 
2415 
2416 };
2417 
2418 
2443 class CImpinjHubVersions : public CParameter
2444 {
2445  public:
2446  CImpinjHubVersions (void);
2447  ~CImpinjHubVersions (void);
2448 
2451 
2452  static const CFieldDescriptor * const
2453  s_apFieldDescriptorTable[];
2454 
2455  static const CTypeDescriptor
2456  s_typeDescriptor;
2457 
2458  void
2459  decodeFields (
2460  CDecoderStream * pDecoderStream);
2461 
2462  void
2463  assimilateSubParameters (
2464  CErrorDetails * pError);
2465 
2466  void
2467  encode (
2468  CEncoderStream * pEncoderStream) const;
2469 
2470 
2471  llrp_bool_t
2472  isAllowedIn (
2473  const CTypeDescriptor * pEnclosingElementType) const;
2474 
2475 
2476  static CElement *
2477  s_construct (void);
2478 
2479  static void
2480  s_decodeFields (
2481  CDecoderStream * pDecoderStream,
2482  CElement * pElement);
2484 
2485 
2486  protected:
2487  std::list<CImpinjArrayVersion *> m_listImpinjArrayVersion;
2488 
2489  public:
2491  inline std::list<CImpinjArrayVersion *>::iterator
2493  {
2494  return m_listImpinjArrayVersion.begin();
2495  }
2496 
2498  inline std::list<CImpinjArrayVersion *>::iterator
2500  {
2501  return m_listImpinjArrayVersion.end();
2502  }
2503 
2505  inline void
2507  {
2508  clearSubParameterList ((tListOfParameters *) &m_listImpinjArrayVersion);
2509  }
2510 
2512  inline int
2514  {
2515  return (int) (m_listImpinjArrayVersion.size());
2516  }
2517 
2518  EResultCode
2521  CImpinjArrayVersion * pValue);
2522 
2523 
2524  protected:
2525  std::list<CParameter *> m_listCustom;
2526 
2527  public:
2529  inline std::list<CParameter *>::iterator
2531  {
2532  return m_listCustom.begin();
2533  }
2534 
2536  inline std::list<CParameter *>::iterator
2537  endCustom (void)
2538  {
2539  return m_listCustom.end();
2540  }
2541 
2543  inline void
2545  {
2546  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2547  }
2548 
2550  inline int
2552  {
2553  return (int) (m_listCustom.size());
2554  }
2555 
2556  EResultCode
2558  addCustom (
2559  CParameter * pValue);
2560 
2561 
2562 };
2563 
2564 
2597 class CImpinjDetailedVersion : public CParameter
2598 {
2599  public:
2600  CImpinjDetailedVersion (void);
2601  ~CImpinjDetailedVersion (void);
2602 
2605 
2606  static const CFieldDescriptor * const
2607  s_apFieldDescriptorTable[];
2608 
2609  static const CTypeDescriptor
2610  s_typeDescriptor;
2611 
2612  void
2613  decodeFields (
2614  CDecoderStream * pDecoderStream);
2615 
2616  void
2617  assimilateSubParameters (
2618  CErrorDetails * pError);
2619 
2620  void
2621  encode (
2622  CEncoderStream * pEncoderStream) const;
2623 
2624 
2625  llrp_bool_t
2626  isAllowedIn (
2627  const CTypeDescriptor * pEnclosingElementType) const;
2628 
2629 
2630  static CElement *
2631  s_construct (void);
2632 
2633  static void
2634  s_decodeFields (
2635  CDecoderStream * pDecoderStream,
2636  CElement * pElement);
2638 
2639 
2640  protected:
2641  llrp_utf8v_t m_ModelName;
2642 
2645  public:
2646  static const CFieldDescriptor
2647  s_fdModelName;
2649 
2651  inline llrp_utf8v_t
2653  {
2654  return m_ModelName;
2655  }
2656 
2658  inline void
2660  llrp_utf8v_t value)
2661  {
2662  m_ModelName = value;
2663  }
2664 
2665 
2666  protected:
2667  llrp_utf8v_t m_SerialNumber;
2668 
2671  public:
2672  static const CFieldDescriptor
2673  s_fdSerialNumber;
2675 
2677  inline llrp_utf8v_t
2679  {
2680  return m_SerialNumber;
2681  }
2682 
2684  inline void
2686  llrp_utf8v_t value)
2687  {
2688  m_SerialNumber = value;
2689  }
2690 
2691 
2692  protected:
2693  llrp_utf8v_t m_SoftwareVersion;
2694 
2697  public:
2698  static const CFieldDescriptor
2699  s_fdSoftwareVersion;
2701 
2703  inline llrp_utf8v_t
2705  {
2706  return m_SoftwareVersion;
2707  }
2708 
2710  inline void
2712  llrp_utf8v_t value)
2713  {
2714  m_SoftwareVersion = value;
2715  }
2716 
2717 
2718  protected:
2719  llrp_utf8v_t m_FirmwareVersion;
2720 
2723  public:
2724  static const CFieldDescriptor
2725  s_fdFirmwareVersion;
2727 
2729  inline llrp_utf8v_t
2731  {
2732  return m_FirmwareVersion;
2733  }
2734 
2736  inline void
2738  llrp_utf8v_t value)
2739  {
2740  m_FirmwareVersion = value;
2741  }
2742 
2743 
2744  protected:
2745  llrp_utf8v_t m_FPGAVersion;
2746 
2749  public:
2750  static const CFieldDescriptor
2751  s_fdFPGAVersion;
2753 
2755  inline llrp_utf8v_t
2757  {
2758  return m_FPGAVersion;
2759  }
2760 
2762  inline void
2764  llrp_utf8v_t value)
2765  {
2766  m_FPGAVersion = value;
2767  }
2768 
2769 
2770  protected:
2771  llrp_utf8v_t m_PCBAVersion;
2772 
2775  public:
2776  static const CFieldDescriptor
2777  s_fdPCBAVersion;
2779 
2781  inline llrp_utf8v_t
2783  {
2784  return m_PCBAVersion;
2785  }
2786 
2788  inline void
2790  llrp_utf8v_t value)
2791  {
2792  m_PCBAVersion = value;
2793  }
2794 
2795 
2796  protected:
2797  CImpinjHubVersions * m_pImpinjHubVersions;
2798 
2799  public:
2801  inline CImpinjHubVersions *
2803  {
2804  return m_pImpinjHubVersions;
2805  }
2806 
2808  EResultCode
2810  CImpinjHubVersions * pValue);
2811 
2812 
2813  protected:
2814  CImpinjArrayVersion * m_pImpinjArrayVersion;
2815 
2816  public:
2818  inline CImpinjArrayVersion *
2820  {
2821  return m_pImpinjArrayVersion;
2822  }
2823 
2825  EResultCode
2827  CImpinjArrayVersion * pValue);
2828 
2829 
2830  protected:
2831  CImpinjBLEVersion * m_pImpinjBLEVersion;
2832 
2833  public:
2835  inline CImpinjBLEVersion *
2837  {
2838  return m_pImpinjBLEVersion;
2839  }
2840 
2842  EResultCode
2844  CImpinjBLEVersion * pValue);
2845 
2846 
2847  protected:
2848  std::list<CParameter *> m_listCustom;
2849 
2850  public:
2852  inline std::list<CParameter *>::iterator
2854  {
2855  return m_listCustom.begin();
2856  }
2857 
2859  inline std::list<CParameter *>::iterator
2860  endCustom (void)
2861  {
2862  return m_listCustom.end();
2863  }
2864 
2866  inline void
2868  {
2869  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2870  }
2871 
2873  inline int
2875  {
2876  return (int) (m_listCustom.size());
2877  }
2878 
2879  EResultCode
2881  addCustom (
2882  CParameter * pValue);
2883 
2884 
2885 };
2886 
2887 
2912 class CImpinjFrequencyCapabilities : public CParameter
2913 {
2914  public:
2917 
2920 
2921  static const CFieldDescriptor * const
2922  s_apFieldDescriptorTable[];
2923 
2924  static const CTypeDescriptor
2925  s_typeDescriptor;
2926 
2927  void
2928  decodeFields (
2929  CDecoderStream * pDecoderStream);
2930 
2931  void
2932  assimilateSubParameters (
2933  CErrorDetails * pError);
2934 
2935  void
2936  encode (
2937  CEncoderStream * pEncoderStream) const;
2938 
2939 
2940  llrp_bool_t
2941  isAllowedIn (
2942  const CTypeDescriptor * pEnclosingElementType) const;
2943 
2944 
2945  static CElement *
2946  s_construct (void);
2947 
2948  static void
2949  s_decodeFields (
2950  CDecoderStream * pDecoderStream,
2951  CElement * pElement);
2953 
2954 
2955  protected:
2956  llrp_u32v_t m_FrequencyList;
2957 
2960  public:
2961  static const CFieldDescriptor
2962  s_fdFrequencyList;
2964 
2966  inline llrp_u32v_t
2968  {
2969  return m_FrequencyList;
2970  }
2971 
2973  inline void
2975  llrp_u32v_t value)
2976  {
2977  m_FrequencyList = value;
2978  }
2979 
2980 
2981  protected:
2982  std::list<CParameter *> m_listCustom;
2983 
2984  public:
2986  inline std::list<CParameter *>::iterator
2988  {
2989  return m_listCustom.begin();
2990  }
2991 
2993  inline std::list<CParameter *>::iterator
2994  endCustom (void)
2995  {
2996  return m_listCustom.end();
2997  }
2998 
3000  inline void
3002  {
3003  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3004  }
3005 
3007  inline int
3009  {
3010  return (int) (m_listCustom.size());
3011  }
3012 
3013  EResultCode
3015  addCustom (
3016  CParameter * pValue);
3017 
3018 
3019 };
3020 
3021 
3048 class CImpinjGPIDebounceConfiguration : public CParameter
3049 {
3050  public:
3053 
3056 
3057  static const CFieldDescriptor * const
3058  s_apFieldDescriptorTable[];
3059 
3060  static const CTypeDescriptor
3061  s_typeDescriptor;
3062 
3063  void
3064  decodeFields (
3065  CDecoderStream * pDecoderStream);
3066 
3067  void
3068  assimilateSubParameters (
3069  CErrorDetails * pError);
3070 
3071  void
3072  encode (
3073  CEncoderStream * pEncoderStream) const;
3074 
3075 
3076  llrp_bool_t
3077  isAllowedIn (
3078  const CTypeDescriptor * pEnclosingElementType) const;
3079 
3080 
3081  static CElement *
3082  s_construct (void);
3083 
3084  static void
3085  s_decodeFields (
3086  CDecoderStream * pDecoderStream,
3087  CElement * pElement);
3089 
3090 
3091  protected:
3092  llrp_u16_t m_GPIPortNum;
3093 
3096  public:
3097  static const CFieldDescriptor
3098  s_fdGPIPortNum;
3100 
3102  inline llrp_u16_t
3104  {
3105  return m_GPIPortNum;
3106  }
3107 
3109  inline void
3111  llrp_u16_t value)
3112  {
3113  m_GPIPortNum = value;
3114  }
3115 
3116 
3117  protected:
3118  llrp_u32_t m_GPIDebounceTimerMSec;
3119 
3122  public:
3123  static const CFieldDescriptor
3124  s_fdGPIDebounceTimerMSec;
3126 
3128  inline llrp_u32_t
3130  {
3131  return m_GPIDebounceTimerMSec;
3132  }
3133 
3135  inline void
3137  llrp_u32_t value)
3138  {
3139  m_GPIDebounceTimerMSec = value;
3140  }
3141 
3142 
3143  protected:
3144  std::list<CParameter *> m_listCustom;
3145 
3146  public:
3148  inline std::list<CParameter *>::iterator
3150  {
3151  return m_listCustom.begin();
3152  }
3153 
3155  inline std::list<CParameter *>::iterator
3156  endCustom (void)
3157  {
3158  return m_listCustom.end();
3159  }
3160 
3162  inline void
3164  {
3165  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3166  }
3167 
3169  inline int
3171  {
3172  return (int) (m_listCustom.size());
3173  }
3174 
3175  EResultCode
3177  addCustom (
3178  CParameter * pValue);
3179 
3180 
3181 };
3182 
3183 
3208 class CImpinjReaderTemperature : public CParameter
3209 {
3210  public:
3211  CImpinjReaderTemperature (void);
3212  ~CImpinjReaderTemperature (void);
3213 
3216 
3217  static const CFieldDescriptor * const
3218  s_apFieldDescriptorTable[];
3219 
3220  static const CTypeDescriptor
3221  s_typeDescriptor;
3222 
3223  void
3224  decodeFields (
3225  CDecoderStream * pDecoderStream);
3226 
3227  void
3228  assimilateSubParameters (
3229  CErrorDetails * pError);
3230 
3231  void
3232  encode (
3233  CEncoderStream * pEncoderStream) const;
3234 
3235 
3236  llrp_bool_t
3237  isAllowedIn (
3238  const CTypeDescriptor * pEnclosingElementType) const;
3239 
3240 
3241  static CElement *
3242  s_construct (void);
3243 
3244  static void
3245  s_decodeFields (
3246  CDecoderStream * pDecoderStream,
3247  CElement * pElement);
3249 
3250 
3251  protected:
3252  llrp_s16_t m_Temperature;
3253 
3256  public:
3257  static const CFieldDescriptor
3258  s_fdTemperature;
3260 
3262  inline llrp_s16_t
3264  {
3265  return m_Temperature;
3266  }
3267 
3269  inline void
3271  llrp_s16_t value)
3272  {
3273  m_Temperature = value;
3274  }
3275 
3276 
3277  protected:
3278  std::list<CParameter *> m_listCustom;
3279 
3280  public:
3282  inline std::list<CParameter *>::iterator
3284  {
3285  return m_listCustom.begin();
3286  }
3287 
3289  inline std::list<CParameter *>::iterator
3290  endCustom (void)
3291  {
3292  return m_listCustom.end();
3293  }
3294 
3296  inline void
3298  {
3299  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3300  }
3301 
3303  inline int
3305  {
3306  return (int) (m_listCustom.size());
3307  }
3308 
3309  EResultCode
3311  addCustom (
3312  CParameter * pValue);
3313 
3314 
3315 };
3316 
3317 
3344 class CImpinjLinkMonitorConfiguration : public CParameter
3345 {
3346  public:
3349 
3352 
3353  static const CFieldDescriptor * const
3354  s_apFieldDescriptorTable[];
3355 
3356  static const CTypeDescriptor
3357  s_typeDescriptor;
3358 
3359  void
3360  decodeFields (
3361  CDecoderStream * pDecoderStream);
3362 
3363  void
3364  assimilateSubParameters (
3365  CErrorDetails * pError);
3366 
3367  void
3368  encode (
3369  CEncoderStream * pEncoderStream) const;
3370 
3371 
3372  llrp_bool_t
3373  isAllowedIn (
3374  const CTypeDescriptor * pEnclosingElementType) const;
3375 
3376 
3377  static CElement *
3378  s_construct (void);
3379 
3380  static void
3381  s_decodeFields (
3382  CDecoderStream * pDecoderStream,
3383  CElement * pElement);
3385 
3386 
3387  protected:
3388  EImpinjLinkMonitorMode m_eLinkMonitorMode;
3389 
3392  public:
3393  static const CFieldDescriptor
3394  s_fdLinkMonitorMode;
3396 
3398  inline EImpinjLinkMonitorMode
3400  {
3401  return m_eLinkMonitorMode;
3402  }
3403 
3405  inline void
3407  EImpinjLinkMonitorMode value)
3408  {
3409  m_eLinkMonitorMode = value;
3410  }
3411 
3412 
3413  protected:
3414  llrp_u16_t m_LinkDownThreshold;
3415 
3418  public:
3419  static const CFieldDescriptor
3420  s_fdLinkDownThreshold;
3422 
3424  inline llrp_u16_t
3426  {
3427  return m_LinkDownThreshold;
3428  }
3429 
3431  inline void
3433  llrp_u16_t value)
3434  {
3435  m_LinkDownThreshold = value;
3436  }
3437 
3438 
3439  protected:
3440  std::list<CParameter *> m_listCustom;
3441 
3442  public:
3444  inline std::list<CParameter *>::iterator
3446  {
3447  return m_listCustom.begin();
3448  }
3449 
3451  inline std::list<CParameter *>::iterator
3452  endCustom (void)
3453  {
3454  return m_listCustom.end();
3455  }
3456 
3458  inline void
3460  {
3461  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3462  }
3463 
3465  inline int
3467  {
3468  return (int) (m_listCustom.size());
3469  }
3470 
3471  EResultCode
3473  addCustom (
3474  CParameter * pValue);
3475 
3476 
3477 };
3478 
3479 
3505 class CImpinjReportBufferConfiguration : public CParameter
3506 {
3507  public:
3510 
3513 
3514  static const CFieldDescriptor * const
3515  s_apFieldDescriptorTable[];
3516 
3517  static const CTypeDescriptor
3518  s_typeDescriptor;
3519 
3520  void
3521  decodeFields (
3522  CDecoderStream * pDecoderStream);
3523 
3524  void
3525  assimilateSubParameters (
3526  CErrorDetails * pError);
3527 
3528  void
3529  encode (
3530  CEncoderStream * pEncoderStream) const;
3531 
3532 
3533  llrp_bool_t
3534  isAllowedIn (
3535  const CTypeDescriptor * pEnclosingElementType) const;
3536 
3537 
3538  static CElement *
3539  s_construct (void);
3540 
3541  static void
3542  s_decodeFields (
3543  CDecoderStream * pDecoderStream,
3544  CElement * pElement);
3546 
3547 
3548  protected:
3549  EImpinjReportBufferMode m_eReportBufferMode;
3550 
3553  public:
3554  static const CFieldDescriptor
3555  s_fdReportBufferMode;
3557 
3559  inline EImpinjReportBufferMode
3561  {
3562  return m_eReportBufferMode;
3563  }
3564 
3566  inline void
3568  EImpinjReportBufferMode value)
3569  {
3570  m_eReportBufferMode = value;
3571  }
3572 
3573 
3574  protected:
3575  std::list<CParameter *> m_listCustom;
3576 
3577  public:
3579  inline std::list<CParameter *>::iterator
3581  {
3582  return m_listCustom.begin();
3583  }
3584 
3586  inline std::list<CParameter *>::iterator
3587  endCustom (void)
3588  {
3589  return m_listCustom.end();
3590  }
3591 
3593  inline void
3595  {
3596  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3597  }
3598 
3600  inline int
3602  {
3603  return (int) (m_listCustom.size());
3604  }
3605 
3606  EResultCode
3608  addCustom (
3609  CParameter * pValue);
3610 
3611 
3612 };
3613 
3614 
3643 class CImpinjAccessSpecConfiguration : public CParameter
3644 {
3645  public:
3648 
3651 
3652  static const CFieldDescriptor * const
3653  s_apFieldDescriptorTable[];
3654 
3655  static const CTypeDescriptor
3656  s_typeDescriptor;
3657 
3658  void
3659  decodeFields (
3660  CDecoderStream * pDecoderStream);
3661 
3662  void
3663  assimilateSubParameters (
3664  CErrorDetails * pError);
3665 
3666  void
3667  encode (
3668  CEncoderStream * pEncoderStream) const;
3669 
3670 
3671  llrp_bool_t
3672  isAllowedIn (
3673  const CTypeDescriptor * pEnclosingElementType) const;
3674 
3675 
3676  static CElement *
3677  s_construct (void);
3678 
3679  static void
3680  s_decodeFields (
3681  CDecoderStream * pDecoderStream,
3682  CElement * pElement);
3684 
3685 
3686  protected:
3687  CImpinjBlockWriteWordCount * m_pImpinjBlockWriteWordCount;
3688 
3689  public:
3693  {
3694  return m_pImpinjBlockWriteWordCount;
3695  }
3696 
3698  EResultCode
3700  CImpinjBlockWriteWordCount * pValue);
3701 
3702 
3703  protected:
3704  CImpinjOpSpecRetryCount * m_pImpinjOpSpecRetryCount;
3705 
3706  public:
3708  inline CImpinjOpSpecRetryCount *
3710  {
3711  return m_pImpinjOpSpecRetryCount;
3712  }
3713 
3715  EResultCode
3717  CImpinjOpSpecRetryCount * pValue);
3718 
3719 
3720  protected:
3721  CImpinjAccessSpecOrdering * m_pImpinjAccessSpecOrdering;
3722 
3723  public:
3725  inline CImpinjAccessSpecOrdering *
3727  {
3728  return m_pImpinjAccessSpecOrdering;
3729  }
3730 
3732  EResultCode
3734  CImpinjAccessSpecOrdering * pValue);
3735 
3736 
3737  protected:
3738  std::list<CParameter *> m_listCustom;
3739 
3740  public:
3742  inline std::list<CParameter *>::iterator
3744  {
3745  return m_listCustom.begin();
3746  }
3747 
3749  inline std::list<CParameter *>::iterator
3750  endCustom (void)
3751  {
3752  return m_listCustom.end();
3753  }
3754 
3756  inline void
3758  {
3759  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3760  }
3761 
3763  inline int
3765  {
3766  return (int) (m_listCustom.size());
3767  }
3768 
3769  EResultCode
3771  addCustom (
3772  CParameter * pValue);
3773 
3774 
3775 };
3776 
3777 
3801 class CImpinjBlockWriteWordCount : public CParameter
3802 {
3803  public:
3806 
3809 
3810  static const CFieldDescriptor * const
3811  s_apFieldDescriptorTable[];
3812 
3813  static const CTypeDescriptor
3814  s_typeDescriptor;
3815 
3816  void
3817  decodeFields (
3818  CDecoderStream * pDecoderStream);
3819 
3820  void
3821  assimilateSubParameters (
3822  CErrorDetails * pError);
3823 
3824  void
3825  encode (
3826  CEncoderStream * pEncoderStream) const;
3827 
3828 
3829  llrp_bool_t
3830  isAllowedIn (
3831  const CTypeDescriptor * pEnclosingElementType) const;
3832 
3833 
3834  static CElement *
3835  s_construct (void);
3836 
3837  static void
3838  s_decodeFields (
3839  CDecoderStream * pDecoderStream,
3840  CElement * pElement);
3842 
3843 
3844  protected:
3845  llrp_u16_t m_WordCount;
3846 
3849  public:
3850  static const CFieldDescriptor
3851  s_fdWordCount;
3853 
3855  inline llrp_u16_t
3857  {
3858  return m_WordCount;
3859  }
3860 
3862  inline void
3864  llrp_u16_t value)
3865  {
3866  m_WordCount = value;
3867  }
3868 
3869 
3870  protected:
3871  std::list<CParameter *> m_listCustom;
3872 
3873  public:
3875  inline std::list<CParameter *>::iterator
3877  {
3878  return m_listCustom.begin();
3879  }
3880 
3882  inline std::list<CParameter *>::iterator
3883  endCustom (void)
3884  {
3885  return m_listCustom.end();
3886  }
3887 
3889  inline void
3891  {
3892  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3893  }
3894 
3896  inline int
3898  {
3899  return (int) (m_listCustom.size());
3900  }
3901 
3902  EResultCode
3904  addCustom (
3905  CParameter * pValue);
3906 
3907 
3908 };
3909 
3910 
3940 class CImpinjBlockPermalock : public CParameter
3941 {
3942  public:
3943  CImpinjBlockPermalock (void);
3944  ~CImpinjBlockPermalock (void);
3945 
3948 
3949  static const CFieldDescriptor * const
3950  s_apFieldDescriptorTable[];
3951 
3952  static const CTypeDescriptor
3953  s_typeDescriptor;
3954 
3955  void
3956  decodeFields (
3957  CDecoderStream * pDecoderStream);
3958 
3959  void
3960  assimilateSubParameters (
3961  CErrorDetails * pError);
3962 
3963  void
3964  encode (
3965  CEncoderStream * pEncoderStream) const;
3966 
3967 
3968  llrp_bool_t
3969  isAllowedIn (
3970  const CTypeDescriptor * pEnclosingElementType) const;
3971 
3972 
3973  static CElement *
3974  s_construct (void);
3975 
3976  static void
3977  s_decodeFields (
3978  CDecoderStream * pDecoderStream,
3979  CElement * pElement);
3981 
3982 
3983  protected:
3984  llrp_u16_t m_OpSpecID;
3985 
3988  public:
3989  static const CFieldDescriptor
3990  s_fdOpSpecID;
3992 
3994  inline llrp_u16_t
3996  {
3997  return m_OpSpecID;
3998  }
3999 
4001  inline void
4003  llrp_u16_t value)
4004  {
4005  m_OpSpecID = value;
4006  }
4007 
4008 
4009  protected:
4010  llrp_u32_t m_AccessPassword;
4011 
4014  public:
4015  static const CFieldDescriptor
4016  s_fdAccessPassword;
4018 
4020  inline llrp_u32_t
4022  {
4023  return m_AccessPassword;
4024  }
4025 
4027  inline void
4029  llrp_u32_t value)
4030  {
4031  m_AccessPassword = value;
4032  }
4033 
4034 
4035  protected:
4036  llrp_u2_t m_MB;
4037 
4040  public:
4041  static const CFieldDescriptor
4042  s_fdMB;
4044 
4046  inline llrp_u2_t
4047  getMB (void)
4048  {
4049  return m_MB;
4050  }
4051 
4053  inline void
4055  llrp_u2_t value)
4056  {
4057  m_MB = value;
4058  }
4059 
4060 
4061  protected:
4062  llrp_u16_t m_BlockPointer;
4063 
4066  public:
4067  static const CFieldDescriptor
4068  s_fdBlockPointer;
4070 
4072  inline llrp_u16_t
4074  {
4075  return m_BlockPointer;
4076  }
4077 
4079  inline void
4081  llrp_u16_t value)
4082  {
4083  m_BlockPointer = value;
4084  }
4085 
4086 
4087  protected:
4088  llrp_u16v_t m_BlockMask;
4089 
4092  public:
4093  static const CFieldDescriptor
4094  s_fdBlockMask;
4096 
4098  inline llrp_u16v_t
4100  {
4101  return m_BlockMask;
4102  }
4103 
4105  inline void
4107  llrp_u16v_t value)
4108  {
4109  m_BlockMask = value;
4110  }
4111 
4112 
4113  protected:
4114  std::list<CParameter *> m_listCustom;
4115 
4116  public:
4118  inline std::list<CParameter *>::iterator
4120  {
4121  return m_listCustom.begin();
4122  }
4123 
4125  inline std::list<CParameter *>::iterator
4126  endCustom (void)
4127  {
4128  return m_listCustom.end();
4129  }
4130 
4132  inline void
4134  {
4135  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4136  }
4137 
4139  inline int
4141  {
4142  return (int) (m_listCustom.size());
4143  }
4144 
4145  EResultCode
4147  addCustom (
4148  CParameter * pValue);
4149 
4150 
4151 };
4152 
4153 
4179 class CImpinjBlockPermalockOpSpecResult : public CParameter
4180 {
4181  public:
4184 
4187 
4188  static const CFieldDescriptor * const
4189  s_apFieldDescriptorTable[];
4190 
4191  static const CTypeDescriptor
4192  s_typeDescriptor;
4193 
4194  void
4195  decodeFields (
4196  CDecoderStream * pDecoderStream);
4197 
4198  void
4199  assimilateSubParameters (
4200  CErrorDetails * pError);
4201 
4202  void
4203  encode (
4204  CEncoderStream * pEncoderStream) const;
4205 
4206 
4207  llrp_bool_t
4208  isAllowedIn (
4209  const CTypeDescriptor * pEnclosingElementType) const;
4210 
4211 
4212  static CElement *
4213  s_construct (void);
4214 
4215  static void
4216  s_decodeFields (
4217  CDecoderStream * pDecoderStream,
4218  CElement * pElement);
4220 
4221 
4222  protected:
4223  EImpinjBlockPermalockResultType m_eResult;
4224 
4227  public:
4228  static const CFieldDescriptor
4229  s_fdResult;
4231 
4233  inline EImpinjBlockPermalockResultType
4234  getResult (void)
4235  {
4236  return m_eResult;
4237  }
4238 
4240  inline void
4242  EImpinjBlockPermalockResultType value)
4243  {
4244  m_eResult = value;
4245  }
4246 
4247 
4248  protected:
4249  llrp_u16_t m_OpSpecID;
4250 
4253  public:
4254  static const CFieldDescriptor
4255  s_fdOpSpecID;
4257 
4259  inline llrp_u16_t
4261  {
4262  return m_OpSpecID;
4263  }
4264 
4266  inline void
4268  llrp_u16_t value)
4269  {
4270  m_OpSpecID = value;
4271  }
4272 
4273 
4274  protected:
4275  std::list<CParameter *> m_listCustom;
4276 
4277  public:
4279  inline std::list<CParameter *>::iterator
4281  {
4282  return m_listCustom.begin();
4283  }
4284 
4286  inline std::list<CParameter *>::iterator
4287  endCustom (void)
4288  {
4289  return m_listCustom.end();
4290  }
4291 
4293  inline void
4295  {
4296  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4297  }
4298 
4300  inline int
4302  {
4303  return (int) (m_listCustom.size());
4304  }
4305 
4306  EResultCode
4308  addCustom (
4309  CParameter * pValue);
4310 
4311 
4312 };
4313 
4314 
4344 class CImpinjGetBlockPermalockStatus : public CParameter
4345 {
4346  public:
4349 
4352 
4353  static const CFieldDescriptor * const
4354  s_apFieldDescriptorTable[];
4355 
4356  static const CTypeDescriptor
4357  s_typeDescriptor;
4358 
4359  void
4360  decodeFields (
4361  CDecoderStream * pDecoderStream);
4362 
4363  void
4364  assimilateSubParameters (
4365  CErrorDetails * pError);
4366 
4367  void
4368  encode (
4369  CEncoderStream * pEncoderStream) const;
4370 
4371 
4372  llrp_bool_t
4373  isAllowedIn (
4374  const CTypeDescriptor * pEnclosingElementType) const;
4375 
4376 
4377  static CElement *
4378  s_construct (void);
4379 
4380  static void
4381  s_decodeFields (
4382  CDecoderStream * pDecoderStream,
4383  CElement * pElement);
4385 
4386 
4387  protected:
4388  llrp_u16_t m_OpSpecID;
4389 
4392  public:
4393  static const CFieldDescriptor
4394  s_fdOpSpecID;
4396 
4398  inline llrp_u16_t
4400  {
4401  return m_OpSpecID;
4402  }
4403 
4405  inline void
4407  llrp_u16_t value)
4408  {
4409  m_OpSpecID = value;
4410  }
4411 
4412 
4413  protected:
4414  llrp_u32_t m_AccessPassword;
4415 
4418  public:
4419  static const CFieldDescriptor
4420  s_fdAccessPassword;
4422 
4424  inline llrp_u32_t
4426  {
4427  return m_AccessPassword;
4428  }
4429 
4431  inline void
4433  llrp_u32_t value)
4434  {
4435  m_AccessPassword = value;
4436  }
4437 
4438 
4439  protected:
4440  llrp_u2_t m_MB;
4441 
4444  public:
4445  static const CFieldDescriptor
4446  s_fdMB;
4448 
4450  inline llrp_u2_t
4451  getMB (void)
4452  {
4453  return m_MB;
4454  }
4455 
4457  inline void
4459  llrp_u2_t value)
4460  {
4461  m_MB = value;
4462  }
4463 
4464 
4465  protected:
4466  llrp_u16_t m_BlockPointer;
4467 
4470  public:
4471  static const CFieldDescriptor
4472  s_fdBlockPointer;
4474 
4476  inline llrp_u16_t
4478  {
4479  return m_BlockPointer;
4480  }
4481 
4483  inline void
4485  llrp_u16_t value)
4486  {
4487  m_BlockPointer = value;
4488  }
4489 
4490 
4491  protected:
4492  llrp_u16_t m_BlockRange;
4493 
4496  public:
4497  static const CFieldDescriptor
4498  s_fdBlockRange;
4500 
4502  inline llrp_u16_t
4504  {
4505  return m_BlockRange;
4506  }
4507 
4509  inline void
4511  llrp_u16_t value)
4512  {
4513  m_BlockRange = value;
4514  }
4515 
4516 
4517  protected:
4518  std::list<CParameter *> m_listCustom;
4519 
4520  public:
4522  inline std::list<CParameter *>::iterator
4524  {
4525  return m_listCustom.begin();
4526  }
4527 
4529  inline std::list<CParameter *>::iterator
4530  endCustom (void)
4531  {
4532  return m_listCustom.end();
4533  }
4534 
4536  inline void
4538  {
4539  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4540  }
4541 
4543  inline int
4545  {
4546  return (int) (m_listCustom.size());
4547  }
4548 
4549  EResultCode
4551  addCustom (
4552  CParameter * pValue);
4553 
4554 
4555 };
4556 
4557 
4585 {
4586  public:
4589 
4592 
4593  static const CFieldDescriptor * const
4594  s_apFieldDescriptorTable[];
4595 
4596  static const CTypeDescriptor
4597  s_typeDescriptor;
4598 
4599  void
4600  decodeFields (
4601  CDecoderStream * pDecoderStream);
4602 
4603  void
4604  assimilateSubParameters (
4605  CErrorDetails * pError);
4606 
4607  void
4608  encode (
4609  CEncoderStream * pEncoderStream) const;
4610 
4611 
4612  llrp_bool_t
4613  isAllowedIn (
4614  const CTypeDescriptor * pEnclosingElementType) const;
4615 
4616 
4617  static CElement *
4618  s_construct (void);
4619 
4620  static void
4621  s_decodeFields (
4622  CDecoderStream * pDecoderStream,
4623  CElement * pElement);
4625 
4626 
4627  protected:
4628  EImpinjGetBlockPermalockStatusResultType m_eResult;
4629 
4632  public:
4633  static const CFieldDescriptor
4634  s_fdResult;
4636 
4638  inline EImpinjGetBlockPermalockStatusResultType
4639  getResult (void)
4640  {
4641  return m_eResult;
4642  }
4643 
4645  inline void
4647  EImpinjGetBlockPermalockStatusResultType value)
4648  {
4649  m_eResult = value;
4650  }
4651 
4652 
4653  protected:
4654  llrp_u16_t m_OpSpecID;
4655 
4658  public:
4659  static const CFieldDescriptor
4660  s_fdOpSpecID;
4662 
4664  inline llrp_u16_t
4666  {
4667  return m_OpSpecID;
4668  }
4669 
4671  inline void
4673  llrp_u16_t value)
4674  {
4675  m_OpSpecID = value;
4676  }
4677 
4678 
4679  protected:
4680  llrp_u16v_t m_PermalockStatus;
4681 
4684  public:
4685  static const CFieldDescriptor
4686  s_fdPermalockStatus;
4688 
4690  inline llrp_u16v_t
4692  {
4693  return m_PermalockStatus;
4694  }
4695 
4697  inline void
4699  llrp_u16v_t value)
4700  {
4701  m_PermalockStatus = value;
4702  }
4703 
4704 
4705  protected:
4706  std::list<CParameter *> m_listCustom;
4707 
4708  public:
4710  inline std::list<CParameter *>::iterator
4712  {
4713  return m_listCustom.begin();
4714  }
4715 
4717  inline std::list<CParameter *>::iterator
4718  endCustom (void)
4719  {
4720  return m_listCustom.end();
4721  }
4722 
4724  inline void
4726  {
4727  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4728  }
4729 
4731  inline int
4733  {
4734  return (int) (m_listCustom.size());
4735  }
4736 
4737  EResultCode
4739  addCustom (
4740  CParameter * pValue);
4741 
4742 
4743 };
4744 
4745 
4775 class CImpinjSetQTConfig : public CParameter
4776 {
4777  public:
4778  CImpinjSetQTConfig (void);
4779  ~CImpinjSetQTConfig (void);
4780 
4783 
4784  static const CFieldDescriptor * const
4785  s_apFieldDescriptorTable[];
4786 
4787  static const CTypeDescriptor
4788  s_typeDescriptor;
4789 
4790  void
4791  decodeFields (
4792  CDecoderStream * pDecoderStream);
4793 
4794  void
4795  assimilateSubParameters (
4796  CErrorDetails * pError);
4797 
4798  void
4799  encode (
4800  CEncoderStream * pEncoderStream) const;
4801 
4802 
4803  llrp_bool_t
4804  isAllowedIn (
4805  const CTypeDescriptor * pEnclosingElementType) const;
4806 
4807 
4808  static CElement *
4809  s_construct (void);
4810 
4811  static void
4812  s_decodeFields (
4813  CDecoderStream * pDecoderStream,
4814  CElement * pElement);
4816 
4817 
4818  protected:
4819  llrp_u16_t m_OpSpecID;
4820 
4823  public:
4824  static const CFieldDescriptor
4825  s_fdOpSpecID;
4827 
4829  inline llrp_u16_t
4831  {
4832  return m_OpSpecID;
4833  }
4834 
4836  inline void
4838  llrp_u16_t value)
4839  {
4840  m_OpSpecID = value;
4841  }
4842 
4843 
4844  protected:
4845  llrp_u32_t m_AccessPassword;
4846 
4849  public:
4850  static const CFieldDescriptor
4851  s_fdAccessPassword;
4853 
4855  inline llrp_u32_t
4857  {
4858  return m_AccessPassword;
4859  }
4860 
4862  inline void
4864  llrp_u32_t value)
4865  {
4866  m_AccessPassword = value;
4867  }
4868 
4869 
4870  protected:
4871  EImpinjQTDataProfile m_eDataProfile;
4872 
4875  public:
4876  static const CFieldDescriptor
4877  s_fdDataProfile;
4879 
4881  inline EImpinjQTDataProfile
4883  {
4884  return m_eDataProfile;
4885  }
4886 
4888  inline void
4890  EImpinjQTDataProfile value)
4891  {
4892  m_eDataProfile = value;
4893  }
4894 
4895 
4896  protected:
4897  EImpinjQTAccessRange m_eAccessRange;
4898 
4901  public:
4902  static const CFieldDescriptor
4903  s_fdAccessRange;
4905 
4907  inline EImpinjQTAccessRange
4909  {
4910  return m_eAccessRange;
4911  }
4912 
4914  inline void
4916  EImpinjQTAccessRange value)
4917  {
4918  m_eAccessRange = value;
4919  }
4920 
4921 
4922  protected:
4923  EImpinjQTPersistence m_ePersistence;
4924 
4927  public:
4928  static const CFieldDescriptor
4929  s_fdPersistence;
4931 
4933  inline EImpinjQTPersistence
4935  {
4936  return m_ePersistence;
4937  }
4938 
4940  inline void
4942  EImpinjQTPersistence value)
4943  {
4944  m_ePersistence = value;
4945  }
4946 
4947 
4948  protected:
4949  std::list<CParameter *> m_listCustom;
4950 
4951  public:
4953  inline std::list<CParameter *>::iterator
4955  {
4956  return m_listCustom.begin();
4957  }
4958 
4960  inline std::list<CParameter *>::iterator
4961  endCustom (void)
4962  {
4963  return m_listCustom.end();
4964  }
4965 
4967  inline void
4969  {
4970  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4971  }
4972 
4974  inline int
4976  {
4977  return (int) (m_listCustom.size());
4978  }
4979 
4980  EResultCode
4982  addCustom (
4983  CParameter * pValue);
4984 
4985 
4986 };
4987 
4988 
5014 class CImpinjSetQTConfigOpSpecResult : public CParameter
5015 {
5016  public:
5019 
5022 
5023  static const CFieldDescriptor * const
5024  s_apFieldDescriptorTable[];
5025 
5026  static const CTypeDescriptor
5027  s_typeDescriptor;
5028 
5029  void
5030  decodeFields (
5031  CDecoderStream * pDecoderStream);
5032 
5033  void
5034  assimilateSubParameters (
5035  CErrorDetails * pError);
5036 
5037  void
5038  encode (
5039  CEncoderStream * pEncoderStream) const;
5040 
5041 
5042  llrp_bool_t
5043  isAllowedIn (
5044  const CTypeDescriptor * pEnclosingElementType) const;
5045 
5046 
5047  static CElement *
5048  s_construct (void);
5049 
5050  static void
5051  s_decodeFields (
5052  CDecoderStream * pDecoderStream,
5053  CElement * pElement);
5055 
5056 
5057  protected:
5058  EImpinjSetQTConfigResultType m_eResult;
5059 
5062  public:
5063  static const CFieldDescriptor
5064  s_fdResult;
5066 
5068  inline EImpinjSetQTConfigResultType
5069  getResult (void)
5070  {
5071  return m_eResult;
5072  }
5073 
5075  inline void
5077  EImpinjSetQTConfigResultType value)
5078  {
5079  m_eResult = value;
5080  }
5081 
5082 
5083  protected:
5084  llrp_u16_t m_OpSpecID;
5085 
5088  public:
5089  static const CFieldDescriptor
5090  s_fdOpSpecID;
5092 
5094  inline llrp_u16_t
5096  {
5097  return m_OpSpecID;
5098  }
5099 
5101  inline void
5103  llrp_u16_t value)
5104  {
5105  m_OpSpecID = value;
5106  }
5107 
5108 
5109  protected:
5110  std::list<CParameter *> m_listCustom;
5111 
5112  public:
5114  inline std::list<CParameter *>::iterator
5116  {
5117  return m_listCustom.begin();
5118  }
5119 
5121  inline std::list<CParameter *>::iterator
5122  endCustom (void)
5123  {
5124  return m_listCustom.end();
5125  }
5126 
5128  inline void
5130  {
5131  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5132  }
5133 
5135  inline int
5137  {
5138  return (int) (m_listCustom.size());
5139  }
5140 
5141  EResultCode
5143  addCustom (
5144  CParameter * pValue);
5145 
5146 
5147 };
5148 
5149 
5175 class CImpinjGetQTConfig : public CParameter
5176 {
5177  public:
5178  CImpinjGetQTConfig (void);
5179  ~CImpinjGetQTConfig (void);
5180 
5183 
5184  static const CFieldDescriptor * const
5185  s_apFieldDescriptorTable[];
5186 
5187  static const CTypeDescriptor
5188  s_typeDescriptor;
5189 
5190  void
5191  decodeFields (
5192  CDecoderStream * pDecoderStream);
5193 
5194  void
5195  assimilateSubParameters (
5196  CErrorDetails * pError);
5197 
5198  void
5199  encode (
5200  CEncoderStream * pEncoderStream) const;
5201 
5202 
5203  llrp_bool_t
5204  isAllowedIn (
5205  const CTypeDescriptor * pEnclosingElementType) const;
5206 
5207 
5208  static CElement *
5209  s_construct (void);
5210 
5211  static void
5212  s_decodeFields (
5213  CDecoderStream * pDecoderStream,
5214  CElement * pElement);
5216 
5217 
5218  protected:
5219  llrp_u16_t m_OpSpecID;
5220 
5223  public:
5224  static const CFieldDescriptor
5225  s_fdOpSpecID;
5227 
5229  inline llrp_u16_t
5231  {
5232  return m_OpSpecID;
5233  }
5234 
5236  inline void
5238  llrp_u16_t value)
5239  {
5240  m_OpSpecID = value;
5241  }
5242 
5243 
5244  protected:
5245  llrp_u32_t m_AccessPassword;
5246 
5249  public:
5250  static const CFieldDescriptor
5251  s_fdAccessPassword;
5253 
5255  inline llrp_u32_t
5257  {
5258  return m_AccessPassword;
5259  }
5260 
5262  inline void
5264  llrp_u32_t value)
5265  {
5266  m_AccessPassword = value;
5267  }
5268 
5269 
5270  protected:
5271  std::list<CParameter *> m_listCustom;
5272 
5273  public:
5275  inline std::list<CParameter *>::iterator
5277  {
5278  return m_listCustom.begin();
5279  }
5280 
5282  inline std::list<CParameter *>::iterator
5283  endCustom (void)
5284  {
5285  return m_listCustom.end();
5286  }
5287 
5289  inline void
5291  {
5292  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5293  }
5294 
5296  inline int
5298  {
5299  return (int) (m_listCustom.size());
5300  }
5301 
5302  EResultCode
5304  addCustom (
5305  CParameter * pValue);
5306 
5307 
5308 };
5309 
5310 
5339 class CImpinjGetQTConfigOpSpecResult : public CParameter
5340 {
5341  public:
5344 
5347 
5348  static const CFieldDescriptor * const
5349  s_apFieldDescriptorTable[];
5350 
5351  static const CTypeDescriptor
5352  s_typeDescriptor;
5353 
5354  void
5355  decodeFields (
5356  CDecoderStream * pDecoderStream);
5357 
5358  void
5359  assimilateSubParameters (
5360  CErrorDetails * pError);
5361 
5362  void
5363  encode (
5364  CEncoderStream * pEncoderStream) const;
5365 
5366 
5367  llrp_bool_t
5368  isAllowedIn (
5369  const CTypeDescriptor * pEnclosingElementType) const;
5370 
5371 
5372  static CElement *
5373  s_construct (void);
5374 
5375  static void
5376  s_decodeFields (
5377  CDecoderStream * pDecoderStream,
5378  CElement * pElement);
5380 
5381 
5382  protected:
5383  EImpinjGetQTConfigResultType m_eResult;
5384 
5387  public:
5388  static const CFieldDescriptor
5389  s_fdResult;
5391 
5393  inline EImpinjGetQTConfigResultType
5394  getResult (void)
5395  {
5396  return m_eResult;
5397  }
5398 
5400  inline void
5402  EImpinjGetQTConfigResultType value)
5403  {
5404  m_eResult = value;
5405  }
5406 
5407 
5408  protected:
5409  llrp_u16_t m_OpSpecID;
5410 
5413  public:
5414  static const CFieldDescriptor
5415  s_fdOpSpecID;
5417 
5419  inline llrp_u16_t
5421  {
5422  return m_OpSpecID;
5423  }
5424 
5426  inline void
5428  llrp_u16_t value)
5429  {
5430  m_OpSpecID = value;
5431  }
5432 
5433 
5434  protected:
5435  EImpinjQTDataProfile m_eDataProfile;
5436 
5439  public:
5440  static const CFieldDescriptor
5441  s_fdDataProfile;
5443 
5445  inline EImpinjQTDataProfile
5447  {
5448  return m_eDataProfile;
5449  }
5450 
5452  inline void
5454  EImpinjQTDataProfile value)
5455  {
5456  m_eDataProfile = value;
5457  }
5458 
5459 
5460  protected:
5461  EImpinjQTAccessRange m_eAccessRange;
5462 
5465  public:
5466  static const CFieldDescriptor
5467  s_fdAccessRange;
5469 
5471  inline EImpinjQTAccessRange
5473  {
5474  return m_eAccessRange;
5475  }
5476 
5478  inline void
5480  EImpinjQTAccessRange value)
5481  {
5482  m_eAccessRange = value;
5483  }
5484 
5485 
5486  protected:
5487  std::list<CParameter *> m_listCustom;
5488 
5489  public:
5491  inline std::list<CParameter *>::iterator
5493  {
5494  return m_listCustom.begin();
5495  }
5496 
5498  inline std::list<CParameter *>::iterator
5499  endCustom (void)
5500  {
5501  return m_listCustom.end();
5502  }
5503 
5505  inline void
5507  {
5508  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5509  }
5510 
5512  inline int
5514  {
5515  return (int) (m_listCustom.size());
5516  }
5517 
5518  EResultCode
5520  addCustom (
5521  CParameter * pValue);
5522 
5523 
5524 };
5525 
5526 
5556 class CImpinjTagReportContentSelector : public CParameter
5557 {
5558  public:
5561 
5564 
5565  static const CFieldDescriptor * const
5566  s_apFieldDescriptorTable[];
5567 
5568  static const CTypeDescriptor
5569  s_typeDescriptor;
5570 
5571  void
5572  decodeFields (
5573  CDecoderStream * pDecoderStream);
5574 
5575  void
5576  assimilateSubParameters (
5577  CErrorDetails * pError);
5578 
5579  void
5580  encode (
5581  CEncoderStream * pEncoderStream) const;
5582 
5583 
5584  llrp_bool_t
5585  isAllowedIn (
5586  const CTypeDescriptor * pEnclosingElementType) const;
5587 
5588 
5589  static CElement *
5590  s_construct (void);
5591 
5592  static void
5593  s_decodeFields (
5594  CDecoderStream * pDecoderStream,
5595  CElement * pElement);
5597 
5598 
5599  protected:
5600  CImpinjEnableSerializedTID * m_pImpinjEnableSerializedTID;
5601 
5602  public:
5606  {
5607  return m_pImpinjEnableSerializedTID;
5608  }
5609 
5611  EResultCode
5613  CImpinjEnableSerializedTID * pValue);
5614 
5615 
5616  protected:
5617  CImpinjEnableRFPhaseAngle * m_pImpinjEnableRFPhaseAngle;
5618 
5619  public:
5621  inline CImpinjEnableRFPhaseAngle *
5623  {
5624  return m_pImpinjEnableRFPhaseAngle;
5625  }
5626 
5628  EResultCode
5630  CImpinjEnableRFPhaseAngle * pValue);
5631 
5632 
5633  protected:
5634  CImpinjEnablePeakRSSI * m_pImpinjEnablePeakRSSI;
5635 
5636  public:
5638  inline CImpinjEnablePeakRSSI *
5640  {
5641  return m_pImpinjEnablePeakRSSI;
5642  }
5643 
5645  EResultCode
5647  CImpinjEnablePeakRSSI * pValue);
5648 
5649 
5650  protected:
5651  CImpinjEnableGPSCoordinates * m_pImpinjEnableGPSCoordinates;
5652 
5653  public:
5657  {
5658  return m_pImpinjEnableGPSCoordinates;
5659  }
5660 
5662  EResultCode
5664  CImpinjEnableGPSCoordinates * pValue);
5665 
5666 
5667  protected:
5668  CImpinjEnableOptimizedRead * m_pImpinjEnableOptimizedRead;
5669 
5670  public:
5674  {
5675  return m_pImpinjEnableOptimizedRead;
5676  }
5677 
5679  EResultCode
5681  CImpinjEnableOptimizedRead * pValue);
5682 
5683 
5684  protected:
5685  CImpinjEnableRFDopplerFrequency * m_pImpinjEnableRFDopplerFrequency;
5686 
5687  public:
5691  {
5692  return m_pImpinjEnableRFDopplerFrequency;
5693  }
5694 
5696  EResultCode
5699 
5700 
5701  protected:
5702  std::list<CParameter *> m_listCustom;
5703 
5704  public:
5706  inline std::list<CParameter *>::iterator
5708  {
5709  return m_listCustom.begin();
5710  }
5711 
5713  inline std::list<CParameter *>::iterator
5714  endCustom (void)
5715  {
5716  return m_listCustom.end();
5717  }
5718 
5720  inline void
5722  {
5723  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5724  }
5725 
5727  inline int
5729  {
5730  return (int) (m_listCustom.size());
5731  }
5732 
5733  EResultCode
5735  addCustom (
5736  CParameter * pValue);
5737 
5738 
5739 };
5740 
5741 
5765 class CImpinjEnableSerializedTID : public CParameter
5766 {
5767  public:
5770 
5773 
5774  static const CFieldDescriptor * const
5775  s_apFieldDescriptorTable[];
5776 
5777  static const CTypeDescriptor
5778  s_typeDescriptor;
5779 
5780  void
5781  decodeFields (
5782  CDecoderStream * pDecoderStream);
5783 
5784  void
5785  assimilateSubParameters (
5786  CErrorDetails * pError);
5787 
5788  void
5789  encode (
5790  CEncoderStream * pEncoderStream) const;
5791 
5792 
5793  llrp_bool_t
5794  isAllowedIn (
5795  const CTypeDescriptor * pEnclosingElementType) const;
5796 
5797 
5798  static CElement *
5799  s_construct (void);
5800 
5801  static void
5802  s_decodeFields (
5803  CDecoderStream * pDecoderStream,
5804  CElement * pElement);
5806 
5807 
5808  protected:
5809  EImpinjSerializedTIDMode m_eSerializedTIDMode;
5810 
5813  public:
5814  static const CFieldDescriptor
5815  s_fdSerializedTIDMode;
5817 
5819  inline EImpinjSerializedTIDMode
5821  {
5822  return m_eSerializedTIDMode;
5823  }
5824 
5826  inline void
5828  EImpinjSerializedTIDMode value)
5829  {
5830  m_eSerializedTIDMode = value;
5831  }
5832 
5833 
5834  protected:
5835  std::list<CParameter *> m_listCustom;
5836 
5837  public:
5839  inline std::list<CParameter *>::iterator
5841  {
5842  return m_listCustom.begin();
5843  }
5844 
5846  inline std::list<CParameter *>::iterator
5847  endCustom (void)
5848  {
5849  return m_listCustom.end();
5850  }
5851 
5853  inline void
5855  {
5856  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5857  }
5858 
5860  inline int
5862  {
5863  return (int) (m_listCustom.size());
5864  }
5865 
5866  EResultCode
5868  addCustom (
5869  CParameter * pValue);
5870 
5871 
5872 };
5873 
5874 
5898 class CImpinjEnableRFPhaseAngle : public CParameter
5899 {
5900  public:
5902  ~CImpinjEnableRFPhaseAngle (void);
5903 
5906 
5907  static const CFieldDescriptor * const
5908  s_apFieldDescriptorTable[];
5909 
5910  static const CTypeDescriptor
5911  s_typeDescriptor;
5912 
5913  void
5914  decodeFields (
5915  CDecoderStream * pDecoderStream);
5916 
5917  void
5918  assimilateSubParameters (
5919  CErrorDetails * pError);
5920 
5921  void
5922  encode (
5923  CEncoderStream * pEncoderStream) const;
5924 
5925 
5926  llrp_bool_t
5927  isAllowedIn (
5928  const CTypeDescriptor * pEnclosingElementType) const;
5929 
5930 
5931  static CElement *
5932  s_construct (void);
5933 
5934  static void
5935  s_decodeFields (
5936  CDecoderStream * pDecoderStream,
5937  CElement * pElement);
5939 
5940 
5941  protected:
5942  EImpinjRFPhaseAngleMode m_eRFPhaseAngleMode;
5943 
5946  public:
5947  static const CFieldDescriptor
5948  s_fdRFPhaseAngleMode;
5950 
5952  inline EImpinjRFPhaseAngleMode
5954  {
5955  return m_eRFPhaseAngleMode;
5956  }
5957 
5959  inline void
5961  EImpinjRFPhaseAngleMode value)
5962  {
5963  m_eRFPhaseAngleMode = value;
5964  }
5965 
5966 
5967  protected:
5968  std::list<CParameter *> m_listCustom;
5969 
5970  public:
5972  inline std::list<CParameter *>::iterator
5974  {
5975  return m_listCustom.begin();
5976  }
5977 
5979  inline std::list<CParameter *>::iterator
5980  endCustom (void)
5981  {
5982  return m_listCustom.end();
5983  }
5984 
5986  inline void
5988  {
5989  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5990  }
5991 
5993  inline int
5995  {
5996  return (int) (m_listCustom.size());
5997  }
5998 
5999  EResultCode
6001  addCustom (
6002  CParameter * pValue);
6003 
6004 
6005 };
6006 
6007 
6031 class CImpinjEnablePeakRSSI : public CParameter
6032 {
6033  public:
6034  CImpinjEnablePeakRSSI (void);
6035  ~CImpinjEnablePeakRSSI (void);
6036 
6039 
6040  static const CFieldDescriptor * const
6041  s_apFieldDescriptorTable[];
6042 
6043  static const CTypeDescriptor
6044  s_typeDescriptor;
6045 
6046  void
6047  decodeFields (
6048  CDecoderStream * pDecoderStream);
6049 
6050  void
6051  assimilateSubParameters (
6052  CErrorDetails * pError);
6053 
6054  void
6055  encode (
6056  CEncoderStream * pEncoderStream) const;
6057 
6058 
6059  llrp_bool_t
6060  isAllowedIn (
6061  const CTypeDescriptor * pEnclosingElementType) const;
6062 
6063 
6064  static CElement *
6065  s_construct (void);
6066 
6067  static void
6068  s_decodeFields (
6069  CDecoderStream * pDecoderStream,
6070  CElement * pElement);
6072 
6073 
6074  protected:
6075  EImpinjPeakRSSIMode m_ePeakRSSIMode;
6076 
6079  public:
6080  static const CFieldDescriptor
6081  s_fdPeakRSSIMode;
6083 
6085  inline EImpinjPeakRSSIMode
6087  {
6088  return m_ePeakRSSIMode;
6089  }
6090 
6092  inline void
6094  EImpinjPeakRSSIMode value)
6095  {
6096  m_ePeakRSSIMode = value;
6097  }
6098 
6099 
6100  protected:
6101  std::list<CParameter *> m_listCustom;
6102 
6103  public:
6105  inline std::list<CParameter *>::iterator
6107  {
6108  return m_listCustom.begin();
6109  }
6110 
6112  inline std::list<CParameter *>::iterator
6113  endCustom (void)
6114  {
6115  return m_listCustom.end();
6116  }
6117 
6119  inline void
6121  {
6122  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6123  }
6124 
6126  inline int
6128  {
6129  return (int) (m_listCustom.size());
6130  }
6131 
6132  EResultCode
6134  addCustom (
6135  CParameter * pValue);
6136 
6137 
6138 };
6139 
6140 
6164 class CImpinjEnableGPSCoordinates : public CParameter
6165 {
6166  public:
6169 
6172 
6173  static const CFieldDescriptor * const
6174  s_apFieldDescriptorTable[];
6175 
6176  static const CTypeDescriptor
6177  s_typeDescriptor;
6178 
6179  void
6180  decodeFields (
6181  CDecoderStream * pDecoderStream);
6182 
6183  void
6184  assimilateSubParameters (
6185  CErrorDetails * pError);
6186 
6187  void
6188  encode (
6189  CEncoderStream * pEncoderStream) const;
6190 
6191 
6192  llrp_bool_t
6193  isAllowedIn (
6194  const CTypeDescriptor * pEnclosingElementType) const;
6195 
6196 
6197  static CElement *
6198  s_construct (void);
6199 
6200  static void
6201  s_decodeFields (
6202  CDecoderStream * pDecoderStream,
6203  CElement * pElement);
6205 
6206 
6207  protected:
6208  EImpinjGPSCoordinatesMode m_eGPSCoordinatesMode;
6209 
6212  public:
6213  static const CFieldDescriptor
6214  s_fdGPSCoordinatesMode;
6216 
6218  inline EImpinjGPSCoordinatesMode
6220  {
6221  return m_eGPSCoordinatesMode;
6222  }
6223 
6225  inline void
6227  EImpinjGPSCoordinatesMode value)
6228  {
6229  m_eGPSCoordinatesMode = value;
6230  }
6231 
6232 
6233  protected:
6234  std::list<CParameter *> m_listCustom;
6235 
6236  public:
6238  inline std::list<CParameter *>::iterator
6240  {
6241  return m_listCustom.begin();
6242  }
6243 
6245  inline std::list<CParameter *>::iterator
6246  endCustom (void)
6247  {
6248  return m_listCustom.end();
6249  }
6250 
6252  inline void
6254  {
6255  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6256  }
6257 
6259  inline int
6261  {
6262  return (int) (m_listCustom.size());
6263  }
6264 
6265  EResultCode
6267  addCustom (
6268  CParameter * pValue);
6269 
6270 
6271 };
6272 
6273 
6299 class CImpinjSerializedTID : public CParameter
6300 {
6301  public:
6302  CImpinjSerializedTID (void);
6303  ~CImpinjSerializedTID (void);
6304 
6307 
6308  static const CFieldDescriptor * const
6309  s_apFieldDescriptorTable[];
6310 
6311  static const CTypeDescriptor
6312  s_typeDescriptor;
6313 
6314  void
6315  decodeFields (
6316  CDecoderStream * pDecoderStream);
6317 
6318  void
6319  assimilateSubParameters (
6320  CErrorDetails * pError);
6321 
6322  void
6323  encode (
6324  CEncoderStream * pEncoderStream) const;
6325 
6326 
6327  llrp_bool_t
6328  isAllowedIn (
6329  const CTypeDescriptor * pEnclosingElementType) const;
6330 
6331 
6332  static CElement *
6333  s_construct (void);
6334 
6335  static void
6336  s_decodeFields (
6337  CDecoderStream * pDecoderStream,
6338  CElement * pElement);
6340 
6341 
6342  protected:
6343  llrp_u16v_t m_TID;
6344 
6347  public:
6348  static const CFieldDescriptor
6349  s_fdTID;
6351 
6353  inline llrp_u16v_t
6354  getTID (void)
6355  {
6356  return m_TID;
6357  }
6358 
6360  inline void
6362  llrp_u16v_t value)
6363  {
6364  m_TID = value;
6365  }
6366 
6367 
6368  protected:
6369  CImpinjTIDParity * m_pImpinjTIDParity;
6370 
6371  public:
6373  inline CImpinjTIDParity *
6375  {
6376  return m_pImpinjTIDParity;
6377  }
6378 
6380  EResultCode
6382  CImpinjTIDParity * pValue);
6383 
6384 
6385  protected:
6386  std::list<CParameter *> m_listCustom;
6387 
6388  public:
6390  inline std::list<CParameter *>::iterator
6392  {
6393  return m_listCustom.begin();
6394  }
6395 
6397  inline std::list<CParameter *>::iterator
6398  endCustom (void)
6399  {
6400  return m_listCustom.end();
6401  }
6402 
6404  inline void
6406  {
6407  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6408  }
6409 
6411  inline int
6413  {
6414  return (int) (m_listCustom.size());
6415  }
6416 
6417  EResultCode
6419  addCustom (
6420  CParameter * pValue);
6421 
6422 
6423 };
6424 
6425 
6450 class CImpinjRFPhaseAngle : public CParameter
6451 {
6452  public:
6453  CImpinjRFPhaseAngle (void);
6454  ~CImpinjRFPhaseAngle (void);
6455 
6458 
6459  static const CFieldDescriptor * const
6460  s_apFieldDescriptorTable[];
6461 
6462  static const CTypeDescriptor
6463  s_typeDescriptor;
6464 
6465  void
6466  decodeFields (
6467  CDecoderStream * pDecoderStream);
6468 
6469  void
6470  assimilateSubParameters (
6471  CErrorDetails * pError);
6472 
6473  void
6474  encode (
6475  CEncoderStream * pEncoderStream) const;
6476 
6477 
6478  llrp_bool_t
6479  isAllowedIn (
6480  const CTypeDescriptor * pEnclosingElementType) const;
6481 
6482 
6483  static CElement *
6484  s_construct (void);
6485 
6486  static void
6487  s_decodeFields (
6488  CDecoderStream * pDecoderStream,
6489  CElement * pElement);
6491 
6492 
6493  protected:
6494  llrp_u16_t m_PhaseAngle;
6495 
6498  public:
6499  static const CFieldDescriptor
6500  s_fdPhaseAngle;
6502 
6504  inline llrp_u16_t
6506  {
6507  return m_PhaseAngle;
6508  }
6509 
6511  inline void
6513  llrp_u16_t value)
6514  {
6515  m_PhaseAngle = value;
6516  }
6517 
6518 
6519  protected:
6520  std::list<CParameter *> m_listCustom;
6521 
6522  public:
6524  inline std::list<CParameter *>::iterator
6526  {
6527  return m_listCustom.begin();
6528  }
6529 
6531  inline std::list<CParameter *>::iterator
6532  endCustom (void)
6533  {
6534  return m_listCustom.end();
6535  }
6536 
6538  inline void
6540  {
6541  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6542  }
6543 
6545  inline int
6547  {
6548  return (int) (m_listCustom.size());
6549  }
6550 
6551  EResultCode
6553  addCustom (
6554  CParameter * pValue);
6555 
6556 
6557 };
6558 
6559 
6584 class CImpinjPeakRSSI : public CParameter
6585 {
6586  public:
6587  CImpinjPeakRSSI (void);
6588  ~CImpinjPeakRSSI (void);
6589 
6592 
6593  static const CFieldDescriptor * const
6594  s_apFieldDescriptorTable[];
6595 
6596  static const CTypeDescriptor
6597  s_typeDescriptor;
6598 
6599  void
6600  decodeFields (
6601  CDecoderStream * pDecoderStream);
6602 
6603  void
6604  assimilateSubParameters (
6605  CErrorDetails * pError);
6606 
6607  void
6608  encode (
6609  CEncoderStream * pEncoderStream) const;
6610 
6611 
6612  llrp_bool_t
6613  isAllowedIn (
6614  const CTypeDescriptor * pEnclosingElementType) const;
6615 
6616 
6617  static CElement *
6618  s_construct (void);
6619 
6620  static void
6621  s_decodeFields (
6622  CDecoderStream * pDecoderStream,
6623  CElement * pElement);
6625 
6626 
6627  protected:
6628  llrp_s16_t m_RSSI;
6629 
6632  public:
6633  static const CFieldDescriptor
6634  s_fdRSSI;
6636 
6638  inline llrp_s16_t
6639  getRSSI (void)
6640  {
6641  return m_RSSI;
6642  }
6643 
6645  inline void
6647  llrp_s16_t value)
6648  {
6649  m_RSSI = value;
6650  }
6651 
6652 
6653  protected:
6654  std::list<CParameter *> m_listCustom;
6655 
6656  public:
6658  inline std::list<CParameter *>::iterator
6660  {
6661  return m_listCustom.begin();
6662  }
6663 
6665  inline std::list<CParameter *>::iterator
6666  endCustom (void)
6667  {
6668  return m_listCustom.end();
6669  }
6670 
6672  inline void
6674  {
6675  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6676  }
6677 
6679  inline int
6681  {
6682  return (int) (m_listCustom.size());
6683  }
6684 
6685  EResultCode
6687  addCustom (
6688  CParameter * pValue);
6689 
6690 
6691 };
6692 
6693 
6719 class CImpinjGPSCoordinates : public CParameter
6720 {
6721  public:
6722  CImpinjGPSCoordinates (void);
6723  ~CImpinjGPSCoordinates (void);
6724 
6727 
6728  static const CFieldDescriptor * const
6729  s_apFieldDescriptorTable[];
6730 
6731  static const CTypeDescriptor
6732  s_typeDescriptor;
6733 
6734  void
6735  decodeFields (
6736  CDecoderStream * pDecoderStream);
6737 
6738  void
6739  assimilateSubParameters (
6740  CErrorDetails * pError);
6741 
6742  void
6743  encode (
6744  CEncoderStream * pEncoderStream) const;
6745 
6746 
6747  llrp_bool_t
6748  isAllowedIn (
6749  const CTypeDescriptor * pEnclosingElementType) const;
6750 
6751 
6752  static CElement *
6753  s_construct (void);
6754 
6755  static void
6756  s_decodeFields (
6757  CDecoderStream * pDecoderStream,
6758  CElement * pElement);
6760 
6761 
6762  protected:
6763  llrp_s32_t m_Latitude;
6764 
6767  public:
6768  static const CFieldDescriptor
6769  s_fdLatitude;
6771 
6773  inline llrp_s32_t
6775  {
6776  return m_Latitude;
6777  }
6778 
6780  inline void
6782  llrp_s32_t value)
6783  {
6784  m_Latitude = value;
6785  }
6786 
6787 
6788  protected:
6789  llrp_s32_t m_Longitude;
6790 
6793  public:
6794  static const CFieldDescriptor
6795  s_fdLongitude;
6797 
6799  inline llrp_s32_t
6801  {
6802  return m_Longitude;
6803  }
6804 
6806  inline void
6808  llrp_s32_t value)
6809  {
6810  m_Longitude = value;
6811  }
6812 
6813 
6814  protected:
6815  std::list<CParameter *> m_listCustom;
6816 
6817  public:
6819  inline std::list<CParameter *>::iterator
6821  {
6822  return m_listCustom.begin();
6823  }
6824 
6826  inline std::list<CParameter *>::iterator
6827  endCustom (void)
6828  {
6829  return m_listCustom.end();
6830  }
6831 
6833  inline void
6835  {
6836  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6837  }
6838 
6840  inline int
6842  {
6843  return (int) (m_listCustom.size());
6844  }
6845 
6846  EResultCode
6848  addCustom (
6849  CParameter * pValue);
6850 
6851 
6852 };
6853 
6854 
6879 class CImpinjLoopSpec : public CParameter
6880 {
6881  public:
6882  CImpinjLoopSpec (void);
6883  ~CImpinjLoopSpec (void);
6884 
6887 
6888  static const CFieldDescriptor * const
6889  s_apFieldDescriptorTable[];
6890 
6891  static const CTypeDescriptor
6892  s_typeDescriptor;
6893 
6894  void
6895  decodeFields (
6896  CDecoderStream * pDecoderStream);
6897 
6898  void
6899  assimilateSubParameters (
6900  CErrorDetails * pError);
6901 
6902  void
6903  encode (
6904  CEncoderStream * pEncoderStream) const;
6905 
6906 
6907  llrp_bool_t
6908  isAllowedIn (
6909  const CTypeDescriptor * pEnclosingElementType) const;
6910 
6911 
6912  static CElement *
6913  s_construct (void);
6914 
6915  static void
6916  s_decodeFields (
6917  CDecoderStream * pDecoderStream,
6918  CElement * pElement);
6920 
6921 
6922  protected:
6923  llrp_u32_t m_LoopCount;
6924 
6927  public:
6928  static const CFieldDescriptor
6929  s_fdLoopCount;
6931 
6933  inline llrp_u32_t
6935  {
6936  return m_LoopCount;
6937  }
6938 
6940  inline void
6942  llrp_u32_t value)
6943  {
6944  m_LoopCount = value;
6945  }
6946 
6947 
6948  protected:
6949  std::list<CParameter *> m_listCustom;
6950 
6951  public:
6953  inline std::list<CParameter *>::iterator
6955  {
6956  return m_listCustom.begin();
6957  }
6958 
6960  inline std::list<CParameter *>::iterator
6961  endCustom (void)
6962  {
6963  return m_listCustom.end();
6964  }
6965 
6967  inline void
6969  {
6970  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6971  }
6972 
6974  inline int
6976  {
6977  return (int) (m_listCustom.size());
6978  }
6979 
6980  EResultCode
6982  addCustom (
6983  CParameter * pValue);
6984 
6985 
6986 };
6987 
6988 
7014 class CImpinjGPSNMEASentences : public CParameter
7015 {
7016  public:
7017  CImpinjGPSNMEASentences (void);
7018  ~CImpinjGPSNMEASentences (void);
7019 
7022 
7023  static const CFieldDescriptor * const
7024  s_apFieldDescriptorTable[];
7025 
7026  static const CTypeDescriptor
7027  s_typeDescriptor;
7028 
7029  void
7030  decodeFields (
7031  CDecoderStream * pDecoderStream);
7032 
7033  void
7034  assimilateSubParameters (
7035  CErrorDetails * pError);
7036 
7037  void
7038  encode (
7039  CEncoderStream * pEncoderStream) const;
7040 
7041 
7042  llrp_bool_t
7043  isAllowedIn (
7044  const CTypeDescriptor * pEnclosingElementType) const;
7045 
7046 
7047  static CElement *
7048  s_construct (void);
7049 
7050  static void
7051  s_decodeFields (
7052  CDecoderStream * pDecoderStream,
7053  CElement * pElement);
7055 
7056 
7057  protected:
7058  CImpinjGGASentence * m_pImpinjGGASentence;
7059 
7060  public:
7062  inline CImpinjGGASentence *
7064  {
7065  return m_pImpinjGGASentence;
7066  }
7067 
7069  EResultCode
7071  CImpinjGGASentence * pValue);
7072 
7073 
7074  protected:
7075  CImpinjRMCSentence * m_pImpinjRMCSentence;
7076 
7077  public:
7079  inline CImpinjRMCSentence *
7081  {
7082  return m_pImpinjRMCSentence;
7083  }
7084 
7086  EResultCode
7088  CImpinjRMCSentence * pValue);
7089 
7090 
7091  protected:
7092  std::list<CParameter *> m_listCustom;
7093 
7094  public:
7096  inline std::list<CParameter *>::iterator
7098  {
7099  return m_listCustom.begin();
7100  }
7101 
7103  inline std::list<CParameter *>::iterator
7104  endCustom (void)
7105  {
7106  return m_listCustom.end();
7107  }
7108 
7110  inline void
7112  {
7113  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7114  }
7115 
7117  inline int
7119  {
7120  return (int) (m_listCustom.size());
7121  }
7122 
7123  EResultCode
7125  addCustom (
7126  CParameter * pValue);
7127 
7128 
7129 };
7130 
7131 
7155 class CImpinjGGASentence : public CParameter
7156 {
7157  public:
7158  CImpinjGGASentence (void);
7159  ~CImpinjGGASentence (void);
7160 
7163 
7164  static const CFieldDescriptor * const
7165  s_apFieldDescriptorTable[];
7166 
7167  static const CTypeDescriptor
7168  s_typeDescriptor;
7169 
7170  void
7171  decodeFields (
7172  CDecoderStream * pDecoderStream);
7173 
7174  void
7175  assimilateSubParameters (
7176  CErrorDetails * pError);
7177 
7178  void
7179  encode (
7180  CEncoderStream * pEncoderStream) const;
7181 
7182 
7183  llrp_bool_t
7184  isAllowedIn (
7185  const CTypeDescriptor * pEnclosingElementType) const;
7186 
7187 
7188  static CElement *
7189  s_construct (void);
7190 
7191  static void
7192  s_decodeFields (
7193  CDecoderStream * pDecoderStream,
7194  CElement * pElement);
7196 
7197 
7198  protected:
7199  llrp_utf8v_t m_GGASentence;
7200 
7203  public:
7204  static const CFieldDescriptor
7205  s_fdGGASentence;
7207 
7209  inline llrp_utf8v_t
7211  {
7212  return m_GGASentence;
7213  }
7214 
7216  inline void
7218  llrp_utf8v_t value)
7219  {
7220  m_GGASentence = value;
7221  }
7222 
7223 
7224  protected:
7225  std::list<CParameter *> m_listCustom;
7226 
7227  public:
7229  inline std::list<CParameter *>::iterator
7231  {
7232  return m_listCustom.begin();
7233  }
7234 
7236  inline std::list<CParameter *>::iterator
7237  endCustom (void)
7238  {
7239  return m_listCustom.end();
7240  }
7241 
7243  inline void
7245  {
7246  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7247  }
7248 
7250  inline int
7252  {
7253  return (int) (m_listCustom.size());
7254  }
7255 
7256  EResultCode
7258  addCustom (
7259  CParameter * pValue);
7260 
7261 
7262 };
7263 
7264 
7288 class CImpinjRMCSentence : public CParameter
7289 {
7290  public:
7291  CImpinjRMCSentence (void);
7292  ~CImpinjRMCSentence (void);
7293 
7296 
7297  static const CFieldDescriptor * const
7298  s_apFieldDescriptorTable[];
7299 
7300  static const CTypeDescriptor
7301  s_typeDescriptor;
7302 
7303  void
7304  decodeFields (
7305  CDecoderStream * pDecoderStream);
7306 
7307  void
7308  assimilateSubParameters (
7309  CErrorDetails * pError);
7310 
7311  void
7312  encode (
7313  CEncoderStream * pEncoderStream) const;
7314 
7315 
7316  llrp_bool_t
7317  isAllowedIn (
7318  const CTypeDescriptor * pEnclosingElementType) const;
7319 
7320 
7321  static CElement *
7322  s_construct (void);
7323 
7324  static void
7325  s_decodeFields (
7326  CDecoderStream * pDecoderStream,
7327  CElement * pElement);
7329 
7330 
7331  protected:
7332  llrp_utf8v_t m_RMCSentence;
7333 
7336  public:
7337  static const CFieldDescriptor
7338  s_fdRMCSentence;
7340 
7342  inline llrp_utf8v_t
7344  {
7345  return m_RMCSentence;
7346  }
7347 
7349  inline void
7351  llrp_utf8v_t value)
7352  {
7353  m_RMCSentence = value;
7354  }
7355 
7356 
7357  protected:
7358  std::list<CParameter *> m_listCustom;
7359 
7360  public:
7362  inline std::list<CParameter *>::iterator
7364  {
7365  return m_listCustom.begin();
7366  }
7367 
7369  inline std::list<CParameter *>::iterator
7370  endCustom (void)
7371  {
7372  return m_listCustom.end();
7373  }
7374 
7376  inline void
7378  {
7379  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7380  }
7381 
7383  inline int
7385  {
7386  return (int) (m_listCustom.size());
7387  }
7388 
7389  EResultCode
7391  addCustom (
7392  CParameter * pValue);
7393 
7394 
7395 };
7396 
7397 
7421 class CImpinjOpSpecRetryCount : public CParameter
7422 {
7423  public:
7424  CImpinjOpSpecRetryCount (void);
7425  ~CImpinjOpSpecRetryCount (void);
7426 
7429 
7430  static const CFieldDescriptor * const
7431  s_apFieldDescriptorTable[];
7432 
7433  static const CTypeDescriptor
7434  s_typeDescriptor;
7435 
7436  void
7437  decodeFields (
7438  CDecoderStream * pDecoderStream);
7439 
7440  void
7441  assimilateSubParameters (
7442  CErrorDetails * pError);
7443 
7444  void
7445  encode (
7446  CEncoderStream * pEncoderStream) const;
7447 
7448 
7449  llrp_bool_t
7450  isAllowedIn (
7451  const CTypeDescriptor * pEnclosingElementType) const;
7452 
7453 
7454  static CElement *
7455  s_construct (void);
7456 
7457  static void
7458  s_decodeFields (
7459  CDecoderStream * pDecoderStream,
7460  CElement * pElement);
7462 
7463 
7464  protected:
7465  llrp_u16_t m_RetryCount;
7466 
7469  public:
7470  static const CFieldDescriptor
7471  s_fdRetryCount;
7473 
7475  inline llrp_u16_t
7477  {
7478  return m_RetryCount;
7479  }
7480 
7482  inline void
7484  llrp_u16_t value)
7485  {
7486  m_RetryCount = value;
7487  }
7488 
7489 
7490  protected:
7491  std::list<CParameter *> m_listCustom;
7492 
7493  public:
7495  inline std::list<CParameter *>::iterator
7497  {
7498  return m_listCustom.begin();
7499  }
7500 
7502  inline std::list<CParameter *>::iterator
7503  endCustom (void)
7504  {
7505  return m_listCustom.end();
7506  }
7507 
7509  inline void
7511  {
7512  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7513  }
7514 
7516  inline int
7518  {
7519  return (int) (m_listCustom.size());
7520  }
7521 
7522  EResultCode
7524  addCustom (
7525  CParameter * pValue);
7526 
7527 
7528 };
7529 
7530 
7558 class CImpinjAdvancedGPOConfiguration : public CParameter
7559 {
7560  public:
7563 
7566 
7567  static const CFieldDescriptor * const
7568  s_apFieldDescriptorTable[];
7569 
7570  static const CTypeDescriptor
7571  s_typeDescriptor;
7572 
7573  void
7574  decodeFields (
7575  CDecoderStream * pDecoderStream);
7576 
7577  void
7578  assimilateSubParameters (
7579  CErrorDetails * pError);
7580 
7581  void
7582  encode (
7583  CEncoderStream * pEncoderStream) const;
7584 
7585 
7586  llrp_bool_t
7587  isAllowedIn (
7588  const CTypeDescriptor * pEnclosingElementType) const;
7589 
7590 
7591  static CElement *
7592  s_construct (void);
7593 
7594  static void
7595  s_decodeFields (
7596  CDecoderStream * pDecoderStream,
7597  CElement * pElement);
7599 
7600 
7601  protected:
7602  llrp_u16_t m_GPOPortNum;
7603 
7606  public:
7607  static const CFieldDescriptor
7608  s_fdGPOPortNum;
7610 
7612  inline llrp_u16_t
7614  {
7615  return m_GPOPortNum;
7616  }
7617 
7619  inline void
7621  llrp_u16_t value)
7622  {
7623  m_GPOPortNum = value;
7624  }
7625 
7626 
7627  protected:
7628  EImpinjAdvancedGPOMode m_eGPOMode;
7629 
7632  public:
7633  static const CFieldDescriptor
7634  s_fdGPOMode;
7636 
7638  inline EImpinjAdvancedGPOMode
7639  getGPOMode (void)
7640  {
7641  return m_eGPOMode;
7642  }
7643 
7645  inline void
7647  EImpinjAdvancedGPOMode value)
7648  {
7649  m_eGPOMode = value;
7650  }
7651 
7652 
7653  protected:
7654  llrp_u32_t m_GPOPulseDurationMSec;
7655 
7658  public:
7659  static const CFieldDescriptor
7660  s_fdGPOPulseDurationMSec;
7662 
7664  inline llrp_u32_t
7666  {
7667  return m_GPOPulseDurationMSec;
7668  }
7669 
7671  inline void
7673  llrp_u32_t value)
7674  {
7675  m_GPOPulseDurationMSec = value;
7676  }
7677 
7678 
7679  protected:
7680  std::list<CParameter *> m_listCustom;
7681 
7682  public:
7684  inline std::list<CParameter *>::iterator
7686  {
7687  return m_listCustom.begin();
7688  }
7689 
7691  inline std::list<CParameter *>::iterator
7692  endCustom (void)
7693  {
7694  return m_listCustom.end();
7695  }
7696 
7698  inline void
7700  {
7701  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7702  }
7703 
7705  inline int
7707  {
7708  return (int) (m_listCustom.size());
7709  }
7710 
7711  EResultCode
7713  addCustom (
7714  CParameter * pValue);
7715 
7716 
7717 };
7718 
7719 
7753 class CImpinjEnableOptimizedRead : public CParameter
7754 {
7755  public:
7758 
7761 
7762  static const CFieldDescriptor * const
7763  s_apFieldDescriptorTable[];
7764 
7765  static const CTypeDescriptor
7766  s_typeDescriptor;
7767 
7768  void
7769  decodeFields (
7770  CDecoderStream * pDecoderStream);
7771 
7772  void
7773  assimilateSubParameters (
7774  CErrorDetails * pError);
7775 
7776  void
7777  encode (
7778  CEncoderStream * pEncoderStream) const;
7779 
7780 
7781  llrp_bool_t
7782  isAllowedIn (
7783  const CTypeDescriptor * pEnclosingElementType) const;
7784 
7785 
7786  static CElement *
7787  s_construct (void);
7788 
7789  static void
7790  s_decodeFields (
7791  CDecoderStream * pDecoderStream,
7792  CElement * pElement);
7794 
7795 
7796  protected:
7797  EImpinjOptimizedReadMode m_eOptimizedReadMode;
7798 
7801  public:
7802  static const CFieldDescriptor
7803  s_fdOptimizedReadMode;
7805 
7807  inline EImpinjOptimizedReadMode
7809  {
7810  return m_eOptimizedReadMode;
7811  }
7812 
7814  inline void
7816  EImpinjOptimizedReadMode value)
7817  {
7818  m_eOptimizedReadMode = value;
7819  }
7820 
7821 
7822  protected:
7823  std::list<CC1G2Read *> m_listC1G2Read;
7824 
7825  public:
7827  inline std::list<CC1G2Read *>::iterator
7829  {
7830  return m_listC1G2Read.begin();
7831  }
7832 
7834  inline std::list<CC1G2Read *>::iterator
7836  {
7837  return m_listC1G2Read.end();
7838  }
7839 
7841  inline void
7843  {
7844  clearSubParameterList ((tListOfParameters *) &m_listC1G2Read);
7845  }
7846 
7848  inline int
7850  {
7851  return (int) (m_listC1G2Read.size());
7852  }
7853 
7854  EResultCode
7856  addC1G2Read (
7857  CC1G2Read * pValue);
7858 
7859 
7860  protected:
7861  std::list<CParameter *> m_listCustom;
7862 
7863  public:
7865  inline std::list<CParameter *>::iterator
7867  {
7868  return m_listCustom.begin();
7869  }
7870 
7872  inline std::list<CParameter *>::iterator
7873  endCustom (void)
7874  {
7875  return m_listCustom.end();
7876  }
7877 
7879  inline void
7881  {
7882  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7883  }
7884 
7886  inline int
7888  {
7889  return (int) (m_listCustom.size());
7890  }
7891 
7892  EResultCode
7894  addCustom (
7895  CParameter * pValue);
7896 
7897 
7898 };
7899 
7900 
7927 class CImpinjAccessSpecOrdering : public CParameter
7928 {
7929  public:
7931  ~CImpinjAccessSpecOrdering (void);
7932 
7935 
7936  static const CFieldDescriptor * const
7937  s_apFieldDescriptorTable[];
7938 
7939  static const CTypeDescriptor
7940  s_typeDescriptor;
7941 
7942  void
7943  decodeFields (
7944  CDecoderStream * pDecoderStream);
7945 
7946  void
7947  assimilateSubParameters (
7948  CErrorDetails * pError);
7949 
7950  void
7951  encode (
7952  CEncoderStream * pEncoderStream) const;
7953 
7954 
7955  llrp_bool_t
7956  isAllowedIn (
7957  const CTypeDescriptor * pEnclosingElementType) const;
7958 
7959 
7960  static CElement *
7961  s_construct (void);
7962 
7963  static void
7964  s_decodeFields (
7965  CDecoderStream * pDecoderStream,
7966  CElement * pElement);
7968 
7969 
7970  protected:
7971  EImpinjAccessSpecOrderingMode m_eOrderingMode;
7972 
7975  public:
7976  static const CFieldDescriptor
7977  s_fdOrderingMode;
7979 
7981  inline EImpinjAccessSpecOrderingMode
7983  {
7984  return m_eOrderingMode;
7985  }
7986 
7988  inline void
7990  EImpinjAccessSpecOrderingMode value)
7991  {
7992  m_eOrderingMode = value;
7993  }
7994 
7995 
7996  protected:
7997  std::list<CParameter *> m_listCustom;
7998 
7999  public:
8001  inline std::list<CParameter *>::iterator
8003  {
8004  return m_listCustom.begin();
8005  }
8006 
8008  inline std::list<CParameter *>::iterator
8009  endCustom (void)
8010  {
8011  return m_listCustom.end();
8012  }
8013 
8015  inline void
8017  {
8018  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8019  }
8020 
8022  inline int
8024  {
8025  return (int) (m_listCustom.size());
8026  }
8027 
8028  EResultCode
8030  addCustom (
8031  CParameter * pValue);
8032 
8033 
8034 };
8035 
8036 
8060 class CImpinjEnableRFDopplerFrequency : public CParameter
8061 {
8062  public:
8065 
8068 
8069  static const CFieldDescriptor * const
8070  s_apFieldDescriptorTable[];
8071 
8072  static const CTypeDescriptor
8073  s_typeDescriptor;
8074 
8075  void
8076  decodeFields (
8077  CDecoderStream * pDecoderStream);
8078 
8079  void
8080  assimilateSubParameters (
8081  CErrorDetails * pError);
8082 
8083  void
8084  encode (
8085  CEncoderStream * pEncoderStream) const;
8086 
8087 
8088  llrp_bool_t
8089  isAllowedIn (
8090  const CTypeDescriptor * pEnclosingElementType) const;
8091 
8092 
8093  static CElement *
8094  s_construct (void);
8095 
8096  static void
8097  s_decodeFields (
8098  CDecoderStream * pDecoderStream,
8099  CElement * pElement);
8101 
8102 
8103  protected:
8104  EImpinjRFDopplerFrequencyMode m_eRFDopplerFrequencyMode;
8105 
8108  public:
8109  static const CFieldDescriptor
8110  s_fdRFDopplerFrequencyMode;
8112 
8114  inline EImpinjRFDopplerFrequencyMode
8116  {
8117  return m_eRFDopplerFrequencyMode;
8118  }
8119 
8121  inline void
8123  EImpinjRFDopplerFrequencyMode value)
8124  {
8125  m_eRFDopplerFrequencyMode = value;
8126  }
8127 
8128 
8129  protected:
8130  std::list<CParameter *> m_listCustom;
8131 
8132  public:
8134  inline std::list<CParameter *>::iterator
8136  {
8137  return m_listCustom.begin();
8138  }
8139 
8141  inline std::list<CParameter *>::iterator
8142  endCustom (void)
8143  {
8144  return m_listCustom.end();
8145  }
8146 
8148  inline void
8150  {
8151  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8152  }
8153 
8155  inline int
8157  {
8158  return (int) (m_listCustom.size());
8159  }
8160 
8161  EResultCode
8163  addCustom (
8164  CParameter * pValue);
8165 
8166 
8167 };
8168 
8169 
8194 class CImpinjRFDopplerFrequency : public CParameter
8195 {
8196  public:
8198  ~CImpinjRFDopplerFrequency (void);
8199 
8202 
8203  static const CFieldDescriptor * const
8204  s_apFieldDescriptorTable[];
8205 
8206  static const CTypeDescriptor
8207  s_typeDescriptor;
8208 
8209  void
8210  decodeFields (
8211  CDecoderStream * pDecoderStream);
8212 
8213  void
8214  assimilateSubParameters (
8215  CErrorDetails * pError);
8216 
8217  void
8218  encode (
8219  CEncoderStream * pEncoderStream) const;
8220 
8221 
8222  llrp_bool_t
8223  isAllowedIn (
8224  const CTypeDescriptor * pEnclosingElementType) const;
8225 
8226 
8227  static CElement *
8228  s_construct (void);
8229 
8230  static void
8231  s_decodeFields (
8232  CDecoderStream * pDecoderStream,
8233  CElement * pElement);
8235 
8236 
8237  protected:
8238  llrp_s16_t m_DopplerFrequency;
8239 
8242  public:
8243  static const CFieldDescriptor
8244  s_fdDopplerFrequency;
8246 
8248  inline llrp_s16_t
8250  {
8251  return m_DopplerFrequency;
8252  }
8253 
8255  inline void
8257  llrp_s16_t value)
8258  {
8259  m_DopplerFrequency = value;
8260  }
8261 
8262 
8263  protected:
8264  std::list<CParameter *> m_listCustom;
8265 
8266  public:
8268  inline std::list<CParameter *>::iterator
8270  {
8271  return m_listCustom.begin();
8272  }
8273 
8275  inline std::list<CParameter *>::iterator
8276  endCustom (void)
8277  {
8278  return m_listCustom.end();
8279  }
8280 
8282  inline void
8284  {
8285  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8286  }
8287 
8289  inline int
8291  {
8292  return (int) (m_listCustom.size());
8293  }
8294 
8295  EResultCode
8297  addCustom (
8298  CParameter * pValue);
8299 
8300 
8301 };
8302 
8303 
8336 class CImpinjInventoryConfiguration : public CParameter
8337 {
8338  public:
8341 
8344 
8345  static const CFieldDescriptor * const
8346  s_apFieldDescriptorTable[];
8347 
8348  static const CTypeDescriptor
8349  s_typeDescriptor;
8350 
8351  void
8352  decodeFields (
8353  CDecoderStream * pDecoderStream);
8354 
8355  void
8356  assimilateSubParameters (
8357  CErrorDetails * pError);
8358 
8359  void
8360  encode (
8361  CEncoderStream * pEncoderStream) const;
8362 
8363 
8364  llrp_bool_t
8365  isAllowedIn (
8366  const CTypeDescriptor * pEnclosingElementType) const;
8367 
8368 
8369  static CElement *
8370  s_construct (void);
8371 
8372  static void
8373  s_decodeFields (
8374  CDecoderStream * pDecoderStream,
8375  CElement * pElement);
8377 
8378 
8379  protected:
8380  llrp_u1_t m_EnableAntDwellTimeLimit;
8381 
8384  public:
8385  static const CFieldDescriptor
8386  s_fdEnableAntDwellTimeLimit;
8388 
8390  inline llrp_u1_t
8392  {
8393  return m_EnableAntDwellTimeLimit;
8394  }
8395 
8397  inline void
8399  llrp_u1_t value)
8400  {
8401  m_EnableAntDwellTimeLimit = value;
8402  }
8403 
8404 
8405  protected:
8406  llrp_u1_t m_EnableSelectGapClose;
8407 
8410  public:
8411  static const CFieldDescriptor
8412  s_fdEnableSelectGapClose;
8414 
8416  inline llrp_u1_t
8418  {
8419  return m_EnableSelectGapClose;
8420  }
8421 
8423  inline void
8425  llrp_u1_t value)
8426  {
8427  m_EnableSelectGapClose = value;
8428  }
8429 
8430 
8431  protected:
8432  std::list<CParameter *> m_listCustom;
8433 
8434  public:
8436  inline std::list<CParameter *>::iterator
8438  {
8439  return m_listCustom.begin();
8440  }
8441 
8443  inline std::list<CParameter *>::iterator
8444  endCustom (void)
8445  {
8446  return m_listCustom.end();
8447  }
8448 
8450  inline void
8452  {
8453  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8454  }
8455 
8457  inline int
8459  {
8460  return (int) (m_listCustom.size());
8461  }
8462 
8463  EResultCode
8465  addCustom (
8466  CParameter * pValue);
8467 
8468 
8469 };
8470 
8471 
8498 class CImpinjArrayVersion : public CParameter
8499 {
8500  public:
8501  CImpinjArrayVersion (void);
8502  ~CImpinjArrayVersion (void);
8503 
8506 
8507  static const CFieldDescriptor * const
8508  s_apFieldDescriptorTable[];
8509 
8510  static const CTypeDescriptor
8511  s_typeDescriptor;
8512 
8513  void
8514  decodeFields (
8515  CDecoderStream * pDecoderStream);
8516 
8517  void
8518  assimilateSubParameters (
8519  CErrorDetails * pError);
8520 
8521  void
8522  encode (
8523  CEncoderStream * pEncoderStream) const;
8524 
8525 
8526  llrp_bool_t
8527  isAllowedIn (
8528  const CTypeDescriptor * pEnclosingElementType) const;
8529 
8530 
8531  static CElement *
8532  s_construct (void);
8533 
8534  static void
8535  s_decodeFields (
8536  CDecoderStream * pDecoderStream,
8537  CElement * pElement);
8539 
8540 
8541  protected:
8542  llrp_utf8v_t m_SerialNumber;
8543 
8546  public:
8547  static const CFieldDescriptor
8548  s_fdSerialNumber;
8550 
8552  inline llrp_utf8v_t
8554  {
8555  return m_SerialNumber;
8556  }
8557 
8559  inline void
8561  llrp_utf8v_t value)
8562  {
8563  m_SerialNumber = value;
8564  }
8565 
8566 
8567  protected:
8568  llrp_utf8v_t m_FirmwareVersion;
8569 
8572  public:
8573  static const CFieldDescriptor
8574  s_fdFirmwareVersion;
8576 
8578  inline llrp_utf8v_t
8580  {
8581  return m_FirmwareVersion;
8582  }
8583 
8585  inline void
8587  llrp_utf8v_t value)
8588  {
8589  m_FirmwareVersion = value;
8590  }
8591 
8592 
8593  protected:
8594  llrp_utf8v_t m_PCBAVersion;
8595 
8598  public:
8599  static const CFieldDescriptor
8600  s_fdPCBAVersion;
8602 
8604  inline llrp_utf8v_t
8606  {
8607  return m_PCBAVersion;
8608  }
8609 
8611  inline void
8613  llrp_utf8v_t value)
8614  {
8615  m_PCBAVersion = value;
8616  }
8617 
8618 
8619  protected:
8620  std::list<CParameter *> m_listCustom;
8621 
8622  public:
8624  inline std::list<CParameter *>::iterator
8626  {
8627  return m_listCustom.begin();
8628  }
8629 
8631  inline std::list<CParameter *>::iterator
8632  endCustom (void)
8633  {
8634  return m_listCustom.end();
8635  }
8636 
8638  inline void
8640  {
8641  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8642  }
8643 
8645  inline int
8647  {
8648  return (int) (m_listCustom.size());
8649  }
8650 
8651  EResultCode
8653  addCustom (
8654  CParameter * pValue);
8655 
8656 
8657 };
8658 
8659 
8692 class CImpinjxArrayCapabilities : public CParameter
8693 {
8694  public:
8696  ~CImpinjxArrayCapabilities (void);
8697 
8700 
8701  static const CFieldDescriptor * const
8702  s_apFieldDescriptorTable[];
8703 
8704  static const CTypeDescriptor
8705  s_typeDescriptor;
8706 
8707  void
8708  decodeFields (
8709  CDecoderStream * pDecoderStream);
8710 
8711  void
8712  assimilateSubParameters (
8713  CErrorDetails * pError);
8714 
8715  void
8716  encode (
8717  CEncoderStream * pEncoderStream) const;
8718 
8719 
8720  llrp_bool_t
8721  isAllowedIn (
8722  const CTypeDescriptor * pEnclosingElementType) const;
8723 
8724 
8725  static CElement *
8726  s_construct (void);
8727 
8728  static void
8729  s_decodeFields (
8730  CDecoderStream * pDecoderStream,
8731  CElement * pElement);
8733 
8734 
8735  protected:
8736  llrp_u32_t m_MaxNumSectors;
8737 
8740  public:
8741  static const CFieldDescriptor
8742  s_fdMaxNumSectors;
8744 
8746  inline llrp_u32_t
8748  {
8749  return m_MaxNumSectors;
8750  }
8751 
8753  inline void
8755  llrp_u32_t value)
8756  {
8757  m_MaxNumSectors = value;
8758  }
8759 
8760 
8761  protected:
8762  llrp_u1_t m_SupportsLISpecs;
8763 
8766  public:
8767  static const CFieldDescriptor
8768  s_fdSupportsLISpecs;
8770 
8772  inline llrp_u1_t
8774  {
8775  return m_SupportsLISpecs;
8776  }
8777 
8779  inline void
8781  llrp_u1_t value)
8782  {
8783  m_SupportsLISpecs = value;
8784  }
8785 
8786 
8787  protected:
8788  llrp_u1_t m_SupportsTISpecs;
8789 
8792  public:
8793  static const CFieldDescriptor
8794  s_fdSupportsTISpecs;
8796 
8798  inline llrp_u1_t
8800  {
8801  return m_SupportsTISpecs;
8802  }
8803 
8805  inline void
8807  llrp_u1_t value)
8808  {
8809  m_SupportsTISpecs = value;
8810  }
8811 
8812 
8813  protected:
8814  llrp_u1_t m_SupportsTSISpecs;
8815 
8818  public:
8819  static const CFieldDescriptor
8820  s_fdSupportsTSISpecs;
8822 
8824  inline llrp_u1_t
8826  {
8827  return m_SupportsTSISpecs;
8828  }
8829 
8831  inline void
8833  llrp_u1_t value)
8834  {
8835  m_SupportsTSISpecs = value;
8836  }
8837 
8838 
8839  protected:
8840  llrp_u1_t m_SupportsDISpecs;
8841 
8844  public:
8845  static const CFieldDescriptor
8846  s_fdSupportsDISpecs;
8848 
8850  inline llrp_u1_t
8852  {
8853  return m_SupportsDISpecs;
8854  }
8855 
8857  inline void
8859  llrp_u1_t value)
8860  {
8861  m_SupportsDISpecs = value;
8862  }
8863 
8864 
8865  protected:
8866  CImpinjxArrayDirectionCapabilities * m_pImpinjxArrayDirectionCapabilities;
8867 
8868  public:
8872  {
8873  return m_pImpinjxArrayDirectionCapabilities;
8874  }
8875 
8877  EResultCode
8880 
8881 
8882  protected:
8883  std::list<CParameter *> m_listCustom;
8884 
8885  public:
8887  inline std::list<CParameter *>::iterator
8889  {
8890  return m_listCustom.begin();
8891  }
8892 
8894  inline std::list<CParameter *>::iterator
8895  endCustom (void)
8896  {
8897  return m_listCustom.end();
8898  }
8899 
8901  inline void
8903  {
8904  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8905  }
8906 
8908  inline int
8910  {
8911  return (int) (m_listCustom.size());
8912  }
8913 
8914  EResultCode
8916  addCustom (
8917  CParameter * pValue);
8918 
8919 
8920 };
8921 
8922 
8950 class CImpinjTiltConfiguration : public CParameter
8951 {
8952  public:
8953  CImpinjTiltConfiguration (void);
8954  ~CImpinjTiltConfiguration (void);
8955 
8958 
8959  static const CFieldDescriptor * const
8960  s_apFieldDescriptorTable[];
8961 
8962  static const CTypeDescriptor
8963  s_typeDescriptor;
8964 
8965  void
8966  decodeFields (
8967  CDecoderStream * pDecoderStream);
8968 
8969  void
8970  assimilateSubParameters (
8971  CErrorDetails * pError);
8972 
8973  void
8974  encode (
8975  CEncoderStream * pEncoderStream) const;
8976 
8977 
8978  llrp_bool_t
8979  isAllowedIn (
8980  const CTypeDescriptor * pEnclosingElementType) const;
8981 
8982 
8983  static CElement *
8984  s_construct (void);
8985 
8986  static void
8987  s_decodeFields (
8988  CDecoderStream * pDecoderStream,
8989  CElement * pElement);
8991 
8992 
8993  protected:
8994  llrp_s32_t m_XAxis;
8995 
8998  public:
8999  static const CFieldDescriptor
9000  s_fdXAxis;
9002 
9004  inline llrp_s32_t
9005  getXAxis (void)
9006  {
9007  return m_XAxis;
9008  }
9009 
9011  inline void
9013  llrp_s32_t value)
9014  {
9015  m_XAxis = value;
9016  }
9017 
9018 
9019  protected:
9020  llrp_s32_t m_YAxis;
9021 
9024  public:
9025  static const CFieldDescriptor
9026  s_fdYAxis;
9028 
9030  inline llrp_s32_t
9031  getYAxis (void)
9032  {
9033  return m_YAxis;
9034  }
9035 
9037  inline void
9039  llrp_s32_t value)
9040  {
9041  m_YAxis = value;
9042  }
9043 
9044 
9045  protected:
9046  llrp_s32_t m_ZAxis;
9047 
9050  public:
9051  static const CFieldDescriptor
9052  s_fdZAxis;
9054 
9056  inline llrp_s32_t
9057  getZAxis (void)
9058  {
9059  return m_ZAxis;
9060  }
9061 
9063  inline void
9065  llrp_s32_t value)
9066  {
9067  m_ZAxis = value;
9068  }
9069 
9070 
9071  protected:
9072  std::list<CParameter *> m_listCustom;
9073 
9074  public:
9076  inline std::list<CParameter *>::iterator
9078  {
9079  return m_listCustom.begin();
9080  }
9081 
9083  inline std::list<CParameter *>::iterator
9084  endCustom (void)
9085  {
9086  return m_listCustom.end();
9087  }
9088 
9090  inline void
9092  {
9093  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9094  }
9095 
9097  inline int
9099  {
9100  return (int) (m_listCustom.size());
9101  }
9102 
9103  EResultCode
9105  addCustom (
9106  CParameter * pValue);
9107 
9108 
9109 };
9110 
9111 
9140 class CImpinjBeaconConfiguration : public CParameter
9141 {
9142  public:
9145 
9148 
9149  static const CFieldDescriptor * const
9150  s_apFieldDescriptorTable[];
9151 
9152  static const CTypeDescriptor
9153  s_typeDescriptor;
9154 
9155  void
9156  decodeFields (
9157  CDecoderStream * pDecoderStream);
9158 
9159  void
9160  assimilateSubParameters (
9161  CErrorDetails * pError);
9162 
9163  void
9164  encode (
9165  CEncoderStream * pEncoderStream) const;
9166 
9167 
9168  llrp_bool_t
9169  isAllowedIn (
9170  const CTypeDescriptor * pEnclosingElementType) const;
9171 
9172 
9173  static CElement *
9174  s_construct (void);
9175 
9176  static void
9177  s_decodeFields (
9178  CDecoderStream * pDecoderStream,
9179  CElement * pElement);
9181 
9182 
9183  protected:
9184  llrp_u1_t m_BeaconState;
9185 
9188  public:
9189  static const CFieldDescriptor
9190  s_fdBeaconState;
9192 
9194  inline llrp_u1_t
9196  {
9197  return m_BeaconState;
9198  }
9199 
9201  inline void
9203  llrp_u1_t value)
9204  {
9205  m_BeaconState = value;
9206  }
9207 
9208 
9209  protected:
9210  llrp_u64_t m_BeaconDurationSeconds;
9211 
9214  public:
9215  static const CFieldDescriptor
9216  s_fdBeaconDurationSeconds;
9218 
9220  inline llrp_u64_t
9222  {
9223  return m_BeaconDurationSeconds;
9224  }
9225 
9227  inline void
9229  llrp_u64_t value)
9230  {
9231  m_BeaconDurationSeconds = value;
9232  }
9233 
9234 
9235  protected:
9236  std::list<CParameter *> m_listCustom;
9237 
9238  public:
9240  inline std::list<CParameter *>::iterator
9242  {
9243  return m_listCustom.begin();
9244  }
9245 
9247  inline std::list<CParameter *>::iterator
9248  endCustom (void)
9249  {
9250  return m_listCustom.end();
9251  }
9252 
9254  inline void
9256  {
9257  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9258  }
9259 
9261  inline int
9263  {
9264  return (int) (m_listCustom.size());
9265  }
9266 
9267  EResultCode
9269  addCustom (
9270  CParameter * pValue);
9271 
9272 
9273 };
9274 
9275 
9303 class CImpinjAntennaConfiguration : public CParameter
9304 {
9305  public:
9308 
9311 
9312  static const CFieldDescriptor * const
9313  s_apFieldDescriptorTable[];
9314 
9315  static const CTypeDescriptor
9316  s_typeDescriptor;
9317 
9318  void
9319  decodeFields (
9320  CDecoderStream * pDecoderStream);
9321 
9322  void
9323  assimilateSubParameters (
9324  CErrorDetails * pError);
9325 
9326  void
9327  encode (
9328  CEncoderStream * pEncoderStream) const;
9329 
9330 
9331  llrp_bool_t
9332  isAllowedIn (
9333  const CTypeDescriptor * pEnclosingElementType) const;
9334 
9335 
9336  static CElement *
9337  s_construct (void);
9338 
9339  static void
9340  s_decodeFields (
9341  CDecoderStream * pDecoderStream,
9342  CElement * pElement);
9344 
9345 
9346  protected:
9347  CImpinjAntennaEventHysteresis * m_pImpinjAntennaEventHysteresis;
9348 
9349  public:
9353  {
9354  return m_pImpinjAntennaEventHysteresis;
9355  }
9356 
9358  EResultCode
9361 
9362 
9363  protected:
9364  CImpinjAntennaEventConfiguration * m_pImpinjAntennaEventConfiguration;
9365 
9366  public:
9370  {
9371  return m_pImpinjAntennaEventConfiguration;
9372  }
9373 
9375  EResultCode
9378 
9379 
9380  protected:
9381  std::list<CParameter *> m_listCustom;
9382 
9383  public:
9385  inline std::list<CParameter *>::iterator
9387  {
9388  return m_listCustom.begin();
9389  }
9390 
9392  inline std::list<CParameter *>::iterator
9393  endCustom (void)
9394  {
9395  return m_listCustom.end();
9396  }
9397 
9399  inline void
9401  {
9402  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9403  }
9404 
9406  inline int
9408  {
9409  return (int) (m_listCustom.size());
9410  }
9411 
9412  EResultCode
9414  addCustom (
9415  CParameter * pValue);
9416 
9417 
9418 };
9419 
9420 
9452 class CImpinjAntennaEventHysteresis : public CParameter
9453 {
9454  public:
9457 
9460 
9461  static const CFieldDescriptor * const
9462  s_apFieldDescriptorTable[];
9463 
9464  static const CTypeDescriptor
9465  s_typeDescriptor;
9466 
9467  void
9468  decodeFields (
9469  CDecoderStream * pDecoderStream);
9470 
9471  void
9472  assimilateSubParameters (
9473  CErrorDetails * pError);
9474 
9475  void
9476  encode (
9477  CEncoderStream * pEncoderStream) const;
9478 
9479 
9480  llrp_bool_t
9481  isAllowedIn (
9482  const CTypeDescriptor * pEnclosingElementType) const;
9483 
9484 
9485  static CElement *
9486  s_construct (void);
9487 
9488  static void
9489  s_decodeFields (
9490  CDecoderStream * pDecoderStream,
9491  CElement * pElement);
9493 
9494 
9495  protected:
9496  llrp_u64_t m_AntennaEventConnected;
9497 
9500  public:
9501  static const CFieldDescriptor
9502  s_fdAntennaEventConnected;
9504 
9506  inline llrp_u64_t
9508  {
9509  return m_AntennaEventConnected;
9510  }
9511 
9513  inline void
9515  llrp_u64_t value)
9516  {
9517  m_AntennaEventConnected = value;
9518  }
9519 
9520 
9521  protected:
9522  llrp_u64_t m_AntennaEventDisconnected;
9523 
9526  public:
9527  static const CFieldDescriptor
9528  s_fdAntennaEventDisconnected;
9530 
9532  inline llrp_u64_t
9534  {
9535  return m_AntennaEventDisconnected;
9536  }
9537 
9539  inline void
9541  llrp_u64_t value)
9542  {
9543  m_AntennaEventDisconnected = value;
9544  }
9545 
9546 
9547  protected:
9548  std::list<CParameter *> m_listCustom;
9549 
9550  public:
9552  inline std::list<CParameter *>::iterator
9554  {
9555  return m_listCustom.begin();
9556  }
9557 
9559  inline std::list<CParameter *>::iterator
9560  endCustom (void)
9561  {
9562  return m_listCustom.end();
9563  }
9564 
9566  inline void
9568  {
9569  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9570  }
9571 
9573  inline int
9575  {
9576  return (int) (m_listCustom.size());
9577  }
9578 
9579  EResultCode
9581  addCustom (
9582  CParameter * pValue);
9583 
9584 
9585 };
9586 
9587 
9613 class CImpinjAntennaEventConfiguration : public CParameter
9614 {
9615  public:
9618 
9621 
9622  static const CFieldDescriptor * const
9623  s_apFieldDescriptorTable[];
9624 
9625  static const CTypeDescriptor
9626  s_typeDescriptor;
9627 
9628  void
9629  decodeFields (
9630  CDecoderStream * pDecoderStream);
9631 
9632  void
9633  assimilateSubParameters (
9634  CErrorDetails * pError);
9635 
9636  void
9637  encode (
9638  CEncoderStream * pEncoderStream) const;
9639 
9640 
9641  llrp_bool_t
9642  isAllowedIn (
9643  const CTypeDescriptor * pEnclosingElementType) const;
9644 
9645 
9646  static CElement *
9647  s_construct (void);
9648 
9649  static void
9650  s_decodeFields (
9651  CDecoderStream * pDecoderStream,
9652  CElement * pElement);
9654 
9655 
9656  protected:
9657  llrp_u1_t m_EnableAntennaAttemptNotification;
9658 
9661  public:
9662  static const CFieldDescriptor
9663  s_fdEnableAntennaAttemptNotification;
9665 
9667  inline llrp_u1_t
9669  {
9670  return m_EnableAntennaAttemptNotification;
9671  }
9672 
9674  inline void
9676  llrp_u1_t value)
9677  {
9678  m_EnableAntennaAttemptNotification = value;
9679  }
9680 
9681 
9682  protected:
9683  std::list<CParameter *> m_listCustom;
9684 
9685  public:
9687  inline std::list<CParameter *>::iterator
9689  {
9690  return m_listCustom.begin();
9691  }
9692 
9694  inline std::list<CParameter *>::iterator
9695  endCustom (void)
9696  {
9697  return m_listCustom.end();
9698  }
9699 
9701  inline void
9703  {
9704  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9705  }
9706 
9708  inline int
9710  {
9711  return (int) (m_listCustom.size());
9712  }
9713 
9714  EResultCode
9716  addCustom (
9717  CParameter * pValue);
9718 
9719 
9720 };
9721 
9722 
9747 class CImpinjAntennaAttemptEvent : public CParameter
9748 {
9749  public:
9752 
9755 
9756  static const CFieldDescriptor * const
9757  s_apFieldDescriptorTable[];
9758 
9759  static const CTypeDescriptor
9760  s_typeDescriptor;
9761 
9762  void
9763  decodeFields (
9764  CDecoderStream * pDecoderStream);
9765 
9766  void
9767  assimilateSubParameters (
9768  CErrorDetails * pError);
9769 
9770  void
9771  encode (
9772  CEncoderStream * pEncoderStream) const;
9773 
9774 
9775  llrp_bool_t
9776  isAllowedIn (
9777  const CTypeDescriptor * pEnclosingElementType) const;
9778 
9779 
9780  static CElement *
9781  s_construct (void);
9782 
9783  static void
9784  s_decodeFields (
9785  CDecoderStream * pDecoderStream,
9786  CElement * pElement);
9788 
9789 
9790  protected:
9791  llrp_u16_t m_AntennaID;
9792 
9795  public:
9796  static const CFieldDescriptor
9797  s_fdAntennaID;
9799 
9801  inline llrp_u16_t
9803  {
9804  return m_AntennaID;
9805  }
9806 
9808  inline void
9810  llrp_u16_t value)
9811  {
9812  m_AntennaID = value;
9813  }
9814 
9815 
9816  protected:
9817  std::list<CParameter *> m_listCustom;
9818 
9819  public:
9821  inline std::list<CParameter *>::iterator
9823  {
9824  return m_listCustom.begin();
9825  }
9826 
9828  inline std::list<CParameter *>::iterator
9829  endCustom (void)
9830  {
9831  return m_listCustom.end();
9832  }
9833 
9835  inline void
9837  {
9838  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9839  }
9840 
9842  inline int
9844  {
9845  return (int) (m_listCustom.size());
9846  }
9847 
9848  EResultCode
9850  addCustom (
9851  CParameter * pValue);
9852 
9853 
9854 };
9855 
9856 
9884 class CImpinjHubConfiguration : public CParameter
9885 {
9886  public:
9887  CImpinjHubConfiguration (void);
9888  ~CImpinjHubConfiguration (void);
9889 
9892 
9893  static const CFieldDescriptor * const
9894  s_apFieldDescriptorTable[];
9895 
9896  static const CTypeDescriptor
9897  s_typeDescriptor;
9898 
9899  void
9900  decodeFields (
9901  CDecoderStream * pDecoderStream);
9902 
9903  void
9904  assimilateSubParameters (
9905  CErrorDetails * pError);
9906 
9907  void
9908  encode (
9909  CEncoderStream * pEncoderStream) const;
9910 
9911 
9912  llrp_bool_t
9913  isAllowedIn (
9914  const CTypeDescriptor * pEnclosingElementType) const;
9915 
9916 
9917  static CElement *
9918  s_construct (void);
9919 
9920  static void
9921  s_decodeFields (
9922  CDecoderStream * pDecoderStream,
9923  CElement * pElement);
9925 
9926 
9927  protected:
9928  llrp_u16_t m_HubID;
9929 
9932  public:
9933  static const CFieldDescriptor
9934  s_fdHubID;
9936 
9938  inline llrp_u16_t
9939  getHubID (void)
9940  {
9941  return m_HubID;
9942  }
9943 
9945  inline void
9947  llrp_u16_t value)
9948  {
9949  m_HubID = value;
9950  }
9951 
9952 
9953  protected:
9954  EImpinjHubConnectedType m_eConnected;
9955 
9958  public:
9959  static const CFieldDescriptor
9960  s_fdConnected;
9962 
9964  inline EImpinjHubConnectedType
9966  {
9967  return m_eConnected;
9968  }
9969 
9971  inline void
9973  EImpinjHubConnectedType value)
9974  {
9975  m_eConnected = value;
9976  }
9977 
9978 
9979  protected:
9980  EImpinjHubFaultType m_eFault;
9981 
9984  public:
9985  static const CFieldDescriptor
9986  s_fdFault;
9988 
9990  inline EImpinjHubFaultType
9991  getFault (void)
9992  {
9993  return m_eFault;
9994  }
9995 
9997  inline void
9999  EImpinjHubFaultType value)
10000  {
10001  m_eFault = value;
10002  }
10003 
10004 
10005  protected:
10006  std::list<CParameter *> m_listCustom;
10007 
10008  public:
10010  inline std::list<CParameter *>::iterator
10012  {
10013  return m_listCustom.begin();
10014  }
10015 
10017  inline std::list<CParameter *>::iterator
10018  endCustom (void)
10019  {
10020  return m_listCustom.end();
10021  }
10022 
10024  inline void
10026  {
10027  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10028  }
10029 
10031  inline int
10033  {
10034  return (int) (m_listCustom.size());
10035  }
10036 
10037  EResultCode
10039  addCustom (
10040  CParameter * pValue);
10041 
10042 
10043 };
10044 
10045 
10069 class CImpinjDiagnosticReport : public CParameter
10070 {
10071  public:
10072  CImpinjDiagnosticReport (void);
10073  ~CImpinjDiagnosticReport (void);
10074 
10077 
10078  static const CFieldDescriptor * const
10079  s_apFieldDescriptorTable[];
10080 
10081  static const CTypeDescriptor
10082  s_typeDescriptor;
10083 
10084  void
10085  decodeFields (
10086  CDecoderStream * pDecoderStream);
10087 
10088  void
10089  assimilateSubParameters (
10090  CErrorDetails * pError);
10091 
10092  void
10093  encode (
10094  CEncoderStream * pEncoderStream) const;
10095 
10096 
10097  llrp_bool_t
10098  isAllowedIn (
10099  const CTypeDescriptor * pEnclosingElementType) const;
10100 
10101 
10102  static CElement *
10103  s_construct (void);
10104 
10105  static void
10106  s_decodeFields (
10107  CDecoderStream * pDecoderStream,
10108  CElement * pElement);
10110 
10111 
10112  protected:
10113  llrp_u32v_t m_Metric;
10114 
10117  public:
10118  static const CFieldDescriptor
10119  s_fdMetric;
10121 
10123  inline llrp_u32v_t
10124  getMetric (void)
10125  {
10126  return m_Metric;
10127  }
10128 
10130  inline void
10132  llrp_u32v_t value)
10133  {
10134  m_Metric = value;
10135  }
10136 
10137 
10138 };
10139 
10140 
10179 class CImpinjPlacementConfiguration : public CParameter
10180 {
10181  public:
10184 
10187 
10188  static const CFieldDescriptor * const
10189  s_apFieldDescriptorTable[];
10190 
10191  static const CTypeDescriptor
10192  s_typeDescriptor;
10193 
10194  void
10195  decodeFields (
10196  CDecoderStream * pDecoderStream);
10197 
10198  void
10199  assimilateSubParameters (
10200  CErrorDetails * pError);
10201 
10202  void
10203  encode (
10204  CEncoderStream * pEncoderStream) const;
10205 
10206 
10207  llrp_bool_t
10208  isAllowedIn (
10209  const CTypeDescriptor * pEnclosingElementType) const;
10210 
10211 
10212  static CElement *
10213  s_construct (void);
10214 
10215  static void
10216  s_decodeFields (
10217  CDecoderStream * pDecoderStream,
10218  CElement * pElement);
10220 
10221 
10222  protected:
10223  llrp_u16_t m_HeightCm;
10224 
10227  public:
10228  static const CFieldDescriptor
10229  s_fdHeightCm;
10231 
10233  inline llrp_u16_t
10235  {
10236  return m_HeightCm;
10237  }
10238 
10240  inline void
10242  llrp_u16_t value)
10243  {
10244  m_HeightCm = value;
10245  }
10246 
10247 
10248  protected:
10249  llrp_s32_t m_FacilityXLocationCm;
10250 
10253  public:
10254  static const CFieldDescriptor
10255  s_fdFacilityXLocationCm;
10257 
10259  inline llrp_s32_t
10261  {
10262  return m_FacilityXLocationCm;
10263  }
10264 
10266  inline void
10268  llrp_s32_t value)
10269  {
10270  m_FacilityXLocationCm = value;
10271  }
10272 
10273 
10274  protected:
10275  llrp_s32_t m_FacilityYLocationCm;
10276 
10279  public:
10280  static const CFieldDescriptor
10281  s_fdFacilityYLocationCm;
10283 
10285  inline llrp_s32_t
10287  {
10288  return m_FacilityYLocationCm;
10289  }
10290 
10292  inline void
10294  llrp_s32_t value)
10295  {
10296  m_FacilityYLocationCm = value;
10297  }
10298 
10299 
10300  protected:
10301  llrp_s16_t m_OrientationDegrees;
10302 
10305  public:
10306  static const CFieldDescriptor
10307  s_fdOrientationDegrees;
10309 
10311  inline llrp_s16_t
10313  {
10314  return m_OrientationDegrees;
10315  }
10316 
10318  inline void
10320  llrp_s16_t value)
10321  {
10322  m_OrientationDegrees = value;
10323  }
10324 
10325 
10326  protected:
10327  std::list<CParameter *> m_listCustom;
10328 
10329  public:
10331  inline std::list<CParameter *>::iterator
10333  {
10334  return m_listCustom.begin();
10335  }
10336 
10338  inline std::list<CParameter *>::iterator
10339  endCustom (void)
10340  {
10341  return m_listCustom.end();
10342  }
10343 
10345  inline void
10347  {
10348  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10349  }
10350 
10352  inline int
10354  {
10355  return (int) (m_listCustom.size());
10356  }
10357 
10358  EResultCode
10360  addCustom (
10361  CParameter * pValue);
10362 
10363 
10364 };
10365 
10366 
10397 class CImpinjLISpec : public CParameter
10398 {
10399  public:
10400  CImpinjLISpec (void);
10401  ~CImpinjLISpec (void);
10402 
10405 
10406  static const CFieldDescriptor * const
10407  s_apFieldDescriptorTable[];
10408 
10409  static const CTypeDescriptor
10410  s_typeDescriptor;
10411 
10412  void
10413  decodeFields (
10414  CDecoderStream * pDecoderStream);
10415 
10416  void
10417  assimilateSubParameters (
10418  CErrorDetails * pError);
10419 
10420  void
10421  encode (
10422  CEncoderStream * pEncoderStream) const;
10423 
10424 
10425  llrp_bool_t
10426  isAllowedIn (
10427  const CTypeDescriptor * pEnclosingElementType) const;
10428 
10429 
10430  static CElement *
10431  s_construct (void);
10432 
10433  static void
10434  s_decodeFields (
10435  CDecoderStream * pDecoderStream,
10436  CElement * pElement);
10438 
10439 
10440  protected:
10441  CImpinjLocationConfig * m_pImpinjLocationConfig;
10442 
10443  public:
10445  inline CImpinjLocationConfig *
10447  {
10448  return m_pImpinjLocationConfig;
10449  }
10450 
10452  EResultCode
10454  CImpinjLocationConfig * pValue);
10455 
10456 
10457  protected:
10458  CImpinjC1G2LocationConfig * m_pImpinjC1G2LocationConfig;
10459 
10460  public:
10462  inline CImpinjC1G2LocationConfig *
10464  {
10465  return m_pImpinjC1G2LocationConfig;
10466  }
10467 
10469  EResultCode
10471  CImpinjC1G2LocationConfig * pValue);
10472 
10473 
10474  protected:
10475  CImpinjLocationReporting * m_pImpinjLocationReporting;
10476 
10477  public:
10479  inline CImpinjLocationReporting *
10481  {
10482  return m_pImpinjLocationReporting;
10483  }
10484 
10486  EResultCode
10488  CImpinjLocationReporting * pValue);
10489 
10490 
10491  protected:
10492  std::list<CParameter *> m_listCustom;
10493 
10494  public:
10496  inline std::list<CParameter *>::iterator
10498  {
10499  return m_listCustom.begin();
10500  }
10501 
10503  inline std::list<CParameter *>::iterator
10504  endCustom (void)
10505  {
10506  return m_listCustom.end();
10507  }
10508 
10510  inline void
10512  {
10513  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10514  }
10515 
10517  inline int
10519  {
10520  return (int) (m_listCustom.size());
10521  }
10522 
10523  EResultCode
10525  addCustom (
10526  CParameter * pValue);
10527 
10528 
10529 };
10530 
10531 
10577 class CImpinjLocationConfig : public CParameter
10578 {
10579  public:
10580  CImpinjLocationConfig (void);
10581  ~CImpinjLocationConfig (void);
10582 
10585 
10586  static const CFieldDescriptor * const
10587  s_apFieldDescriptorTable[];
10588 
10589  static const CTypeDescriptor
10590  s_typeDescriptor;
10591 
10592  void
10593  decodeFields (
10594  CDecoderStream * pDecoderStream);
10595 
10596  void
10597  assimilateSubParameters (
10598  CErrorDetails * pError);
10599 
10600  void
10601  encode (
10602  CEncoderStream * pEncoderStream) const;
10603 
10604 
10605  llrp_bool_t
10606  isAllowedIn (
10607  const CTypeDescriptor * pEnclosingElementType) const;
10608 
10609 
10610  static CElement *
10611  s_construct (void);
10612 
10613  static void
10614  s_decodeFields (
10615  CDecoderStream * pDecoderStream,
10616  CElement * pElement);
10618 
10619 
10620  protected:
10621  llrp_u16_t m_ComputeWindowSeconds;
10622 
10625  public:
10626  static const CFieldDescriptor
10627  s_fdComputeWindowSeconds;
10629 
10631  inline llrp_u16_t
10633  {
10634  return m_ComputeWindowSeconds;
10635  }
10636 
10638  inline void
10640  llrp_u16_t value)
10641  {
10642  m_ComputeWindowSeconds = value;
10643  }
10644 
10645 
10646  protected:
10647  llrp_u16_t m_TagAgeIntervalSeconds;
10648 
10651  public:
10652  static const CFieldDescriptor
10653  s_fdTagAgeIntervalSeconds;
10655 
10657  inline llrp_u16_t
10659  {
10660  return m_TagAgeIntervalSeconds;
10661  }
10662 
10664  inline void
10666  llrp_u16_t value)
10667  {
10668  m_TagAgeIntervalSeconds = value;
10669  }
10670 
10671 
10672  protected:
10673  llrp_u16_t m_UpdateIntervalSeconds;
10674 
10677  public:
10678  static const CFieldDescriptor
10679  s_fdUpdateIntervalSeconds;
10681 
10683  inline llrp_u16_t
10685  {
10686  return m_UpdateIntervalSeconds;
10687  }
10688 
10690  inline void
10692  llrp_u16_t value)
10693  {
10694  m_UpdateIntervalSeconds = value;
10695  }
10696 
10697 
10698  protected:
10699  CImpinjDisabledAntennas * m_pImpinjDisabledAntennas;
10700 
10701  public:
10703  inline CImpinjDisabledAntennas *
10705  {
10706  return m_pImpinjDisabledAntennas;
10707  }
10708 
10710  EResultCode
10712  CImpinjDisabledAntennas * pValue);
10713 
10714 
10715  protected:
10716  CImpinjLocationAlgorithmControl * m_pImpinjLocationAlgorithmControl;
10717 
10718  public:
10722  {
10723  return m_pImpinjLocationAlgorithmControl;
10724  }
10725 
10727  EResultCode
10730 
10731 
10732  protected:
10733  std::list<CParameter *> m_listCustom;
10734 
10735  public:
10737  inline std::list<CParameter *>::iterator
10739  {
10740  return m_listCustom.begin();
10741  }
10742 
10744  inline std::list<CParameter *>::iterator
10745  endCustom (void)
10746  {
10747  return m_listCustom.end();
10748  }
10749 
10751  inline void
10753  {
10754  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10755  }
10756 
10758  inline int
10760  {
10761  return (int) (m_listCustom.size());
10762  }
10763 
10764  EResultCode
10766  addCustom (
10767  CParameter * pValue);
10768 
10769 
10770 };
10771 
10772 
10815 class CImpinjC1G2LocationConfig : public CParameter
10816 {
10817  public:
10819  ~CImpinjC1G2LocationConfig (void);
10820 
10823 
10824  static const CFieldDescriptor * const
10825  s_apFieldDescriptorTable[];
10826 
10827  static const CTypeDescriptor
10828  s_typeDescriptor;
10829 
10830  void
10831  decodeFields (
10832  CDecoderStream * pDecoderStream);
10833 
10834  void
10835  assimilateSubParameters (
10836  CErrorDetails * pError);
10837 
10838  void
10839  encode (
10840  CEncoderStream * pEncoderStream) const;
10841 
10842 
10843  llrp_bool_t
10844  isAllowedIn (
10845  const CTypeDescriptor * pEnclosingElementType) const;
10846 
10847 
10848  static CElement *
10849  s_construct (void);
10850 
10851  static void
10852  s_decodeFields (
10853  CDecoderStream * pDecoderStream,
10854  CElement * pElement);
10856 
10857 
10858  protected:
10859  llrp_u16_t m_ModeIndex;
10860 
10863  public:
10864  static const CFieldDescriptor
10865  s_fdModeIndex;
10867 
10869  inline llrp_u16_t
10871  {
10872  return m_ModeIndex;
10873  }
10874 
10876  inline void
10878  llrp_u16_t value)
10879  {
10880  m_ModeIndex = value;
10881  }
10882 
10883 
10884  protected:
10885  llrp_u2_t m_Session;
10886 
10889  public:
10890  static const CFieldDescriptor
10891  s_fdSession;
10893 
10895  inline llrp_u2_t
10896  getSession (void)
10897  {
10898  return m_Session;
10899  }
10900 
10902  inline void
10904  llrp_u2_t value)
10905  {
10906  m_Session = value;
10907  }
10908 
10909 
10910  protected:
10911  std::list<CC1G2Filter *> m_listC1G2Filter;
10912 
10913  public:
10915  inline std::list<CC1G2Filter *>::iterator
10917  {
10918  return m_listC1G2Filter.begin();
10919  }
10920 
10922  inline std::list<CC1G2Filter *>::iterator
10924  {
10925  return m_listC1G2Filter.end();
10926  }
10927 
10929  inline void
10931  {
10932  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
10933  }
10934 
10936  inline int
10938  {
10939  return (int) (m_listC1G2Filter.size());
10940  }
10941 
10942  EResultCode
10944  addC1G2Filter (
10945  CC1G2Filter * pValue);
10946 
10947 
10948  protected:
10949  CImpinjTransmitPower * m_pImpinjTransmitPower;
10950 
10951  public:
10953  inline CImpinjTransmitPower *
10955  {
10956  return m_pImpinjTransmitPower;
10957  }
10958 
10960  EResultCode
10962  CImpinjTransmitPower * pValue);
10963 
10964 
10965  protected:
10966  std::list<CParameter *> m_listCustom;
10967 
10968  public:
10970  inline std::list<CParameter *>::iterator
10972  {
10973  return m_listCustom.begin();
10974  }
10975 
10977  inline std::list<CParameter *>::iterator
10978  endCustom (void)
10979  {
10980  return m_listCustom.end();
10981  }
10982 
10984  inline void
10986  {
10987  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10988  }
10989 
10991  inline int
10993  {
10994  return (int) (m_listCustom.size());
10995  }
10996 
10997  EResultCode
10999  addCustom (
11000  CParameter * pValue);
11001 
11002 
11003 };
11004 
11005 
11047 class CImpinjLocationReporting : public CParameter
11048 {
11049  public:
11050  CImpinjLocationReporting (void);
11051  ~CImpinjLocationReporting (void);
11052 
11055 
11056  static const CFieldDescriptor * const
11057  s_apFieldDescriptorTable[];
11058 
11059  static const CTypeDescriptor
11060  s_typeDescriptor;
11061 
11062  void
11063  decodeFields (
11064  CDecoderStream * pDecoderStream);
11065 
11066  void
11067  assimilateSubParameters (
11068  CErrorDetails * pError);
11069 
11070  void
11071  encode (
11072  CEncoderStream * pEncoderStream) const;
11073 
11074 
11075  llrp_bool_t
11076  isAllowedIn (
11077  const CTypeDescriptor * pEnclosingElementType) const;
11078 
11079 
11080  static CElement *
11081  s_construct (void);
11082 
11083  static void
11084  s_decodeFields (
11085  CDecoderStream * pDecoderStream,
11086  CElement * pElement);
11088 
11089 
11090  protected:
11091  llrp_u1_t m_EnableUpdateReport;
11092 
11095  public:
11096  static const CFieldDescriptor
11097  s_fdEnableUpdateReport;
11099 
11101  inline llrp_u1_t
11103  {
11104  return m_EnableUpdateReport;
11105  }
11106 
11108  inline void
11110  llrp_u1_t value)
11111  {
11112  m_EnableUpdateReport = value;
11113  }
11114 
11115 
11116  protected:
11117  llrp_u1_t m_EnableEntryReport;
11118 
11121  public:
11122  static const CFieldDescriptor
11123  s_fdEnableEntryReport;
11125 
11127  inline llrp_u1_t
11129  {
11130  return m_EnableEntryReport;
11131  }
11132 
11134  inline void
11136  llrp_u1_t value)
11137  {
11138  m_EnableEntryReport = value;
11139  }
11140 
11141 
11142  protected:
11143  llrp_u1_t m_EnableExitReport;
11144 
11147  public:
11148  static const CFieldDescriptor
11149  s_fdEnableExitReport;
11151 
11153  inline llrp_u1_t
11155  {
11156  return m_EnableExitReport;
11157  }
11158 
11160  inline void
11162  llrp_u1_t value)
11163  {
11164  m_EnableExitReport = value;
11165  }
11166 
11167 
11168  protected:
11169  llrp_u1_t m_EnableDiagnosticReport;
11170 
11173  public:
11174  static const CFieldDescriptor
11175  s_fdEnableDiagnosticReport;
11177 
11179  inline llrp_u1_t
11181  {
11182  return m_EnableDiagnosticReport;
11183  }
11184 
11186  inline void
11188  llrp_u1_t value)
11189  {
11190  m_EnableDiagnosticReport = value;
11191  }
11192 
11193 
11194  protected:
11195  std::list<CParameter *> m_listCustom;
11196 
11197  public:
11199  inline std::list<CParameter *>::iterator
11201  {
11202  return m_listCustom.begin();
11203  }
11204 
11206  inline std::list<CParameter *>::iterator
11207  endCustom (void)
11208  {
11209  return m_listCustom.end();
11210  }
11211 
11213  inline void
11215  {
11216  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11217  }
11218 
11220  inline int
11222  {
11223  return (int) (m_listCustom.size());
11224  }
11225 
11226  EResultCode
11228  addCustom (
11229  CParameter * pValue);
11230 
11231 
11232 };
11233 
11234 
11265 class CImpinjLocationConfidence : public CParameter
11266 {
11267  public:
11269  ~CImpinjLocationConfidence (void);
11270 
11273 
11274  static const CFieldDescriptor * const
11275  s_apFieldDescriptorTable[];
11276 
11277  static const CTypeDescriptor
11278  s_typeDescriptor;
11279 
11280  void
11281  decodeFields (
11282  CDecoderStream * pDecoderStream);
11283 
11284  void
11285  assimilateSubParameters (
11286  CErrorDetails * pError);
11287 
11288  void
11289  encode (
11290  CEncoderStream * pEncoderStream) const;
11291 
11292 
11293  llrp_bool_t
11294  isAllowedIn (
11295  const CTypeDescriptor * pEnclosingElementType) const;
11296 
11297 
11298  static CElement *
11299  s_construct (void);
11300 
11301  static void
11302  s_decodeFields (
11303  CDecoderStream * pDecoderStream,
11304  CElement * pElement);
11306 
11307 
11308  protected:
11309  llrp_u16_t m_ReadCount;
11310 
11313  public:
11314  static const CFieldDescriptor
11315  s_fdReadCount;
11317 
11319  inline llrp_u16_t
11321  {
11322  return m_ReadCount;
11323  }
11324 
11326  inline void
11328  llrp_u16_t value)
11329  {
11330  m_ReadCount = value;
11331  }
11332 
11333 
11334  protected:
11335  llrp_u32v_t m_ConfidenceData;
11336 
11339  public:
11340  static const CFieldDescriptor
11341  s_fdConfidenceData;
11343 
11345  inline llrp_u32v_t
11347  {
11348  return m_ConfidenceData;
11349  }
11350 
11352  inline void
11354  llrp_u32v_t value)
11355  {
11356  m_ConfidenceData = value;
11357  }
11358 
11359 
11360  protected:
11361  std::list<CParameter *> m_listCustom;
11362 
11363  public:
11365  inline std::list<CParameter *>::iterator
11367  {
11368  return m_listCustom.begin();
11369  }
11370 
11372  inline std::list<CParameter *>::iterator
11373  endCustom (void)
11374  {
11375  return m_listCustom.end();
11376  }
11377 
11379  inline void
11381  {
11382  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11383  }
11384 
11386  inline int
11388  {
11389  return (int) (m_listCustom.size());
11390  }
11391 
11392  EResultCode
11394  addCustom (
11395  CParameter * pValue);
11396 
11397 
11398 };
11399 
11400 
11438 class CImpinjLocationReportData : public CParameter
11439 {
11440  public:
11442  ~CImpinjLocationReportData (void);
11443 
11446 
11447  static const CFieldDescriptor * const
11448  s_apFieldDescriptorTable[];
11449 
11450  static const CTypeDescriptor
11451  s_typeDescriptor;
11452 
11453  void
11454  decodeFields (
11455  CDecoderStream * pDecoderStream);
11456 
11457  void
11458  assimilateSubParameters (
11459  CErrorDetails * pError);
11460 
11461  void
11462  encode (
11463  CEncoderStream * pEncoderStream) const;
11464 
11465 
11466  llrp_bool_t
11467  isAllowedIn (
11468  const CTypeDescriptor * pEnclosingElementType) const;
11469 
11470 
11471  static CElement *
11472  s_construct (void);
11473 
11474  static void
11475  s_decodeFields (
11476  CDecoderStream * pDecoderStream,
11477  CElement * pElement);
11479 
11480 
11481  protected:
11482  llrp_u64_t m_LastSeenTimestampUTC;
11483 
11486  public:
11487  static const CFieldDescriptor
11488  s_fdLastSeenTimestampUTC;
11490 
11492  inline llrp_u64_t
11494  {
11495  return m_LastSeenTimestampUTC;
11496  }
11497 
11499  inline void
11501  llrp_u64_t value)
11502  {
11503  m_LastSeenTimestampUTC = value;
11504  }
11505 
11506 
11507  protected:
11508  llrp_s32_t m_LocXCentimeters;
11509 
11512  public:
11513  static const CFieldDescriptor
11514  s_fdLocXCentimeters;
11516 
11518  inline llrp_s32_t
11520  {
11521  return m_LocXCentimeters;
11522  }
11523 
11525  inline void
11527  llrp_s32_t value)
11528  {
11529  m_LocXCentimeters = value;
11530  }
11531 
11532 
11533  protected:
11534  llrp_s32_t m_LocYCentimeters;
11535 
11538  public:
11539  static const CFieldDescriptor
11540  s_fdLocYCentimeters;
11542 
11544  inline llrp_s32_t
11546  {
11547  return m_LocYCentimeters;
11548  }
11549 
11551  inline void
11553  llrp_s32_t value)
11554  {
11555  m_LocYCentimeters = value;
11556  }
11557 
11558 
11559  protected:
11560  EImpinjLocationReportType m_eType;
11561 
11564  public:
11565  static const CFieldDescriptor
11566  s_fdType;
11568 
11570  inline EImpinjLocationReportType
11571  getType (void)
11572  {
11573  return m_eType;
11574  }
11575 
11577  inline void
11579  EImpinjLocationReportType value)
11580  {
11581  m_eType = value;
11582  }
11583 
11584 
11585  protected:
11586  CImpinjLocationConfidence * m_pImpinjLocationConfidence;
11587 
11588  public:
11590  inline CImpinjLocationConfidence *
11592  {
11593  return m_pImpinjLocationConfidence;
11594  }
11595 
11597  EResultCode
11599  CImpinjLocationConfidence * pValue);
11600 
11601 
11602  protected:
11603  std::list<CParameter *> m_listCustom;
11604 
11605  public:
11607  inline std::list<CParameter *>::iterator
11609  {
11610  return m_listCustom.begin();
11611  }
11612 
11614  inline std::list<CParameter *>::iterator
11615  endCustom (void)
11616  {
11617  return m_listCustom.end();
11618  }
11619 
11621  inline void
11623  {
11624  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11625  }
11626 
11628  inline int
11630  {
11631  return (int) (m_listCustom.size());
11632  }
11633 
11634  EResultCode
11636  addCustom (
11637  CParameter * pValue);
11638 
11639 
11640 };
11641 
11642 
11675 class CImpinjDISpec : public CParameter
11676 {
11677  public:
11678  CImpinjDISpec (void);
11679  ~CImpinjDISpec (void);
11680 
11683 
11684  static const CFieldDescriptor * const
11685  s_apFieldDescriptorTable[];
11686 
11687  static const CTypeDescriptor
11688  s_typeDescriptor;
11689 
11690  void
11691  decodeFields (
11692  CDecoderStream * pDecoderStream);
11693 
11694  void
11695  assimilateSubParameters (
11696  CErrorDetails * pError);
11697 
11698  void
11699  encode (
11700  CEncoderStream * pEncoderStream) const;
11701 
11702 
11703  llrp_bool_t
11704  isAllowedIn (
11705  const CTypeDescriptor * pEnclosingElementType) const;
11706 
11707 
11708  static CElement *
11709  s_construct (void);
11710 
11711  static void
11712  s_decodeFields (
11713  CDecoderStream * pDecoderStream,
11714  CElement * pElement);
11716 
11717 
11718  protected:
11719  CImpinjDirectionSectors * m_pImpinjDirectionSectors;
11720 
11721  public:
11723  inline CImpinjDirectionSectors *
11725  {
11726  return m_pImpinjDirectionSectors;
11727  }
11728 
11730  EResultCode
11732  CImpinjDirectionSectors * pValue);
11733 
11734 
11735  protected:
11736  CImpinjDirectionConfig * m_pImpinjDirectionConfig;
11737 
11738  public:
11740  inline CImpinjDirectionConfig *
11742  {
11743  return m_pImpinjDirectionConfig;
11744  }
11745 
11747  EResultCode
11749  CImpinjDirectionConfig * pValue);
11750 
11751 
11752  protected:
11753  CImpinjC1G2DirectionConfig * m_pImpinjC1G2DirectionConfig;
11754 
11755  public:
11759  {
11760  return m_pImpinjC1G2DirectionConfig;
11761  }
11762 
11764  EResultCode
11766  CImpinjC1G2DirectionConfig * pValue);
11767 
11768 
11769  protected:
11770  CImpinjDirectionReporting * m_pImpinjDirectionReporting;
11771 
11772  public:
11774  inline CImpinjDirectionReporting *
11776  {
11777  return m_pImpinjDirectionReporting;
11778  }
11779 
11781  EResultCode
11783  CImpinjDirectionReporting * pValue);
11784 
11785 
11786  protected:
11787  std::list<CParameter *> m_listCustom;
11788 
11789  public:
11791  inline std::list<CParameter *>::iterator
11793  {
11794  return m_listCustom.begin();
11795  }
11796 
11798  inline std::list<CParameter *>::iterator
11799  endCustom (void)
11800  {
11801  return m_listCustom.end();
11802  }
11803 
11805  inline void
11807  {
11808  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11809  }
11810 
11812  inline int
11814  {
11815  return (int) (m_listCustom.size());
11816  }
11817 
11818  EResultCode
11820  addCustom (
11821  CParameter * pValue);
11822 
11823 
11824 };
11825 
11826 
11854 class CImpinjDirectionSectors : public CParameter
11855 {
11856  public:
11857  CImpinjDirectionSectors (void);
11858  ~CImpinjDirectionSectors (void);
11859 
11862 
11863  static const CFieldDescriptor * const
11864  s_apFieldDescriptorTable[];
11865 
11866  static const CTypeDescriptor
11867  s_typeDescriptor;
11868 
11869  void
11870  decodeFields (
11871  CDecoderStream * pDecoderStream);
11872 
11873  void
11874  assimilateSubParameters (
11875  CErrorDetails * pError);
11876 
11877  void
11878  encode (
11879  CEncoderStream * pEncoderStream) const;
11880 
11881 
11882  llrp_bool_t
11883  isAllowedIn (
11884  const CTypeDescriptor * pEnclosingElementType) const;
11885 
11886 
11887  static CElement *
11888  s_construct (void);
11889 
11890  static void
11891  s_decodeFields (
11892  CDecoderStream * pDecoderStream,
11893  CElement * pElement);
11895 
11896 
11897  protected:
11898  llrp_u16v_t m_EnabledSectorIDs;
11899 
11902  public:
11903  static const CFieldDescriptor
11904  s_fdEnabledSectorIDs;
11906 
11908  inline llrp_u16v_t
11910  {
11911  return m_EnabledSectorIDs;
11912  }
11913 
11915  inline void
11917  llrp_u16v_t value)
11918  {
11919  m_EnabledSectorIDs = value;
11920  }
11921 
11922 
11923  protected:
11924  std::list<CParameter *> m_listCustom;
11925 
11926  public:
11928  inline std::list<CParameter *>::iterator
11930  {
11931  return m_listCustom.begin();
11932  }
11933 
11935  inline std::list<CParameter *>::iterator
11936  endCustom (void)
11937  {
11938  return m_listCustom.end();
11939  }
11940 
11942  inline void
11944  {
11945  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11946  }
11947 
11949  inline int
11951  {
11952  return (int) (m_listCustom.size());
11953  }
11954 
11955  EResultCode
11957  addCustom (
11958  CParameter * pValue);
11959 
11960 
11961 };
11962 
11963 
12002 class CImpinjDirectionConfig : public CParameter
12003 {
12004  public:
12005  CImpinjDirectionConfig (void);
12006  ~CImpinjDirectionConfig (void);
12007 
12010 
12011  static const CFieldDescriptor * const
12012  s_apFieldDescriptorTable[];
12013 
12014  static const CTypeDescriptor
12015  s_typeDescriptor;
12016 
12017  void
12018  decodeFields (
12019  CDecoderStream * pDecoderStream);
12020 
12021  void
12022  assimilateSubParameters (
12023  CErrorDetails * pError);
12024 
12025  void
12026  encode (
12027  CEncoderStream * pEncoderStream) const;
12028 
12029 
12030  llrp_bool_t
12031  isAllowedIn (
12032  const CTypeDescriptor * pEnclosingElementType) const;
12033 
12034 
12035  static CElement *
12036  s_construct (void);
12037 
12038  static void
12039  s_decodeFields (
12040  CDecoderStream * pDecoderStream,
12041  CElement * pElement);
12043 
12044 
12045  protected:
12046  llrp_u16_t m_TagAgeIntervalSeconds;
12047 
12050  public:
12051  static const CFieldDescriptor
12052  s_fdTagAgeIntervalSeconds;
12054 
12056  inline llrp_u16_t
12058  {
12059  return m_TagAgeIntervalSeconds;
12060  }
12061 
12063  inline void
12065  llrp_u16_t value)
12066  {
12067  m_TagAgeIntervalSeconds = value;
12068  }
12069 
12070 
12071  protected:
12072  llrp_u16_t m_UpdateIntervalSeconds;
12073 
12076  public:
12077  static const CFieldDescriptor
12078  s_fdUpdateIntervalSeconds;
12080 
12082  inline llrp_u16_t
12084  {
12085  return m_UpdateIntervalSeconds;
12086  }
12087 
12089  inline void
12091  llrp_u16_t value)
12092  {
12093  m_UpdateIntervalSeconds = value;
12094  }
12095 
12096 
12097  protected:
12098  EImpinjDirectionFieldOfView m_eFieldOfView;
12099 
12102  public:
12103  static const CFieldDescriptor
12104  s_fdFieldOfView;
12106 
12108  inline EImpinjDirectionFieldOfView
12110  {
12111  return m_eFieldOfView;
12112  }
12113 
12115  inline void
12117  EImpinjDirectionFieldOfView value)
12118  {
12119  m_eFieldOfView = value;
12120  }
12121 
12122 
12123  protected:
12124  CImpinjDirectionUserTagPopulationLimit * m_pImpinjDirectionUserTagPopulationLimit;
12125 
12126  public:
12130  {
12131  return m_pImpinjDirectionUserTagPopulationLimit;
12132  }
12133 
12135  EResultCode
12138 
12139 
12140  protected:
12141  std::list<CParameter *> m_listCustom;
12142 
12143  public:
12145  inline std::list<CParameter *>::iterator
12147  {
12148  return m_listCustom.begin();
12149  }
12150 
12152  inline std::list<CParameter *>::iterator
12153  endCustom (void)
12154  {
12155  return m_listCustom.end();
12156  }
12157 
12159  inline void
12161  {
12162  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12163  }
12164 
12166  inline int
12168  {
12169  return (int) (m_listCustom.size());
12170  }
12171 
12172  EResultCode
12174  addCustom (
12175  CParameter * pValue);
12176 
12177 
12178 };
12179 
12180 
12204 {
12205  public:
12208 
12211 
12212  static const CFieldDescriptor * const
12213  s_apFieldDescriptorTable[];
12214 
12215  static const CTypeDescriptor
12216  s_typeDescriptor;
12217 
12218  void
12219  decodeFields (
12220  CDecoderStream * pDecoderStream);
12221 
12222  void
12223  assimilateSubParameters (
12224  CErrorDetails * pError);
12225 
12226  void
12227  encode (
12228  CEncoderStream * pEncoderStream) const;
12229 
12230 
12231  llrp_bool_t
12232  isAllowedIn (
12233  const CTypeDescriptor * pEnclosingElementType) const;
12234 
12235 
12236  static CElement *
12237  s_construct (void);
12238 
12239  static void
12240  s_decodeFields (
12241  CDecoderStream * pDecoderStream,
12242  CElement * pElement);
12244 
12245 
12246  protected:
12247  llrp_u16_t m_UserTagPopulationLimit;
12248 
12251  public:
12252  static const CFieldDescriptor
12253  s_fdUserTagPopulationLimit;
12255 
12257  inline llrp_u16_t
12259  {
12260  return m_UserTagPopulationLimit;
12261  }
12262 
12264  inline void
12266  llrp_u16_t value)
12267  {
12268  m_UserTagPopulationLimit = value;
12269  }
12270 
12271 
12272 };
12273 
12274 
12312 class CImpinjC1G2DirectionConfig : public CParameter
12313 {
12314  public:
12317 
12320 
12321  static const CFieldDescriptor * const
12322  s_apFieldDescriptorTable[];
12323 
12324  static const CTypeDescriptor
12325  s_typeDescriptor;
12326 
12327  void
12328  decodeFields (
12329  CDecoderStream * pDecoderStream);
12330 
12331  void
12332  assimilateSubParameters (
12333  CErrorDetails * pError);
12334 
12335  void
12336  encode (
12337  CEncoderStream * pEncoderStream) const;
12338 
12339 
12340  llrp_bool_t
12341  isAllowedIn (
12342  const CTypeDescriptor * pEnclosingElementType) const;
12343 
12344 
12345  static CElement *
12346  s_construct (void);
12347 
12348  static void
12349  s_decodeFields (
12350  CDecoderStream * pDecoderStream,
12351  CElement * pElement);
12353 
12354 
12355  protected:
12356  EImpinjDirectionRFMode m_eRFMode;
12357 
12360  public:
12361  static const CFieldDescriptor
12362  s_fdRFMode;
12364 
12366  inline EImpinjDirectionRFMode
12367  getRFMode (void)
12368  {
12369  return m_eRFMode;
12370  }
12371 
12373  inline void
12375  EImpinjDirectionRFMode value)
12376  {
12377  m_eRFMode = value;
12378  }
12379 
12380 
12381  protected:
12382  CImpinjTransmitPower * m_pImpinjTransmitPower;
12383 
12384  public:
12386  inline CImpinjTransmitPower *
12388  {
12389  return m_pImpinjTransmitPower;
12390  }
12391 
12393  EResultCode
12395  CImpinjTransmitPower * pValue);
12396 
12397 
12398  protected:
12399  std::list<CC1G2Filter *> m_listC1G2Filter;
12400 
12401  public:
12403  inline std::list<CC1G2Filter *>::iterator
12405  {
12406  return m_listC1G2Filter.begin();
12407  }
12408 
12410  inline std::list<CC1G2Filter *>::iterator
12412  {
12413  return m_listC1G2Filter.end();
12414  }
12415 
12417  inline void
12419  {
12420  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
12421  }
12422 
12424  inline int
12426  {
12427  return (int) (m_listC1G2Filter.size());
12428  }
12429 
12430  EResultCode
12432  addC1G2Filter (
12433  CC1G2Filter * pValue);
12434 
12435 
12436  protected:
12437  std::list<CParameter *> m_listCustom;
12438 
12439  public:
12441  inline std::list<CParameter *>::iterator
12443  {
12444  return m_listCustom.begin();
12445  }
12446 
12448  inline std::list<CParameter *>::iterator
12449  endCustom (void)
12450  {
12451  return m_listCustom.end();
12452  }
12453 
12455  inline void
12457  {
12458  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12459  }
12460 
12462  inline int
12464  {
12465  return (int) (m_listCustom.size());
12466  }
12467 
12468  EResultCode
12470  addCustom (
12471  CParameter * pValue);
12472 
12473 
12474 };
12475 
12476 
12509 class CImpinjExtendedTagInformation : public CParameter
12510 {
12511  public:
12514 
12517 
12518  static const CFieldDescriptor * const
12519  s_apFieldDescriptorTable[];
12520 
12521  static const CTypeDescriptor
12522  s_typeDescriptor;
12523 
12524  void
12525  decodeFields (
12526  CDecoderStream * pDecoderStream);
12527 
12528  void
12529  assimilateSubParameters (
12530  CErrorDetails * pError);
12531 
12532  void
12533  encode (
12534  CEncoderStream * pEncoderStream) const;
12535 
12536 
12537  llrp_bool_t
12538  isAllowedIn (
12539  const CTypeDescriptor * pEnclosingElementType) const;
12540 
12541 
12542  static CElement *
12543  s_construct (void);
12544 
12545  static void
12546  s_decodeFields (
12547  CDecoderStream * pDecoderStream,
12548  CElement * pElement);
12550 
12551 
12552  protected:
12553  std::list<CEPCData *> m_listEPCData;
12554 
12555  public:
12557  inline std::list<CEPCData *>::iterator
12559  {
12560  return m_listEPCData.begin();
12561  }
12562 
12564  inline std::list<CEPCData *>::iterator
12565  endEPCData (void)
12566  {
12567  return m_listEPCData.end();
12568  }
12569 
12571  inline void
12573  {
12574  clearSubParameterList ((tListOfParameters *) &m_listEPCData);
12575  }
12576 
12578  inline int
12580  {
12581  return (int) (m_listEPCData.size());
12582  }
12583 
12584  EResultCode
12586  addEPCData (
12587  CEPCData * pValue);
12588 
12589 
12590  protected:
12591  CImpinjLocationReportData * m_pImpinjLocationReportData;
12592 
12593  public:
12595  inline CImpinjLocationReportData *
12597  {
12598  return m_pImpinjLocationReportData;
12599  }
12600 
12602  EResultCode
12604  CImpinjLocationReportData * pValue);
12605 
12606 
12607  protected:
12608  CImpinjDirectionReportData * m_pImpinjDirectionReportData;
12609 
12610  public:
12614  {
12615  return m_pImpinjDirectionReportData;
12616  }
12617 
12619  EResultCode
12621  CImpinjDirectionReportData * pValue);
12622 
12623 
12624  protected:
12625  std::list<CParameter *> m_listCustom;
12626 
12627  public:
12629  inline std::list<CParameter *>::iterator
12631  {
12632  return m_listCustom.begin();
12633  }
12634 
12636  inline std::list<CParameter *>::iterator
12637  endCustom (void)
12638  {
12639  return m_listCustom.end();
12640  }
12641 
12643  inline void
12645  {
12646  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12647  }
12648 
12650  inline int
12652  {
12653  return (int) (m_listCustom.size());
12654  }
12655 
12656  EResultCode
12658  addCustom (
12659  CParameter * pValue);
12660 
12661 
12662 };
12663 
12664 
12711 class CImpinjDirectionReporting : public CParameter
12712 {
12713  public:
12715  ~CImpinjDirectionReporting (void);
12716 
12719 
12720  static const CFieldDescriptor * const
12721  s_apFieldDescriptorTable[];
12722 
12723  static const CTypeDescriptor
12724  s_typeDescriptor;
12725 
12726  void
12727  decodeFields (
12728  CDecoderStream * pDecoderStream);
12729 
12730  void
12731  assimilateSubParameters (
12732  CErrorDetails * pError);
12733 
12734  void
12735  encode (
12736  CEncoderStream * pEncoderStream) const;
12737 
12738 
12739  llrp_bool_t
12740  isAllowedIn (
12741  const CTypeDescriptor * pEnclosingElementType) const;
12742 
12743 
12744  static CElement *
12745  s_construct (void);
12746 
12747  static void
12748  s_decodeFields (
12749  CDecoderStream * pDecoderStream,
12750  CElement * pElement);
12752 
12753 
12754  protected:
12755  llrp_u1_t m_EnableUpdateReport;
12756 
12759  public:
12760  static const CFieldDescriptor
12761  s_fdEnableUpdateReport;
12763 
12765  inline llrp_u1_t
12767  {
12768  return m_EnableUpdateReport;
12769  }
12770 
12772  inline void
12774  llrp_u1_t value)
12775  {
12776  m_EnableUpdateReport = value;
12777  }
12778 
12779 
12780  protected:
12781  llrp_u1_t m_EnableEntryReport;
12782 
12785  public:
12786  static const CFieldDescriptor
12787  s_fdEnableEntryReport;
12789 
12791  inline llrp_u1_t
12793  {
12794  return m_EnableEntryReport;
12795  }
12796 
12798  inline void
12800  llrp_u1_t value)
12801  {
12802  m_EnableEntryReport = value;
12803  }
12804 
12805 
12806  protected:
12807  llrp_u1_t m_EnableExitReport;
12808 
12811  public:
12812  static const CFieldDescriptor
12813  s_fdEnableExitReport;
12815 
12817  inline llrp_u1_t
12819  {
12820  return m_EnableExitReport;
12821  }
12822 
12824  inline void
12826  llrp_u1_t value)
12827  {
12828  m_EnableExitReport = value;
12829  }
12830 
12831 
12832  protected:
12833  llrp_u1_t m_EnableDiagnosticReport;
12834 
12837  public:
12838  static const CFieldDescriptor
12839  s_fdEnableDiagnosticReport;
12841 
12843  inline llrp_u1_t
12845  {
12846  return m_EnableDiagnosticReport;
12847  }
12848 
12850  inline void
12852  llrp_u1_t value)
12853  {
12854  m_EnableDiagnosticReport = value;
12855  }
12856 
12857 
12858  protected:
12859  EImpinjDirectionDiagnosticReportLevel m_eDiagnosticReportLevel;
12860 
12863  public:
12864  static const CFieldDescriptor
12865  s_fdDiagnosticReportLevel;
12867 
12869  inline EImpinjDirectionDiagnosticReportLevel
12871  {
12872  return m_eDiagnosticReportLevel;
12873  }
12874 
12876  inline void
12878  EImpinjDirectionDiagnosticReportLevel value)
12879  {
12880  m_eDiagnosticReportLevel = value;
12881  }
12882 
12883 
12884  protected:
12885  std::list<CParameter *> m_listCustom;
12886 
12887  public:
12889  inline std::list<CParameter *>::iterator
12891  {
12892  return m_listCustom.begin();
12893  }
12894 
12896  inline std::list<CParameter *>::iterator
12897  endCustom (void)
12898  {
12899  return m_listCustom.end();
12900  }
12901 
12903  inline void
12905  {
12906  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12907  }
12908 
12910  inline int
12912  {
12913  return (int) (m_listCustom.size());
12914  }
12915 
12916  EResultCode
12918  addCustom (
12919  CParameter * pValue);
12920 
12921 
12922 };
12923 
12924 
12972 class CImpinjDirectionReportData : public CParameter
12973 {
12974  public:
12977 
12980 
12981  static const CFieldDescriptor * const
12982  s_apFieldDescriptorTable[];
12983 
12984  static const CTypeDescriptor
12985  s_typeDescriptor;
12986 
12987  void
12988  decodeFields (
12989  CDecoderStream * pDecoderStream);
12990 
12991  void
12992  assimilateSubParameters (
12993  CErrorDetails * pError);
12994 
12995  void
12996  encode (
12997  CEncoderStream * pEncoderStream) const;
12998 
12999 
13000  llrp_bool_t
13001  isAllowedIn (
13002  const CTypeDescriptor * pEnclosingElementType) const;
13003 
13004 
13005  static CElement *
13006  s_construct (void);
13007 
13008  static void
13009  s_decodeFields (
13010  CDecoderStream * pDecoderStream,
13011  CElement * pElement);
13013 
13014 
13015  protected:
13016  EImpinjDirectionReportType m_eType;
13017 
13020  public:
13021  static const CFieldDescriptor
13022  s_fdType;
13024 
13026  inline EImpinjDirectionReportType
13027  getType (void)
13028  {
13029  return m_eType;
13030  }
13031 
13033  inline void
13035  EImpinjDirectionReportType value)
13036  {
13037  m_eType = value;
13038  }
13039 
13040 
13041  protected:
13042  EImpinjDirectionTagPopulationStatus m_eTagPopulationStatus;
13043 
13046  public:
13047  static const CFieldDescriptor
13048  s_fdTagPopulationStatus;
13050 
13052  inline EImpinjDirectionTagPopulationStatus
13054  {
13055  return m_eTagPopulationStatus;
13056  }
13057 
13059  inline void
13061  EImpinjDirectionTagPopulationStatus value)
13062  {
13063  m_eTagPopulationStatus = value;
13064  }
13065 
13066 
13067  protected:
13068  llrp_u8_t m_FirstSeenSectorID;
13069 
13072  public:
13073  static const CFieldDescriptor
13074  s_fdFirstSeenSectorID;
13076 
13078  inline llrp_u8_t
13080  {
13081  return m_FirstSeenSectorID;
13082  }
13083 
13085  inline void
13087  llrp_u8_t value)
13088  {
13089  m_FirstSeenSectorID = value;
13090  }
13091 
13092 
13093  protected:
13094  llrp_u64_t m_FirstSeenTimestampUTC;
13095 
13098  public:
13099  static const CFieldDescriptor
13100  s_fdFirstSeenTimestampUTC;
13102 
13104  inline llrp_u64_t
13106  {
13107  return m_FirstSeenTimestampUTC;
13108  }
13109 
13111  inline void
13113  llrp_u64_t value)
13114  {
13115  m_FirstSeenTimestampUTC = value;
13116  }
13117 
13118 
13119  protected:
13120  llrp_u8_t m_LastSeenSectorID;
13121 
13124  public:
13125  static const CFieldDescriptor
13126  s_fdLastSeenSectorID;
13128 
13130  inline llrp_u8_t
13132  {
13133  return m_LastSeenSectorID;
13134  }
13135 
13137  inline void
13139  llrp_u8_t value)
13140  {
13141  m_LastSeenSectorID = value;
13142  }
13143 
13144 
13145  protected:
13146  llrp_u64_t m_LastSeenTimestampUTC;
13147 
13150  public:
13151  static const CFieldDescriptor
13152  s_fdLastSeenTimestampUTC;
13154 
13156  inline llrp_u64_t
13158  {
13159  return m_LastSeenTimestampUTC;
13160  }
13161 
13163  inline void
13165  llrp_u64_t value)
13166  {
13167  m_LastSeenTimestampUTC = value;
13168  }
13169 
13170 
13171  protected:
13172  CImpinjDirectionDiagnosticData * m_pImpinjDirectionDiagnosticData;
13173 
13174  public:
13178  {
13179  return m_pImpinjDirectionDiagnosticData;
13180  }
13181 
13183  EResultCode
13186 
13187 
13188  protected:
13189  std::list<CParameter *> m_listCustom;
13190 
13191  public:
13193  inline std::list<CParameter *>::iterator
13195  {
13196  return m_listCustom.begin();
13197  }
13198 
13200  inline std::list<CParameter *>::iterator
13201  endCustom (void)
13202  {
13203  return m_listCustom.end();
13204  }
13205 
13207  inline void
13209  {
13210  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13211  }
13212 
13214  inline int
13216  {
13217  return (int) (m_listCustom.size());
13218  }
13219 
13220  EResultCode
13222  addCustom (
13223  CParameter * pValue);
13224 
13225 
13226 };
13227 
13228 
13251 class CImpinjDirectionDiagnosticData : public CParameter
13252 {
13253  public:
13256 
13259 
13260  static const CFieldDescriptor * const
13261  s_apFieldDescriptorTable[];
13262 
13263  static const CTypeDescriptor
13264  s_typeDescriptor;
13265 
13266  void
13267  decodeFields (
13268  CDecoderStream * pDecoderStream);
13269 
13270  void
13271  assimilateSubParameters (
13272  CErrorDetails * pError);
13273 
13274  void
13275  encode (
13276  CEncoderStream * pEncoderStream) const;
13277 
13278 
13279  llrp_bool_t
13280  isAllowedIn (
13281  const CTypeDescriptor * pEnclosingElementType) const;
13282 
13283 
13284  static CElement *
13285  s_construct (void);
13286 
13287  static void
13288  s_decodeFields (
13289  CDecoderStream * pDecoderStream,
13290  CElement * pElement);
13292 
13293 
13294  protected:
13295  llrp_u32v_t m_Metric;
13296 
13299  public:
13300  static const CFieldDescriptor
13301  s_fdMetric;
13303 
13305  inline llrp_u32v_t
13306  getMetric (void)
13307  {
13308  return m_Metric;
13309  }
13310 
13312  inline void
13314  llrp_u32v_t value)
13315  {
13316  m_Metric = value;
13317  }
13318 
13319 
13320 };
13321 
13322 
13347 class CImpinjxArrayDirectionCapabilities : public CParameter
13348 {
13349  public:
13352 
13355 
13356  static const CFieldDescriptor * const
13357  s_apFieldDescriptorTable[];
13358 
13359  static const CTypeDescriptor
13360  s_typeDescriptor;
13361 
13362  void
13363  decodeFields (
13364  CDecoderStream * pDecoderStream);
13365 
13366  void
13367  assimilateSubParameters (
13368  CErrorDetails * pError);
13369 
13370  void
13371  encode (
13372  CEncoderStream * pEncoderStream) const;
13373 
13374 
13375  llrp_bool_t
13376  isAllowedIn (
13377  const CTypeDescriptor * pEnclosingElementType) const;
13378 
13379 
13380  static CElement *
13381  s_construct (void);
13382 
13383  static void
13384  s_decodeFields (
13385  CDecoderStream * pDecoderStream,
13386  CElement * pElement);
13388 
13389 
13390  protected:
13391  llrp_u16_t m_SystemTagPopulationLimitHighSensitivity;
13392 
13395  public:
13396  static const CFieldDescriptor
13397  s_fdSystemTagPopulationLimitHighSensitivity;
13399 
13401  inline llrp_u16_t
13403  {
13404  return m_SystemTagPopulationLimitHighSensitivity;
13405  }
13406 
13408  inline void
13410  llrp_u16_t value)
13411  {
13412  m_SystemTagPopulationLimitHighSensitivity = value;
13413  }
13414 
13415 
13416  protected:
13417  llrp_u16_t m_SystemTagPopulationLimitHighPerformance;
13418 
13421  public:
13422  static const CFieldDescriptor
13423  s_fdSystemTagPopulationLimitHighPerformance;
13425 
13427  inline llrp_u16_t
13429  {
13430  return m_SystemTagPopulationLimitHighPerformance;
13431  }
13432 
13434  inline void
13436  llrp_u16_t value)
13437  {
13438  m_SystemTagPopulationLimitHighPerformance = value;
13439  }
13440 
13441 
13442  protected:
13443  std::list<CParameter *> m_listCustom;
13444 
13445  public:
13447  inline std::list<CParameter *>::iterator
13449  {
13450  return m_listCustom.begin();
13451  }
13452 
13454  inline std::list<CParameter *>::iterator
13455  endCustom (void)
13456  {
13457  return m_listCustom.end();
13458  }
13459 
13461  inline void
13463  {
13464  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13465  }
13466 
13468  inline int
13470  {
13471  return (int) (m_listCustom.size());
13472  }
13473 
13474  EResultCode
13476  addCustom (
13477  CParameter * pValue);
13478 
13479 
13480 };
13481 
13482 
13508 class CImpinjIntelligentAntennaManagement : public CParameter
13509 {
13510  public:
13513 
13516 
13517  static const CFieldDescriptor * const
13518  s_apFieldDescriptorTable[];
13519 
13520  static const CTypeDescriptor
13521  s_typeDescriptor;
13522 
13523  void
13524  decodeFields (
13525  CDecoderStream * pDecoderStream);
13526 
13527  void
13528  assimilateSubParameters (
13529  CErrorDetails * pError);
13530 
13531  void
13532  encode (
13533  CEncoderStream * pEncoderStream) const;
13534 
13535 
13536  llrp_bool_t
13537  isAllowedIn (
13538  const CTypeDescriptor * pEnclosingElementType) const;
13539 
13540 
13541  static CElement *
13542  s_construct (void);
13543 
13544  static void
13545  s_decodeFields (
13546  CDecoderStream * pDecoderStream,
13547  CElement * pElement);
13549 
13550 
13551  protected:
13552  EImpinjIntelligentAntennaMode m_eManagementEnabled;
13553 
13556  public:
13557  static const CFieldDescriptor
13558  s_fdManagementEnabled;
13560 
13562  inline EImpinjIntelligentAntennaMode
13564  {
13565  return m_eManagementEnabled;
13566  }
13567 
13569  inline void
13571  EImpinjIntelligentAntennaMode value)
13572  {
13573  m_eManagementEnabled = value;
13574  }
13575 
13576 
13577  protected:
13578  std::list<CParameter *> m_listCustom;
13579 
13580  public:
13582  inline std::list<CParameter *>::iterator
13584  {
13585  return m_listCustom.begin();
13586  }
13587 
13589  inline std::list<CParameter *>::iterator
13590  endCustom (void)
13591  {
13592  return m_listCustom.end();
13593  }
13594 
13596  inline void
13598  {
13599  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13600  }
13601 
13603  inline int
13605  {
13606  return (int) (m_listCustom.size());
13607  }
13608 
13609  EResultCode
13611  addCustom (
13612  CParameter * pValue);
13613 
13614 
13615 };
13616 
13617 
13644 class CImpinjTransmitPower : public CParameter
13645 {
13646  public:
13647  CImpinjTransmitPower (void);
13648  ~CImpinjTransmitPower (void);
13649 
13652 
13653  static const CFieldDescriptor * const
13654  s_apFieldDescriptorTable[];
13655 
13656  static const CTypeDescriptor
13657  s_typeDescriptor;
13658 
13659  void
13660  decodeFields (
13661  CDecoderStream * pDecoderStream);
13662 
13663  void
13664  assimilateSubParameters (
13665  CErrorDetails * pError);
13666 
13667  void
13668  encode (
13669  CEncoderStream * pEncoderStream) const;
13670 
13671 
13672  llrp_bool_t
13673  isAllowedIn (
13674  const CTypeDescriptor * pEnclosingElementType) const;
13675 
13676 
13677  static CElement *
13678  s_construct (void);
13679 
13680  static void
13681  s_decodeFields (
13682  CDecoderStream * pDecoderStream,
13683  CElement * pElement);
13685 
13686 
13687  protected:
13688  llrp_u16_t m_TransmitPower;
13689 
13692  public:
13693  static const CFieldDescriptor
13694  s_fdTransmitPower;
13696 
13698  inline llrp_u16_t
13700  {
13701  return m_TransmitPower;
13702  }
13703 
13705  inline void
13707  llrp_u16_t value)
13708  {
13709  m_TransmitPower = value;
13710  }
13711 
13712 
13713  protected:
13714  std::list<CParameter *> m_listCustom;
13715 
13716  public:
13718  inline std::list<CParameter *>::iterator
13720  {
13721  return m_listCustom.begin();
13722  }
13723 
13725  inline std::list<CParameter *>::iterator
13726  endCustom (void)
13727  {
13728  return m_listCustom.end();
13729  }
13730 
13732  inline void
13734  {
13735  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13736  }
13737 
13739  inline int
13741  {
13742  return (int) (m_listCustom.size());
13743  }
13744 
13745  EResultCode
13747  addCustom (
13748  CParameter * pValue);
13749 
13750 
13751 };
13752 
13753 
13780 class CImpinjPolarizationControl : public CParameter
13781 {
13782  public:
13785 
13788 
13789  static const CFieldDescriptor * const
13790  s_apFieldDescriptorTable[];
13791 
13792  static const CTypeDescriptor
13793  s_typeDescriptor;
13794 
13795  void
13796  decodeFields (
13797  CDecoderStream * pDecoderStream);
13798 
13799  void
13800  assimilateSubParameters (
13801  CErrorDetails * pError);
13802 
13803  void
13804  encode (
13805  CEncoderStream * pEncoderStream) const;
13806 
13807 
13808  llrp_bool_t
13809  isAllowedIn (
13810  const CTypeDescriptor * pEnclosingElementType) const;
13811 
13812 
13813  static CElement *
13814  s_construct (void);
13815 
13816  static void
13817  s_decodeFields (
13818  CDecoderStream * pDecoderStream,
13819  CElement * pElement);
13821 
13822 
13823  protected:
13824  llrp_u1_t m_PolarizationControlEnabled;
13825 
13828  public:
13829  static const CFieldDescriptor
13830  s_fdPolarizationControlEnabled;
13832 
13834  inline llrp_u1_t
13836  {
13837  return m_PolarizationControlEnabled;
13838  }
13839 
13841  inline void
13843  llrp_u1_t value)
13844  {
13845  m_PolarizationControlEnabled = value;
13846  }
13847 
13848 
13849  protected:
13850  std::list<CParameter *> m_listCustom;
13851 
13852  public:
13854  inline std::list<CParameter *>::iterator
13856  {
13857  return m_listCustom.begin();
13858  }
13859 
13861  inline std::list<CParameter *>::iterator
13862  endCustom (void)
13863  {
13864  return m_listCustom.end();
13865  }
13866 
13868  inline void
13870  {
13871  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13872  }
13873 
13875  inline int
13877  {
13878  return (int) (m_listCustom.size());
13879  }
13880 
13881  EResultCode
13883  addCustom (
13884  CParameter * pValue);
13885 
13886 
13887 };
13888 
13889 
13914 class CImpinjAntennaCapabilities : public CParameter
13915 {
13916  public:
13919 
13922 
13923  static const CFieldDescriptor * const
13924  s_apFieldDescriptorTable[];
13925 
13926  static const CTypeDescriptor
13927  s_typeDescriptor;
13928 
13929  void
13930  decodeFields (
13931  CDecoderStream * pDecoderStream);
13932 
13933  void
13934  assimilateSubParameters (
13935  CErrorDetails * pError);
13936 
13937  void
13938  encode (
13939  CEncoderStream * pEncoderStream) const;
13940 
13941 
13942  llrp_bool_t
13943  isAllowedIn (
13944  const CTypeDescriptor * pEnclosingElementType) const;
13945 
13946 
13947  static CElement *
13948  s_construct (void);
13949 
13950  static void
13951  s_decodeFields (
13952  CDecoderStream * pDecoderStream,
13953  CElement * pElement);
13955 
13956 
13957  protected:
13958  std::list<CImpinjAntennaPolarizationCapability *> m_listImpinjAntennaPolarizationCapability;
13959 
13960  public:
13962  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
13964  {
13965  return m_listImpinjAntennaPolarizationCapability.begin();
13966  }
13967 
13969  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
13971  {
13972  return m_listImpinjAntennaPolarizationCapability.end();
13973  }
13974 
13976  inline void
13978  {
13979  clearSubParameterList ((tListOfParameters *) &m_listImpinjAntennaPolarizationCapability);
13980  }
13981 
13983  inline int
13985  {
13986  return (int) (m_listImpinjAntennaPolarizationCapability.size());
13987  }
13988 
13989  EResultCode
13993 
13994 
13995  protected:
13996  std::list<CParameter *> m_listCustom;
13997 
13998  public:
14000  inline std::list<CParameter *>::iterator
14002  {
14003  return m_listCustom.begin();
14004  }
14005 
14007  inline std::list<CParameter *>::iterator
14008  endCustom (void)
14009  {
14010  return m_listCustom.end();
14011  }
14012 
14014  inline void
14016  {
14017  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14018  }
14019 
14021  inline int
14023  {
14024  return (int) (m_listCustom.size());
14025  }
14026 
14027  EResultCode
14029  addCustom (
14030  CParameter * pValue);
14031 
14032 
14033 };
14034 
14035 
14060 class CImpinjAntennaPolarizationCapability : public CParameter
14061 {
14062  public:
14065 
14068 
14069  static const CFieldDescriptor * const
14070  s_apFieldDescriptorTable[];
14071 
14072  static const CTypeDescriptor
14073  s_typeDescriptor;
14074 
14075  void
14076  decodeFields (
14077  CDecoderStream * pDecoderStream);
14078 
14079  void
14080  assimilateSubParameters (
14081  CErrorDetails * pError);
14082 
14083  void
14084  encode (
14085  CEncoderStream * pEncoderStream) const;
14086 
14087 
14088  llrp_bool_t
14089  isAllowedIn (
14090  const CTypeDescriptor * pEnclosingElementType) const;
14091 
14092 
14093  static CElement *
14094  s_construct (void);
14095 
14096  static void
14097  s_decodeFields (
14098  CDecoderStream * pDecoderStream,
14099  CElement * pElement);
14101 
14102 
14103  protected:
14104  EImpinjAntennaPolarizationType m_eType;
14105 
14108  public:
14109  static const CFieldDescriptor
14110  s_fdType;
14112 
14114  inline EImpinjAntennaPolarizationType
14115  getType (void)
14116  {
14117  return m_eType;
14118  }
14119 
14121  inline void
14123  EImpinjAntennaPolarizationType value)
14124  {
14125  m_eType = value;
14126  }
14127 
14128 
14129  protected:
14130  llrp_u16_t m_AntennaIDOffset;
14131 
14134  public:
14135  static const CFieldDescriptor
14136  s_fdAntennaIDOffset;
14138 
14140  inline llrp_u16_t
14142  {
14143  return m_AntennaIDOffset;
14144  }
14145 
14147  inline void
14149  llrp_u16_t value)
14150  {
14151  m_AntennaIDOffset = value;
14152  }
14153 
14154 
14155  protected:
14156  std::list<CParameter *> m_listCustom;
14157 
14158  public:
14160  inline std::list<CParameter *>::iterator
14162  {
14163  return m_listCustom.begin();
14164  }
14165 
14167  inline std::list<CParameter *>::iterator
14168  endCustom (void)
14169  {
14170  return m_listCustom.end();
14171  }
14172 
14174  inline void
14176  {
14177  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14178  }
14179 
14181  inline int
14183  {
14184  return (int) (m_listCustom.size());
14185  }
14186 
14187  EResultCode
14189  addCustom (
14190  CParameter * pValue);
14191 
14192 
14193 };
14194 
14195 
14219 class CImpinjDisabledAntennas : public CParameter
14220 {
14221  public:
14222  CImpinjDisabledAntennas (void);
14223  ~CImpinjDisabledAntennas (void);
14224 
14227 
14228  static const CFieldDescriptor * const
14229  s_apFieldDescriptorTable[];
14230 
14231  static const CTypeDescriptor
14232  s_typeDescriptor;
14233 
14234  void
14235  decodeFields (
14236  CDecoderStream * pDecoderStream);
14237 
14238  void
14239  assimilateSubParameters (
14240  CErrorDetails * pError);
14241 
14242  void
14243  encode (
14244  CEncoderStream * pEncoderStream) const;
14245 
14246 
14247  llrp_bool_t
14248  isAllowedIn (
14249  const CTypeDescriptor * pEnclosingElementType) const;
14250 
14251 
14252  static CElement *
14253  s_construct (void);
14254 
14255  static void
14256  s_decodeFields (
14257  CDecoderStream * pDecoderStream,
14258  CElement * pElement);
14260 
14261 
14262  protected:
14263  llrp_u16v_t m_AntennaIDs;
14264 
14267  public:
14268  static const CFieldDescriptor
14269  s_fdAntennaIDs;
14271 
14273  inline llrp_u16v_t
14275  {
14276  return m_AntennaIDs;
14277  }
14278 
14280  inline void
14282  llrp_u16v_t value)
14283  {
14284  m_AntennaIDs = value;
14285  }
14286 
14287 
14288  protected:
14289  std::list<CParameter *> m_listCustom;
14290 
14291  public:
14293  inline std::list<CParameter *>::iterator
14295  {
14296  return m_listCustom.begin();
14297  }
14298 
14300  inline std::list<CParameter *>::iterator
14301  endCustom (void)
14302  {
14303  return m_listCustom.end();
14304  }
14305 
14307  inline void
14309  {
14310  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14311  }
14312 
14314  inline int
14316  {
14317  return (int) (m_listCustom.size());
14318  }
14319 
14320  EResultCode
14322  addCustom (
14323  CParameter * pValue);
14324 
14325 
14326 };
14327 
14328 
14353 class CImpinjTIDParity : public CParameter
14354 {
14355  public:
14356  CImpinjTIDParity (void);
14357  ~CImpinjTIDParity (void);
14358 
14361 
14362  static const CFieldDescriptor * const
14363  s_apFieldDescriptorTable[];
14364 
14365  static const CTypeDescriptor
14366  s_typeDescriptor;
14367 
14368  void
14369  decodeFields (
14370  CDecoderStream * pDecoderStream);
14371 
14372  void
14373  assimilateSubParameters (
14374  CErrorDetails * pError);
14375 
14376  void
14377  encode (
14378  CEncoderStream * pEncoderStream) const;
14379 
14380 
14381  llrp_bool_t
14382  isAllowedIn (
14383  const CTypeDescriptor * pEnclosingElementType) const;
14384 
14385 
14386  static CElement *
14387  s_construct (void);
14388 
14389  static void
14390  s_decodeFields (
14391  CDecoderStream * pDecoderStream,
14392  CElement * pElement);
14394 
14395 
14396  protected:
14397  llrp_u1_t m_ParityError;
14398 
14401  public:
14402  static const CFieldDescriptor
14403  s_fdParityError;
14405 
14407  inline llrp_u1_t
14409  {
14410  return m_ParityError;
14411  }
14412 
14414  inline void
14416  llrp_u1_t value)
14417  {
14418  m_ParityError = value;
14419  }
14420 
14421 
14422  protected:
14423  std::list<CParameter *> m_listCustom;
14424 
14425  public:
14427  inline std::list<CParameter *>::iterator
14429  {
14430  return m_listCustom.begin();
14431  }
14432 
14434  inline std::list<CParameter *>::iterator
14435  endCustom (void)
14436  {
14437  return m_listCustom.end();
14438  }
14439 
14441  inline void
14443  {
14444  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14445  }
14446 
14448  inline int
14450  {
14451  return (int) (m_listCustom.size());
14452  }
14453 
14454  EResultCode
14456  addCustom (
14457  CParameter * pValue);
14458 
14459 
14460 };
14461 
14462 
14493 class CImpinjMarginRead : public CParameter
14494 {
14495  public:
14496  CImpinjMarginRead (void);
14497  ~CImpinjMarginRead (void);
14498 
14501 
14502  static const CFieldDescriptor * const
14503  s_apFieldDescriptorTable[];
14504 
14505  static const CTypeDescriptor
14506  s_typeDescriptor;
14507 
14508  void
14509  decodeFields (
14510  CDecoderStream * pDecoderStream);
14511 
14512  void
14513  assimilateSubParameters (
14514  CErrorDetails * pError);
14515 
14516  void
14517  encode (
14518  CEncoderStream * pEncoderStream) const;
14519 
14520 
14521  llrp_bool_t
14522  isAllowedIn (
14523  const CTypeDescriptor * pEnclosingElementType) const;
14524 
14525 
14526  static CElement *
14527  s_construct (void);
14528 
14529  static void
14530  s_decodeFields (
14531  CDecoderStream * pDecoderStream,
14532  CElement * pElement);
14534 
14535 
14536  protected:
14537  llrp_u16_t m_OpSpecID;
14538 
14541  public:
14542  static const CFieldDescriptor
14543  s_fdOpSpecID;
14545 
14547  inline llrp_u16_t
14549  {
14550  return m_OpSpecID;
14551  }
14552 
14554  inline void
14556  llrp_u16_t value)
14557  {
14558  m_OpSpecID = value;
14559  }
14560 
14561 
14562  protected:
14563  llrp_u32_t m_AccessPassword;
14564 
14567  public:
14568  static const CFieldDescriptor
14569  s_fdAccessPassword;
14571 
14573  inline llrp_u32_t
14575  {
14576  return m_AccessPassword;
14577  }
14578 
14580  inline void
14582  llrp_u32_t value)
14583  {
14584  m_AccessPassword = value;
14585  }
14586 
14587 
14588  protected:
14589  llrp_u2_t m_MB;
14590 
14593  public:
14594  static const CFieldDescriptor
14595  s_fdMB;
14597 
14599  inline llrp_u2_t
14600  getMB (void)
14601  {
14602  return m_MB;
14603  }
14604 
14606  inline void
14608  llrp_u2_t value)
14609  {
14610  m_MB = value;
14611  }
14612 
14613 
14614  protected:
14615  llrp_u16_t m_BitPointer;
14616 
14619  public:
14620  static const CFieldDescriptor
14621  s_fdBitPointer;
14623 
14625  inline llrp_u16_t
14627  {
14628  return m_BitPointer;
14629  }
14630 
14632  inline void
14634  llrp_u16_t value)
14635  {
14636  m_BitPointer = value;
14637  }
14638 
14639 
14640  protected:
14641  llrp_u8_t m_BitLength;
14642 
14645  public:
14646  static const CFieldDescriptor
14647  s_fdBitLength;
14649 
14651  inline llrp_u8_t
14653  {
14654  return m_BitLength;
14655  }
14656 
14658  inline void
14660  llrp_u8_t value)
14661  {
14662  m_BitLength = value;
14663  }
14664 
14665 
14666  protected:
14667  llrp_u16v_t m_Mask;
14668 
14671  public:
14672  static const CFieldDescriptor
14673  s_fdMask;
14675 
14677  inline llrp_u16v_t
14678  getMask (void)
14679  {
14680  return m_Mask;
14681  }
14682 
14684  inline void
14686  llrp_u16v_t value)
14687  {
14688  m_Mask = value;
14689  }
14690 
14691 
14692  protected:
14693  std::list<CParameter *> m_listCustom;
14694 
14695  public:
14697  inline std::list<CParameter *>::iterator
14699  {
14700  return m_listCustom.begin();
14701  }
14702 
14704  inline std::list<CParameter *>::iterator
14705  endCustom (void)
14706  {
14707  return m_listCustom.end();
14708  }
14709 
14711  inline void
14713  {
14714  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14715  }
14716 
14718  inline int
14720  {
14721  return (int) (m_listCustom.size());
14722  }
14723 
14724  EResultCode
14726  addCustom (
14727  CParameter * pValue);
14728 
14729 
14730 };
14731 
14732 
14758 class CImpinjMarginReadOpSpecResult : public CParameter
14759 {
14760  public:
14763 
14766 
14767  static const CFieldDescriptor * const
14768  s_apFieldDescriptorTable[];
14769 
14770  static const CTypeDescriptor
14771  s_typeDescriptor;
14772 
14773  void
14774  decodeFields (
14775  CDecoderStream * pDecoderStream);
14776 
14777  void
14778  assimilateSubParameters (
14779  CErrorDetails * pError);
14780 
14781  void
14782  encode (
14783  CEncoderStream * pEncoderStream) const;
14784 
14785 
14786  llrp_bool_t
14787  isAllowedIn (
14788  const CTypeDescriptor * pEnclosingElementType) const;
14789 
14790 
14791  static CElement *
14792  s_construct (void);
14793 
14794  static void
14795  s_decodeFields (
14796  CDecoderStream * pDecoderStream,
14797  CElement * pElement);
14799 
14800 
14801  protected:
14802  EImpinjMarginReadResultType m_eResult;
14803 
14806  public:
14807  static const CFieldDescriptor
14808  s_fdResult;
14810 
14812  inline EImpinjMarginReadResultType
14813  getResult (void)
14814  {
14815  return m_eResult;
14816  }
14817 
14819  inline void
14821  EImpinjMarginReadResultType value)
14822  {
14823  m_eResult = value;
14824  }
14825 
14826 
14827  protected:
14828  llrp_u16_t m_OpSpecID;
14829 
14832  public:
14833  static const CFieldDescriptor
14834  s_fdOpSpecID;
14836 
14838  inline llrp_u16_t
14840  {
14841  return m_OpSpecID;
14842  }
14843 
14845  inline void
14847  llrp_u16_t value)
14848  {
14849  m_OpSpecID = value;
14850  }
14851 
14852 
14853  protected:
14854  std::list<CParameter *> m_listCustom;
14855 
14856  public:
14858  inline std::list<CParameter *>::iterator
14860  {
14861  return m_listCustom.begin();
14862  }
14863 
14865  inline std::list<CParameter *>::iterator
14866  endCustom (void)
14867  {
14868  return m_listCustom.end();
14869  }
14870 
14872  inline void
14874  {
14875  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14876  }
14877 
14879  inline int
14881  {
14882  return (int) (m_listCustom.size());
14883  }
14884 
14885  EResultCode
14887  addCustom (
14888  CParameter * pValue);
14889 
14890 
14891 };
14892 
14893 
14918 class CImpinjBLEVersion : public CParameter
14919 {
14920  public:
14921  CImpinjBLEVersion (void);
14922  ~CImpinjBLEVersion (void);
14923 
14926 
14927  static const CFieldDescriptor * const
14928  s_apFieldDescriptorTable[];
14929 
14930  static const CTypeDescriptor
14931  s_typeDescriptor;
14932 
14933  void
14934  decodeFields (
14935  CDecoderStream * pDecoderStream);
14936 
14937  void
14938  assimilateSubParameters (
14939  CErrorDetails * pError);
14940 
14941  void
14942  encode (
14943  CEncoderStream * pEncoderStream) const;
14944 
14945 
14946  llrp_bool_t
14947  isAllowedIn (
14948  const CTypeDescriptor * pEnclosingElementType) const;
14949 
14950 
14951  static CElement *
14952  s_construct (void);
14953 
14954  static void
14955  s_decodeFields (
14956  CDecoderStream * pDecoderStream,
14957  CElement * pElement);
14959 
14960 
14961  protected:
14962  llrp_utf8v_t m_FirmwareVersion;
14963 
14966  public:
14967  static const CFieldDescriptor
14968  s_fdFirmwareVersion;
14970 
14972  inline llrp_utf8v_t
14974  {
14975  return m_FirmwareVersion;
14976  }
14977 
14979  inline void
14981  llrp_utf8v_t value)
14982  {
14983  m_FirmwareVersion = value;
14984  }
14985 
14986 
14987  protected:
14988  std::list<CParameter *> m_listCustom;
14989 
14990  public:
14992  inline std::list<CParameter *>::iterator
14994  {
14995  return m_listCustom.begin();
14996  }
14997 
14999  inline std::list<CParameter *>::iterator
15000  endCustom (void)
15001  {
15002  return m_listCustom.end();
15003  }
15004 
15006  inline void
15008  {
15009  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15010  }
15011 
15013  inline int
15015  {
15016  return (int) (m_listCustom.size());
15017  }
15018 
15019  EResultCode
15021  addCustom (
15022  CParameter * pValue);
15023 
15024 
15025 };
15026 
15027 
15051 class CImpinjLocationAlgorithmControl : public CParameter
15052 {
15053  public:
15056 
15059 
15060  static const CFieldDescriptor * const
15061  s_apFieldDescriptorTable[];
15062 
15063  static const CTypeDescriptor
15064  s_typeDescriptor;
15065 
15066  void
15067  decodeFields (
15068  CDecoderStream * pDecoderStream);
15069 
15070  void
15071  assimilateSubParameters (
15072  CErrorDetails * pError);
15073 
15074  void
15075  encode (
15076  CEncoderStream * pEncoderStream) const;
15077 
15078 
15079  llrp_bool_t
15080  isAllowedIn (
15081  const CTypeDescriptor * pEnclosingElementType) const;
15082 
15083 
15084  static CElement *
15085  s_construct (void);
15086 
15087  static void
15088  s_decodeFields (
15089  CDecoderStream * pDecoderStream,
15090  CElement * pElement);
15092 
15093 
15094  protected:
15095  llrp_u32v_t m_ControlData;
15096 
15099  public:
15100  static const CFieldDescriptor
15101  s_fdControlData;
15103 
15105  inline llrp_u32v_t
15107  {
15108  return m_ControlData;
15109  }
15110 
15112  inline void
15114  llrp_u32v_t value)
15115  {
15116  m_ControlData = value;
15117  }
15118 
15119 
15120  protected:
15121  std::list<CParameter *> m_listCustom;
15122 
15123  public:
15125  inline std::list<CParameter *>::iterator
15127  {
15128  return m_listCustom.begin();
15129  }
15130 
15132  inline std::list<CParameter *>::iterator
15133  endCustom (void)
15134  {
15135  return m_listCustom.end();
15136  }
15137 
15139  inline void
15141  {
15142  clearSubParameterList ((tListOfParameters *) &m_listCustom);
15143  }
15144 
15146  inline int
15148  {
15149  return (int) (m_listCustom.size());
15150  }
15151 
15152  EResultCode
15154  addCustom (
15155  CParameter * pValue);
15156 
15157 
15158 };
15159 
15160 
15175 extern void
15177  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.
llrp_u32v_t getControlData(void)
Get accessor functions for the LLRP ControlData field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s32_t getYAxis(void)
Get accessor functions for the LLRP YAxis field.
llrp_u64_t getLastSeenTimestampUTC(void)
Get accessor functions for the LLRP LastSeenTimestampUTC field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u8_t getLastSeenSectorID(void)
Get accessor functions for the LLRP LastSeenSectorID field.
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.
Class Definition CImpinjLocationAlgorithmControl for LLRP parameter ImpinjLocationAlgorithmControl.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setMaxNumSectors(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumSectors field.
void setXAxis(llrp_s32_t value)
Set accessor functions for the LLRP XAxis field.
EResultCode setImpinjBlockWriteWordCount(CImpinjBlockWriteWordCount *pValue)
Set accessor functions for the LLRP ImpinjBlockWriteWordCount sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u8_t getFirstSeenSectorID(void)
Get accessor functions for the LLRP FirstSeenSectorID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjLISpec for LLRP parameter ImpinjLISpec.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode setImpinjDirectionSectors(CImpinjDirectionSectors *pValue)
Set accessor functions for the LLRP ImpinjDirectionSectors sub-parameter.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getLatitude(void)
Get accessor functions for the LLRP Latitude field.
EResultCode setImpinjTransmitPower(CImpinjTransmitPower *pValue)
Set accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setSerializedTIDMode(EImpinjSerializedTIDMode value)
Set accessor functions for the LLRP SerializedTIDMode field.
EResultCode setImpinjTransmitPower(CImpinjTransmitPower *pValue)
Set accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
Class Definition CImpinjDirectionReportData for LLRP parameter ImpinjDirectionReportData.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setFieldPingInterval(llrp_u16_t value)
Set accessor functions for the LLRP FieldPingInterval field.
llrp_u1_t getEnableAntennaAttemptNotification(void)
Get accessor functions for the LLRP EnableAntennaAttemptNotification field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjBLEVersion for LLRP parameter ImpinjBLEVersion.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode setImpinjLocationConfidence(CImpinjLocationConfidence *pValue)
Set accessor functions for the LLRP ImpinjLocationConfidence sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjLocationReportData for LLRP parameter ImpinjLocationReportData.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjLinkMonitorMode getLinkMonitorMode(void)
Get accessor functions for the LLRP LinkMonitorMode field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void 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 addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode setImpinjEnablePeakRSSI(CImpinjEnablePeakRSSI *pValue)
Set accessor functions for the LLRP ImpinjEnablePeakRSSI sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjC1G2LocationConfig * getImpinjC1G2LocationConfig(void)
Get accessor functions for the LLRP ImpinjC1G2LocationConfig sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setMetric(llrp_u32v_t value)
Set accessor functions for the LLRP Metric field.
CImpinjBlockWriteWordCount * getImpinjBlockWriteWordCount(void)
Get accessor functions for the LLRP ImpinjBlockWriteWordCount sub-parameter.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
void setLinkDownThreshold(llrp_u16_t value)
Set accessor functions for the LLRP LinkDownThreshold field.
Class Definition CImpinjGPSNMEASentences for LLRP parameter ImpinjGPSNMEASentences.
Class Definition CImpinjDiagnosticReport for LLRP parameter ImpinjDiagnosticReport.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EImpinjDirectionTagPopulationStatus getTagPopulationStatus(void)
Get accessor functions for the LLRP TagPopulationStatus field.
void setPersistence(EImpinjQTPersistence value)
Set accessor functions for the LLRP Persistence field.
llrp_u1_t getEnableUpdateReport(void)
Get accessor functions for the LLRP EnableUpdateReport field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setLocYCentimeters(llrp_s32_t value)
Set accessor functions for the LLRP LocYCentimeters field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u16_t getBlockPointer(void)
Get accessor functions for the LLRP BlockPointer field.
llrp_u32v_t getConfidenceData(void)
Get accessor functions for the LLRP ConfidenceData field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setLowDutyCycleMode(EImpinjLowDutyCycleMode value)
Set accessor functions for the LLRP LowDutyCycleMode field.
llrp_u16v_t getMask(void)
Get accessor functions for the LLRP Mask field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EImpinjIntelligentAntennaMode getManagementEnabled(void)
Get accessor functions for the LLRP ManagementEnabled field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjxArrayCapabilities for LLRP parameter ImpinjxArrayCapabilities.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setUpdateIntervalSeconds(llrp_u16_t value)
Set accessor functions for the LLRP UpdateIntervalSeconds field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjBlockPermalockOpSpecResult for LLRP parameter ImpinjBlockPermalockOpSpecResul...
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
CImpinjRMCSentence * getImpinjRMCSentence(void)
Get accessor functions for the LLRP ImpinjRMCSentence sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode setImpinjLocationConfig(CImpinjLocationConfig *pValue)
Set accessor functions for the LLRP ImpinjLocationConfig sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjArrayVersion for LLRP parameter ImpinjArrayVersion.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
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.
void setControlData(llrp_u32v_t value)
Set accessor functions for the LLRP ControlData field.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
Class Definition CImpinjLocationConfig for LLRP parameter ImpinjLocationConfig.
Class Definition CLLRPStatus for LLRP parameter LLRPStatus.
Definition: out_ltkcpp.h:18888
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEnableEntryReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableEntryReport field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setPCBAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP PCBAVersion field.
void setAntennaIDOffset(llrp_u16_t value)
Set accessor functions for the LLRP AntennaIDOffset field.
void setFPGAVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FPGAVersion field.
void setLatitude(llrp_s32_t value)
Set accessor functions for the LLRP Latitude field.
void setRequestedData(EImpinjRequestedDataType value)
Set accessor functions for the LLRP RequestedData field.
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 clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setLocXCentimeters(llrp_s32_t value)
Set accessor functions for the LLRP LocXCentimeters field.
EResultCode setImpinjAntennaEventHysteresis(CImpinjAntennaEventHysteresis *pValue)
Set accessor functions for the LLRP ImpinjAntennaEventHysteresis sub-parameter.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
int countC1G2Read(void)
Count of the LLRP C1G2Read sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CC1G2Read * >::iterator beginC1G2Read(void)
Returns the first element of the C1G2Read sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjDirectionConfig * getImpinjDirectionConfig(void)
Get accessor functions for the LLRP ImpinjDirectionConfig sub-parameter.
llrp_u16_t getLinkDownThreshold(void)
Get accessor functions for the LLRP LinkDownThreshold field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setSaveConfiguration(llrp_u1_t value)
Set accessor functions for the LLRP SaveConfiguration field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjLocationConfig * getImpinjLocationConfig(void)
Get accessor functions for the LLRP ImpinjLocationConfig sub-parameter.
llrp_u64_t getAntennaEventDisconnected(void)
Get accessor functions for the LLRP AntennaEventDisconnected field.
void setPermalockStatus(llrp_u16v_t value)
Set accessor functions for the LLRP PermalockStatus field.
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.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode setImpinjC1G2DirectionConfig(CImpinjC1G2DirectionConfig *pValue)
Set accessor functions for the LLRP ImpinjC1G2DirectionConfig sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u16_t getHubID(void)
Get accessor functions for the LLRP HubID field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setOrderingMode(EImpinjAccessSpecOrderingMode value)
Set accessor functions for the LLRP OrderingMode field.
llrp_u16_t getPhaseAngle(void)
Get accessor functions for the LLRP PhaseAngle field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setAccessRange(EImpinjQTAccessRange value)
Set accessor functions for the LLRP AccessRange field.
llrp_utf8v_t getSerialNumber(void)
Get accessor functions for the LLRP SerialNumber field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode setImpinjDirectionReportData(CImpinjDirectionReportData *pValue)
Set accessor functions for the LLRP ImpinjDirectionReportData sub-parameter.
llrp_u16_t getWordCount(void)
Get accessor functions for the LLRP WordCount field.
CImpinjC1G2DirectionConfig * getImpinjC1G2DirectionConfig(void)
Get accessor functions for the LLRP ImpinjC1G2DirectionConfig sub-parameter.
llrp_u16_t getBlockRange(void)
Get accessor functions for the LLRP BlockRange field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CImpinjAntennaPolarizationCapability * >::iterator endImpinjAntennaPolarizationCapability(void)
Returns the last element of the ImpinjAntennaPolarizationCapability sub-parameter list...
llrp_u1_t getPolarizationControlEnabled(void)
Get accessor functions for the LLRP PolarizationControlEnabled field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setRSSI(llrp_s16_t value)
Set accessor functions for the LLRP RSSI field.
Class Definition CImpinjDetailedVersion for LLRP parameter ImpinjDetailedVersion. ...
std::list< CC1G2Filter * >::iterator beginC1G2Filter(void)
Returns the first element of the C1G2Filter sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjGPSCoordinates for LLRP parameter ImpinjGPSCoordinates.
llrp_u32v_t getMetric(void)
Get accessor functions for the LLRP Metric field.
Class Definition CImpinjReaderTemperature for LLRP parameter ImpinjReaderTemperature.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setLastSeenTimestampUTC(llrp_u64_t value)
Set accessor functions for the LLRP LastSeenTimestampUTC field.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjEnableRFDopplerFrequency for LLRP parameter ImpinjEnableRFDopplerFrequency.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjHubVersions for LLRP parameter ImpinjHubVersions.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjFixedFrequencyMode getFixedFrequencyMode(void)
Get accessor functions for the LLRP FixedFrequencyMode field.
Class Definition CImpinjOpSpecRetryCount for LLRP parameter ImpinjOpSpecRetryCount.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setChannelList(llrp_u16v_t value)
Set accessor functions for the LLRP ChannelList field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode setImpinjDirectionConfig(CImpinjDirectionConfig *pValue)
Set accessor functions for the LLRP ImpinjDirectionConfig sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjxArrayDirectionCapabilities * getImpinjxArrayDirectionCapabilities(void)
Get accessor functions for the LLRP ImpinjxArrayDirectionCapabilities sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
llrp_utf8v_t getPCBAVersion(void)
Get accessor functions for the LLRP PCBAVersion field.
void setSupportsTSISpecs(llrp_u1_t value)
Set accessor functions for the LLRP SupportsTSISpecs field.
void setTagPopulationStatus(EImpinjDirectionTagPopulationStatus value)
Set accessor functions for the LLRP TagPopulationStatus field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_u16v_t getAntennaIDs(void)
Get accessor functions for the LLRP AntennaIDs field.
int countEPCData(void)
Count of the LLRP EPCData sub-parameter list.
void setFrequencyList(llrp_u32v_t value)
Set accessor functions for the LLRP FrequencyList field.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Class Definition CImpinjDirectionReporting for LLRP parameter ImpinjDirectionReporting.
void setTransmitPower(llrp_u16_t value)
Set accessor functions for the LLRP TransmitPower field.
llrp_u32_t getLoopCount(void)
Get accessor functions for the LLRP LoopCount field.
llrp_u1_t getEnableUpdateReport(void)
Get accessor functions for the LLRP EnableUpdateReport field.
llrp_u1_t getSaveConfiguration(void)
Get accessor functions for the LLRP SaveConfiguration field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
Class Definition CImpinjGetBlockPermalockStatus for LLRP parameter ImpinjGetBlockPermalockStatus.
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setDiagnosticReportLevel(EImpinjDirectionDiagnosticReportLevel value)
Set accessor functions for the LLRP DiagnosticReportLevel field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearEPCData(void)
Clears the LLRP EPCData sub-parameter list.
std::list< CImpinjArrayVersion * >::iterator endImpinjArrayVersion(void)
Returns the last element of the ImpinjArrayVersion sub-parameter list.
Class Definition CImpinjTIDParity for LLRP parameter ImpinjTIDParity.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countImpinjArrayVersion(void)
Count of the LLRP ImpinjArrayVersion sub-parameter list.
llrp_utf8v_t getGGASentence(void)
Get accessor functions for the LLRP GGASentence field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjGetBlockPermalockStatusResultType getResult(void)
Get accessor functions for the LLRP Result field.
llrp_u1_t getEnableSelectGapClose(void)
Get accessor functions for the LLRP EnableSelectGapClose field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
llrp_u64_t getBeaconDurationSeconds(void)
Get accessor functions for the LLRP BeaconDurationSeconds field.
void setBeaconDurationSeconds(llrp_u64_t value)
Set accessor functions for the LLRP BeaconDurationSeconds field.
void setRetryCount(llrp_u16_t value)
Set accessor functions for the LLRP RetryCount field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addEPCData(CEPCData *pValue)
Add a EPCData to the LLRP sub-parameter list.
EImpinjQTPersistence getPersistence(void)
Get accessor functions for the LLRP Persistence field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CC1G2Filter * >::iterator endC1G2Filter(void)
Returns the last element of the C1G2Filter sub-parameter list.
void setFault(EImpinjHubFaultType value)
Set accessor functions for the LLRP Fault field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EImpinjSerializedTIDMode getSerializedTIDMode(void)
Get accessor functions for the LLRP SerializedTIDMode field.
Class Definition CC1G2Read for LLRP parameter C1G2Read.
Definition: out_ltkcpp.h:21571
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
CImpinjLocationReporting * getImpinjLocationReporting(void)
Get accessor functions for the LLRP ImpinjLocationReporting sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setComputeWindowSeconds(llrp_u16_t value)
Set accessor functions for the LLRP ComputeWindowSeconds field.
void setGGASentence(llrp_utf8v_t value)
Set accessor functions for the LLRP GGASentence field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setConfidenceData(llrp_u32v_t value)
Set accessor functions for the LLRP ConfidenceData field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Class Definition CImpinjAntennaAttemptEvent for LLRP parameter ImpinjAntennaAttemptEvent.
void setEnableExitReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableExitReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjDirectionSectors for LLRP parameter ImpinjDirectionSectors.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setGPSCoordinatesMode(EImpinjGPSCoordinatesMode value)
Set accessor functions for the LLRP GPSCoordinatesMode field.
EImpinjSetQTConfigResultType getResult(void)
Get accessor functions for the LLRP Result field.
CImpinjDirectionDiagnosticData * getImpinjDirectionDiagnosticData(void)
Get accessor functions for the LLRP ImpinjDirectionDiagnosticData sub-parameter.
void setBlockMask(llrp_u16v_t value)
Set accessor functions for the LLRP BlockMask field.
void setSoftwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP SoftwareVersion field.
llrp_u64_t getFirstSeenTimestampUTC(void)
Get accessor functions for the LLRP FirstSeenTimestampUTC field.
llrp_s32_t getLongitude(void)
Get accessor functions for the LLRP Longitude field.
EResultCode setImpinjLocationAlgorithmControl(CImpinjLocationAlgorithmControl *pValue)
Set accessor functions for the LLRP ImpinjLocationAlgorithmControl sub-parameter. ...
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.
CImpinjLocationAlgorithmControl * getImpinjLocationAlgorithmControl(void)
Get accessor functions for the LLRP ImpinjLocationAlgorithmControl sub-parameter. ...
Class Definition CImpinjEnableOptimizedRead for LLRP parameter ImpinjEnableOptimizedRead.
Class Definition CImpinjRequestedData for LLRP parameter ImpinjRequestedData.
EImpinjPeakRSSIMode getPeakRSSIMode(void)
Get accessor functions for the LLRP PeakRSSIMode field.
void setEnableEntryReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableEntryReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.