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;
83 class CImpinjLISpec;
89 class CImpinjDISpec;
105 class CImpinjTIDParity;
106 
107 /*
108  * Vendor descriptor declarations.
109  */
110 
111 extern const CVendorDescriptor
112 g_vdescImpinj;
113 
114 
115 /*
116  * Namespace descriptor declarations.
117  */
118 
119 extern const CNamespaceDescriptor
120 g_nsdescImpinj;
121 
122 
123 /*
124  * Enumeration definitions and declarations of
125  * enumeration string tables.
126  */
127 
128 
160 enum EImpinjRequestedDataType
161 {
163 };
164 
165 extern const SEnumTableEntry
166 g_estImpinjRequestedDataType[];
167 
168 
202 enum EImpinjRegulatoryRegion
203 {
205 };
206 
207 extern const SEnumTableEntry
208 g_estImpinjRegulatoryRegion[];
209 
210 
225 enum EImpinjInventorySearchType
226 {
228 };
229 
230 extern const SEnumTableEntry
231 g_estImpinjInventorySearchType[];
232 
233 
244 enum EImpinjFixedFrequencyMode
245 {
247 };
248 
249 extern const SEnumTableEntry
250 g_estImpinjFixedFrequencyMode[];
251 
252 
262 enum EImpinjReducedPowerMode
263 {
265 };
266 
267 extern const SEnumTableEntry
268 g_estImpinjReducedPowerMode[];
269 
270 
280 enum EImpinjLowDutyCycleMode
281 {
283 };
284 
285 extern const SEnumTableEntry
286 g_estImpinjLowDutyCycleMode[];
287 
288 
298 enum EImpinjLinkMonitorMode
299 {
301 };
302 
303 extern const SEnumTableEntry
304 g_estImpinjLinkMonitorMode[];
305 
306 
316 enum EImpinjReportBufferMode
317 {
319 };
320 
321 extern const SEnumTableEntry
322 g_estImpinjReportBufferMode[];
323 
324 
339 enum EImpinjBlockPermalockResultType
340 {
342 };
343 
344 extern const SEnumTableEntry
345 g_estImpinjBlockPermalockResultType[];
346 
347 
361 enum EImpinjGetBlockPermalockStatusResultType
362 {
364 };
365 
366 extern const SEnumTableEntry
367 g_estImpinjGetBlockPermalockStatusResultType[];
368 
369 
380 enum EImpinjQTDataProfile
381 {
383 };
384 
385 extern const SEnumTableEntry
386 g_estImpinjQTDataProfile[];
387 
388 
399 enum EImpinjQTAccessRange
400 {
402 };
403 
404 extern const SEnumTableEntry
405 g_estImpinjQTAccessRange[];
406 
407 
418 enum EImpinjQTPersistence
419 {
421 };
422 
423 extern const SEnumTableEntry
424 g_estImpinjQTPersistence[];
425 
426 
440 enum EImpinjSetQTConfigResultType
441 {
443 };
444 
445 extern const SEnumTableEntry
446 g_estImpinjSetQTConfigResultType[];
447 
448 
461 enum EImpinjGetQTConfigResultType
462 {
464 };
465 
466 extern const SEnumTableEntry
467 g_estImpinjGetQTConfigResultType[];
468 
469 
479 enum EImpinjSerializedTIDMode
480 {
482 };
483 
484 extern const SEnumTableEntry
485 g_estImpinjSerializedTIDMode[];
486 
487 
497 enum EImpinjRFPhaseAngleMode
498 {
500 };
501 
502 extern const SEnumTableEntry
503 g_estImpinjRFPhaseAngleMode[];
504 
505 
515 enum EImpinjPeakRSSIMode
516 {
518 };
519 
520 extern const SEnumTableEntry
521 g_estImpinjPeakRSSIMode[];
522 
523 
533 enum EImpinjGPSCoordinatesMode
534 {
536 };
537 
538 extern const SEnumTableEntry
539 g_estImpinjGPSCoordinatesMode[];
540 
541 
556 enum EImpinjAdvancedGPOMode
557 {
559 };
560 
561 extern const SEnumTableEntry
562 g_estImpinjAdvancedGPOMode[];
563 
564 
574 enum EImpinjOptimizedReadMode
575 {
577 };
578 
579 extern const SEnumTableEntry
580 g_estImpinjOptimizedReadMode[];
581 
582 
592 enum EImpinjAccessSpecOrderingMode
593 {
595 };
596 
597 extern const SEnumTableEntry
598 g_estImpinjAccessSpecOrderingMode[];
599 
600 
610 enum EImpinjRFDopplerFrequencyMode
611 {
613 };
614 
615 extern const SEnumTableEntry
616 g_estImpinjRFDopplerFrequencyMode[];
617 
618 
629 enum EImpinjHubConnectedType
630 {
632 };
633 
634 extern const SEnumTableEntry
635 g_estImpinjHubConnectedType[];
636 
637 
654 enum EImpinjHubFaultType
655 {
657 };
658 
659 extern const SEnumTableEntry
660 g_estImpinjHubFaultType[];
661 
662 
673 enum EImpinjLocationReportType
674 {
676 };
677 
678 extern const SEnumTableEntry
679 g_estImpinjLocationReportType[];
680 
681 
725 enum EImpinjDirectionFieldOfView
726 {
728 };
729 
730 extern const SEnumTableEntry
731 g_estImpinjDirectionFieldOfView[];
732 
733 
768 enum EImpinjDirectionRFMode
769 {
771 };
772 
773 extern const SEnumTableEntry
774 g_estImpinjDirectionRFMode[];
775 
776 
826 enum EImpinjDirectionDiagnosticReportLevel
827 {
829 };
830 
831 extern const SEnumTableEntry
832 g_estImpinjDirectionDiagnosticReportLevel[];
833 
834 
873 enum EImpinjDirectionReportType
874 {
876 };
877 
878 extern const SEnumTableEntry
879 g_estImpinjDirectionReportType[];
880 
881 
920 enum EImpinjDirectionTagPopulationStatus
921 {
923 };
924 
925 extern const SEnumTableEntry
926 g_estImpinjDirectionTagPopulationStatus[];
927 
928 
938 enum EImpinjIntelligentAntennaMode
939 {
941 };
942 
943 extern const SEnumTableEntry
944 g_estImpinjIntelligentAntennaMode[];
945 
946 
958 enum EImpinjAntennaPolarizationType
959 {
961 };
962 
963 extern const SEnumTableEntry
964 g_estImpinjAntennaPolarizationType[];
965 
966 
972 
996 class CIMPINJ_ENABLE_EXTENSIONS : public CMessage
997 {
998  public:
1000  ~CIMPINJ_ENABLE_EXTENSIONS (void);
1001 
1004 
1005  static const CFieldDescriptor * const
1006  s_apFieldDescriptorTable[];
1007 
1008  static const CTypeDescriptor
1009  s_typeDescriptor;
1010 
1011  void
1012  decodeFields (
1013  CDecoderStream * pDecoderStream);
1014 
1015  void
1016  assimilateSubParameters (
1017  CErrorDetails * pError);
1018 
1019  void
1020  encode (
1021  CEncoderStream * pEncoderStream) const;
1022 
1023 
1024 
1025  static CElement *
1026  s_construct (void);
1027 
1028  static void
1029  s_decodeFields (
1030  CDecoderStream * pDecoderStream,
1031  CElement * pElement);
1033 
1034 
1035  protected:
1036  std::list<CParameter *> m_listCustom;
1037 
1038  public:
1040  inline std::list<CParameter *>::iterator
1042  {
1043  return m_listCustom.begin();
1044  }
1045 
1047  inline std::list<CParameter *>::iterator
1048  endCustom (void)
1049  {
1050  return m_listCustom.end();
1051  }
1052 
1054  inline void
1056  {
1057  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1058  }
1059 
1061  inline int
1063  {
1064  return (int) (m_listCustom.size());
1065  }
1066 
1067  EResultCode
1069  addCustom (
1070  CParameter * pValue);
1071 
1072 
1073 };
1074 
1075 
1099 class CIMPINJ_ENABLE_EXTENSIONS_RESPONSE : public CMessage
1100 {
1101  public:
1104 
1107 
1108  static const CFieldDescriptor * const
1109  s_apFieldDescriptorTable[];
1110 
1111  static const CTypeDescriptor
1112  s_typeDescriptor;
1113 
1114  void
1115  decodeFields (
1116  CDecoderStream * pDecoderStream);
1117 
1118  void
1119  assimilateSubParameters (
1120  CErrorDetails * pError);
1121 
1122  void
1123  encode (
1124  CEncoderStream * pEncoderStream) const;
1125 
1126 
1127 
1128  static CElement *
1129  s_construct (void);
1130 
1131  static void
1132  s_decodeFields (
1133  CDecoderStream * pDecoderStream,
1134  CElement * pElement);
1136 
1137 
1138  protected:
1139  CLLRPStatus * m_pLLRPStatus;
1140 
1141  public:
1143  inline CLLRPStatus *
1145  {
1146  return m_pLLRPStatus;
1147  }
1148 
1150  EResultCode
1151  setLLRPStatus (
1152  CLLRPStatus * pValue);
1153 
1154 
1155  protected:
1156  std::list<CParameter *> m_listCustom;
1157 
1158  public:
1160  inline std::list<CParameter *>::iterator
1162  {
1163  return m_listCustom.begin();
1164  }
1165 
1167  inline std::list<CParameter *>::iterator
1168  endCustom (void)
1169  {
1170  return m_listCustom.end();
1171  }
1172 
1174  inline void
1176  {
1177  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1178  }
1179 
1181  inline int
1183  {
1184  return (int) (m_listCustom.size());
1185  }
1186 
1187  EResultCode
1189  addCustom (
1190  CParameter * pValue);
1191 
1192 
1193 };
1194 
1195 
1229 class CIMPINJ_SAVE_SETTINGS : public CMessage
1230 {
1231  public:
1232  CIMPINJ_SAVE_SETTINGS (void);
1233  ~CIMPINJ_SAVE_SETTINGS (void);
1234 
1237 
1238  static const CFieldDescriptor * const
1239  s_apFieldDescriptorTable[];
1240 
1241  static const CTypeDescriptor
1242  s_typeDescriptor;
1243 
1244  void
1245  decodeFields (
1246  CDecoderStream * pDecoderStream);
1247 
1248  void
1249  assimilateSubParameters (
1250  CErrorDetails * pError);
1251 
1252  void
1253  encode (
1254  CEncoderStream * pEncoderStream) const;
1255 
1256 
1257 
1258  static CElement *
1259  s_construct (void);
1260 
1261  static void
1262  s_decodeFields (
1263  CDecoderStream * pDecoderStream,
1264  CElement * pElement);
1266 
1267 
1268  protected:
1269  llrp_u1_t m_SaveConfiguration;
1270 
1273  public:
1274  static const CFieldDescriptor
1275  s_fdSaveConfiguration;
1277 
1279  inline llrp_u1_t
1281  {
1282  return m_SaveConfiguration;
1283  }
1284 
1286  inline void
1288  llrp_u1_t value)
1289  {
1290  m_SaveConfiguration = value;
1291  }
1292 
1293 
1294  protected:
1295  std::list<CParameter *> m_listCustom;
1296 
1297  public:
1299  inline std::list<CParameter *>::iterator
1301  {
1302  return m_listCustom.begin();
1303  }
1304 
1306  inline std::list<CParameter *>::iterator
1307  endCustom (void)
1308  {
1309  return m_listCustom.end();
1310  }
1311 
1313  inline void
1315  {
1316  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1317  }
1318 
1320  inline int
1322  {
1323  return (int) (m_listCustom.size());
1324  }
1325 
1326  EResultCode
1328  addCustom (
1329  CParameter * pValue);
1330 
1331 
1332 };
1333 
1334 
1358 class CIMPINJ_SAVE_SETTINGS_RESPONSE : public CMessage
1359 {
1360  public:
1363 
1366 
1367  static const CFieldDescriptor * const
1368  s_apFieldDescriptorTable[];
1369 
1370  static const CTypeDescriptor
1371  s_typeDescriptor;
1372 
1373  void
1374  decodeFields (
1375  CDecoderStream * pDecoderStream);
1376 
1377  void
1378  assimilateSubParameters (
1379  CErrorDetails * pError);
1380 
1381  void
1382  encode (
1383  CEncoderStream * pEncoderStream) const;
1384 
1385 
1386 
1387  static CElement *
1388  s_construct (void);
1389 
1390  static void
1391  s_decodeFields (
1392  CDecoderStream * pDecoderStream,
1393  CElement * pElement);
1395 
1396 
1397  protected:
1398  CLLRPStatus * m_pLLRPStatus;
1399 
1400  public:
1402  inline CLLRPStatus *
1404  {
1405  return m_pLLRPStatus;
1406  }
1407 
1409  EResultCode
1410  setLLRPStatus (
1411  CLLRPStatus * pValue);
1412 
1413 
1414  protected:
1415  std::list<CParameter *> m_listCustom;
1416 
1417  public:
1419  inline std::list<CParameter *>::iterator
1421  {
1422  return m_listCustom.begin();
1423  }
1424 
1426  inline std::list<CParameter *>::iterator
1427  endCustom (void)
1428  {
1429  return m_listCustom.end();
1430  }
1431 
1433  inline void
1435  {
1436  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1437  }
1438 
1440  inline int
1442  {
1443  return (int) (m_listCustom.size());
1444  }
1445 
1446  EResultCode
1448  addCustom (
1449  CParameter * pValue);
1450 
1451 
1452 };
1453 
1454 
1462 
1485 class CImpinjRequestedData : public CParameter
1486 {
1487  public:
1488  CImpinjRequestedData (void);
1489  ~CImpinjRequestedData (void);
1490 
1493 
1494  static const CFieldDescriptor * const
1495  s_apFieldDescriptorTable[];
1496 
1497  static const CTypeDescriptor
1498  s_typeDescriptor;
1499 
1500  void
1501  decodeFields (
1502  CDecoderStream * pDecoderStream);
1503 
1504  void
1505  assimilateSubParameters (
1506  CErrorDetails * pError);
1507 
1508  void
1509  encode (
1510  CEncoderStream * pEncoderStream) const;
1511 
1512 
1513  llrp_bool_t
1514  isAllowedIn (
1515  const CTypeDescriptor * pEnclosingElementType) const;
1516 
1517 
1518  static CElement *
1519  s_construct (void);
1520 
1521  static void
1522  s_decodeFields (
1523  CDecoderStream * pDecoderStream,
1524  CElement * pElement);
1526 
1527 
1528  protected:
1529  EImpinjRequestedDataType m_eRequestedData;
1530 
1533  public:
1534  static const CFieldDescriptor
1535  s_fdRequestedData;
1537 
1539  inline EImpinjRequestedDataType
1541  {
1542  return m_eRequestedData;
1543  }
1544 
1546  inline void
1548  EImpinjRequestedDataType value)
1549  {
1550  m_eRequestedData = value;
1551  }
1552 
1553 
1554  protected:
1555  std::list<CParameter *> m_listCustom;
1556 
1557  public:
1559  inline std::list<CParameter *>::iterator
1561  {
1562  return m_listCustom.begin();
1563  }
1564 
1566  inline std::list<CParameter *>::iterator
1567  endCustom (void)
1568  {
1569  return m_listCustom.end();
1570  }
1571 
1573  inline void
1575  {
1576  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1577  }
1578 
1580  inline int
1582  {
1583  return (int) (m_listCustom.size());
1584  }
1585 
1586  EResultCode
1588  addCustom (
1589  CParameter * pValue);
1590 
1591 
1592 };
1593 
1594 
1623 class CImpinjSubRegulatoryRegion : public CParameter
1624 {
1625  public:
1628 
1631 
1632  static const CFieldDescriptor * const
1633  s_apFieldDescriptorTable[];
1634 
1635  static const CTypeDescriptor
1636  s_typeDescriptor;
1637 
1638  void
1639  decodeFields (
1640  CDecoderStream * pDecoderStream);
1641 
1642  void
1643  assimilateSubParameters (
1644  CErrorDetails * pError);
1645 
1646  void
1647  encode (
1648  CEncoderStream * pEncoderStream) const;
1649 
1650 
1651  llrp_bool_t
1652  isAllowedIn (
1653  const CTypeDescriptor * pEnclosingElementType) const;
1654 
1655 
1656  static CElement *
1657  s_construct (void);
1658 
1659  static void
1660  s_decodeFields (
1661  CDecoderStream * pDecoderStream,
1662  CElement * pElement);
1664 
1665 
1666  protected:
1667  EImpinjRegulatoryRegion m_eRegulatoryRegion;
1668 
1671  public:
1672  static const CFieldDescriptor
1673  s_fdRegulatoryRegion;
1675 
1677  inline EImpinjRegulatoryRegion
1679  {
1680  return m_eRegulatoryRegion;
1681  }
1682 
1684  inline void
1686  EImpinjRegulatoryRegion value)
1687  {
1688  m_eRegulatoryRegion = value;
1689  }
1690 
1691 
1692  protected:
1693  std::list<CParameter *> m_listCustom;
1694 
1695  public:
1697  inline std::list<CParameter *>::iterator
1699  {
1700  return m_listCustom.begin();
1701  }
1702 
1704  inline std::list<CParameter *>::iterator
1705  endCustom (void)
1706  {
1707  return m_listCustom.end();
1708  }
1709 
1711  inline void
1713  {
1714  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1715  }
1716 
1718  inline int
1720  {
1721  return (int) (m_listCustom.size());
1722  }
1723 
1724  EResultCode
1726  addCustom (
1727  CParameter * pValue);
1728 
1729 
1730 };
1731 
1732 
1757 class CImpinjInventorySearchMode : public CParameter
1758 {
1759  public:
1762 
1765 
1766  static const CFieldDescriptor * const
1767  s_apFieldDescriptorTable[];
1768 
1769  static const CTypeDescriptor
1770  s_typeDescriptor;
1771 
1772  void
1773  decodeFields (
1774  CDecoderStream * pDecoderStream);
1775 
1776  void
1777  assimilateSubParameters (
1778  CErrorDetails * pError);
1779 
1780  void
1781  encode (
1782  CEncoderStream * pEncoderStream) const;
1783 
1784 
1785  llrp_bool_t
1786  isAllowedIn (
1787  const CTypeDescriptor * pEnclosingElementType) const;
1788 
1789 
1790  static CElement *
1791  s_construct (void);
1792 
1793  static void
1794  s_decodeFields (
1795  CDecoderStream * pDecoderStream,
1796  CElement * pElement);
1798 
1799 
1800  protected:
1801  EImpinjInventorySearchType m_eInventorySearchMode;
1802 
1805  public:
1806  static const CFieldDescriptor
1807  s_fdInventorySearchMode;
1809 
1811  inline EImpinjInventorySearchType
1813  {
1814  return m_eInventorySearchMode;
1815  }
1816 
1818  inline void
1820  EImpinjInventorySearchType value)
1821  {
1822  m_eInventorySearchMode = value;
1823  }
1824 
1825 
1826  protected:
1827  std::list<CParameter *> m_listCustom;
1828 
1829  public:
1831  inline std::list<CParameter *>::iterator
1833  {
1834  return m_listCustom.begin();
1835  }
1836 
1838  inline std::list<CParameter *>::iterator
1839  endCustom (void)
1840  {
1841  return m_listCustom.end();
1842  }
1843 
1845  inline void
1847  {
1848  clearSubParameterList ((tListOfParameters *) &m_listCustom);
1849  }
1850 
1852  inline int
1854  {
1855  return (int) (m_listCustom.size());
1856  }
1857 
1858  EResultCode
1860  addCustom (
1861  CParameter * pValue);
1862 
1863 
1864 };
1865 
1866 
1896 class CImpinjFixedFrequencyList : public CParameter
1897 {
1898  public:
1900  ~CImpinjFixedFrequencyList (void);
1901 
1904 
1905  static const CFieldDescriptor * const
1906  s_apFieldDescriptorTable[];
1907 
1908  static const CTypeDescriptor
1909  s_typeDescriptor;
1910 
1911  void
1912  decodeFields (
1913  CDecoderStream * pDecoderStream);
1914 
1915  void
1916  assimilateSubParameters (
1917  CErrorDetails * pError);
1918 
1919  void
1920  encode (
1921  CEncoderStream * pEncoderStream) const;
1922 
1923 
1924  llrp_bool_t
1925  isAllowedIn (
1926  const CTypeDescriptor * pEnclosingElementType) const;
1927 
1928 
1929  static CElement *
1930  s_construct (void);
1931 
1932  static void
1933  s_decodeFields (
1934  CDecoderStream * pDecoderStream,
1935  CElement * pElement);
1937 
1938 
1939  protected:
1940  EImpinjFixedFrequencyMode m_eFixedFrequencyMode;
1941 
1944  public:
1945  static const CFieldDescriptor
1946  s_fdFixedFrequencyMode;
1948 
1950  inline EImpinjFixedFrequencyMode
1952  {
1953  return m_eFixedFrequencyMode;
1954  }
1955 
1957  inline void
1959  EImpinjFixedFrequencyMode value)
1960  {
1961  m_eFixedFrequencyMode = value;
1962  }
1963 
1964 
1965  protected:
1966  llrp_u16v_t m_ChannelList;
1967 
1970  public:
1971  static const CFieldDescriptor
1972  s_fdChannelList;
1974 
1976  inline llrp_u16v_t
1978  {
1979  return m_ChannelList;
1980  }
1981 
1983  inline void
1985  llrp_u16v_t value)
1986  {
1987  m_ChannelList = value;
1988  }
1989 
1990 
1991  protected:
1992  std::list<CParameter *> m_listCustom;
1993 
1994  public:
1996  inline std::list<CParameter *>::iterator
1998  {
1999  return m_listCustom.begin();
2000  }
2001 
2003  inline std::list<CParameter *>::iterator
2004  endCustom (void)
2005  {
2006  return m_listCustom.end();
2007  }
2008 
2010  inline void
2012  {
2013  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2014  }
2015 
2017  inline int
2019  {
2020  return (int) (m_listCustom.size());
2021  }
2022 
2023  EResultCode
2025  addCustom (
2026  CParameter * pValue);
2027 
2028 
2029 };
2030 
2031 
2061 class CImpinjReducedPowerFrequencyList : public CParameter
2062 {
2063  public:
2066 
2069 
2070  static const CFieldDescriptor * const
2071  s_apFieldDescriptorTable[];
2072 
2073  static const CTypeDescriptor
2074  s_typeDescriptor;
2075 
2076  void
2077  decodeFields (
2078  CDecoderStream * pDecoderStream);
2079 
2080  void
2081  assimilateSubParameters (
2082  CErrorDetails * pError);
2083 
2084  void
2085  encode (
2086  CEncoderStream * pEncoderStream) const;
2087 
2088 
2089  llrp_bool_t
2090  isAllowedIn (
2091  const CTypeDescriptor * pEnclosingElementType) const;
2092 
2093 
2094  static CElement *
2095  s_construct (void);
2096 
2097  static void
2098  s_decodeFields (
2099  CDecoderStream * pDecoderStream,
2100  CElement * pElement);
2102 
2103 
2104  protected:
2105  EImpinjReducedPowerMode m_eReducedPowerMode;
2106 
2109  public:
2110  static const CFieldDescriptor
2111  s_fdReducedPowerMode;
2113 
2115  inline EImpinjReducedPowerMode
2117  {
2118  return m_eReducedPowerMode;
2119  }
2120 
2122  inline void
2124  EImpinjReducedPowerMode value)
2125  {
2126  m_eReducedPowerMode = value;
2127  }
2128 
2129 
2130  protected:
2131  llrp_u16v_t m_ChannelList;
2132 
2135  public:
2136  static const CFieldDescriptor
2137  s_fdChannelList;
2139 
2141  inline llrp_u16v_t
2143  {
2144  return m_ChannelList;
2145  }
2146 
2148  inline void
2150  llrp_u16v_t value)
2151  {
2152  m_ChannelList = value;
2153  }
2154 
2155 
2156  protected:
2157  std::list<CParameter *> m_listCustom;
2158 
2159  public:
2161  inline std::list<CParameter *>::iterator
2163  {
2164  return m_listCustom.begin();
2165  }
2166 
2168  inline std::list<CParameter *>::iterator
2169  endCustom (void)
2170  {
2171  return m_listCustom.end();
2172  }
2173 
2175  inline void
2177  {
2178  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2179  }
2180 
2182  inline int
2184  {
2185  return (int) (m_listCustom.size());
2186  }
2187 
2188  EResultCode
2190  addCustom (
2191  CParameter * pValue);
2192 
2193 
2194 };
2195 
2196 
2226 class CImpinjLowDutyCycle : public CParameter
2227 {
2228  public:
2229  CImpinjLowDutyCycle (void);
2230  ~CImpinjLowDutyCycle (void);
2231 
2234 
2235  static const CFieldDescriptor * const
2236  s_apFieldDescriptorTable[];
2237 
2238  static const CTypeDescriptor
2239  s_typeDescriptor;
2240 
2241  void
2242  decodeFields (
2243  CDecoderStream * pDecoderStream);
2244 
2245  void
2246  assimilateSubParameters (
2247  CErrorDetails * pError);
2248 
2249  void
2250  encode (
2251  CEncoderStream * pEncoderStream) const;
2252 
2253 
2254  llrp_bool_t
2255  isAllowedIn (
2256  const CTypeDescriptor * pEnclosingElementType) const;
2257 
2258 
2259  static CElement *
2260  s_construct (void);
2261 
2262  static void
2263  s_decodeFields (
2264  CDecoderStream * pDecoderStream,
2265  CElement * pElement);
2267 
2268 
2269  protected:
2270  EImpinjLowDutyCycleMode m_eLowDutyCycleMode;
2271 
2274  public:
2275  static const CFieldDescriptor
2276  s_fdLowDutyCycleMode;
2278 
2280  inline EImpinjLowDutyCycleMode
2282  {
2283  return m_eLowDutyCycleMode;
2284  }
2285 
2287  inline void
2289  EImpinjLowDutyCycleMode value)
2290  {
2291  m_eLowDutyCycleMode = value;
2292  }
2293 
2294 
2295  protected:
2296  llrp_u16_t m_EmptyFieldTimeout;
2297 
2300  public:
2301  static const CFieldDescriptor
2302  s_fdEmptyFieldTimeout;
2304 
2306  inline llrp_u16_t
2308  {
2309  return m_EmptyFieldTimeout;
2310  }
2311 
2313  inline void
2315  llrp_u16_t value)
2316  {
2317  m_EmptyFieldTimeout = value;
2318  }
2319 
2320 
2321  protected:
2322  llrp_u16_t m_FieldPingInterval;
2323 
2326  public:
2327  static const CFieldDescriptor
2328  s_fdFieldPingInterval;
2330 
2332  inline llrp_u16_t
2334  {
2335  return m_FieldPingInterval;
2336  }
2337 
2339  inline void
2341  llrp_u16_t value)
2342  {
2343  m_FieldPingInterval = value;
2344  }
2345 
2346 
2347  protected:
2348  std::list<CParameter *> m_listCustom;
2349 
2350  public:
2352  inline std::list<CParameter *>::iterator
2354  {
2355  return m_listCustom.begin();
2356  }
2357 
2359  inline std::list<CParameter *>::iterator
2360  endCustom (void)
2361  {
2362  return m_listCustom.end();
2363  }
2364 
2366  inline void
2368  {
2369  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2370  }
2371 
2373  inline int
2375  {
2376  return (int) (m_listCustom.size());
2377  }
2378 
2379  EResultCode
2381  addCustom (
2382  CParameter * pValue);
2383 
2384 
2385 };
2386 
2387 
2412 class CImpinjHubVersions : public CParameter
2413 {
2414  public:
2415  CImpinjHubVersions (void);
2416  ~CImpinjHubVersions (void);
2417 
2420 
2421  static const CFieldDescriptor * const
2422  s_apFieldDescriptorTable[];
2423 
2424  static const CTypeDescriptor
2425  s_typeDescriptor;
2426 
2427  void
2428  decodeFields (
2429  CDecoderStream * pDecoderStream);
2430 
2431  void
2432  assimilateSubParameters (
2433  CErrorDetails * pError);
2434 
2435  void
2436  encode (
2437  CEncoderStream * pEncoderStream) const;
2438 
2439 
2440  llrp_bool_t
2441  isAllowedIn (
2442  const CTypeDescriptor * pEnclosingElementType) const;
2443 
2444 
2445  static CElement *
2446  s_construct (void);
2447 
2448  static void
2449  s_decodeFields (
2450  CDecoderStream * pDecoderStream,
2451  CElement * pElement);
2453 
2454 
2455  protected:
2456  std::list<CImpinjArrayVersion *> m_listImpinjArrayVersion;
2457 
2458  public:
2460  inline std::list<CImpinjArrayVersion *>::iterator
2462  {
2463  return m_listImpinjArrayVersion.begin();
2464  }
2465 
2467  inline std::list<CImpinjArrayVersion *>::iterator
2469  {
2470  return m_listImpinjArrayVersion.end();
2471  }
2472 
2474  inline void
2476  {
2477  clearSubParameterList ((tListOfParameters *) &m_listImpinjArrayVersion);
2478  }
2479 
2481  inline int
2483  {
2484  return (int) (m_listImpinjArrayVersion.size());
2485  }
2486 
2487  EResultCode
2490  CImpinjArrayVersion * pValue);
2491 
2492 
2493  protected:
2494  std::list<CParameter *> m_listCustom;
2495 
2496  public:
2498  inline std::list<CParameter *>::iterator
2500  {
2501  return m_listCustom.begin();
2502  }
2503 
2505  inline std::list<CParameter *>::iterator
2506  endCustom (void)
2507  {
2508  return m_listCustom.end();
2509  }
2510 
2512  inline void
2514  {
2515  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2516  }
2517 
2519  inline int
2521  {
2522  return (int) (m_listCustom.size());
2523  }
2524 
2525  EResultCode
2527  addCustom (
2528  CParameter * pValue);
2529 
2530 
2531 };
2532 
2533 
2565 class CImpinjDetailedVersion : public CParameter
2566 {
2567  public:
2568  CImpinjDetailedVersion (void);
2569  ~CImpinjDetailedVersion (void);
2570 
2573 
2574  static const CFieldDescriptor * const
2575  s_apFieldDescriptorTable[];
2576 
2577  static const CTypeDescriptor
2578  s_typeDescriptor;
2579 
2580  void
2581  decodeFields (
2582  CDecoderStream * pDecoderStream);
2583 
2584  void
2585  assimilateSubParameters (
2586  CErrorDetails * pError);
2587 
2588  void
2589  encode (
2590  CEncoderStream * pEncoderStream) const;
2591 
2592 
2593  llrp_bool_t
2594  isAllowedIn (
2595  const CTypeDescriptor * pEnclosingElementType) const;
2596 
2597 
2598  static CElement *
2599  s_construct (void);
2600 
2601  static void
2602  s_decodeFields (
2603  CDecoderStream * pDecoderStream,
2604  CElement * pElement);
2606 
2607 
2608  protected:
2609  llrp_utf8v_t m_ModelName;
2610 
2613  public:
2614  static const CFieldDescriptor
2615  s_fdModelName;
2617 
2619  inline llrp_utf8v_t
2621  {
2622  return m_ModelName;
2623  }
2624 
2626  inline void
2628  llrp_utf8v_t value)
2629  {
2630  m_ModelName = value;
2631  }
2632 
2633 
2634  protected:
2635  llrp_utf8v_t m_SerialNumber;
2636 
2639  public:
2640  static const CFieldDescriptor
2641  s_fdSerialNumber;
2643 
2645  inline llrp_utf8v_t
2647  {
2648  return m_SerialNumber;
2649  }
2650 
2652  inline void
2654  llrp_utf8v_t value)
2655  {
2656  m_SerialNumber = value;
2657  }
2658 
2659 
2660  protected:
2661  llrp_utf8v_t m_SoftwareVersion;
2662 
2665  public:
2666  static const CFieldDescriptor
2667  s_fdSoftwareVersion;
2669 
2671  inline llrp_utf8v_t
2673  {
2674  return m_SoftwareVersion;
2675  }
2676 
2678  inline void
2680  llrp_utf8v_t value)
2681  {
2682  m_SoftwareVersion = value;
2683  }
2684 
2685 
2686  protected:
2687  llrp_utf8v_t m_FirmwareVersion;
2688 
2691  public:
2692  static const CFieldDescriptor
2693  s_fdFirmwareVersion;
2695 
2697  inline llrp_utf8v_t
2699  {
2700  return m_FirmwareVersion;
2701  }
2702 
2704  inline void
2706  llrp_utf8v_t value)
2707  {
2708  m_FirmwareVersion = value;
2709  }
2710 
2711 
2712  protected:
2713  llrp_utf8v_t m_FPGAVersion;
2714 
2717  public:
2718  static const CFieldDescriptor
2719  s_fdFPGAVersion;
2721 
2723  inline llrp_utf8v_t
2725  {
2726  return m_FPGAVersion;
2727  }
2728 
2730  inline void
2732  llrp_utf8v_t value)
2733  {
2734  m_FPGAVersion = value;
2735  }
2736 
2737 
2738  protected:
2739  llrp_utf8v_t m_PCBAVersion;
2740 
2743  public:
2744  static const CFieldDescriptor
2745  s_fdPCBAVersion;
2747 
2749  inline llrp_utf8v_t
2751  {
2752  return m_PCBAVersion;
2753  }
2754 
2756  inline void
2758  llrp_utf8v_t value)
2759  {
2760  m_PCBAVersion = value;
2761  }
2762 
2763 
2764  protected:
2765  CImpinjHubVersions * m_pImpinjHubVersions;
2766 
2767  public:
2769  inline CImpinjHubVersions *
2771  {
2772  return m_pImpinjHubVersions;
2773  }
2774 
2776  EResultCode
2778  CImpinjHubVersions * pValue);
2779 
2780 
2781  protected:
2782  CImpinjArrayVersion * m_pImpinjArrayVersion;
2783 
2784  public:
2786  inline CImpinjArrayVersion *
2788  {
2789  return m_pImpinjArrayVersion;
2790  }
2791 
2793  EResultCode
2795  CImpinjArrayVersion * pValue);
2796 
2797 
2798  protected:
2799  std::list<CParameter *> m_listCustom;
2800 
2801  public:
2803  inline std::list<CParameter *>::iterator
2805  {
2806  return m_listCustom.begin();
2807  }
2808 
2810  inline std::list<CParameter *>::iterator
2811  endCustom (void)
2812  {
2813  return m_listCustom.end();
2814  }
2815 
2817  inline void
2819  {
2820  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2821  }
2822 
2824  inline int
2826  {
2827  return (int) (m_listCustom.size());
2828  }
2829 
2830  EResultCode
2832  addCustom (
2833  CParameter * pValue);
2834 
2835 
2836 };
2837 
2838 
2863 class CImpinjFrequencyCapabilities : public CParameter
2864 {
2865  public:
2868 
2871 
2872  static const CFieldDescriptor * const
2873  s_apFieldDescriptorTable[];
2874 
2875  static const CTypeDescriptor
2876  s_typeDescriptor;
2877 
2878  void
2879  decodeFields (
2880  CDecoderStream * pDecoderStream);
2881 
2882  void
2883  assimilateSubParameters (
2884  CErrorDetails * pError);
2885 
2886  void
2887  encode (
2888  CEncoderStream * pEncoderStream) const;
2889 
2890 
2891  llrp_bool_t
2892  isAllowedIn (
2893  const CTypeDescriptor * pEnclosingElementType) const;
2894 
2895 
2896  static CElement *
2897  s_construct (void);
2898 
2899  static void
2900  s_decodeFields (
2901  CDecoderStream * pDecoderStream,
2902  CElement * pElement);
2904 
2905 
2906  protected:
2907  llrp_u32v_t m_FrequencyList;
2908 
2911  public:
2912  static const CFieldDescriptor
2913  s_fdFrequencyList;
2915 
2917  inline llrp_u32v_t
2919  {
2920  return m_FrequencyList;
2921  }
2922 
2924  inline void
2926  llrp_u32v_t value)
2927  {
2928  m_FrequencyList = value;
2929  }
2930 
2931 
2932  protected:
2933  std::list<CParameter *> m_listCustom;
2934 
2935  public:
2937  inline std::list<CParameter *>::iterator
2939  {
2940  return m_listCustom.begin();
2941  }
2942 
2944  inline std::list<CParameter *>::iterator
2945  endCustom (void)
2946  {
2947  return m_listCustom.end();
2948  }
2949 
2951  inline void
2953  {
2954  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2955  }
2956 
2958  inline int
2960  {
2961  return (int) (m_listCustom.size());
2962  }
2963 
2964  EResultCode
2966  addCustom (
2967  CParameter * pValue);
2968 
2969 
2970 };
2971 
2972 
2999 class CImpinjGPIDebounceConfiguration : public CParameter
3000 {
3001  public:
3004 
3007 
3008  static const CFieldDescriptor * const
3009  s_apFieldDescriptorTable[];
3010 
3011  static const CTypeDescriptor
3012  s_typeDescriptor;
3013 
3014  void
3015  decodeFields (
3016  CDecoderStream * pDecoderStream);
3017 
3018  void
3019  assimilateSubParameters (
3020  CErrorDetails * pError);
3021 
3022  void
3023  encode (
3024  CEncoderStream * pEncoderStream) const;
3025 
3026 
3027  llrp_bool_t
3028  isAllowedIn (
3029  const CTypeDescriptor * pEnclosingElementType) const;
3030 
3031 
3032  static CElement *
3033  s_construct (void);
3034 
3035  static void
3036  s_decodeFields (
3037  CDecoderStream * pDecoderStream,
3038  CElement * pElement);
3040 
3041 
3042  protected:
3043  llrp_u16_t m_GPIPortNum;
3044 
3047  public:
3048  static const CFieldDescriptor
3049  s_fdGPIPortNum;
3051 
3053  inline llrp_u16_t
3055  {
3056  return m_GPIPortNum;
3057  }
3058 
3060  inline void
3062  llrp_u16_t value)
3063  {
3064  m_GPIPortNum = value;
3065  }
3066 
3067 
3068  protected:
3069  llrp_u32_t m_GPIDebounceTimerMSec;
3070 
3073  public:
3074  static const CFieldDescriptor
3075  s_fdGPIDebounceTimerMSec;
3077 
3079  inline llrp_u32_t
3081  {
3082  return m_GPIDebounceTimerMSec;
3083  }
3084 
3086  inline void
3088  llrp_u32_t value)
3089  {
3090  m_GPIDebounceTimerMSec = value;
3091  }
3092 
3093 
3094  protected:
3095  std::list<CParameter *> m_listCustom;
3096 
3097  public:
3099  inline std::list<CParameter *>::iterator
3101  {
3102  return m_listCustom.begin();
3103  }
3104 
3106  inline std::list<CParameter *>::iterator
3107  endCustom (void)
3108  {
3109  return m_listCustom.end();
3110  }
3111 
3113  inline void
3115  {
3116  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3117  }
3118 
3120  inline int
3122  {
3123  return (int) (m_listCustom.size());
3124  }
3125 
3126  EResultCode
3128  addCustom (
3129  CParameter * pValue);
3130 
3131 
3132 };
3133 
3134 
3159 class CImpinjReaderTemperature : public CParameter
3160 {
3161  public:
3162  CImpinjReaderTemperature (void);
3163  ~CImpinjReaderTemperature (void);
3164 
3167 
3168  static const CFieldDescriptor * const
3169  s_apFieldDescriptorTable[];
3170 
3171  static const CTypeDescriptor
3172  s_typeDescriptor;
3173 
3174  void
3175  decodeFields (
3176  CDecoderStream * pDecoderStream);
3177 
3178  void
3179  assimilateSubParameters (
3180  CErrorDetails * pError);
3181 
3182  void
3183  encode (
3184  CEncoderStream * pEncoderStream) const;
3185 
3186 
3187  llrp_bool_t
3188  isAllowedIn (
3189  const CTypeDescriptor * pEnclosingElementType) const;
3190 
3191 
3192  static CElement *
3193  s_construct (void);
3194 
3195  static void
3196  s_decodeFields (
3197  CDecoderStream * pDecoderStream,
3198  CElement * pElement);
3200 
3201 
3202  protected:
3203  llrp_s16_t m_Temperature;
3204 
3207  public:
3208  static const CFieldDescriptor
3209  s_fdTemperature;
3211 
3213  inline llrp_s16_t
3215  {
3216  return m_Temperature;
3217  }
3218 
3220  inline void
3222  llrp_s16_t value)
3223  {
3224  m_Temperature = value;
3225  }
3226 
3227 
3228  protected:
3229  std::list<CParameter *> m_listCustom;
3230 
3231  public:
3233  inline std::list<CParameter *>::iterator
3235  {
3236  return m_listCustom.begin();
3237  }
3238 
3240  inline std::list<CParameter *>::iterator
3241  endCustom (void)
3242  {
3243  return m_listCustom.end();
3244  }
3245 
3247  inline void
3249  {
3250  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3251  }
3252 
3254  inline int
3256  {
3257  return (int) (m_listCustom.size());
3258  }
3259 
3260  EResultCode
3262  addCustom (
3263  CParameter * pValue);
3264 
3265 
3266 };
3267 
3268 
3295 class CImpinjLinkMonitorConfiguration : public CParameter
3296 {
3297  public:
3300 
3303 
3304  static const CFieldDescriptor * const
3305  s_apFieldDescriptorTable[];
3306 
3307  static const CTypeDescriptor
3308  s_typeDescriptor;
3309 
3310  void
3311  decodeFields (
3312  CDecoderStream * pDecoderStream);
3313 
3314  void
3315  assimilateSubParameters (
3316  CErrorDetails * pError);
3317 
3318  void
3319  encode (
3320  CEncoderStream * pEncoderStream) const;
3321 
3322 
3323  llrp_bool_t
3324  isAllowedIn (
3325  const CTypeDescriptor * pEnclosingElementType) const;
3326 
3327 
3328  static CElement *
3329  s_construct (void);
3330 
3331  static void
3332  s_decodeFields (
3333  CDecoderStream * pDecoderStream,
3334  CElement * pElement);
3336 
3337 
3338  protected:
3339  EImpinjLinkMonitorMode m_eLinkMonitorMode;
3340 
3343  public:
3344  static const CFieldDescriptor
3345  s_fdLinkMonitorMode;
3347 
3349  inline EImpinjLinkMonitorMode
3351  {
3352  return m_eLinkMonitorMode;
3353  }
3354 
3356  inline void
3358  EImpinjLinkMonitorMode value)
3359  {
3360  m_eLinkMonitorMode = value;
3361  }
3362 
3363 
3364  protected:
3365  llrp_u16_t m_LinkDownThreshold;
3366 
3369  public:
3370  static const CFieldDescriptor
3371  s_fdLinkDownThreshold;
3373 
3375  inline llrp_u16_t
3377  {
3378  return m_LinkDownThreshold;
3379  }
3380 
3382  inline void
3384  llrp_u16_t value)
3385  {
3386  m_LinkDownThreshold = value;
3387  }
3388 
3389 
3390  protected:
3391  std::list<CParameter *> m_listCustom;
3392 
3393  public:
3395  inline std::list<CParameter *>::iterator
3397  {
3398  return m_listCustom.begin();
3399  }
3400 
3402  inline std::list<CParameter *>::iterator
3403  endCustom (void)
3404  {
3405  return m_listCustom.end();
3406  }
3407 
3409  inline void
3411  {
3412  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3413  }
3414 
3416  inline int
3418  {
3419  return (int) (m_listCustom.size());
3420  }
3421 
3422  EResultCode
3424  addCustom (
3425  CParameter * pValue);
3426 
3427 
3428 };
3429 
3430 
3456 class CImpinjReportBufferConfiguration : public CParameter
3457 {
3458  public:
3461 
3464 
3465  static const CFieldDescriptor * const
3466  s_apFieldDescriptorTable[];
3467 
3468  static const CTypeDescriptor
3469  s_typeDescriptor;
3470 
3471  void
3472  decodeFields (
3473  CDecoderStream * pDecoderStream);
3474 
3475  void
3476  assimilateSubParameters (
3477  CErrorDetails * pError);
3478 
3479  void
3480  encode (
3481  CEncoderStream * pEncoderStream) const;
3482 
3483 
3484  llrp_bool_t
3485  isAllowedIn (
3486  const CTypeDescriptor * pEnclosingElementType) const;
3487 
3488 
3489  static CElement *
3490  s_construct (void);
3491 
3492  static void
3493  s_decodeFields (
3494  CDecoderStream * pDecoderStream,
3495  CElement * pElement);
3497 
3498 
3499  protected:
3500  EImpinjReportBufferMode m_eReportBufferMode;
3501 
3504  public:
3505  static const CFieldDescriptor
3506  s_fdReportBufferMode;
3508 
3510  inline EImpinjReportBufferMode
3512  {
3513  return m_eReportBufferMode;
3514  }
3515 
3517  inline void
3519  EImpinjReportBufferMode value)
3520  {
3521  m_eReportBufferMode = value;
3522  }
3523 
3524 
3525  protected:
3526  std::list<CParameter *> m_listCustom;
3527 
3528  public:
3530  inline std::list<CParameter *>::iterator
3532  {
3533  return m_listCustom.begin();
3534  }
3535 
3537  inline std::list<CParameter *>::iterator
3538  endCustom (void)
3539  {
3540  return m_listCustom.end();
3541  }
3542 
3544  inline void
3546  {
3547  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3548  }
3549 
3551  inline int
3553  {
3554  return (int) (m_listCustom.size());
3555  }
3556 
3557  EResultCode
3559  addCustom (
3560  CParameter * pValue);
3561 
3562 
3563 };
3564 
3565 
3594 class CImpinjAccessSpecConfiguration : public CParameter
3595 {
3596  public:
3599 
3602 
3603  static const CFieldDescriptor * const
3604  s_apFieldDescriptorTable[];
3605 
3606  static const CTypeDescriptor
3607  s_typeDescriptor;
3608 
3609  void
3610  decodeFields (
3611  CDecoderStream * pDecoderStream);
3612 
3613  void
3614  assimilateSubParameters (
3615  CErrorDetails * pError);
3616 
3617  void
3618  encode (
3619  CEncoderStream * pEncoderStream) const;
3620 
3621 
3622  llrp_bool_t
3623  isAllowedIn (
3624  const CTypeDescriptor * pEnclosingElementType) const;
3625 
3626 
3627  static CElement *
3628  s_construct (void);
3629 
3630  static void
3631  s_decodeFields (
3632  CDecoderStream * pDecoderStream,
3633  CElement * pElement);
3635 
3636 
3637  protected:
3638  CImpinjBlockWriteWordCount * m_pImpinjBlockWriteWordCount;
3639 
3640  public:
3644  {
3645  return m_pImpinjBlockWriteWordCount;
3646  }
3647 
3649  EResultCode
3651  CImpinjBlockWriteWordCount * pValue);
3652 
3653 
3654  protected:
3655  CImpinjOpSpecRetryCount * m_pImpinjOpSpecRetryCount;
3656 
3657  public:
3659  inline CImpinjOpSpecRetryCount *
3661  {
3662  return m_pImpinjOpSpecRetryCount;
3663  }
3664 
3666  EResultCode
3668  CImpinjOpSpecRetryCount * pValue);
3669 
3670 
3671  protected:
3672  CImpinjAccessSpecOrdering * m_pImpinjAccessSpecOrdering;
3673 
3674  public:
3676  inline CImpinjAccessSpecOrdering *
3678  {
3679  return m_pImpinjAccessSpecOrdering;
3680  }
3681 
3683  EResultCode
3685  CImpinjAccessSpecOrdering * pValue);
3686 
3687 
3688  protected:
3689  std::list<CParameter *> m_listCustom;
3690 
3691  public:
3693  inline std::list<CParameter *>::iterator
3695  {
3696  return m_listCustom.begin();
3697  }
3698 
3700  inline std::list<CParameter *>::iterator
3701  endCustom (void)
3702  {
3703  return m_listCustom.end();
3704  }
3705 
3707  inline void
3709  {
3710  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3711  }
3712 
3714  inline int
3716  {
3717  return (int) (m_listCustom.size());
3718  }
3719 
3720  EResultCode
3722  addCustom (
3723  CParameter * pValue);
3724 
3725 
3726 };
3727 
3728 
3752 class CImpinjBlockWriteWordCount : public CParameter
3753 {
3754  public:
3757 
3760 
3761  static const CFieldDescriptor * const
3762  s_apFieldDescriptorTable[];
3763 
3764  static const CTypeDescriptor
3765  s_typeDescriptor;
3766 
3767  void
3768  decodeFields (
3769  CDecoderStream * pDecoderStream);
3770 
3771  void
3772  assimilateSubParameters (
3773  CErrorDetails * pError);
3774 
3775  void
3776  encode (
3777  CEncoderStream * pEncoderStream) const;
3778 
3779 
3780  llrp_bool_t
3781  isAllowedIn (
3782  const CTypeDescriptor * pEnclosingElementType) const;
3783 
3784 
3785  static CElement *
3786  s_construct (void);
3787 
3788  static void
3789  s_decodeFields (
3790  CDecoderStream * pDecoderStream,
3791  CElement * pElement);
3793 
3794 
3795  protected:
3796  llrp_u16_t m_WordCount;
3797 
3800  public:
3801  static const CFieldDescriptor
3802  s_fdWordCount;
3804 
3806  inline llrp_u16_t
3808  {
3809  return m_WordCount;
3810  }
3811 
3813  inline void
3815  llrp_u16_t value)
3816  {
3817  m_WordCount = value;
3818  }
3819 
3820 
3821  protected:
3822  std::list<CParameter *> m_listCustom;
3823 
3824  public:
3826  inline std::list<CParameter *>::iterator
3828  {
3829  return m_listCustom.begin();
3830  }
3831 
3833  inline std::list<CParameter *>::iterator
3834  endCustom (void)
3835  {
3836  return m_listCustom.end();
3837  }
3838 
3840  inline void
3842  {
3843  clearSubParameterList ((tListOfParameters *) &m_listCustom);
3844  }
3845 
3847  inline int
3849  {
3850  return (int) (m_listCustom.size());
3851  }
3852 
3853  EResultCode
3855  addCustom (
3856  CParameter * pValue);
3857 
3858 
3859 };
3860 
3861 
3891 class CImpinjBlockPermalock : public CParameter
3892 {
3893  public:
3894  CImpinjBlockPermalock (void);
3895  ~CImpinjBlockPermalock (void);
3896 
3899 
3900  static const CFieldDescriptor * const
3901  s_apFieldDescriptorTable[];
3902 
3903  static const CTypeDescriptor
3904  s_typeDescriptor;
3905 
3906  void
3907  decodeFields (
3908  CDecoderStream * pDecoderStream);
3909 
3910  void
3911  assimilateSubParameters (
3912  CErrorDetails * pError);
3913 
3914  void
3915  encode (
3916  CEncoderStream * pEncoderStream) const;
3917 
3918 
3919  llrp_bool_t
3920  isAllowedIn (
3921  const CTypeDescriptor * pEnclosingElementType) const;
3922 
3923 
3924  static CElement *
3925  s_construct (void);
3926 
3927  static void
3928  s_decodeFields (
3929  CDecoderStream * pDecoderStream,
3930  CElement * pElement);
3932 
3933 
3934  protected:
3935  llrp_u16_t m_OpSpecID;
3936 
3939  public:
3940  static const CFieldDescriptor
3941  s_fdOpSpecID;
3943 
3945  inline llrp_u16_t
3947  {
3948  return m_OpSpecID;
3949  }
3950 
3952  inline void
3954  llrp_u16_t value)
3955  {
3956  m_OpSpecID = value;
3957  }
3958 
3959 
3960  protected:
3961  llrp_u32_t m_AccessPassword;
3962 
3965  public:
3966  static const CFieldDescriptor
3967  s_fdAccessPassword;
3969 
3971  inline llrp_u32_t
3973  {
3974  return m_AccessPassword;
3975  }
3976 
3978  inline void
3980  llrp_u32_t value)
3981  {
3982  m_AccessPassword = value;
3983  }
3984 
3985 
3986  protected:
3987  llrp_u2_t m_MB;
3988 
3991  public:
3992  static const CFieldDescriptor
3993  s_fdMB;
3995 
3997  inline llrp_u2_t
3998  getMB (void)
3999  {
4000  return m_MB;
4001  }
4002 
4004  inline void
4006  llrp_u2_t value)
4007  {
4008  m_MB = value;
4009  }
4010 
4011 
4012  protected:
4013  llrp_u16_t m_BlockPointer;
4014 
4017  public:
4018  static const CFieldDescriptor
4019  s_fdBlockPointer;
4021 
4023  inline llrp_u16_t
4025  {
4026  return m_BlockPointer;
4027  }
4028 
4030  inline void
4032  llrp_u16_t value)
4033  {
4034  m_BlockPointer = value;
4035  }
4036 
4037 
4038  protected:
4039  llrp_u16v_t m_BlockMask;
4040 
4043  public:
4044  static const CFieldDescriptor
4045  s_fdBlockMask;
4047 
4049  inline llrp_u16v_t
4051  {
4052  return m_BlockMask;
4053  }
4054 
4056  inline void
4058  llrp_u16v_t value)
4059  {
4060  m_BlockMask = value;
4061  }
4062 
4063 
4064  protected:
4065  std::list<CParameter *> m_listCustom;
4066 
4067  public:
4069  inline std::list<CParameter *>::iterator
4071  {
4072  return m_listCustom.begin();
4073  }
4074 
4076  inline std::list<CParameter *>::iterator
4077  endCustom (void)
4078  {
4079  return m_listCustom.end();
4080  }
4081 
4083  inline void
4085  {
4086  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4087  }
4088 
4090  inline int
4092  {
4093  return (int) (m_listCustom.size());
4094  }
4095 
4096  EResultCode
4098  addCustom (
4099  CParameter * pValue);
4100 
4101 
4102 };
4103 
4104 
4130 class CImpinjBlockPermalockOpSpecResult : public CParameter
4131 {
4132  public:
4135 
4138 
4139  static const CFieldDescriptor * const
4140  s_apFieldDescriptorTable[];
4141 
4142  static const CTypeDescriptor
4143  s_typeDescriptor;
4144 
4145  void
4146  decodeFields (
4147  CDecoderStream * pDecoderStream);
4148 
4149  void
4150  assimilateSubParameters (
4151  CErrorDetails * pError);
4152 
4153  void
4154  encode (
4155  CEncoderStream * pEncoderStream) const;
4156 
4157 
4158  llrp_bool_t
4159  isAllowedIn (
4160  const CTypeDescriptor * pEnclosingElementType) const;
4161 
4162 
4163  static CElement *
4164  s_construct (void);
4165 
4166  static void
4167  s_decodeFields (
4168  CDecoderStream * pDecoderStream,
4169  CElement * pElement);
4171 
4172 
4173  protected:
4174  EImpinjBlockPermalockResultType m_eResult;
4175 
4178  public:
4179  static const CFieldDescriptor
4180  s_fdResult;
4182 
4184  inline EImpinjBlockPermalockResultType
4185  getResult (void)
4186  {
4187  return m_eResult;
4188  }
4189 
4191  inline void
4193  EImpinjBlockPermalockResultType value)
4194  {
4195  m_eResult = value;
4196  }
4197 
4198 
4199  protected:
4200  llrp_u16_t m_OpSpecID;
4201 
4204  public:
4205  static const CFieldDescriptor
4206  s_fdOpSpecID;
4208 
4210  inline llrp_u16_t
4212  {
4213  return m_OpSpecID;
4214  }
4215 
4217  inline void
4219  llrp_u16_t value)
4220  {
4221  m_OpSpecID = value;
4222  }
4223 
4224 
4225  protected:
4226  std::list<CParameter *> m_listCustom;
4227 
4228  public:
4230  inline std::list<CParameter *>::iterator
4232  {
4233  return m_listCustom.begin();
4234  }
4235 
4237  inline std::list<CParameter *>::iterator
4238  endCustom (void)
4239  {
4240  return m_listCustom.end();
4241  }
4242 
4244  inline void
4246  {
4247  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4248  }
4249 
4251  inline int
4253  {
4254  return (int) (m_listCustom.size());
4255  }
4256 
4257  EResultCode
4259  addCustom (
4260  CParameter * pValue);
4261 
4262 
4263 };
4264 
4265 
4295 class CImpinjGetBlockPermalockStatus : public CParameter
4296 {
4297  public:
4300 
4303 
4304  static const CFieldDescriptor * const
4305  s_apFieldDescriptorTable[];
4306 
4307  static const CTypeDescriptor
4308  s_typeDescriptor;
4309 
4310  void
4311  decodeFields (
4312  CDecoderStream * pDecoderStream);
4313 
4314  void
4315  assimilateSubParameters (
4316  CErrorDetails * pError);
4317 
4318  void
4319  encode (
4320  CEncoderStream * pEncoderStream) const;
4321 
4322 
4323  llrp_bool_t
4324  isAllowedIn (
4325  const CTypeDescriptor * pEnclosingElementType) const;
4326 
4327 
4328  static CElement *
4329  s_construct (void);
4330 
4331  static void
4332  s_decodeFields (
4333  CDecoderStream * pDecoderStream,
4334  CElement * pElement);
4336 
4337 
4338  protected:
4339  llrp_u16_t m_OpSpecID;
4340 
4343  public:
4344  static const CFieldDescriptor
4345  s_fdOpSpecID;
4347 
4349  inline llrp_u16_t
4351  {
4352  return m_OpSpecID;
4353  }
4354 
4356  inline void
4358  llrp_u16_t value)
4359  {
4360  m_OpSpecID = value;
4361  }
4362 
4363 
4364  protected:
4365  llrp_u32_t m_AccessPassword;
4366 
4369  public:
4370  static const CFieldDescriptor
4371  s_fdAccessPassword;
4373 
4375  inline llrp_u32_t
4377  {
4378  return m_AccessPassword;
4379  }
4380 
4382  inline void
4384  llrp_u32_t value)
4385  {
4386  m_AccessPassword = value;
4387  }
4388 
4389 
4390  protected:
4391  llrp_u2_t m_MB;
4392 
4395  public:
4396  static const CFieldDescriptor
4397  s_fdMB;
4399 
4401  inline llrp_u2_t
4402  getMB (void)
4403  {
4404  return m_MB;
4405  }
4406 
4408  inline void
4410  llrp_u2_t value)
4411  {
4412  m_MB = value;
4413  }
4414 
4415 
4416  protected:
4417  llrp_u16_t m_BlockPointer;
4418 
4421  public:
4422  static const CFieldDescriptor
4423  s_fdBlockPointer;
4425 
4427  inline llrp_u16_t
4429  {
4430  return m_BlockPointer;
4431  }
4432 
4434  inline void
4436  llrp_u16_t value)
4437  {
4438  m_BlockPointer = value;
4439  }
4440 
4441 
4442  protected:
4443  llrp_u16_t m_BlockRange;
4444 
4447  public:
4448  static const CFieldDescriptor
4449  s_fdBlockRange;
4451 
4453  inline llrp_u16_t
4455  {
4456  return m_BlockRange;
4457  }
4458 
4460  inline void
4462  llrp_u16_t value)
4463  {
4464  m_BlockRange = value;
4465  }
4466 
4467 
4468  protected:
4469  std::list<CParameter *> m_listCustom;
4470 
4471  public:
4473  inline std::list<CParameter *>::iterator
4475  {
4476  return m_listCustom.begin();
4477  }
4478 
4480  inline std::list<CParameter *>::iterator
4481  endCustom (void)
4482  {
4483  return m_listCustom.end();
4484  }
4485 
4487  inline void
4489  {
4490  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4491  }
4492 
4494  inline int
4496  {
4497  return (int) (m_listCustom.size());
4498  }
4499 
4500  EResultCode
4502  addCustom (
4503  CParameter * pValue);
4504 
4505 
4506 };
4507 
4508 
4536 {
4537  public:
4540 
4543 
4544  static const CFieldDescriptor * const
4545  s_apFieldDescriptorTable[];
4546 
4547  static const CTypeDescriptor
4548  s_typeDescriptor;
4549 
4550  void
4551  decodeFields (
4552  CDecoderStream * pDecoderStream);
4553 
4554  void
4555  assimilateSubParameters (
4556  CErrorDetails * pError);
4557 
4558  void
4559  encode (
4560  CEncoderStream * pEncoderStream) const;
4561 
4562 
4563  llrp_bool_t
4564  isAllowedIn (
4565  const CTypeDescriptor * pEnclosingElementType) const;
4566 
4567 
4568  static CElement *
4569  s_construct (void);
4570 
4571  static void
4572  s_decodeFields (
4573  CDecoderStream * pDecoderStream,
4574  CElement * pElement);
4576 
4577 
4578  protected:
4579  EImpinjGetBlockPermalockStatusResultType m_eResult;
4580 
4583  public:
4584  static const CFieldDescriptor
4585  s_fdResult;
4587 
4589  inline EImpinjGetBlockPermalockStatusResultType
4590  getResult (void)
4591  {
4592  return m_eResult;
4593  }
4594 
4596  inline void
4598  EImpinjGetBlockPermalockStatusResultType value)
4599  {
4600  m_eResult = value;
4601  }
4602 
4603 
4604  protected:
4605  llrp_u16_t m_OpSpecID;
4606 
4609  public:
4610  static const CFieldDescriptor
4611  s_fdOpSpecID;
4613 
4615  inline llrp_u16_t
4617  {
4618  return m_OpSpecID;
4619  }
4620 
4622  inline void
4624  llrp_u16_t value)
4625  {
4626  m_OpSpecID = value;
4627  }
4628 
4629 
4630  protected:
4631  llrp_u16v_t m_PermalockStatus;
4632 
4635  public:
4636  static const CFieldDescriptor
4637  s_fdPermalockStatus;
4639 
4641  inline llrp_u16v_t
4643  {
4644  return m_PermalockStatus;
4645  }
4646 
4648  inline void
4650  llrp_u16v_t value)
4651  {
4652  m_PermalockStatus = value;
4653  }
4654 
4655 
4656  protected:
4657  std::list<CParameter *> m_listCustom;
4658 
4659  public:
4661  inline std::list<CParameter *>::iterator
4663  {
4664  return m_listCustom.begin();
4665  }
4666 
4668  inline std::list<CParameter *>::iterator
4669  endCustom (void)
4670  {
4671  return m_listCustom.end();
4672  }
4673 
4675  inline void
4677  {
4678  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4679  }
4680 
4682  inline int
4684  {
4685  return (int) (m_listCustom.size());
4686  }
4687 
4688  EResultCode
4690  addCustom (
4691  CParameter * pValue);
4692 
4693 
4694 };
4695 
4696 
4726 class CImpinjSetQTConfig : public CParameter
4727 {
4728  public:
4729  CImpinjSetQTConfig (void);
4730  ~CImpinjSetQTConfig (void);
4731 
4734 
4735  static const CFieldDescriptor * const
4736  s_apFieldDescriptorTable[];
4737 
4738  static const CTypeDescriptor
4739  s_typeDescriptor;
4740 
4741  void
4742  decodeFields (
4743  CDecoderStream * pDecoderStream);
4744 
4745  void
4746  assimilateSubParameters (
4747  CErrorDetails * pError);
4748 
4749  void
4750  encode (
4751  CEncoderStream * pEncoderStream) const;
4752 
4753 
4754  llrp_bool_t
4755  isAllowedIn (
4756  const CTypeDescriptor * pEnclosingElementType) const;
4757 
4758 
4759  static CElement *
4760  s_construct (void);
4761 
4762  static void
4763  s_decodeFields (
4764  CDecoderStream * pDecoderStream,
4765  CElement * pElement);
4767 
4768 
4769  protected:
4770  llrp_u16_t m_OpSpecID;
4771 
4774  public:
4775  static const CFieldDescriptor
4776  s_fdOpSpecID;
4778 
4780  inline llrp_u16_t
4782  {
4783  return m_OpSpecID;
4784  }
4785 
4787  inline void
4789  llrp_u16_t value)
4790  {
4791  m_OpSpecID = value;
4792  }
4793 
4794 
4795  protected:
4796  llrp_u32_t m_AccessPassword;
4797 
4800  public:
4801  static const CFieldDescriptor
4802  s_fdAccessPassword;
4804 
4806  inline llrp_u32_t
4808  {
4809  return m_AccessPassword;
4810  }
4811 
4813  inline void
4815  llrp_u32_t value)
4816  {
4817  m_AccessPassword = value;
4818  }
4819 
4820 
4821  protected:
4822  EImpinjQTDataProfile m_eDataProfile;
4823 
4826  public:
4827  static const CFieldDescriptor
4828  s_fdDataProfile;
4830 
4832  inline EImpinjQTDataProfile
4834  {
4835  return m_eDataProfile;
4836  }
4837 
4839  inline void
4841  EImpinjQTDataProfile value)
4842  {
4843  m_eDataProfile = value;
4844  }
4845 
4846 
4847  protected:
4848  EImpinjQTAccessRange m_eAccessRange;
4849 
4852  public:
4853  static const CFieldDescriptor
4854  s_fdAccessRange;
4856 
4858  inline EImpinjQTAccessRange
4860  {
4861  return m_eAccessRange;
4862  }
4863 
4865  inline void
4867  EImpinjQTAccessRange value)
4868  {
4869  m_eAccessRange = value;
4870  }
4871 
4872 
4873  protected:
4874  EImpinjQTPersistence m_ePersistence;
4875 
4878  public:
4879  static const CFieldDescriptor
4880  s_fdPersistence;
4882 
4884  inline EImpinjQTPersistence
4886  {
4887  return m_ePersistence;
4888  }
4889 
4891  inline void
4893  EImpinjQTPersistence value)
4894  {
4895  m_ePersistence = value;
4896  }
4897 
4898 
4899  protected:
4900  std::list<CParameter *> m_listCustom;
4901 
4902  public:
4904  inline std::list<CParameter *>::iterator
4906  {
4907  return m_listCustom.begin();
4908  }
4909 
4911  inline std::list<CParameter *>::iterator
4912  endCustom (void)
4913  {
4914  return m_listCustom.end();
4915  }
4916 
4918  inline void
4920  {
4921  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4922  }
4923 
4925  inline int
4927  {
4928  return (int) (m_listCustom.size());
4929  }
4930 
4931  EResultCode
4933  addCustom (
4934  CParameter * pValue);
4935 
4936 
4937 };
4938 
4939 
4965 class CImpinjSetQTConfigOpSpecResult : public CParameter
4966 {
4967  public:
4970 
4973 
4974  static const CFieldDescriptor * const
4975  s_apFieldDescriptorTable[];
4976 
4977  static const CTypeDescriptor
4978  s_typeDescriptor;
4979 
4980  void
4981  decodeFields (
4982  CDecoderStream * pDecoderStream);
4983 
4984  void
4985  assimilateSubParameters (
4986  CErrorDetails * pError);
4987 
4988  void
4989  encode (
4990  CEncoderStream * pEncoderStream) const;
4991 
4992 
4993  llrp_bool_t
4994  isAllowedIn (
4995  const CTypeDescriptor * pEnclosingElementType) const;
4996 
4997 
4998  static CElement *
4999  s_construct (void);
5000 
5001  static void
5002  s_decodeFields (
5003  CDecoderStream * pDecoderStream,
5004  CElement * pElement);
5006 
5007 
5008  protected:
5009  EImpinjSetQTConfigResultType m_eResult;
5010 
5013  public:
5014  static const CFieldDescriptor
5015  s_fdResult;
5017 
5019  inline EImpinjSetQTConfigResultType
5020  getResult (void)
5021  {
5022  return m_eResult;
5023  }
5024 
5026  inline void
5028  EImpinjSetQTConfigResultType value)
5029  {
5030  m_eResult = value;
5031  }
5032 
5033 
5034  protected:
5035  llrp_u16_t m_OpSpecID;
5036 
5039  public:
5040  static const CFieldDescriptor
5041  s_fdOpSpecID;
5043 
5045  inline llrp_u16_t
5047  {
5048  return m_OpSpecID;
5049  }
5050 
5052  inline void
5054  llrp_u16_t value)
5055  {
5056  m_OpSpecID = value;
5057  }
5058 
5059 
5060  protected:
5061  std::list<CParameter *> m_listCustom;
5062 
5063  public:
5065  inline std::list<CParameter *>::iterator
5067  {
5068  return m_listCustom.begin();
5069  }
5070 
5072  inline std::list<CParameter *>::iterator
5073  endCustom (void)
5074  {
5075  return m_listCustom.end();
5076  }
5077 
5079  inline void
5081  {
5082  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5083  }
5084 
5086  inline int
5088  {
5089  return (int) (m_listCustom.size());
5090  }
5091 
5092  EResultCode
5094  addCustom (
5095  CParameter * pValue);
5096 
5097 
5098 };
5099 
5100 
5126 class CImpinjGetQTConfig : public CParameter
5127 {
5128  public:
5129  CImpinjGetQTConfig (void);
5130  ~CImpinjGetQTConfig (void);
5131 
5134 
5135  static const CFieldDescriptor * const
5136  s_apFieldDescriptorTable[];
5137 
5138  static const CTypeDescriptor
5139  s_typeDescriptor;
5140 
5141  void
5142  decodeFields (
5143  CDecoderStream * pDecoderStream);
5144 
5145  void
5146  assimilateSubParameters (
5147  CErrorDetails * pError);
5148 
5149  void
5150  encode (
5151  CEncoderStream * pEncoderStream) const;
5152 
5153 
5154  llrp_bool_t
5155  isAllowedIn (
5156  const CTypeDescriptor * pEnclosingElementType) const;
5157 
5158 
5159  static CElement *
5160  s_construct (void);
5161 
5162  static void
5163  s_decodeFields (
5164  CDecoderStream * pDecoderStream,
5165  CElement * pElement);
5167 
5168 
5169  protected:
5170  llrp_u16_t m_OpSpecID;
5171 
5174  public:
5175  static const CFieldDescriptor
5176  s_fdOpSpecID;
5178 
5180  inline llrp_u16_t
5182  {
5183  return m_OpSpecID;
5184  }
5185 
5187  inline void
5189  llrp_u16_t value)
5190  {
5191  m_OpSpecID = value;
5192  }
5193 
5194 
5195  protected:
5196  llrp_u32_t m_AccessPassword;
5197 
5200  public:
5201  static const CFieldDescriptor
5202  s_fdAccessPassword;
5204 
5206  inline llrp_u32_t
5208  {
5209  return m_AccessPassword;
5210  }
5211 
5213  inline void
5215  llrp_u32_t value)
5216  {
5217  m_AccessPassword = value;
5218  }
5219 
5220 
5221  protected:
5222  std::list<CParameter *> m_listCustom;
5223 
5224  public:
5226  inline std::list<CParameter *>::iterator
5228  {
5229  return m_listCustom.begin();
5230  }
5231 
5233  inline std::list<CParameter *>::iterator
5234  endCustom (void)
5235  {
5236  return m_listCustom.end();
5237  }
5238 
5240  inline void
5242  {
5243  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5244  }
5245 
5247  inline int
5249  {
5250  return (int) (m_listCustom.size());
5251  }
5252 
5253  EResultCode
5255  addCustom (
5256  CParameter * pValue);
5257 
5258 
5259 };
5260 
5261 
5290 class CImpinjGetQTConfigOpSpecResult : public CParameter
5291 {
5292  public:
5295 
5298 
5299  static const CFieldDescriptor * const
5300  s_apFieldDescriptorTable[];
5301 
5302  static const CTypeDescriptor
5303  s_typeDescriptor;
5304 
5305  void
5306  decodeFields (
5307  CDecoderStream * pDecoderStream);
5308 
5309  void
5310  assimilateSubParameters (
5311  CErrorDetails * pError);
5312 
5313  void
5314  encode (
5315  CEncoderStream * pEncoderStream) const;
5316 
5317 
5318  llrp_bool_t
5319  isAllowedIn (
5320  const CTypeDescriptor * pEnclosingElementType) const;
5321 
5322 
5323  static CElement *
5324  s_construct (void);
5325 
5326  static void
5327  s_decodeFields (
5328  CDecoderStream * pDecoderStream,
5329  CElement * pElement);
5331 
5332 
5333  protected:
5334  EImpinjGetQTConfigResultType m_eResult;
5335 
5338  public:
5339  static const CFieldDescriptor
5340  s_fdResult;
5342 
5344  inline EImpinjGetQTConfigResultType
5345  getResult (void)
5346  {
5347  return m_eResult;
5348  }
5349 
5351  inline void
5353  EImpinjGetQTConfigResultType value)
5354  {
5355  m_eResult = value;
5356  }
5357 
5358 
5359  protected:
5360  llrp_u16_t m_OpSpecID;
5361 
5364  public:
5365  static const CFieldDescriptor
5366  s_fdOpSpecID;
5368 
5370  inline llrp_u16_t
5372  {
5373  return m_OpSpecID;
5374  }
5375 
5377  inline void
5379  llrp_u16_t value)
5380  {
5381  m_OpSpecID = value;
5382  }
5383 
5384 
5385  protected:
5386  EImpinjQTDataProfile m_eDataProfile;
5387 
5390  public:
5391  static const CFieldDescriptor
5392  s_fdDataProfile;
5394 
5396  inline EImpinjQTDataProfile
5398  {
5399  return m_eDataProfile;
5400  }
5401 
5403  inline void
5405  EImpinjQTDataProfile value)
5406  {
5407  m_eDataProfile = value;
5408  }
5409 
5410 
5411  protected:
5412  EImpinjQTAccessRange m_eAccessRange;
5413 
5416  public:
5417  static const CFieldDescriptor
5418  s_fdAccessRange;
5420 
5422  inline EImpinjQTAccessRange
5424  {
5425  return m_eAccessRange;
5426  }
5427 
5429  inline void
5431  EImpinjQTAccessRange value)
5432  {
5433  m_eAccessRange = value;
5434  }
5435 
5436 
5437  protected:
5438  std::list<CParameter *> m_listCustom;
5439 
5440  public:
5442  inline std::list<CParameter *>::iterator
5444  {
5445  return m_listCustom.begin();
5446  }
5447 
5449  inline std::list<CParameter *>::iterator
5450  endCustom (void)
5451  {
5452  return m_listCustom.end();
5453  }
5454 
5456  inline void
5458  {
5459  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5460  }
5461 
5463  inline int
5465  {
5466  return (int) (m_listCustom.size());
5467  }
5468 
5469  EResultCode
5471  addCustom (
5472  CParameter * pValue);
5473 
5474 
5475 };
5476 
5477 
5507 class CImpinjTagReportContentSelector : public CParameter
5508 {
5509  public:
5512 
5515 
5516  static const CFieldDescriptor * const
5517  s_apFieldDescriptorTable[];
5518 
5519  static const CTypeDescriptor
5520  s_typeDescriptor;
5521 
5522  void
5523  decodeFields (
5524  CDecoderStream * pDecoderStream);
5525 
5526  void
5527  assimilateSubParameters (
5528  CErrorDetails * pError);
5529 
5530  void
5531  encode (
5532  CEncoderStream * pEncoderStream) const;
5533 
5534 
5535  llrp_bool_t
5536  isAllowedIn (
5537  const CTypeDescriptor * pEnclosingElementType) const;
5538 
5539 
5540  static CElement *
5541  s_construct (void);
5542 
5543  static void
5544  s_decodeFields (
5545  CDecoderStream * pDecoderStream,
5546  CElement * pElement);
5548 
5549 
5550  protected:
5551  CImpinjEnableSerializedTID * m_pImpinjEnableSerializedTID;
5552 
5553  public:
5557  {
5558  return m_pImpinjEnableSerializedTID;
5559  }
5560 
5562  EResultCode
5564  CImpinjEnableSerializedTID * pValue);
5565 
5566 
5567  protected:
5568  CImpinjEnableRFPhaseAngle * m_pImpinjEnableRFPhaseAngle;
5569 
5570  public:
5572  inline CImpinjEnableRFPhaseAngle *
5574  {
5575  return m_pImpinjEnableRFPhaseAngle;
5576  }
5577 
5579  EResultCode
5581  CImpinjEnableRFPhaseAngle * pValue);
5582 
5583 
5584  protected:
5585  CImpinjEnablePeakRSSI * m_pImpinjEnablePeakRSSI;
5586 
5587  public:
5589  inline CImpinjEnablePeakRSSI *
5591  {
5592  return m_pImpinjEnablePeakRSSI;
5593  }
5594 
5596  EResultCode
5598  CImpinjEnablePeakRSSI * pValue);
5599 
5600 
5601  protected:
5602  CImpinjEnableGPSCoordinates * m_pImpinjEnableGPSCoordinates;
5603 
5604  public:
5608  {
5609  return m_pImpinjEnableGPSCoordinates;
5610  }
5611 
5613  EResultCode
5615  CImpinjEnableGPSCoordinates * pValue);
5616 
5617 
5618  protected:
5619  CImpinjEnableOptimizedRead * m_pImpinjEnableOptimizedRead;
5620 
5621  public:
5625  {
5626  return m_pImpinjEnableOptimizedRead;
5627  }
5628 
5630  EResultCode
5632  CImpinjEnableOptimizedRead * pValue);
5633 
5634 
5635  protected:
5636  CImpinjEnableRFDopplerFrequency * m_pImpinjEnableRFDopplerFrequency;
5637 
5638  public:
5642  {
5643  return m_pImpinjEnableRFDopplerFrequency;
5644  }
5645 
5647  EResultCode
5650 
5651 
5652  protected:
5653  std::list<CParameter *> m_listCustom;
5654 
5655  public:
5657  inline std::list<CParameter *>::iterator
5659  {
5660  return m_listCustom.begin();
5661  }
5662 
5664  inline std::list<CParameter *>::iterator
5665  endCustom (void)
5666  {
5667  return m_listCustom.end();
5668  }
5669 
5671  inline void
5673  {
5674  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5675  }
5676 
5678  inline int
5680  {
5681  return (int) (m_listCustom.size());
5682  }
5683 
5684  EResultCode
5686  addCustom (
5687  CParameter * pValue);
5688 
5689 
5690 };
5691 
5692 
5716 class CImpinjEnableSerializedTID : public CParameter
5717 {
5718  public:
5721 
5724 
5725  static const CFieldDescriptor * const
5726  s_apFieldDescriptorTable[];
5727 
5728  static const CTypeDescriptor
5729  s_typeDescriptor;
5730 
5731  void
5732  decodeFields (
5733  CDecoderStream * pDecoderStream);
5734 
5735  void
5736  assimilateSubParameters (
5737  CErrorDetails * pError);
5738 
5739  void
5740  encode (
5741  CEncoderStream * pEncoderStream) const;
5742 
5743 
5744  llrp_bool_t
5745  isAllowedIn (
5746  const CTypeDescriptor * pEnclosingElementType) const;
5747 
5748 
5749  static CElement *
5750  s_construct (void);
5751 
5752  static void
5753  s_decodeFields (
5754  CDecoderStream * pDecoderStream,
5755  CElement * pElement);
5757 
5758 
5759  protected:
5760  EImpinjSerializedTIDMode m_eSerializedTIDMode;
5761 
5764  public:
5765  static const CFieldDescriptor
5766  s_fdSerializedTIDMode;
5768 
5770  inline EImpinjSerializedTIDMode
5772  {
5773  return m_eSerializedTIDMode;
5774  }
5775 
5777  inline void
5779  EImpinjSerializedTIDMode value)
5780  {
5781  m_eSerializedTIDMode = value;
5782  }
5783 
5784 
5785  protected:
5786  std::list<CParameter *> m_listCustom;
5787 
5788  public:
5790  inline std::list<CParameter *>::iterator
5792  {
5793  return m_listCustom.begin();
5794  }
5795 
5797  inline std::list<CParameter *>::iterator
5798  endCustom (void)
5799  {
5800  return m_listCustom.end();
5801  }
5802 
5804  inline void
5806  {
5807  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5808  }
5809 
5811  inline int
5813  {
5814  return (int) (m_listCustom.size());
5815  }
5816 
5817  EResultCode
5819  addCustom (
5820  CParameter * pValue);
5821 
5822 
5823 };
5824 
5825 
5849 class CImpinjEnableRFPhaseAngle : public CParameter
5850 {
5851  public:
5853  ~CImpinjEnableRFPhaseAngle (void);
5854 
5857 
5858  static const CFieldDescriptor * const
5859  s_apFieldDescriptorTable[];
5860 
5861  static const CTypeDescriptor
5862  s_typeDescriptor;
5863 
5864  void
5865  decodeFields (
5866  CDecoderStream * pDecoderStream);
5867 
5868  void
5869  assimilateSubParameters (
5870  CErrorDetails * pError);
5871 
5872  void
5873  encode (
5874  CEncoderStream * pEncoderStream) const;
5875 
5876 
5877  llrp_bool_t
5878  isAllowedIn (
5879  const CTypeDescriptor * pEnclosingElementType) const;
5880 
5881 
5882  static CElement *
5883  s_construct (void);
5884 
5885  static void
5886  s_decodeFields (
5887  CDecoderStream * pDecoderStream,
5888  CElement * pElement);
5890 
5891 
5892  protected:
5893  EImpinjRFPhaseAngleMode m_eRFPhaseAngleMode;
5894 
5897  public:
5898  static const CFieldDescriptor
5899  s_fdRFPhaseAngleMode;
5901 
5903  inline EImpinjRFPhaseAngleMode
5905  {
5906  return m_eRFPhaseAngleMode;
5907  }
5908 
5910  inline void
5912  EImpinjRFPhaseAngleMode value)
5913  {
5914  m_eRFPhaseAngleMode = value;
5915  }
5916 
5917 
5918  protected:
5919  std::list<CParameter *> m_listCustom;
5920 
5921  public:
5923  inline std::list<CParameter *>::iterator
5925  {
5926  return m_listCustom.begin();
5927  }
5928 
5930  inline std::list<CParameter *>::iterator
5931  endCustom (void)
5932  {
5933  return m_listCustom.end();
5934  }
5935 
5937  inline void
5939  {
5940  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5941  }
5942 
5944  inline int
5946  {
5947  return (int) (m_listCustom.size());
5948  }
5949 
5950  EResultCode
5952  addCustom (
5953  CParameter * pValue);
5954 
5955 
5956 };
5957 
5958 
5982 class CImpinjEnablePeakRSSI : public CParameter
5983 {
5984  public:
5985  CImpinjEnablePeakRSSI (void);
5986  ~CImpinjEnablePeakRSSI (void);
5987 
5990 
5991  static const CFieldDescriptor * const
5992  s_apFieldDescriptorTable[];
5993 
5994  static const CTypeDescriptor
5995  s_typeDescriptor;
5996 
5997  void
5998  decodeFields (
5999  CDecoderStream * pDecoderStream);
6000 
6001  void
6002  assimilateSubParameters (
6003  CErrorDetails * pError);
6004 
6005  void
6006  encode (
6007  CEncoderStream * pEncoderStream) const;
6008 
6009 
6010  llrp_bool_t
6011  isAllowedIn (
6012  const CTypeDescriptor * pEnclosingElementType) const;
6013 
6014 
6015  static CElement *
6016  s_construct (void);
6017 
6018  static void
6019  s_decodeFields (
6020  CDecoderStream * pDecoderStream,
6021  CElement * pElement);
6023 
6024 
6025  protected:
6026  EImpinjPeakRSSIMode m_ePeakRSSIMode;
6027 
6030  public:
6031  static const CFieldDescriptor
6032  s_fdPeakRSSIMode;
6034 
6036  inline EImpinjPeakRSSIMode
6038  {
6039  return m_ePeakRSSIMode;
6040  }
6041 
6043  inline void
6045  EImpinjPeakRSSIMode value)
6046  {
6047  m_ePeakRSSIMode = value;
6048  }
6049 
6050 
6051  protected:
6052  std::list<CParameter *> m_listCustom;
6053 
6054  public:
6056  inline std::list<CParameter *>::iterator
6058  {
6059  return m_listCustom.begin();
6060  }
6061 
6063  inline std::list<CParameter *>::iterator
6064  endCustom (void)
6065  {
6066  return m_listCustom.end();
6067  }
6068 
6070  inline void
6072  {
6073  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6074  }
6075 
6077  inline int
6079  {
6080  return (int) (m_listCustom.size());
6081  }
6082 
6083  EResultCode
6085  addCustom (
6086  CParameter * pValue);
6087 
6088 
6089 };
6090 
6091 
6115 class CImpinjEnableGPSCoordinates : public CParameter
6116 {
6117  public:
6120 
6123 
6124  static const CFieldDescriptor * const
6125  s_apFieldDescriptorTable[];
6126 
6127  static const CTypeDescriptor
6128  s_typeDescriptor;
6129 
6130  void
6131  decodeFields (
6132  CDecoderStream * pDecoderStream);
6133 
6134  void
6135  assimilateSubParameters (
6136  CErrorDetails * pError);
6137 
6138  void
6139  encode (
6140  CEncoderStream * pEncoderStream) const;
6141 
6142 
6143  llrp_bool_t
6144  isAllowedIn (
6145  const CTypeDescriptor * pEnclosingElementType) const;
6146 
6147 
6148  static CElement *
6149  s_construct (void);
6150 
6151  static void
6152  s_decodeFields (
6153  CDecoderStream * pDecoderStream,
6154  CElement * pElement);
6156 
6157 
6158  protected:
6159  EImpinjGPSCoordinatesMode m_eGPSCoordinatesMode;
6160 
6163  public:
6164  static const CFieldDescriptor
6165  s_fdGPSCoordinatesMode;
6167 
6169  inline EImpinjGPSCoordinatesMode
6171  {
6172  return m_eGPSCoordinatesMode;
6173  }
6174 
6176  inline void
6178  EImpinjGPSCoordinatesMode value)
6179  {
6180  m_eGPSCoordinatesMode = value;
6181  }
6182 
6183 
6184  protected:
6185  std::list<CParameter *> m_listCustom;
6186 
6187  public:
6189  inline std::list<CParameter *>::iterator
6191  {
6192  return m_listCustom.begin();
6193  }
6194 
6196  inline std::list<CParameter *>::iterator
6197  endCustom (void)
6198  {
6199  return m_listCustom.end();
6200  }
6201 
6203  inline void
6205  {
6206  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6207  }
6208 
6210  inline int
6212  {
6213  return (int) (m_listCustom.size());
6214  }
6215 
6216  EResultCode
6218  addCustom (
6219  CParameter * pValue);
6220 
6221 
6222 };
6223 
6224 
6250 class CImpinjSerializedTID : public CParameter
6251 {
6252  public:
6253  CImpinjSerializedTID (void);
6254  ~CImpinjSerializedTID (void);
6255 
6258 
6259  static const CFieldDescriptor * const
6260  s_apFieldDescriptorTable[];
6261 
6262  static const CTypeDescriptor
6263  s_typeDescriptor;
6264 
6265  void
6266  decodeFields (
6267  CDecoderStream * pDecoderStream);
6268 
6269  void
6270  assimilateSubParameters (
6271  CErrorDetails * pError);
6272 
6273  void
6274  encode (
6275  CEncoderStream * pEncoderStream) const;
6276 
6277 
6278  llrp_bool_t
6279  isAllowedIn (
6280  const CTypeDescriptor * pEnclosingElementType) const;
6281 
6282 
6283  static CElement *
6284  s_construct (void);
6285 
6286  static void
6287  s_decodeFields (
6288  CDecoderStream * pDecoderStream,
6289  CElement * pElement);
6291 
6292 
6293  protected:
6294  llrp_u16v_t m_TID;
6295 
6298  public:
6299  static const CFieldDescriptor
6300  s_fdTID;
6302 
6304  inline llrp_u16v_t
6305  getTID (void)
6306  {
6307  return m_TID;
6308  }
6309 
6311  inline void
6313  llrp_u16v_t value)
6314  {
6315  m_TID = value;
6316  }
6317 
6318 
6319  protected:
6320  CImpinjTIDParity * m_pImpinjTIDParity;
6321 
6322  public:
6324  inline CImpinjTIDParity *
6326  {
6327  return m_pImpinjTIDParity;
6328  }
6329 
6331  EResultCode
6333  CImpinjTIDParity * pValue);
6334 
6335 
6336  protected:
6337  std::list<CParameter *> m_listCustom;
6338 
6339  public:
6341  inline std::list<CParameter *>::iterator
6343  {
6344  return m_listCustom.begin();
6345  }
6346 
6348  inline std::list<CParameter *>::iterator
6349  endCustom (void)
6350  {
6351  return m_listCustom.end();
6352  }
6353 
6355  inline void
6357  {
6358  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6359  }
6360 
6362  inline int
6364  {
6365  return (int) (m_listCustom.size());
6366  }
6367 
6368  EResultCode
6370  addCustom (
6371  CParameter * pValue);
6372 
6373 
6374 };
6375 
6376 
6401 class CImpinjRFPhaseAngle : public CParameter
6402 {
6403  public:
6404  CImpinjRFPhaseAngle (void);
6405  ~CImpinjRFPhaseAngle (void);
6406 
6409 
6410  static const CFieldDescriptor * const
6411  s_apFieldDescriptorTable[];
6412 
6413  static const CTypeDescriptor
6414  s_typeDescriptor;
6415 
6416  void
6417  decodeFields (
6418  CDecoderStream * pDecoderStream);
6419 
6420  void
6421  assimilateSubParameters (
6422  CErrorDetails * pError);
6423 
6424  void
6425  encode (
6426  CEncoderStream * pEncoderStream) const;
6427 
6428 
6429  llrp_bool_t
6430  isAllowedIn (
6431  const CTypeDescriptor * pEnclosingElementType) const;
6432 
6433 
6434  static CElement *
6435  s_construct (void);
6436 
6437  static void
6438  s_decodeFields (
6439  CDecoderStream * pDecoderStream,
6440  CElement * pElement);
6442 
6443 
6444  protected:
6445  llrp_u16_t m_PhaseAngle;
6446 
6449  public:
6450  static const CFieldDescriptor
6451  s_fdPhaseAngle;
6453 
6455  inline llrp_u16_t
6457  {
6458  return m_PhaseAngle;
6459  }
6460 
6462  inline void
6464  llrp_u16_t value)
6465  {
6466  m_PhaseAngle = value;
6467  }
6468 
6469 
6470  protected:
6471  std::list<CParameter *> m_listCustom;
6472 
6473  public:
6475  inline std::list<CParameter *>::iterator
6477  {
6478  return m_listCustom.begin();
6479  }
6480 
6482  inline std::list<CParameter *>::iterator
6483  endCustom (void)
6484  {
6485  return m_listCustom.end();
6486  }
6487 
6489  inline void
6491  {
6492  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6493  }
6494 
6496  inline int
6498  {
6499  return (int) (m_listCustom.size());
6500  }
6501 
6502  EResultCode
6504  addCustom (
6505  CParameter * pValue);
6506 
6507 
6508 };
6509 
6510 
6535 class CImpinjPeakRSSI : public CParameter
6536 {
6537  public:
6538  CImpinjPeakRSSI (void);
6539  ~CImpinjPeakRSSI (void);
6540 
6543 
6544  static const CFieldDescriptor * const
6545  s_apFieldDescriptorTable[];
6546 
6547  static const CTypeDescriptor
6548  s_typeDescriptor;
6549 
6550  void
6551  decodeFields (
6552  CDecoderStream * pDecoderStream);
6553 
6554  void
6555  assimilateSubParameters (
6556  CErrorDetails * pError);
6557 
6558  void
6559  encode (
6560  CEncoderStream * pEncoderStream) const;
6561 
6562 
6563  llrp_bool_t
6564  isAllowedIn (
6565  const CTypeDescriptor * pEnclosingElementType) const;
6566 
6567 
6568  static CElement *
6569  s_construct (void);
6570 
6571  static void
6572  s_decodeFields (
6573  CDecoderStream * pDecoderStream,
6574  CElement * pElement);
6576 
6577 
6578  protected:
6579  llrp_s16_t m_RSSI;
6580 
6583  public:
6584  static const CFieldDescriptor
6585  s_fdRSSI;
6587 
6589  inline llrp_s16_t
6590  getRSSI (void)
6591  {
6592  return m_RSSI;
6593  }
6594 
6596  inline void
6598  llrp_s16_t value)
6599  {
6600  m_RSSI = value;
6601  }
6602 
6603 
6604  protected:
6605  std::list<CParameter *> m_listCustom;
6606 
6607  public:
6609  inline std::list<CParameter *>::iterator
6611  {
6612  return m_listCustom.begin();
6613  }
6614 
6616  inline std::list<CParameter *>::iterator
6617  endCustom (void)
6618  {
6619  return m_listCustom.end();
6620  }
6621 
6623  inline void
6625  {
6626  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6627  }
6628 
6630  inline int
6632  {
6633  return (int) (m_listCustom.size());
6634  }
6635 
6636  EResultCode
6638  addCustom (
6639  CParameter * pValue);
6640 
6641 
6642 };
6643 
6644 
6670 class CImpinjGPSCoordinates : public CParameter
6671 {
6672  public:
6673  CImpinjGPSCoordinates (void);
6674  ~CImpinjGPSCoordinates (void);
6675 
6678 
6679  static const CFieldDescriptor * const
6680  s_apFieldDescriptorTable[];
6681 
6682  static const CTypeDescriptor
6683  s_typeDescriptor;
6684 
6685  void
6686  decodeFields (
6687  CDecoderStream * pDecoderStream);
6688 
6689  void
6690  assimilateSubParameters (
6691  CErrorDetails * pError);
6692 
6693  void
6694  encode (
6695  CEncoderStream * pEncoderStream) const;
6696 
6697 
6698  llrp_bool_t
6699  isAllowedIn (
6700  const CTypeDescriptor * pEnclosingElementType) const;
6701 
6702 
6703  static CElement *
6704  s_construct (void);
6705 
6706  static void
6707  s_decodeFields (
6708  CDecoderStream * pDecoderStream,
6709  CElement * pElement);
6711 
6712 
6713  protected:
6714  llrp_s32_t m_Latitude;
6715 
6718  public:
6719  static const CFieldDescriptor
6720  s_fdLatitude;
6722 
6724  inline llrp_s32_t
6726  {
6727  return m_Latitude;
6728  }
6729 
6731  inline void
6733  llrp_s32_t value)
6734  {
6735  m_Latitude = value;
6736  }
6737 
6738 
6739  protected:
6740  llrp_s32_t m_Longitude;
6741 
6744  public:
6745  static const CFieldDescriptor
6746  s_fdLongitude;
6748 
6750  inline llrp_s32_t
6752  {
6753  return m_Longitude;
6754  }
6755 
6757  inline void
6759  llrp_s32_t value)
6760  {
6761  m_Longitude = value;
6762  }
6763 
6764 
6765  protected:
6766  std::list<CParameter *> m_listCustom;
6767 
6768  public:
6770  inline std::list<CParameter *>::iterator
6772  {
6773  return m_listCustom.begin();
6774  }
6775 
6777  inline std::list<CParameter *>::iterator
6778  endCustom (void)
6779  {
6780  return m_listCustom.end();
6781  }
6782 
6784  inline void
6786  {
6787  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6788  }
6789 
6791  inline int
6793  {
6794  return (int) (m_listCustom.size());
6795  }
6796 
6797  EResultCode
6799  addCustom (
6800  CParameter * pValue);
6801 
6802 
6803 };
6804 
6805 
6830 class CImpinjLoopSpec : public CParameter
6831 {
6832  public:
6833  CImpinjLoopSpec (void);
6834  ~CImpinjLoopSpec (void);
6835 
6838 
6839  static const CFieldDescriptor * const
6840  s_apFieldDescriptorTable[];
6841 
6842  static const CTypeDescriptor
6843  s_typeDescriptor;
6844 
6845  void
6846  decodeFields (
6847  CDecoderStream * pDecoderStream);
6848 
6849  void
6850  assimilateSubParameters (
6851  CErrorDetails * pError);
6852 
6853  void
6854  encode (
6855  CEncoderStream * pEncoderStream) const;
6856 
6857 
6858  llrp_bool_t
6859  isAllowedIn (
6860  const CTypeDescriptor * pEnclosingElementType) const;
6861 
6862 
6863  static CElement *
6864  s_construct (void);
6865 
6866  static void
6867  s_decodeFields (
6868  CDecoderStream * pDecoderStream,
6869  CElement * pElement);
6871 
6872 
6873  protected:
6874  llrp_u32_t m_LoopCount;
6875 
6878  public:
6879  static const CFieldDescriptor
6880  s_fdLoopCount;
6882 
6884  inline llrp_u32_t
6886  {
6887  return m_LoopCount;
6888  }
6889 
6891  inline void
6893  llrp_u32_t value)
6894  {
6895  m_LoopCount = value;
6896  }
6897 
6898 
6899  protected:
6900  std::list<CParameter *> m_listCustom;
6901 
6902  public:
6904  inline std::list<CParameter *>::iterator
6906  {
6907  return m_listCustom.begin();
6908  }
6909 
6911  inline std::list<CParameter *>::iterator
6912  endCustom (void)
6913  {
6914  return m_listCustom.end();
6915  }
6916 
6918  inline void
6920  {
6921  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6922  }
6923 
6925  inline int
6927  {
6928  return (int) (m_listCustom.size());
6929  }
6930 
6931  EResultCode
6933  addCustom (
6934  CParameter * pValue);
6935 
6936 
6937 };
6938 
6939 
6965 class CImpinjGPSNMEASentences : public CParameter
6966 {
6967  public:
6968  CImpinjGPSNMEASentences (void);
6969  ~CImpinjGPSNMEASentences (void);
6970 
6973 
6974  static const CFieldDescriptor * const
6975  s_apFieldDescriptorTable[];
6976 
6977  static const CTypeDescriptor
6978  s_typeDescriptor;
6979 
6980  void
6981  decodeFields (
6982  CDecoderStream * pDecoderStream);
6983 
6984  void
6985  assimilateSubParameters (
6986  CErrorDetails * pError);
6987 
6988  void
6989  encode (
6990  CEncoderStream * pEncoderStream) const;
6991 
6992 
6993  llrp_bool_t
6994  isAllowedIn (
6995  const CTypeDescriptor * pEnclosingElementType) const;
6996 
6997 
6998  static CElement *
6999  s_construct (void);
7000 
7001  static void
7002  s_decodeFields (
7003  CDecoderStream * pDecoderStream,
7004  CElement * pElement);
7006 
7007 
7008  protected:
7009  CImpinjGGASentence * m_pImpinjGGASentence;
7010 
7011  public:
7013  inline CImpinjGGASentence *
7015  {
7016  return m_pImpinjGGASentence;
7017  }
7018 
7020  EResultCode
7022  CImpinjGGASentence * pValue);
7023 
7024 
7025  protected:
7026  CImpinjRMCSentence * m_pImpinjRMCSentence;
7027 
7028  public:
7030  inline CImpinjRMCSentence *
7032  {
7033  return m_pImpinjRMCSentence;
7034  }
7035 
7037  EResultCode
7039  CImpinjRMCSentence * pValue);
7040 
7041 
7042  protected:
7043  std::list<CParameter *> m_listCustom;
7044 
7045  public:
7047  inline std::list<CParameter *>::iterator
7049  {
7050  return m_listCustom.begin();
7051  }
7052 
7054  inline std::list<CParameter *>::iterator
7055  endCustom (void)
7056  {
7057  return m_listCustom.end();
7058  }
7059 
7061  inline void
7063  {
7064  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7065  }
7066 
7068  inline int
7070  {
7071  return (int) (m_listCustom.size());
7072  }
7073 
7074  EResultCode
7076  addCustom (
7077  CParameter * pValue);
7078 
7079 
7080 };
7081 
7082 
7106 class CImpinjGGASentence : public CParameter
7107 {
7108  public:
7109  CImpinjGGASentence (void);
7110  ~CImpinjGGASentence (void);
7111 
7114 
7115  static const CFieldDescriptor * const
7116  s_apFieldDescriptorTable[];
7117 
7118  static const CTypeDescriptor
7119  s_typeDescriptor;
7120 
7121  void
7122  decodeFields (
7123  CDecoderStream * pDecoderStream);
7124 
7125  void
7126  assimilateSubParameters (
7127  CErrorDetails * pError);
7128 
7129  void
7130  encode (
7131  CEncoderStream * pEncoderStream) const;
7132 
7133 
7134  llrp_bool_t
7135  isAllowedIn (
7136  const CTypeDescriptor * pEnclosingElementType) const;
7137 
7138 
7139  static CElement *
7140  s_construct (void);
7141 
7142  static void
7143  s_decodeFields (
7144  CDecoderStream * pDecoderStream,
7145  CElement * pElement);
7147 
7148 
7149  protected:
7150  llrp_utf8v_t m_GGASentence;
7151 
7154  public:
7155  static const CFieldDescriptor
7156  s_fdGGASentence;
7158 
7160  inline llrp_utf8v_t
7162  {
7163  return m_GGASentence;
7164  }
7165 
7167  inline void
7169  llrp_utf8v_t value)
7170  {
7171  m_GGASentence = value;
7172  }
7173 
7174 
7175  protected:
7176  std::list<CParameter *> m_listCustom;
7177 
7178  public:
7180  inline std::list<CParameter *>::iterator
7182  {
7183  return m_listCustom.begin();
7184  }
7185 
7187  inline std::list<CParameter *>::iterator
7188  endCustom (void)
7189  {
7190  return m_listCustom.end();
7191  }
7192 
7194  inline void
7196  {
7197  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7198  }
7199 
7201  inline int
7203  {
7204  return (int) (m_listCustom.size());
7205  }
7206 
7207  EResultCode
7209  addCustom (
7210  CParameter * pValue);
7211 
7212 
7213 };
7214 
7215 
7239 class CImpinjRMCSentence : public CParameter
7240 {
7241  public:
7242  CImpinjRMCSentence (void);
7243  ~CImpinjRMCSentence (void);
7244 
7247 
7248  static const CFieldDescriptor * const
7249  s_apFieldDescriptorTable[];
7250 
7251  static const CTypeDescriptor
7252  s_typeDescriptor;
7253 
7254  void
7255  decodeFields (
7256  CDecoderStream * pDecoderStream);
7257 
7258  void
7259  assimilateSubParameters (
7260  CErrorDetails * pError);
7261 
7262  void
7263  encode (
7264  CEncoderStream * pEncoderStream) const;
7265 
7266 
7267  llrp_bool_t
7268  isAllowedIn (
7269  const CTypeDescriptor * pEnclosingElementType) const;
7270 
7271 
7272  static CElement *
7273  s_construct (void);
7274 
7275  static void
7276  s_decodeFields (
7277  CDecoderStream * pDecoderStream,
7278  CElement * pElement);
7280 
7281 
7282  protected:
7283  llrp_utf8v_t m_RMCSentence;
7284 
7287  public:
7288  static const CFieldDescriptor
7289  s_fdRMCSentence;
7291 
7293  inline llrp_utf8v_t
7295  {
7296  return m_RMCSentence;
7297  }
7298 
7300  inline void
7302  llrp_utf8v_t value)
7303  {
7304  m_RMCSentence = value;
7305  }
7306 
7307 
7308  protected:
7309  std::list<CParameter *> m_listCustom;
7310 
7311  public:
7313  inline std::list<CParameter *>::iterator
7315  {
7316  return m_listCustom.begin();
7317  }
7318 
7320  inline std::list<CParameter *>::iterator
7321  endCustom (void)
7322  {
7323  return m_listCustom.end();
7324  }
7325 
7327  inline void
7329  {
7330  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7331  }
7332 
7334  inline int
7336  {
7337  return (int) (m_listCustom.size());
7338  }
7339 
7340  EResultCode
7342  addCustom (
7343  CParameter * pValue);
7344 
7345 
7346 };
7347 
7348 
7372 class CImpinjOpSpecRetryCount : public CParameter
7373 {
7374  public:
7375  CImpinjOpSpecRetryCount (void);
7376  ~CImpinjOpSpecRetryCount (void);
7377 
7380 
7381  static const CFieldDescriptor * const
7382  s_apFieldDescriptorTable[];
7383 
7384  static const CTypeDescriptor
7385  s_typeDescriptor;
7386 
7387  void
7388  decodeFields (
7389  CDecoderStream * pDecoderStream);
7390 
7391  void
7392  assimilateSubParameters (
7393  CErrorDetails * pError);
7394 
7395  void
7396  encode (
7397  CEncoderStream * pEncoderStream) const;
7398 
7399 
7400  llrp_bool_t
7401  isAllowedIn (
7402  const CTypeDescriptor * pEnclosingElementType) const;
7403 
7404 
7405  static CElement *
7406  s_construct (void);
7407 
7408  static void
7409  s_decodeFields (
7410  CDecoderStream * pDecoderStream,
7411  CElement * pElement);
7413 
7414 
7415  protected:
7416  llrp_u16_t m_RetryCount;
7417 
7420  public:
7421  static const CFieldDescriptor
7422  s_fdRetryCount;
7424 
7426  inline llrp_u16_t
7428  {
7429  return m_RetryCount;
7430  }
7431 
7433  inline void
7435  llrp_u16_t value)
7436  {
7437  m_RetryCount = value;
7438  }
7439 
7440 
7441  protected:
7442  std::list<CParameter *> m_listCustom;
7443 
7444  public:
7446  inline std::list<CParameter *>::iterator
7448  {
7449  return m_listCustom.begin();
7450  }
7451 
7453  inline std::list<CParameter *>::iterator
7454  endCustom (void)
7455  {
7456  return m_listCustom.end();
7457  }
7458 
7460  inline void
7462  {
7463  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7464  }
7465 
7467  inline int
7469  {
7470  return (int) (m_listCustom.size());
7471  }
7472 
7473  EResultCode
7475  addCustom (
7476  CParameter * pValue);
7477 
7478 
7479 };
7480 
7481 
7509 class CImpinjAdvancedGPOConfiguration : public CParameter
7510 {
7511  public:
7514 
7517 
7518  static const CFieldDescriptor * const
7519  s_apFieldDescriptorTable[];
7520 
7521  static const CTypeDescriptor
7522  s_typeDescriptor;
7523 
7524  void
7525  decodeFields (
7526  CDecoderStream * pDecoderStream);
7527 
7528  void
7529  assimilateSubParameters (
7530  CErrorDetails * pError);
7531 
7532  void
7533  encode (
7534  CEncoderStream * pEncoderStream) const;
7535 
7536 
7537  llrp_bool_t
7538  isAllowedIn (
7539  const CTypeDescriptor * pEnclosingElementType) const;
7540 
7541 
7542  static CElement *
7543  s_construct (void);
7544 
7545  static void
7546  s_decodeFields (
7547  CDecoderStream * pDecoderStream,
7548  CElement * pElement);
7550 
7551 
7552  protected:
7553  llrp_u16_t m_GPOPortNum;
7554 
7557  public:
7558  static const CFieldDescriptor
7559  s_fdGPOPortNum;
7561 
7563  inline llrp_u16_t
7565  {
7566  return m_GPOPortNum;
7567  }
7568 
7570  inline void
7572  llrp_u16_t value)
7573  {
7574  m_GPOPortNum = value;
7575  }
7576 
7577 
7578  protected:
7579  EImpinjAdvancedGPOMode m_eGPOMode;
7580 
7583  public:
7584  static const CFieldDescriptor
7585  s_fdGPOMode;
7587 
7589  inline EImpinjAdvancedGPOMode
7590  getGPOMode (void)
7591  {
7592  return m_eGPOMode;
7593  }
7594 
7596  inline void
7598  EImpinjAdvancedGPOMode value)
7599  {
7600  m_eGPOMode = value;
7601  }
7602 
7603 
7604  protected:
7605  llrp_u32_t m_GPOPulseDurationMSec;
7606 
7609  public:
7610  static const CFieldDescriptor
7611  s_fdGPOPulseDurationMSec;
7613 
7615  inline llrp_u32_t
7617  {
7618  return m_GPOPulseDurationMSec;
7619  }
7620 
7622  inline void
7624  llrp_u32_t value)
7625  {
7626  m_GPOPulseDurationMSec = value;
7627  }
7628 
7629 
7630  protected:
7631  std::list<CParameter *> m_listCustom;
7632 
7633  public:
7635  inline std::list<CParameter *>::iterator
7637  {
7638  return m_listCustom.begin();
7639  }
7640 
7642  inline std::list<CParameter *>::iterator
7643  endCustom (void)
7644  {
7645  return m_listCustom.end();
7646  }
7647 
7649  inline void
7651  {
7652  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7653  }
7654 
7656  inline int
7658  {
7659  return (int) (m_listCustom.size());
7660  }
7661 
7662  EResultCode
7664  addCustom (
7665  CParameter * pValue);
7666 
7667 
7668 };
7669 
7670 
7704 class CImpinjEnableOptimizedRead : public CParameter
7705 {
7706  public:
7709 
7712 
7713  static const CFieldDescriptor * const
7714  s_apFieldDescriptorTable[];
7715 
7716  static const CTypeDescriptor
7717  s_typeDescriptor;
7718 
7719  void
7720  decodeFields (
7721  CDecoderStream * pDecoderStream);
7722 
7723  void
7724  assimilateSubParameters (
7725  CErrorDetails * pError);
7726 
7727  void
7728  encode (
7729  CEncoderStream * pEncoderStream) const;
7730 
7731 
7732  llrp_bool_t
7733  isAllowedIn (
7734  const CTypeDescriptor * pEnclosingElementType) const;
7735 
7736 
7737  static CElement *
7738  s_construct (void);
7739 
7740  static void
7741  s_decodeFields (
7742  CDecoderStream * pDecoderStream,
7743  CElement * pElement);
7745 
7746 
7747  protected:
7748  EImpinjOptimizedReadMode m_eOptimizedReadMode;
7749 
7752  public:
7753  static const CFieldDescriptor
7754  s_fdOptimizedReadMode;
7756 
7758  inline EImpinjOptimizedReadMode
7760  {
7761  return m_eOptimizedReadMode;
7762  }
7763 
7765  inline void
7767  EImpinjOptimizedReadMode value)
7768  {
7769  m_eOptimizedReadMode = value;
7770  }
7771 
7772 
7773  protected:
7774  std::list<CC1G2Read *> m_listC1G2Read;
7775 
7776  public:
7778  inline std::list<CC1G2Read *>::iterator
7780  {
7781  return m_listC1G2Read.begin();
7782  }
7783 
7785  inline std::list<CC1G2Read *>::iterator
7787  {
7788  return m_listC1G2Read.end();
7789  }
7790 
7792  inline void
7794  {
7795  clearSubParameterList ((tListOfParameters *) &m_listC1G2Read);
7796  }
7797 
7799  inline int
7801  {
7802  return (int) (m_listC1G2Read.size());
7803  }
7804 
7805  EResultCode
7807  addC1G2Read (
7808  CC1G2Read * pValue);
7809 
7810 
7811  protected:
7812  std::list<CParameter *> m_listCustom;
7813 
7814  public:
7816  inline std::list<CParameter *>::iterator
7818  {
7819  return m_listCustom.begin();
7820  }
7821 
7823  inline std::list<CParameter *>::iterator
7824  endCustom (void)
7825  {
7826  return m_listCustom.end();
7827  }
7828 
7830  inline void
7832  {
7833  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7834  }
7835 
7837  inline int
7839  {
7840  return (int) (m_listCustom.size());
7841  }
7842 
7843  EResultCode
7845  addCustom (
7846  CParameter * pValue);
7847 
7848 
7849 };
7850 
7851 
7878 class CImpinjAccessSpecOrdering : public CParameter
7879 {
7880  public:
7882  ~CImpinjAccessSpecOrdering (void);
7883 
7886 
7887  static const CFieldDescriptor * const
7888  s_apFieldDescriptorTable[];
7889 
7890  static const CTypeDescriptor
7891  s_typeDescriptor;
7892 
7893  void
7894  decodeFields (
7895  CDecoderStream * pDecoderStream);
7896 
7897  void
7898  assimilateSubParameters (
7899  CErrorDetails * pError);
7900 
7901  void
7902  encode (
7903  CEncoderStream * pEncoderStream) const;
7904 
7905 
7906  llrp_bool_t
7907  isAllowedIn (
7908  const CTypeDescriptor * pEnclosingElementType) const;
7909 
7910 
7911  static CElement *
7912  s_construct (void);
7913 
7914  static void
7915  s_decodeFields (
7916  CDecoderStream * pDecoderStream,
7917  CElement * pElement);
7919 
7920 
7921  protected:
7922  EImpinjAccessSpecOrderingMode m_eOrderingMode;
7923 
7926  public:
7927  static const CFieldDescriptor
7928  s_fdOrderingMode;
7930 
7932  inline EImpinjAccessSpecOrderingMode
7934  {
7935  return m_eOrderingMode;
7936  }
7937 
7939  inline void
7941  EImpinjAccessSpecOrderingMode value)
7942  {
7943  m_eOrderingMode = value;
7944  }
7945 
7946 
7947  protected:
7948  std::list<CParameter *> m_listCustom;
7949 
7950  public:
7952  inline std::list<CParameter *>::iterator
7954  {
7955  return m_listCustom.begin();
7956  }
7957 
7959  inline std::list<CParameter *>::iterator
7960  endCustom (void)
7961  {
7962  return m_listCustom.end();
7963  }
7964 
7966  inline void
7968  {
7969  clearSubParameterList ((tListOfParameters *) &m_listCustom);
7970  }
7971 
7973  inline int
7975  {
7976  return (int) (m_listCustom.size());
7977  }
7978 
7979  EResultCode
7981  addCustom (
7982  CParameter * pValue);
7983 
7984 
7985 };
7986 
7987 
8011 class CImpinjEnableRFDopplerFrequency : public CParameter
8012 {
8013  public:
8016 
8019 
8020  static const CFieldDescriptor * const
8021  s_apFieldDescriptorTable[];
8022 
8023  static const CTypeDescriptor
8024  s_typeDescriptor;
8025 
8026  void
8027  decodeFields (
8028  CDecoderStream * pDecoderStream);
8029 
8030  void
8031  assimilateSubParameters (
8032  CErrorDetails * pError);
8033 
8034  void
8035  encode (
8036  CEncoderStream * pEncoderStream) const;
8037 
8038 
8039  llrp_bool_t
8040  isAllowedIn (
8041  const CTypeDescriptor * pEnclosingElementType) const;
8042 
8043 
8044  static CElement *
8045  s_construct (void);
8046 
8047  static void
8048  s_decodeFields (
8049  CDecoderStream * pDecoderStream,
8050  CElement * pElement);
8052 
8053 
8054  protected:
8055  EImpinjRFDopplerFrequencyMode m_eRFDopplerFrequencyMode;
8056 
8059  public:
8060  static const CFieldDescriptor
8061  s_fdRFDopplerFrequencyMode;
8063 
8065  inline EImpinjRFDopplerFrequencyMode
8067  {
8068  return m_eRFDopplerFrequencyMode;
8069  }
8070 
8072  inline void
8074  EImpinjRFDopplerFrequencyMode value)
8075  {
8076  m_eRFDopplerFrequencyMode = value;
8077  }
8078 
8079 
8080  protected:
8081  std::list<CParameter *> m_listCustom;
8082 
8083  public:
8085  inline std::list<CParameter *>::iterator
8087  {
8088  return m_listCustom.begin();
8089  }
8090 
8092  inline std::list<CParameter *>::iterator
8093  endCustom (void)
8094  {
8095  return m_listCustom.end();
8096  }
8097 
8099  inline void
8101  {
8102  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8103  }
8104 
8106  inline int
8108  {
8109  return (int) (m_listCustom.size());
8110  }
8111 
8112  EResultCode
8114  addCustom (
8115  CParameter * pValue);
8116 
8117 
8118 };
8119 
8120 
8145 class CImpinjRFDopplerFrequency : public CParameter
8146 {
8147  public:
8149  ~CImpinjRFDopplerFrequency (void);
8150 
8153 
8154  static const CFieldDescriptor * const
8155  s_apFieldDescriptorTable[];
8156 
8157  static const CTypeDescriptor
8158  s_typeDescriptor;
8159 
8160  void
8161  decodeFields (
8162  CDecoderStream * pDecoderStream);
8163 
8164  void
8165  assimilateSubParameters (
8166  CErrorDetails * pError);
8167 
8168  void
8169  encode (
8170  CEncoderStream * pEncoderStream) const;
8171 
8172 
8173  llrp_bool_t
8174  isAllowedIn (
8175  const CTypeDescriptor * pEnclosingElementType) const;
8176 
8177 
8178  static CElement *
8179  s_construct (void);
8180 
8181  static void
8182  s_decodeFields (
8183  CDecoderStream * pDecoderStream,
8184  CElement * pElement);
8186 
8187 
8188  protected:
8189  llrp_s16_t m_DopplerFrequency;
8190 
8193  public:
8194  static const CFieldDescriptor
8195  s_fdDopplerFrequency;
8197 
8199  inline llrp_s16_t
8201  {
8202  return m_DopplerFrequency;
8203  }
8204 
8206  inline void
8208  llrp_s16_t value)
8209  {
8210  m_DopplerFrequency = value;
8211  }
8212 
8213 
8214  protected:
8215  std::list<CParameter *> m_listCustom;
8216 
8217  public:
8219  inline std::list<CParameter *>::iterator
8221  {
8222  return m_listCustom.begin();
8223  }
8224 
8226  inline std::list<CParameter *>::iterator
8227  endCustom (void)
8228  {
8229  return m_listCustom.end();
8230  }
8231 
8233  inline void
8235  {
8236  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8237  }
8238 
8240  inline int
8242  {
8243  return (int) (m_listCustom.size());
8244  }
8245 
8246  EResultCode
8248  addCustom (
8249  CParameter * pValue);
8250 
8251 
8252 };
8253 
8254 
8287 class CImpinjInventoryConfiguration : public CParameter
8288 {
8289  public:
8292 
8295 
8296  static const CFieldDescriptor * const
8297  s_apFieldDescriptorTable[];
8298 
8299  static const CTypeDescriptor
8300  s_typeDescriptor;
8301 
8302  void
8303  decodeFields (
8304  CDecoderStream * pDecoderStream);
8305 
8306  void
8307  assimilateSubParameters (
8308  CErrorDetails * pError);
8309 
8310  void
8311  encode (
8312  CEncoderStream * pEncoderStream) const;
8313 
8314 
8315  llrp_bool_t
8316  isAllowedIn (
8317  const CTypeDescriptor * pEnclosingElementType) const;
8318 
8319 
8320  static CElement *
8321  s_construct (void);
8322 
8323  static void
8324  s_decodeFields (
8325  CDecoderStream * pDecoderStream,
8326  CElement * pElement);
8328 
8329 
8330  protected:
8331  llrp_u1_t m_EnableAntDwellTimeLimit;
8332 
8335  public:
8336  static const CFieldDescriptor
8337  s_fdEnableAntDwellTimeLimit;
8339 
8341  inline llrp_u1_t
8343  {
8344  return m_EnableAntDwellTimeLimit;
8345  }
8346 
8348  inline void
8350  llrp_u1_t value)
8351  {
8352  m_EnableAntDwellTimeLimit = value;
8353  }
8354 
8355 
8356  protected:
8357  llrp_u1_t m_EnableSelectGapClose;
8358 
8361  public:
8362  static const CFieldDescriptor
8363  s_fdEnableSelectGapClose;
8365 
8367  inline llrp_u1_t
8369  {
8370  return m_EnableSelectGapClose;
8371  }
8372 
8374  inline void
8376  llrp_u1_t value)
8377  {
8378  m_EnableSelectGapClose = value;
8379  }
8380 
8381 
8382  protected:
8383  std::list<CParameter *> m_listCustom;
8384 
8385  public:
8387  inline std::list<CParameter *>::iterator
8389  {
8390  return m_listCustom.begin();
8391  }
8392 
8394  inline std::list<CParameter *>::iterator
8395  endCustom (void)
8396  {
8397  return m_listCustom.end();
8398  }
8399 
8401  inline void
8403  {
8404  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8405  }
8406 
8408  inline int
8410  {
8411  return (int) (m_listCustom.size());
8412  }
8413 
8414  EResultCode
8416  addCustom (
8417  CParameter * pValue);
8418 
8419 
8420 };
8421 
8422 
8449 class CImpinjArrayVersion : public CParameter
8450 {
8451  public:
8452  CImpinjArrayVersion (void);
8453  ~CImpinjArrayVersion (void);
8454 
8457 
8458  static const CFieldDescriptor * const
8459  s_apFieldDescriptorTable[];
8460 
8461  static const CTypeDescriptor
8462  s_typeDescriptor;
8463 
8464  void
8465  decodeFields (
8466  CDecoderStream * pDecoderStream);
8467 
8468  void
8469  assimilateSubParameters (
8470  CErrorDetails * pError);
8471 
8472  void
8473  encode (
8474  CEncoderStream * pEncoderStream) const;
8475 
8476 
8477  llrp_bool_t
8478  isAllowedIn (
8479  const CTypeDescriptor * pEnclosingElementType) const;
8480 
8481 
8482  static CElement *
8483  s_construct (void);
8484 
8485  static void
8486  s_decodeFields (
8487  CDecoderStream * pDecoderStream,
8488  CElement * pElement);
8490 
8491 
8492  protected:
8493  llrp_utf8v_t m_SerialNumber;
8494 
8497  public:
8498  static const CFieldDescriptor
8499  s_fdSerialNumber;
8501 
8503  inline llrp_utf8v_t
8505  {
8506  return m_SerialNumber;
8507  }
8508 
8510  inline void
8512  llrp_utf8v_t value)
8513  {
8514  m_SerialNumber = value;
8515  }
8516 
8517 
8518  protected:
8519  llrp_utf8v_t m_FirmwareVersion;
8520 
8523  public:
8524  static const CFieldDescriptor
8525  s_fdFirmwareVersion;
8527 
8529  inline llrp_utf8v_t
8531  {
8532  return m_FirmwareVersion;
8533  }
8534 
8536  inline void
8538  llrp_utf8v_t value)
8539  {
8540  m_FirmwareVersion = value;
8541  }
8542 
8543 
8544  protected:
8545  llrp_utf8v_t m_PCBAVersion;
8546 
8549  public:
8550  static const CFieldDescriptor
8551  s_fdPCBAVersion;
8553 
8555  inline llrp_utf8v_t
8557  {
8558  return m_PCBAVersion;
8559  }
8560 
8562  inline void
8564  llrp_utf8v_t value)
8565  {
8566  m_PCBAVersion = value;
8567  }
8568 
8569 
8570  protected:
8571  std::list<CParameter *> m_listCustom;
8572 
8573  public:
8575  inline std::list<CParameter *>::iterator
8577  {
8578  return m_listCustom.begin();
8579  }
8580 
8582  inline std::list<CParameter *>::iterator
8583  endCustom (void)
8584  {
8585  return m_listCustom.end();
8586  }
8587 
8589  inline void
8591  {
8592  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8593  }
8594 
8596  inline int
8598  {
8599  return (int) (m_listCustom.size());
8600  }
8601 
8602  EResultCode
8604  addCustom (
8605  CParameter * pValue);
8606 
8607 
8608 };
8609 
8610 
8643 class CImpinjxArrayCapabilities : public CParameter
8644 {
8645  public:
8647  ~CImpinjxArrayCapabilities (void);
8648 
8651 
8652  static const CFieldDescriptor * const
8653  s_apFieldDescriptorTable[];
8654 
8655  static const CTypeDescriptor
8656  s_typeDescriptor;
8657 
8658  void
8659  decodeFields (
8660  CDecoderStream * pDecoderStream);
8661 
8662  void
8663  assimilateSubParameters (
8664  CErrorDetails * pError);
8665 
8666  void
8667  encode (
8668  CEncoderStream * pEncoderStream) const;
8669 
8670 
8671  llrp_bool_t
8672  isAllowedIn (
8673  const CTypeDescriptor * pEnclosingElementType) const;
8674 
8675 
8676  static CElement *
8677  s_construct (void);
8678 
8679  static void
8680  s_decodeFields (
8681  CDecoderStream * pDecoderStream,
8682  CElement * pElement);
8684 
8685 
8686  protected:
8687  llrp_u32_t m_MaxNumSectors;
8688 
8691  public:
8692  static const CFieldDescriptor
8693  s_fdMaxNumSectors;
8695 
8697  inline llrp_u32_t
8699  {
8700  return m_MaxNumSectors;
8701  }
8702 
8704  inline void
8706  llrp_u32_t value)
8707  {
8708  m_MaxNumSectors = value;
8709  }
8710 
8711 
8712  protected:
8713  llrp_u1_t m_SupportsLISpecs;
8714 
8717  public:
8718  static const CFieldDescriptor
8719  s_fdSupportsLISpecs;
8721 
8723  inline llrp_u1_t
8725  {
8726  return m_SupportsLISpecs;
8727  }
8728 
8730  inline void
8732  llrp_u1_t value)
8733  {
8734  m_SupportsLISpecs = value;
8735  }
8736 
8737 
8738  protected:
8739  llrp_u1_t m_SupportsTISpecs;
8740 
8743  public:
8744  static const CFieldDescriptor
8745  s_fdSupportsTISpecs;
8747 
8749  inline llrp_u1_t
8751  {
8752  return m_SupportsTISpecs;
8753  }
8754 
8756  inline void
8758  llrp_u1_t value)
8759  {
8760  m_SupportsTISpecs = value;
8761  }
8762 
8763 
8764  protected:
8765  llrp_u1_t m_SupportsTSISpecs;
8766 
8769  public:
8770  static const CFieldDescriptor
8771  s_fdSupportsTSISpecs;
8773 
8775  inline llrp_u1_t
8777  {
8778  return m_SupportsTSISpecs;
8779  }
8780 
8782  inline void
8784  llrp_u1_t value)
8785  {
8786  m_SupportsTSISpecs = value;
8787  }
8788 
8789 
8790  protected:
8791  llrp_u1_t m_SupportsDISpecs;
8792 
8795  public:
8796  static const CFieldDescriptor
8797  s_fdSupportsDISpecs;
8799 
8801  inline llrp_u1_t
8803  {
8804  return m_SupportsDISpecs;
8805  }
8806 
8808  inline void
8810  llrp_u1_t value)
8811  {
8812  m_SupportsDISpecs = value;
8813  }
8814 
8815 
8816  protected:
8817  CImpinjxArrayDirectionCapabilities * m_pImpinjxArrayDirectionCapabilities;
8818 
8819  public:
8823  {
8824  return m_pImpinjxArrayDirectionCapabilities;
8825  }
8826 
8828  EResultCode
8831 
8832 
8833  protected:
8834  std::list<CParameter *> m_listCustom;
8835 
8836  public:
8838  inline std::list<CParameter *>::iterator
8840  {
8841  return m_listCustom.begin();
8842  }
8843 
8845  inline std::list<CParameter *>::iterator
8846  endCustom (void)
8847  {
8848  return m_listCustom.end();
8849  }
8850 
8852  inline void
8854  {
8855  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8856  }
8857 
8859  inline int
8861  {
8862  return (int) (m_listCustom.size());
8863  }
8864 
8865  EResultCode
8867  addCustom (
8868  CParameter * pValue);
8869 
8870 
8871 };
8872 
8873 
8901 class CImpinjTiltConfiguration : public CParameter
8902 {
8903  public:
8904  CImpinjTiltConfiguration (void);
8905  ~CImpinjTiltConfiguration (void);
8906 
8909 
8910  static const CFieldDescriptor * const
8911  s_apFieldDescriptorTable[];
8912 
8913  static const CTypeDescriptor
8914  s_typeDescriptor;
8915 
8916  void
8917  decodeFields (
8918  CDecoderStream * pDecoderStream);
8919 
8920  void
8921  assimilateSubParameters (
8922  CErrorDetails * pError);
8923 
8924  void
8925  encode (
8926  CEncoderStream * pEncoderStream) const;
8927 
8928 
8929  llrp_bool_t
8930  isAllowedIn (
8931  const CTypeDescriptor * pEnclosingElementType) const;
8932 
8933 
8934  static CElement *
8935  s_construct (void);
8936 
8937  static void
8938  s_decodeFields (
8939  CDecoderStream * pDecoderStream,
8940  CElement * pElement);
8942 
8943 
8944  protected:
8945  llrp_s32_t m_XAxis;
8946 
8949  public:
8950  static const CFieldDescriptor
8951  s_fdXAxis;
8953 
8955  inline llrp_s32_t
8956  getXAxis (void)
8957  {
8958  return m_XAxis;
8959  }
8960 
8962  inline void
8964  llrp_s32_t value)
8965  {
8966  m_XAxis = value;
8967  }
8968 
8969 
8970  protected:
8971  llrp_s32_t m_YAxis;
8972 
8975  public:
8976  static const CFieldDescriptor
8977  s_fdYAxis;
8979 
8981  inline llrp_s32_t
8982  getYAxis (void)
8983  {
8984  return m_YAxis;
8985  }
8986 
8988  inline void
8990  llrp_s32_t value)
8991  {
8992  m_YAxis = value;
8993  }
8994 
8995 
8996  protected:
8997  llrp_s32_t m_ZAxis;
8998 
9001  public:
9002  static const CFieldDescriptor
9003  s_fdZAxis;
9005 
9007  inline llrp_s32_t
9008  getZAxis (void)
9009  {
9010  return m_ZAxis;
9011  }
9012 
9014  inline void
9016  llrp_s32_t value)
9017  {
9018  m_ZAxis = value;
9019  }
9020 
9021 
9022  protected:
9023  std::list<CParameter *> m_listCustom;
9024 
9025  public:
9027  inline std::list<CParameter *>::iterator
9029  {
9030  return m_listCustom.begin();
9031  }
9032 
9034  inline std::list<CParameter *>::iterator
9035  endCustom (void)
9036  {
9037  return m_listCustom.end();
9038  }
9039 
9041  inline void
9043  {
9044  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9045  }
9046 
9048  inline int
9050  {
9051  return (int) (m_listCustom.size());
9052  }
9053 
9054  EResultCode
9056  addCustom (
9057  CParameter * pValue);
9058 
9059 
9060 };
9061 
9062 
9091 class CImpinjBeaconConfiguration : public CParameter
9092 {
9093  public:
9096 
9099 
9100  static const CFieldDescriptor * const
9101  s_apFieldDescriptorTable[];
9102 
9103  static const CTypeDescriptor
9104  s_typeDescriptor;
9105 
9106  void
9107  decodeFields (
9108  CDecoderStream * pDecoderStream);
9109 
9110  void
9111  assimilateSubParameters (
9112  CErrorDetails * pError);
9113 
9114  void
9115  encode (
9116  CEncoderStream * pEncoderStream) const;
9117 
9118 
9119  llrp_bool_t
9120  isAllowedIn (
9121  const CTypeDescriptor * pEnclosingElementType) const;
9122 
9123 
9124  static CElement *
9125  s_construct (void);
9126 
9127  static void
9128  s_decodeFields (
9129  CDecoderStream * pDecoderStream,
9130  CElement * pElement);
9132 
9133 
9134  protected:
9135  llrp_u1_t m_BeaconState;
9136 
9139  public:
9140  static const CFieldDescriptor
9141  s_fdBeaconState;
9143 
9145  inline llrp_u1_t
9147  {
9148  return m_BeaconState;
9149  }
9150 
9152  inline void
9154  llrp_u1_t value)
9155  {
9156  m_BeaconState = value;
9157  }
9158 
9159 
9160  protected:
9161  llrp_u64_t m_BeaconDurationSeconds;
9162 
9165  public:
9166  static const CFieldDescriptor
9167  s_fdBeaconDurationSeconds;
9169 
9171  inline llrp_u64_t
9173  {
9174  return m_BeaconDurationSeconds;
9175  }
9176 
9178  inline void
9180  llrp_u64_t value)
9181  {
9182  m_BeaconDurationSeconds = value;
9183  }
9184 
9185 
9186  protected:
9187  std::list<CParameter *> m_listCustom;
9188 
9189  public:
9191  inline std::list<CParameter *>::iterator
9193  {
9194  return m_listCustom.begin();
9195  }
9196 
9198  inline std::list<CParameter *>::iterator
9199  endCustom (void)
9200  {
9201  return m_listCustom.end();
9202  }
9203 
9205  inline void
9207  {
9208  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9209  }
9210 
9212  inline int
9214  {
9215  return (int) (m_listCustom.size());
9216  }
9217 
9218  EResultCode
9220  addCustom (
9221  CParameter * pValue);
9222 
9223 
9224 };
9225 
9226 
9256 class CImpinjAntennaConfiguration : public CParameter
9257 {
9258  public:
9261 
9264 
9265  static const CFieldDescriptor * const
9266  s_apFieldDescriptorTable[];
9267 
9268  static const CTypeDescriptor
9269  s_typeDescriptor;
9270 
9271  void
9272  decodeFields (
9273  CDecoderStream * pDecoderStream);
9274 
9275  void
9276  assimilateSubParameters (
9277  CErrorDetails * pError);
9278 
9279  void
9280  encode (
9281  CEncoderStream * pEncoderStream) const;
9282 
9283 
9284  llrp_bool_t
9285  isAllowedIn (
9286  const CTypeDescriptor * pEnclosingElementType) const;
9287 
9288 
9289  static CElement *
9290  s_construct (void);
9291 
9292  static void
9293  s_decodeFields (
9294  CDecoderStream * pDecoderStream,
9295  CElement * pElement);
9297 
9298 
9299  protected:
9300  CImpinjAntennaEventHysteresis * m_pImpinjAntennaEventHysteresis;
9301 
9302  public:
9306  {
9307  return m_pImpinjAntennaEventHysteresis;
9308  }
9309 
9311  EResultCode
9314 
9315 
9316  protected:
9317  std::list<CParameter *> m_listCustom;
9318 
9319  public:
9321  inline std::list<CParameter *>::iterator
9323  {
9324  return m_listCustom.begin();
9325  }
9326 
9328  inline std::list<CParameter *>::iterator
9329  endCustom (void)
9330  {
9331  return m_listCustom.end();
9332  }
9333 
9335  inline void
9337  {
9338  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9339  }
9340 
9342  inline int
9344  {
9345  return (int) (m_listCustom.size());
9346  }
9347 
9348  EResultCode
9350  addCustom (
9351  CParameter * pValue);
9352 
9353 
9354 };
9355 
9356 
9388 class CImpinjAntennaEventHysteresis : public CParameter
9389 {
9390  public:
9393 
9396 
9397  static const CFieldDescriptor * const
9398  s_apFieldDescriptorTable[];
9399 
9400  static const CTypeDescriptor
9401  s_typeDescriptor;
9402 
9403  void
9404  decodeFields (
9405  CDecoderStream * pDecoderStream);
9406 
9407  void
9408  assimilateSubParameters (
9409  CErrorDetails * pError);
9410 
9411  void
9412  encode (
9413  CEncoderStream * pEncoderStream) const;
9414 
9415 
9416  llrp_bool_t
9417  isAllowedIn (
9418  const CTypeDescriptor * pEnclosingElementType) const;
9419 
9420 
9421  static CElement *
9422  s_construct (void);
9423 
9424  static void
9425  s_decodeFields (
9426  CDecoderStream * pDecoderStream,
9427  CElement * pElement);
9429 
9430 
9431  protected:
9432  llrp_u64_t m_AntennaEventConnected;
9433 
9436  public:
9437  static const CFieldDescriptor
9438  s_fdAntennaEventConnected;
9440 
9442  inline llrp_u64_t
9444  {
9445  return m_AntennaEventConnected;
9446  }
9447 
9449  inline void
9451  llrp_u64_t value)
9452  {
9453  m_AntennaEventConnected = value;
9454  }
9455 
9456 
9457  protected:
9458  llrp_u64_t m_AntennaEventDisconnected;
9459 
9462  public:
9463  static const CFieldDescriptor
9464  s_fdAntennaEventDisconnected;
9466 
9468  inline llrp_u64_t
9470  {
9471  return m_AntennaEventDisconnected;
9472  }
9473 
9475  inline void
9477  llrp_u64_t value)
9478  {
9479  m_AntennaEventDisconnected = value;
9480  }
9481 
9482 
9483  protected:
9484  std::list<CParameter *> m_listCustom;
9485 
9486  public:
9488  inline std::list<CParameter *>::iterator
9490  {
9491  return m_listCustom.begin();
9492  }
9493 
9495  inline std::list<CParameter *>::iterator
9496  endCustom (void)
9497  {
9498  return m_listCustom.end();
9499  }
9500 
9502  inline void
9504  {
9505  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9506  }
9507 
9509  inline int
9511  {
9512  return (int) (m_listCustom.size());
9513  }
9514 
9515  EResultCode
9517  addCustom (
9518  CParameter * pValue);
9519 
9520 
9521 };
9522 
9523 
9551 class CImpinjHubConfiguration : public CParameter
9552 {
9553  public:
9554  CImpinjHubConfiguration (void);
9555  ~CImpinjHubConfiguration (void);
9556 
9559 
9560  static const CFieldDescriptor * const
9561  s_apFieldDescriptorTable[];
9562 
9563  static const CTypeDescriptor
9564  s_typeDescriptor;
9565 
9566  void
9567  decodeFields (
9568  CDecoderStream * pDecoderStream);
9569 
9570  void
9571  assimilateSubParameters (
9572  CErrorDetails * pError);
9573 
9574  void
9575  encode (
9576  CEncoderStream * pEncoderStream) const;
9577 
9578 
9579  llrp_bool_t
9580  isAllowedIn (
9581  const CTypeDescriptor * pEnclosingElementType) const;
9582 
9583 
9584  static CElement *
9585  s_construct (void);
9586 
9587  static void
9588  s_decodeFields (
9589  CDecoderStream * pDecoderStream,
9590  CElement * pElement);
9592 
9593 
9594  protected:
9595  llrp_u16_t m_HubID;
9596 
9599  public:
9600  static const CFieldDescriptor
9601  s_fdHubID;
9603 
9605  inline llrp_u16_t
9606  getHubID (void)
9607  {
9608  return m_HubID;
9609  }
9610 
9612  inline void
9614  llrp_u16_t value)
9615  {
9616  m_HubID = value;
9617  }
9618 
9619 
9620  protected:
9621  EImpinjHubConnectedType m_eConnected;
9622 
9625  public:
9626  static const CFieldDescriptor
9627  s_fdConnected;
9629 
9631  inline EImpinjHubConnectedType
9633  {
9634  return m_eConnected;
9635  }
9636 
9638  inline void
9640  EImpinjHubConnectedType value)
9641  {
9642  m_eConnected = value;
9643  }
9644 
9645 
9646  protected:
9647  EImpinjHubFaultType m_eFault;
9648 
9651  public:
9652  static const CFieldDescriptor
9653  s_fdFault;
9655 
9657  inline EImpinjHubFaultType
9658  getFault (void)
9659  {
9660  return m_eFault;
9661  }
9662 
9664  inline void
9666  EImpinjHubFaultType value)
9667  {
9668  m_eFault = value;
9669  }
9670 
9671 
9672  protected:
9673  std::list<CParameter *> m_listCustom;
9674 
9675  public:
9677  inline std::list<CParameter *>::iterator
9679  {
9680  return m_listCustom.begin();
9681  }
9682 
9684  inline std::list<CParameter *>::iterator
9685  endCustom (void)
9686  {
9687  return m_listCustom.end();
9688  }
9689 
9691  inline void
9693  {
9694  clearSubParameterList ((tListOfParameters *) &m_listCustom);
9695  }
9696 
9698  inline int
9700  {
9701  return (int) (m_listCustom.size());
9702  }
9703 
9704  EResultCode
9706  addCustom (
9707  CParameter * pValue);
9708 
9709 
9710 };
9711 
9712 
9736 class CImpinjDiagnosticReport : public CParameter
9737 {
9738  public:
9739  CImpinjDiagnosticReport (void);
9740  ~CImpinjDiagnosticReport (void);
9741 
9744 
9745  static const CFieldDescriptor * const
9746  s_apFieldDescriptorTable[];
9747 
9748  static const CTypeDescriptor
9749  s_typeDescriptor;
9750 
9751  void
9752  decodeFields (
9753  CDecoderStream * pDecoderStream);
9754 
9755  void
9756  assimilateSubParameters (
9757  CErrorDetails * pError);
9758 
9759  void
9760  encode (
9761  CEncoderStream * pEncoderStream) const;
9762 
9763 
9764  llrp_bool_t
9765  isAllowedIn (
9766  const CTypeDescriptor * pEnclosingElementType) const;
9767 
9768 
9769  static CElement *
9770  s_construct (void);
9771 
9772  static void
9773  s_decodeFields (
9774  CDecoderStream * pDecoderStream,
9775  CElement * pElement);
9777 
9778 
9779  protected:
9780  llrp_u32v_t m_Metric;
9781 
9784  public:
9785  static const CFieldDescriptor
9786  s_fdMetric;
9788 
9790  inline llrp_u32v_t
9791  getMetric (void)
9792  {
9793  return m_Metric;
9794  }
9795 
9797  inline void
9799  llrp_u32v_t value)
9800  {
9801  m_Metric = value;
9802  }
9803 
9804 
9805 };
9806 
9807 
9846 class CImpinjPlacementConfiguration : public CParameter
9847 {
9848  public:
9851 
9854 
9855  static const CFieldDescriptor * const
9856  s_apFieldDescriptorTable[];
9857 
9858  static const CTypeDescriptor
9859  s_typeDescriptor;
9860 
9861  void
9862  decodeFields (
9863  CDecoderStream * pDecoderStream);
9864 
9865  void
9866  assimilateSubParameters (
9867  CErrorDetails * pError);
9868 
9869  void
9870  encode (
9871  CEncoderStream * pEncoderStream) const;
9872 
9873 
9874  llrp_bool_t
9875  isAllowedIn (
9876  const CTypeDescriptor * pEnclosingElementType) const;
9877 
9878 
9879  static CElement *
9880  s_construct (void);
9881 
9882  static void
9883  s_decodeFields (
9884  CDecoderStream * pDecoderStream,
9885  CElement * pElement);
9887 
9888 
9889  protected:
9890  llrp_u16_t m_HeightCm;
9891 
9894  public:
9895  static const CFieldDescriptor
9896  s_fdHeightCm;
9898 
9900  inline llrp_u16_t
9902  {
9903  return m_HeightCm;
9904  }
9905 
9907  inline void
9909  llrp_u16_t value)
9910  {
9911  m_HeightCm = value;
9912  }
9913 
9914 
9915  protected:
9916  llrp_s32_t m_FacilityXLocationCm;
9917 
9920  public:
9921  static const CFieldDescriptor
9922  s_fdFacilityXLocationCm;
9924 
9926  inline llrp_s32_t
9928  {
9929  return m_FacilityXLocationCm;
9930  }
9931 
9933  inline void
9935  llrp_s32_t value)
9936  {
9937  m_FacilityXLocationCm = value;
9938  }
9939 
9940 
9941  protected:
9942  llrp_s32_t m_FacilityYLocationCm;
9943 
9946  public:
9947  static const CFieldDescriptor
9948  s_fdFacilityYLocationCm;
9950 
9952  inline llrp_s32_t
9954  {
9955  return m_FacilityYLocationCm;
9956  }
9957 
9959  inline void
9961  llrp_s32_t value)
9962  {
9963  m_FacilityYLocationCm = value;
9964  }
9965 
9966 
9967  protected:
9968  llrp_s16_t m_OrientationDegrees;
9969 
9972  public:
9973  static const CFieldDescriptor
9974  s_fdOrientationDegrees;
9976 
9978  inline llrp_s16_t
9980  {
9981  return m_OrientationDegrees;
9982  }
9983 
9985  inline void
9987  llrp_s16_t value)
9988  {
9989  m_OrientationDegrees = value;
9990  }
9991 
9992 
9993  protected:
9994  std::list<CParameter *> m_listCustom;
9995 
9996  public:
9998  inline std::list<CParameter *>::iterator
10000  {
10001  return m_listCustom.begin();
10002  }
10003 
10005  inline std::list<CParameter *>::iterator
10006  endCustom (void)
10007  {
10008  return m_listCustom.end();
10009  }
10010 
10012  inline void
10014  {
10015  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10016  }
10017 
10019  inline int
10021  {
10022  return (int) (m_listCustom.size());
10023  }
10024 
10025  EResultCode
10027  addCustom (
10028  CParameter * pValue);
10029 
10030 
10031 };
10032 
10033 
10064 class CImpinjLISpec : public CParameter
10065 {
10066  public:
10067  CImpinjLISpec (void);
10068  ~CImpinjLISpec (void);
10069 
10072 
10073  static const CFieldDescriptor * const
10074  s_apFieldDescriptorTable[];
10075 
10076  static const CTypeDescriptor
10077  s_typeDescriptor;
10078 
10079  void
10080  decodeFields (
10081  CDecoderStream * pDecoderStream);
10082 
10083  void
10084  assimilateSubParameters (
10085  CErrorDetails * pError);
10086 
10087  void
10088  encode (
10089  CEncoderStream * pEncoderStream) const;
10090 
10091 
10092  llrp_bool_t
10093  isAllowedIn (
10094  const CTypeDescriptor * pEnclosingElementType) const;
10095 
10096 
10097  static CElement *
10098  s_construct (void);
10099 
10100  static void
10101  s_decodeFields (
10102  CDecoderStream * pDecoderStream,
10103  CElement * pElement);
10105 
10106 
10107  protected:
10108  CImpinjLocationConfig * m_pImpinjLocationConfig;
10109 
10110  public:
10112  inline CImpinjLocationConfig *
10114  {
10115  return m_pImpinjLocationConfig;
10116  }
10117 
10119  EResultCode
10121  CImpinjLocationConfig * pValue);
10122 
10123 
10124  protected:
10125  CImpinjC1G2LocationConfig * m_pImpinjC1G2LocationConfig;
10126 
10127  public:
10129  inline CImpinjC1G2LocationConfig *
10131  {
10132  return m_pImpinjC1G2LocationConfig;
10133  }
10134 
10136  EResultCode
10138  CImpinjC1G2LocationConfig * pValue);
10139 
10140 
10141  protected:
10142  CImpinjLocationReporting * m_pImpinjLocationReporting;
10143 
10144  public:
10146  inline CImpinjLocationReporting *
10148  {
10149  return m_pImpinjLocationReporting;
10150  }
10151 
10153  EResultCode
10155  CImpinjLocationReporting * pValue);
10156 
10157 
10158  protected:
10159  std::list<CParameter *> m_listCustom;
10160 
10161  public:
10163  inline std::list<CParameter *>::iterator
10165  {
10166  return m_listCustom.begin();
10167  }
10168 
10170  inline std::list<CParameter *>::iterator
10171  endCustom (void)
10172  {
10173  return m_listCustom.end();
10174  }
10175 
10177  inline void
10179  {
10180  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10181  }
10182 
10184  inline int
10186  {
10187  return (int) (m_listCustom.size());
10188  }
10189 
10190  EResultCode
10192  addCustom (
10193  CParameter * pValue);
10194 
10195 
10196 };
10197 
10198 
10240 class CImpinjLocationConfig : public CParameter
10241 {
10242  public:
10243  CImpinjLocationConfig (void);
10244  ~CImpinjLocationConfig (void);
10245 
10248 
10249  static const CFieldDescriptor * const
10250  s_apFieldDescriptorTable[];
10251 
10252  static const CTypeDescriptor
10253  s_typeDescriptor;
10254 
10255  void
10256  decodeFields (
10257  CDecoderStream * pDecoderStream);
10258 
10259  void
10260  assimilateSubParameters (
10261  CErrorDetails * pError);
10262 
10263  void
10264  encode (
10265  CEncoderStream * pEncoderStream) const;
10266 
10267 
10268  llrp_bool_t
10269  isAllowedIn (
10270  const CTypeDescriptor * pEnclosingElementType) const;
10271 
10272 
10273  static CElement *
10274  s_construct (void);
10275 
10276  static void
10277  s_decodeFields (
10278  CDecoderStream * pDecoderStream,
10279  CElement * pElement);
10281 
10282 
10283  protected:
10284  llrp_u16_t m_ComputeWindowSeconds;
10285 
10288  public:
10289  static const CFieldDescriptor
10290  s_fdComputeWindowSeconds;
10292 
10294  inline llrp_u16_t
10296  {
10297  return m_ComputeWindowSeconds;
10298  }
10299 
10301  inline void
10303  llrp_u16_t value)
10304  {
10305  m_ComputeWindowSeconds = value;
10306  }
10307 
10308 
10309  protected:
10310  llrp_u16_t m_TagAgeIntervalSeconds;
10311 
10314  public:
10315  static const CFieldDescriptor
10316  s_fdTagAgeIntervalSeconds;
10318 
10320  inline llrp_u16_t
10322  {
10323  return m_TagAgeIntervalSeconds;
10324  }
10325 
10327  inline void
10329  llrp_u16_t value)
10330  {
10331  m_TagAgeIntervalSeconds = value;
10332  }
10333 
10334 
10335  protected:
10336  llrp_u16_t m_UpdateIntervalSeconds;
10337 
10340  public:
10341  static const CFieldDescriptor
10342  s_fdUpdateIntervalSeconds;
10344 
10346  inline llrp_u16_t
10348  {
10349  return m_UpdateIntervalSeconds;
10350  }
10351 
10353  inline void
10355  llrp_u16_t value)
10356  {
10357  m_UpdateIntervalSeconds = value;
10358  }
10359 
10360 
10361  protected:
10362  CImpinjDisabledAntennas * m_pImpinjDisabledAntennas;
10363 
10364  public:
10366  inline CImpinjDisabledAntennas *
10368  {
10369  return m_pImpinjDisabledAntennas;
10370  }
10371 
10373  EResultCode
10375  CImpinjDisabledAntennas * pValue);
10376 
10377 
10378  protected:
10379  std::list<CParameter *> m_listCustom;
10380 
10381  public:
10383  inline std::list<CParameter *>::iterator
10385  {
10386  return m_listCustom.begin();
10387  }
10388 
10390  inline std::list<CParameter *>::iterator
10391  endCustom (void)
10392  {
10393  return m_listCustom.end();
10394  }
10395 
10397  inline void
10399  {
10400  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10401  }
10402 
10404  inline int
10406  {
10407  return (int) (m_listCustom.size());
10408  }
10409 
10410  EResultCode
10412  addCustom (
10413  CParameter * pValue);
10414 
10415 
10416 };
10417 
10418 
10461 class CImpinjC1G2LocationConfig : public CParameter
10462 {
10463  public:
10465  ~CImpinjC1G2LocationConfig (void);
10466 
10469 
10470  static const CFieldDescriptor * const
10471  s_apFieldDescriptorTable[];
10472 
10473  static const CTypeDescriptor
10474  s_typeDescriptor;
10475 
10476  void
10477  decodeFields (
10478  CDecoderStream * pDecoderStream);
10479 
10480  void
10481  assimilateSubParameters (
10482  CErrorDetails * pError);
10483 
10484  void
10485  encode (
10486  CEncoderStream * pEncoderStream) const;
10487 
10488 
10489  llrp_bool_t
10490  isAllowedIn (
10491  const CTypeDescriptor * pEnclosingElementType) const;
10492 
10493 
10494  static CElement *
10495  s_construct (void);
10496 
10497  static void
10498  s_decodeFields (
10499  CDecoderStream * pDecoderStream,
10500  CElement * pElement);
10502 
10503 
10504  protected:
10505  llrp_u16_t m_ModeIndex;
10506 
10509  public:
10510  static const CFieldDescriptor
10511  s_fdModeIndex;
10513 
10515  inline llrp_u16_t
10517  {
10518  return m_ModeIndex;
10519  }
10520 
10522  inline void
10524  llrp_u16_t value)
10525  {
10526  m_ModeIndex = value;
10527  }
10528 
10529 
10530  protected:
10531  llrp_u2_t m_Session;
10532 
10535  public:
10536  static const CFieldDescriptor
10537  s_fdSession;
10539 
10541  inline llrp_u2_t
10542  getSession (void)
10543  {
10544  return m_Session;
10545  }
10546 
10548  inline void
10550  llrp_u2_t value)
10551  {
10552  m_Session = value;
10553  }
10554 
10555 
10556  protected:
10557  std::list<CC1G2Filter *> m_listC1G2Filter;
10558 
10559  public:
10561  inline std::list<CC1G2Filter *>::iterator
10563  {
10564  return m_listC1G2Filter.begin();
10565  }
10566 
10568  inline std::list<CC1G2Filter *>::iterator
10570  {
10571  return m_listC1G2Filter.end();
10572  }
10573 
10575  inline void
10577  {
10578  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
10579  }
10580 
10582  inline int
10584  {
10585  return (int) (m_listC1G2Filter.size());
10586  }
10587 
10588  EResultCode
10590  addC1G2Filter (
10591  CC1G2Filter * pValue);
10592 
10593 
10594  protected:
10595  CImpinjTransmitPower * m_pImpinjTransmitPower;
10596 
10597  public:
10599  inline CImpinjTransmitPower *
10601  {
10602  return m_pImpinjTransmitPower;
10603  }
10604 
10606  EResultCode
10608  CImpinjTransmitPower * pValue);
10609 
10610 
10611  protected:
10612  std::list<CParameter *> m_listCustom;
10613 
10614  public:
10616  inline std::list<CParameter *>::iterator
10618  {
10619  return m_listCustom.begin();
10620  }
10621 
10623  inline std::list<CParameter *>::iterator
10624  endCustom (void)
10625  {
10626  return m_listCustom.end();
10627  }
10628 
10630  inline void
10632  {
10633  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10634  }
10635 
10637  inline int
10639  {
10640  return (int) (m_listCustom.size());
10641  }
10642 
10643  EResultCode
10645  addCustom (
10646  CParameter * pValue);
10647 
10648 
10649 };
10650 
10651 
10693 class CImpinjLocationReporting : public CParameter
10694 {
10695  public:
10696  CImpinjLocationReporting (void);
10697  ~CImpinjLocationReporting (void);
10698 
10701 
10702  static const CFieldDescriptor * const
10703  s_apFieldDescriptorTable[];
10704 
10705  static const CTypeDescriptor
10706  s_typeDescriptor;
10707 
10708  void
10709  decodeFields (
10710  CDecoderStream * pDecoderStream);
10711 
10712  void
10713  assimilateSubParameters (
10714  CErrorDetails * pError);
10715 
10716  void
10717  encode (
10718  CEncoderStream * pEncoderStream) const;
10719 
10720 
10721  llrp_bool_t
10722  isAllowedIn (
10723  const CTypeDescriptor * pEnclosingElementType) const;
10724 
10725 
10726  static CElement *
10727  s_construct (void);
10728 
10729  static void
10730  s_decodeFields (
10731  CDecoderStream * pDecoderStream,
10732  CElement * pElement);
10734 
10735 
10736  protected:
10737  llrp_u1_t m_EnableUpdateReport;
10738 
10741  public:
10742  static const CFieldDescriptor
10743  s_fdEnableUpdateReport;
10745 
10747  inline llrp_u1_t
10749  {
10750  return m_EnableUpdateReport;
10751  }
10752 
10754  inline void
10756  llrp_u1_t value)
10757  {
10758  m_EnableUpdateReport = value;
10759  }
10760 
10761 
10762  protected:
10763  llrp_u1_t m_EnableEntryReport;
10764 
10767  public:
10768  static const CFieldDescriptor
10769  s_fdEnableEntryReport;
10771 
10773  inline llrp_u1_t
10775  {
10776  return m_EnableEntryReport;
10777  }
10778 
10780  inline void
10782  llrp_u1_t value)
10783  {
10784  m_EnableEntryReport = value;
10785  }
10786 
10787 
10788  protected:
10789  llrp_u1_t m_EnableExitReport;
10790 
10793  public:
10794  static const CFieldDescriptor
10795  s_fdEnableExitReport;
10797 
10799  inline llrp_u1_t
10801  {
10802  return m_EnableExitReport;
10803  }
10804 
10806  inline void
10808  llrp_u1_t value)
10809  {
10810  m_EnableExitReport = value;
10811  }
10812 
10813 
10814  protected:
10815  llrp_u1_t m_EnableDiagnosticReport;
10816 
10819  public:
10820  static const CFieldDescriptor
10821  s_fdEnableDiagnosticReport;
10823 
10825  inline llrp_u1_t
10827  {
10828  return m_EnableDiagnosticReport;
10829  }
10830 
10832  inline void
10834  llrp_u1_t value)
10835  {
10836  m_EnableDiagnosticReport = value;
10837  }
10838 
10839 
10840  protected:
10841  std::list<CParameter *> m_listCustom;
10842 
10843  public:
10845  inline std::list<CParameter *>::iterator
10847  {
10848  return m_listCustom.begin();
10849  }
10850 
10852  inline std::list<CParameter *>::iterator
10853  endCustom (void)
10854  {
10855  return m_listCustom.end();
10856  }
10857 
10859  inline void
10861  {
10862  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10863  }
10864 
10866  inline int
10868  {
10869  return (int) (m_listCustom.size());
10870  }
10871 
10872  EResultCode
10874  addCustom (
10875  CParameter * pValue);
10876 
10877 
10878 };
10879 
10880 
10911 class CImpinjLocationConfidence : public CParameter
10912 {
10913  public:
10915  ~CImpinjLocationConfidence (void);
10916 
10919 
10920  static const CFieldDescriptor * const
10921  s_apFieldDescriptorTable[];
10922 
10923  static const CTypeDescriptor
10924  s_typeDescriptor;
10925 
10926  void
10927  decodeFields (
10928  CDecoderStream * pDecoderStream);
10929 
10930  void
10931  assimilateSubParameters (
10932  CErrorDetails * pError);
10933 
10934  void
10935  encode (
10936  CEncoderStream * pEncoderStream) const;
10937 
10938 
10939  llrp_bool_t
10940  isAllowedIn (
10941  const CTypeDescriptor * pEnclosingElementType) const;
10942 
10943 
10944  static CElement *
10945  s_construct (void);
10946 
10947  static void
10948  s_decodeFields (
10949  CDecoderStream * pDecoderStream,
10950  CElement * pElement);
10952 
10953 
10954  protected:
10955  llrp_u16_t m_ReadCount;
10956 
10959  public:
10960  static const CFieldDescriptor
10961  s_fdReadCount;
10963 
10965  inline llrp_u16_t
10967  {
10968  return m_ReadCount;
10969  }
10970 
10972  inline void
10974  llrp_u16_t value)
10975  {
10976  m_ReadCount = value;
10977  }
10978 
10979 
10980  protected:
10981  llrp_u32v_t m_ConfidenceData;
10982 
10985  public:
10986  static const CFieldDescriptor
10987  s_fdConfidenceData;
10989 
10991  inline llrp_u32v_t
10993  {
10994  return m_ConfidenceData;
10995  }
10996 
10998  inline void
11000  llrp_u32v_t value)
11001  {
11002  m_ConfidenceData = value;
11003  }
11004 
11005 
11006  protected:
11007  std::list<CParameter *> m_listCustom;
11008 
11009  public:
11011  inline std::list<CParameter *>::iterator
11013  {
11014  return m_listCustom.begin();
11015  }
11016 
11018  inline std::list<CParameter *>::iterator
11019  endCustom (void)
11020  {
11021  return m_listCustom.end();
11022  }
11023 
11025  inline void
11027  {
11028  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11029  }
11030 
11032  inline int
11034  {
11035  return (int) (m_listCustom.size());
11036  }
11037 
11038  EResultCode
11040  addCustom (
11041  CParameter * pValue);
11042 
11043 
11044 };
11045 
11046 
11084 class CImpinjLocationReportData : public CParameter
11085 {
11086  public:
11088  ~CImpinjLocationReportData (void);
11089 
11092 
11093  static const CFieldDescriptor * const
11094  s_apFieldDescriptorTable[];
11095 
11096  static const CTypeDescriptor
11097  s_typeDescriptor;
11098 
11099  void
11100  decodeFields (
11101  CDecoderStream * pDecoderStream);
11102 
11103  void
11104  assimilateSubParameters (
11105  CErrorDetails * pError);
11106 
11107  void
11108  encode (
11109  CEncoderStream * pEncoderStream) const;
11110 
11111 
11112  llrp_bool_t
11113  isAllowedIn (
11114  const CTypeDescriptor * pEnclosingElementType) const;
11115 
11116 
11117  static CElement *
11118  s_construct (void);
11119 
11120  static void
11121  s_decodeFields (
11122  CDecoderStream * pDecoderStream,
11123  CElement * pElement);
11125 
11126 
11127  protected:
11128  llrp_u64_t m_LastSeenTimestampUTC;
11129 
11132  public:
11133  static const CFieldDescriptor
11134  s_fdLastSeenTimestampUTC;
11136 
11138  inline llrp_u64_t
11140  {
11141  return m_LastSeenTimestampUTC;
11142  }
11143 
11145  inline void
11147  llrp_u64_t value)
11148  {
11149  m_LastSeenTimestampUTC = value;
11150  }
11151 
11152 
11153  protected:
11154  llrp_s32_t m_LocXCentimeters;
11155 
11158  public:
11159  static const CFieldDescriptor
11160  s_fdLocXCentimeters;
11162 
11164  inline llrp_s32_t
11166  {
11167  return m_LocXCentimeters;
11168  }
11169 
11171  inline void
11173  llrp_s32_t value)
11174  {
11175  m_LocXCentimeters = value;
11176  }
11177 
11178 
11179  protected:
11180  llrp_s32_t m_LocYCentimeters;
11181 
11184  public:
11185  static const CFieldDescriptor
11186  s_fdLocYCentimeters;
11188 
11190  inline llrp_s32_t
11192  {
11193  return m_LocYCentimeters;
11194  }
11195 
11197  inline void
11199  llrp_s32_t value)
11200  {
11201  m_LocYCentimeters = value;
11202  }
11203 
11204 
11205  protected:
11206  EImpinjLocationReportType m_eType;
11207 
11210  public:
11211  static const CFieldDescriptor
11212  s_fdType;
11214 
11216  inline EImpinjLocationReportType
11217  getType (void)
11218  {
11219  return m_eType;
11220  }
11221 
11223  inline void
11225  EImpinjLocationReportType value)
11226  {
11227  m_eType = value;
11228  }
11229 
11230 
11231  protected:
11232  CImpinjLocationConfidence * m_pImpinjLocationConfidence;
11233 
11234  public:
11236  inline CImpinjLocationConfidence *
11238  {
11239  return m_pImpinjLocationConfidence;
11240  }
11241 
11243  EResultCode
11245  CImpinjLocationConfidence * pValue);
11246 
11247 
11248  protected:
11249  std::list<CParameter *> m_listCustom;
11250 
11251  public:
11253  inline std::list<CParameter *>::iterator
11255  {
11256  return m_listCustom.begin();
11257  }
11258 
11260  inline std::list<CParameter *>::iterator
11261  endCustom (void)
11262  {
11263  return m_listCustom.end();
11264  }
11265 
11267  inline void
11269  {
11270  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11271  }
11272 
11274  inline int
11276  {
11277  return (int) (m_listCustom.size());
11278  }
11279 
11280  EResultCode
11282  addCustom (
11283  CParameter * pValue);
11284 
11285 
11286 };
11287 
11288 
11321 class CImpinjDISpec : public CParameter
11322 {
11323  public:
11324  CImpinjDISpec (void);
11325  ~CImpinjDISpec (void);
11326 
11329 
11330  static const CFieldDescriptor * const
11331  s_apFieldDescriptorTable[];
11332 
11333  static const CTypeDescriptor
11334  s_typeDescriptor;
11335 
11336  void
11337  decodeFields (
11338  CDecoderStream * pDecoderStream);
11339 
11340  void
11341  assimilateSubParameters (
11342  CErrorDetails * pError);
11343 
11344  void
11345  encode (
11346  CEncoderStream * pEncoderStream) const;
11347 
11348 
11349  llrp_bool_t
11350  isAllowedIn (
11351  const CTypeDescriptor * pEnclosingElementType) const;
11352 
11353 
11354  static CElement *
11355  s_construct (void);
11356 
11357  static void
11358  s_decodeFields (
11359  CDecoderStream * pDecoderStream,
11360  CElement * pElement);
11362 
11363 
11364  protected:
11365  CImpinjDirectionSectors * m_pImpinjDirectionSectors;
11366 
11367  public:
11369  inline CImpinjDirectionSectors *
11371  {
11372  return m_pImpinjDirectionSectors;
11373  }
11374 
11376  EResultCode
11378  CImpinjDirectionSectors * pValue);
11379 
11380 
11381  protected:
11382  CImpinjDirectionConfig * m_pImpinjDirectionConfig;
11383 
11384  public:
11386  inline CImpinjDirectionConfig *
11388  {
11389  return m_pImpinjDirectionConfig;
11390  }
11391 
11393  EResultCode
11395  CImpinjDirectionConfig * pValue);
11396 
11397 
11398  protected:
11399  CImpinjC1G2DirectionConfig * m_pImpinjC1G2DirectionConfig;
11400 
11401  public:
11405  {
11406  return m_pImpinjC1G2DirectionConfig;
11407  }
11408 
11410  EResultCode
11412  CImpinjC1G2DirectionConfig * pValue);
11413 
11414 
11415  protected:
11416  CImpinjDirectionReporting * m_pImpinjDirectionReporting;
11417 
11418  public:
11420  inline CImpinjDirectionReporting *
11422  {
11423  return m_pImpinjDirectionReporting;
11424  }
11425 
11427  EResultCode
11429  CImpinjDirectionReporting * pValue);
11430 
11431 
11432  protected:
11433  std::list<CParameter *> m_listCustom;
11434 
11435  public:
11437  inline std::list<CParameter *>::iterator
11439  {
11440  return m_listCustom.begin();
11441  }
11442 
11444  inline std::list<CParameter *>::iterator
11445  endCustom (void)
11446  {
11447  return m_listCustom.end();
11448  }
11449 
11451  inline void
11453  {
11454  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11455  }
11456 
11458  inline int
11460  {
11461  return (int) (m_listCustom.size());
11462  }
11463 
11464  EResultCode
11466  addCustom (
11467  CParameter * pValue);
11468 
11469 
11470 };
11471 
11472 
11500 class CImpinjDirectionSectors : public CParameter
11501 {
11502  public:
11503  CImpinjDirectionSectors (void);
11504  ~CImpinjDirectionSectors (void);
11505 
11508 
11509  static const CFieldDescriptor * const
11510  s_apFieldDescriptorTable[];
11511 
11512  static const CTypeDescriptor
11513  s_typeDescriptor;
11514 
11515  void
11516  decodeFields (
11517  CDecoderStream * pDecoderStream);
11518 
11519  void
11520  assimilateSubParameters (
11521  CErrorDetails * pError);
11522 
11523  void
11524  encode (
11525  CEncoderStream * pEncoderStream) const;
11526 
11527 
11528  llrp_bool_t
11529  isAllowedIn (
11530  const CTypeDescriptor * pEnclosingElementType) const;
11531 
11532 
11533  static CElement *
11534  s_construct (void);
11535 
11536  static void
11537  s_decodeFields (
11538  CDecoderStream * pDecoderStream,
11539  CElement * pElement);
11541 
11542 
11543  protected:
11544  llrp_u16v_t m_EnabledSectorIDs;
11545 
11548  public:
11549  static const CFieldDescriptor
11550  s_fdEnabledSectorIDs;
11552 
11554  inline llrp_u16v_t
11556  {
11557  return m_EnabledSectorIDs;
11558  }
11559 
11561  inline void
11563  llrp_u16v_t value)
11564  {
11565  m_EnabledSectorIDs = value;
11566  }
11567 
11568 
11569  protected:
11570  std::list<CParameter *> m_listCustom;
11571 
11572  public:
11574  inline std::list<CParameter *>::iterator
11576  {
11577  return m_listCustom.begin();
11578  }
11579 
11581  inline std::list<CParameter *>::iterator
11582  endCustom (void)
11583  {
11584  return m_listCustom.end();
11585  }
11586 
11588  inline void
11590  {
11591  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11592  }
11593 
11595  inline int
11597  {
11598  return (int) (m_listCustom.size());
11599  }
11600 
11601  EResultCode
11603  addCustom (
11604  CParameter * pValue);
11605 
11606 
11607 };
11608 
11609 
11648 class CImpinjDirectionConfig : public CParameter
11649 {
11650  public:
11651  CImpinjDirectionConfig (void);
11652  ~CImpinjDirectionConfig (void);
11653 
11656 
11657  static const CFieldDescriptor * const
11658  s_apFieldDescriptorTable[];
11659 
11660  static const CTypeDescriptor
11661  s_typeDescriptor;
11662 
11663  void
11664  decodeFields (
11665  CDecoderStream * pDecoderStream);
11666 
11667  void
11668  assimilateSubParameters (
11669  CErrorDetails * pError);
11670 
11671  void
11672  encode (
11673  CEncoderStream * pEncoderStream) const;
11674 
11675 
11676  llrp_bool_t
11677  isAllowedIn (
11678  const CTypeDescriptor * pEnclosingElementType) const;
11679 
11680 
11681  static CElement *
11682  s_construct (void);
11683 
11684  static void
11685  s_decodeFields (
11686  CDecoderStream * pDecoderStream,
11687  CElement * pElement);
11689 
11690 
11691  protected:
11692  llrp_u16_t m_TagAgeIntervalSeconds;
11693 
11696  public:
11697  static const CFieldDescriptor
11698  s_fdTagAgeIntervalSeconds;
11700 
11702  inline llrp_u16_t
11704  {
11705  return m_TagAgeIntervalSeconds;
11706  }
11707 
11709  inline void
11711  llrp_u16_t value)
11712  {
11713  m_TagAgeIntervalSeconds = value;
11714  }
11715 
11716 
11717  protected:
11718  llrp_u16_t m_UpdateIntervalSeconds;
11719 
11722  public:
11723  static const CFieldDescriptor
11724  s_fdUpdateIntervalSeconds;
11726 
11728  inline llrp_u16_t
11730  {
11731  return m_UpdateIntervalSeconds;
11732  }
11733 
11735  inline void
11737  llrp_u16_t value)
11738  {
11739  m_UpdateIntervalSeconds = value;
11740  }
11741 
11742 
11743  protected:
11744  EImpinjDirectionFieldOfView m_eFieldOfView;
11745 
11748  public:
11749  static const CFieldDescriptor
11750  s_fdFieldOfView;
11752 
11754  inline EImpinjDirectionFieldOfView
11756  {
11757  return m_eFieldOfView;
11758  }
11759 
11761  inline void
11763  EImpinjDirectionFieldOfView value)
11764  {
11765  m_eFieldOfView = value;
11766  }
11767 
11768 
11769  protected:
11770  CImpinjDirectionUserTagPopulationLimit * m_pImpinjDirectionUserTagPopulationLimit;
11771 
11772  public:
11776  {
11777  return m_pImpinjDirectionUserTagPopulationLimit;
11778  }
11779 
11781  EResultCode
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 
11850 {
11851  public:
11854 
11857 
11858  static const CFieldDescriptor * const
11859  s_apFieldDescriptorTable[];
11860 
11861  static const CTypeDescriptor
11862  s_typeDescriptor;
11863 
11864  void
11865  decodeFields (
11866  CDecoderStream * pDecoderStream);
11867 
11868  void
11869  assimilateSubParameters (
11870  CErrorDetails * pError);
11871 
11872  void
11873  encode (
11874  CEncoderStream * pEncoderStream) const;
11875 
11876 
11877  llrp_bool_t
11878  isAllowedIn (
11879  const CTypeDescriptor * pEnclosingElementType) const;
11880 
11881 
11882  static CElement *
11883  s_construct (void);
11884 
11885  static void
11886  s_decodeFields (
11887  CDecoderStream * pDecoderStream,
11888  CElement * pElement);
11890 
11891 
11892  protected:
11893  llrp_u16_t m_UserTagPopulationLimit;
11894 
11897  public:
11898  static const CFieldDescriptor
11899  s_fdUserTagPopulationLimit;
11901 
11903  inline llrp_u16_t
11905  {
11906  return m_UserTagPopulationLimit;
11907  }
11908 
11910  inline void
11912  llrp_u16_t value)
11913  {
11914  m_UserTagPopulationLimit = value;
11915  }
11916 
11917 
11918 };
11919 
11920 
11958 class CImpinjC1G2DirectionConfig : public CParameter
11959 {
11960  public:
11963 
11966 
11967  static const CFieldDescriptor * const
11968  s_apFieldDescriptorTable[];
11969 
11970  static const CTypeDescriptor
11971  s_typeDescriptor;
11972 
11973  void
11974  decodeFields (
11975  CDecoderStream * pDecoderStream);
11976 
11977  void
11978  assimilateSubParameters (
11979  CErrorDetails * pError);
11980 
11981  void
11982  encode (
11983  CEncoderStream * pEncoderStream) const;
11984 
11985 
11986  llrp_bool_t
11987  isAllowedIn (
11988  const CTypeDescriptor * pEnclosingElementType) const;
11989 
11990 
11991  static CElement *
11992  s_construct (void);
11993 
11994  static void
11995  s_decodeFields (
11996  CDecoderStream * pDecoderStream,
11997  CElement * pElement);
11999 
12000 
12001  protected:
12002  EImpinjDirectionRFMode m_eRFMode;
12003 
12006  public:
12007  static const CFieldDescriptor
12008  s_fdRFMode;
12010 
12012  inline EImpinjDirectionRFMode
12013  getRFMode (void)
12014  {
12015  return m_eRFMode;
12016  }
12017 
12019  inline void
12021  EImpinjDirectionRFMode value)
12022  {
12023  m_eRFMode = value;
12024  }
12025 
12026 
12027  protected:
12028  CImpinjTransmitPower * m_pImpinjTransmitPower;
12029 
12030  public:
12032  inline CImpinjTransmitPower *
12034  {
12035  return m_pImpinjTransmitPower;
12036  }
12037 
12039  EResultCode
12041  CImpinjTransmitPower * pValue);
12042 
12043 
12044  protected:
12045  std::list<CC1G2Filter *> m_listC1G2Filter;
12046 
12047  public:
12049  inline std::list<CC1G2Filter *>::iterator
12051  {
12052  return m_listC1G2Filter.begin();
12053  }
12054 
12056  inline std::list<CC1G2Filter *>::iterator
12058  {
12059  return m_listC1G2Filter.end();
12060  }
12061 
12063  inline void
12065  {
12066  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
12067  }
12068 
12070  inline int
12072  {
12073  return (int) (m_listC1G2Filter.size());
12074  }
12075 
12076  EResultCode
12078  addC1G2Filter (
12079  CC1G2Filter * pValue);
12080 
12081 
12082  protected:
12083  std::list<CParameter *> m_listCustom;
12084 
12085  public:
12087  inline std::list<CParameter *>::iterator
12089  {
12090  return m_listCustom.begin();
12091  }
12092 
12094  inline std::list<CParameter *>::iterator
12095  endCustom (void)
12096  {
12097  return m_listCustom.end();
12098  }
12099 
12101  inline void
12103  {
12104  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12105  }
12106 
12108  inline int
12110  {
12111  return (int) (m_listCustom.size());
12112  }
12113 
12114  EResultCode
12116  addCustom (
12117  CParameter * pValue);
12118 
12119 
12120 };
12121 
12122 
12155 class CImpinjExtendedTagInformation : public CParameter
12156 {
12157  public:
12160 
12163 
12164  static const CFieldDescriptor * const
12165  s_apFieldDescriptorTable[];
12166 
12167  static const CTypeDescriptor
12168  s_typeDescriptor;
12169 
12170  void
12171  decodeFields (
12172  CDecoderStream * pDecoderStream);
12173 
12174  void
12175  assimilateSubParameters (
12176  CErrorDetails * pError);
12177 
12178  void
12179  encode (
12180  CEncoderStream * pEncoderStream) const;
12181 
12182 
12183  llrp_bool_t
12184  isAllowedIn (
12185  const CTypeDescriptor * pEnclosingElementType) const;
12186 
12187 
12188  static CElement *
12189  s_construct (void);
12190 
12191  static void
12192  s_decodeFields (
12193  CDecoderStream * pDecoderStream,
12194  CElement * pElement);
12196 
12197 
12198  protected:
12199  std::list<CEPCData *> m_listEPCData;
12200 
12201  public:
12203  inline std::list<CEPCData *>::iterator
12205  {
12206  return m_listEPCData.begin();
12207  }
12208 
12210  inline std::list<CEPCData *>::iterator
12211  endEPCData (void)
12212  {
12213  return m_listEPCData.end();
12214  }
12215 
12217  inline void
12219  {
12220  clearSubParameterList ((tListOfParameters *) &m_listEPCData);
12221  }
12222 
12224  inline int
12226  {
12227  return (int) (m_listEPCData.size());
12228  }
12229 
12230  EResultCode
12232  addEPCData (
12233  CEPCData * pValue);
12234 
12235 
12236  protected:
12237  CImpinjLocationReportData * m_pImpinjLocationReportData;
12238 
12239  public:
12241  inline CImpinjLocationReportData *
12243  {
12244  return m_pImpinjLocationReportData;
12245  }
12246 
12248  EResultCode
12250  CImpinjLocationReportData * pValue);
12251 
12252 
12253  protected:
12254  CImpinjDirectionReportData * m_pImpinjDirectionReportData;
12255 
12256  public:
12260  {
12261  return m_pImpinjDirectionReportData;
12262  }
12263 
12265  EResultCode
12267  CImpinjDirectionReportData * pValue);
12268 
12269 
12270  protected:
12271  std::list<CParameter *> m_listCustom;
12272 
12273  public:
12275  inline std::list<CParameter *>::iterator
12277  {
12278  return m_listCustom.begin();
12279  }
12280 
12282  inline std::list<CParameter *>::iterator
12283  endCustom (void)
12284  {
12285  return m_listCustom.end();
12286  }
12287 
12289  inline void
12291  {
12292  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12293  }
12294 
12296  inline int
12298  {
12299  return (int) (m_listCustom.size());
12300  }
12301 
12302  EResultCode
12304  addCustom (
12305  CParameter * pValue);
12306 
12307 
12308 };
12309 
12310 
12357 class CImpinjDirectionReporting : public CParameter
12358 {
12359  public:
12361  ~CImpinjDirectionReporting (void);
12362 
12365 
12366  static const CFieldDescriptor * const
12367  s_apFieldDescriptorTable[];
12368 
12369  static const CTypeDescriptor
12370  s_typeDescriptor;
12371 
12372  void
12373  decodeFields (
12374  CDecoderStream * pDecoderStream);
12375 
12376  void
12377  assimilateSubParameters (
12378  CErrorDetails * pError);
12379 
12380  void
12381  encode (
12382  CEncoderStream * pEncoderStream) const;
12383 
12384 
12385  llrp_bool_t
12386  isAllowedIn (
12387  const CTypeDescriptor * pEnclosingElementType) const;
12388 
12389 
12390  static CElement *
12391  s_construct (void);
12392 
12393  static void
12394  s_decodeFields (
12395  CDecoderStream * pDecoderStream,
12396  CElement * pElement);
12398 
12399 
12400  protected:
12401  llrp_u1_t m_EnableUpdateReport;
12402 
12405  public:
12406  static const CFieldDescriptor
12407  s_fdEnableUpdateReport;
12409 
12411  inline llrp_u1_t
12413  {
12414  return m_EnableUpdateReport;
12415  }
12416 
12418  inline void
12420  llrp_u1_t value)
12421  {
12422  m_EnableUpdateReport = value;
12423  }
12424 
12425 
12426  protected:
12427  llrp_u1_t m_EnableEntryReport;
12428 
12431  public:
12432  static const CFieldDescriptor
12433  s_fdEnableEntryReport;
12435 
12437  inline llrp_u1_t
12439  {
12440  return m_EnableEntryReport;
12441  }
12442 
12444  inline void
12446  llrp_u1_t value)
12447  {
12448  m_EnableEntryReport = value;
12449  }
12450 
12451 
12452  protected:
12453  llrp_u1_t m_EnableExitReport;
12454 
12457  public:
12458  static const CFieldDescriptor
12459  s_fdEnableExitReport;
12461 
12463  inline llrp_u1_t
12465  {
12466  return m_EnableExitReport;
12467  }
12468 
12470  inline void
12472  llrp_u1_t value)
12473  {
12474  m_EnableExitReport = value;
12475  }
12476 
12477 
12478  protected:
12479  llrp_u1_t m_EnableDiagnosticReport;
12480 
12483  public:
12484  static const CFieldDescriptor
12485  s_fdEnableDiagnosticReport;
12487 
12489  inline llrp_u1_t
12491  {
12492  return m_EnableDiagnosticReport;
12493  }
12494 
12496  inline void
12498  llrp_u1_t value)
12499  {
12500  m_EnableDiagnosticReport = value;
12501  }
12502 
12503 
12504  protected:
12505  EImpinjDirectionDiagnosticReportLevel m_eDiagnosticReportLevel;
12506 
12509  public:
12510  static const CFieldDescriptor
12511  s_fdDiagnosticReportLevel;
12513 
12515  inline EImpinjDirectionDiagnosticReportLevel
12517  {
12518  return m_eDiagnosticReportLevel;
12519  }
12520 
12522  inline void
12524  EImpinjDirectionDiagnosticReportLevel value)
12525  {
12526  m_eDiagnosticReportLevel = value;
12527  }
12528 
12529 
12530  protected:
12531  std::list<CParameter *> m_listCustom;
12532 
12533  public:
12535  inline std::list<CParameter *>::iterator
12537  {
12538  return m_listCustom.begin();
12539  }
12540 
12542  inline std::list<CParameter *>::iterator
12543  endCustom (void)
12544  {
12545  return m_listCustom.end();
12546  }
12547 
12549  inline void
12551  {
12552  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12553  }
12554 
12556  inline int
12558  {
12559  return (int) (m_listCustom.size());
12560  }
12561 
12562  EResultCode
12564  addCustom (
12565  CParameter * pValue);
12566 
12567 
12568 };
12569 
12570 
12618 class CImpinjDirectionReportData : public CParameter
12619 {
12620  public:
12623 
12626 
12627  static const CFieldDescriptor * const
12628  s_apFieldDescriptorTable[];
12629 
12630  static const CTypeDescriptor
12631  s_typeDescriptor;
12632 
12633  void
12634  decodeFields (
12635  CDecoderStream * pDecoderStream);
12636 
12637  void
12638  assimilateSubParameters (
12639  CErrorDetails * pError);
12640 
12641  void
12642  encode (
12643  CEncoderStream * pEncoderStream) const;
12644 
12645 
12646  llrp_bool_t
12647  isAllowedIn (
12648  const CTypeDescriptor * pEnclosingElementType) const;
12649 
12650 
12651  static CElement *
12652  s_construct (void);
12653 
12654  static void
12655  s_decodeFields (
12656  CDecoderStream * pDecoderStream,
12657  CElement * pElement);
12659 
12660 
12661  protected:
12662  EImpinjDirectionReportType m_eType;
12663 
12666  public:
12667  static const CFieldDescriptor
12668  s_fdType;
12670 
12672  inline EImpinjDirectionReportType
12673  getType (void)
12674  {
12675  return m_eType;
12676  }
12677 
12679  inline void
12681  EImpinjDirectionReportType value)
12682  {
12683  m_eType = value;
12684  }
12685 
12686 
12687  protected:
12688  EImpinjDirectionTagPopulationStatus m_eTagPopulationStatus;
12689 
12692  public:
12693  static const CFieldDescriptor
12694  s_fdTagPopulationStatus;
12696 
12698  inline EImpinjDirectionTagPopulationStatus
12700  {
12701  return m_eTagPopulationStatus;
12702  }
12703 
12705  inline void
12707  EImpinjDirectionTagPopulationStatus value)
12708  {
12709  m_eTagPopulationStatus = value;
12710  }
12711 
12712 
12713  protected:
12714  llrp_u8_t m_FirstSeenSectorID;
12715 
12718  public:
12719  static const CFieldDescriptor
12720  s_fdFirstSeenSectorID;
12722 
12724  inline llrp_u8_t
12726  {
12727  return m_FirstSeenSectorID;
12728  }
12729 
12731  inline void
12733  llrp_u8_t value)
12734  {
12735  m_FirstSeenSectorID = value;
12736  }
12737 
12738 
12739  protected:
12740  llrp_u64_t m_FirstSeenTimestampUTC;
12741 
12744  public:
12745  static const CFieldDescriptor
12746  s_fdFirstSeenTimestampUTC;
12748 
12750  inline llrp_u64_t
12752  {
12753  return m_FirstSeenTimestampUTC;
12754  }
12755 
12757  inline void
12759  llrp_u64_t value)
12760  {
12761  m_FirstSeenTimestampUTC = value;
12762  }
12763 
12764 
12765  protected:
12766  llrp_u8_t m_LastSeenSectorID;
12767 
12770  public:
12771  static const CFieldDescriptor
12772  s_fdLastSeenSectorID;
12774 
12776  inline llrp_u8_t
12778  {
12779  return m_LastSeenSectorID;
12780  }
12781 
12783  inline void
12785  llrp_u8_t value)
12786  {
12787  m_LastSeenSectorID = value;
12788  }
12789 
12790 
12791  protected:
12792  llrp_u64_t m_LastSeenTimestampUTC;
12793 
12796  public:
12797  static const CFieldDescriptor
12798  s_fdLastSeenTimestampUTC;
12800 
12802  inline llrp_u64_t
12804  {
12805  return m_LastSeenTimestampUTC;
12806  }
12807 
12809  inline void
12811  llrp_u64_t value)
12812  {
12813  m_LastSeenTimestampUTC = value;
12814  }
12815 
12816 
12817  protected:
12818  CImpinjDirectionDiagnosticData * m_pImpinjDirectionDiagnosticData;
12819 
12820  public:
12824  {
12825  return m_pImpinjDirectionDiagnosticData;
12826  }
12827 
12829  EResultCode
12832 
12833 
12834  protected:
12835  std::list<CParameter *> m_listCustom;
12836 
12837  public:
12839  inline std::list<CParameter *>::iterator
12841  {
12842  return m_listCustom.begin();
12843  }
12844 
12846  inline std::list<CParameter *>::iterator
12847  endCustom (void)
12848  {
12849  return m_listCustom.end();
12850  }
12851 
12853  inline void
12855  {
12856  clearSubParameterList ((tListOfParameters *) &m_listCustom);
12857  }
12858 
12860  inline int
12862  {
12863  return (int) (m_listCustom.size());
12864  }
12865 
12866  EResultCode
12868  addCustom (
12869  CParameter * pValue);
12870 
12871 
12872 };
12873 
12874 
12897 class CImpinjDirectionDiagnosticData : public CParameter
12898 {
12899  public:
12902 
12905 
12906  static const CFieldDescriptor * const
12907  s_apFieldDescriptorTable[];
12908 
12909  static const CTypeDescriptor
12910  s_typeDescriptor;
12911 
12912  void
12913  decodeFields (
12914  CDecoderStream * pDecoderStream);
12915 
12916  void
12917  assimilateSubParameters (
12918  CErrorDetails * pError);
12919 
12920  void
12921  encode (
12922  CEncoderStream * pEncoderStream) const;
12923 
12924 
12925  llrp_bool_t
12926  isAllowedIn (
12927  const CTypeDescriptor * pEnclosingElementType) const;
12928 
12929 
12930  static CElement *
12931  s_construct (void);
12932 
12933  static void
12934  s_decodeFields (
12935  CDecoderStream * pDecoderStream,
12936  CElement * pElement);
12938 
12939 
12940  protected:
12941  llrp_u32v_t m_Metric;
12942 
12945  public:
12946  static const CFieldDescriptor
12947  s_fdMetric;
12949 
12951  inline llrp_u32v_t
12952  getMetric (void)
12953  {
12954  return m_Metric;
12955  }
12956 
12958  inline void
12960  llrp_u32v_t value)
12961  {
12962  m_Metric = value;
12963  }
12964 
12965 
12966 };
12967 
12968 
12993 class CImpinjxArrayDirectionCapabilities : public CParameter
12994 {
12995  public:
12998 
13001 
13002  static const CFieldDescriptor * const
13003  s_apFieldDescriptorTable[];
13004 
13005  static const CTypeDescriptor
13006  s_typeDescriptor;
13007 
13008  void
13009  decodeFields (
13010  CDecoderStream * pDecoderStream);
13011 
13012  void
13013  assimilateSubParameters (
13014  CErrorDetails * pError);
13015 
13016  void
13017  encode (
13018  CEncoderStream * pEncoderStream) const;
13019 
13020 
13021  llrp_bool_t
13022  isAllowedIn (
13023  const CTypeDescriptor * pEnclosingElementType) const;
13024 
13025 
13026  static CElement *
13027  s_construct (void);
13028 
13029  static void
13030  s_decodeFields (
13031  CDecoderStream * pDecoderStream,
13032  CElement * pElement);
13034 
13035 
13036  protected:
13037  llrp_u16_t m_SystemTagPopulationLimitHighSensitivity;
13038 
13041  public:
13042  static const CFieldDescriptor
13043  s_fdSystemTagPopulationLimitHighSensitivity;
13045 
13047  inline llrp_u16_t
13049  {
13050  return m_SystemTagPopulationLimitHighSensitivity;
13051  }
13052 
13054  inline void
13056  llrp_u16_t value)
13057  {
13058  m_SystemTagPopulationLimitHighSensitivity = value;
13059  }
13060 
13061 
13062  protected:
13063  llrp_u16_t m_SystemTagPopulationLimitHighPerformance;
13064 
13067  public:
13068  static const CFieldDescriptor
13069  s_fdSystemTagPopulationLimitHighPerformance;
13071 
13073  inline llrp_u16_t
13075  {
13076  return m_SystemTagPopulationLimitHighPerformance;
13077  }
13078 
13080  inline void
13082  llrp_u16_t value)
13083  {
13084  m_SystemTagPopulationLimitHighPerformance = value;
13085  }
13086 
13087 
13088  protected:
13089  std::list<CParameter *> m_listCustom;
13090 
13091  public:
13093  inline std::list<CParameter *>::iterator
13095  {
13096  return m_listCustom.begin();
13097  }
13098 
13100  inline std::list<CParameter *>::iterator
13101  endCustom (void)
13102  {
13103  return m_listCustom.end();
13104  }
13105 
13107  inline void
13109  {
13110  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13111  }
13112 
13114  inline int
13116  {
13117  return (int) (m_listCustom.size());
13118  }
13119 
13120  EResultCode
13122  addCustom (
13123  CParameter * pValue);
13124 
13125 
13126 };
13127 
13128 
13154 class CImpinjIntelligentAntennaManagement : public CParameter
13155 {
13156  public:
13159 
13162 
13163  static const CFieldDescriptor * const
13164  s_apFieldDescriptorTable[];
13165 
13166  static const CTypeDescriptor
13167  s_typeDescriptor;
13168 
13169  void
13170  decodeFields (
13171  CDecoderStream * pDecoderStream);
13172 
13173  void
13174  assimilateSubParameters (
13175  CErrorDetails * pError);
13176 
13177  void
13178  encode (
13179  CEncoderStream * pEncoderStream) const;
13180 
13181 
13182  llrp_bool_t
13183  isAllowedIn (
13184  const CTypeDescriptor * pEnclosingElementType) const;
13185 
13186 
13187  static CElement *
13188  s_construct (void);
13189 
13190  static void
13191  s_decodeFields (
13192  CDecoderStream * pDecoderStream,
13193  CElement * pElement);
13195 
13196 
13197  protected:
13198  EImpinjIntelligentAntennaMode m_eManagementEnabled;
13199 
13202  public:
13203  static const CFieldDescriptor
13204  s_fdManagementEnabled;
13206 
13208  inline EImpinjIntelligentAntennaMode
13210  {
13211  return m_eManagementEnabled;
13212  }
13213 
13215  inline void
13217  EImpinjIntelligentAntennaMode value)
13218  {
13219  m_eManagementEnabled = value;
13220  }
13221 
13222 
13223  protected:
13224  std::list<CParameter *> m_listCustom;
13225 
13226  public:
13228  inline std::list<CParameter *>::iterator
13230  {
13231  return m_listCustom.begin();
13232  }
13233 
13235  inline std::list<CParameter *>::iterator
13236  endCustom (void)
13237  {
13238  return m_listCustom.end();
13239  }
13240 
13242  inline void
13244  {
13245  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13246  }
13247 
13249  inline int
13251  {
13252  return (int) (m_listCustom.size());
13253  }
13254 
13255  EResultCode
13257  addCustom (
13258  CParameter * pValue);
13259 
13260 
13261 };
13262 
13263 
13290 class CImpinjTransmitPower : public CParameter
13291 {
13292  public:
13293  CImpinjTransmitPower (void);
13294  ~CImpinjTransmitPower (void);
13295 
13298 
13299  static const CFieldDescriptor * const
13300  s_apFieldDescriptorTable[];
13301 
13302  static const CTypeDescriptor
13303  s_typeDescriptor;
13304 
13305  void
13306  decodeFields (
13307  CDecoderStream * pDecoderStream);
13308 
13309  void
13310  assimilateSubParameters (
13311  CErrorDetails * pError);
13312 
13313  void
13314  encode (
13315  CEncoderStream * pEncoderStream) const;
13316 
13317 
13318  llrp_bool_t
13319  isAllowedIn (
13320  const CTypeDescriptor * pEnclosingElementType) const;
13321 
13322 
13323  static CElement *
13324  s_construct (void);
13325 
13326  static void
13327  s_decodeFields (
13328  CDecoderStream * pDecoderStream,
13329  CElement * pElement);
13331 
13332 
13333  protected:
13334  llrp_u16_t m_TransmitPower;
13335 
13338  public:
13339  static const CFieldDescriptor
13340  s_fdTransmitPower;
13342 
13344  inline llrp_u16_t
13346  {
13347  return m_TransmitPower;
13348  }
13349 
13351  inline void
13353  llrp_u16_t value)
13354  {
13355  m_TransmitPower = value;
13356  }
13357 
13358 
13359  protected:
13360  std::list<CParameter *> m_listCustom;
13361 
13362  public:
13364  inline std::list<CParameter *>::iterator
13366  {
13367  return m_listCustom.begin();
13368  }
13369 
13371  inline std::list<CParameter *>::iterator
13372  endCustom (void)
13373  {
13374  return m_listCustom.end();
13375  }
13376 
13378  inline void
13380  {
13381  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13382  }
13383 
13385  inline int
13387  {
13388  return (int) (m_listCustom.size());
13389  }
13390 
13391  EResultCode
13393  addCustom (
13394  CParameter * pValue);
13395 
13396 
13397 };
13398 
13399 
13426 class CImpinjPolarizationControl : public CParameter
13427 {
13428  public:
13431 
13434 
13435  static const CFieldDescriptor * const
13436  s_apFieldDescriptorTable[];
13437 
13438  static const CTypeDescriptor
13439  s_typeDescriptor;
13440 
13441  void
13442  decodeFields (
13443  CDecoderStream * pDecoderStream);
13444 
13445  void
13446  assimilateSubParameters (
13447  CErrorDetails * pError);
13448 
13449  void
13450  encode (
13451  CEncoderStream * pEncoderStream) const;
13452 
13453 
13454  llrp_bool_t
13455  isAllowedIn (
13456  const CTypeDescriptor * pEnclosingElementType) const;
13457 
13458 
13459  static CElement *
13460  s_construct (void);
13461 
13462  static void
13463  s_decodeFields (
13464  CDecoderStream * pDecoderStream,
13465  CElement * pElement);
13467 
13468 
13469  protected:
13470  llrp_u1_t m_PolarizationControlEnabled;
13471 
13474  public:
13475  static const CFieldDescriptor
13476  s_fdPolarizationControlEnabled;
13478 
13480  inline llrp_u1_t
13482  {
13483  return m_PolarizationControlEnabled;
13484  }
13485 
13487  inline void
13489  llrp_u1_t value)
13490  {
13491  m_PolarizationControlEnabled = value;
13492  }
13493 
13494 
13495  protected:
13496  std::list<CParameter *> m_listCustom;
13497 
13498  public:
13500  inline std::list<CParameter *>::iterator
13502  {
13503  return m_listCustom.begin();
13504  }
13505 
13507  inline std::list<CParameter *>::iterator
13508  endCustom (void)
13509  {
13510  return m_listCustom.end();
13511  }
13512 
13514  inline void
13516  {
13517  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13518  }
13519 
13521  inline int
13523  {
13524  return (int) (m_listCustom.size());
13525  }
13526 
13527  EResultCode
13529  addCustom (
13530  CParameter * pValue);
13531 
13532 
13533 };
13534 
13535 
13560 class CImpinjAntennaCapabilities : public CParameter
13561 {
13562  public:
13565 
13568 
13569  static const CFieldDescriptor * const
13570  s_apFieldDescriptorTable[];
13571 
13572  static const CTypeDescriptor
13573  s_typeDescriptor;
13574 
13575  void
13576  decodeFields (
13577  CDecoderStream * pDecoderStream);
13578 
13579  void
13580  assimilateSubParameters (
13581  CErrorDetails * pError);
13582 
13583  void
13584  encode (
13585  CEncoderStream * pEncoderStream) const;
13586 
13587 
13588  llrp_bool_t
13589  isAllowedIn (
13590  const CTypeDescriptor * pEnclosingElementType) const;
13591 
13592 
13593  static CElement *
13594  s_construct (void);
13595 
13596  static void
13597  s_decodeFields (
13598  CDecoderStream * pDecoderStream,
13599  CElement * pElement);
13601 
13602 
13603  protected:
13604  std::list<CImpinjAntennaPolarizationCapability *> m_listImpinjAntennaPolarizationCapability;
13605 
13606  public:
13608  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
13610  {
13611  return m_listImpinjAntennaPolarizationCapability.begin();
13612  }
13613 
13615  inline std::list<CImpinjAntennaPolarizationCapability *>::iterator
13617  {
13618  return m_listImpinjAntennaPolarizationCapability.end();
13619  }
13620 
13622  inline void
13624  {
13625  clearSubParameterList ((tListOfParameters *) &m_listImpinjAntennaPolarizationCapability);
13626  }
13627 
13629  inline int
13631  {
13632  return (int) (m_listImpinjAntennaPolarizationCapability.size());
13633  }
13634 
13635  EResultCode
13639 
13640 
13641  protected:
13642  std::list<CParameter *> m_listCustom;
13643 
13644  public:
13646  inline std::list<CParameter *>::iterator
13648  {
13649  return m_listCustom.begin();
13650  }
13651 
13653  inline std::list<CParameter *>::iterator
13654  endCustom (void)
13655  {
13656  return m_listCustom.end();
13657  }
13658 
13660  inline void
13662  {
13663  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13664  }
13665 
13667  inline int
13669  {
13670  return (int) (m_listCustom.size());
13671  }
13672 
13673  EResultCode
13675  addCustom (
13676  CParameter * pValue);
13677 
13678 
13679 };
13680 
13681 
13706 class CImpinjAntennaPolarizationCapability : public CParameter
13707 {
13708  public:
13711 
13714 
13715  static const CFieldDescriptor * const
13716  s_apFieldDescriptorTable[];
13717 
13718  static const CTypeDescriptor
13719  s_typeDescriptor;
13720 
13721  void
13722  decodeFields (
13723  CDecoderStream * pDecoderStream);
13724 
13725  void
13726  assimilateSubParameters (
13727  CErrorDetails * pError);
13728 
13729  void
13730  encode (
13731  CEncoderStream * pEncoderStream) const;
13732 
13733 
13734  llrp_bool_t
13735  isAllowedIn (
13736  const CTypeDescriptor * pEnclosingElementType) const;
13737 
13738 
13739  static CElement *
13740  s_construct (void);
13741 
13742  static void
13743  s_decodeFields (
13744  CDecoderStream * pDecoderStream,
13745  CElement * pElement);
13747 
13748 
13749  protected:
13750  EImpinjAntennaPolarizationType m_eType;
13751 
13754  public:
13755  static const CFieldDescriptor
13756  s_fdType;
13758 
13760  inline EImpinjAntennaPolarizationType
13761  getType (void)
13762  {
13763  return m_eType;
13764  }
13765 
13767  inline void
13769  EImpinjAntennaPolarizationType value)
13770  {
13771  m_eType = value;
13772  }
13773 
13774 
13775  protected:
13776  llrp_u16_t m_AntennaIDOffset;
13777 
13780  public:
13781  static const CFieldDescriptor
13782  s_fdAntennaIDOffset;
13784 
13786  inline llrp_u16_t
13788  {
13789  return m_AntennaIDOffset;
13790  }
13791 
13793  inline void
13795  llrp_u16_t value)
13796  {
13797  m_AntennaIDOffset = value;
13798  }
13799 
13800 
13801  protected:
13802  std::list<CParameter *> m_listCustom;
13803 
13804  public:
13806  inline std::list<CParameter *>::iterator
13808  {
13809  return m_listCustom.begin();
13810  }
13811 
13813  inline std::list<CParameter *>::iterator
13814  endCustom (void)
13815  {
13816  return m_listCustom.end();
13817  }
13818 
13820  inline void
13822  {
13823  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13824  }
13825 
13827  inline int
13829  {
13830  return (int) (m_listCustom.size());
13831  }
13832 
13833  EResultCode
13835  addCustom (
13836  CParameter * pValue);
13837 
13838 
13839 };
13840 
13841 
13865 class CImpinjDisabledAntennas : public CParameter
13866 {
13867  public:
13868  CImpinjDisabledAntennas (void);
13869  ~CImpinjDisabledAntennas (void);
13870 
13873 
13874  static const CFieldDescriptor * const
13875  s_apFieldDescriptorTable[];
13876 
13877  static const CTypeDescriptor
13878  s_typeDescriptor;
13879 
13880  void
13881  decodeFields (
13882  CDecoderStream * pDecoderStream);
13883 
13884  void
13885  assimilateSubParameters (
13886  CErrorDetails * pError);
13887 
13888  void
13889  encode (
13890  CEncoderStream * pEncoderStream) const;
13891 
13892 
13893  llrp_bool_t
13894  isAllowedIn (
13895  const CTypeDescriptor * pEnclosingElementType) const;
13896 
13897 
13898  static CElement *
13899  s_construct (void);
13900 
13901  static void
13902  s_decodeFields (
13903  CDecoderStream * pDecoderStream,
13904  CElement * pElement);
13906 
13907 
13908  protected:
13909  llrp_u16v_t m_AntennaIDs;
13910 
13913  public:
13914  static const CFieldDescriptor
13915  s_fdAntennaIDs;
13917 
13919  inline llrp_u16v_t
13921  {
13922  return m_AntennaIDs;
13923  }
13924 
13926  inline void
13928  llrp_u16v_t value)
13929  {
13930  m_AntennaIDs = value;
13931  }
13932 
13933 
13934  protected:
13935  std::list<CParameter *> m_listCustom;
13936 
13937  public:
13939  inline std::list<CParameter *>::iterator
13941  {
13942  return m_listCustom.begin();
13943  }
13944 
13946  inline std::list<CParameter *>::iterator
13947  endCustom (void)
13948  {
13949  return m_listCustom.end();
13950  }
13951 
13953  inline void
13955  {
13956  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13957  }
13958 
13960  inline int
13962  {
13963  return (int) (m_listCustom.size());
13964  }
13965 
13966  EResultCode
13968  addCustom (
13969  CParameter * pValue);
13970 
13971 
13972 };
13973 
13974 
13999 class CImpinjTIDParity : public CParameter
14000 {
14001  public:
14002  CImpinjTIDParity (void);
14003  ~CImpinjTIDParity (void);
14004 
14007 
14008  static const CFieldDescriptor * const
14009  s_apFieldDescriptorTable[];
14010 
14011  static const CTypeDescriptor
14012  s_typeDescriptor;
14013 
14014  void
14015  decodeFields (
14016  CDecoderStream * pDecoderStream);
14017 
14018  void
14019  assimilateSubParameters (
14020  CErrorDetails * pError);
14021 
14022  void
14023  encode (
14024  CEncoderStream * pEncoderStream) const;
14025 
14026 
14027  llrp_bool_t
14028  isAllowedIn (
14029  const CTypeDescriptor * pEnclosingElementType) const;
14030 
14031 
14032  static CElement *
14033  s_construct (void);
14034 
14035  static void
14036  s_decodeFields (
14037  CDecoderStream * pDecoderStream,
14038  CElement * pElement);
14040 
14041 
14042  protected:
14043  llrp_u1_t m_ParityError;
14044 
14047  public:
14048  static const CFieldDescriptor
14049  s_fdParityError;
14051 
14053  inline llrp_u1_t
14055  {
14056  return m_ParityError;
14057  }
14058 
14060  inline void
14062  llrp_u1_t value)
14063  {
14064  m_ParityError = value;
14065  }
14066 
14067 
14068  protected:
14069  std::list<CParameter *> m_listCustom;
14070 
14071  public:
14073  inline std::list<CParameter *>::iterator
14075  {
14076  return m_listCustom.begin();
14077  }
14078 
14080  inline std::list<CParameter *>::iterator
14081  endCustom (void)
14082  {
14083  return m_listCustom.end();
14084  }
14085 
14087  inline void
14089  {
14090  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14091  }
14092 
14094  inline int
14096  {
14097  return (int) (m_listCustom.size());
14098  }
14099 
14100  EResultCode
14102  addCustom (
14103  CParameter * pValue);
14104 
14105 
14106 };
14107 
14108 
14123 extern void
14125  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.
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.
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.
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.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setType(EImpinjAntennaPolarizationType value)
Set accessor functions for the LLRP Type field.
Class Definition CImpinjLoopSpec for LLRP parameter ImpinjLoopSpec.
Class Definition CImpinjSubRegulatoryRegion for LLRP parameter ImpinjSubRegulatoryRegion.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjTransmitPower for LLRP parameter ImpinjTransmitPower.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_s32_t getYAxis(void)
Get accessor functions for the LLRP YAxis field.
llrp_u64_t getLastSeenTimestampUTC(void)
Get accessor functions for the LLRP LastSeenTimestampUTC field.
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 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.
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.
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.
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.
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 getUserTagPopulationLimit(void)
Get accessor functions for the LLRP UserTagPopulationLimit field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
llrp_utf8v_t getModelName(void)
Get accessor functions for the LLRP ModelName field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setMaxNumSectors(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumSectors field.
void setXAxis(llrp_s32_t value)
Set accessor functions for the LLRP XAxis field.
EResultCode setImpinjBlockWriteWordCount(CImpinjBlockWriteWordCount *pValue)
Set accessor functions for the LLRP ImpinjBlockWriteWordCount sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u8_t getFirstSeenSectorID(void)
Get accessor functions for the LLRP FirstSeenSectorID field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjLISpec for LLRP parameter ImpinjLISpec.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode setImpinjDirectionSectors(CImpinjDirectionSectors *pValue)
Set accessor functions for the LLRP ImpinjDirectionSectors sub-parameter.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
llrp_s32_t getLatitude(void)
Get accessor functions for the LLRP Latitude field.
EResultCode setImpinjTransmitPower(CImpinjTransmitPower *pValue)
Set accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setSerializedTIDMode(EImpinjSerializedTIDMode value)
Set accessor functions for the LLRP SerializedTIDMode field.
EResultCode setImpinjTransmitPower(CImpinjTransmitPower *pValue)
Set accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
Class Definition CImpinjDirectionReportData for LLRP parameter ImpinjDirectionReportData.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setFieldPingInterval(llrp_u16_t value)
Set accessor functions for the LLRP FieldPingInterval field.
void clearCustom(void)
Clears the LLRP 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.
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.
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.
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.
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.
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.
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.
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.
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.
void setRFPhaseAngleMode(EImpinjRFPhaseAngleMode value)
Set accessor functions for the LLRP RFPhaseAngleMode field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setResult(EImpinjGetQTConfigResultType value)
Set accessor functions for the LLRP Result field.
Class Definition CImpinjEnablePeakRSSI for LLRP parameter ImpinjEnablePeakRSSI.
Class Definition CImpinjBeaconConfiguration for LLRP parameter ImpinjBeaconConfiguration.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EResultCode setImpinjEnablePeakRSSI(CImpinjEnablePeakRSSI *pValue)
Set accessor functions for the LLRP ImpinjEnablePeakRSSI sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjC1G2LocationConfig * getImpinjC1G2LocationConfig(void)
Get accessor functions for the LLRP ImpinjC1G2LocationConfig sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setMetric(llrp_u32v_t value)
Set accessor functions for the LLRP Metric field.
CImpinjBlockWriteWordCount * getImpinjBlockWriteWordCount(void)
Get accessor functions for the LLRP ImpinjBlockWriteWordCount sub-parameter.
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.
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.
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.
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.
void setInventorySearchMode(EImpinjInventorySearchType value)
Set accessor functions for the LLRP InventorySearchMode field.
void setSerialNumber(llrp_utf8v_t value)
Set accessor functions for the LLRP SerialNumber field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
EImpinjRequestedDataType getRequestedData(void)
Get accessor functions for the LLRP RequestedData field.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
Class Definition CImpinjLocationConfig for LLRP parameter ImpinjLocationConfig.
Class Definition CLLRPStatus for LLRP parameter LLRPStatus.
Definition: out_ltkcpp.h:18888
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.
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.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
llrp_u16_t getAntennaIDOffset(void)
Get accessor functions for the LLRP AntennaIDOffset field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setGPOMode(EImpinjAdvancedGPOMode value)
Set accessor functions for the LLRP GPOMode field.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setLocXCentimeters(llrp_s32_t value)
Set accessor functions for the LLRP LocXCentimeters field.
EResultCode setImpinjAntennaEventHysteresis(CImpinjAntennaEventHysteresis *pValue)
Set accessor functions for the LLRP ImpinjAntennaEventHysteresis sub-parameter.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
int countC1G2Read(void)
Count of the LLRP C1G2Read sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CC1G2Read * >::iterator beginC1G2Read(void)
Returns the first element of the C1G2Read sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
CImpinjDirectionConfig * getImpinjDirectionConfig(void)
Get accessor functions for the LLRP ImpinjDirectionConfig sub-parameter.
llrp_u16_t getLinkDownThreshold(void)
Get accessor functions for the LLRP LinkDownThreshold field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setSaveConfiguration(llrp_u1_t value)
Set accessor functions for the LLRP SaveConfiguration field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
CImpinjLocationConfig * getImpinjLocationConfig(void)
Get accessor functions for the LLRP ImpinjLocationConfig sub-parameter.
llrp_u64_t getAntennaEventDisconnected(void)
Get accessor functions for the LLRP AntennaEventDisconnected field.
void setPermalockStatus(llrp_u16v_t value)
Set accessor functions for the LLRP PermalockStatus field.
llrp_u16_t getFieldPingInterval(void)
Get accessor functions for the LLRP FieldPingInterval field.
Class Definition CImpinjEnableSerializedTID for LLRP parameter ImpinjEnableSerializedTID.
llrp_u16v_t getChannelList(void)
Get accessor functions for the LLRP ChannelList field.
void setEnableExitReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableExitReport field.
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
EResultCode setImpinjC1G2DirectionConfig(CImpinjC1G2DirectionConfig *pValue)
Set accessor functions for the LLRP ImpinjC1G2DirectionConfig sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
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.
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.
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.
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.
void setEnableExitReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableExitReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Class Definition CImpinjDirectionSectors for LLRP parameter ImpinjDirectionSectors.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void setGPSCoordinatesMode(EImpinjGPSCoordinatesMode value)
Set accessor functions for the LLRP GPSCoordinatesMode field.
EImpinjSetQTConfigResultType getResult(void)
Get accessor functions for the LLRP Result field.
CImpinjDirectionDiagnosticData * getImpinjDirectionDiagnosticData(void)
Get accessor functions for the LLRP ImpinjDirectionDiagnosticData sub-parameter.
void setBlockMask(llrp_u16v_t value)
Set accessor functions for the LLRP BlockMask field.
void setSoftwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP SoftwareVersion field.
llrp_u64_t getFirstSeenTimestampUTC(void)
Get accessor functions for the LLRP FirstSeenTimestampUTC field.
llrp_s32_t getLongitude(void)
Get accessor functions for the LLRP Longitude field.
llrp_u1_t getEnableAntDwellTimeLimit(void)
Get accessor functions for the LLRP EnableAntDwellTimeLimit field.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
CImpinjEnableGPSCoordinates * getImpinjEnableGPSCoordinates(void)
Get accessor functions for the LLRP ImpinjEnableGPSCoordinates sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
void setOrientationDegrees(llrp_s16_t value)
Set accessor functions for the LLRP OrientationDegrees field.
void setAccessRange(EImpinjQTAccessRange value)
Set accessor functions for the LLRP AccessRange field.
llrp_u16_t getTagAgeIntervalSeconds(void)
Get accessor functions for the LLRP TagAgeIntervalSeconds field.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
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.
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.
Class Definition CImpinjRFDopplerFrequency for LLRP parameter ImpinjRFDopplerFrequency.
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
void setDataProfile(EImpinjQTDataProfile value)
Set accessor functions for the LLRP DataProfile field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setUserTagPopulationLimit(llrp_u16_t value)
Set accessor functions for the LLRP UserTagPopulationLimit field.
llrp_utf8v_t getSoftwareVersion(void)
Get accessor functions for the LLRP SoftwareVersion field.
EImpinjLocationReportType getType(void)
Get accessor functions for the LLRP Type field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CParameter * >::iterator 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.
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.
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.
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 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.
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.
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.
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.
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.
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.
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
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.
void setPeakRSSIMode(EImpinjPeakRSSIMode value)
Set accessor functions for the LLRP PeakRSSIMode field.
void setChannelList(llrp_u16v_t value)
Set accessor functions for the LLRP ChannelList field.
void setFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP FirmwareVersion field.
CImpinjTransmitPower * getImpinjTransmitPower(void)
Get accessor functions for the LLRP ImpinjTransmitPower sub-parameter.
llrp_utf8v_t getFirmwareVersion(void)
Get accessor functions for the LLRP FirmwareVersion field.
Class Definition CImpinjC1G2LocationConfig for LLRP parameter ImpinjC1G2LocationConfig.
EResultCode setImpinjEnableRFPhaseAngle(CImpinjEnableRFPhaseAngle *pValue)
Set accessor functions for the LLRP ImpinjEnableRFPhaseAngle sub-parameter.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
EImpinjHubFaultType getFault(void)
Get accessor functions for the LLRP Fault field.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void setEmptyFieldTimeout(llrp_u16_t value)
Set accessor functions for the LLRP EmptyFieldTimeout field.
void setAntennaEventConnected(llrp_u64_t value)
Set accessor functions for the LLRP AntennaEventConnected field.
llrp_u1_t getEnableDiagnosticReport(void)
Get accessor functions for the LLRP EnableDiagnosticReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Class Definition CImpinjEnableOptimizedRead for LLRP parameter ImpinjEnableOptimizedRead.
Class Definition CImpinjRequestedData for LLRP parameter ImpinjRequestedData.
EImpinjPeakRSSIMode getPeakRSSIMode(void)
Get accessor functions for the LLRP PeakRSSIMode field.
void setEnableEntryReport(llrp_u1_t value)
Set accessor functions for the LLRP EnableEntryReport field.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.