LTKCPP-- LLRP Toolkit C Plus Plus Library
out_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 class CCUSTOM_MESSAGE;
19 class CADD_ROSPEC;
21 class CDELETE_ROSPEC;
23 class CSTART_ROSPEC;
25 class CSTOP_ROSPEC;
27 class CENABLE_ROSPEC;
29 class CDISABLE_ROSPEC;
31 class CGET_ROSPECS;
33 class CADD_ACCESSSPEC;
35 class CDELETE_ACCESSSPEC;
37 class CENABLE_ACCESSSPEC;
41 class CGET_ACCESSSPECS;
43 class CCLIENT_REQUEST_OP;
45 class CGET_READER_CONFIG;
47 class CSET_READER_CONFIG;
49 class CCLOSE_CONNECTION;
51 class CGET_REPORT;
52 class CRO_ACCESS_REPORT;
53 class CKEEPALIVE;
54 class CKEEPALIVE_ACK;
57 class CERROR_MESSAGE;
58 
59 /* Custom messages */
60 
61 
62 /*
63  * Parameter classes - forward decls
64  */
65 
66 class CUTCTimestamp;
67 class CUptime;
68 class CCustom;
73 class CGPIOCapabilities;
74 class CLLRPCapabilities;
79 class CFrequencyHopTable;
81 class CROSpec;
82 class CROBoundarySpec;
85 class CGPITriggerValue;
86 class CROSpecStopTrigger;
87 class CAISpec;
88 class CAISpecStopTrigger;
91 class CRFSurveySpec;
93 class CAccessSpec;
95 class CAccessCommand;
99 class CIdentification;
100 class CGPOWriteData;
101 class CKeepaliveSpec;
102 class CAntennaProperties;
104 class CRFReceiver;
105 class CRFTransmitter;
107 class CEventsAndReports;
108 class CROReportSpec;
110 class CAccessReportSpec;
111 class CTagReportData;
112 class CEPCData;
113 class CEPC_96;
114 class CROSpecID;
115 class CSpecIndex;
117 class CAntennaID;
118 class CPeakRSSI;
119 class CChannelIndex;
124 class CTagSeenCount;
126 class CAccessSpecID;
127 class CRFSurveyReportData;
132 class CHoppingEvent;
133 class CGPIEvent;
134 class CROSpecEvent;
138 class COpSpecID;
139 class CRFSurveyEvent;
140 class CAISpecEvent;
141 class CAntennaEvent;
144 class CLLRPStatus;
145 class CFieldError;
146 class CParameterError;
148 class CC1G2UHFRFModeTable;
151 class CC1G2Filter;
155 class CC1G2RFControl;
158 class CC1G2TagSpec;
159 class CC1G2TargetTag;
160 class CC1G2Read;
161 class CC1G2Write;
162 class CC1G2Kill;
163 class CC1G2Lock;
164 class CC1G2LockPayload;
165 class CC1G2BlockErase;
166 class CC1G2BlockWrite;
168 class CC1G2_PC;
169 class CC1G2_CRC;
177 
178 /* Custom parameters */
179 
180 
181 /*
182  * Vendor descriptor declarations.
183  */
184 
185 
186 /*
187  * Namespace descriptor declarations.
188  */
189 
190 extern const CNamespaceDescriptor
191 g_nsdescllrp;
192 
193 
194 /*
195  * Enumeration definitions and declarations of
196  * enumeration string tables.
197  */
198 
199 
227 enum EAirProtocols
228 {
230 };
231 
232 extern const SEnumTableEntry
233 g_estAirProtocols[];
234 
235 
259 enum EGetReaderCapabilitiesRequestedData
260 {
262 };
263 
264 extern const SEnumTableEntry
265 g_estGetReaderCapabilitiesRequestedData[];
266 
267 
303 enum ECommunicationsStandard
304 {
306 };
307 
308 extern const SEnumTableEntry
309 g_estCommunicationsStandard[];
310 
311 
333 enum EROSpecState
334 {
336 };
337 
338 extern const SEnumTableEntry
339 g_estROSpecState[];
340 
341 
395 enum EROSpecStartTriggerType
396 {
398 };
399 
400 extern const SEnumTableEntry
401 g_estROSpecStartTriggerType[];
402 
403 
451 enum EROSpecStopTriggerType
452 {
454 };
455 
456 extern const SEnumTableEntry
457 g_estROSpecStopTriggerType[];
458 
459 
513 enum EAISpecStopTriggerType
514 {
516 };
517 
518 extern const SEnumTableEntry
519 g_estAISpecStopTriggerType[];
520 
521 
569 enum ETagObservationTriggerType
570 {
572 };
573 
574 extern const SEnumTableEntry
575 g_estTagObservationTriggerType[];
576 
577 
599 enum ERFSurveySpecStopTriggerType
600 {
602 };
603 
604 extern const SEnumTableEntry
605 g_estRFSurveySpecStopTriggerType[];
606 
607 
628 enum EAccessSpecState
629 {
631 };
632 
633 extern const SEnumTableEntry
634 g_estAccessSpecState[];
635 
636 
678 enum EAccessSpecStopTriggerType
679 {
681 };
682 
683 extern const SEnumTableEntry
684 g_estAccessSpecStopTriggerType[];
685 
686 
717 enum EGetReaderConfigRequestedData
718 {
720 };
721 
722 extern const SEnumTableEntry
723 g_estGetReaderConfigRequestedData[];
724 
725 
746 enum EIdentificationType
747 {
749 };
750 
751 extern const SEnumTableEntry
752 g_estIdentificationType[];
753 
754 
798 enum EKeepaliveTriggerType
799 {
801 };
802 
803 extern const SEnumTableEntry
804 g_estKeepaliveTriggerType[];
805 
806 
828 enum EGPIPortState
829 {
831 };
832 
833 extern const SEnumTableEntry
834 g_estGPIPortState[];
835 
836 
858 enum EROReportTriggerType
859 {
861 };
862 
863 extern const SEnumTableEntry
864 g_estROReportTriggerType[];
865 
866 
887 enum EAccessReportTriggerType
888 {
890 };
891 
892 extern const SEnumTableEntry
893 g_estAccessReportTriggerType[];
894 
895 
923 enum ENotificationEventType
924 {
926 };
927 
928 extern const SEnumTableEntry
929 g_estNotificationEventType[];
930 
931 
953 enum EROSpecEventType
954 {
956 };
957 
958 extern const SEnumTableEntry
959 g_estROSpecEventType[];
960 
961 
982 enum ERFSurveyEventType
983 {
985 };
986 
987 extern const SEnumTableEntry
988 g_estRFSurveyEventType[];
989 
990 
1010 enum EAISpecEventType
1011 {
1013 };
1014 
1015 extern const SEnumTableEntry
1016 g_estAISpecEventType[];
1017 
1018 
1040 enum EAntennaEventType
1041 {
1043 };
1044 
1045 extern const SEnumTableEntry
1046 g_estAntennaEventType[];
1047 
1048 
1076 enum EConnectionAttemptStatusType
1077 {
1079 };
1080 
1081 extern const SEnumTableEntry
1082 g_estConnectionAttemptStatusType[];
1083 
1084 
1136 enum EStatusCode
1137 {
1139 };
1140 
1141 extern const SEnumTableEntry
1142 g_estStatusCode[];
1143 
1144 
1165 enum EC1G2DRValue
1166 {
1168 };
1169 
1170 extern const SEnumTableEntry
1171 g_estC1G2DRValue[];
1172 
1173 
1196 enum EC1G2MValue
1197 {
1199 };
1200 
1201 extern const SEnumTableEntry
1202 g_estC1G2MValue[];
1203 
1204 
1226 enum EC1G2ForwardLinkModulation
1227 {
1229 };
1230 
1231 extern const SEnumTableEntry
1232 g_estC1G2ForwardLinkModulation[];
1233 
1234 
1288 enum EC1G2SpectralMaskIndicator
1289 {
1291 };
1292 
1293 extern const SEnumTableEntry
1294 g_estC1G2SpectralMaskIndicator[];
1295 
1296 
1318 enum EC1G2TruncateAction
1319 {
1321 };
1322 
1323 extern const SEnumTableEntry
1324 g_estC1G2TruncateAction[];
1325 
1326 
1350 enum EC1G2StateAwareTarget
1351 {
1353 };
1354 
1355 extern const SEnumTableEntry
1356 g_estC1G2StateAwareTarget[];
1357 
1358 
1385 enum EC1G2StateAwareAction
1386 {
1388 };
1389 
1390 extern const SEnumTableEntry
1391 g_estC1G2StateAwareAction[];
1392 
1393 
1418 enum EC1G2StateUnawareAction
1419 {
1421 };
1422 
1423 extern const SEnumTableEntry
1424 g_estC1G2StateUnawareAction[];
1425 
1426 
1447 enum EC1G2TagInventoryStateAwareI
1448 {
1450 };
1451 
1452 extern const SEnumTableEntry
1453 g_estC1G2TagInventoryStateAwareI[];
1454 
1455 
1476 enum EC1G2TagInventoryStateAwareS
1477 {
1479 };
1480 
1481 extern const SEnumTableEntry
1482 g_estC1G2TagInventoryStateAwareS[];
1483 
1484 
1514 enum EC1G2LockPrivilege
1515 {
1517 };
1518 
1519 extern const SEnumTableEntry
1520 g_estC1G2LockPrivilege[];
1521 
1522 
1546 enum EC1G2LockDataField
1547 {
1549 };
1550 
1551 extern const SEnumTableEntry
1552 g_estC1G2LockDataField[];
1553 
1554 
1577 enum EC1G2ReadResultType
1578 {
1580 };
1581 
1582 extern const SEnumTableEntry
1583 g_estC1G2ReadResultType[];
1584 
1585 
1615 enum EC1G2WriteResultType
1616 {
1618 };
1619 
1620 extern const SEnumTableEntry
1621 g_estC1G2WriteResultType[];
1622 
1623 
1648 enum EC1G2KillResultType
1649 {
1651 };
1652 
1653 extern const SEnumTableEntry
1654 g_estC1G2KillResultType[];
1655 
1656 
1680 enum EC1G2LockResultType
1681 {
1683 };
1684 
1685 extern const SEnumTableEntry
1686 g_estC1G2LockResultType[];
1687 
1688 
1714 enum EC1G2BlockEraseResultType
1715 {
1717 };
1718 
1719 extern const SEnumTableEntry
1720 g_estC1G2BlockEraseResultType[];
1721 
1722 
1752 enum EC1G2BlockWriteResultType
1753 {
1755 };
1756 
1757 extern const SEnumTableEntry
1758 g_estC1G2BlockWriteResultType[];
1759 
1760 
1766 
1806 class CCUSTOM_MESSAGE : public CMessage
1807 {
1808  public:
1809  CCUSTOM_MESSAGE (void);
1810  ~CCUSTOM_MESSAGE (void);
1811 
1814 
1815  static const CFieldDescriptor * const
1816  s_apFieldDescriptorTable[];
1817 
1818  static const CTypeDescriptor
1819  s_typeDescriptor;
1820 
1821  void
1822  decodeFields (
1823  CDecoderStream * pDecoderStream);
1824 
1825  void
1826  assimilateSubParameters (
1827  CErrorDetails * pError);
1828 
1829  void
1830  encode (
1831  CEncoderStream * pEncoderStream) const;
1832 
1833 
1834 
1835  static CElement *
1836  s_construct (void);
1837 
1838  static void
1839  s_decodeFields (
1840  CDecoderStream * pDecoderStream,
1841  CElement * pElement);
1843 
1844 
1845  protected:
1846  llrp_u32_t m_VendorIdentifier;
1847 
1850  public:
1851  static const CFieldDescriptor
1852  s_fdVendorIdentifier;
1854 
1856  inline llrp_u32_t
1858  {
1859  return m_VendorIdentifier;
1860  }
1861 
1863  inline void
1865  llrp_u32_t value)
1866  {
1867  m_VendorIdentifier = value;
1868  }
1869 
1870 
1871  protected:
1872  llrp_u8_t m_MessageSubtype;
1873 
1876  public:
1877  static const CFieldDescriptor
1878  s_fdMessageSubtype;
1880 
1882  inline llrp_u8_t
1884  {
1885  return m_MessageSubtype;
1886  }
1887 
1889  inline void
1891  llrp_u8_t value)
1892  {
1893  m_MessageSubtype = value;
1894  }
1895 
1896 
1897  protected:
1898  llrp_bytesToEnd_t m_Data;
1899 
1902  public:
1903  static const CFieldDescriptor
1904  s_fdData;
1906 
1908  inline llrp_bytesToEnd_t
1909  getData (void)
1910  {
1911  return m_Data;
1912  }
1913 
1915  inline void
1917  llrp_bytesToEnd_t value)
1918  {
1919  m_Data = value;
1920  }
1921 
1922 
1923 };
1924 
1925 
1957 class CGET_READER_CAPABILITIES : public CMessage
1958 {
1959  public:
1960  CGET_READER_CAPABILITIES (void);
1961  ~CGET_READER_CAPABILITIES (void);
1962 
1965 
1966  static const CFieldDescriptor * const
1967  s_apFieldDescriptorTable[];
1968 
1969  static const CTypeDescriptor
1970  s_typeDescriptor;
1971 
1972  void
1973  decodeFields (
1974  CDecoderStream * pDecoderStream);
1975 
1976  void
1977  assimilateSubParameters (
1978  CErrorDetails * pError);
1979 
1980  void
1981  encode (
1982  CEncoderStream * pEncoderStream) const;
1983 
1984 
1985 
1986  static CElement *
1987  s_construct (void);
1988 
1989  static void
1990  s_decodeFields (
1991  CDecoderStream * pDecoderStream,
1992  CElement * pElement);
1994 
1995 
1996  protected:
1997  EGetReaderCapabilitiesRequestedData m_eRequestedData;
1998 
2001  public:
2002  static const CFieldDescriptor
2003  s_fdRequestedData;
2005 
2007  inline EGetReaderCapabilitiesRequestedData
2009  {
2010  return m_eRequestedData;
2011  }
2012 
2014  inline void
2016  EGetReaderCapabilitiesRequestedData value)
2017  {
2018  m_eRequestedData = value;
2019  }
2020 
2021 
2022  protected:
2023  std::list<CParameter *> m_listCustom;
2024 
2025  public:
2027  inline std::list<CParameter *>::iterator
2029  {
2030  return m_listCustom.begin();
2031  }
2032 
2034  inline std::list<CParameter *>::iterator
2035  endCustom (void)
2036  {
2037  return m_listCustom.end();
2038  }
2039 
2041  inline void
2043  {
2044  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2045  }
2046 
2048  inline int
2050  {
2051  return (int) (m_listCustom.size());
2052  }
2053 
2054  EResultCode
2056  addCustom (
2057  CParameter * pValue);
2058 
2059 
2060 };
2061 
2062 
2098 class CGET_READER_CAPABILITIES_RESPONSE : public CMessage
2099 {
2100  public:
2103 
2106 
2107  static const CFieldDescriptor * const
2108  s_apFieldDescriptorTable[];
2109 
2110  static const CTypeDescriptor
2111  s_typeDescriptor;
2112 
2113  void
2114  decodeFields (
2115  CDecoderStream * pDecoderStream);
2116 
2117  void
2118  assimilateSubParameters (
2119  CErrorDetails * pError);
2120 
2121  void
2122  encode (
2123  CEncoderStream * pEncoderStream) const;
2124 
2125 
2126 
2127  static CElement *
2128  s_construct (void);
2129 
2130  static void
2131  s_decodeFields (
2132  CDecoderStream * pDecoderStream,
2133  CElement * pElement);
2135 
2136 
2137  protected:
2138  CLLRPStatus * m_pLLRPStatus;
2139 
2140  public:
2142  inline CLLRPStatus *
2144  {
2145  return m_pLLRPStatus;
2146  }
2147 
2149  EResultCode
2150  setLLRPStatus (
2151  CLLRPStatus * pValue);
2152 
2153 
2154  protected:
2155  CGeneralDeviceCapabilities * m_pGeneralDeviceCapabilities;
2156 
2157  public:
2161  {
2162  return m_pGeneralDeviceCapabilities;
2163  }
2164 
2166  EResultCode
2168  CGeneralDeviceCapabilities * pValue);
2169 
2170 
2171  protected:
2172  CLLRPCapabilities * m_pLLRPCapabilities;
2173 
2174  public:
2176  inline CLLRPCapabilities *
2178  {
2179  return m_pLLRPCapabilities;
2180  }
2181 
2183  EResultCode
2185  CLLRPCapabilities * pValue);
2186 
2187 
2188  protected:
2189  CRegulatoryCapabilities * m_pRegulatoryCapabilities;
2190 
2191  public:
2193  inline CRegulatoryCapabilities *
2195  {
2196  return m_pRegulatoryCapabilities;
2197  }
2198 
2200  EResultCode
2202  CRegulatoryCapabilities * pValue);
2203 
2204 
2205  protected:
2206  CParameter * m_pAirProtocolLLRPCapabilities;
2207 
2208  public:
2210  inline CParameter *
2212  {
2213  return m_pAirProtocolLLRPCapabilities;
2214  }
2215 
2217  EResultCode
2219  CParameter * pValue);
2220 
2221 
2222  protected:
2223  std::list<CParameter *> m_listCustom;
2224 
2225  public:
2227  inline std::list<CParameter *>::iterator
2229  {
2230  return m_listCustom.begin();
2231  }
2232 
2234  inline std::list<CParameter *>::iterator
2235  endCustom (void)
2236  {
2237  return m_listCustom.end();
2238  }
2239 
2241  inline void
2243  {
2244  clearSubParameterList ((tListOfParameters *) &m_listCustom);
2245  }
2246 
2248  inline int
2250  {
2251  return (int) (m_listCustom.size());
2252  }
2253 
2254  EResultCode
2256  addCustom (
2257  CParameter * pValue);
2258 
2259 
2260 };
2261 
2262 
2302 class CADD_ROSPEC : public CMessage
2303 {
2304  public:
2305  CADD_ROSPEC (void);
2306  ~CADD_ROSPEC (void);
2307 
2310 
2311  static const CFieldDescriptor * const
2312  s_apFieldDescriptorTable[];
2313 
2314  static const CTypeDescriptor
2315  s_typeDescriptor;
2316 
2317  void
2318  decodeFields (
2319  CDecoderStream * pDecoderStream);
2320 
2321  void
2322  assimilateSubParameters (
2323  CErrorDetails * pError);
2324 
2325  void
2326  encode (
2327  CEncoderStream * pEncoderStream) const;
2328 
2329 
2330 
2331  static CElement *
2332  s_construct (void);
2333 
2334  static void
2335  s_decodeFields (
2336  CDecoderStream * pDecoderStream,
2337  CElement * pElement);
2339 
2340 
2341  protected:
2342  CROSpec * m_pROSpec;
2343 
2344  public:
2346  inline CROSpec *
2347  getROSpec (void)
2348  {
2349  return m_pROSpec;
2350  }
2351 
2353  EResultCode
2354  setROSpec (
2355  CROSpec * pValue);
2356 
2357 
2358 };
2359 
2360 
2391 class CADD_ROSPEC_RESPONSE : public CMessage
2392 {
2393  public:
2394  CADD_ROSPEC_RESPONSE (void);
2395  ~CADD_ROSPEC_RESPONSE (void);
2396 
2399 
2400  static const CFieldDescriptor * const
2401  s_apFieldDescriptorTable[];
2402 
2403  static const CTypeDescriptor
2404  s_typeDescriptor;
2405 
2406  void
2407  decodeFields (
2408  CDecoderStream * pDecoderStream);
2409 
2410  void
2411  assimilateSubParameters (
2412  CErrorDetails * pError);
2413 
2414  void
2415  encode (
2416  CEncoderStream * pEncoderStream) const;
2417 
2418 
2419 
2420  static CElement *
2421  s_construct (void);
2422 
2423  static void
2424  s_decodeFields (
2425  CDecoderStream * pDecoderStream,
2426  CElement * pElement);
2428 
2429 
2430  protected:
2431  CLLRPStatus * m_pLLRPStatus;
2432 
2433  public:
2435  inline CLLRPStatus *
2437  {
2438  return m_pLLRPStatus;
2439  }
2440 
2442  EResultCode
2443  setLLRPStatus (
2444  CLLRPStatus * pValue);
2445 
2446 
2447 };
2448 
2449 
2483 class CDELETE_ROSPEC : public CMessage
2484 {
2485  public:
2486  CDELETE_ROSPEC (void);
2487  ~CDELETE_ROSPEC (void);
2488 
2491 
2492  static const CFieldDescriptor * const
2493  s_apFieldDescriptorTable[];
2494 
2495  static const CTypeDescriptor
2496  s_typeDescriptor;
2497 
2498  void
2499  decodeFields (
2500  CDecoderStream * pDecoderStream);
2501 
2502  void
2503  assimilateSubParameters (
2504  CErrorDetails * pError);
2505 
2506  void
2507  encode (
2508  CEncoderStream * pEncoderStream) const;
2509 
2510 
2511 
2512  static CElement *
2513  s_construct (void);
2514 
2515  static void
2516  s_decodeFields (
2517  CDecoderStream * pDecoderStream,
2518  CElement * pElement);
2520 
2521 
2522  protected:
2523  llrp_u32_t m_ROSpecID;
2524 
2527  public:
2528  static const CFieldDescriptor
2529  s_fdROSpecID;
2531 
2533  inline llrp_u32_t
2535  {
2536  return m_ROSpecID;
2537  }
2538 
2540  inline void
2542  llrp_u32_t value)
2543  {
2544  m_ROSpecID = value;
2545  }
2546 
2547 
2548 };
2549 
2550 
2581 class CDELETE_ROSPEC_RESPONSE : public CMessage
2582 {
2583  public:
2584  CDELETE_ROSPEC_RESPONSE (void);
2585  ~CDELETE_ROSPEC_RESPONSE (void);
2586 
2589 
2590  static const CFieldDescriptor * const
2591  s_apFieldDescriptorTable[];
2592 
2593  static const CTypeDescriptor
2594  s_typeDescriptor;
2595 
2596  void
2597  decodeFields (
2598  CDecoderStream * pDecoderStream);
2599 
2600  void
2601  assimilateSubParameters (
2602  CErrorDetails * pError);
2603 
2604  void
2605  encode (
2606  CEncoderStream * pEncoderStream) const;
2607 
2608 
2609 
2610  static CElement *
2611  s_construct (void);
2612 
2613  static void
2614  s_decodeFields (
2615  CDecoderStream * pDecoderStream,
2616  CElement * pElement);
2618 
2619 
2620  protected:
2621  CLLRPStatus * m_pLLRPStatus;
2622 
2623  public:
2625  inline CLLRPStatus *
2627  {
2628  return m_pLLRPStatus;
2629  }
2630 
2632  EResultCode
2633  setLLRPStatus (
2634  CLLRPStatus * pValue);
2635 
2636 
2637 };
2638 
2639 
2673 class CSTART_ROSPEC : public CMessage
2674 {
2675  public:
2676  CSTART_ROSPEC (void);
2677  ~CSTART_ROSPEC (void);
2678 
2681 
2682  static const CFieldDescriptor * const
2683  s_apFieldDescriptorTable[];
2684 
2685  static const CTypeDescriptor
2686  s_typeDescriptor;
2687 
2688  void
2689  decodeFields (
2690  CDecoderStream * pDecoderStream);
2691 
2692  void
2693  assimilateSubParameters (
2694  CErrorDetails * pError);
2695 
2696  void
2697  encode (
2698  CEncoderStream * pEncoderStream) const;
2699 
2700 
2701 
2702  static CElement *
2703  s_construct (void);
2704 
2705  static void
2706  s_decodeFields (
2707  CDecoderStream * pDecoderStream,
2708  CElement * pElement);
2710 
2711 
2712  protected:
2713  llrp_u32_t m_ROSpecID;
2714 
2717  public:
2718  static const CFieldDescriptor
2719  s_fdROSpecID;
2721 
2723  inline llrp_u32_t
2725  {
2726  return m_ROSpecID;
2727  }
2728 
2730  inline void
2732  llrp_u32_t value)
2733  {
2734  m_ROSpecID = value;
2735  }
2736 
2737 
2738 };
2739 
2740 
2771 class CSTART_ROSPEC_RESPONSE : public CMessage
2772 {
2773  public:
2774  CSTART_ROSPEC_RESPONSE (void);
2775  ~CSTART_ROSPEC_RESPONSE (void);
2776 
2779 
2780  static const CFieldDescriptor * const
2781  s_apFieldDescriptorTable[];
2782 
2783  static const CTypeDescriptor
2784  s_typeDescriptor;
2785 
2786  void
2787  decodeFields (
2788  CDecoderStream * pDecoderStream);
2789 
2790  void
2791  assimilateSubParameters (
2792  CErrorDetails * pError);
2793 
2794  void
2795  encode (
2796  CEncoderStream * pEncoderStream) const;
2797 
2798 
2799 
2800  static CElement *
2801  s_construct (void);
2802 
2803  static void
2804  s_decodeFields (
2805  CDecoderStream * pDecoderStream,
2806  CElement * pElement);
2808 
2809 
2810  protected:
2811  CLLRPStatus * m_pLLRPStatus;
2812 
2813  public:
2815  inline CLLRPStatus *
2817  {
2818  return m_pLLRPStatus;
2819  }
2820 
2822  EResultCode
2823  setLLRPStatus (
2824  CLLRPStatus * pValue);
2825 
2826 
2827 };
2828 
2829 
2863 class CSTOP_ROSPEC : public CMessage
2864 {
2865  public:
2866  CSTOP_ROSPEC (void);
2867  ~CSTOP_ROSPEC (void);
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 
2892  static CElement *
2893  s_construct (void);
2894 
2895  static void
2896  s_decodeFields (
2897  CDecoderStream * pDecoderStream,
2898  CElement * pElement);
2900 
2901 
2902  protected:
2903  llrp_u32_t m_ROSpecID;
2904 
2907  public:
2908  static const CFieldDescriptor
2909  s_fdROSpecID;
2911 
2913  inline llrp_u32_t
2915  {
2916  return m_ROSpecID;
2917  }
2918 
2920  inline void
2922  llrp_u32_t value)
2923  {
2924  m_ROSpecID = value;
2925  }
2926 
2927 
2928 };
2929 
2930 
2961 class CSTOP_ROSPEC_RESPONSE : public CMessage
2962 {
2963  public:
2964  CSTOP_ROSPEC_RESPONSE (void);
2965  ~CSTOP_ROSPEC_RESPONSE (void);
2966 
2969 
2970  static const CFieldDescriptor * const
2971  s_apFieldDescriptorTable[];
2972 
2973  static const CTypeDescriptor
2974  s_typeDescriptor;
2975 
2976  void
2977  decodeFields (
2978  CDecoderStream * pDecoderStream);
2979 
2980  void
2981  assimilateSubParameters (
2982  CErrorDetails * pError);
2983 
2984  void
2985  encode (
2986  CEncoderStream * pEncoderStream) const;
2987 
2988 
2989 
2990  static CElement *
2991  s_construct (void);
2992 
2993  static void
2994  s_decodeFields (
2995  CDecoderStream * pDecoderStream,
2996  CElement * pElement);
2998 
2999 
3000  protected:
3001  CLLRPStatus * m_pLLRPStatus;
3002 
3003  public:
3005  inline CLLRPStatus *
3007  {
3008  return m_pLLRPStatus;
3009  }
3010 
3012  EResultCode
3013  setLLRPStatus (
3014  CLLRPStatus * pValue);
3015 
3016 
3017 };
3018 
3019 
3053 class CENABLE_ROSPEC : public CMessage
3054 {
3055  public:
3056  CENABLE_ROSPEC (void);
3057  ~CENABLE_ROSPEC (void);
3058 
3061 
3062  static const CFieldDescriptor * const
3063  s_apFieldDescriptorTable[];
3064 
3065  static const CTypeDescriptor
3066  s_typeDescriptor;
3067 
3068  void
3069  decodeFields (
3070  CDecoderStream * pDecoderStream);
3071 
3072  void
3073  assimilateSubParameters (
3074  CErrorDetails * pError);
3075 
3076  void
3077  encode (
3078  CEncoderStream * pEncoderStream) const;
3079 
3080 
3081 
3082  static CElement *
3083  s_construct (void);
3084 
3085  static void
3086  s_decodeFields (
3087  CDecoderStream * pDecoderStream,
3088  CElement * pElement);
3090 
3091 
3092  protected:
3093  llrp_u32_t m_ROSpecID;
3094 
3097  public:
3098  static const CFieldDescriptor
3099  s_fdROSpecID;
3101 
3103  inline llrp_u32_t
3105  {
3106  return m_ROSpecID;
3107  }
3108 
3110  inline void
3112  llrp_u32_t value)
3113  {
3114  m_ROSpecID = value;
3115  }
3116 
3117 
3118 };
3119 
3120 
3151 class CENABLE_ROSPEC_RESPONSE : public CMessage
3152 {
3153  public:
3154  CENABLE_ROSPEC_RESPONSE (void);
3155  ~CENABLE_ROSPEC_RESPONSE (void);
3156 
3159 
3160  static const CFieldDescriptor * const
3161  s_apFieldDescriptorTable[];
3162 
3163  static const CTypeDescriptor
3164  s_typeDescriptor;
3165 
3166  void
3167  decodeFields (
3168  CDecoderStream * pDecoderStream);
3169 
3170  void
3171  assimilateSubParameters (
3172  CErrorDetails * pError);
3173 
3174  void
3175  encode (
3176  CEncoderStream * pEncoderStream) const;
3177 
3178 
3179 
3180  static CElement *
3181  s_construct (void);
3182 
3183  static void
3184  s_decodeFields (
3185  CDecoderStream * pDecoderStream,
3186  CElement * pElement);
3188 
3189 
3190  protected:
3191  CLLRPStatus * m_pLLRPStatus;
3192 
3193  public:
3195  inline CLLRPStatus *
3197  {
3198  return m_pLLRPStatus;
3199  }
3200 
3202  EResultCode
3203  setLLRPStatus (
3204  CLLRPStatus * pValue);
3205 
3206 
3207 };
3208 
3209 
3243 class CDISABLE_ROSPEC : public CMessage
3244 {
3245  public:
3246  CDISABLE_ROSPEC (void);
3247  ~CDISABLE_ROSPEC (void);
3248 
3251 
3252  static const CFieldDescriptor * const
3253  s_apFieldDescriptorTable[];
3254 
3255  static const CTypeDescriptor
3256  s_typeDescriptor;
3257 
3258  void
3259  decodeFields (
3260  CDecoderStream * pDecoderStream);
3261 
3262  void
3263  assimilateSubParameters (
3264  CErrorDetails * pError);
3265 
3266  void
3267  encode (
3268  CEncoderStream * pEncoderStream) const;
3269 
3270 
3271 
3272  static CElement *
3273  s_construct (void);
3274 
3275  static void
3276  s_decodeFields (
3277  CDecoderStream * pDecoderStream,
3278  CElement * pElement);
3280 
3281 
3282  protected:
3283  llrp_u32_t m_ROSpecID;
3284 
3287  public:
3288  static const CFieldDescriptor
3289  s_fdROSpecID;
3291 
3293  inline llrp_u32_t
3295  {
3296  return m_ROSpecID;
3297  }
3298 
3300  inline void
3302  llrp_u32_t value)
3303  {
3304  m_ROSpecID = value;
3305  }
3306 
3307 
3308 };
3309 
3310 
3341 class CDISABLE_ROSPEC_RESPONSE : public CMessage
3342 {
3343  public:
3344  CDISABLE_ROSPEC_RESPONSE (void);
3345  ~CDISABLE_ROSPEC_RESPONSE (void);
3346 
3349 
3350  static const CFieldDescriptor * const
3351  s_apFieldDescriptorTable[];
3352 
3353  static const CTypeDescriptor
3354  s_typeDescriptor;
3355 
3356  void
3357  decodeFields (
3358  CDecoderStream * pDecoderStream);
3359 
3360  void
3361  assimilateSubParameters (
3362  CErrorDetails * pError);
3363 
3364  void
3365  encode (
3366  CEncoderStream * pEncoderStream) const;
3367 
3368 
3369 
3370  static CElement *
3371  s_construct (void);
3372 
3373  static void
3374  s_decodeFields (
3375  CDecoderStream * pDecoderStream,
3376  CElement * pElement);
3378 
3379 
3380  protected:
3381  CLLRPStatus * m_pLLRPStatus;
3382 
3383  public:
3385  inline CLLRPStatus *
3387  {
3388  return m_pLLRPStatus;
3389  }
3390 
3392  EResultCode
3393  setLLRPStatus (
3394  CLLRPStatus * pValue);
3395 
3396 
3397 };
3398 
3399 
3429 class CGET_ROSPECS : public CMessage
3430 {
3431  public:
3432  CGET_ROSPECS (void);
3433  ~CGET_ROSPECS (void);
3434 
3437 
3438  static const CFieldDescriptor * const
3439  s_apFieldDescriptorTable[];
3440 
3441  static const CTypeDescriptor
3442  s_typeDescriptor;
3443 
3444  void
3445  decodeFields (
3446  CDecoderStream * pDecoderStream);
3447 
3448  void
3449  assimilateSubParameters (
3450  CErrorDetails * pError);
3451 
3452  void
3453  encode (
3454  CEncoderStream * pEncoderStream) const;
3455 
3456 
3457 
3458  static CElement *
3459  s_construct (void);
3460 
3461  static void
3462  s_decodeFields (
3463  CDecoderStream * pDecoderStream,
3464  CElement * pElement);
3466 
3467 
3468 };
3469 
3470 
3502 class CGET_ROSPECS_RESPONSE : public CMessage
3503 {
3504  public:
3505  CGET_ROSPECS_RESPONSE (void);
3506  ~CGET_ROSPECS_RESPONSE (void);
3507 
3510 
3511  static const CFieldDescriptor * const
3512  s_apFieldDescriptorTable[];
3513 
3514  static const CTypeDescriptor
3515  s_typeDescriptor;
3516 
3517  void
3518  decodeFields (
3519  CDecoderStream * pDecoderStream);
3520 
3521  void
3522  assimilateSubParameters (
3523  CErrorDetails * pError);
3524 
3525  void
3526  encode (
3527  CEncoderStream * pEncoderStream) const;
3528 
3529 
3530 
3531  static CElement *
3532  s_construct (void);
3533 
3534  static void
3535  s_decodeFields (
3536  CDecoderStream * pDecoderStream,
3537  CElement * pElement);
3539 
3540 
3541  protected:
3542  CLLRPStatus * m_pLLRPStatus;
3543 
3544  public:
3546  inline CLLRPStatus *
3548  {
3549  return m_pLLRPStatus;
3550  }
3551 
3553  EResultCode
3554  setLLRPStatus (
3555  CLLRPStatus * pValue);
3556 
3557 
3558  protected:
3559  std::list<CROSpec *> m_listROSpec;
3560 
3561  public:
3563  inline std::list<CROSpec *>::iterator
3565  {
3566  return m_listROSpec.begin();
3567  }
3568 
3570  inline std::list<CROSpec *>::iterator
3571  endROSpec (void)
3572  {
3573  return m_listROSpec.end();
3574  }
3575 
3577  inline void
3579  {
3580  clearSubParameterList ((tListOfParameters *) &m_listROSpec);
3581  }
3582 
3584  inline int
3586  {
3587  return (int) (m_listROSpec.size());
3588  }
3589 
3590  EResultCode
3592  addROSpec (
3593  CROSpec * pValue);
3594 
3595 
3596 };
3597 
3598 
3638 class CADD_ACCESSSPEC : public CMessage
3639 {
3640  public:
3641  CADD_ACCESSSPEC (void);
3642  ~CADD_ACCESSSPEC (void);
3643 
3646 
3647  static const CFieldDescriptor * const
3648  s_apFieldDescriptorTable[];
3649 
3650  static const CTypeDescriptor
3651  s_typeDescriptor;
3652 
3653  void
3654  decodeFields (
3655  CDecoderStream * pDecoderStream);
3656 
3657  void
3658  assimilateSubParameters (
3659  CErrorDetails * pError);
3660 
3661  void
3662  encode (
3663  CEncoderStream * pEncoderStream) const;
3664 
3665 
3666 
3667  static CElement *
3668  s_construct (void);
3669 
3670  static void
3671  s_decodeFields (
3672  CDecoderStream * pDecoderStream,
3673  CElement * pElement);
3675 
3676 
3677  protected:
3678  CAccessSpec * m_pAccessSpec;
3679 
3680  public:
3682  inline CAccessSpec *
3684  {
3685  return m_pAccessSpec;
3686  }
3687 
3689  EResultCode
3690  setAccessSpec (
3691  CAccessSpec * pValue);
3692 
3693 
3694 };
3695 
3696 
3727 class CADD_ACCESSSPEC_RESPONSE : public CMessage
3728 {
3729  public:
3730  CADD_ACCESSSPEC_RESPONSE (void);
3731  ~CADD_ACCESSSPEC_RESPONSE (void);
3732 
3735 
3736  static const CFieldDescriptor * const
3737  s_apFieldDescriptorTable[];
3738 
3739  static const CTypeDescriptor
3740  s_typeDescriptor;
3741 
3742  void
3743  decodeFields (
3744  CDecoderStream * pDecoderStream);
3745 
3746  void
3747  assimilateSubParameters (
3748  CErrorDetails * pError);
3749 
3750  void
3751  encode (
3752  CEncoderStream * pEncoderStream) const;
3753 
3754 
3755 
3756  static CElement *
3757  s_construct (void);
3758 
3759  static void
3760  s_decodeFields (
3761  CDecoderStream * pDecoderStream,
3762  CElement * pElement);
3764 
3765 
3766  protected:
3767  CLLRPStatus * m_pLLRPStatus;
3768 
3769  public:
3771  inline CLLRPStatus *
3773  {
3774  return m_pLLRPStatus;
3775  }
3776 
3778  EResultCode
3779  setLLRPStatus (
3780  CLLRPStatus * pValue);
3781 
3782 
3783 };
3784 
3785 
3819 class CDELETE_ACCESSSPEC : public CMessage
3820 {
3821  public:
3822  CDELETE_ACCESSSPEC (void);
3823  ~CDELETE_ACCESSSPEC (void);
3824 
3827 
3828  static const CFieldDescriptor * const
3829  s_apFieldDescriptorTable[];
3830 
3831  static const CTypeDescriptor
3832  s_typeDescriptor;
3833 
3834  void
3835  decodeFields (
3836  CDecoderStream * pDecoderStream);
3837 
3838  void
3839  assimilateSubParameters (
3840  CErrorDetails * pError);
3841 
3842  void
3843  encode (
3844  CEncoderStream * pEncoderStream) const;
3845 
3846 
3847 
3848  static CElement *
3849  s_construct (void);
3850 
3851  static void
3852  s_decodeFields (
3853  CDecoderStream * pDecoderStream,
3854  CElement * pElement);
3856 
3857 
3858  protected:
3859  llrp_u32_t m_AccessSpecID;
3860 
3863  public:
3864  static const CFieldDescriptor
3865  s_fdAccessSpecID;
3867 
3869  inline llrp_u32_t
3871  {
3872  return m_AccessSpecID;
3873  }
3874 
3876  inline void
3878  llrp_u32_t value)
3879  {
3880  m_AccessSpecID = value;
3881  }
3882 
3883 
3884 };
3885 
3886 
3917 class CDELETE_ACCESSSPEC_RESPONSE : public CMessage
3918 {
3919  public:
3922 
3925 
3926  static const CFieldDescriptor * const
3927  s_apFieldDescriptorTable[];
3928 
3929  static const CTypeDescriptor
3930  s_typeDescriptor;
3931 
3932  void
3933  decodeFields (
3934  CDecoderStream * pDecoderStream);
3935 
3936  void
3937  assimilateSubParameters (
3938  CErrorDetails * pError);
3939 
3940  void
3941  encode (
3942  CEncoderStream * pEncoderStream) const;
3943 
3944 
3945 
3946  static CElement *
3947  s_construct (void);
3948 
3949  static void
3950  s_decodeFields (
3951  CDecoderStream * pDecoderStream,
3952  CElement * pElement);
3954 
3955 
3956  protected:
3957  CLLRPStatus * m_pLLRPStatus;
3958 
3959  public:
3961  inline CLLRPStatus *
3963  {
3964  return m_pLLRPStatus;
3965  }
3966 
3968  EResultCode
3969  setLLRPStatus (
3970  CLLRPStatus * pValue);
3971 
3972 
3973 };
3974 
3975 
4009 class CENABLE_ACCESSSPEC : public CMessage
4010 {
4011  public:
4012  CENABLE_ACCESSSPEC (void);
4013  ~CENABLE_ACCESSSPEC (void);
4014 
4017 
4018  static const CFieldDescriptor * const
4019  s_apFieldDescriptorTable[];
4020 
4021  static const CTypeDescriptor
4022  s_typeDescriptor;
4023 
4024  void
4025  decodeFields (
4026  CDecoderStream * pDecoderStream);
4027 
4028  void
4029  assimilateSubParameters (
4030  CErrorDetails * pError);
4031 
4032  void
4033  encode (
4034  CEncoderStream * pEncoderStream) const;
4035 
4036 
4037 
4038  static CElement *
4039  s_construct (void);
4040 
4041  static void
4042  s_decodeFields (
4043  CDecoderStream * pDecoderStream,
4044  CElement * pElement);
4046 
4047 
4048  protected:
4049  llrp_u32_t m_AccessSpecID;
4050 
4053  public:
4054  static const CFieldDescriptor
4055  s_fdAccessSpecID;
4057 
4059  inline llrp_u32_t
4061  {
4062  return m_AccessSpecID;
4063  }
4064 
4066  inline void
4068  llrp_u32_t value)
4069  {
4070  m_AccessSpecID = value;
4071  }
4072 
4073 
4074 };
4075 
4076 
4107 class CENABLE_ACCESSSPEC_RESPONSE : public CMessage
4108 {
4109  public:
4112 
4115 
4116  static const CFieldDescriptor * const
4117  s_apFieldDescriptorTable[];
4118 
4119  static const CTypeDescriptor
4120  s_typeDescriptor;
4121 
4122  void
4123  decodeFields (
4124  CDecoderStream * pDecoderStream);
4125 
4126  void
4127  assimilateSubParameters (
4128  CErrorDetails * pError);
4129 
4130  void
4131  encode (
4132  CEncoderStream * pEncoderStream) const;
4133 
4134 
4135 
4136  static CElement *
4137  s_construct (void);
4138 
4139  static void
4140  s_decodeFields (
4141  CDecoderStream * pDecoderStream,
4142  CElement * pElement);
4144 
4145 
4146  protected:
4147  CLLRPStatus * m_pLLRPStatus;
4148 
4149  public:
4151  inline CLLRPStatus *
4153  {
4154  return m_pLLRPStatus;
4155  }
4156 
4158  EResultCode
4159  setLLRPStatus (
4160  CLLRPStatus * pValue);
4161 
4162 
4163 };
4164 
4165 
4199 class CDISABLE_ACCESSSPEC : public CMessage
4200 {
4201  public:
4202  CDISABLE_ACCESSSPEC (void);
4203  ~CDISABLE_ACCESSSPEC (void);
4204 
4207 
4208  static const CFieldDescriptor * const
4209  s_apFieldDescriptorTable[];
4210 
4211  static const CTypeDescriptor
4212  s_typeDescriptor;
4213 
4214  void
4215  decodeFields (
4216  CDecoderStream * pDecoderStream);
4217 
4218  void
4219  assimilateSubParameters (
4220  CErrorDetails * pError);
4221 
4222  void
4223  encode (
4224  CEncoderStream * pEncoderStream) const;
4225 
4226 
4227 
4228  static CElement *
4229  s_construct (void);
4230 
4231  static void
4232  s_decodeFields (
4233  CDecoderStream * pDecoderStream,
4234  CElement * pElement);
4236 
4237 
4238  protected:
4239  llrp_u32_t m_AccessSpecID;
4240 
4243  public:
4244  static const CFieldDescriptor
4245  s_fdAccessSpecID;
4247 
4249  inline llrp_u32_t
4251  {
4252  return m_AccessSpecID;
4253  }
4254 
4256  inline void
4258  llrp_u32_t value)
4259  {
4260  m_AccessSpecID = value;
4261  }
4262 
4263 
4264 };
4265 
4266 
4297 class CDISABLE_ACCESSSPEC_RESPONSE : public CMessage
4298 {
4299  public:
4302 
4305 
4306  static const CFieldDescriptor * const
4307  s_apFieldDescriptorTable[];
4308 
4309  static const CTypeDescriptor
4310  s_typeDescriptor;
4311 
4312  void
4313  decodeFields (
4314  CDecoderStream * pDecoderStream);
4315 
4316  void
4317  assimilateSubParameters (
4318  CErrorDetails * pError);
4319 
4320  void
4321  encode (
4322  CEncoderStream * pEncoderStream) const;
4323 
4324 
4325 
4326  static CElement *
4327  s_construct (void);
4328 
4329  static void
4330  s_decodeFields (
4331  CDecoderStream * pDecoderStream,
4332  CElement * pElement);
4334 
4335 
4336  protected:
4337  CLLRPStatus * m_pLLRPStatus;
4338 
4339  public:
4341  inline CLLRPStatus *
4343  {
4344  return m_pLLRPStatus;
4345  }
4346 
4348  EResultCode
4349  setLLRPStatus (
4350  CLLRPStatus * pValue);
4351 
4352 
4353 };
4354 
4355 
4385 class CGET_ACCESSSPECS : public CMessage
4386 {
4387  public:
4388  CGET_ACCESSSPECS (void);
4389  ~CGET_ACCESSSPECS (void);
4390 
4393 
4394  static const CFieldDescriptor * const
4395  s_apFieldDescriptorTable[];
4396 
4397  static const CTypeDescriptor
4398  s_typeDescriptor;
4399 
4400  void
4401  decodeFields (
4402  CDecoderStream * pDecoderStream);
4403 
4404  void
4405  assimilateSubParameters (
4406  CErrorDetails * pError);
4407 
4408  void
4409  encode (
4410  CEncoderStream * pEncoderStream) const;
4411 
4412 
4413 
4414  static CElement *
4415  s_construct (void);
4416 
4417  static void
4418  s_decodeFields (
4419  CDecoderStream * pDecoderStream,
4420  CElement * pElement);
4422 
4423 
4424 };
4425 
4426 
4458 class CGET_ACCESSSPECS_RESPONSE : public CMessage
4459 {
4460  public:
4462  ~CGET_ACCESSSPECS_RESPONSE (void);
4463 
4466 
4467  static const CFieldDescriptor * const
4468  s_apFieldDescriptorTable[];
4469 
4470  static const CTypeDescriptor
4471  s_typeDescriptor;
4472 
4473  void
4474  decodeFields (
4475  CDecoderStream * pDecoderStream);
4476 
4477  void
4478  assimilateSubParameters (
4479  CErrorDetails * pError);
4480 
4481  void
4482  encode (
4483  CEncoderStream * pEncoderStream) const;
4484 
4485 
4486 
4487  static CElement *
4488  s_construct (void);
4489 
4490  static void
4491  s_decodeFields (
4492  CDecoderStream * pDecoderStream,
4493  CElement * pElement);
4495 
4496 
4497  protected:
4498  CLLRPStatus * m_pLLRPStatus;
4499 
4500  public:
4502  inline CLLRPStatus *
4504  {
4505  return m_pLLRPStatus;
4506  }
4507 
4509  EResultCode
4510  setLLRPStatus (
4511  CLLRPStatus * pValue);
4512 
4513 
4514  protected:
4515  std::list<CAccessSpec *> m_listAccessSpec;
4516 
4517  public:
4519  inline std::list<CAccessSpec *>::iterator
4521  {
4522  return m_listAccessSpec.begin();
4523  }
4524 
4526  inline std::list<CAccessSpec *>::iterator
4528  {
4529  return m_listAccessSpec.end();
4530  }
4531 
4533  inline void
4535  {
4536  clearSubParameterList ((tListOfParameters *) &m_listAccessSpec);
4537  }
4538 
4540  inline int
4542  {
4543  return (int) (m_listAccessSpec.size());
4544  }
4545 
4546  EResultCode
4548  addAccessSpec (
4549  CAccessSpec * pValue);
4550 
4551 
4552 };
4553 
4554 
4585 class CCLIENT_REQUEST_OP : public CMessage
4586 {
4587  public:
4588  CCLIENT_REQUEST_OP (void);
4589  ~CCLIENT_REQUEST_OP (void);
4590 
4593 
4594  static const CFieldDescriptor * const
4595  s_apFieldDescriptorTable[];
4596 
4597  static const CTypeDescriptor
4598  s_typeDescriptor;
4599 
4600  void
4601  decodeFields (
4602  CDecoderStream * pDecoderStream);
4603 
4604  void
4605  assimilateSubParameters (
4606  CErrorDetails * pError);
4607 
4608  void
4609  encode (
4610  CEncoderStream * pEncoderStream) const;
4611 
4612 
4613 
4614  static CElement *
4615  s_construct (void);
4616 
4617  static void
4618  s_decodeFields (
4619  CDecoderStream * pDecoderStream,
4620  CElement * pElement);
4622 
4623 
4624  protected:
4625  CTagReportData * m_pTagReportData;
4626 
4627  public:
4629  inline CTagReportData *
4631  {
4632  return m_pTagReportData;
4633  }
4634 
4636  EResultCode
4638  CTagReportData * pValue);
4639 
4640 
4641 };
4642 
4643 
4674 class CCLIENT_REQUEST_OP_RESPONSE : public CMessage
4675 {
4676  public:
4679 
4682 
4683  static const CFieldDescriptor * const
4684  s_apFieldDescriptorTable[];
4685 
4686  static const CTypeDescriptor
4687  s_typeDescriptor;
4688 
4689  void
4690  decodeFields (
4691  CDecoderStream * pDecoderStream);
4692 
4693  void
4694  assimilateSubParameters (
4695  CErrorDetails * pError);
4696 
4697  void
4698  encode (
4699  CEncoderStream * pEncoderStream) const;
4700 
4701 
4702 
4703  static CElement *
4704  s_construct (void);
4705 
4706  static void
4707  s_decodeFields (
4708  CDecoderStream * pDecoderStream,
4709  CElement * pElement);
4711 
4712 
4713  protected:
4714  CClientRequestResponse * m_pClientRequestResponse;
4715 
4716  public:
4718  inline CClientRequestResponse *
4720  {
4721  return m_pClientRequestResponse;
4722  }
4723 
4725  EResultCode
4727  CClientRequestResponse * pValue);
4728 
4729 
4730 };
4731 
4732 
4767 class CGET_READER_CONFIG : public CMessage
4768 {
4769  public:
4770  CGET_READER_CONFIG (void);
4771  ~CGET_READER_CONFIG (void);
4772 
4775 
4776  static const CFieldDescriptor * const
4777  s_apFieldDescriptorTable[];
4778 
4779  static const CTypeDescriptor
4780  s_typeDescriptor;
4781 
4782  void
4783  decodeFields (
4784  CDecoderStream * pDecoderStream);
4785 
4786  void
4787  assimilateSubParameters (
4788  CErrorDetails * pError);
4789 
4790  void
4791  encode (
4792  CEncoderStream * pEncoderStream) const;
4793 
4794 
4795 
4796  static CElement *
4797  s_construct (void);
4798 
4799  static void
4800  s_decodeFields (
4801  CDecoderStream * pDecoderStream,
4802  CElement * pElement);
4804 
4805 
4806  protected:
4807  llrp_u16_t m_AntennaID;
4808 
4811  public:
4812  static const CFieldDescriptor
4813  s_fdAntennaID;
4815 
4817  inline llrp_u16_t
4819  {
4820  return m_AntennaID;
4821  }
4822 
4824  inline void
4826  llrp_u16_t value)
4827  {
4828  m_AntennaID = value;
4829  }
4830 
4831 
4832  protected:
4833  EGetReaderConfigRequestedData m_eRequestedData;
4834 
4837  public:
4838  static const CFieldDescriptor
4839  s_fdRequestedData;
4841 
4843  inline EGetReaderConfigRequestedData
4845  {
4846  return m_eRequestedData;
4847  }
4848 
4850  inline void
4852  EGetReaderConfigRequestedData value)
4853  {
4854  m_eRequestedData = value;
4855  }
4856 
4857 
4858  protected:
4859  llrp_u16_t m_GPIPortNum;
4860 
4863  public:
4864  static const CFieldDescriptor
4865  s_fdGPIPortNum;
4867 
4869  inline llrp_u16_t
4871  {
4872  return m_GPIPortNum;
4873  }
4874 
4876  inline void
4878  llrp_u16_t value)
4879  {
4880  m_GPIPortNum = value;
4881  }
4882 
4883 
4884  protected:
4885  llrp_u16_t m_GPOPortNum;
4886 
4889  public:
4890  static const CFieldDescriptor
4891  s_fdGPOPortNum;
4893 
4895  inline llrp_u16_t
4897  {
4898  return m_GPOPortNum;
4899  }
4900 
4902  inline void
4904  llrp_u16_t value)
4905  {
4906  m_GPOPortNum = value;
4907  }
4908 
4909 
4910  protected:
4911  std::list<CParameter *> m_listCustom;
4912 
4913  public:
4915  inline std::list<CParameter *>::iterator
4917  {
4918  return m_listCustom.begin();
4919  }
4920 
4922  inline std::list<CParameter *>::iterator
4923  endCustom (void)
4924  {
4925  return m_listCustom.end();
4926  }
4927 
4929  inline void
4931  {
4932  clearSubParameterList ((tListOfParameters *) &m_listCustom);
4933  }
4934 
4936  inline int
4938  {
4939  return (int) (m_listCustom.size());
4940  }
4941 
4942  EResultCode
4944  addCustom (
4945  CParameter * pValue);
4946 
4947 
4948 };
4949 
4950 
5011 class CGET_READER_CONFIG_RESPONSE : public CMessage
5012 {
5013  public:
5016 
5019 
5020  static const CFieldDescriptor * const
5021  s_apFieldDescriptorTable[];
5022 
5023  static const CTypeDescriptor
5024  s_typeDescriptor;
5025 
5026  void
5027  decodeFields (
5028  CDecoderStream * pDecoderStream);
5029 
5030  void
5031  assimilateSubParameters (
5032  CErrorDetails * pError);
5033 
5034  void
5035  encode (
5036  CEncoderStream * pEncoderStream) const;
5037 
5038 
5039 
5040  static CElement *
5041  s_construct (void);
5042 
5043  static void
5044  s_decodeFields (
5045  CDecoderStream * pDecoderStream,
5046  CElement * pElement);
5048 
5049 
5050  protected:
5051  CLLRPStatus * m_pLLRPStatus;
5052 
5053  public:
5055  inline CLLRPStatus *
5057  {
5058  return m_pLLRPStatus;
5059  }
5060 
5062  EResultCode
5063  setLLRPStatus (
5064  CLLRPStatus * pValue);
5065 
5066 
5067  protected:
5068  CIdentification * m_pIdentification;
5069 
5070  public:
5072  inline CIdentification *
5074  {
5075  return m_pIdentification;
5076  }
5077 
5079  EResultCode
5081  CIdentification * pValue);
5082 
5083 
5084  protected:
5085  std::list<CAntennaProperties *> m_listAntennaProperties;
5086 
5087  public:
5089  inline std::list<CAntennaProperties *>::iterator
5091  {
5092  return m_listAntennaProperties.begin();
5093  }
5094 
5096  inline std::list<CAntennaProperties *>::iterator
5098  {
5099  return m_listAntennaProperties.end();
5100  }
5101 
5103  inline void
5105  {
5106  clearSubParameterList ((tListOfParameters *) &m_listAntennaProperties);
5107  }
5108 
5110  inline int
5112  {
5113  return (int) (m_listAntennaProperties.size());
5114  }
5115 
5116  EResultCode
5119  CAntennaProperties * pValue);
5120 
5121 
5122  protected:
5123  std::list<CAntennaConfiguration *> m_listAntennaConfiguration;
5124 
5125  public:
5127  inline std::list<CAntennaConfiguration *>::iterator
5129  {
5130  return m_listAntennaConfiguration.begin();
5131  }
5132 
5134  inline std::list<CAntennaConfiguration *>::iterator
5136  {
5137  return m_listAntennaConfiguration.end();
5138  }
5139 
5141  inline void
5143  {
5144  clearSubParameterList ((tListOfParameters *) &m_listAntennaConfiguration);
5145  }
5146 
5148  inline int
5150  {
5151  return (int) (m_listAntennaConfiguration.size());
5152  }
5153 
5154  EResultCode
5157  CAntennaConfiguration * pValue);
5158 
5159 
5160  protected:
5161  CReaderEventNotificationSpec * m_pReaderEventNotificationSpec;
5162 
5163  public:
5167  {
5168  return m_pReaderEventNotificationSpec;
5169  }
5170 
5172  EResultCode
5174  CReaderEventNotificationSpec * pValue);
5175 
5176 
5177  protected:
5178  CROReportSpec * m_pROReportSpec;
5179 
5180  public:
5182  inline CROReportSpec *
5184  {
5185  return m_pROReportSpec;
5186  }
5187 
5189  EResultCode
5190  setROReportSpec (
5191  CROReportSpec * pValue);
5192 
5193 
5194  protected:
5195  CAccessReportSpec * m_pAccessReportSpec;
5196 
5197  public:
5199  inline CAccessReportSpec *
5201  {
5202  return m_pAccessReportSpec;
5203  }
5204 
5206  EResultCode
5208  CAccessReportSpec * pValue);
5209 
5210 
5211  protected:
5212  CLLRPConfigurationStateValue * m_pLLRPConfigurationStateValue;
5213 
5214  public:
5218  {
5219  return m_pLLRPConfigurationStateValue;
5220  }
5221 
5223  EResultCode
5225  CLLRPConfigurationStateValue * pValue);
5226 
5227 
5228  protected:
5229  CKeepaliveSpec * m_pKeepaliveSpec;
5230 
5231  public:
5233  inline CKeepaliveSpec *
5235  {
5236  return m_pKeepaliveSpec;
5237  }
5238 
5240  EResultCode
5242  CKeepaliveSpec * pValue);
5243 
5244 
5245  protected:
5246  std::list<CGPIPortCurrentState *> m_listGPIPortCurrentState;
5247 
5248  public:
5250  inline std::list<CGPIPortCurrentState *>::iterator
5252  {
5253  return m_listGPIPortCurrentState.begin();
5254  }
5255 
5257  inline std::list<CGPIPortCurrentState *>::iterator
5259  {
5260  return m_listGPIPortCurrentState.end();
5261  }
5262 
5264  inline void
5266  {
5267  clearSubParameterList ((tListOfParameters *) &m_listGPIPortCurrentState);
5268  }
5269 
5271  inline int
5273  {
5274  return (int) (m_listGPIPortCurrentState.size());
5275  }
5276 
5277  EResultCode
5280  CGPIPortCurrentState * pValue);
5281 
5282 
5283  protected:
5284  std::list<CGPOWriteData *> m_listGPOWriteData;
5285 
5286  public:
5288  inline std::list<CGPOWriteData *>::iterator
5290  {
5291  return m_listGPOWriteData.begin();
5292  }
5293 
5295  inline std::list<CGPOWriteData *>::iterator
5297  {
5298  return m_listGPOWriteData.end();
5299  }
5300 
5302  inline void
5304  {
5305  clearSubParameterList ((tListOfParameters *) &m_listGPOWriteData);
5306  }
5307 
5309  inline int
5311  {
5312  return (int) (m_listGPOWriteData.size());
5313  }
5314 
5315  EResultCode
5317  addGPOWriteData (
5318  CGPOWriteData * pValue);
5319 
5320 
5321  protected:
5322  CEventsAndReports * m_pEventsAndReports;
5323 
5324  public:
5326  inline CEventsAndReports *
5328  {
5329  return m_pEventsAndReports;
5330  }
5331 
5333  EResultCode
5335  CEventsAndReports * pValue);
5336 
5337 
5338  protected:
5339  std::list<CParameter *> m_listCustom;
5340 
5341  public:
5343  inline std::list<CParameter *>::iterator
5345  {
5346  return m_listCustom.begin();
5347  }
5348 
5350  inline std::list<CParameter *>::iterator
5351  endCustom (void)
5352  {
5353  return m_listCustom.end();
5354  }
5355 
5357  inline void
5359  {
5360  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5361  }
5362 
5364  inline int
5366  {
5367  return (int) (m_listCustom.size());
5368  }
5369 
5370  EResultCode
5372  addCustom (
5373  CParameter * pValue);
5374 
5375 
5376 };
5377 
5378 
5428 class CSET_READER_CONFIG : public CMessage
5429 {
5430  public:
5431  CSET_READER_CONFIG (void);
5432  ~CSET_READER_CONFIG (void);
5433 
5436 
5437  static const CFieldDescriptor * const
5438  s_apFieldDescriptorTable[];
5439 
5440  static const CTypeDescriptor
5441  s_typeDescriptor;
5442 
5443  void
5444  decodeFields (
5445  CDecoderStream * pDecoderStream);
5446 
5447  void
5448  assimilateSubParameters (
5449  CErrorDetails * pError);
5450 
5451  void
5452  encode (
5453  CEncoderStream * pEncoderStream) const;
5454 
5455 
5456 
5457  static CElement *
5458  s_construct (void);
5459 
5460  static void
5461  s_decodeFields (
5462  CDecoderStream * pDecoderStream,
5463  CElement * pElement);
5465 
5466 
5467  protected:
5468  llrp_u1_t m_ResetToFactoryDefault;
5469 
5472  public:
5473  static const CFieldDescriptor
5474  s_fdResetToFactoryDefault;
5476 
5478  inline llrp_u1_t
5480  {
5481  return m_ResetToFactoryDefault;
5482  }
5483 
5485  inline void
5487  llrp_u1_t value)
5488  {
5489  m_ResetToFactoryDefault = value;
5490  }
5491 
5492 
5493  protected:
5494  CReaderEventNotificationSpec * m_pReaderEventNotificationSpec;
5495 
5496  public:
5500  {
5501  return m_pReaderEventNotificationSpec;
5502  }
5503 
5505  EResultCode
5507  CReaderEventNotificationSpec * pValue);
5508 
5509 
5510  protected:
5511  std::list<CAntennaProperties *> m_listAntennaProperties;
5512 
5513  public:
5515  inline std::list<CAntennaProperties *>::iterator
5517  {
5518  return m_listAntennaProperties.begin();
5519  }
5520 
5522  inline std::list<CAntennaProperties *>::iterator
5524  {
5525  return m_listAntennaProperties.end();
5526  }
5527 
5529  inline void
5531  {
5532  clearSubParameterList ((tListOfParameters *) &m_listAntennaProperties);
5533  }
5534 
5536  inline int
5538  {
5539  return (int) (m_listAntennaProperties.size());
5540  }
5541 
5542  EResultCode
5545  CAntennaProperties * pValue);
5546 
5547 
5548  protected:
5549  std::list<CAntennaConfiguration *> m_listAntennaConfiguration;
5550 
5551  public:
5553  inline std::list<CAntennaConfiguration *>::iterator
5555  {
5556  return m_listAntennaConfiguration.begin();
5557  }
5558 
5560  inline std::list<CAntennaConfiguration *>::iterator
5562  {
5563  return m_listAntennaConfiguration.end();
5564  }
5565 
5567  inline void
5569  {
5570  clearSubParameterList ((tListOfParameters *) &m_listAntennaConfiguration);
5571  }
5572 
5574  inline int
5576  {
5577  return (int) (m_listAntennaConfiguration.size());
5578  }
5579 
5580  EResultCode
5583  CAntennaConfiguration * pValue);
5584 
5585 
5586  protected:
5587  CROReportSpec * m_pROReportSpec;
5588 
5589  public:
5591  inline CROReportSpec *
5593  {
5594  return m_pROReportSpec;
5595  }
5596 
5598  EResultCode
5599  setROReportSpec (
5600  CROReportSpec * pValue);
5601 
5602 
5603  protected:
5604  CAccessReportSpec * m_pAccessReportSpec;
5605 
5606  public:
5608  inline CAccessReportSpec *
5610  {
5611  return m_pAccessReportSpec;
5612  }
5613 
5615  EResultCode
5617  CAccessReportSpec * pValue);
5618 
5619 
5620  protected:
5621  CKeepaliveSpec * m_pKeepaliveSpec;
5622 
5623  public:
5625  inline CKeepaliveSpec *
5627  {
5628  return m_pKeepaliveSpec;
5629  }
5630 
5632  EResultCode
5634  CKeepaliveSpec * pValue);
5635 
5636 
5637  protected:
5638  std::list<CGPOWriteData *> m_listGPOWriteData;
5639 
5640  public:
5642  inline std::list<CGPOWriteData *>::iterator
5644  {
5645  return m_listGPOWriteData.begin();
5646  }
5647 
5649  inline std::list<CGPOWriteData *>::iterator
5651  {
5652  return m_listGPOWriteData.end();
5653  }
5654 
5656  inline void
5658  {
5659  clearSubParameterList ((tListOfParameters *) &m_listGPOWriteData);
5660  }
5661 
5663  inline int
5665  {
5666  return (int) (m_listGPOWriteData.size());
5667  }
5668 
5669  EResultCode
5671  addGPOWriteData (
5672  CGPOWriteData * pValue);
5673 
5674 
5675  protected:
5676  std::list<CGPIPortCurrentState *> m_listGPIPortCurrentState;
5677 
5678  public:
5680  inline std::list<CGPIPortCurrentState *>::iterator
5682  {
5683  return m_listGPIPortCurrentState.begin();
5684  }
5685 
5687  inline std::list<CGPIPortCurrentState *>::iterator
5689  {
5690  return m_listGPIPortCurrentState.end();
5691  }
5692 
5694  inline void
5696  {
5697  clearSubParameterList ((tListOfParameters *) &m_listGPIPortCurrentState);
5698  }
5699 
5701  inline int
5703  {
5704  return (int) (m_listGPIPortCurrentState.size());
5705  }
5706 
5707  EResultCode
5710  CGPIPortCurrentState * pValue);
5711 
5712 
5713  protected:
5714  CEventsAndReports * m_pEventsAndReports;
5715 
5716  public:
5718  inline CEventsAndReports *
5720  {
5721  return m_pEventsAndReports;
5722  }
5723 
5725  EResultCode
5727  CEventsAndReports * pValue);
5728 
5729 
5730  protected:
5731  std::list<CParameter *> m_listCustom;
5732 
5733  public:
5735  inline std::list<CParameter *>::iterator
5737  {
5738  return m_listCustom.begin();
5739  }
5740 
5742  inline std::list<CParameter *>::iterator
5743  endCustom (void)
5744  {
5745  return m_listCustom.end();
5746  }
5747 
5749  inline void
5751  {
5752  clearSubParameterList ((tListOfParameters *) &m_listCustom);
5753  }
5754 
5756  inline int
5758  {
5759  return (int) (m_listCustom.size());
5760  }
5761 
5762  EResultCode
5764  addCustom (
5765  CParameter * pValue);
5766 
5767 
5768 };
5769 
5770 
5801 class CSET_READER_CONFIG_RESPONSE : public CMessage
5802 {
5803  public:
5806 
5809 
5810  static const CFieldDescriptor * const
5811  s_apFieldDescriptorTable[];
5812 
5813  static const CTypeDescriptor
5814  s_typeDescriptor;
5815 
5816  void
5817  decodeFields (
5818  CDecoderStream * pDecoderStream);
5819 
5820  void
5821  assimilateSubParameters (
5822  CErrorDetails * pError);
5823 
5824  void
5825  encode (
5826  CEncoderStream * pEncoderStream) const;
5827 
5828 
5829 
5830  static CElement *
5831  s_construct (void);
5832 
5833  static void
5834  s_decodeFields (
5835  CDecoderStream * pDecoderStream,
5836  CElement * pElement);
5838 
5839 
5840  protected:
5841  CLLRPStatus * m_pLLRPStatus;
5842 
5843  public:
5845  inline CLLRPStatus *
5847  {
5848  return m_pLLRPStatus;
5849  }
5850 
5852  EResultCode
5853  setLLRPStatus (
5854  CLLRPStatus * pValue);
5855 
5856 
5857 };
5858 
5859 
5901 class CCLOSE_CONNECTION : public CMessage
5902 {
5903  public:
5904  CCLOSE_CONNECTION (void);
5905  ~CCLOSE_CONNECTION (void);
5906 
5909 
5910  static const CFieldDescriptor * const
5911  s_apFieldDescriptorTable[];
5912 
5913  static const CTypeDescriptor
5914  s_typeDescriptor;
5915 
5916  void
5917  decodeFields (
5918  CDecoderStream * pDecoderStream);
5919 
5920  void
5921  assimilateSubParameters (
5922  CErrorDetails * pError);
5923 
5924  void
5925  encode (
5926  CEncoderStream * pEncoderStream) const;
5927 
5928 
5929 
5930  static CElement *
5931  s_construct (void);
5932 
5933  static void
5934  s_decodeFields (
5935  CDecoderStream * pDecoderStream,
5936  CElement * pElement);
5938 
5939 
5940 };
5941 
5942 
5977 class CCLOSE_CONNECTION_RESPONSE : public CMessage
5978 {
5979  public:
5982 
5985 
5986  static const CFieldDescriptor * const
5987  s_apFieldDescriptorTable[];
5988 
5989  static const CTypeDescriptor
5990  s_typeDescriptor;
5991 
5992  void
5993  decodeFields (
5994  CDecoderStream * pDecoderStream);
5995 
5996  void
5997  assimilateSubParameters (
5998  CErrorDetails * pError);
5999 
6000  void
6001  encode (
6002  CEncoderStream * pEncoderStream) const;
6003 
6004 
6005 
6006  static CElement *
6007  s_construct (void);
6008 
6009  static void
6010  s_decodeFields (
6011  CDecoderStream * pDecoderStream,
6012  CElement * pElement);
6014 
6015 
6016  protected:
6017  CLLRPStatus * m_pLLRPStatus;
6018 
6019  public:
6021  inline CLLRPStatus *
6023  {
6024  return m_pLLRPStatus;
6025  }
6026 
6028  EResultCode
6029  setLLRPStatus (
6030  CLLRPStatus * pValue);
6031 
6032 
6033 };
6034 
6035 
6067 class CGET_REPORT : public CMessage
6068 {
6069  public:
6070  CGET_REPORT (void);
6071  ~CGET_REPORT (void);
6072 
6075 
6076  static const CFieldDescriptor * const
6077  s_apFieldDescriptorTable[];
6078 
6079  static const CTypeDescriptor
6080  s_typeDescriptor;
6081 
6082  void
6083  decodeFields (
6084  CDecoderStream * pDecoderStream);
6085 
6086  void
6087  assimilateSubParameters (
6088  CErrorDetails * pError);
6089 
6090  void
6091  encode (
6092  CEncoderStream * pEncoderStream) const;
6093 
6094 
6095 
6096  static CElement *
6097  s_construct (void);
6098 
6099  static void
6100  s_decodeFields (
6101  CDecoderStream * pDecoderStream,
6102  CElement * pElement);
6104 
6105 
6106 };
6107 
6108 
6141 class CRO_ACCESS_REPORT : public CMessage
6142 {
6143  public:
6144  CRO_ACCESS_REPORT (void);
6145  ~CRO_ACCESS_REPORT (void);
6146 
6149 
6150  static const CFieldDescriptor * const
6151  s_apFieldDescriptorTable[];
6152 
6153  static const CTypeDescriptor
6154  s_typeDescriptor;
6155 
6156  void
6157  decodeFields (
6158  CDecoderStream * pDecoderStream);
6159 
6160  void
6161  assimilateSubParameters (
6162  CErrorDetails * pError);
6163 
6164  void
6165  encode (
6166  CEncoderStream * pEncoderStream) const;
6167 
6168 
6169 
6170  static CElement *
6171  s_construct (void);
6172 
6173  static void
6174  s_decodeFields (
6175  CDecoderStream * pDecoderStream,
6176  CElement * pElement);
6178 
6179 
6180  protected:
6181  std::list<CTagReportData *> m_listTagReportData;
6182 
6183  public:
6185  inline std::list<CTagReportData *>::iterator
6187  {
6188  return m_listTagReportData.begin();
6189  }
6190 
6192  inline std::list<CTagReportData *>::iterator
6194  {
6195  return m_listTagReportData.end();
6196  }
6197 
6199  inline void
6201  {
6202  clearSubParameterList ((tListOfParameters *) &m_listTagReportData);
6203  }
6204 
6206  inline int
6208  {
6209  return (int) (m_listTagReportData.size());
6210  }
6211 
6212  EResultCode
6215  CTagReportData * pValue);
6216 
6217 
6218  protected:
6219  std::list<CRFSurveyReportData *> m_listRFSurveyReportData;
6220 
6221  public:
6223  inline std::list<CRFSurveyReportData *>::iterator
6225  {
6226  return m_listRFSurveyReportData.begin();
6227  }
6228 
6230  inline std::list<CRFSurveyReportData *>::iterator
6232  {
6233  return m_listRFSurveyReportData.end();
6234  }
6235 
6237  inline void
6239  {
6240  clearSubParameterList ((tListOfParameters *) &m_listRFSurveyReportData);
6241  }
6242 
6244  inline int
6246  {
6247  return (int) (m_listRFSurveyReportData.size());
6248  }
6249 
6250  EResultCode
6253  CRFSurveyReportData * pValue);
6254 
6255 
6256  protected:
6257  std::list<CParameter *> m_listCustom;
6258 
6259  public:
6261  inline std::list<CParameter *>::iterator
6263  {
6264  return m_listCustom.begin();
6265  }
6266 
6268  inline std::list<CParameter *>::iterator
6269  endCustom (void)
6270  {
6271  return m_listCustom.end();
6272  }
6273 
6275  inline void
6277  {
6278  clearSubParameterList ((tListOfParameters *) &m_listCustom);
6279  }
6280 
6282  inline int
6284  {
6285  return (int) (m_listCustom.size());
6286  }
6287 
6288  EResultCode
6290  addCustom (
6291  CParameter * pValue);
6292 
6293 
6294 };
6295 
6296 
6326 class CKEEPALIVE : public CMessage
6327 {
6328  public:
6329  CKEEPALIVE (void);
6330  ~CKEEPALIVE (void);
6331 
6334 
6335  static const CFieldDescriptor * const
6336  s_apFieldDescriptorTable[];
6337 
6338  static const CTypeDescriptor
6339  s_typeDescriptor;
6340 
6341  void
6342  decodeFields (
6343  CDecoderStream * pDecoderStream);
6344 
6345  void
6346  assimilateSubParameters (
6347  CErrorDetails * pError);
6348 
6349  void
6350  encode (
6351  CEncoderStream * pEncoderStream) const;
6352 
6353 
6354 
6355  static CElement *
6356  s_construct (void);
6357 
6358  static void
6359  s_decodeFields (
6360  CDecoderStream * pDecoderStream,
6361  CElement * pElement);
6363 
6364 
6365 };
6366 
6367 
6399 class CKEEPALIVE_ACK : public CMessage
6400 {
6401  public:
6402  CKEEPALIVE_ACK (void);
6403  ~CKEEPALIVE_ACK (void);
6404 
6407 
6408  static const CFieldDescriptor * const
6409  s_apFieldDescriptorTable[];
6410 
6411  static const CTypeDescriptor
6412  s_typeDescriptor;
6413 
6414  void
6415  decodeFields (
6416  CDecoderStream * pDecoderStream);
6417 
6418  void
6419  assimilateSubParameters (
6420  CErrorDetails * pError);
6421 
6422  void
6423  encode (
6424  CEncoderStream * pEncoderStream) const;
6425 
6426 
6427 
6428  static CElement *
6429  s_construct (void);
6430 
6431  static void
6432  s_decodeFields (
6433  CDecoderStream * pDecoderStream,
6434  CElement * pElement);
6436 
6437 
6438 };
6439 
6440 
6471 class CREADER_EVENT_NOTIFICATION : public CMessage
6472 {
6473  public:
6476 
6479 
6480  static const CFieldDescriptor * const
6481  s_apFieldDescriptorTable[];
6482 
6483  static const CTypeDescriptor
6484  s_typeDescriptor;
6485 
6486  void
6487  decodeFields (
6488  CDecoderStream * pDecoderStream);
6489 
6490  void
6491  assimilateSubParameters (
6492  CErrorDetails * pError);
6493 
6494  void
6495  encode (
6496  CEncoderStream * pEncoderStream) const;
6497 
6498 
6499 
6500  static CElement *
6501  s_construct (void);
6502 
6503  static void
6504  s_decodeFields (
6505  CDecoderStream * pDecoderStream,
6506  CElement * pElement);
6508 
6509 
6510  protected:
6511  CReaderEventNotificationData * m_pReaderEventNotificationData;
6512 
6513  public:
6517  {
6518  return m_pReaderEventNotificationData;
6519  }
6520 
6522  EResultCode
6524  CReaderEventNotificationData * pValue);
6525 
6526 
6527 };
6528 
6529 
6559 class CENABLE_EVENTS_AND_REPORTS : public CMessage
6560 {
6561  public:
6564 
6567 
6568  static const CFieldDescriptor * const
6569  s_apFieldDescriptorTable[];
6570 
6571  static const CTypeDescriptor
6572  s_typeDescriptor;
6573 
6574  void
6575  decodeFields (
6576  CDecoderStream * pDecoderStream);
6577 
6578  void
6579  assimilateSubParameters (
6580  CErrorDetails * pError);
6581 
6582  void
6583  encode (
6584  CEncoderStream * pEncoderStream) const;
6585 
6586 
6587 
6588  static CElement *
6589  s_construct (void);
6590 
6591  static void
6592  s_decodeFields (
6593  CDecoderStream * pDecoderStream,
6594  CElement * pElement);
6596 
6597 
6598 };
6599 
6600 
6659 class CERROR_MESSAGE : public CMessage
6660 {
6661  public:
6662  CERROR_MESSAGE (void);
6663  ~CERROR_MESSAGE (void);
6664 
6667 
6668  static const CFieldDescriptor * const
6669  s_apFieldDescriptorTable[];
6670 
6671  static const CTypeDescriptor
6672  s_typeDescriptor;
6673 
6674  void
6675  decodeFields (
6676  CDecoderStream * pDecoderStream);
6677 
6678  void
6679  assimilateSubParameters (
6680  CErrorDetails * pError);
6681 
6682  void
6683  encode (
6684  CEncoderStream * pEncoderStream) const;
6685 
6686 
6687 
6688  static CElement *
6689  s_construct (void);
6690 
6691  static void
6692  s_decodeFields (
6693  CDecoderStream * pDecoderStream,
6694  CElement * pElement);
6696 
6697 
6698  protected:
6699  CLLRPStatus * m_pLLRPStatus;
6700 
6701  public:
6703  inline CLLRPStatus *
6705  {
6706  return m_pLLRPStatus;
6707  }
6708 
6710  EResultCode
6711  setLLRPStatus (
6712  CLLRPStatus * pValue);
6713 
6714 
6715 };
6716 
6717 
6725 
6760 class CUTCTimestamp : public CParameter
6761 {
6762  public:
6763  CUTCTimestamp (void);
6764  ~CUTCTimestamp (void);
6765 
6768 
6769  static const CFieldDescriptor * const
6770  s_apFieldDescriptorTable[];
6771 
6772  static const CTypeDescriptor
6773  s_typeDescriptor;
6774 
6775  void
6776  decodeFields (
6777  CDecoderStream * pDecoderStream);
6778 
6779  void
6780  assimilateSubParameters (
6781  CErrorDetails * pError);
6782 
6783  void
6784  encode (
6785  CEncoderStream * pEncoderStream) const;
6786 
6787 
6788 
6789  static CElement *
6790  s_construct (void);
6791 
6792  static void
6793  s_decodeFields (
6794  CDecoderStream * pDecoderStream,
6795  CElement * pElement);
6797 
6798 
6799  protected:
6800  llrp_u64_t m_Microseconds;
6801 
6804  public:
6805  static const CFieldDescriptor
6806  s_fdMicroseconds;
6808 
6810  inline llrp_u64_t
6812  {
6813  return m_Microseconds;
6814  }
6815 
6817  inline void
6819  llrp_u64_t value)
6820  {
6821  m_Microseconds = value;
6822  }
6823 
6824 
6825 };
6826 
6827 
6862 class CUptime : public CParameter
6863 {
6864  public:
6865  CUptime (void);
6866  ~CUptime (void);
6867 
6870 
6871  static const CFieldDescriptor * const
6872  s_apFieldDescriptorTable[];
6873 
6874  static const CTypeDescriptor
6875  s_typeDescriptor;
6876 
6877  void
6878  decodeFields (
6879  CDecoderStream * pDecoderStream);
6880 
6881  void
6882  assimilateSubParameters (
6883  CErrorDetails * pError);
6884 
6885  void
6886  encode (
6887  CEncoderStream * pEncoderStream) const;
6888 
6889 
6890 
6891  static CElement *
6892  s_construct (void);
6893 
6894  static void
6895  s_decodeFields (
6896  CDecoderStream * pDecoderStream,
6897  CElement * pElement);
6899 
6900 
6901  protected:
6902  llrp_u64_t m_Microseconds;
6903 
6906  public:
6907  static const CFieldDescriptor
6908  s_fdMicroseconds;
6910 
6912  inline llrp_u64_t
6914  {
6915  return m_Microseconds;
6916  }
6917 
6919  inline void
6921  llrp_u64_t value)
6922  {
6923  m_Microseconds = value;
6924  }
6925 
6926 
6927 };
6928 
6929 
6973 class CCustom : public CParameter
6974 {
6975  public:
6976  CCustom (void);
6977  ~CCustom (void);
6978 
6981 
6982  static const CFieldDescriptor * const
6983  s_apFieldDescriptorTable[];
6984 
6985  static const CTypeDescriptor
6986  s_typeDescriptor;
6987 
6988  void
6989  decodeFields (
6990  CDecoderStream * pDecoderStream);
6991 
6992  void
6993  assimilateSubParameters (
6994  CErrorDetails * pError);
6995 
6996  void
6997  encode (
6998  CEncoderStream * pEncoderStream) const;
6999 
7000 
7001 
7002  static CElement *
7003  s_construct (void);
7004 
7005  static void
7006  s_decodeFields (
7007  CDecoderStream * pDecoderStream,
7008  CElement * pElement);
7010 
7011 
7012  protected:
7013  llrp_u32_t m_VendorIdentifier;
7014 
7017  public:
7018  static const CFieldDescriptor
7019  s_fdVendorIdentifier;
7021 
7023  inline llrp_u32_t
7025  {
7026  return m_VendorIdentifier;
7027  }
7028 
7030  inline void
7032  llrp_u32_t value)
7033  {
7034  m_VendorIdentifier = value;
7035  }
7036 
7037 
7038  protected:
7039  llrp_u32_t m_ParameterSubtype;
7040 
7043  public:
7044  static const CFieldDescriptor
7045  s_fdParameterSubtype;
7047 
7049  inline llrp_u32_t
7051  {
7052  return m_ParameterSubtype;
7053  }
7054 
7056  inline void
7058  llrp_u32_t value)
7059  {
7060  m_ParameterSubtype = value;
7061  }
7062 
7063 
7064  protected:
7065  llrp_bytesToEnd_t m_Data;
7066 
7069  public:
7070  static const CFieldDescriptor
7071  s_fdData;
7073 
7075  inline llrp_bytesToEnd_t
7076  getData (void)
7077  {
7078  return m_Data;
7079  }
7080 
7082  inline void
7084  llrp_bytesToEnd_t value)
7085  {
7086  m_Data = value;
7087  }
7088 
7089 
7090 };
7091 
7092 
7133 class CGeneralDeviceCapabilities : public CParameter
7134 {
7135  public:
7138 
7141 
7142  static const CFieldDescriptor * const
7143  s_apFieldDescriptorTable[];
7144 
7145  static const CTypeDescriptor
7146  s_typeDescriptor;
7147 
7148  void
7149  decodeFields (
7150  CDecoderStream * pDecoderStream);
7151 
7152  void
7153  assimilateSubParameters (
7154  CErrorDetails * pError);
7155 
7156  void
7157  encode (
7158  CEncoderStream * pEncoderStream) const;
7159 
7160 
7161 
7162  static CElement *
7163  s_construct (void);
7164 
7165  static void
7166  s_decodeFields (
7167  CDecoderStream * pDecoderStream,
7168  CElement * pElement);
7170 
7171 
7172  protected:
7173  llrp_u16_t m_MaxNumberOfAntennaSupported;
7174 
7177  public:
7178  static const CFieldDescriptor
7179  s_fdMaxNumberOfAntennaSupported;
7181 
7183  inline llrp_u16_t
7185  {
7186  return m_MaxNumberOfAntennaSupported;
7187  }
7188 
7190  inline void
7192  llrp_u16_t value)
7193  {
7194  m_MaxNumberOfAntennaSupported = value;
7195  }
7196 
7197 
7198  protected:
7199  llrp_u1_t m_CanSetAntennaProperties;
7200 
7203  public:
7204  static const CFieldDescriptor
7205  s_fdCanSetAntennaProperties;
7207 
7209  inline llrp_u1_t
7211  {
7212  return m_CanSetAntennaProperties;
7213  }
7214 
7216  inline void
7218  llrp_u1_t value)
7219  {
7220  m_CanSetAntennaProperties = value;
7221  }
7222 
7223 
7224  protected:
7225  llrp_u1_t m_HasUTCClockCapability;
7226 
7229  public:
7230  static const CFieldDescriptor
7231  s_fdHasUTCClockCapability;
7233 
7235  inline llrp_u1_t
7237  {
7238  return m_HasUTCClockCapability;
7239  }
7240 
7242  inline void
7244  llrp_u1_t value)
7245  {
7246  m_HasUTCClockCapability = value;
7247  }
7248 
7249 
7250  protected:
7251  llrp_u32_t m_DeviceManufacturerName;
7252 
7255  public:
7256  static const CFieldDescriptor
7257  s_fdDeviceManufacturerName;
7259 
7261  inline llrp_u32_t
7263  {
7264  return m_DeviceManufacturerName;
7265  }
7266 
7268  inline void
7270  llrp_u32_t value)
7271  {
7272  m_DeviceManufacturerName = value;
7273  }
7274 
7275 
7276  protected:
7277  llrp_u32_t m_ModelName;
7278 
7281  public:
7282  static const CFieldDescriptor
7283  s_fdModelName;
7285 
7287  inline llrp_u32_t
7289  {
7290  return m_ModelName;
7291  }
7292 
7294  inline void
7296  llrp_u32_t value)
7297  {
7298  m_ModelName = value;
7299  }
7300 
7301 
7302  protected:
7303  llrp_utf8v_t m_ReaderFirmwareVersion;
7304 
7307  public:
7308  static const CFieldDescriptor
7309  s_fdReaderFirmwareVersion;
7311 
7313  inline llrp_utf8v_t
7315  {
7316  return m_ReaderFirmwareVersion;
7317  }
7318 
7320  inline void
7322  llrp_utf8v_t value)
7323  {
7324  m_ReaderFirmwareVersion = value;
7325  }
7326 
7327 
7328  protected:
7329  std::list<CReceiveSensitivityTableEntry *> m_listReceiveSensitivityTableEntry;
7330 
7331  public:
7333  inline std::list<CReceiveSensitivityTableEntry *>::iterator
7335  {
7336  return m_listReceiveSensitivityTableEntry.begin();
7337  }
7338 
7340  inline std::list<CReceiveSensitivityTableEntry *>::iterator
7342  {
7343  return m_listReceiveSensitivityTableEntry.end();
7344  }
7345 
7347  inline void
7349  {
7350  clearSubParameterList ((tListOfParameters *) &m_listReceiveSensitivityTableEntry);
7351  }
7352 
7354  inline int
7356  {
7357  return (int) (m_listReceiveSensitivityTableEntry.size());
7358  }
7359 
7360  EResultCode
7364 
7365 
7366  protected:
7367  std::list<CPerAntennaReceiveSensitivityRange *> m_listPerAntennaReceiveSensitivityRange;
7368 
7369  public:
7371  inline std::list<CPerAntennaReceiveSensitivityRange *>::iterator
7373  {
7374  return m_listPerAntennaReceiveSensitivityRange.begin();
7375  }
7376 
7378  inline std::list<CPerAntennaReceiveSensitivityRange *>::iterator
7380  {
7381  return m_listPerAntennaReceiveSensitivityRange.end();
7382  }
7383 
7385  inline void
7387  {
7388  clearSubParameterList ((tListOfParameters *) &m_listPerAntennaReceiveSensitivityRange);
7389  }
7390 
7392  inline int
7394  {
7395  return (int) (m_listPerAntennaReceiveSensitivityRange.size());
7396  }
7397 
7398  EResultCode
7402 
7403 
7404  protected:
7405  CGPIOCapabilities * m_pGPIOCapabilities;
7406 
7407  public:
7409  inline CGPIOCapabilities *
7411  {
7412  return m_pGPIOCapabilities;
7413  }
7414 
7416  EResultCode
7418  CGPIOCapabilities * pValue);
7419 
7420 
7421  protected:
7422  std::list<CPerAntennaAirProtocol *> m_listPerAntennaAirProtocol;
7423 
7424  public:
7426  inline std::list<CPerAntennaAirProtocol *>::iterator
7428  {
7429  return m_listPerAntennaAirProtocol.begin();
7430  }
7431 
7433  inline std::list<CPerAntennaAirProtocol *>::iterator
7435  {
7436  return m_listPerAntennaAirProtocol.end();
7437  }
7438 
7440  inline void
7442  {
7443  clearSubParameterList ((tListOfParameters *) &m_listPerAntennaAirProtocol);
7444  }
7445 
7447  inline int
7449  {
7450  return (int) (m_listPerAntennaAirProtocol.size());
7451  }
7452 
7453  EResultCode
7456  CPerAntennaAirProtocol * pValue);
7457 
7458 
7459 };
7460 
7461 
7496 class CReceiveSensitivityTableEntry : public CParameter
7497 {
7498  public:
7501 
7504 
7505  static const CFieldDescriptor * const
7506  s_apFieldDescriptorTable[];
7507 
7508  static const CTypeDescriptor
7509  s_typeDescriptor;
7510 
7511  void
7512  decodeFields (
7513  CDecoderStream * pDecoderStream);
7514 
7515  void
7516  assimilateSubParameters (
7517  CErrorDetails * pError);
7518 
7519  void
7520  encode (
7521  CEncoderStream * pEncoderStream) const;
7522 
7523 
7524 
7525  static CElement *
7526  s_construct (void);
7527 
7528  static void
7529  s_decodeFields (
7530  CDecoderStream * pDecoderStream,
7531  CElement * pElement);
7533 
7534 
7535  protected:
7536  llrp_u16_t m_Index;
7537 
7540  public:
7541  static const CFieldDescriptor
7542  s_fdIndex;
7544 
7546  inline llrp_u16_t
7547  getIndex (void)
7548  {
7549  return m_Index;
7550  }
7551 
7553  inline void
7555  llrp_u16_t value)
7556  {
7557  m_Index = value;
7558  }
7559 
7560 
7561  protected:
7562  llrp_s16_t m_ReceiveSensitivityValue;
7563 
7566  public:
7567  static const CFieldDescriptor
7568  s_fdReceiveSensitivityValue;
7570 
7572  inline llrp_s16_t
7574  {
7575  return m_ReceiveSensitivityValue;
7576  }
7577 
7579  inline void
7581  llrp_s16_t value)
7582  {
7583  m_ReceiveSensitivityValue = value;
7584  }
7585 
7586 
7587 };
7588 
7589 
7627 class CPerAntennaReceiveSensitivityRange : public CParameter
7628 {
7629  public:
7632 
7635 
7636  static const CFieldDescriptor * const
7637  s_apFieldDescriptorTable[];
7638 
7639  static const CTypeDescriptor
7640  s_typeDescriptor;
7641 
7642  void
7643  decodeFields (
7644  CDecoderStream * pDecoderStream);
7645 
7646  void
7647  assimilateSubParameters (
7648  CErrorDetails * pError);
7649 
7650  void
7651  encode (
7652  CEncoderStream * pEncoderStream) const;
7653 
7654 
7655 
7656  static CElement *
7657  s_construct (void);
7658 
7659  static void
7660  s_decodeFields (
7661  CDecoderStream * pDecoderStream,
7662  CElement * pElement);
7664 
7665 
7666  protected:
7667  llrp_u16_t m_AntennaID;
7668 
7671  public:
7672  static const CFieldDescriptor
7673  s_fdAntennaID;
7675 
7677  inline llrp_u16_t
7679  {
7680  return m_AntennaID;
7681  }
7682 
7684  inline void
7686  llrp_u16_t value)
7687  {
7688  m_AntennaID = value;
7689  }
7690 
7691 
7692  protected:
7693  llrp_u16_t m_ReceiveSensitivityIndexMin;
7694 
7697  public:
7698  static const CFieldDescriptor
7699  s_fdReceiveSensitivityIndexMin;
7701 
7703  inline llrp_u16_t
7705  {
7706  return m_ReceiveSensitivityIndexMin;
7707  }
7708 
7710  inline void
7712  llrp_u16_t value)
7713  {
7714  m_ReceiveSensitivityIndexMin = value;
7715  }
7716 
7717 
7718  protected:
7719  llrp_u16_t m_ReceiveSensitivityIndexMax;
7720 
7723  public:
7724  static const CFieldDescriptor
7725  s_fdReceiveSensitivityIndexMax;
7727 
7729  inline llrp_u16_t
7731  {
7732  return m_ReceiveSensitivityIndexMax;
7733  }
7734 
7736  inline void
7738  llrp_u16_t value)
7739  {
7740  m_ReceiveSensitivityIndexMax = value;
7741  }
7742 
7743 
7744 };
7745 
7746 
7778 class CPerAntennaAirProtocol : public CParameter
7779 {
7780  public:
7781  CPerAntennaAirProtocol (void);
7782  ~CPerAntennaAirProtocol (void);
7783 
7786 
7787  static const CFieldDescriptor * const
7788  s_apFieldDescriptorTable[];
7789 
7790  static const CTypeDescriptor
7791  s_typeDescriptor;
7792 
7793  void
7794  decodeFields (
7795  CDecoderStream * pDecoderStream);
7796 
7797  void
7798  assimilateSubParameters (
7799  CErrorDetails * pError);
7800 
7801  void
7802  encode (
7803  CEncoderStream * pEncoderStream) const;
7804 
7805 
7806 
7807  static CElement *
7808  s_construct (void);
7809 
7810  static void
7811  s_decodeFields (
7812  CDecoderStream * pDecoderStream,
7813  CElement * pElement);
7815 
7816 
7817  protected:
7818  llrp_u16_t m_AntennaID;
7819 
7822  public:
7823  static const CFieldDescriptor
7824  s_fdAntennaID;
7826 
7828  inline llrp_u16_t
7830  {
7831  return m_AntennaID;
7832  }
7833 
7835  inline void
7837  llrp_u16_t value)
7838  {
7839  m_AntennaID = value;
7840  }
7841 
7842 
7843  protected:
7844  llrp_u8v_t m_ProtocolID;
7845 
7848  public:
7849  static const CFieldDescriptor
7850  s_fdProtocolID;
7852 
7854  inline llrp_u8v_t
7856  {
7857  return m_ProtocolID;
7858  }
7859 
7861  inline void
7863  llrp_u8v_t value)
7864  {
7865  m_ProtocolID = value;
7866  }
7867 
7868 
7869 };
7870 
7871 
7903 class CGPIOCapabilities : public CParameter
7904 {
7905  public:
7906  CGPIOCapabilities (void);
7907  ~CGPIOCapabilities (void);
7908 
7911 
7912  static const CFieldDescriptor * const
7913  s_apFieldDescriptorTable[];
7914 
7915  static const CTypeDescriptor
7916  s_typeDescriptor;
7917 
7918  void
7919  decodeFields (
7920  CDecoderStream * pDecoderStream);
7921 
7922  void
7923  assimilateSubParameters (
7924  CErrorDetails * pError);
7925 
7926  void
7927  encode (
7928  CEncoderStream * pEncoderStream) const;
7929 
7930 
7931 
7932  static CElement *
7933  s_construct (void);
7934 
7935  static void
7936  s_decodeFields (
7937  CDecoderStream * pDecoderStream,
7938  CElement * pElement);
7940 
7941 
7942  protected:
7943  llrp_u16_t m_NumGPIs;
7944 
7947  public:
7948  static const CFieldDescriptor
7949  s_fdNumGPIs;
7951 
7953  inline llrp_u16_t
7954  getNumGPIs (void)
7955  {
7956  return m_NumGPIs;
7957  }
7958 
7960  inline void
7962  llrp_u16_t value)
7963  {
7964  m_NumGPIs = value;
7965  }
7966 
7967 
7968  protected:
7969  llrp_u16_t m_NumGPOs;
7970 
7973  public:
7974  static const CFieldDescriptor
7975  s_fdNumGPOs;
7977 
7979  inline llrp_u16_t
7980  getNumGPOs (void)
7981  {
7982  return m_NumGPOs;
7983  }
7984 
7986  inline void
7988  llrp_u16_t value)
7989  {
7990  m_NumGPOs = value;
7991  }
7992 
7993 
7994 };
7995 
7996 
8056 class CLLRPCapabilities : public CParameter
8057 {
8058  public:
8059  CLLRPCapabilities (void);
8060  ~CLLRPCapabilities (void);
8061 
8064 
8065  static const CFieldDescriptor * const
8066  s_apFieldDescriptorTable[];
8067 
8068  static const CTypeDescriptor
8069  s_typeDescriptor;
8070 
8071  void
8072  decodeFields (
8073  CDecoderStream * pDecoderStream);
8074 
8075  void
8076  assimilateSubParameters (
8077  CErrorDetails * pError);
8078 
8079  void
8080  encode (
8081  CEncoderStream * pEncoderStream) const;
8082 
8083 
8084 
8085  static CElement *
8086  s_construct (void);
8087 
8088  static void
8089  s_decodeFields (
8090  CDecoderStream * pDecoderStream,
8091  CElement * pElement);
8093 
8094 
8095  protected:
8096  llrp_u1_t m_CanDoRFSurvey;
8097 
8100  public:
8101  static const CFieldDescriptor
8102  s_fdCanDoRFSurvey;
8104 
8106  inline llrp_u1_t
8108  {
8109  return m_CanDoRFSurvey;
8110  }
8111 
8113  inline void
8115  llrp_u1_t value)
8116  {
8117  m_CanDoRFSurvey = value;
8118  }
8119 
8120 
8121  protected:
8122  llrp_u1_t m_CanReportBufferFillWarning;
8123 
8126  public:
8127  static const CFieldDescriptor
8128  s_fdCanReportBufferFillWarning;
8130 
8132  inline llrp_u1_t
8134  {
8135  return m_CanReportBufferFillWarning;
8136  }
8137 
8139  inline void
8141  llrp_u1_t value)
8142  {
8143  m_CanReportBufferFillWarning = value;
8144  }
8145 
8146 
8147  protected:
8148  llrp_u1_t m_SupportsClientRequestOpSpec;
8149 
8152  public:
8153  static const CFieldDescriptor
8154  s_fdSupportsClientRequestOpSpec;
8156 
8158  inline llrp_u1_t
8160  {
8161  return m_SupportsClientRequestOpSpec;
8162  }
8163 
8165  inline void
8167  llrp_u1_t value)
8168  {
8169  m_SupportsClientRequestOpSpec = value;
8170  }
8171 
8172 
8173  protected:
8174  llrp_u1_t m_CanDoTagInventoryStateAwareSingulation;
8175 
8178  public:
8179  static const CFieldDescriptor
8180  s_fdCanDoTagInventoryStateAwareSingulation;
8182 
8184  inline llrp_u1_t
8186  {
8187  return m_CanDoTagInventoryStateAwareSingulation;
8188  }
8189 
8191  inline void
8193  llrp_u1_t value)
8194  {
8195  m_CanDoTagInventoryStateAwareSingulation = value;
8196  }
8197 
8198 
8199  protected:
8200  llrp_u1_t m_SupportsEventAndReportHolding;
8201 
8204  public:
8205  static const CFieldDescriptor
8206  s_fdSupportsEventAndReportHolding;
8208 
8210  inline llrp_u1_t
8212  {
8213  return m_SupportsEventAndReportHolding;
8214  }
8215 
8217  inline void
8219  llrp_u1_t value)
8220  {
8221  m_SupportsEventAndReportHolding = value;
8222  }
8223 
8224 
8225  protected:
8226  llrp_u8_t m_MaxNumPriorityLevelsSupported;
8227 
8230  public:
8231  static const CFieldDescriptor
8232  s_fdMaxNumPriorityLevelsSupported;
8234 
8236  inline llrp_u8_t
8238  {
8239  return m_MaxNumPriorityLevelsSupported;
8240  }
8241 
8243  inline void
8245  llrp_u8_t value)
8246  {
8247  m_MaxNumPriorityLevelsSupported = value;
8248  }
8249 
8250 
8251  protected:
8252  llrp_u16_t m_ClientRequestOpSpecTimeout;
8253 
8256  public:
8257  static const CFieldDescriptor
8258  s_fdClientRequestOpSpecTimeout;
8260 
8262  inline llrp_u16_t
8264  {
8265  return m_ClientRequestOpSpecTimeout;
8266  }
8267 
8269  inline void
8271  llrp_u16_t value)
8272  {
8273  m_ClientRequestOpSpecTimeout = value;
8274  }
8275 
8276 
8277  protected:
8278  llrp_u32_t m_MaxNumROSpecs;
8279 
8282  public:
8283  static const CFieldDescriptor
8284  s_fdMaxNumROSpecs;
8286 
8288  inline llrp_u32_t
8290  {
8291  return m_MaxNumROSpecs;
8292  }
8293 
8295  inline void
8297  llrp_u32_t value)
8298  {
8299  m_MaxNumROSpecs = value;
8300  }
8301 
8302 
8303  protected:
8304  llrp_u32_t m_MaxNumSpecsPerROSpec;
8305 
8308  public:
8309  static const CFieldDescriptor
8310  s_fdMaxNumSpecsPerROSpec;
8312 
8314  inline llrp_u32_t
8316  {
8317  return m_MaxNumSpecsPerROSpec;
8318  }
8319 
8321  inline void
8323  llrp_u32_t value)
8324  {
8325  m_MaxNumSpecsPerROSpec = value;
8326  }
8327 
8328 
8329  protected:
8330  llrp_u32_t m_MaxNumInventoryParameterSpecsPerAISpec;
8331 
8334  public:
8335  static const CFieldDescriptor
8336  s_fdMaxNumInventoryParameterSpecsPerAISpec;
8338 
8340  inline llrp_u32_t
8342  {
8343  return m_MaxNumInventoryParameterSpecsPerAISpec;
8344  }
8345 
8347  inline void
8349  llrp_u32_t value)
8350  {
8351  m_MaxNumInventoryParameterSpecsPerAISpec = value;
8352  }
8353 
8354 
8355  protected:
8356  llrp_u32_t m_MaxNumAccessSpecs;
8357 
8360  public:
8361  static const CFieldDescriptor
8362  s_fdMaxNumAccessSpecs;
8364 
8366  inline llrp_u32_t
8368  {
8369  return m_MaxNumAccessSpecs;
8370  }
8371 
8373  inline void
8375  llrp_u32_t value)
8376  {
8377  m_MaxNumAccessSpecs = value;
8378  }
8379 
8380 
8381  protected:
8382  llrp_u32_t m_MaxNumOpSpecsPerAccessSpec;
8383 
8386  public:
8387  static const CFieldDescriptor
8388  s_fdMaxNumOpSpecsPerAccessSpec;
8390 
8392  inline llrp_u32_t
8394  {
8395  return m_MaxNumOpSpecsPerAccessSpec;
8396  }
8397 
8399  inline void
8401  llrp_u32_t value)
8402  {
8403  m_MaxNumOpSpecsPerAccessSpec = value;
8404  }
8405 
8406 
8407 };
8408 
8409 
8446 class CRegulatoryCapabilities : public CParameter
8447 {
8448  public:
8449  CRegulatoryCapabilities (void);
8450  ~CRegulatoryCapabilities (void);
8451 
8454 
8455  static const CFieldDescriptor * const
8456  s_apFieldDescriptorTable[];
8457 
8458  static const CTypeDescriptor
8459  s_typeDescriptor;
8460 
8461  void
8462  decodeFields (
8463  CDecoderStream * pDecoderStream);
8464 
8465  void
8466  assimilateSubParameters (
8467  CErrorDetails * pError);
8468 
8469  void
8470  encode (
8471  CEncoderStream * pEncoderStream) const;
8472 
8473 
8474 
8475  static CElement *
8476  s_construct (void);
8477 
8478  static void
8479  s_decodeFields (
8480  CDecoderStream * pDecoderStream,
8481  CElement * pElement);
8483 
8484 
8485  protected:
8486  llrp_u16_t m_CountryCode;
8487 
8490  public:
8491  static const CFieldDescriptor
8492  s_fdCountryCode;
8494 
8496  inline llrp_u16_t
8498  {
8499  return m_CountryCode;
8500  }
8501 
8503  inline void
8505  llrp_u16_t value)
8506  {
8507  m_CountryCode = value;
8508  }
8509 
8510 
8511  protected:
8512  ECommunicationsStandard m_eCommunicationsStandard;
8513 
8516  public:
8517  static const CFieldDescriptor
8518  s_fdCommunicationsStandard;
8520 
8522  inline ECommunicationsStandard
8524  {
8525  return m_eCommunicationsStandard;
8526  }
8527 
8529  inline void
8531  ECommunicationsStandard value)
8532  {
8533  m_eCommunicationsStandard = value;
8534  }
8535 
8536 
8537  protected:
8538  CUHFBandCapabilities * m_pUHFBandCapabilities;
8539 
8540  public:
8542  inline CUHFBandCapabilities *
8544  {
8545  return m_pUHFBandCapabilities;
8546  }
8547 
8549  EResultCode
8551  CUHFBandCapabilities * pValue);
8552 
8553 
8554  protected:
8555  std::list<CParameter *> m_listCustom;
8556 
8557  public:
8559  inline std::list<CParameter *>::iterator
8561  {
8562  return m_listCustom.begin();
8563  }
8564 
8566  inline std::list<CParameter *>::iterator
8567  endCustom (void)
8568  {
8569  return m_listCustom.end();
8570  }
8571 
8573  inline void
8575  {
8576  clearSubParameterList ((tListOfParameters *) &m_listCustom);
8577  }
8578 
8580  inline int
8582  {
8583  return (int) (m_listCustom.size());
8584  }
8585 
8586  EResultCode
8588  addCustom (
8589  CParameter * pValue);
8590 
8591 
8592 };
8593 
8594 
8627 class CUHFBandCapabilities : public CParameter
8628 {
8629  public:
8630  CUHFBandCapabilities (void);
8631  ~CUHFBandCapabilities (void);
8632 
8635 
8636  static const CFieldDescriptor * const
8637  s_apFieldDescriptorTable[];
8638 
8639  static const CTypeDescriptor
8640  s_typeDescriptor;
8641 
8642  void
8643  decodeFields (
8644  CDecoderStream * pDecoderStream);
8645 
8646  void
8647  assimilateSubParameters (
8648  CErrorDetails * pError);
8649 
8650  void
8651  encode (
8652  CEncoderStream * pEncoderStream) const;
8653 
8654 
8655 
8656  static CElement *
8657  s_construct (void);
8658 
8659  static void
8660  s_decodeFields (
8661  CDecoderStream * pDecoderStream,
8662  CElement * pElement);
8664 
8665 
8666  protected:
8667  std::list<CTransmitPowerLevelTableEntry *> m_listTransmitPowerLevelTableEntry;
8668 
8669  public:
8671  inline std::list<CTransmitPowerLevelTableEntry *>::iterator
8673  {
8674  return m_listTransmitPowerLevelTableEntry.begin();
8675  }
8676 
8678  inline std::list<CTransmitPowerLevelTableEntry *>::iterator
8680  {
8681  return m_listTransmitPowerLevelTableEntry.end();
8682  }
8683 
8685  inline void
8687  {
8688  clearSubParameterList ((tListOfParameters *) &m_listTransmitPowerLevelTableEntry);
8689  }
8690 
8692  inline int
8694  {
8695  return (int) (m_listTransmitPowerLevelTableEntry.size());
8696  }
8697 
8698  EResultCode
8702 
8703 
8704  protected:
8705  CFrequencyInformation * m_pFrequencyInformation;
8706 
8707  public:
8709  inline CFrequencyInformation *
8711  {
8712  return m_pFrequencyInformation;
8713  }
8714 
8716  EResultCode
8718  CFrequencyInformation * pValue);
8719 
8720 
8721  protected:
8722  std::list<CParameter *> m_listAirProtocolUHFRFModeTable;
8723 
8724  public:
8726  inline std::list<CParameter *>::iterator
8728  {
8729  return m_listAirProtocolUHFRFModeTable.begin();
8730  }
8731 
8733  inline std::list<CParameter *>::iterator
8735  {
8736  return m_listAirProtocolUHFRFModeTable.end();
8737  }
8738 
8740  inline void
8742  {
8743  clearSubParameterList ((tListOfParameters *) &m_listAirProtocolUHFRFModeTable);
8744  }
8745 
8747  inline int
8749  {
8750  return (int) (m_listAirProtocolUHFRFModeTable.size());
8751  }
8752 
8753  EResultCode
8756  CParameter * pValue);
8757 
8758 
8759 };
8760 
8761 
8793 class CTransmitPowerLevelTableEntry : public CParameter
8794 {
8795  public:
8798 
8801 
8802  static const CFieldDescriptor * const
8803  s_apFieldDescriptorTable[];
8804 
8805  static const CTypeDescriptor
8806  s_typeDescriptor;
8807 
8808  void
8809  decodeFields (
8810  CDecoderStream * pDecoderStream);
8811 
8812  void
8813  assimilateSubParameters (
8814  CErrorDetails * pError);
8815 
8816  void
8817  encode (
8818  CEncoderStream * pEncoderStream) const;
8819 
8820 
8821 
8822  static CElement *
8823  s_construct (void);
8824 
8825  static void
8826  s_decodeFields (
8827  CDecoderStream * pDecoderStream,
8828  CElement * pElement);
8830 
8831 
8832  protected:
8833  llrp_u16_t m_Index;
8834 
8837  public:
8838  static const CFieldDescriptor
8839  s_fdIndex;
8841 
8843  inline llrp_u16_t
8844  getIndex (void)
8845  {
8846  return m_Index;
8847  }
8848 
8850  inline void
8852  llrp_u16_t value)
8853  {
8854  m_Index = value;
8855  }
8856 
8857 
8858  protected:
8859  llrp_s16_t m_TransmitPowerValue;
8860 
8863  public:
8864  static const CFieldDescriptor
8865  s_fdTransmitPowerValue;
8867 
8869  inline llrp_s16_t
8871  {
8872  return m_TransmitPowerValue;
8873  }
8874 
8876  inline void
8878  llrp_s16_t value)
8879  {
8880  m_TransmitPowerValue = value;
8881  }
8882 
8883 
8884 };
8885 
8886 
8920 class CFrequencyInformation : public CParameter
8921 {
8922  public:
8923  CFrequencyInformation (void);
8924  ~CFrequencyInformation (void);
8925 
8928 
8929  static const CFieldDescriptor * const
8930  s_apFieldDescriptorTable[];
8931 
8932  static const CTypeDescriptor
8933  s_typeDescriptor;
8934 
8935  void
8936  decodeFields (
8937  CDecoderStream * pDecoderStream);
8938 
8939  void
8940  assimilateSubParameters (
8941  CErrorDetails * pError);
8942 
8943  void
8944  encode (
8945  CEncoderStream * pEncoderStream) const;
8946 
8947 
8948 
8949  static CElement *
8950  s_construct (void);
8951 
8952  static void
8953  s_decodeFields (
8954  CDecoderStream * pDecoderStream,
8955  CElement * pElement);
8957 
8958 
8959  protected:
8960  llrp_u1_t m_Hopping;
8961 
8964  public:
8965  static const CFieldDescriptor
8966  s_fdHopping;
8968 
8970  inline llrp_u1_t
8971  getHopping (void)
8972  {
8973  return m_Hopping;
8974  }
8975 
8977  inline void
8979  llrp_u1_t value)
8980  {
8981  m_Hopping = value;
8982  }
8983 
8984 
8985  protected:
8986  std::list<CFrequencyHopTable *> m_listFrequencyHopTable;
8987 
8988  public:
8990  inline std::list<CFrequencyHopTable *>::iterator
8992  {
8993  return m_listFrequencyHopTable.begin();
8994  }
8995 
8997  inline std::list<CFrequencyHopTable *>::iterator
8999  {
9000  return m_listFrequencyHopTable.end();
9001  }
9002 
9004  inline void
9006  {
9007  clearSubParameterList ((tListOfParameters *) &m_listFrequencyHopTable);
9008  }
9009 
9011  inline int
9013  {
9014  return (int) (m_listFrequencyHopTable.size());
9015  }
9016 
9017  EResultCode
9020  CFrequencyHopTable * pValue);
9021 
9022 
9023  protected:
9024  CFixedFrequencyTable * m_pFixedFrequencyTable;
9025 
9026  public:
9028  inline CFixedFrequencyTable *
9030  {
9031  return m_pFixedFrequencyTable;
9032  }
9033 
9035  EResultCode
9037  CFixedFrequencyTable * pValue);
9038 
9039 
9040 };
9041 
9042 
9089 class CFrequencyHopTable : public CParameter
9090 {
9091  public:
9092  CFrequencyHopTable (void);
9093  ~CFrequencyHopTable (void);
9094 
9097 
9098  static const CFieldDescriptor * const
9099  s_apFieldDescriptorTable[];
9100 
9101  static const CTypeDescriptor
9102  s_typeDescriptor;
9103 
9104  void
9105  decodeFields (
9106  CDecoderStream * pDecoderStream);
9107 
9108  void
9109  assimilateSubParameters (
9110  CErrorDetails * pError);
9111 
9112  void
9113  encode (
9114  CEncoderStream * pEncoderStream) const;
9115 
9116 
9117 
9118  static CElement *
9119  s_construct (void);
9120 
9121  static void
9122  s_decodeFields (
9123  CDecoderStream * pDecoderStream,
9124  CElement * pElement);
9126 
9127 
9128  protected:
9129  llrp_u8_t m_HopTableID;
9130 
9133  public:
9134  static const CFieldDescriptor
9135  s_fdHopTableID;
9137 
9139  inline llrp_u8_t
9141  {
9142  return m_HopTableID;
9143  }
9144 
9146  inline void
9148  llrp_u8_t value)
9149  {
9150  m_HopTableID = value;
9151  }
9152 
9153 
9154  protected:
9155  llrp_u32v_t m_Frequency;
9156 
9159  public:
9160  static const CFieldDescriptor
9161  s_fdFrequency;
9163 
9165  inline llrp_u32v_t
9167  {
9168  return m_Frequency;
9169  }
9170 
9172  inline void
9174  llrp_u32v_t value)
9175  {
9176  m_Frequency = value;
9177  }
9178 
9179 
9180 };
9181 
9182 
9213 class CFixedFrequencyTable : public CParameter
9214 {
9215  public:
9216  CFixedFrequencyTable (void);
9217  ~CFixedFrequencyTable (void);
9218 
9221 
9222  static const CFieldDescriptor * const
9223  s_apFieldDescriptorTable[];
9224 
9225  static const CTypeDescriptor
9226  s_typeDescriptor;
9227 
9228  void
9229  decodeFields (
9230  CDecoderStream * pDecoderStream);
9231 
9232  void
9233  assimilateSubParameters (
9234  CErrorDetails * pError);
9235 
9236  void
9237  encode (
9238  CEncoderStream * pEncoderStream) const;
9239 
9240 
9241 
9242  static CElement *
9243  s_construct (void);
9244 
9245  static void
9246  s_decodeFields (
9247  CDecoderStream * pDecoderStream,
9248  CElement * pElement);
9250 
9251 
9252  protected:
9253  llrp_u32v_t m_Frequency;
9254 
9257  public:
9258  static const CFieldDescriptor
9259  s_fdFrequency;
9261 
9263  inline llrp_u32v_t
9265  {
9266  return m_Frequency;
9267  }
9268 
9270  inline void
9272  llrp_u32v_t value)
9273  {
9274  m_Frequency = value;
9275  }
9276 
9277 
9278 };
9279 
9280 
9316 class CROSpec : public CParameter
9317 {
9318  public:
9319  CROSpec (void);
9320  ~CROSpec (void);
9321 
9324 
9325  static const CFieldDescriptor * const
9326  s_apFieldDescriptorTable[];
9327 
9328  static const CTypeDescriptor
9329  s_typeDescriptor;
9330 
9331  void
9332  decodeFields (
9333  CDecoderStream * pDecoderStream);
9334 
9335  void
9336  assimilateSubParameters (
9337  CErrorDetails * pError);
9338 
9339  void
9340  encode (
9341  CEncoderStream * pEncoderStream) const;
9342 
9343 
9344 
9345  static CElement *
9346  s_construct (void);
9347 
9348  static void
9349  s_decodeFields (
9350  CDecoderStream * pDecoderStream,
9351  CElement * pElement);
9353 
9354 
9355  protected:
9356  llrp_u32_t m_ROSpecID;
9357 
9360  public:
9361  static const CFieldDescriptor
9362  s_fdROSpecID;
9364 
9366  inline llrp_u32_t
9368  {
9369  return m_ROSpecID;
9370  }
9371 
9373  inline void
9375  llrp_u32_t value)
9376  {
9377  m_ROSpecID = value;
9378  }
9379 
9380 
9381  protected:
9382  llrp_u8_t m_Priority;
9383 
9386  public:
9387  static const CFieldDescriptor
9388  s_fdPriority;
9390 
9392  inline llrp_u8_t
9394  {
9395  return m_Priority;
9396  }
9397 
9399  inline void
9401  llrp_u8_t value)
9402  {
9403  m_Priority = value;
9404  }
9405 
9406 
9407  protected:
9408  EROSpecState m_eCurrentState;
9409 
9412  public:
9413  static const CFieldDescriptor
9414  s_fdCurrentState;
9416 
9418  inline EROSpecState
9420  {
9421  return m_eCurrentState;
9422  }
9423 
9425  inline void
9427  EROSpecState value)
9428  {
9429  m_eCurrentState = value;
9430  }
9431 
9432 
9433  protected:
9434  CROBoundarySpec * m_pROBoundarySpec;
9435 
9436  public:
9438  inline CROBoundarySpec *
9440  {
9441  return m_pROBoundarySpec;
9442  }
9443 
9445  EResultCode
9447  CROBoundarySpec * pValue);
9448 
9449 
9450  protected:
9451  std::list<CParameter *> m_listSpecParameter;
9452 
9453  public:
9455  inline std::list<CParameter *>::iterator
9457  {
9458  return m_listSpecParameter.begin();
9459  }
9460 
9462  inline std::list<CParameter *>::iterator
9464  {
9465  return m_listSpecParameter.end();
9466  }
9467 
9469  inline void
9471  {
9472  clearSubParameterList ((tListOfParameters *) &m_listSpecParameter);
9473  }
9474 
9476  inline int
9478  {
9479  return (int) (m_listSpecParameter.size());
9480  }
9481 
9482  EResultCode
9485  CParameter * pValue);
9486 
9487 
9488  protected:
9489  CROReportSpec * m_pROReportSpec;
9490 
9491  public:
9493  inline CROReportSpec *
9495  {
9496  return m_pROReportSpec;
9497  }
9498 
9500  EResultCode
9501  setROReportSpec (
9502  CROReportSpec * pValue);
9503 
9504 
9505 };
9506 
9507 
9539 class CROBoundarySpec : public CParameter
9540 {
9541  public:
9542  CROBoundarySpec (void);
9543  ~CROBoundarySpec (void);
9544 
9547 
9548  static const CFieldDescriptor * const
9549  s_apFieldDescriptorTable[];
9550 
9551  static const CTypeDescriptor
9552  s_typeDescriptor;
9553 
9554  void
9555  decodeFields (
9556  CDecoderStream * pDecoderStream);
9557 
9558  void
9559  assimilateSubParameters (
9560  CErrorDetails * pError);
9561 
9562  void
9563  encode (
9564  CEncoderStream * pEncoderStream) const;
9565 
9566 
9567 
9568  static CElement *
9569  s_construct (void);
9570 
9571  static void
9572  s_decodeFields (
9573  CDecoderStream * pDecoderStream,
9574  CElement * pElement);
9576 
9577 
9578  protected:
9579  CROSpecStartTrigger * m_pROSpecStartTrigger;
9580 
9581  public:
9583  inline CROSpecStartTrigger *
9585  {
9586  return m_pROSpecStartTrigger;
9587  }
9588 
9590  EResultCode
9592  CROSpecStartTrigger * pValue);
9593 
9594 
9595  protected:
9596  CROSpecStopTrigger * m_pROSpecStopTrigger;
9597 
9598  public:
9600  inline CROSpecStopTrigger *
9602  {
9603  return m_pROSpecStopTrigger;
9604  }
9605 
9607  EResultCode
9609  CROSpecStopTrigger * pValue);
9610 
9611 
9612 };
9613 
9614 
9647 class CROSpecStartTrigger : public CParameter
9648 {
9649  public:
9650  CROSpecStartTrigger (void);
9651  ~CROSpecStartTrigger (void);
9652 
9655 
9656  static const CFieldDescriptor * const
9657  s_apFieldDescriptorTable[];
9658 
9659  static const CTypeDescriptor
9660  s_typeDescriptor;
9661 
9662  void
9663  decodeFields (
9664  CDecoderStream * pDecoderStream);
9665 
9666  void
9667  assimilateSubParameters (
9668  CErrorDetails * pError);
9669 
9670  void
9671  encode (
9672  CEncoderStream * pEncoderStream) const;
9673 
9674 
9675 
9676  static CElement *
9677  s_construct (void);
9678 
9679  static void
9680  s_decodeFields (
9681  CDecoderStream * pDecoderStream,
9682  CElement * pElement);
9684 
9685 
9686  protected:
9687  EROSpecStartTriggerType m_eROSpecStartTriggerType;
9688 
9691  public:
9692  static const CFieldDescriptor
9693  s_fdROSpecStartTriggerType;
9695 
9697  inline EROSpecStartTriggerType
9699  {
9700  return m_eROSpecStartTriggerType;
9701  }
9702 
9704  inline void
9706  EROSpecStartTriggerType value)
9707  {
9708  m_eROSpecStartTriggerType = value;
9709  }
9710 
9711 
9712  protected:
9713  CPeriodicTriggerValue * m_pPeriodicTriggerValue;
9714 
9715  public:
9717  inline CPeriodicTriggerValue *
9719  {
9720  return m_pPeriodicTriggerValue;
9721  }
9722 
9724  EResultCode
9726  CPeriodicTriggerValue * pValue);
9727 
9728 
9729  protected:
9730  CGPITriggerValue * m_pGPITriggerValue;
9731 
9732  public:
9734  inline CGPITriggerValue *
9736  {
9737  return m_pGPITriggerValue;
9738  }
9739 
9741  EResultCode
9743  CGPITriggerValue * pValue);
9744 
9745 
9746 };
9747 
9748 
9792 class CPeriodicTriggerValue : public CParameter
9793 {
9794  public:
9795  CPeriodicTriggerValue (void);
9796  ~CPeriodicTriggerValue (void);
9797 
9800 
9801  static const CFieldDescriptor * const
9802  s_apFieldDescriptorTable[];
9803 
9804  static const CTypeDescriptor
9805  s_typeDescriptor;
9806 
9807  void
9808  decodeFields (
9809  CDecoderStream * pDecoderStream);
9810 
9811  void
9812  assimilateSubParameters (
9813  CErrorDetails * pError);
9814 
9815  void
9816  encode (
9817  CEncoderStream * pEncoderStream) const;
9818 
9819 
9820 
9821  static CElement *
9822  s_construct (void);
9823 
9824  static void
9825  s_decodeFields (
9826  CDecoderStream * pDecoderStream,
9827  CElement * pElement);
9829 
9830 
9831  protected:
9832  llrp_u32_t m_Offset;
9833 
9836  public:
9837  static const CFieldDescriptor
9838  s_fdOffset;
9840 
9842  inline llrp_u32_t
9843  getOffset (void)
9844  {
9845  return m_Offset;
9846  }
9847 
9849  inline void
9851  llrp_u32_t value)
9852  {
9853  m_Offset = value;
9854  }
9855 
9856 
9857  protected:
9858  llrp_u32_t m_Period;
9859 
9862  public:
9863  static const CFieldDescriptor
9864  s_fdPeriod;
9866 
9868  inline llrp_u32_t
9869  getPeriod (void)
9870  {
9871  return m_Period;
9872  }
9873 
9875  inline void
9877  llrp_u32_t value)
9878  {
9879  m_Period = value;
9880  }
9881 
9882 
9883  protected:
9884  CUTCTimestamp * m_pUTCTimestamp;
9885 
9886  public:
9888  inline CUTCTimestamp *
9890  {
9891  return m_pUTCTimestamp;
9892  }
9893 
9895  EResultCode
9896  setUTCTimestamp (
9897  CUTCTimestamp * pValue);
9898 
9899 
9900 };
9901 
9902 
9948 class CGPITriggerValue : public CParameter
9949 {
9950  public:
9951  CGPITriggerValue (void);
9952  ~CGPITriggerValue (void);
9953 
9956 
9957  static const CFieldDescriptor * const
9958  s_apFieldDescriptorTable[];
9959 
9960  static const CTypeDescriptor
9961  s_typeDescriptor;
9962 
9963  void
9964  decodeFields (
9965  CDecoderStream * pDecoderStream);
9966 
9967  void
9968  assimilateSubParameters (
9969  CErrorDetails * pError);
9970 
9971  void
9972  encode (
9973  CEncoderStream * pEncoderStream) const;
9974 
9975 
9976 
9977  static CElement *
9978  s_construct (void);
9979 
9980  static void
9981  s_decodeFields (
9982  CDecoderStream * pDecoderStream,
9983  CElement * pElement);
9985 
9986 
9987  protected:
9988  llrp_u16_t m_GPIPortNum;
9989 
9992  public:
9993  static const CFieldDescriptor
9994  s_fdGPIPortNum;
9996 
9998  inline llrp_u16_t
10000  {
10001  return m_GPIPortNum;
10002  }
10003 
10005  inline void
10007  llrp_u16_t value)
10008  {
10009  m_GPIPortNum = value;
10010  }
10011 
10012 
10013  protected:
10014  llrp_u1_t m_GPIEvent;
10015 
10018  public:
10019  static const CFieldDescriptor
10020  s_fdGPIEvent;
10022 
10024  inline llrp_u1_t
10026  {
10027  return m_GPIEvent;
10028  }
10029 
10031  inline void
10033  llrp_u1_t value)
10034  {
10035  m_GPIEvent = value;
10036  }
10037 
10038 
10039  protected:
10040  llrp_u32_t m_Timeout;
10041 
10044  public:
10045  static const CFieldDescriptor
10046  s_fdTimeout;
10048 
10050  inline llrp_u32_t
10051  getTimeout (void)
10052  {
10053  return m_Timeout;
10054  }
10055 
10057  inline void
10059  llrp_u32_t value)
10060  {
10061  m_Timeout = value;
10062  }
10063 
10064 
10065 };
10066 
10067 
10100 class CROSpecStopTrigger : public CParameter
10101 {
10102  public:
10103  CROSpecStopTrigger (void);
10104  ~CROSpecStopTrigger (void);
10105 
10108 
10109  static const CFieldDescriptor * const
10110  s_apFieldDescriptorTable[];
10111 
10112  static const CTypeDescriptor
10113  s_typeDescriptor;
10114 
10115  void
10116  decodeFields (
10117  CDecoderStream * pDecoderStream);
10118 
10119  void
10120  assimilateSubParameters (
10121  CErrorDetails * pError);
10122 
10123  void
10124  encode (
10125  CEncoderStream * pEncoderStream) const;
10126 
10127 
10128 
10129  static CElement *
10130  s_construct (void);
10131 
10132  static void
10133  s_decodeFields (
10134  CDecoderStream * pDecoderStream,
10135  CElement * pElement);
10137 
10138 
10139  protected:
10140  EROSpecStopTriggerType m_eROSpecStopTriggerType;
10141 
10144  public:
10145  static const CFieldDescriptor
10146  s_fdROSpecStopTriggerType;
10148 
10150  inline EROSpecStopTriggerType
10152  {
10153  return m_eROSpecStopTriggerType;
10154  }
10155 
10157  inline void
10159  EROSpecStopTriggerType value)
10160  {
10161  m_eROSpecStopTriggerType = value;
10162  }
10163 
10164 
10165  protected:
10166  llrp_u32_t m_DurationTriggerValue;
10167 
10170  public:
10171  static const CFieldDescriptor
10172  s_fdDurationTriggerValue;
10174 
10176  inline llrp_u32_t
10178  {
10179  return m_DurationTriggerValue;
10180  }
10181 
10183  inline void
10185  llrp_u32_t value)
10186  {
10187  m_DurationTriggerValue = value;
10188  }
10189 
10190 
10191  protected:
10192  CGPITriggerValue * m_pGPITriggerValue;
10193 
10194  public:
10196  inline CGPITriggerValue *
10198  {
10199  return m_pGPITriggerValue;
10200  }
10201 
10203  EResultCode
10205  CGPITriggerValue * pValue);
10206 
10207 
10208 };
10209 
10210 
10244 class CAISpec : public CParameter
10245 {
10246  public:
10247  CAISpec (void);
10248  ~CAISpec (void);
10249 
10252 
10253  static const CFieldDescriptor * const
10254  s_apFieldDescriptorTable[];
10255 
10256  static const CTypeDescriptor
10257  s_typeDescriptor;
10258 
10259  void
10260  decodeFields (
10261  CDecoderStream * pDecoderStream);
10262 
10263  void
10264  assimilateSubParameters (
10265  CErrorDetails * pError);
10266 
10267  void
10268  encode (
10269  CEncoderStream * pEncoderStream) const;
10270 
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_u16v_t m_AntennaIDs;
10285 
10288  public:
10289  static const CFieldDescriptor
10290  s_fdAntennaIDs;
10292 
10294  inline llrp_u16v_t
10296  {
10297  return m_AntennaIDs;
10298  }
10299 
10301  inline void
10303  llrp_u16v_t value)
10304  {
10305  m_AntennaIDs = value;
10306  }
10307 
10308 
10309  protected:
10310  CAISpecStopTrigger * m_pAISpecStopTrigger;
10311 
10312  public:
10314  inline CAISpecStopTrigger *
10316  {
10317  return m_pAISpecStopTrigger;
10318  }
10319 
10321  EResultCode
10323  CAISpecStopTrigger * pValue);
10324 
10325 
10326  protected:
10327  std::list<CInventoryParameterSpec *> m_listInventoryParameterSpec;
10328 
10329  public:
10331  inline std::list<CInventoryParameterSpec *>::iterator
10333  {
10334  return m_listInventoryParameterSpec.begin();
10335  }
10336 
10338  inline std::list<CInventoryParameterSpec *>::iterator
10340  {
10341  return m_listInventoryParameterSpec.end();
10342  }
10343 
10345  inline void
10347  {
10348  clearSubParameterList ((tListOfParameters *) &m_listInventoryParameterSpec);
10349  }
10350 
10352  inline int
10354  {
10355  return (int) (m_listInventoryParameterSpec.size());
10356  }
10357 
10358  EResultCode
10361  CInventoryParameterSpec * pValue);
10362 
10363 
10364  protected:
10365  std::list<CParameter *> m_listCustom;
10366 
10367  public:
10369  inline std::list<CParameter *>::iterator
10371  {
10372  return m_listCustom.begin();
10373  }
10374 
10376  inline std::list<CParameter *>::iterator
10377  endCustom (void)
10378  {
10379  return m_listCustom.end();
10380  }
10381 
10383  inline void
10385  {
10386  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10387  }
10388 
10390  inline int
10392  {
10393  return (int) (m_listCustom.size());
10394  }
10395 
10396  EResultCode
10398  addCustom (
10399  CParameter * pValue);
10400 
10401 
10402 };
10403 
10404 
10438 class CAISpecStopTrigger : public CParameter
10439 {
10440  public:
10441  CAISpecStopTrigger (void);
10442  ~CAISpecStopTrigger (void);
10443 
10446 
10447  static const CFieldDescriptor * const
10448  s_apFieldDescriptorTable[];
10449 
10450  static const CTypeDescriptor
10451  s_typeDescriptor;
10452 
10453  void
10454  decodeFields (
10455  CDecoderStream * pDecoderStream);
10456 
10457  void
10458  assimilateSubParameters (
10459  CErrorDetails * pError);
10460 
10461  void
10462  encode (
10463  CEncoderStream * pEncoderStream) const;
10464 
10465 
10466 
10467  static CElement *
10468  s_construct (void);
10469 
10470  static void
10471  s_decodeFields (
10472  CDecoderStream * pDecoderStream,
10473  CElement * pElement);
10475 
10476 
10477  protected:
10478  EAISpecStopTriggerType m_eAISpecStopTriggerType;
10479 
10482  public:
10483  static const CFieldDescriptor
10484  s_fdAISpecStopTriggerType;
10486 
10488  inline EAISpecStopTriggerType
10490  {
10491  return m_eAISpecStopTriggerType;
10492  }
10493 
10495  inline void
10497  EAISpecStopTriggerType value)
10498  {
10499  m_eAISpecStopTriggerType = value;
10500  }
10501 
10502 
10503  protected:
10504  llrp_u32_t m_DurationTrigger;
10505 
10508  public:
10509  static const CFieldDescriptor
10510  s_fdDurationTrigger;
10512 
10514  inline llrp_u32_t
10516  {
10517  return m_DurationTrigger;
10518  }
10519 
10521  inline void
10523  llrp_u32_t value)
10524  {
10525  m_DurationTrigger = value;
10526  }
10527 
10528 
10529  protected:
10530  CGPITriggerValue * m_pGPITriggerValue;
10531 
10532  public:
10534  inline CGPITriggerValue *
10536  {
10537  return m_pGPITriggerValue;
10538  }
10539 
10541  EResultCode
10543  CGPITriggerValue * pValue);
10544 
10545 
10546  protected:
10547  CTagObservationTrigger * m_pTagObservationTrigger;
10548 
10549  public:
10551  inline CTagObservationTrigger *
10553  {
10554  return m_pTagObservationTrigger;
10555  }
10556 
10558  EResultCode
10560  CTagObservationTrigger * pValue);
10561 
10562 
10563 };
10564 
10565 
10601 class CTagObservationTrigger : public CParameter
10602 {
10603  public:
10604  CTagObservationTrigger (void);
10605  ~CTagObservationTrigger (void);
10606 
10609 
10610  static const CFieldDescriptor * const
10611  s_apFieldDescriptorTable[];
10612 
10613  static const CTypeDescriptor
10614  s_typeDescriptor;
10615 
10616  void
10617  decodeFields (
10618  CDecoderStream * pDecoderStream);
10619 
10620  void
10621  assimilateSubParameters (
10622  CErrorDetails * pError);
10623 
10624  void
10625  encode (
10626  CEncoderStream * pEncoderStream) const;
10627 
10628 
10629 
10630  static CElement *
10631  s_construct (void);
10632 
10633  static void
10634  s_decodeFields (
10635  CDecoderStream * pDecoderStream,
10636  CElement * pElement);
10638 
10639 
10640  protected:
10641  ETagObservationTriggerType m_eTriggerType;
10642 
10645  public:
10646  static const CFieldDescriptor
10647  s_fdTriggerType;
10649 
10651  inline ETagObservationTriggerType
10653  {
10654  return m_eTriggerType;
10655  }
10656 
10658  inline void
10660  ETagObservationTriggerType value)
10661  {
10662  m_eTriggerType = value;
10663  }
10664 
10665 
10666  protected:
10667  llrp_u16_t m_NumberOfTags;
10668 
10671  public:
10672  static const CFieldDescriptor
10673  s_fdNumberOfTags;
10675 
10677  inline llrp_u16_t
10679  {
10680  return m_NumberOfTags;
10681  }
10682 
10684  inline void
10686  llrp_u16_t value)
10687  {
10688  m_NumberOfTags = value;
10689  }
10690 
10691 
10692  protected:
10693  llrp_u16_t m_NumberOfAttempts;
10694 
10697  public:
10698  static const CFieldDescriptor
10699  s_fdNumberOfAttempts;
10701 
10703  inline llrp_u16_t
10705  {
10706  return m_NumberOfAttempts;
10707  }
10708 
10710  inline void
10712  llrp_u16_t value)
10713  {
10714  m_NumberOfAttempts = value;
10715  }
10716 
10717 
10718  protected:
10719  llrp_u16_t m_T;
10720 
10723  public:
10724  static const CFieldDescriptor
10725  s_fdT;
10727 
10729  inline llrp_u16_t
10730  getT (void)
10731  {
10732  return m_T;
10733  }
10734 
10736  inline void
10738  llrp_u16_t value)
10739  {
10740  m_T = value;
10741  }
10742 
10743 
10744  protected:
10745  llrp_u32_t m_Timeout;
10746 
10749  public:
10750  static const CFieldDescriptor
10751  s_fdTimeout;
10753 
10755  inline llrp_u32_t
10756  getTimeout (void)
10757  {
10758  return m_Timeout;
10759  }
10760 
10762  inline void
10764  llrp_u32_t value)
10765  {
10766  m_Timeout = value;
10767  }
10768 
10769 
10770 };
10771 
10772 
10806 class CInventoryParameterSpec : public CParameter
10807 {
10808  public:
10809  CInventoryParameterSpec (void);
10810  ~CInventoryParameterSpec (void);
10811 
10814 
10815  static const CFieldDescriptor * const
10816  s_apFieldDescriptorTable[];
10817 
10818  static const CTypeDescriptor
10819  s_typeDescriptor;
10820 
10821  void
10822  decodeFields (
10823  CDecoderStream * pDecoderStream);
10824 
10825  void
10826  assimilateSubParameters (
10827  CErrorDetails * pError);
10828 
10829  void
10830  encode (
10831  CEncoderStream * pEncoderStream) const;
10832 
10833 
10834 
10835  static CElement *
10836  s_construct (void);
10837 
10838  static void
10839  s_decodeFields (
10840  CDecoderStream * pDecoderStream,
10841  CElement * pElement);
10843 
10844 
10845  protected:
10846  llrp_u16_t m_InventoryParameterSpecID;
10847 
10850  public:
10851  static const CFieldDescriptor
10852  s_fdInventoryParameterSpecID;
10854 
10856  inline llrp_u16_t
10858  {
10859  return m_InventoryParameterSpecID;
10860  }
10861 
10863  inline void
10865  llrp_u16_t value)
10866  {
10867  m_InventoryParameterSpecID = value;
10868  }
10869 
10870 
10871  protected:
10872  EAirProtocols m_eProtocolID;
10873 
10876  public:
10877  static const CFieldDescriptor
10878  s_fdProtocolID;
10880 
10882  inline EAirProtocols
10884  {
10885  return m_eProtocolID;
10886  }
10887 
10889  inline void
10891  EAirProtocols value)
10892  {
10893  m_eProtocolID = value;
10894  }
10895 
10896 
10897  protected:
10898  std::list<CAntennaConfiguration *> m_listAntennaConfiguration;
10899 
10900  public:
10902  inline std::list<CAntennaConfiguration *>::iterator
10904  {
10905  return m_listAntennaConfiguration.begin();
10906  }
10907 
10909  inline std::list<CAntennaConfiguration *>::iterator
10911  {
10912  return m_listAntennaConfiguration.end();
10913  }
10914 
10916  inline void
10918  {
10919  clearSubParameterList ((tListOfParameters *) &m_listAntennaConfiguration);
10920  }
10921 
10923  inline int
10925  {
10926  return (int) (m_listAntennaConfiguration.size());
10927  }
10928 
10929  EResultCode
10932  CAntennaConfiguration * pValue);
10933 
10934 
10935  protected:
10936  std::list<CParameter *> m_listCustom;
10937 
10938  public:
10940  inline std::list<CParameter *>::iterator
10942  {
10943  return m_listCustom.begin();
10944  }
10945 
10947  inline std::list<CParameter *>::iterator
10948  endCustom (void)
10949  {
10950  return m_listCustom.end();
10951  }
10952 
10954  inline void
10956  {
10957  clearSubParameterList ((tListOfParameters *) &m_listCustom);
10958  }
10959 
10961  inline int
10963  {
10964  return (int) (m_listCustom.size());
10965  }
10966 
10967  EResultCode
10969  addCustom (
10970  CParameter * pValue);
10971 
10972 
10973 };
10974 
10975 
11010 class CRFSurveySpec : public CParameter
11011 {
11012  public:
11013  CRFSurveySpec (void);
11014  ~CRFSurveySpec (void);
11015 
11018 
11019  static const CFieldDescriptor * const
11020  s_apFieldDescriptorTable[];
11021 
11022  static const CTypeDescriptor
11023  s_typeDescriptor;
11024 
11025  void
11026  decodeFields (
11027  CDecoderStream * pDecoderStream);
11028 
11029  void
11030  assimilateSubParameters (
11031  CErrorDetails * pError);
11032 
11033  void
11034  encode (
11035  CEncoderStream * pEncoderStream) const;
11036 
11037 
11038 
11039  static CElement *
11040  s_construct (void);
11041 
11042  static void
11043  s_decodeFields (
11044  CDecoderStream * pDecoderStream,
11045  CElement * pElement);
11047 
11048 
11049  protected:
11050  llrp_u16_t m_AntennaID;
11051 
11054  public:
11055  static const CFieldDescriptor
11056  s_fdAntennaID;
11058 
11060  inline llrp_u16_t
11062  {
11063  return m_AntennaID;
11064  }
11065 
11067  inline void
11069  llrp_u16_t value)
11070  {
11071  m_AntennaID = value;
11072  }
11073 
11074 
11075  protected:
11076  llrp_u32_t m_StartFrequency;
11077 
11080  public:
11081  static const CFieldDescriptor
11082  s_fdStartFrequency;
11084 
11086  inline llrp_u32_t
11088  {
11089  return m_StartFrequency;
11090  }
11091 
11093  inline void
11095  llrp_u32_t value)
11096  {
11097  m_StartFrequency = value;
11098  }
11099 
11100 
11101  protected:
11102  llrp_u32_t m_EndFrequency;
11103 
11106  public:
11107  static const CFieldDescriptor
11108  s_fdEndFrequency;
11110 
11112  inline llrp_u32_t
11114  {
11115  return m_EndFrequency;
11116  }
11117 
11119  inline void
11121  llrp_u32_t value)
11122  {
11123  m_EndFrequency = value;
11124  }
11125 
11126 
11127  protected:
11128  CRFSurveySpecStopTrigger * m_pRFSurveySpecStopTrigger;
11129 
11130  public:
11132  inline CRFSurveySpecStopTrigger *
11134  {
11135  return m_pRFSurveySpecStopTrigger;
11136  }
11137 
11139  EResultCode
11141  CRFSurveySpecStopTrigger * pValue);
11142 
11143 
11144  protected:
11145  std::list<CParameter *> m_listCustom;
11146 
11147  public:
11149  inline std::list<CParameter *>::iterator
11151  {
11152  return m_listCustom.begin();
11153  }
11154 
11156  inline std::list<CParameter *>::iterator
11157  endCustom (void)
11158  {
11159  return m_listCustom.end();
11160  }
11161 
11163  inline void
11165  {
11166  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11167  }
11168 
11170  inline int
11172  {
11173  return (int) (m_listCustom.size());
11174  }
11175 
11176  EResultCode
11178  addCustom (
11179  CParameter * pValue);
11180 
11181 
11182 };
11183 
11184 
11217 class CRFSurveySpecStopTrigger : public CParameter
11218 {
11219  public:
11220  CRFSurveySpecStopTrigger (void);
11221  ~CRFSurveySpecStopTrigger (void);
11222 
11225 
11226  static const CFieldDescriptor * const
11227  s_apFieldDescriptorTable[];
11228 
11229  static const CTypeDescriptor
11230  s_typeDescriptor;
11231 
11232  void
11233  decodeFields (
11234  CDecoderStream * pDecoderStream);
11235 
11236  void
11237  assimilateSubParameters (
11238  CErrorDetails * pError);
11239 
11240  void
11241  encode (
11242  CEncoderStream * pEncoderStream) const;
11243 
11244 
11245 
11246  static CElement *
11247  s_construct (void);
11248 
11249  static void
11250  s_decodeFields (
11251  CDecoderStream * pDecoderStream,
11252  CElement * pElement);
11254 
11255 
11256  protected:
11257  ERFSurveySpecStopTriggerType m_eStopTriggerType;
11258 
11261  public:
11262  static const CFieldDescriptor
11263  s_fdStopTriggerType;
11265 
11267  inline ERFSurveySpecStopTriggerType
11269  {
11270  return m_eStopTriggerType;
11271  }
11272 
11274  inline void
11276  ERFSurveySpecStopTriggerType value)
11277  {
11278  m_eStopTriggerType = value;
11279  }
11280 
11281 
11282  protected:
11283  llrp_u32_t m_DurationPeriod;
11284 
11287  public:
11288  static const CFieldDescriptor
11289  s_fdDurationPeriod;
11291 
11293  inline llrp_u32_t
11295  {
11296  return m_DurationPeriod;
11297  }
11298 
11300  inline void
11302  llrp_u32_t value)
11303  {
11304  m_DurationPeriod = value;
11305  }
11306 
11307 
11308  protected:
11309  llrp_u32_t m_N;
11310 
11313  public:
11314  static const CFieldDescriptor
11315  s_fdN;
11317 
11319  inline llrp_u32_t
11320  getN (void)
11321  {
11322  return m_N;
11323  }
11324 
11326  inline void
11328  llrp_u32_t value)
11329  {
11330  m_N = value;
11331  }
11332 
11333 
11334 };
11335 
11336 
11376 class CAccessSpec : public CParameter
11377 {
11378  public:
11379  CAccessSpec (void);
11380  ~CAccessSpec (void);
11381 
11384 
11385  static const CFieldDescriptor * const
11386  s_apFieldDescriptorTable[];
11387 
11388  static const CTypeDescriptor
11389  s_typeDescriptor;
11390 
11391  void
11392  decodeFields (
11393  CDecoderStream * pDecoderStream);
11394 
11395  void
11396  assimilateSubParameters (
11397  CErrorDetails * pError);
11398 
11399  void
11400  encode (
11401  CEncoderStream * pEncoderStream) const;
11402 
11403 
11404 
11405  static CElement *
11406  s_construct (void);
11407 
11408  static void
11409  s_decodeFields (
11410  CDecoderStream * pDecoderStream,
11411  CElement * pElement);
11413 
11414 
11415  protected:
11416  llrp_u32_t m_AccessSpecID;
11417 
11420  public:
11421  static const CFieldDescriptor
11422  s_fdAccessSpecID;
11424 
11426  inline llrp_u32_t
11428  {
11429  return m_AccessSpecID;
11430  }
11431 
11433  inline void
11435  llrp_u32_t value)
11436  {
11437  m_AccessSpecID = value;
11438  }
11439 
11440 
11441  protected:
11442  llrp_u16_t m_AntennaID;
11443 
11446  public:
11447  static const CFieldDescriptor
11448  s_fdAntennaID;
11450 
11452  inline llrp_u16_t
11454  {
11455  return m_AntennaID;
11456  }
11457 
11459  inline void
11461  llrp_u16_t value)
11462  {
11463  m_AntennaID = value;
11464  }
11465 
11466 
11467  protected:
11468  EAirProtocols m_eProtocolID;
11469 
11472  public:
11473  static const CFieldDescriptor
11474  s_fdProtocolID;
11476 
11478  inline EAirProtocols
11480  {
11481  return m_eProtocolID;
11482  }
11483 
11485  inline void
11487  EAirProtocols value)
11488  {
11489  m_eProtocolID = value;
11490  }
11491 
11492 
11493  protected:
11494  EAccessSpecState m_eCurrentState;
11495 
11498  public:
11499  static const CFieldDescriptor
11500  s_fdCurrentState;
11502 
11504  inline EAccessSpecState
11506  {
11507  return m_eCurrentState;
11508  }
11509 
11511  inline void
11513  EAccessSpecState value)
11514  {
11515  m_eCurrentState = value;
11516  }
11517 
11518 
11519  protected:
11520  llrp_u32_t m_ROSpecID;
11521 
11524  public:
11525  static const CFieldDescriptor
11526  s_fdROSpecID;
11528 
11530  inline llrp_u32_t
11532  {
11533  return m_ROSpecID;
11534  }
11535 
11537  inline void
11539  llrp_u32_t value)
11540  {
11541  m_ROSpecID = value;
11542  }
11543 
11544 
11545  protected:
11546  CAccessSpecStopTrigger * m_pAccessSpecStopTrigger;
11547 
11548  public:
11550  inline CAccessSpecStopTrigger *
11552  {
11553  return m_pAccessSpecStopTrigger;
11554  }
11555 
11557  EResultCode
11559  CAccessSpecStopTrigger * pValue);
11560 
11561 
11562  protected:
11563  CAccessCommand * m_pAccessCommand;
11564 
11565  public:
11567  inline CAccessCommand *
11569  {
11570  return m_pAccessCommand;
11571  }
11572 
11574  EResultCode
11576  CAccessCommand * pValue);
11577 
11578 
11579  protected:
11580  CAccessReportSpec * m_pAccessReportSpec;
11581 
11582  public:
11584  inline CAccessReportSpec *
11586  {
11587  return m_pAccessReportSpec;
11588  }
11589 
11591  EResultCode
11593  CAccessReportSpec * pValue);
11594 
11595 
11596  protected:
11597  std::list<CParameter *> m_listCustom;
11598 
11599  public:
11601  inline std::list<CParameter *>::iterator
11603  {
11604  return m_listCustom.begin();
11605  }
11606 
11608  inline std::list<CParameter *>::iterator
11609  endCustom (void)
11610  {
11611  return m_listCustom.end();
11612  }
11613 
11615  inline void
11617  {
11618  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11619  }
11620 
11622  inline int
11624  {
11625  return (int) (m_listCustom.size());
11626  }
11627 
11628  EResultCode
11630  addCustom (
11631  CParameter * pValue);
11632 
11633 
11634 };
11635 
11636 
11671 class CAccessSpecStopTrigger : public CParameter
11672 {
11673  public:
11674  CAccessSpecStopTrigger (void);
11675  ~CAccessSpecStopTrigger (void);
11676 
11679 
11680  static const CFieldDescriptor * const
11681  s_apFieldDescriptorTable[];
11682 
11683  static const CTypeDescriptor
11684  s_typeDescriptor;
11685 
11686  void
11687  decodeFields (
11688  CDecoderStream * pDecoderStream);
11689 
11690  void
11691  assimilateSubParameters (
11692  CErrorDetails * pError);
11693 
11694  void
11695  encode (
11696  CEncoderStream * pEncoderStream) const;
11697 
11698 
11699 
11700  static CElement *
11701  s_construct (void);
11702 
11703  static void
11704  s_decodeFields (
11705  CDecoderStream * pDecoderStream,
11706  CElement * pElement);
11708 
11709 
11710  protected:
11711  EAccessSpecStopTriggerType m_eAccessSpecStopTrigger;
11712 
11715  public:
11716  static const CFieldDescriptor
11717  s_fdAccessSpecStopTrigger;
11719 
11721  inline EAccessSpecStopTriggerType
11723  {
11724  return m_eAccessSpecStopTrigger;
11725  }
11726 
11728  inline void
11730  EAccessSpecStopTriggerType value)
11731  {
11732  m_eAccessSpecStopTrigger = value;
11733  }
11734 
11735 
11736  protected:
11737  llrp_u16_t m_OperationCountValue;
11738 
11741  public:
11742  static const CFieldDescriptor
11743  s_fdOperationCountValue;
11745 
11747  inline llrp_u16_t
11749  {
11750  return m_OperationCountValue;
11751  }
11752 
11754  inline void
11756  llrp_u16_t value)
11757  {
11758  m_OperationCountValue = value;
11759  }
11760 
11761 
11762 };
11763 
11764 
11807 class CAccessCommand : public CParameter
11808 {
11809  public:
11810  CAccessCommand (void);
11811  ~CAccessCommand (void);
11812 
11815 
11816  static const CFieldDescriptor * const
11817  s_apFieldDescriptorTable[];
11818 
11819  static const CTypeDescriptor
11820  s_typeDescriptor;
11821 
11822  void
11823  decodeFields (
11824  CDecoderStream * pDecoderStream);
11825 
11826  void
11827  assimilateSubParameters (
11828  CErrorDetails * pError);
11829 
11830  void
11831  encode (
11832  CEncoderStream * pEncoderStream) const;
11833 
11834 
11835 
11836  static CElement *
11837  s_construct (void);
11838 
11839  static void
11840  s_decodeFields (
11841  CDecoderStream * pDecoderStream,
11842  CElement * pElement);
11844 
11845 
11846  protected:
11847  CParameter * m_pAirProtocolTagSpec;
11848 
11849  public:
11851  inline CParameter *
11853  {
11854  return m_pAirProtocolTagSpec;
11855  }
11856 
11858  EResultCode
11860  CParameter * pValue);
11861 
11862 
11863  protected:
11864  std::list<CParameter *> m_listAccessCommandOpSpec;
11865 
11866  public:
11868  inline std::list<CParameter *>::iterator
11870  {
11871  return m_listAccessCommandOpSpec.begin();
11872  }
11873 
11875  inline std::list<CParameter *>::iterator
11877  {
11878  return m_listAccessCommandOpSpec.end();
11879  }
11880 
11882  inline void
11884  {
11885  clearSubParameterList ((tListOfParameters *) &m_listAccessCommandOpSpec);
11886  }
11887 
11889  inline int
11891  {
11892  return (int) (m_listAccessCommandOpSpec.size());
11893  }
11894 
11895  EResultCode
11898  CParameter * pValue);
11899 
11900 
11901  protected:
11902  std::list<CParameter *> m_listCustom;
11903 
11904  public:
11906  inline std::list<CParameter *>::iterator
11908  {
11909  return m_listCustom.begin();
11910  }
11911 
11913  inline std::list<CParameter *>::iterator
11914  endCustom (void)
11915  {
11916  return m_listCustom.end();
11917  }
11918 
11920  inline void
11922  {
11923  clearSubParameterList ((tListOfParameters *) &m_listCustom);
11924  }
11925 
11927  inline int
11929  {
11930  return (int) (m_listCustom.size());
11931  }
11932 
11933  EResultCode
11935  addCustom (
11936  CParameter * pValue);
11937 
11938 
11939 };
11940 
11941 
11975 class CClientRequestOpSpec : public CParameter
11976 {
11977  public:
11978  CClientRequestOpSpec (void);
11979  ~CClientRequestOpSpec (void);
11980 
11983 
11984  static const CFieldDescriptor * const
11985  s_apFieldDescriptorTable[];
11986 
11987  static const CTypeDescriptor
11988  s_typeDescriptor;
11989 
11990  void
11991  decodeFields (
11992  CDecoderStream * pDecoderStream);
11993 
11994  void
11995  assimilateSubParameters (
11996  CErrorDetails * pError);
11997 
11998  void
11999  encode (
12000  CEncoderStream * pEncoderStream) const;
12001 
12002 
12003 
12004  static CElement *
12005  s_construct (void);
12006 
12007  static void
12008  s_decodeFields (
12009  CDecoderStream * pDecoderStream,
12010  CElement * pElement);
12012 
12013 
12014  protected:
12015  llrp_u16_t m_OpSpecID;
12016 
12019  public:
12020  static const CFieldDescriptor
12021  s_fdOpSpecID;
12023 
12025  inline llrp_u16_t
12027  {
12028  return m_OpSpecID;
12029  }
12030 
12032  inline void
12034  llrp_u16_t value)
12035  {
12036  m_OpSpecID = value;
12037  }
12038 
12039 
12040 };
12041 
12042 
12075 class CClientRequestResponse : public CParameter
12076 {
12077  public:
12078  CClientRequestResponse (void);
12079  ~CClientRequestResponse (void);
12080 
12083 
12084  static const CFieldDescriptor * const
12085  s_apFieldDescriptorTable[];
12086 
12087  static const CTypeDescriptor
12088  s_typeDescriptor;
12089 
12090  void
12091  decodeFields (
12092  CDecoderStream * pDecoderStream);
12093 
12094  void
12095  assimilateSubParameters (
12096  CErrorDetails * pError);
12097 
12098  void
12099  encode (
12100  CEncoderStream * pEncoderStream) const;
12101 
12102 
12103 
12104  static CElement *
12105  s_construct (void);
12106 
12107  static void
12108  s_decodeFields (
12109  CDecoderStream * pDecoderStream,
12110  CElement * pElement);
12112 
12113 
12114  protected:
12115  llrp_u32_t m_AccessSpecID;
12116 
12119  public:
12120  static const CFieldDescriptor
12121  s_fdAccessSpecID;
12123 
12125  inline llrp_u32_t
12127  {
12128  return m_AccessSpecID;
12129  }
12130 
12132  inline void
12134  llrp_u32_t value)
12135  {
12136  m_AccessSpecID = value;
12137  }
12138 
12139 
12140  protected:
12141  CEPCData * m_pEPCData;
12142 
12143  public:
12145  inline CEPCData *
12146  getEPCData (void)
12147  {
12148  return m_pEPCData;
12149  }
12150 
12152  EResultCode
12153  setEPCData (
12154  CEPCData * pValue);
12155 
12156 
12157  protected:
12158  std::list<CParameter *> m_listAirProtocolOpSpec;
12159 
12160  public:
12162  inline std::list<CParameter *>::iterator
12164  {
12165  return m_listAirProtocolOpSpec.begin();
12166  }
12167 
12169  inline std::list<CParameter *>::iterator
12171  {
12172  return m_listAirProtocolOpSpec.end();
12173  }
12174 
12176  inline void
12178  {
12179  clearSubParameterList ((tListOfParameters *) &m_listAirProtocolOpSpec);
12180  }
12181 
12183  inline int
12185  {
12186  return (int) (m_listAirProtocolOpSpec.size());
12187  }
12188 
12189  EResultCode
12192  CParameter * pValue);
12193 
12194 
12195 };
12196 
12197 
12262 class CLLRPConfigurationStateValue : public CParameter
12263 {
12264  public:
12267 
12270 
12271  static const CFieldDescriptor * const
12272  s_apFieldDescriptorTable[];
12273 
12274  static const CTypeDescriptor
12275  s_typeDescriptor;
12276 
12277  void
12278  decodeFields (
12279  CDecoderStream * pDecoderStream);
12280 
12281  void
12282  assimilateSubParameters (
12283  CErrorDetails * pError);
12284 
12285  void
12286  encode (
12287  CEncoderStream * pEncoderStream) const;
12288 
12289 
12290 
12291  static CElement *
12292  s_construct (void);
12293 
12294  static void
12295  s_decodeFields (
12296  CDecoderStream * pDecoderStream,
12297  CElement * pElement);
12299 
12300 
12301  protected:
12302  llrp_u32_t m_LLRPConfigurationStateValue;
12303 
12306  public:
12307  static const CFieldDescriptor
12308  s_fdLLRPConfigurationStateValue;
12310 
12312  inline llrp_u32_t
12314  {
12315  return m_LLRPConfigurationStateValue;
12316  }
12317 
12319  inline void
12321  llrp_u32_t value)
12322  {
12323  m_LLRPConfigurationStateValue = value;
12324  }
12325 
12326 
12327 };
12328 
12329 
12366 class CIdentification : public CParameter
12367 {
12368  public:
12369  CIdentification (void);
12370  ~CIdentification (void);
12371 
12374 
12375  static const CFieldDescriptor * const
12376  s_apFieldDescriptorTable[];
12377 
12378  static const CTypeDescriptor
12379  s_typeDescriptor;
12380 
12381  void
12382  decodeFields (
12383  CDecoderStream * pDecoderStream);
12384 
12385  void
12386  assimilateSubParameters (
12387  CErrorDetails * pError);
12388 
12389  void
12390  encode (
12391  CEncoderStream * pEncoderStream) const;
12392 
12393 
12394 
12395  static CElement *
12396  s_construct (void);
12397 
12398  static void
12399  s_decodeFields (
12400  CDecoderStream * pDecoderStream,
12401  CElement * pElement);
12403 
12404 
12405  protected:
12406  EIdentificationType m_eIDType;
12407 
12410  public:
12411  static const CFieldDescriptor
12412  s_fdIDType;
12414 
12416  inline EIdentificationType
12417  getIDType (void)
12418  {
12419  return m_eIDType;
12420  }
12421 
12423  inline void
12425  EIdentificationType value)
12426  {
12427  m_eIDType = value;
12428  }
12429 
12430 
12431  protected:
12432  llrp_u8v_t m_ReaderID;
12433 
12436  public:
12437  static const CFieldDescriptor
12438  s_fdReaderID;
12440 
12442  inline llrp_u8v_t
12444  {
12445  return m_ReaderID;
12446  }
12447 
12449  inline void
12451  llrp_u8v_t value)
12452  {
12453  m_ReaderID = value;
12454  }
12455 
12456 
12457 };
12458 
12459 
12499 class CGPOWriteData : public CParameter
12500 {
12501  public:
12502  CGPOWriteData (void);
12503  ~CGPOWriteData (void);
12504 
12507 
12508  static const CFieldDescriptor * const
12509  s_apFieldDescriptorTable[];
12510 
12511  static const CTypeDescriptor
12512  s_typeDescriptor;
12513 
12514  void
12515  decodeFields (
12516  CDecoderStream * pDecoderStream);
12517 
12518  void
12519  assimilateSubParameters (
12520  CErrorDetails * pError);
12521 
12522  void
12523  encode (
12524  CEncoderStream * pEncoderStream) const;
12525 
12526 
12527 
12528  static CElement *
12529  s_construct (void);
12530 
12531  static void
12532  s_decodeFields (
12533  CDecoderStream * pDecoderStream,
12534  CElement * pElement);
12536 
12537 
12538  protected:
12539  llrp_u16_t m_GPOPortNumber;
12540 
12543  public:
12544  static const CFieldDescriptor
12545  s_fdGPOPortNumber;
12547 
12549  inline llrp_u16_t
12551  {
12552  return m_GPOPortNumber;
12553  }
12554 
12556  inline void
12558  llrp_u16_t value)
12559  {
12560  m_GPOPortNumber = value;
12561  }
12562 
12563 
12564  protected:
12565  llrp_u1_t m_GPOData;
12566 
12569  public:
12570  static const CFieldDescriptor
12571  s_fdGPOData;
12573 
12575  inline llrp_u1_t
12576  getGPOData (void)
12577  {
12578  return m_GPOData;
12579  }
12580 
12582  inline void
12584  llrp_u1_t value)
12585  {
12586  m_GPOData = value;
12587  }
12588 
12589 
12590 };
12591 
12592 
12624 class CKeepaliveSpec : public CParameter
12625 {
12626  public:
12627  CKeepaliveSpec (void);
12628  ~CKeepaliveSpec (void);
12629 
12632 
12633  static const CFieldDescriptor * const
12634  s_apFieldDescriptorTable[];
12635 
12636  static const CTypeDescriptor
12637  s_typeDescriptor;
12638 
12639  void
12640  decodeFields (
12641  CDecoderStream * pDecoderStream);
12642 
12643  void
12644  assimilateSubParameters (
12645  CErrorDetails * pError);
12646 
12647  void
12648  encode (
12649  CEncoderStream * pEncoderStream) const;
12650 
12651 
12652 
12653  static CElement *
12654  s_construct (void);
12655 
12656  static void
12657  s_decodeFields (
12658  CDecoderStream * pDecoderStream,
12659  CElement * pElement);
12661 
12662 
12663  protected:
12664  EKeepaliveTriggerType m_eKeepaliveTriggerType;
12665 
12668  public:
12669  static const CFieldDescriptor
12670  s_fdKeepaliveTriggerType;
12672 
12674  inline EKeepaliveTriggerType
12676  {
12677  return m_eKeepaliveTriggerType;
12678  }
12679 
12681  inline void
12683  EKeepaliveTriggerType value)
12684  {
12685  m_eKeepaliveTriggerType = value;
12686  }
12687 
12688 
12689  protected:
12690  llrp_u32_t m_PeriodicTriggerValue;
12691 
12694  public:
12695  static const CFieldDescriptor
12696  s_fdPeriodicTriggerValue;
12698 
12700  inline llrp_u32_t
12702  {
12703  return m_PeriodicTriggerValue;
12704  }
12705 
12707  inline void
12709  llrp_u32_t value)
12710  {
12711  m_PeriodicTriggerValue = value;
12712  }
12713 
12714 
12715 };
12716 
12717 
12751 class CAntennaProperties : public CParameter
12752 {
12753  public:
12754  CAntennaProperties (void);
12755  ~CAntennaProperties (void);
12756 
12759 
12760  static const CFieldDescriptor * const
12761  s_apFieldDescriptorTable[];
12762 
12763  static const CTypeDescriptor
12764  s_typeDescriptor;
12765 
12766  void
12767  decodeFields (
12768  CDecoderStream * pDecoderStream);
12769 
12770  void
12771  assimilateSubParameters (
12772  CErrorDetails * pError);
12773 
12774  void
12775  encode (
12776  CEncoderStream * pEncoderStream) const;
12777 
12778 
12779 
12780  static CElement *
12781  s_construct (void);
12782 
12783  static void
12784  s_decodeFields (
12785  CDecoderStream * pDecoderStream,
12786  CElement * pElement);
12788 
12789 
12790  protected:
12791  llrp_u1_t m_AntennaConnected;
12792 
12795  public:
12796  static const CFieldDescriptor
12797  s_fdAntennaConnected;
12799 
12801  inline llrp_u1_t
12803  {
12804  return m_AntennaConnected;
12805  }
12806 
12808  inline void
12810  llrp_u1_t value)
12811  {
12812  m_AntennaConnected = value;
12813  }
12814 
12815 
12816  protected:
12817  llrp_u16_t m_AntennaID;
12818 
12821  public:
12822  static const CFieldDescriptor
12823  s_fdAntennaID;
12825 
12827  inline llrp_u16_t
12829  {
12830  return m_AntennaID;
12831  }
12832 
12834  inline void
12836  llrp_u16_t value)
12837  {
12838  m_AntennaID = value;
12839  }
12840 
12841 
12842  protected:
12843  llrp_s16_t m_AntennaGain;
12844 
12847  public:
12848  static const CFieldDescriptor
12849  s_fdAntennaGain;
12851 
12853  inline llrp_s16_t
12855  {
12856  return m_AntennaGain;
12857  }
12858 
12860  inline void
12862  llrp_s16_t value)
12863  {
12864  m_AntennaGain = value;
12865  }
12866 
12867 
12868 };
12869 
12870 
12904 class CAntennaConfiguration : public CParameter
12905 {
12906  public:
12907  CAntennaConfiguration (void);
12908  ~CAntennaConfiguration (void);
12909 
12912 
12913  static const CFieldDescriptor * const
12914  s_apFieldDescriptorTable[];
12915 
12916  static const CTypeDescriptor
12917  s_typeDescriptor;
12918 
12919  void
12920  decodeFields (
12921  CDecoderStream * pDecoderStream);
12922 
12923  void
12924  assimilateSubParameters (
12925  CErrorDetails * pError);
12926 
12927  void
12928  encode (
12929  CEncoderStream * pEncoderStream) const;
12930 
12931 
12932 
12933  static CElement *
12934  s_construct (void);
12935 
12936  static void
12937  s_decodeFields (
12938  CDecoderStream * pDecoderStream,
12939  CElement * pElement);
12941 
12942 
12943  protected:
12944  llrp_u16_t m_AntennaID;
12945 
12948  public:
12949  static const CFieldDescriptor
12950  s_fdAntennaID;
12952 
12954  inline llrp_u16_t
12956  {
12957  return m_AntennaID;
12958  }
12959 
12961  inline void
12963  llrp_u16_t value)
12964  {
12965  m_AntennaID = value;
12966  }
12967 
12968 
12969  protected:
12970  CRFReceiver * m_pRFReceiver;
12971 
12972  public:
12974  inline CRFReceiver *
12976  {
12977  return m_pRFReceiver;
12978  }
12979 
12981  EResultCode
12982  setRFReceiver (
12983  CRFReceiver * pValue);
12984 
12985 
12986  protected:
12987  CRFTransmitter * m_pRFTransmitter;
12988 
12989  public:
12991  inline CRFTransmitter *
12993  {
12994  return m_pRFTransmitter;
12995  }
12996 
12998  EResultCode
13000  CRFTransmitter * pValue);
13001 
13002 
13003  protected:
13004  std::list<CParameter *> m_listAirProtocolInventoryCommandSettings;
13005 
13006  public:
13008  inline std::list<CParameter *>::iterator
13010  {
13011  return m_listAirProtocolInventoryCommandSettings.begin();
13012  }
13013 
13015  inline std::list<CParameter *>::iterator
13017  {
13018  return m_listAirProtocolInventoryCommandSettings.end();
13019  }
13020 
13022  inline void
13024  {
13025  clearSubParameterList ((tListOfParameters *) &m_listAirProtocolInventoryCommandSettings);
13026  }
13027 
13029  inline int
13031  {
13032  return (int) (m_listAirProtocolInventoryCommandSettings.size());
13033  }
13034 
13035  EResultCode
13038  CParameter * pValue);
13039 
13040 
13041 };
13042 
13043 
13074 class CRFReceiver : public CParameter
13075 {
13076  public:
13077  CRFReceiver (void);
13078  ~CRFReceiver (void);
13079 
13082 
13083  static const CFieldDescriptor * const
13084  s_apFieldDescriptorTable[];
13085 
13086  static const CTypeDescriptor
13087  s_typeDescriptor;
13088 
13089  void
13090  decodeFields (
13091  CDecoderStream * pDecoderStream);
13092 
13093  void
13094  assimilateSubParameters (
13095  CErrorDetails * pError);
13096 
13097  void
13098  encode (
13099  CEncoderStream * pEncoderStream) const;
13100 
13101 
13102 
13103  static CElement *
13104  s_construct (void);
13105 
13106  static void
13107  s_decodeFields (
13108  CDecoderStream * pDecoderStream,
13109  CElement * pElement);
13111 
13112 
13113  protected:
13114  llrp_u16_t m_ReceiverSensitivity;
13115 
13118  public:
13119  static const CFieldDescriptor
13120  s_fdReceiverSensitivity;
13122 
13124  inline llrp_u16_t
13126  {
13127  return m_ReceiverSensitivity;
13128  }
13129 
13131  inline void
13133  llrp_u16_t value)
13134  {
13135  m_ReceiverSensitivity = value;
13136  }
13137 
13138 
13139 };
13140 
13141 
13174 class CRFTransmitter : public CParameter
13175 {
13176  public:
13177  CRFTransmitter (void);
13178  ~CRFTransmitter (void);
13179 
13182 
13183  static const CFieldDescriptor * const
13184  s_apFieldDescriptorTable[];
13185 
13186  static const CTypeDescriptor
13187  s_typeDescriptor;
13188 
13189  void
13190  decodeFields (
13191  CDecoderStream * pDecoderStream);
13192 
13193  void
13194  assimilateSubParameters (
13195  CErrorDetails * pError);
13196 
13197  void
13198  encode (
13199  CEncoderStream * pEncoderStream) const;
13200 
13201 
13202 
13203  static CElement *
13204  s_construct (void);
13205 
13206  static void
13207  s_decodeFields (
13208  CDecoderStream * pDecoderStream,
13209  CElement * pElement);
13211 
13212 
13213  protected:
13214  llrp_u16_t m_HopTableID;
13215 
13218  public:
13219  static const CFieldDescriptor
13220  s_fdHopTableID;
13222 
13224  inline llrp_u16_t
13226  {
13227  return m_HopTableID;
13228  }
13229 
13231  inline void
13233  llrp_u16_t value)
13234  {
13235  m_HopTableID = value;
13236  }
13237 
13238 
13239  protected:
13240  llrp_u16_t m_ChannelIndex;
13241 
13244  public:
13245  static const CFieldDescriptor
13246  s_fdChannelIndex;
13248 
13250  inline llrp_u16_t
13252  {
13253  return m_ChannelIndex;
13254  }
13255 
13257  inline void
13259  llrp_u16_t value)
13260  {
13261  m_ChannelIndex = value;
13262  }
13263 
13264 
13265  protected:
13266  llrp_u16_t m_TransmitPower;
13267 
13270  public:
13271  static const CFieldDescriptor
13272  s_fdTransmitPower;
13274 
13276  inline llrp_u16_t
13278  {
13279  return m_TransmitPower;
13280  }
13281 
13283  inline void
13285  llrp_u16_t value)
13286  {
13287  m_TransmitPower = value;
13288  }
13289 
13290 
13291 };
13292 
13293 
13337 class CGPIPortCurrentState : public CParameter
13338 {
13339  public:
13340  CGPIPortCurrentState (void);
13341  ~CGPIPortCurrentState (void);
13342 
13345 
13346  static const CFieldDescriptor * const
13347  s_apFieldDescriptorTable[];
13348 
13349  static const CTypeDescriptor
13350  s_typeDescriptor;
13351 
13352  void
13353  decodeFields (
13354  CDecoderStream * pDecoderStream);
13355 
13356  void
13357  assimilateSubParameters (
13358  CErrorDetails * pError);
13359 
13360  void
13361  encode (
13362  CEncoderStream * pEncoderStream) const;
13363 
13364 
13365 
13366  static CElement *
13367  s_construct (void);
13368 
13369  static void
13370  s_decodeFields (
13371  CDecoderStream * pDecoderStream,
13372  CElement * pElement);
13374 
13375 
13376  protected:
13377  llrp_u16_t m_GPIPortNum;
13378 
13381  public:
13382  static const CFieldDescriptor
13383  s_fdGPIPortNum;
13385 
13387  inline llrp_u16_t
13389  {
13390  return m_GPIPortNum;
13391  }
13392 
13394  inline void
13396  llrp_u16_t value)
13397  {
13398  m_GPIPortNum = value;
13399  }
13400 
13401 
13402  protected:
13403  llrp_u1_t m_Config;
13404 
13407  public:
13408  static const CFieldDescriptor
13409  s_fdConfig;
13411 
13413  inline llrp_u1_t
13414  getConfig (void)
13415  {
13416  return m_Config;
13417  }
13418 
13420  inline void
13422  llrp_u1_t value)
13423  {
13424  m_Config = value;
13425  }
13426 
13427 
13428  protected:
13429  EGPIPortState m_eState;
13430 
13433  public:
13434  static const CFieldDescriptor
13435  s_fdState;
13437 
13439  inline EGPIPortState
13440  getState (void)
13441  {
13442  return m_eState;
13443  }
13444 
13446  inline void
13448  EGPIPortState value)
13449  {
13450  m_eState = value;
13451  }
13452 
13453 
13454 };
13455 
13456 
13488 class CEventsAndReports : public CParameter
13489 {
13490  public:
13491  CEventsAndReports (void);
13492  ~CEventsAndReports (void);
13493 
13496 
13497  static const CFieldDescriptor * const
13498  s_apFieldDescriptorTable[];
13499 
13500  static const CTypeDescriptor
13501  s_typeDescriptor;
13502 
13503  void
13504  decodeFields (
13505  CDecoderStream * pDecoderStream);
13506 
13507  void
13508  assimilateSubParameters (
13509  CErrorDetails * pError);
13510 
13511  void
13512  encode (
13513  CEncoderStream * pEncoderStream) const;
13514 
13515 
13516 
13517  static CElement *
13518  s_construct (void);
13519 
13520  static void
13521  s_decodeFields (
13522  CDecoderStream * pDecoderStream,
13523  CElement * pElement);
13525 
13526 
13527  protected:
13528  llrp_u1_t m_HoldEventsAndReportsUponReconnect;
13529 
13532  public:
13533  static const CFieldDescriptor
13534  s_fdHoldEventsAndReportsUponReconnect;
13536 
13538  inline llrp_u1_t
13540  {
13541  return m_HoldEventsAndReportsUponReconnect;
13542  }
13543 
13545  inline void
13547  llrp_u1_t value)
13548  {
13549  m_HoldEventsAndReportsUponReconnect = value;
13550  }
13551 
13552 
13553 };
13554 
13555 
13598 class CROReportSpec : public CParameter
13599 {
13600  public:
13601  CROReportSpec (void);
13602  ~CROReportSpec (void);
13603 
13606 
13607  static const CFieldDescriptor * const
13608  s_apFieldDescriptorTable[];
13609 
13610  static const CTypeDescriptor
13611  s_typeDescriptor;
13612 
13613  void
13614  decodeFields (
13615  CDecoderStream * pDecoderStream);
13616 
13617  void
13618  assimilateSubParameters (
13619  CErrorDetails * pError);
13620 
13621  void
13622  encode (
13623  CEncoderStream * pEncoderStream) const;
13624 
13625 
13626 
13627  static CElement *
13628  s_construct (void);
13629 
13630  static void
13631  s_decodeFields (
13632  CDecoderStream * pDecoderStream,
13633  CElement * pElement);
13635 
13636 
13637  protected:
13638  EROReportTriggerType m_eROReportTrigger;
13639 
13642  public:
13643  static const CFieldDescriptor
13644  s_fdROReportTrigger;
13646 
13648  inline EROReportTriggerType
13650  {
13651  return m_eROReportTrigger;
13652  }
13653 
13655  inline void
13657  EROReportTriggerType value)
13658  {
13659  m_eROReportTrigger = value;
13660  }
13661 
13662 
13663  protected:
13664  llrp_u16_t m_N;
13665 
13668  public:
13669  static const CFieldDescriptor
13670  s_fdN;
13672 
13674  inline llrp_u16_t
13675  getN (void)
13676  {
13677  return m_N;
13678  }
13679 
13681  inline void
13683  llrp_u16_t value)
13684  {
13685  m_N = value;
13686  }
13687 
13688 
13689  protected:
13690  CTagReportContentSelector * m_pTagReportContentSelector;
13691 
13692  public:
13694  inline CTagReportContentSelector *
13696  {
13697  return m_pTagReportContentSelector;
13698  }
13699 
13701  EResultCode
13703  CTagReportContentSelector * pValue);
13704 
13705 
13706  protected:
13707  std::list<CParameter *> m_listCustom;
13708 
13709  public:
13711  inline std::list<CParameter *>::iterator
13713  {
13714  return m_listCustom.begin();
13715  }
13716 
13718  inline std::list<CParameter *>::iterator
13719  endCustom (void)
13720  {
13721  return m_listCustom.end();
13722  }
13723 
13725  inline void
13727  {
13728  clearSubParameterList ((tListOfParameters *) &m_listCustom);
13729  }
13730 
13732  inline int
13734  {
13735  return (int) (m_listCustom.size());
13736  }
13737 
13738  EResultCode
13740  addCustom (
13741  CParameter * pValue);
13742 
13743 
13744 };
13745 
13746 
13788 class CTagReportContentSelector : public CParameter
13789 {
13790  public:
13792  ~CTagReportContentSelector (void);
13793 
13796 
13797  static const CFieldDescriptor * const
13798  s_apFieldDescriptorTable[];
13799 
13800  static const CTypeDescriptor
13801  s_typeDescriptor;
13802 
13803  void
13804  decodeFields (
13805  CDecoderStream * pDecoderStream);
13806 
13807  void
13808  assimilateSubParameters (
13809  CErrorDetails * pError);
13810 
13811  void
13812  encode (
13813  CEncoderStream * pEncoderStream) const;
13814 
13815 
13816 
13817  static CElement *
13818  s_construct (void);
13819 
13820  static void
13821  s_decodeFields (
13822  CDecoderStream * pDecoderStream,
13823  CElement * pElement);
13825 
13826 
13827  protected:
13828  llrp_u1_t m_EnableROSpecID;
13829 
13832  public:
13833  static const CFieldDescriptor
13834  s_fdEnableROSpecID;
13836 
13838  inline llrp_u1_t
13840  {
13841  return m_EnableROSpecID;
13842  }
13843 
13845  inline void
13847  llrp_u1_t value)
13848  {
13849  m_EnableROSpecID = value;
13850  }
13851 
13852 
13853  protected:
13854  llrp_u1_t m_EnableSpecIndex;
13855 
13858  public:
13859  static const CFieldDescriptor
13860  s_fdEnableSpecIndex;
13862 
13864  inline llrp_u1_t
13866  {
13867  return m_EnableSpecIndex;
13868  }
13869 
13871  inline void
13873  llrp_u1_t value)
13874  {
13875  m_EnableSpecIndex = value;
13876  }
13877 
13878 
13879  protected:
13880  llrp_u1_t m_EnableInventoryParameterSpecID;
13881 
13884  public:
13885  static const CFieldDescriptor
13886  s_fdEnableInventoryParameterSpecID;
13888 
13890  inline llrp_u1_t
13892  {
13893  return m_EnableInventoryParameterSpecID;
13894  }
13895 
13897  inline void
13899  llrp_u1_t value)
13900  {
13901  m_EnableInventoryParameterSpecID = value;
13902  }
13903 
13904 
13905  protected:
13906  llrp_u1_t m_EnableAntennaID;
13907 
13910  public:
13911  static const CFieldDescriptor
13912  s_fdEnableAntennaID;
13914 
13916  inline llrp_u1_t
13918  {
13919  return m_EnableAntennaID;
13920  }
13921 
13923  inline void
13925  llrp_u1_t value)
13926  {
13927  m_EnableAntennaID = value;
13928  }
13929 
13930 
13931  protected:
13932  llrp_u1_t m_EnableChannelIndex;
13933 
13936  public:
13937  static const CFieldDescriptor
13938  s_fdEnableChannelIndex;
13940 
13942  inline llrp_u1_t
13944  {
13945  return m_EnableChannelIndex;
13946  }
13947 
13949  inline void
13951  llrp_u1_t value)
13952  {
13953  m_EnableChannelIndex = value;
13954  }
13955 
13956 
13957  protected:
13958  llrp_u1_t m_EnablePeakRSSI;
13959 
13962  public:
13963  static const CFieldDescriptor
13964  s_fdEnablePeakRSSI;
13966 
13968  inline llrp_u1_t
13970  {
13971  return m_EnablePeakRSSI;
13972  }
13973 
13975  inline void
13977  llrp_u1_t value)
13978  {
13979  m_EnablePeakRSSI = value;
13980  }
13981 
13982 
13983  protected:
13984  llrp_u1_t m_EnableFirstSeenTimestamp;
13985 
13988  public:
13989  static const CFieldDescriptor
13990  s_fdEnableFirstSeenTimestamp;
13992 
13994  inline llrp_u1_t
13996  {
13997  return m_EnableFirstSeenTimestamp;
13998  }
13999 
14001  inline void
14003  llrp_u1_t value)
14004  {
14005  m_EnableFirstSeenTimestamp = value;
14006  }
14007 
14008 
14009  protected:
14010  llrp_u1_t m_EnableLastSeenTimestamp;
14011 
14014  public:
14015  static const CFieldDescriptor
14016  s_fdEnableLastSeenTimestamp;
14018 
14020  inline llrp_u1_t
14022  {
14023  return m_EnableLastSeenTimestamp;
14024  }
14025 
14027  inline void
14029  llrp_u1_t value)
14030  {
14031  m_EnableLastSeenTimestamp = value;
14032  }
14033 
14034 
14035  protected:
14036  llrp_u1_t m_EnableTagSeenCount;
14037 
14040  public:
14041  static const CFieldDescriptor
14042  s_fdEnableTagSeenCount;
14044 
14046  inline llrp_u1_t
14048  {
14049  return m_EnableTagSeenCount;
14050  }
14051 
14053  inline void
14055  llrp_u1_t value)
14056  {
14057  m_EnableTagSeenCount = value;
14058  }
14059 
14060 
14061  protected:
14062  llrp_u1_t m_EnableAccessSpecID;
14063 
14066  public:
14067  static const CFieldDescriptor
14068  s_fdEnableAccessSpecID;
14070 
14072  inline llrp_u1_t
14074  {
14075  return m_EnableAccessSpecID;
14076  }
14077 
14079  inline void
14081  llrp_u1_t value)
14082  {
14083  m_EnableAccessSpecID = value;
14084  }
14085 
14086 
14087  protected:
14088  std::list<CParameter *> m_listAirProtocolEPCMemorySelector;
14089 
14090  public:
14092  inline std::list<CParameter *>::iterator
14094  {
14095  return m_listAirProtocolEPCMemorySelector.begin();
14096  }
14097 
14099  inline std::list<CParameter *>::iterator
14101  {
14102  return m_listAirProtocolEPCMemorySelector.end();
14103  }
14104 
14106  inline void
14108  {
14109  clearSubParameterList ((tListOfParameters *) &m_listAirProtocolEPCMemorySelector);
14110  }
14111 
14113  inline int
14115  {
14116  return (int) (m_listAirProtocolEPCMemorySelector.size());
14117  }
14118 
14119  EResultCode
14122  CParameter * pValue);
14123 
14124 
14125 };
14126 
14127 
14158 class CAccessReportSpec : public CParameter
14159 {
14160  public:
14161  CAccessReportSpec (void);
14162  ~CAccessReportSpec (void);
14163 
14166 
14167  static const CFieldDescriptor * const
14168  s_apFieldDescriptorTable[];
14169 
14170  static const CTypeDescriptor
14171  s_typeDescriptor;
14172 
14173  void
14174  decodeFields (
14175  CDecoderStream * pDecoderStream);
14176 
14177  void
14178  assimilateSubParameters (
14179  CErrorDetails * pError);
14180 
14181  void
14182  encode (
14183  CEncoderStream * pEncoderStream) const;
14184 
14185 
14186 
14187  static CElement *
14188  s_construct (void);
14189 
14190  static void
14191  s_decodeFields (
14192  CDecoderStream * pDecoderStream,
14193  CElement * pElement);
14195 
14196 
14197  protected:
14198  EAccessReportTriggerType m_eAccessReportTrigger;
14199 
14202  public:
14203  static const CFieldDescriptor
14204  s_fdAccessReportTrigger;
14206 
14208  inline EAccessReportTriggerType
14210  {
14211  return m_eAccessReportTrigger;
14212  }
14213 
14215  inline void
14217  EAccessReportTriggerType value)
14218  {
14219  m_eAccessReportTrigger = value;
14220  }
14221 
14222 
14223 };
14224 
14225 
14395 class CTagReportData : public CParameter
14396 {
14397  public:
14398  CTagReportData (void);
14399  ~CTagReportData (void);
14400 
14403 
14404  static const CFieldDescriptor * const
14405  s_apFieldDescriptorTable[];
14406 
14407  static const CTypeDescriptor
14408  s_typeDescriptor;
14409 
14410  void
14411  decodeFields (
14412  CDecoderStream * pDecoderStream);
14413 
14414  void
14415  assimilateSubParameters (
14416  CErrorDetails * pError);
14417 
14418  void
14419  encode (
14420  CEncoderStream * pEncoderStream) const;
14421 
14422 
14423 
14424  static CElement *
14425  s_construct (void);
14426 
14427  static void
14428  s_decodeFields (
14429  CDecoderStream * pDecoderStream,
14430  CElement * pElement);
14432 
14433 
14434  protected:
14435  CParameter * m_pEPCParameter;
14436 
14437  public:
14439  inline CParameter *
14441  {
14442  return m_pEPCParameter;
14443  }
14444 
14446  EResultCode
14447  setEPCParameter (
14448  CParameter * pValue);
14449 
14450 
14451  protected:
14452  CROSpecID * m_pROSpecID;
14453 
14454  public:
14456  inline CROSpecID *
14458  {
14459  return m_pROSpecID;
14460  }
14461 
14463  EResultCode
14464  setROSpecID (
14465  CROSpecID * pValue);
14466 
14467 
14468  protected:
14469  CSpecIndex * m_pSpecIndex;
14470 
14471  public:
14473  inline CSpecIndex *
14475  {
14476  return m_pSpecIndex;
14477  }
14478 
14480  EResultCode
14481  setSpecIndex (
14482  CSpecIndex * pValue);
14483 
14484 
14485  protected:
14486  CInventoryParameterSpecID * m_pInventoryParameterSpecID;
14487 
14488  public:
14490  inline CInventoryParameterSpecID *
14492  {
14493  return m_pInventoryParameterSpecID;
14494  }
14495 
14497  EResultCode
14499  CInventoryParameterSpecID * pValue);
14500 
14501 
14502  protected:
14503  CAntennaID * m_pAntennaID;
14504 
14505  public:
14507  inline CAntennaID *
14509  {
14510  return m_pAntennaID;
14511  }
14512 
14514  EResultCode
14515  setAntennaID (
14516  CAntennaID * pValue);
14517 
14518 
14519  protected:
14520  CPeakRSSI * m_pPeakRSSI;
14521 
14522  public:
14524  inline CPeakRSSI *
14526  {
14527  return m_pPeakRSSI;
14528  }
14529 
14531  EResultCode
14532  setPeakRSSI (
14533  CPeakRSSI * pValue);
14534 
14535 
14536  protected:
14537  CChannelIndex * m_pChannelIndex;
14538 
14539  public:
14541  inline CChannelIndex *
14543  {
14544  return m_pChannelIndex;
14545  }
14546 
14548  EResultCode
14549  setChannelIndex (
14550  CChannelIndex * pValue);
14551 
14552 
14553  protected:
14554  CFirstSeenTimestampUTC * m_pFirstSeenTimestampUTC;
14555 
14556  public:
14558  inline CFirstSeenTimestampUTC *
14560  {
14561  return m_pFirstSeenTimestampUTC;
14562  }
14563 
14565  EResultCode
14567  CFirstSeenTimestampUTC * pValue);
14568 
14569 
14570  protected:
14571  CFirstSeenTimestampUptime * m_pFirstSeenTimestampUptime;
14572 
14573  public:
14575  inline CFirstSeenTimestampUptime *
14577  {
14578  return m_pFirstSeenTimestampUptime;
14579  }
14580 
14582  EResultCode
14584  CFirstSeenTimestampUptime * pValue);
14585 
14586 
14587  protected:
14588  CLastSeenTimestampUTC * m_pLastSeenTimestampUTC;
14589 
14590  public:
14592  inline CLastSeenTimestampUTC *
14594  {
14595  return m_pLastSeenTimestampUTC;
14596  }
14597 
14599  EResultCode
14601  CLastSeenTimestampUTC * pValue);
14602 
14603 
14604  protected:
14605  CLastSeenTimestampUptime * m_pLastSeenTimestampUptime;
14606 
14607  public:
14609  inline CLastSeenTimestampUptime *
14611  {
14612  return m_pLastSeenTimestampUptime;
14613  }
14614 
14616  EResultCode
14618  CLastSeenTimestampUptime * pValue);
14619 
14620 
14621  protected:
14622  CTagSeenCount * m_pTagSeenCount;
14623 
14624  public:
14626  inline CTagSeenCount *
14628  {
14629  return m_pTagSeenCount;
14630  }
14631 
14633  EResultCode
14634  setTagSeenCount (
14635  CTagSeenCount * pValue);
14636 
14637 
14638  protected:
14639  std::list<CParameter *> m_listAirProtocolTagData;
14640 
14641  public:
14643  inline std::list<CParameter *>::iterator
14645  {
14646  return m_listAirProtocolTagData.begin();
14647  }
14648 
14650  inline std::list<CParameter *>::iterator
14652  {
14653  return m_listAirProtocolTagData.end();
14654  }
14655 
14657  inline void
14659  {
14660  clearSubParameterList ((tListOfParameters *) &m_listAirProtocolTagData);
14661  }
14662 
14664  inline int
14666  {
14667  return (int) (m_listAirProtocolTagData.size());
14668  }
14669 
14670  EResultCode
14673  CParameter * pValue);
14674 
14675 
14676  protected:
14677  CAccessSpecID * m_pAccessSpecID;
14678 
14679  public:
14681  inline CAccessSpecID *
14683  {
14684  return m_pAccessSpecID;
14685  }
14686 
14688  EResultCode
14689  setAccessSpecID (
14690  CAccessSpecID * pValue);
14691 
14692 
14693  protected:
14694  std::list<CParameter *> m_listAccessCommandOpSpecResult;
14695 
14696  public:
14698  inline std::list<CParameter *>::iterator
14700  {
14701  return m_listAccessCommandOpSpecResult.begin();
14702  }
14703 
14705  inline std::list<CParameter *>::iterator
14707  {
14708  return m_listAccessCommandOpSpecResult.end();
14709  }
14710 
14712  inline void
14714  {
14715  clearSubParameterList ((tListOfParameters *) &m_listAccessCommandOpSpecResult);
14716  }
14717 
14719  inline int
14721  {
14722  return (int) (m_listAccessCommandOpSpecResult.size());
14723  }
14724 
14725  EResultCode
14728  CParameter * pValue);
14729 
14730 
14731  protected:
14732  std::list<CParameter *> m_listCustom;
14733 
14734  public:
14736  inline std::list<CParameter *>::iterator
14738  {
14739  return m_listCustom.begin();
14740  }
14741 
14743  inline std::list<CParameter *>::iterator
14744  endCustom (void)
14745  {
14746  return m_listCustom.end();
14747  }
14748 
14750  inline void
14752  {
14753  clearSubParameterList ((tListOfParameters *) &m_listCustom);
14754  }
14755 
14757  inline int
14759  {
14760  return (int) (m_listCustom.size());
14761  }
14762 
14763  EResultCode
14765  addCustom (
14766  CParameter * pValue);
14767 
14768 
14769 };
14770 
14771 
14802 class CEPCData : public CParameter
14803 {
14804  public:
14805  CEPCData (void);
14806  ~CEPCData (void);
14807 
14810 
14811  static const CFieldDescriptor * const
14812  s_apFieldDescriptorTable[];
14813 
14814  static const CTypeDescriptor
14815  s_typeDescriptor;
14816 
14817  void
14818  decodeFields (
14819  CDecoderStream * pDecoderStream);
14820 
14821  void
14822  assimilateSubParameters (
14823  CErrorDetails * pError);
14824 
14825  void
14826  encode (
14827  CEncoderStream * pEncoderStream) const;
14828 
14829 
14830 
14831  static CElement *
14832  s_construct (void);
14833 
14834  static void
14835  s_decodeFields (
14836  CDecoderStream * pDecoderStream,
14837  CElement * pElement);
14839 
14840 
14841  protected:
14842  llrp_u1v_t m_EPC;
14843 
14846  public:
14847  static const CFieldDescriptor
14848  s_fdEPC;
14850 
14852  inline llrp_u1v_t
14853  getEPC (void)
14854  {
14855  return m_EPC;
14856  }
14857 
14859  inline void
14861  llrp_u1v_t value)
14862  {
14863  m_EPC = value;
14864  }
14865 
14866 
14867 };
14868 
14869 
14900 class CEPC_96 : public CParameter
14901 {
14902  public:
14903  CEPC_96 (void);
14904  ~CEPC_96 (void);
14905 
14908 
14909  static const CFieldDescriptor * const
14910  s_apFieldDescriptorTable[];
14911 
14912  static const CTypeDescriptor
14913  s_typeDescriptor;
14914 
14915  void
14916  decodeFields (
14917  CDecoderStream * pDecoderStream);
14918 
14919  void
14920  assimilateSubParameters (
14921  CErrorDetails * pError);
14922 
14923  void
14924  encode (
14925  CEncoderStream * pEncoderStream) const;
14926 
14927 
14928 
14929  static CElement *
14930  s_construct (void);
14931 
14932  static void
14933  s_decodeFields (
14934  CDecoderStream * pDecoderStream,
14935  CElement * pElement);
14937 
14938 
14939  protected:
14940  llrp_u96_t m_EPC;
14941 
14944  public:
14945  static const CFieldDescriptor
14946  s_fdEPC;
14948 
14950  inline llrp_u96_t
14951  getEPC (void)
14952  {
14953  return m_EPC;
14954  }
14955 
14957  inline void
14959  llrp_u96_t value)
14960  {
14961  m_EPC = value;
14962  }
14963 
14964 
14965 };
14966 
14967 
14998 class CROSpecID : public CParameter
14999 {
15000  public:
15001  CROSpecID (void);
15002  ~CROSpecID (void);
15003 
15006 
15007  static const CFieldDescriptor * const
15008  s_apFieldDescriptorTable[];
15009 
15010  static const CTypeDescriptor
15011  s_typeDescriptor;
15012 
15013  void
15014  decodeFields (
15015  CDecoderStream * pDecoderStream);
15016 
15017  void
15018  assimilateSubParameters (
15019  CErrorDetails * pError);
15020 
15021  void
15022  encode (
15023  CEncoderStream * pEncoderStream) const;
15024 
15025 
15026 
15027  static CElement *
15028  s_construct (void);
15029 
15030  static void
15031  s_decodeFields (
15032  CDecoderStream * pDecoderStream,
15033  CElement * pElement);
15035 
15036 
15037  protected:
15038  llrp_u32_t m_ROSpecID;
15039 
15042  public:
15043  static const CFieldDescriptor
15044  s_fdROSpecID;
15046 
15048  inline llrp_u32_t
15050  {
15051  return m_ROSpecID;
15052  }
15053 
15055  inline void
15057  llrp_u32_t value)
15058  {
15059  m_ROSpecID = value;
15060  }
15061 
15062 
15063 };
15064 
15065 
15096 class CSpecIndex : public CParameter
15097 {
15098  public:
15099  CSpecIndex (void);
15100  ~CSpecIndex (void);
15101 
15104 
15105  static const CFieldDescriptor * const
15106  s_apFieldDescriptorTable[];
15107 
15108  static const CTypeDescriptor
15109  s_typeDescriptor;
15110 
15111  void
15112  decodeFields (
15113  CDecoderStream * pDecoderStream);
15114 
15115  void
15116  assimilateSubParameters (
15117  CErrorDetails * pError);
15118 
15119  void
15120  encode (
15121  CEncoderStream * pEncoderStream) const;
15122 
15123 
15124 
15125  static CElement *
15126  s_construct (void);
15127 
15128  static void
15129  s_decodeFields (
15130  CDecoderStream * pDecoderStream,
15131  CElement * pElement);
15133 
15134 
15135  protected:
15136  llrp_u16_t m_SpecIndex;
15137 
15140  public:
15141  static const CFieldDescriptor
15142  s_fdSpecIndex;
15144 
15146  inline llrp_u16_t
15148  {
15149  return m_SpecIndex;
15150  }
15151 
15153  inline void
15155  llrp_u16_t value)
15156  {
15157  m_SpecIndex = value;
15158  }
15159 
15160 
15161 };
15162 
15163 
15194 class CInventoryParameterSpecID : public CParameter
15195 {
15196  public:
15198  ~CInventoryParameterSpecID (void);
15199 
15202 
15203  static const CFieldDescriptor * const
15204  s_apFieldDescriptorTable[];
15205 
15206  static const CTypeDescriptor
15207  s_typeDescriptor;
15208 
15209  void
15210  decodeFields (
15211  CDecoderStream * pDecoderStream);
15212 
15213  void
15214  assimilateSubParameters (
15215  CErrorDetails * pError);
15216 
15217  void
15218  encode (
15219  CEncoderStream * pEncoderStream) const;
15220 
15221 
15222 
15223  static CElement *
15224  s_construct (void);
15225 
15226  static void
15227  s_decodeFields (
15228  CDecoderStream * pDecoderStream,
15229  CElement * pElement);
15231 
15232 
15233  protected:
15234  llrp_u16_t m_InventoryParameterSpecID;
15235 
15238  public:
15239  static const CFieldDescriptor
15240  s_fdInventoryParameterSpecID;
15242 
15244  inline llrp_u16_t
15246  {
15247  return m_InventoryParameterSpecID;
15248  }
15249 
15251  inline void
15253  llrp_u16_t value)
15254  {
15255  m_InventoryParameterSpecID = value;
15256  }
15257 
15258 
15259 };
15260 
15261 
15292 class CAntennaID : public CParameter
15293 {
15294  public:
15295  CAntennaID (void);
15296  ~CAntennaID (void);
15297 
15300 
15301  static const CFieldDescriptor * const
15302  s_apFieldDescriptorTable[];
15303 
15304  static const CTypeDescriptor
15305  s_typeDescriptor;
15306 
15307  void
15308  decodeFields (
15309  CDecoderStream * pDecoderStream);
15310 
15311  void
15312  assimilateSubParameters (
15313  CErrorDetails * pError);
15314 
15315  void
15316  encode (
15317  CEncoderStream * pEncoderStream) const;
15318 
15319 
15320 
15321  static CElement *
15322  s_construct (void);
15323 
15324  static void
15325  s_decodeFields (
15326  CDecoderStream * pDecoderStream,
15327  CElement * pElement);
15329 
15330 
15331  protected:
15332  llrp_u16_t m_AntennaID;
15333 
15336  public:
15337  static const CFieldDescriptor
15338  s_fdAntennaID;
15340 
15342  inline llrp_u16_t
15344  {
15345  return m_AntennaID;
15346  }
15347 
15349  inline void
15351  llrp_u16_t value)
15352  {
15353  m_AntennaID = value;
15354  }
15355 
15356 
15357 };
15358 
15359 
15393 class CPeakRSSI : public CParameter
15394 {
15395  public:
15396  CPeakRSSI (void);
15397  ~CPeakRSSI (void);
15398 
15401 
15402  static const CFieldDescriptor * const
15403  s_apFieldDescriptorTable[];
15404 
15405  static const CTypeDescriptor
15406  s_typeDescriptor;
15407 
15408  void
15409  decodeFields (
15410  CDecoderStream * pDecoderStream);
15411 
15412  void
15413  assimilateSubParameters (
15414  CErrorDetails * pError);
15415 
15416  void
15417  encode (
15418  CEncoderStream * pEncoderStream) const;
15419 
15420 
15421 
15422  static CElement *
15423  s_construct (void);
15424 
15425  static void
15426  s_decodeFields (
15427  CDecoderStream * pDecoderStream,
15428  CElement * pElement);
15430 
15431 
15432  protected:
15433  llrp_s8_t m_PeakRSSI;
15434 
15437  public:
15438  static const CFieldDescriptor
15439  s_fdPeakRSSI;
15441 
15443  inline llrp_s8_t
15445  {
15446  return m_PeakRSSI;
15447  }
15448 
15450  inline void
15452  llrp_s8_t value)
15453  {
15454  m_PeakRSSI = value;
15455  }
15456 
15457 
15458 };
15459 
15460 
15491 class CChannelIndex : public CParameter
15492 {
15493  public:
15494  CChannelIndex (void);
15495  ~CChannelIndex (void);
15496 
15499 
15500  static const CFieldDescriptor * const
15501  s_apFieldDescriptorTable[];
15502 
15503  static const CTypeDescriptor
15504  s_typeDescriptor;
15505 
15506  void
15507  decodeFields (
15508  CDecoderStream * pDecoderStream);
15509 
15510  void
15511  assimilateSubParameters (
15512  CErrorDetails * pError);
15513 
15514  void
15515  encode (
15516  CEncoderStream * pEncoderStream) const;
15517 
15518 
15519 
15520  static CElement *
15521  s_construct (void);
15522 
15523  static void
15524  s_decodeFields (
15525  CDecoderStream * pDecoderStream,
15526  CElement * pElement);
15528 
15529 
15530  protected:
15531  llrp_u16_t m_ChannelIndex;
15532 
15535  public:
15536  static const CFieldDescriptor
15537  s_fdChannelIndex;
15539 
15541  inline llrp_u16_t
15543  {
15544  return m_ChannelIndex;
15545  }
15546 
15548  inline void
15550  llrp_u16_t value)
15551  {
15552  m_ChannelIndex = value;
15553  }
15554 
15555 
15556 };
15557 
15558 
15597 class CFirstSeenTimestampUTC : public CParameter
15598 {
15599  public:
15600  CFirstSeenTimestampUTC (void);
15601  ~CFirstSeenTimestampUTC (void);
15602 
15605 
15606  static const CFieldDescriptor * const
15607  s_apFieldDescriptorTable[];
15608 
15609  static const CTypeDescriptor
15610  s_typeDescriptor;
15611 
15612  void
15613  decodeFields (
15614  CDecoderStream * pDecoderStream);
15615 
15616  void
15617  assimilateSubParameters (
15618  CErrorDetails * pError);
15619 
15620  void
15621  encode (
15622  CEncoderStream * pEncoderStream) const;
15623 
15624 
15625 
15626  static CElement *
15627  s_construct (void);
15628 
15629  static void
15630  s_decodeFields (
15631  CDecoderStream * pDecoderStream,
15632  CElement * pElement);
15634 
15635 
15636  protected:
15637  llrp_u64_t m_Microseconds;
15638 
15641  public:
15642  static const CFieldDescriptor
15643  s_fdMicroseconds;
15645 
15647  inline llrp_u64_t
15649  {
15650  return m_Microseconds;
15651  }
15652 
15654  inline void
15656  llrp_u64_t value)
15657  {
15658  m_Microseconds = value;
15659  }
15660 
15661 
15662 };
15663 
15664 
15702 class CFirstSeenTimestampUptime : public CParameter
15703 {
15704  public:
15706  ~CFirstSeenTimestampUptime (void);
15707 
15710 
15711  static const CFieldDescriptor * const
15712  s_apFieldDescriptorTable[];
15713 
15714  static const CTypeDescriptor
15715  s_typeDescriptor;
15716 
15717  void
15718  decodeFields (
15719  CDecoderStream * pDecoderStream);
15720 
15721  void
15722  assimilateSubParameters (
15723  CErrorDetails * pError);
15724 
15725  void
15726  encode (
15727  CEncoderStream * pEncoderStream) const;
15728 
15729 
15730 
15731  static CElement *
15732  s_construct (void);
15733 
15734  static void
15735  s_decodeFields (
15736  CDecoderStream * pDecoderStream,
15737  CElement * pElement);
15739 
15740 
15741  protected:
15742  llrp_u64_t m_Microseconds;
15743 
15746  public:
15747  static const CFieldDescriptor
15748  s_fdMicroseconds;
15750 
15752  inline llrp_u64_t
15754  {
15755  return m_Microseconds;
15756  }
15757 
15759  inline void
15761  llrp_u64_t value)
15762  {
15763  m_Microseconds = value;
15764  }
15765 
15766 
15767 };
15768 
15769 
15803 class CLastSeenTimestampUTC : public CParameter
15804 {
15805  public:
15806  CLastSeenTimestampUTC (void);
15807  ~CLastSeenTimestampUTC (void);
15808 
15811 
15812  static const CFieldDescriptor * const
15813  s_apFieldDescriptorTable[];
15814 
15815  static const CTypeDescriptor
15816  s_typeDescriptor;
15817 
15818  void
15819  decodeFields (
15820  CDecoderStream * pDecoderStream);
15821 
15822  void
15823  assimilateSubParameters (
15824  CErrorDetails * pError);
15825 
15826  void
15827  encode (
15828  CEncoderStream * pEncoderStream) const;
15829 
15830 
15831 
15832  static CElement *
15833  s_construct (void);
15834 
15835  static void
15836  s_decodeFields (
15837  CDecoderStream * pDecoderStream,
15838  CElement * pElement);
15840 
15841 
15842  protected:
15843  llrp_u64_t m_Microseconds;
15844 
15847  public:
15848  static const CFieldDescriptor
15849  s_fdMicroseconds;
15851 
15853  inline llrp_u64_t
15855  {
15856  return m_Microseconds;
15857  }
15858 
15860  inline void
15862  llrp_u64_t value)
15863  {
15864  m_Microseconds = value;
15865  }
15866 
15867 
15868 };
15869 
15870 
15904 class CLastSeenTimestampUptime : public CParameter
15905 {
15906  public:
15907  CLastSeenTimestampUptime (void);
15908  ~CLastSeenTimestampUptime (void);
15909 
15912 
15913  static const CFieldDescriptor * const
15914  s_apFieldDescriptorTable[];
15915 
15916  static const CTypeDescriptor
15917  s_typeDescriptor;
15918 
15919  void
15920  decodeFields (
15921  CDecoderStream * pDecoderStream);
15922 
15923  void
15924  assimilateSubParameters (
15925  CErrorDetails * pError);
15926 
15927  void
15928  encode (
15929  CEncoderStream * pEncoderStream) const;
15930 
15931 
15932 
15933  static CElement *
15934  s_construct (void);
15935 
15936  static void
15937  s_decodeFields (
15938  CDecoderStream * pDecoderStream,
15939  CElement * pElement);
15941 
15942 
15943  protected:
15944  llrp_u64_t m_Microseconds;
15945 
15948  public:
15949  static const CFieldDescriptor
15950  s_fdMicroseconds;
15952 
15954  inline llrp_u64_t
15956  {
15957  return m_Microseconds;
15958  }
15959 
15961  inline void
15963  llrp_u64_t value)
15964  {
15965  m_Microseconds = value;
15966  }
15967 
15968 
15969 };
15970 
15971 
16004 class CTagSeenCount : public CParameter
16005 {
16006  public:
16007  CTagSeenCount (void);
16008  ~CTagSeenCount (void);
16009 
16012 
16013  static const CFieldDescriptor * const
16014  s_apFieldDescriptorTable[];
16015 
16016  static const CTypeDescriptor
16017  s_typeDescriptor;
16018 
16019  void
16020  decodeFields (
16021  CDecoderStream * pDecoderStream);
16022 
16023  void
16024  assimilateSubParameters (
16025  CErrorDetails * pError);
16026 
16027  void
16028  encode (
16029  CEncoderStream * pEncoderStream) const;
16030 
16031 
16032 
16033  static CElement *
16034  s_construct (void);
16035 
16036  static void
16037  s_decodeFields (
16038  CDecoderStream * pDecoderStream,
16039  CElement * pElement);
16041 
16042 
16043  protected:
16044  llrp_u16_t m_TagCount;
16045 
16048  public:
16049  static const CFieldDescriptor
16050  s_fdTagCount;
16052 
16054  inline llrp_u16_t
16056  {
16057  return m_TagCount;
16058  }
16059 
16061  inline void
16063  llrp_u16_t value)
16064  {
16065  m_TagCount = value;
16066  }
16067 
16068 
16069 };
16070 
16071 
16099 class CClientRequestOpSpecResult : public CParameter
16100 {
16101  public:
16104 
16107 
16108  static const CFieldDescriptor * const
16109  s_apFieldDescriptorTable[];
16110 
16111  static const CTypeDescriptor
16112  s_typeDescriptor;
16113 
16114  void
16115  decodeFields (
16116  CDecoderStream * pDecoderStream);
16117 
16118  void
16119  assimilateSubParameters (
16120  CErrorDetails * pError);
16121 
16122  void
16123  encode (
16124  CEncoderStream * pEncoderStream) const;
16125 
16126 
16127 
16128  static CElement *
16129  s_construct (void);
16130 
16131  static void
16132  s_decodeFields (
16133  CDecoderStream * pDecoderStream,
16134  CElement * pElement);
16136 
16137 
16138  protected:
16139  llrp_u16_t m_OpSpecID;
16140 
16143  public:
16144  static const CFieldDescriptor
16145  s_fdOpSpecID;
16147 
16149  inline llrp_u16_t
16151  {
16152  return m_OpSpecID;
16153  }
16154 
16156  inline void
16158  llrp_u16_t value)
16159  {
16160  m_OpSpecID = value;
16161  }
16162 
16163 
16164 };
16165 
16166 
16197 class CAccessSpecID : public CParameter
16198 {
16199  public:
16200  CAccessSpecID (void);
16201  ~CAccessSpecID (void);
16202 
16205 
16206  static const CFieldDescriptor * const
16207  s_apFieldDescriptorTable[];
16208 
16209  static const CTypeDescriptor
16210  s_typeDescriptor;
16211 
16212  void
16213  decodeFields (
16214  CDecoderStream * pDecoderStream);
16215 
16216  void
16217  assimilateSubParameters (
16218  CErrorDetails * pError);
16219 
16220  void
16221  encode (
16222  CEncoderStream * pEncoderStream) const;
16223 
16224 
16225 
16226  static CElement *
16227  s_construct (void);
16228 
16229  static void
16230  s_decodeFields (
16231  CDecoderStream * pDecoderStream,
16232  CElement * pElement);
16234 
16235 
16236  protected:
16237  llrp_u32_t m_AccessSpecID;
16238 
16241  public:
16242  static const CFieldDescriptor
16243  s_fdAccessSpecID;
16245 
16247  inline llrp_u32_t
16249  {
16250  return m_AccessSpecID;
16251  }
16252 
16254  inline void
16256  llrp_u32_t value)
16257  {
16258  m_AccessSpecID = value;
16259  }
16260 
16261 
16262 };
16263 
16264 
16298 class CRFSurveyReportData : public CParameter
16299 {
16300  public:
16301  CRFSurveyReportData (void);
16302  ~CRFSurveyReportData (void);
16303 
16306 
16307  static const CFieldDescriptor * const
16308  s_apFieldDescriptorTable[];
16309 
16310  static const CTypeDescriptor
16311  s_typeDescriptor;
16312 
16313  void
16314  decodeFields (
16315  CDecoderStream * pDecoderStream);
16316 
16317  void
16318  assimilateSubParameters (
16319  CErrorDetails * pError);
16320 
16321  void
16322  encode (
16323  CEncoderStream * pEncoderStream) const;
16324 
16325 
16326 
16327  static CElement *
16328  s_construct (void);
16329 
16330  static void
16331  s_decodeFields (
16332  CDecoderStream * pDecoderStream,
16333  CElement * pElement);
16335 
16336 
16337  protected:
16338  CROSpecID * m_pROSpecID;
16339 
16340  public:
16342  inline CROSpecID *
16344  {
16345  return m_pROSpecID;
16346  }
16347 
16349  EResultCode
16350  setROSpecID (
16351  CROSpecID * pValue);
16352 
16353 
16354  protected:
16355  CSpecIndex * m_pSpecIndex;
16356 
16357  public:
16359  inline CSpecIndex *
16361  {
16362  return m_pSpecIndex;
16363  }
16364 
16366  EResultCode
16367  setSpecIndex (
16368  CSpecIndex * pValue);
16369 
16370 
16371  protected:
16372  std::list<CFrequencyRSSILevelEntry *> m_listFrequencyRSSILevelEntry;
16373 
16374  public:
16376  inline std::list<CFrequencyRSSILevelEntry *>::iterator
16378  {
16379  return m_listFrequencyRSSILevelEntry.begin();
16380  }
16381 
16383  inline std::list<CFrequencyRSSILevelEntry *>::iterator
16385  {
16386  return m_listFrequencyRSSILevelEntry.end();
16387  }
16388 
16390  inline void
16392  {
16393  clearSubParameterList ((tListOfParameters *) &m_listFrequencyRSSILevelEntry);
16394  }
16395 
16397  inline int
16399  {
16400  return (int) (m_listFrequencyRSSILevelEntry.size());
16401  }
16402 
16403  EResultCode
16406  CFrequencyRSSILevelEntry * pValue);
16407 
16408 
16409  protected:
16410  std::list<CParameter *> m_listCustom;
16411 
16412  public:
16414  inline std::list<CParameter *>::iterator
16416  {
16417  return m_listCustom.begin();
16418  }
16419 
16421  inline std::list<CParameter *>::iterator
16422  endCustom (void)
16423  {
16424  return m_listCustom.end();
16425  }
16426 
16428  inline void
16430  {
16431  clearSubParameterList ((tListOfParameters *) &m_listCustom);
16432  }
16433 
16435  inline int
16437  {
16438  return (int) (m_listCustom.size());
16439  }
16440 
16441  EResultCode
16443  addCustom (
16444  CParameter * pValue);
16445 
16446 
16447 };
16448 
16449 
16508 class CFrequencyRSSILevelEntry : public CParameter
16509 {
16510  public:
16511  CFrequencyRSSILevelEntry (void);
16512  ~CFrequencyRSSILevelEntry (void);
16513 
16516 
16517  static const CFieldDescriptor * const
16518  s_apFieldDescriptorTable[];
16519 
16520  static const CTypeDescriptor
16521  s_typeDescriptor;
16522 
16523  void
16524  decodeFields (
16525  CDecoderStream * pDecoderStream);
16526 
16527  void
16528  assimilateSubParameters (
16529  CErrorDetails * pError);
16530 
16531  void
16532  encode (
16533  CEncoderStream * pEncoderStream) const;
16534 
16535 
16536 
16537  static CElement *
16538  s_construct (void);
16539 
16540  static void
16541  s_decodeFields (
16542  CDecoderStream * pDecoderStream,
16543  CElement * pElement);
16545 
16546 
16547  protected:
16548  llrp_u32_t m_Frequency;
16549 
16552  public:
16553  static const CFieldDescriptor
16554  s_fdFrequency;
16556 
16558  inline llrp_u32_t
16560  {
16561  return m_Frequency;
16562  }
16563 
16565  inline void
16567  llrp_u32_t value)
16568  {
16569  m_Frequency = value;
16570  }
16571 
16572 
16573  protected:
16574  llrp_u32_t m_Bandwidth;
16575 
16578  public:
16579  static const CFieldDescriptor
16580  s_fdBandwidth;
16582 
16584  inline llrp_u32_t
16586  {
16587  return m_Bandwidth;
16588  }
16589 
16591  inline void
16593  llrp_u32_t value)
16594  {
16595  m_Bandwidth = value;
16596  }
16597 
16598 
16599  protected:
16600  llrp_s8_t m_AverageRSSI;
16601 
16604  public:
16605  static const CFieldDescriptor
16606  s_fdAverageRSSI;
16608 
16610  inline llrp_s8_t
16612  {
16613  return m_AverageRSSI;
16614  }
16615 
16617  inline void
16619  llrp_s8_t value)
16620  {
16621  m_AverageRSSI = value;
16622  }
16623 
16624 
16625  protected:
16626  llrp_s8_t m_PeakRSSI;
16627 
16630  public:
16631  static const CFieldDescriptor
16632  s_fdPeakRSSI;
16634 
16636  inline llrp_s8_t
16638  {
16639  return m_PeakRSSI;
16640  }
16641 
16643  inline void
16645  llrp_s8_t value)
16646  {
16647  m_PeakRSSI = value;
16648  }
16649 
16650 
16651  protected:
16652  CParameter * m_pTimestamp;
16653 
16654  public:
16656  inline CParameter *
16658  {
16659  return m_pTimestamp;
16660  }
16661 
16663  EResultCode
16664  setTimestamp (
16665  CParameter * pValue);
16666 
16667 
16668 };
16669 
16670 
16701 class CReaderEventNotificationSpec : public CParameter
16702 {
16703  public:
16706 
16709 
16710  static const CFieldDescriptor * const
16711  s_apFieldDescriptorTable[];
16712 
16713  static const CTypeDescriptor
16714  s_typeDescriptor;
16715 
16716  void
16717  decodeFields (
16718  CDecoderStream * pDecoderStream);
16719 
16720  void
16721  assimilateSubParameters (
16722  CErrorDetails * pError);
16723 
16724  void
16725  encode (
16726  CEncoderStream * pEncoderStream) const;
16727 
16728 
16729 
16730  static CElement *
16731  s_construct (void);
16732 
16733  static void
16734  s_decodeFields (
16735  CDecoderStream * pDecoderStream,
16736  CElement * pElement);
16738 
16739 
16740  protected:
16741  std::list<CEventNotificationState *> m_listEventNotificationState;
16742 
16743  public:
16745  inline std::list<CEventNotificationState *>::iterator
16747  {
16748  return m_listEventNotificationState.begin();
16749  }
16750 
16752  inline std::list<CEventNotificationState *>::iterator
16754  {
16755  return m_listEventNotificationState.end();
16756  }
16757 
16759  inline void
16761  {
16762  clearSubParameterList ((tListOfParameters *) &m_listEventNotificationState);
16763  }
16764 
16766  inline int
16768  {
16769  return (int) (m_listEventNotificationState.size());
16770  }
16771 
16772  EResultCode
16775  CEventNotificationState * pValue);
16776 
16777 
16778 };
16779 
16780 
16813 class CEventNotificationState : public CParameter
16814 {
16815  public:
16816  CEventNotificationState (void);
16817  ~CEventNotificationState (void);
16818 
16821 
16822  static const CFieldDescriptor * const
16823  s_apFieldDescriptorTable[];
16824 
16825  static const CTypeDescriptor
16826  s_typeDescriptor;
16827 
16828  void
16829  decodeFields (
16830  CDecoderStream * pDecoderStream);
16831 
16832  void
16833  assimilateSubParameters (
16834  CErrorDetails * pError);
16835 
16836  void
16837  encode (
16838  CEncoderStream * pEncoderStream) const;
16839 
16840 
16841 
16842  static CElement *
16843  s_construct (void);
16844 
16845  static void
16846  s_decodeFields (
16847  CDecoderStream * pDecoderStream,
16848  CElement * pElement);
16850 
16851 
16852  protected:
16853  ENotificationEventType m_eEventType;
16854 
16857  public:
16858  static const CFieldDescriptor
16859  s_fdEventType;
16861 
16863  inline ENotificationEventType
16865  {
16866  return m_eEventType;
16867  }
16868 
16870  inline void
16872  ENotificationEventType value)
16873  {
16874  m_eEventType = value;
16875  }
16876 
16877 
16878  protected:
16879  llrp_u1_t m_NotificationState;
16880 
16883  public:
16884  static const CFieldDescriptor
16885  s_fdNotificationState;
16887 
16889  inline llrp_u1_t
16891  {
16892  return m_NotificationState;
16893  }
16894 
16896  inline void
16898  llrp_u1_t value)
16899  {
16900  m_NotificationState = value;
16901  }
16902 
16903 
16904 };
16905 
16906 
17016 class CReaderEventNotificationData : public CParameter
17017 {
17018  public:
17021 
17024 
17025  static const CFieldDescriptor * const
17026  s_apFieldDescriptorTable[];
17027 
17028  static const CTypeDescriptor
17029  s_typeDescriptor;
17030 
17031  void
17032  decodeFields (
17033  CDecoderStream * pDecoderStream);
17034 
17035  void
17036  assimilateSubParameters (
17037  CErrorDetails * pError);
17038 
17039  void
17040  encode (
17041  CEncoderStream * pEncoderStream) const;
17042 
17043 
17044 
17045  static CElement *
17046  s_construct (void);
17047 
17048  static void
17049  s_decodeFields (
17050  CDecoderStream * pDecoderStream,
17051  CElement * pElement);
17053 
17054 
17055  protected:
17056  CParameter * m_pTimestamp;
17057 
17058  public:
17060  inline CParameter *
17062  {
17063  return m_pTimestamp;
17064  }
17065 
17067  EResultCode
17068  setTimestamp (
17069  CParameter * pValue);
17070 
17071 
17072  protected:
17073  CHoppingEvent * m_pHoppingEvent;
17074 
17075  public:
17077  inline CHoppingEvent *
17079  {
17080  return m_pHoppingEvent;
17081  }
17082 
17084  EResultCode
17085  setHoppingEvent (
17086  CHoppingEvent * pValue);
17087 
17088 
17089  protected:
17090  CGPIEvent * m_pGPIEvent;
17091 
17092  public:
17094  inline CGPIEvent *
17096  {
17097  return m_pGPIEvent;
17098  }
17099 
17101  EResultCode
17102  setGPIEvent (
17103  CGPIEvent * pValue);
17104 
17105 
17106  protected:
17107  CROSpecEvent * m_pROSpecEvent;
17108 
17109  public:
17111  inline CROSpecEvent *
17113  {
17114  return m_pROSpecEvent;
17115  }
17116 
17118  EResultCode
17119  setROSpecEvent (
17120  CROSpecEvent * pValue);
17121 
17122 
17123  protected:
17124  CReportBufferLevelWarningEvent * m_pReportBufferLevelWarningEvent;
17125 
17126  public:
17130  {
17131  return m_pReportBufferLevelWarningEvent;
17132  }
17133 
17135  EResultCode
17138 
17139 
17140  protected:
17141  CReportBufferOverflowErrorEvent * m_pReportBufferOverflowErrorEvent;
17142 
17143  public:
17147  {
17148  return m_pReportBufferOverflowErrorEvent;
17149  }
17150 
17152  EResultCode
17155 
17156 
17157  protected:
17158  CReaderExceptionEvent * m_pReaderExceptionEvent;
17159 
17160  public:
17162  inline CReaderExceptionEvent *
17164  {
17165  return m_pReaderExceptionEvent;
17166  }
17167 
17169  EResultCode
17171  CReaderExceptionEvent * pValue);
17172 
17173 
17174  protected:
17175  CRFSurveyEvent * m_pRFSurveyEvent;
17176 
17177  public:
17179  inline CRFSurveyEvent *
17181  {
17182  return m_pRFSurveyEvent;
17183  }
17184 
17186  EResultCode
17188  CRFSurveyEvent * pValue);
17189 
17190 
17191  protected:
17192  CAISpecEvent * m_pAISpecEvent;
17193 
17194  public:
17196  inline CAISpecEvent *
17198  {
17199  return m_pAISpecEvent;
17200  }
17201 
17203  EResultCode
17204  setAISpecEvent (
17205  CAISpecEvent * pValue);
17206 
17207 
17208  protected:
17209  CAntennaEvent * m_pAntennaEvent;
17210 
17211  public:
17213  inline CAntennaEvent *
17215  {
17216  return m_pAntennaEvent;
17217  }
17218 
17220  EResultCode
17221  setAntennaEvent (
17222  CAntennaEvent * pValue);
17223 
17224 
17225  protected:
17226  CConnectionAttemptEvent * m_pConnectionAttemptEvent;
17227 
17228  public:
17230  inline CConnectionAttemptEvent *
17232  {
17233  return m_pConnectionAttemptEvent;
17234  }
17235 
17237  EResultCode
17239  CConnectionAttemptEvent * pValue);
17240 
17241 
17242  protected:
17243  CConnectionCloseEvent * m_pConnectionCloseEvent;
17244 
17245  public:
17247  inline CConnectionCloseEvent *
17249  {
17250  return m_pConnectionCloseEvent;
17251  }
17252 
17254  EResultCode
17256  CConnectionCloseEvent * pValue);
17257 
17258 
17259  protected:
17260  std::list<CParameter *> m_listCustom;
17261 
17262  public:
17264  inline std::list<CParameter *>::iterator
17266  {
17267  return m_listCustom.begin();
17268  }
17269 
17271  inline std::list<CParameter *>::iterator
17272  endCustom (void)
17273  {
17274  return m_listCustom.end();
17275  }
17276 
17278  inline void
17280  {
17281  clearSubParameterList ((tListOfParameters *) &m_listCustom);
17282  }
17283 
17285  inline int
17287  {
17288  return (int) (m_listCustom.size());
17289  }
17290 
17291  EResultCode
17293  addCustom (
17294  CParameter * pValue);
17295 
17296 
17297 };
17298 
17299 
17334 class CHoppingEvent : public CParameter
17335 {
17336  public:
17337  CHoppingEvent (void);
17338  ~CHoppingEvent (void);
17339 
17342 
17343  static const CFieldDescriptor * const
17344  s_apFieldDescriptorTable[];
17345 
17346  static const CTypeDescriptor
17347  s_typeDescriptor;
17348 
17349  void
17350  decodeFields (
17351  CDecoderStream * pDecoderStream);
17352 
17353  void
17354  assimilateSubParameters (
17355  CErrorDetails * pError);
17356 
17357  void
17358  encode (
17359  CEncoderStream * pEncoderStream) const;
17360 
17361 
17362 
17363  static CElement *
17364  s_construct (void);
17365 
17366  static void
17367  s_decodeFields (
17368  CDecoderStream * pDecoderStream,
17369  CElement * pElement);
17371 
17372 
17373  protected:
17374  llrp_u16_t m_HopTableID;
17375 
17378  public:
17379  static const CFieldDescriptor
17380  s_fdHopTableID;
17382 
17384  inline llrp_u16_t
17386  {
17387  return m_HopTableID;
17388  }
17389 
17391  inline void
17393  llrp_u16_t value)
17394  {
17395  m_HopTableID = value;
17396  }
17397 
17398 
17399  protected:
17400  llrp_u16_t m_NextChannelIndex;
17401 
17404  public:
17405  static const CFieldDescriptor
17406  s_fdNextChannelIndex;
17408 
17410  inline llrp_u16_t
17412  {
17413  return m_NextChannelIndex;
17414  }
17415 
17417  inline void
17419  llrp_u16_t value)
17420  {
17421  m_NextChannelIndex = value;
17422  }
17423 
17424 
17425 };
17426 
17427 
17460 class CGPIEvent : public CParameter
17461 {
17462  public:
17463  CGPIEvent (void);
17464  ~CGPIEvent (void);
17465 
17468 
17469  static const CFieldDescriptor * const
17470  s_apFieldDescriptorTable[];
17471 
17472  static const CTypeDescriptor
17473  s_typeDescriptor;
17474 
17475  void
17476  decodeFields (
17477  CDecoderStream * pDecoderStream);
17478 
17479  void
17480  assimilateSubParameters (
17481  CErrorDetails * pError);
17482 
17483  void
17484  encode (
17485  CEncoderStream * pEncoderStream) const;
17486 
17487 
17488 
17489  static CElement *
17490  s_construct (void);
17491 
17492  static void
17493  s_decodeFields (
17494  CDecoderStream * pDecoderStream,
17495  CElement * pElement);
17497 
17498 
17499  protected:
17500  llrp_u16_t m_GPIPortNumber;
17501 
17504  public:
17505  static const CFieldDescriptor
17506  s_fdGPIPortNumber;
17508 
17510  inline llrp_u16_t
17512  {
17513  return m_GPIPortNumber;
17514  }
17515 
17517  inline void
17519  llrp_u16_t value)
17520  {
17521  m_GPIPortNumber = value;
17522  }
17523 
17524 
17525  protected:
17526  llrp_u1_t m_GPIEvent;
17527 
17530  public:
17531  static const CFieldDescriptor
17532  s_fdGPIEvent;
17534 
17536  inline llrp_u1_t
17538  {
17539  return m_GPIEvent;
17540  }
17541 
17543  inline void
17545  llrp_u1_t value)
17546  {
17547  m_GPIEvent = value;
17548  }
17549 
17550 
17551 };
17552 
17553 
17589 class CROSpecEvent : public CParameter
17590 {
17591  public:
17592  CROSpecEvent (void);
17593  ~CROSpecEvent (void);
17594 
17597 
17598  static const CFieldDescriptor * const
17599  s_apFieldDescriptorTable[];
17600 
17601  static const CTypeDescriptor
17602  s_typeDescriptor;
17603 
17604  void
17605  decodeFields (
17606  CDecoderStream * pDecoderStream);
17607 
17608  void
17609  assimilateSubParameters (
17610  CErrorDetails * pError);
17611 
17612  void
17613  encode (
17614  CEncoderStream * pEncoderStream) const;
17615 
17616 
17617 
17618  static CElement *
17619  s_construct (void);
17620 
17621  static void
17622  s_decodeFields (
17623  CDecoderStream * pDecoderStream,
17624  CElement * pElement);
17626 
17627 
17628  protected:
17629  EROSpecEventType m_eEventType;
17630 
17633  public:
17634  static const CFieldDescriptor
17635  s_fdEventType;
17637 
17639  inline EROSpecEventType
17641  {
17642  return m_eEventType;
17643  }
17644 
17646  inline void
17648  EROSpecEventType value)
17649  {
17650  m_eEventType = value;
17651  }
17652 
17653 
17654  protected:
17655  llrp_u32_t m_ROSpecID;
17656 
17659  public:
17660  static const CFieldDescriptor
17661  s_fdROSpecID;
17663 
17665  inline llrp_u32_t
17667  {
17668  return m_ROSpecID;
17669  }
17670 
17672  inline void
17674  llrp_u32_t value)
17675  {
17676  m_ROSpecID = value;
17677  }
17678 
17679 
17680  protected:
17681  llrp_u32_t m_PreemptingROSpecID;
17682 
17685  public:
17686  static const CFieldDescriptor
17687  s_fdPreemptingROSpecID;
17689 
17691  inline llrp_u32_t
17693  {
17694  return m_PreemptingROSpecID;
17695  }
17696 
17698  inline void
17700  llrp_u32_t value)
17701  {
17702  m_PreemptingROSpecID = value;
17703  }
17704 
17705 
17706 };
17707 
17708 
17746 class CReportBufferLevelWarningEvent : public CParameter
17747 {
17748  public:
17751 
17754 
17755  static const CFieldDescriptor * const
17756  s_apFieldDescriptorTable[];
17757 
17758  static const CTypeDescriptor
17759  s_typeDescriptor;
17760 
17761  void
17762  decodeFields (
17763  CDecoderStream * pDecoderStream);
17764 
17765  void
17766  assimilateSubParameters (
17767  CErrorDetails * pError);
17768 
17769  void
17770  encode (
17771  CEncoderStream * pEncoderStream) const;
17772 
17773 
17774 
17775  static CElement *
17776  s_construct (void);
17777 
17778  static void
17779  s_decodeFields (
17780  CDecoderStream * pDecoderStream,
17781  CElement * pElement);
17783 
17784 
17785  protected:
17786  llrp_u8_t m_ReportBufferPercentageFull;
17787 
17790  public:
17791  static const CFieldDescriptor
17792  s_fdReportBufferPercentageFull;
17794 
17796  inline llrp_u8_t
17798  {
17799  return m_ReportBufferPercentageFull;
17800  }
17801 
17803  inline void
17805  llrp_u8_t value)
17806  {
17807  m_ReportBufferPercentageFull = value;
17808  }
17809 
17810 
17811 };
17812 
17813 
17848 class CReportBufferOverflowErrorEvent : public CParameter
17849 {
17850  public:
17853 
17856 
17857  static const CFieldDescriptor * const
17858  s_apFieldDescriptorTable[];
17859 
17860  static const CTypeDescriptor
17861  s_typeDescriptor;
17862 
17863  void
17864  decodeFields (
17865  CDecoderStream * pDecoderStream);
17866 
17867  void
17868  assimilateSubParameters (
17869  CErrorDetails * pError);
17870 
17871  void
17872  encode (
17873  CEncoderStream * pEncoderStream) const;
17874 
17875 
17876 
17877  static CElement *
17878  s_construct (void);
17879 
17880  static void
17881  s_decodeFields (
17882  CDecoderStream * pDecoderStream,
17883  CElement * pElement);
17885 
17886 
17887 };
17888 
17889 
17927 class CReaderExceptionEvent : public CParameter
17928 {
17929  public:
17930  CReaderExceptionEvent (void);
17931  ~CReaderExceptionEvent (void);
17932 
17935 
17936  static const CFieldDescriptor * const
17937  s_apFieldDescriptorTable[];
17938 
17939  static const CTypeDescriptor
17940  s_typeDescriptor;
17941 
17942  void
17943  decodeFields (
17944  CDecoderStream * pDecoderStream);
17945 
17946  void
17947  assimilateSubParameters (
17948  CErrorDetails * pError);
17949 
17950  void
17951  encode (
17952  CEncoderStream * pEncoderStream) const;
17953 
17954 
17955 
17956  static CElement *
17957  s_construct (void);
17958 
17959  static void
17960  s_decodeFields (
17961  CDecoderStream * pDecoderStream,
17962  CElement * pElement);
17964 
17965 
17966  protected:
17967  llrp_utf8v_t m_Message;
17968 
17971  public:
17972  static const CFieldDescriptor
17973  s_fdMessage;
17975 
17977  inline llrp_utf8v_t
17978  getMessage (void)
17979  {
17980  return m_Message;
17981  }
17982 
17984  inline void
17986  llrp_utf8v_t value)
17987  {
17988  m_Message = value;
17989  }
17990 
17991 
17992  protected:
17993  CROSpecID * m_pROSpecID;
17994 
17995  public:
17997  inline CROSpecID *
17999  {
18000  return m_pROSpecID;
18001  }
18002 
18004  EResultCode
18005  setROSpecID (
18006  CROSpecID * pValue);
18007 
18008 
18009  protected:
18010  CSpecIndex * m_pSpecIndex;
18011 
18012  public:
18014  inline CSpecIndex *
18016  {
18017  return m_pSpecIndex;
18018  }
18019 
18021  EResultCode
18022  setSpecIndex (
18023  CSpecIndex * pValue);
18024 
18025 
18026  protected:
18027  CInventoryParameterSpecID * m_pInventoryParameterSpecID;
18028 
18029  public:
18031  inline CInventoryParameterSpecID *
18033  {
18034  return m_pInventoryParameterSpecID;
18035  }
18036 
18038  EResultCode
18040  CInventoryParameterSpecID * pValue);
18041 
18042 
18043  protected:
18044  CAntennaID * m_pAntennaID;
18045 
18046  public:
18048  inline CAntennaID *
18050  {
18051  return m_pAntennaID;
18052  }
18053 
18055  EResultCode
18056  setAntennaID (
18057  CAntennaID * pValue);
18058 
18059 
18060  protected:
18061  CAccessSpecID * m_pAccessSpecID;
18062 
18063  public:
18065  inline CAccessSpecID *
18067  {
18068  return m_pAccessSpecID;
18069  }
18070 
18072  EResultCode
18073  setAccessSpecID (
18074  CAccessSpecID * pValue);
18075 
18076 
18077  protected:
18078  COpSpecID * m_pOpSpecID;
18079 
18080  public:
18082  inline COpSpecID *
18084  {
18085  return m_pOpSpecID;
18086  }
18087 
18089  EResultCode
18090  setOpSpecID (
18091  COpSpecID * pValue);
18092 
18093 
18094  protected:
18095  std::list<CParameter *> m_listCustom;
18096 
18097  public:
18099  inline std::list<CParameter *>::iterator
18101  {
18102  return m_listCustom.begin();
18103  }
18104 
18106  inline std::list<CParameter *>::iterator
18107  endCustom (void)
18108  {
18109  return m_listCustom.end();
18110  }
18111 
18113  inline void
18115  {
18116  clearSubParameterList ((tListOfParameters *) &m_listCustom);
18117  }
18118 
18120  inline int
18122  {
18123  return (int) (m_listCustom.size());
18124  }
18125 
18126  EResultCode
18128  addCustom (
18129  CParameter * pValue);
18130 
18131 
18132 };
18133 
18134 
18165 class COpSpecID : public CParameter
18166 {
18167  public:
18168  COpSpecID (void);
18169  ~COpSpecID (void);
18170 
18173 
18174  static const CFieldDescriptor * const
18175  s_apFieldDescriptorTable[];
18176 
18177  static const CTypeDescriptor
18178  s_typeDescriptor;
18179 
18180  void
18181  decodeFields (
18182  CDecoderStream * pDecoderStream);
18183 
18184  void
18185  assimilateSubParameters (
18186  CErrorDetails * pError);
18187 
18188  void
18189  encode (
18190  CEncoderStream * pEncoderStream) const;
18191 
18192 
18193 
18194  static CElement *
18195  s_construct (void);
18196 
18197  static void
18198  s_decodeFields (
18199  CDecoderStream * pDecoderStream,
18200  CElement * pElement);
18202 
18203 
18204  protected:
18205  llrp_u16_t m_OpSpecID;
18206 
18209  public:
18210  static const CFieldDescriptor
18211  s_fdOpSpecID;
18213 
18215  inline llrp_u16_t
18217  {
18218  return m_OpSpecID;
18219  }
18220 
18222  inline void
18224  llrp_u16_t value)
18225  {
18226  m_OpSpecID = value;
18227  }
18228 
18229 
18230 };
18231 
18232 
18265 class CRFSurveyEvent : public CParameter
18266 {
18267  public:
18268  CRFSurveyEvent (void);
18269  ~CRFSurveyEvent (void);
18270 
18273 
18274  static const CFieldDescriptor * const
18275  s_apFieldDescriptorTable[];
18276 
18277  static const CTypeDescriptor
18278  s_typeDescriptor;
18279 
18280  void
18281  decodeFields (
18282  CDecoderStream * pDecoderStream);
18283 
18284  void
18285  assimilateSubParameters (
18286  CErrorDetails * pError);
18287 
18288  void
18289  encode (
18290  CEncoderStream * pEncoderStream) const;
18291 
18292 
18293 
18294  static CElement *
18295  s_construct (void);
18296 
18297  static void
18298  s_decodeFields (
18299  CDecoderStream * pDecoderStream,
18300  CElement * pElement);
18302 
18303 
18304  protected:
18305  ERFSurveyEventType m_eEventType;
18306 
18309  public:
18310  static const CFieldDescriptor
18311  s_fdEventType;
18313 
18315  inline ERFSurveyEventType
18317  {
18318  return m_eEventType;
18319  }
18320 
18322  inline void
18324  ERFSurveyEventType value)
18325  {
18326  m_eEventType = value;
18327  }
18328 
18329 
18330  protected:
18331  llrp_u32_t m_ROSpecID;
18332 
18335  public:
18336  static const CFieldDescriptor
18337  s_fdROSpecID;
18339 
18341  inline llrp_u32_t
18343  {
18344  return m_ROSpecID;
18345  }
18346 
18348  inline void
18350  llrp_u32_t value)
18351  {
18352  m_ROSpecID = value;
18353  }
18354 
18355 
18356  protected:
18357  llrp_u16_t m_SpecIndex;
18358 
18361  public:
18362  static const CFieldDescriptor
18363  s_fdSpecIndex;
18365 
18367  inline llrp_u16_t
18369  {
18370  return m_SpecIndex;
18371  }
18372 
18374  inline void
18376  llrp_u16_t value)
18377  {
18378  m_SpecIndex = value;
18379  }
18380 
18381 
18382 };
18383 
18384 
18420 class CAISpecEvent : public CParameter
18421 {
18422  public:
18423  CAISpecEvent (void);
18424  ~CAISpecEvent (void);
18425 
18428 
18429  static const CFieldDescriptor * const
18430  s_apFieldDescriptorTable[];
18431 
18432  static const CTypeDescriptor
18433  s_typeDescriptor;
18434 
18435  void
18436  decodeFields (
18437  CDecoderStream * pDecoderStream);
18438 
18439  void
18440  assimilateSubParameters (
18441  CErrorDetails * pError);
18442 
18443  void
18444  encode (
18445  CEncoderStream * pEncoderStream) const;
18446 
18447 
18448 
18449  static CElement *
18450  s_construct (void);
18451 
18452  static void
18453  s_decodeFields (
18454  CDecoderStream * pDecoderStream,
18455  CElement * pElement);
18457 
18458 
18459  protected:
18460  EAISpecEventType m_eEventType;
18461 
18464  public:
18465  static const CFieldDescriptor
18466  s_fdEventType;
18468 
18470  inline EAISpecEventType
18472  {
18473  return m_eEventType;
18474  }
18475 
18477  inline void
18479  EAISpecEventType value)
18480  {
18481  m_eEventType = value;
18482  }
18483 
18484 
18485  protected:
18486  llrp_u32_t m_ROSpecID;
18487 
18490  public:
18491  static const CFieldDescriptor
18492  s_fdROSpecID;
18494 
18496  inline llrp_u32_t
18498  {
18499  return m_ROSpecID;
18500  }
18501 
18503  inline void
18505  llrp_u32_t value)
18506  {
18507  m_ROSpecID = value;
18508  }
18509 
18510 
18511  protected:
18512  llrp_u16_t m_SpecIndex;
18513 
18516  public:
18517  static const CFieldDescriptor
18518  s_fdSpecIndex;
18520 
18522  inline llrp_u16_t
18524  {
18525  return m_SpecIndex;
18526  }
18527 
18529  inline void
18531  llrp_u16_t value)
18532  {
18533  m_SpecIndex = value;
18534  }
18535 
18536 
18537  protected:
18538  CParameter * m_pAirProtocolSingulationDetails;
18539 
18540  public:
18542  inline CParameter *
18544  {
18545  return m_pAirProtocolSingulationDetails;
18546  }
18547 
18549  EResultCode
18551  CParameter * pValue);
18552 
18553 
18554 };
18555 
18556 
18588 class CAntennaEvent : public CParameter
18589 {
18590  public:
18591  CAntennaEvent (void);
18592  ~CAntennaEvent (void);
18593 
18596 
18597  static const CFieldDescriptor * const
18598  s_apFieldDescriptorTable[];
18599 
18600  static const CTypeDescriptor
18601  s_typeDescriptor;
18602 
18603  void
18604  decodeFields (
18605  CDecoderStream * pDecoderStream);
18606 
18607  void
18608  assimilateSubParameters (
18609  CErrorDetails * pError);
18610 
18611  void
18612  encode (
18613  CEncoderStream * pEncoderStream) const;
18614 
18615 
18616 
18617  static CElement *
18618  s_construct (void);
18619 
18620  static void
18621  s_decodeFields (
18622  CDecoderStream * pDecoderStream,
18623  CElement * pElement);
18625 
18626 
18627  protected:
18628  EAntennaEventType m_eEventType;
18629 
18632  public:
18633  static const CFieldDescriptor
18634  s_fdEventType;
18636 
18638  inline EAntennaEventType
18640  {
18641  return m_eEventType;
18642  }
18643 
18645  inline void
18647  EAntennaEventType value)
18648  {
18649  m_eEventType = value;
18650  }
18651 
18652 
18653  protected:
18654  llrp_u16_t m_AntennaID;
18655 
18658  public:
18659  static const CFieldDescriptor
18660  s_fdAntennaID;
18662 
18664  inline llrp_u16_t
18666  {
18667  return m_AntennaID;
18668  }
18669 
18671  inline void
18673  llrp_u16_t value)
18674  {
18675  m_AntennaID = value;
18676  }
18677 
18678 
18679 };
18680 
18681 
18712 class CConnectionAttemptEvent : public CParameter
18713 {
18714  public:
18715  CConnectionAttemptEvent (void);
18716  ~CConnectionAttemptEvent (void);
18717 
18720 
18721  static const CFieldDescriptor * const
18722  s_apFieldDescriptorTable[];
18723 
18724  static const CTypeDescriptor
18725  s_typeDescriptor;
18726 
18727  void
18728  decodeFields (
18729  CDecoderStream * pDecoderStream);
18730 
18731  void
18732  assimilateSubParameters (
18733  CErrorDetails * pError);
18734 
18735  void
18736  encode (
18737  CEncoderStream * pEncoderStream) const;
18738 
18739 
18740 
18741  static CElement *
18742  s_construct (void);
18743 
18744  static void
18745  s_decodeFields (
18746  CDecoderStream * pDecoderStream,
18747  CElement * pElement);
18749 
18750 
18751  protected:
18752  EConnectionAttemptStatusType m_eStatus;
18753 
18756  public:
18757  static const CFieldDescriptor
18758  s_fdStatus;
18760 
18762  inline EConnectionAttemptStatusType
18763  getStatus (void)
18764  {
18765  return m_eStatus;
18766  }
18767 
18769  inline void
18771  EConnectionAttemptStatusType value)
18772  {
18773  m_eStatus = value;
18774  }
18775 
18776 
18777 };
18778 
18779 
18820 class CConnectionCloseEvent : public CParameter
18821 {
18822  public:
18823  CConnectionCloseEvent (void);
18824  ~CConnectionCloseEvent (void);
18825 
18828 
18829  static const CFieldDescriptor * const
18830  s_apFieldDescriptorTable[];
18831 
18832  static const CTypeDescriptor
18833  s_typeDescriptor;
18834 
18835  void
18836  decodeFields (
18837  CDecoderStream * pDecoderStream);
18838 
18839  void
18840  assimilateSubParameters (
18841  CErrorDetails * pError);
18842 
18843  void
18844  encode (
18845  CEncoderStream * pEncoderStream) const;
18846 
18847 
18848 
18849  static CElement *
18850  s_construct (void);
18851 
18852  static void
18853  s_decodeFields (
18854  CDecoderStream * pDecoderStream,
18855  CElement * pElement);
18857 
18858 
18859 };
18860 
18861 
18888 class CLLRPStatus : public CParameter
18889 {
18890  public:
18891  CLLRPStatus (void);
18892  ~CLLRPStatus (void);
18893 
18896 
18897  static const CFieldDescriptor * const
18898  s_apFieldDescriptorTable[];
18899 
18900  static const CTypeDescriptor
18901  s_typeDescriptor;
18902 
18903  void
18904  decodeFields (
18905  CDecoderStream * pDecoderStream);
18906 
18907  void
18908  assimilateSubParameters (
18909  CErrorDetails * pError);
18910 
18911  void
18912  encode (
18913  CEncoderStream * pEncoderStream) const;
18914 
18915 
18916 
18917  static CElement *
18918  s_construct (void);
18919 
18920  static void
18921  s_decodeFields (
18922  CDecoderStream * pDecoderStream,
18923  CElement * pElement);
18925 
18926 
18927  protected:
18928  EStatusCode m_eStatusCode;
18929 
18932  public:
18933  static const CFieldDescriptor
18934  s_fdStatusCode;
18936 
18938  inline EStatusCode
18940  {
18941  return m_eStatusCode;
18942  }
18943 
18945  inline void
18947  EStatusCode value)
18948  {
18949  m_eStatusCode = value;
18950  }
18951 
18952 
18953  protected:
18954  llrp_utf8v_t m_ErrorDescription;
18955 
18958  public:
18959  static const CFieldDescriptor
18960  s_fdErrorDescription;
18962 
18964  inline llrp_utf8v_t
18966  {
18967  return m_ErrorDescription;
18968  }
18969 
18971  inline void
18973  llrp_utf8v_t value)
18974  {
18975  m_ErrorDescription = value;
18976  }
18977 
18978 
18979  protected:
18980  CFieldError * m_pFieldError;
18981 
18982  public:
18984  inline CFieldError *
18986  {
18987  return m_pFieldError;
18988  }
18989 
18991  EResultCode
18992  setFieldError (
18993  CFieldError * pValue);
18994 
18995 
18996  protected:
18997  CParameterError * m_pParameterError;
18998 
18999  public:
19001  inline CParameterError *
19003  {
19004  return m_pParameterError;
19005  }
19006 
19008  EResultCode
19010  CParameterError * pValue);
19011 
19012 
19013 };
19014 
19015 
19047 class CFieldError : public CParameter
19048 {
19049  public:
19050  CFieldError (void);
19051  ~CFieldError (void);
19052 
19055 
19056  static const CFieldDescriptor * const
19057  s_apFieldDescriptorTable[];
19058 
19059  static const CTypeDescriptor
19060  s_typeDescriptor;
19061 
19062  void
19063  decodeFields (
19064  CDecoderStream * pDecoderStream);
19065 
19066  void
19067  assimilateSubParameters (
19068  CErrorDetails * pError);
19069 
19070  void
19071  encode (
19072  CEncoderStream * pEncoderStream) const;
19073 
19074 
19075 
19076  static CElement *
19077  s_construct (void);
19078 
19079  static void
19080  s_decodeFields (
19081  CDecoderStream * pDecoderStream,
19082  CElement * pElement);
19084 
19085 
19086  protected:
19087  llrp_u16_t m_FieldNum;
19088 
19091  public:
19092  static const CFieldDescriptor
19093  s_fdFieldNum;
19095 
19097  inline llrp_u16_t
19099  {
19100  return m_FieldNum;
19101  }
19102 
19104  inline void
19106  llrp_u16_t value)
19107  {
19108  m_FieldNum = value;
19109  }
19110 
19111 
19112  protected:
19113  EStatusCode m_eErrorCode;
19114 
19117  public:
19118  static const CFieldDescriptor
19119  s_fdErrorCode;
19121 
19123  inline EStatusCode
19125  {
19126  return m_eErrorCode;
19127  }
19128 
19130  inline void
19132  EStatusCode value)
19133  {
19134  m_eErrorCode = value;
19135  }
19136 
19137 
19138 };
19139 
19140 
19174 class CParameterError : public CParameter
19175 {
19176  public:
19177  CParameterError (void);
19178  ~CParameterError (void);
19179 
19182 
19183  static const CFieldDescriptor * const
19184  s_apFieldDescriptorTable[];
19185 
19186  static const CTypeDescriptor
19187  s_typeDescriptor;
19188 
19189  void
19190  decodeFields (
19191  CDecoderStream * pDecoderStream);
19192 
19193  void
19194  assimilateSubParameters (
19195  CErrorDetails * pError);
19196 
19197  void
19198  encode (
19199  CEncoderStream * pEncoderStream) const;
19200 
19201 
19202 
19203  static CElement *
19204  s_construct (void);
19205 
19206  static void
19207  s_decodeFields (
19208  CDecoderStream * pDecoderStream,
19209  CElement * pElement);
19211 
19212 
19213  protected:
19214  llrp_u16_t m_ParameterType;
19215 
19218  public:
19219  static const CFieldDescriptor
19220  s_fdParameterType;
19222 
19224  inline llrp_u16_t
19226  {
19227  return m_ParameterType;
19228  }
19229 
19231  inline void
19233  llrp_u16_t value)
19234  {
19235  m_ParameterType = value;
19236  }
19237 
19238 
19239  protected:
19240  EStatusCode m_eErrorCode;
19241 
19244  public:
19245  static const CFieldDescriptor
19246  s_fdErrorCode;
19248 
19250  inline EStatusCode
19252  {
19253  return m_eErrorCode;
19254  }
19255 
19257  inline void
19259  EStatusCode value)
19260  {
19261  m_eErrorCode = value;
19262  }
19263 
19264 
19265  protected:
19266  CFieldError * m_pFieldError;
19267 
19268  public:
19270  inline CFieldError *
19272  {
19273  return m_pFieldError;
19274  }
19275 
19277  EResultCode
19278  setFieldError (
19279  CFieldError * pValue);
19280 
19281 
19282  protected:
19283  CParameterError * m_pParameterError;
19284 
19285  public:
19287  inline CParameterError *
19289  {
19290  return m_pParameterError;
19291  }
19292 
19294  EResultCode
19296  CParameterError * pValue);
19297 
19298 
19299 };
19300 
19301 
19341 class CC1G2LLRPCapabilities : public CParameter
19342 {
19343  public:
19344  CC1G2LLRPCapabilities (void);
19345  ~CC1G2LLRPCapabilities (void);
19346 
19349 
19350  static const CFieldDescriptor * const
19351  s_apFieldDescriptorTable[];
19352 
19353  static const CTypeDescriptor
19354  s_typeDescriptor;
19355 
19356  void
19357  decodeFields (
19358  CDecoderStream * pDecoderStream);
19359 
19360  void
19361  assimilateSubParameters (
19362  CErrorDetails * pError);
19363 
19364  void
19365  encode (
19366  CEncoderStream * pEncoderStream) const;
19367 
19368 
19369 
19370  static CElement *
19371  s_construct (void);
19372 
19373  static void
19374  s_decodeFields (
19375  CDecoderStream * pDecoderStream,
19376  CElement * pElement);
19378 
19379 
19380  protected:
19381  llrp_u1_t m_CanSupportBlockErase;
19382 
19385  public:
19386  static const CFieldDescriptor
19387  s_fdCanSupportBlockErase;
19389 
19391  inline llrp_u1_t
19393  {
19394  return m_CanSupportBlockErase;
19395  }
19396 
19398  inline void
19400  llrp_u1_t value)
19401  {
19402  m_CanSupportBlockErase = value;
19403  }
19404 
19405 
19406  protected:
19407  llrp_u1_t m_CanSupportBlockWrite;
19408 
19411  public:
19412  static const CFieldDescriptor
19413  s_fdCanSupportBlockWrite;
19415 
19417  inline llrp_u1_t
19419  {
19420  return m_CanSupportBlockWrite;
19421  }
19422 
19424  inline void
19426  llrp_u1_t value)
19427  {
19428  m_CanSupportBlockWrite = value;
19429  }
19430 
19431 
19432  protected:
19433  llrp_u16_t m_MaxNumSelectFiltersPerQuery;
19434 
19437  public:
19438  static const CFieldDescriptor
19439  s_fdMaxNumSelectFiltersPerQuery;
19441 
19443  inline llrp_u16_t
19445  {
19446  return m_MaxNumSelectFiltersPerQuery;
19447  }
19448 
19450  inline void
19452  llrp_u16_t value)
19453  {
19454  m_MaxNumSelectFiltersPerQuery = value;
19455  }
19456 
19457 
19458 };
19459 
19460 
19491 class CC1G2UHFRFModeTable : public CParameter
19492 {
19493  public:
19494  CC1G2UHFRFModeTable (void);
19495  ~CC1G2UHFRFModeTable (void);
19496 
19499 
19500  static const CFieldDescriptor * const
19501  s_apFieldDescriptorTable[];
19502 
19503  static const CTypeDescriptor
19504  s_typeDescriptor;
19505 
19506  void
19507  decodeFields (
19508  CDecoderStream * pDecoderStream);
19509 
19510  void
19511  assimilateSubParameters (
19512  CErrorDetails * pError);
19513 
19514  void
19515  encode (
19516  CEncoderStream * pEncoderStream) const;
19517 
19518 
19519 
19520  static CElement *
19521  s_construct (void);
19522 
19523  static void
19524  s_decodeFields (
19525  CDecoderStream * pDecoderStream,
19526  CElement * pElement);
19528 
19529 
19530  protected:
19531  std::list<CC1G2UHFRFModeTableEntry *> m_listC1G2UHFRFModeTableEntry;
19532 
19533  public:
19535  inline std::list<CC1G2UHFRFModeTableEntry *>::iterator
19537  {
19538  return m_listC1G2UHFRFModeTableEntry.begin();
19539  }
19540 
19542  inline std::list<CC1G2UHFRFModeTableEntry *>::iterator
19544  {
19545  return m_listC1G2UHFRFModeTableEntry.end();
19546  }
19547 
19549  inline void
19551  {
19552  clearSubParameterList ((tListOfParameters *) &m_listC1G2UHFRFModeTableEntry);
19553  }
19554 
19556  inline int
19558  {
19559  return (int) (m_listC1G2UHFRFModeTableEntry.size());
19560  }
19561 
19562  EResultCode
19565  CC1G2UHFRFModeTableEntry * pValue);
19566 
19567 
19568 };
19569 
19570 
19612 class CC1G2UHFRFModeTableEntry : public CParameter
19613 {
19614  public:
19615  CC1G2UHFRFModeTableEntry (void);
19616  ~CC1G2UHFRFModeTableEntry (void);
19617 
19620 
19621  static const CFieldDescriptor * const
19622  s_apFieldDescriptorTable[];
19623 
19624  static const CTypeDescriptor
19625  s_typeDescriptor;
19626 
19627  void
19628  decodeFields (
19629  CDecoderStream * pDecoderStream);
19630 
19631  void
19632  assimilateSubParameters (
19633  CErrorDetails * pError);
19634 
19635  void
19636  encode (
19637  CEncoderStream * pEncoderStream) const;
19638 
19639 
19640 
19641  static CElement *
19642  s_construct (void);
19643 
19644  static void
19645  s_decodeFields (
19646  CDecoderStream * pDecoderStream,
19647  CElement * pElement);
19649 
19650 
19651  protected:
19652  llrp_u32_t m_ModeIdentifier;
19653 
19656  public:
19657  static const CFieldDescriptor
19658  s_fdModeIdentifier;
19660 
19662  inline llrp_u32_t
19664  {
19665  return m_ModeIdentifier;
19666  }
19667 
19669  inline void
19671  llrp_u32_t value)
19672  {
19673  m_ModeIdentifier = value;
19674  }
19675 
19676 
19677  protected:
19678  EC1G2DRValue m_eDRValue;
19679 
19682  public:
19683  static const CFieldDescriptor
19684  s_fdDRValue;
19686 
19688  inline EC1G2DRValue
19689  getDRValue (void)
19690  {
19691  return m_eDRValue;
19692  }
19693 
19695  inline void
19697  EC1G2DRValue value)
19698  {
19699  m_eDRValue = value;
19700  }
19701 
19702 
19703  protected:
19704  llrp_u1_t m_EPCHAGTCConformance;
19705 
19708  public:
19709  static const CFieldDescriptor
19710  s_fdEPCHAGTCConformance;
19712 
19714  inline llrp_u1_t
19716  {
19717  return m_EPCHAGTCConformance;
19718  }
19719 
19721  inline void
19723  llrp_u1_t value)
19724  {
19725  m_EPCHAGTCConformance = value;
19726  }
19727 
19728 
19729  protected:
19730  EC1G2MValue m_eMValue;
19731 
19734  public:
19735  static const CFieldDescriptor
19736  s_fdMValue;
19738 
19740  inline EC1G2MValue
19741  getMValue (void)
19742  {
19743  return m_eMValue;
19744  }
19745 
19747  inline void
19749  EC1G2MValue value)
19750  {
19751  m_eMValue = value;
19752  }
19753 
19754 
19755  protected:
19756  EC1G2ForwardLinkModulation m_eForwardLinkModulation;
19757 
19760  public:
19761  static const CFieldDescriptor
19762  s_fdForwardLinkModulation;
19764 
19766  inline EC1G2ForwardLinkModulation
19768  {
19769  return m_eForwardLinkModulation;
19770  }
19771 
19773  inline void
19775  EC1G2ForwardLinkModulation value)
19776  {
19777  m_eForwardLinkModulation = value;
19778  }
19779 
19780 
19781  protected:
19782  EC1G2SpectralMaskIndicator m_eSpectralMaskIndicator;
19783 
19786  public:
19787  static const CFieldDescriptor
19788  s_fdSpectralMaskIndicator;
19790 
19792  inline EC1G2SpectralMaskIndicator
19794  {
19795  return m_eSpectralMaskIndicator;
19796  }
19797 
19799  inline void
19801  EC1G2SpectralMaskIndicator value)
19802  {
19803  m_eSpectralMaskIndicator = value;
19804  }
19805 
19806 
19807  protected:
19808  llrp_u32_t m_BDRValue;
19809 
19812  public:
19813  static const CFieldDescriptor
19814  s_fdBDRValue;
19816 
19818  inline llrp_u32_t
19820  {
19821  return m_BDRValue;
19822  }
19823 
19825  inline void
19827  llrp_u32_t value)
19828  {
19829  m_BDRValue = value;
19830  }
19831 
19832 
19833  protected:
19834  llrp_u32_t m_PIEValue;
19835 
19838  public:
19839  static const CFieldDescriptor
19840  s_fdPIEValue;
19842 
19844  inline llrp_u32_t
19846  {
19847  return m_PIEValue;
19848  }
19849 
19851  inline void
19853  llrp_u32_t value)
19854  {
19855  m_PIEValue = value;
19856  }
19857 
19858 
19859  protected:
19860  llrp_u32_t m_MinTariValue;
19861 
19864  public:
19865  static const CFieldDescriptor
19866  s_fdMinTariValue;
19868 
19870  inline llrp_u32_t
19872  {
19873  return m_MinTariValue;
19874  }
19875 
19877  inline void
19879  llrp_u32_t value)
19880  {
19881  m_MinTariValue = value;
19882  }
19883 
19884 
19885  protected:
19886  llrp_u32_t m_MaxTariValue;
19887 
19890  public:
19891  static const CFieldDescriptor
19892  s_fdMaxTariValue;
19894 
19896  inline llrp_u32_t
19898  {
19899  return m_MaxTariValue;
19900  }
19901 
19903  inline void
19905  llrp_u32_t value)
19906  {
19907  m_MaxTariValue = value;
19908  }
19909 
19910 
19911  protected:
19912  llrp_u32_t m_StepTariValue;
19913 
19916  public:
19917  static const CFieldDescriptor
19918  s_fdStepTariValue;
19920 
19922  inline llrp_u32_t
19924  {
19925  return m_StepTariValue;
19926  }
19927 
19929  inline void
19931  llrp_u32_t value)
19932  {
19933  m_StepTariValue = value;
19934  }
19935 
19936 
19937 };
19938 
19939 
19980 class CC1G2InventoryCommand : public CParameter
19981 {
19982  public:
19983  CC1G2InventoryCommand (void);
19984  ~CC1G2InventoryCommand (void);
19985 
19988 
19989  static const CFieldDescriptor * const
19990  s_apFieldDescriptorTable[];
19991 
19992  static const CTypeDescriptor
19993  s_typeDescriptor;
19994 
19995  void
19996  decodeFields (
19997  CDecoderStream * pDecoderStream);
19998 
19999  void
20000  assimilateSubParameters (
20001  CErrorDetails * pError);
20002 
20003  void
20004  encode (
20005  CEncoderStream * pEncoderStream) const;
20006 
20007 
20008 
20009  static CElement *
20010  s_construct (void);
20011 
20012  static void
20013  s_decodeFields (
20014  CDecoderStream * pDecoderStream,
20015  CElement * pElement);
20017 
20018 
20019  protected:
20020  llrp_u1_t m_TagInventoryStateAware;
20021 
20024  public:
20025  static const CFieldDescriptor
20026  s_fdTagInventoryStateAware;
20028 
20030  inline llrp_u1_t
20032  {
20033  return m_TagInventoryStateAware;
20034  }
20035 
20037  inline void
20039  llrp_u1_t value)
20040  {
20041  m_TagInventoryStateAware = value;
20042  }
20043 
20044 
20045  protected:
20046  std::list<CC1G2Filter *> m_listC1G2Filter;
20047 
20048  public:
20050  inline std::list<CC1G2Filter *>::iterator
20052  {
20053  return m_listC1G2Filter.begin();
20054  }
20055 
20057  inline std::list<CC1G2Filter *>::iterator
20059  {
20060  return m_listC1G2Filter.end();
20061  }
20062 
20064  inline void
20066  {
20067  clearSubParameterList ((tListOfParameters *) &m_listC1G2Filter);
20068  }
20069 
20071  inline int
20073  {
20074  return (int) (m_listC1G2Filter.size());
20075  }
20076 
20077  EResultCode
20079  addC1G2Filter (
20080  CC1G2Filter * pValue);
20081 
20082 
20083  protected:
20084  CC1G2RFControl * m_pC1G2RFControl;
20085 
20086  public:
20088  inline CC1G2RFControl *
20090  {
20091  return m_pC1G2RFControl;
20092  }
20093 
20095  EResultCode
20097  CC1G2RFControl * pValue);
20098 
20099 
20100  protected:
20101  CC1G2SingulationControl * m_pC1G2SingulationControl;
20102 
20103  public:
20105  inline CC1G2SingulationControl *
20107  {
20108  return m_pC1G2SingulationControl;
20109  }
20110 
20112  EResultCode
20114  CC1G2SingulationControl * pValue);
20115 
20116 
20117  protected:
20118  std::list<CParameter *> m_listCustom;
20119 
20120  public:
20122  inline std::list<CParameter *>::iterator
20124  {
20125  return m_listCustom.begin();
20126  }
20127 
20129  inline std::list<CParameter *>::iterator
20130  endCustom (void)
20131  {
20132  return m_listCustom.end();
20133  }
20134 
20136  inline void
20138  {
20139  clearSubParameterList ((tListOfParameters *) &m_listCustom);
20140  }
20141 
20143  inline int
20145  {
20146  return (int) (m_listCustom.size());
20147  }
20148 
20149  EResultCode
20151  addCustom (
20152  CParameter * pValue);
20153 
20154 
20155 };
20156 
20157 
20216 class CC1G2Filter : public CParameter
20217 {
20218  public:
20219  CC1G2Filter (void);
20220  ~CC1G2Filter (void);
20221 
20224 
20225  static const CFieldDescriptor * const
20226  s_apFieldDescriptorTable[];
20227 
20228  static const CTypeDescriptor
20229  s_typeDescriptor;
20230 
20231  void
20232  decodeFields (
20233  CDecoderStream * pDecoderStream);
20234 
20235  void
20236  assimilateSubParameters (
20237  CErrorDetails * pError);
20238 
20239  void
20240  encode (
20241  CEncoderStream * pEncoderStream) const;
20242 
20243 
20244 
20245  static CElement *
20246  s_construct (void);
20247 
20248  static void
20249  s_decodeFields (
20250  CDecoderStream * pDecoderStream,
20251  CElement * pElement);
20253 
20254 
20255  protected:
20256  EC1G2TruncateAction m_eT;
20257 
20260  public:
20261  static const CFieldDescriptor
20262  s_fdT;
20264 
20266  inline EC1G2TruncateAction
20267  getT (void)
20268  {
20269  return m_eT;
20270  }
20271 
20273  inline void
20275  EC1G2TruncateAction value)
20276  {
20277  m_eT = value;
20278  }
20279 
20280 
20281  protected:
20282  CC1G2TagInventoryMask * m_pC1G2TagInventoryMask;
20283 
20284  public:
20286  inline CC1G2TagInventoryMask *
20288  {
20289  return m_pC1G2TagInventoryMask;
20290  }
20291 
20293  EResultCode
20295  CC1G2TagInventoryMask * pValue);
20296 
20297 
20298  protected:
20299  CC1G2TagInventoryStateAwareFilterAction * m_pC1G2TagInventoryStateAwareFilterAction;
20300 
20301  public:
20305  {
20306  return m_pC1G2TagInventoryStateAwareFilterAction;
20307  }
20308 
20310  EResultCode
20313 
20314 
20315  protected:
20316  CC1G2TagInventoryStateUnawareFilterAction * m_pC1G2TagInventoryStateUnawareFilterAction;
20317 
20318  public:
20322  {
20323  return m_pC1G2TagInventoryStateUnawareFilterAction;
20324  }
20325 
20327  EResultCode
20330 
20331 
20332 };
20333 
20334 
20361 class CC1G2TagInventoryMask : public CParameter
20362 {
20363  public:
20364  CC1G2TagInventoryMask (void);
20365  ~CC1G2TagInventoryMask (void);
20366 
20369 
20370  static const CFieldDescriptor * const
20371  s_apFieldDescriptorTable[];
20372 
20373  static const CTypeDescriptor
20374  s_typeDescriptor;
20375 
20376  void
20377  decodeFields (
20378  CDecoderStream * pDecoderStream);
20379 
20380  void
20381  assimilateSubParameters (
20382  CErrorDetails * pError);
20383 
20384  void
20385  encode (
20386  CEncoderStream * pEncoderStream) const;
20387 
20388 
20389 
20390  static CElement *
20391  s_construct (void);
20392 
20393  static void
20394  s_decodeFields (
20395  CDecoderStream * pDecoderStream,
20396  CElement * pElement);
20398 
20399 
20400  protected:
20401  llrp_u2_t m_MB;
20402 
20405  public:
20406  static const CFieldDescriptor
20407  s_fdMB;
20409 
20411  inline llrp_u2_t
20412  getMB (void)
20413  {
20414  return m_MB;
20415  }
20416 
20418  inline void
20420  llrp_u2_t value)
20421  {
20422  m_MB = value;
20423  }
20424 
20425 
20426  protected:
20427  llrp_u16_t m_Pointer;
20428 
20431  public:
20432  static const CFieldDescriptor
20433  s_fdPointer;
20435 
20437  inline llrp_u16_t
20438  getPointer (void)
20439  {
20440  return m_Pointer;
20441  }
20442 
20444  inline void
20446  llrp_u16_t value)
20447  {
20448  m_Pointer = value;
20449  }
20450 
20451 
20452  protected:
20453  llrp_u1v_t m_TagMask;
20454 
20457  public:
20458  static const CFieldDescriptor
20459  s_fdTagMask;
20461 
20463  inline llrp_u1v_t
20464  getTagMask (void)
20465  {
20466  return m_TagMask;
20467  }
20468 
20470  inline void
20472  llrp_u1v_t value)
20473  {
20474  m_TagMask = value;
20475  }
20476 
20477 
20478 };
20479 
20480 
20532 {
20533  public:
20536 
20539 
20540  static const CFieldDescriptor * const
20541  s_apFieldDescriptorTable[];
20542 
20543  static const CTypeDescriptor
20544  s_typeDescriptor;
20545 
20546  void
20547  decodeFields (
20548  CDecoderStream * pDecoderStream);
20549 
20550  void
20551  assimilateSubParameters (
20552  CErrorDetails * pError);
20553 
20554  void
20555  encode (
20556  CEncoderStream * pEncoderStream) const;
20557 
20558 
20559 
20560  static CElement *
20561  s_construct (void);
20562 
20563  static void
20564  s_decodeFields (
20565  CDecoderStream * pDecoderStream,
20566  CElement * pElement);
20568 
20569 
20570  protected:
20571  EC1G2StateAwareTarget m_eTarget;
20572 
20575  public:
20576  static const CFieldDescriptor
20577  s_fdTarget;
20579 
20581  inline EC1G2StateAwareTarget
20582  getTarget (void)
20583  {
20584  return m_eTarget;
20585  }
20586 
20588  inline void
20590  EC1G2StateAwareTarget value)
20591  {
20592  m_eTarget = value;
20593  }
20594 
20595 
20596  protected:
20597  EC1G2StateAwareAction m_eAction;
20598 
20601  public:
20602  static const CFieldDescriptor
20603  s_fdAction;
20605 
20607  inline EC1G2StateAwareAction
20608  getAction (void)
20609  {
20610  return m_eAction;
20611  }
20612 
20614  inline void
20616  EC1G2StateAwareAction value)
20617  {
20618  m_eAction = value;
20619  }
20620 
20621 
20622 };
20623 
20624 
20668 {
20669  public:
20672 
20675 
20676  static const CFieldDescriptor * const
20677  s_apFieldDescriptorTable[];
20678 
20679  static const CTypeDescriptor
20680  s_typeDescriptor;
20681 
20682  void
20683  decodeFields (
20684  CDecoderStream * pDecoderStream);
20685 
20686  void
20687  assimilateSubParameters (
20688  CErrorDetails * pError);
20689 
20690  void
20691  encode (
20692  CEncoderStream * pEncoderStream) const;
20693 
20694 
20695 
20696  static CElement *
20697  s_construct (void);
20698 
20699  static void
20700  s_decodeFields (
20701  CDecoderStream * pDecoderStream,
20702  CElement * pElement);
20704 
20705 
20706  protected:
20707  EC1G2StateUnawareAction m_eAction;
20708 
20711  public:
20712  static const CFieldDescriptor
20713  s_fdAction;
20715 
20717  inline EC1G2StateUnawareAction
20718  getAction (void)
20719  {
20720  return m_eAction;
20721  }
20722 
20724  inline void
20726  EC1G2StateUnawareAction value)
20727  {
20728  m_eAction = value;
20729  }
20730 
20731 
20732 };
20733 
20734 
20769 class CC1G2RFControl : public CParameter
20770 {
20771  public:
20772  CC1G2RFControl (void);
20773  ~CC1G2RFControl (void);
20774 
20777 
20778  static const CFieldDescriptor * const
20779  s_apFieldDescriptorTable[];
20780 
20781  static const CTypeDescriptor
20782  s_typeDescriptor;
20783 
20784  void
20785  decodeFields (
20786  CDecoderStream * pDecoderStream);
20787 
20788  void
20789  assimilateSubParameters (
20790  CErrorDetails * pError);
20791 
20792  void
20793  encode (
20794  CEncoderStream * pEncoderStream) const;
20795 
20796 
20797 
20798  static CElement *
20799  s_construct (void);
20800 
20801  static void
20802  s_decodeFields (
20803  CDecoderStream * pDecoderStream,
20804  CElement * pElement);
20806 
20807 
20808  protected:
20809  llrp_u16_t m_ModeIndex;
20810 
20813  public:
20814  static const CFieldDescriptor
20815  s_fdModeIndex;
20817 
20819  inline llrp_u16_t
20821  {
20822  return m_ModeIndex;
20823  }
20824 
20826  inline void
20828  llrp_u16_t value)
20829  {
20830  m_ModeIndex = value;
20831  }
20832 
20833 
20834  protected:
20835  llrp_u16_t m_Tari;
20836 
20839  public:
20840  static const CFieldDescriptor
20841  s_fdTari;
20843 
20845  inline llrp_u16_t
20846  getTari (void)
20847  {
20848  return m_Tari;
20849  }
20850 
20852  inline void
20854  llrp_u16_t value)
20855  {
20856  m_Tari = value;
20857  }
20858 
20859 
20860 };
20861 
20862 
20947 class CC1G2SingulationControl : public CParameter
20948 {
20949  public:
20950  CC1G2SingulationControl (void);
20951  ~CC1G2SingulationControl (void);
20952 
20955 
20956  static const CFieldDescriptor * const
20957  s_apFieldDescriptorTable[];
20958 
20959  static const CTypeDescriptor
20960  s_typeDescriptor;
20961 
20962  void
20963  decodeFields (
20964  CDecoderStream * pDecoderStream);
20965 
20966  void
20967  assimilateSubParameters (
20968  CErrorDetails * pError);
20969 
20970  void
20971  encode (
20972  CEncoderStream * pEncoderStream) const;
20973 
20974 
20975 
20976  static CElement *
20977  s_construct (void);
20978 
20979  static void
20980  s_decodeFields (
20981  CDecoderStream * pDecoderStream,
20982  CElement * pElement);
20984 
20985 
20986  protected:
20987  llrp_u2_t m_Session;
20988 
20991  public:
20992  static const CFieldDescriptor
20993  s_fdSession;
20995 
20997  inline llrp_u2_t
20998  getSession (void)
20999  {
21000  return m_Session;
21001  }
21002 
21004  inline void
21006  llrp_u2_t value)
21007  {
21008  m_Session = value;
21009  }
21010 
21011 
21012  protected:
21013  llrp_u16_t m_TagPopulation;
21014 
21017  public:
21018  static const CFieldDescriptor
21019  s_fdTagPopulation;
21021 
21023  inline llrp_u16_t
21025  {
21026  return m_TagPopulation;
21027  }
21028 
21030  inline void
21032  llrp_u16_t value)
21033  {
21034  m_TagPopulation = value;
21035  }
21036 
21037 
21038  protected:
21039  llrp_u32_t m_TagTransitTime;
21040 
21043  public:
21044  static const CFieldDescriptor
21045  s_fdTagTransitTime;
21047 
21049  inline llrp_u32_t
21051  {
21052  return m_TagTransitTime;
21053  }
21054 
21056  inline void
21058  llrp_u32_t value)
21059  {
21060  m_TagTransitTime = value;
21061  }
21062 
21063 
21064  protected:
21065  CC1G2TagInventoryStateAwareSingulationAction * m_pC1G2TagInventoryStateAwareSingulationAction;
21066 
21067  public:
21071  {
21072  return m_pC1G2TagInventoryStateAwareSingulationAction;
21073  }
21074 
21076  EResultCode
21079 
21080 
21081 };
21082 
21083 
21117 {
21118  public:
21121 
21124 
21125  static const CFieldDescriptor * const
21126  s_apFieldDescriptorTable[];
21127 
21128  static const CTypeDescriptor
21129  s_typeDescriptor;
21130 
21131  void
21132  decodeFields (
21133  CDecoderStream * pDecoderStream);
21134 
21135  void
21136  assimilateSubParameters (
21137  CErrorDetails * pError);
21138 
21139  void
21140  encode (
21141  CEncoderStream * pEncoderStream) const;
21142 
21143 
21144 
21145  static CElement *
21146  s_construct (void);
21147 
21148  static void
21149  s_decodeFields (
21150  CDecoderStream * pDecoderStream,
21151  CElement * pElement);
21153 
21154 
21155  protected:
21156  EC1G2TagInventoryStateAwareI m_eI;
21157 
21160  public:
21161  static const CFieldDescriptor
21162  s_fdI;
21164 
21166  inline EC1G2TagInventoryStateAwareI
21167  getI (void)
21168  {
21169  return m_eI;
21170  }
21171 
21173  inline void
21175  EC1G2TagInventoryStateAwareI value)
21176  {
21177  m_eI = value;
21178  }
21179 
21180 
21181  protected:
21182  EC1G2TagInventoryStateAwareS m_eS;
21183 
21186  public:
21187  static const CFieldDescriptor
21188  s_fdS;
21190 
21192  inline EC1G2TagInventoryStateAwareS
21193  getS (void)
21194  {
21195  return m_eS;
21196  }
21197 
21199  inline void
21201  EC1G2TagInventoryStateAwareS value)
21202  {
21203  m_eS = value;
21204  }
21205 
21206 
21207 };
21208 
21209 
21246 class CC1G2TagSpec : public CParameter
21247 {
21248  public:
21249  CC1G2TagSpec (void);
21250  ~CC1G2TagSpec (void);
21251 
21254 
21255  static const CFieldDescriptor * const
21256  s_apFieldDescriptorTable[];
21257 
21258  static const CTypeDescriptor
21259  s_typeDescriptor;
21260 
21261  void
21262  decodeFields (
21263  CDecoderStream * pDecoderStream);
21264 
21265  void
21266  assimilateSubParameters (
21267  CErrorDetails * pError);
21268 
21269  void
21270  encode (
21271  CEncoderStream * pEncoderStream) const;
21272 
21273 
21274 
21275  static CElement *
21276  s_construct (void);
21277 
21278  static void
21279  s_decodeFields (
21280  CDecoderStream * pDecoderStream,
21281  CElement * pElement);
21283 
21284 
21285  protected:
21286  std::list<CC1G2TargetTag *> m_listC1G2TargetTag;
21287 
21288  public:
21290  inline std::list<CC1G2TargetTag *>::iterator
21292  {
21293  return m_listC1G2TargetTag.begin();
21294  }
21295 
21297  inline std::list<CC1G2TargetTag *>::iterator
21299  {
21300  return m_listC1G2TargetTag.end();
21301  }
21302 
21304  inline void
21306  {
21307  clearSubParameterList ((tListOfParameters *) &m_listC1G2TargetTag);
21308  }
21309 
21311  inline int
21313  {
21314  return (int) (m_listC1G2TargetTag.size());
21315  }
21316 
21317  EResultCode
21320  CC1G2TargetTag * pValue);
21321 
21322 
21323 };
21324 
21325 
21361 class CC1G2TargetTag : public CParameter
21362 {
21363  public:
21364  CC1G2TargetTag (void);
21365  ~CC1G2TargetTag (void);
21366 
21369 
21370  static const CFieldDescriptor * const
21371  s_apFieldDescriptorTable[];
21372 
21373  static const CTypeDescriptor
21374  s_typeDescriptor;
21375 
21376  void
21377  decodeFields (
21378  CDecoderStream * pDecoderStream);
21379 
21380  void
21381  assimilateSubParameters (
21382  CErrorDetails * pError);
21383 
21384  void
21385  encode (
21386  CEncoderStream * pEncoderStream) const;
21387 
21388 
21389 
21390  static CElement *
21391  s_construct (void);
21392 
21393  static void
21394  s_decodeFields (
21395  CDecoderStream * pDecoderStream,
21396  CElement * pElement);
21398 
21399 
21400  protected:
21401  llrp_u2_t m_MB;
21402 
21405  public:
21406  static const CFieldDescriptor
21407  s_fdMB;
21409 
21411  inline llrp_u2_t
21412  getMB (void)
21413  {
21414  return m_MB;
21415  }
21416 
21418  inline void
21420  llrp_u2_t value)
21421  {
21422  m_MB = value;
21423  }
21424 
21425 
21426  protected:
21427  llrp_u1_t m_Match;
21428 
21431  public:
21432  static const CFieldDescriptor
21433  s_fdMatch;
21435 
21437  inline llrp_u1_t
21438  getMatch (void)
21439  {
21440  return m_Match;
21441  }
21442 
21444  inline void
21446  llrp_u1_t value)
21447  {
21448  m_Match = value;
21449  }
21450 
21451 
21452  protected:
21453  llrp_u16_t m_Pointer;
21454 
21457  public:
21458  static const CFieldDescriptor
21459  s_fdPointer;
21461 
21463  inline llrp_u16_t
21464  getPointer (void)
21465  {
21466  return m_Pointer;
21467  }
21468 
21470  inline void
21472  llrp_u16_t value)
21473  {
21474  m_Pointer = value;
21475  }
21476 
21477 
21478  protected:
21479  llrp_u1v_t m_TagMask;
21480 
21483  public:
21484  static const CFieldDescriptor
21485  s_fdTagMask;
21487 
21489  inline llrp_u1v_t
21490  getTagMask (void)
21491  {
21492  return m_TagMask;
21493  }
21494 
21496  inline void
21498  llrp_u1v_t value)
21499  {
21500  m_TagMask = value;
21501  }
21502 
21503 
21504  protected:
21505  llrp_u1v_t m_TagData;
21506 
21509  public:
21510  static const CFieldDescriptor
21511  s_fdTagData;
21513 
21515  inline llrp_u1v_t
21516  getTagData (void)
21517  {
21518  return m_TagData;
21519  }
21520 
21522  inline void
21524  llrp_u1v_t value)
21525  {
21526  m_TagData = value;
21527  }
21528 
21529 
21530 };
21531 
21532 
21571 class CC1G2Read : public CParameter
21572 {
21573  public:
21574  CC1G2Read (void);
21575  ~CC1G2Read (void);
21576 
21579 
21580  static const CFieldDescriptor * const
21581  s_apFieldDescriptorTable[];
21582 
21583  static const CTypeDescriptor
21584  s_typeDescriptor;
21585 
21586  void
21587  decodeFields (
21588  CDecoderStream * pDecoderStream);
21589 
21590  void
21591  assimilateSubParameters (
21592  CErrorDetails * pError);
21593 
21594  void
21595  encode (
21596  CEncoderStream * pEncoderStream) const;
21597 
21598 
21599 
21600  static CElement *
21601  s_construct (void);
21602 
21603  static void
21604  s_decodeFields (
21605  CDecoderStream * pDecoderStream,
21606  CElement * pElement);
21608 
21609 
21610  protected:
21611  llrp_u16_t m_OpSpecID;
21612 
21615  public:
21616  static const CFieldDescriptor
21617  s_fdOpSpecID;
21619 
21621  inline llrp_u16_t
21623  {
21624  return m_OpSpecID;
21625  }
21626 
21628  inline void
21630  llrp_u16_t value)
21631  {
21632  m_OpSpecID = value;
21633  }
21634 
21635 
21636  protected:
21637  llrp_u32_t m_AccessPassword;
21638 
21641  public:
21642  static const CFieldDescriptor
21643  s_fdAccessPassword;
21645 
21647  inline llrp_u32_t
21649  {
21650  return m_AccessPassword;
21651  }
21652 
21654  inline void
21656  llrp_u32_t value)
21657  {
21658  m_AccessPassword = value;
21659  }
21660 
21661 
21662  protected:
21663  llrp_u2_t m_MB;
21664 
21667  public:
21668  static const CFieldDescriptor
21669  s_fdMB;
21671 
21673  inline llrp_u2_t
21674  getMB (void)
21675  {
21676  return m_MB;
21677  }
21678 
21680  inline void
21682  llrp_u2_t value)
21683  {
21684  m_MB = value;
21685  }
21686 
21687 
21688  protected:
21689  llrp_u16_t m_WordPointer;
21690 
21693  public:
21694  static const CFieldDescriptor
21695  s_fdWordPointer;
21697 
21699  inline llrp_u16_t
21701  {
21702  return m_WordPointer;
21703  }
21704 
21706  inline void
21708  llrp_u16_t value)
21709  {
21710  m_WordPointer = value;
21711  }
21712 
21713 
21714  protected:
21715  llrp_u16_t m_WordCount;
21716 
21719  public:
21720  static const CFieldDescriptor
21721  s_fdWordCount;
21723 
21725  inline llrp_u16_t
21727  {
21728  return m_WordCount;
21729  }
21730 
21732  inline void
21734  llrp_u16_t value)
21735  {
21736  m_WordCount = value;
21737  }
21738 
21739 
21740 };
21741 
21742 
21778 class CC1G2Write : public CParameter
21779 {
21780  public:
21781  CC1G2Write (void);
21782  ~CC1G2Write (void);
21783 
21786 
21787  static const CFieldDescriptor * const
21788  s_apFieldDescriptorTable[];
21789 
21790  static const CTypeDescriptor
21791  s_typeDescriptor;
21792 
21793  void
21794  decodeFields (
21795  CDecoderStream * pDecoderStream);
21796 
21797  void
21798  assimilateSubParameters (
21799  CErrorDetails * pError);
21800 
21801  void
21802  encode (
21803  CEncoderStream * pEncoderStream) const;
21804 
21805 
21806 
21807  static CElement *
21808  s_construct (void);
21809 
21810  static void
21811  s_decodeFields (
21812  CDecoderStream * pDecoderStream,
21813  CElement * pElement);
21815 
21816 
21817  protected:
21818  llrp_u16_t m_OpSpecID;
21819 
21822  public:
21823  static const CFieldDescriptor
21824  s_fdOpSpecID;
21826 
21828  inline llrp_u16_t
21830  {
21831  return m_OpSpecID;
21832  }
21833 
21835  inline void
21837  llrp_u16_t value)
21838  {
21839  m_OpSpecID = value;
21840  }
21841 
21842 
21843  protected:
21844  llrp_u32_t m_AccessPassword;
21845 
21848  public:
21849  static const CFieldDescriptor
21850  s_fdAccessPassword;
21852 
21854  inline llrp_u32_t
21856  {
21857  return m_AccessPassword;
21858  }
21859 
21861  inline void
21863  llrp_u32_t value)
21864  {
21865  m_AccessPassword = value;
21866  }
21867 
21868 
21869  protected:
21870  llrp_u2_t m_MB;
21871 
21874  public:
21875  static const CFieldDescriptor
21876  s_fdMB;
21878 
21880  inline llrp_u2_t
21881  getMB (void)
21882  {
21883  return m_MB;
21884  }
21885 
21887  inline void
21889  llrp_u2_t value)
21890  {
21891  m_MB = value;
21892  }
21893 
21894 
21895  protected:
21896  llrp_u16_t m_WordPointer;
21897 
21900  public:
21901  static const CFieldDescriptor
21902  s_fdWordPointer;
21904 
21906  inline llrp_u16_t
21908  {
21909  return m_WordPointer;
21910  }
21911 
21913  inline void
21915  llrp_u16_t value)
21916  {
21917  m_WordPointer = value;
21918  }
21919 
21920 
21921  protected:
21922  llrp_u16v_t m_WriteData;
21923 
21926  public:
21927  static const CFieldDescriptor
21928  s_fdWriteData;
21930 
21932  inline llrp_u16v_t
21934  {
21935  return m_WriteData;
21936  }
21937 
21939  inline void
21941  llrp_u16v_t value)
21942  {
21943  m_WriteData = value;
21944  }
21945 
21946 
21947 };
21948 
21949 
21981 class CC1G2Kill : public CParameter
21982 {
21983  public:
21984  CC1G2Kill (void);
21985  ~CC1G2Kill (void);
21986 
21989 
21990  static const CFieldDescriptor * const
21991  s_apFieldDescriptorTable[];
21992 
21993  static const CTypeDescriptor
21994  s_typeDescriptor;
21995 
21996  void
21997  decodeFields (
21998  CDecoderStream * pDecoderStream);
21999 
22000  void
22001  assimilateSubParameters (
22002  CErrorDetails * pError);
22003 
22004  void
22005  encode (
22006  CEncoderStream * pEncoderStream) const;
22007 
22008 
22009 
22010  static CElement *
22011  s_construct (void);
22012 
22013  static void
22014  s_decodeFields (
22015  CDecoderStream * pDecoderStream,
22016  CElement * pElement);
22018 
22019 
22020  protected:
22021  llrp_u16_t m_OpSpecID;
22022 
22025  public:
22026  static const CFieldDescriptor
22027  s_fdOpSpecID;
22029 
22031  inline llrp_u16_t
22033  {
22034  return m_OpSpecID;
22035  }
22036 
22038  inline void
22040  llrp_u16_t value)
22041  {
22042  m_OpSpecID = value;
22043  }
22044 
22045 
22046  protected:
22047  llrp_u32_t m_KillPassword;
22048 
22051  public:
22052  static const CFieldDescriptor
22053  s_fdKillPassword;
22055 
22057  inline llrp_u32_t
22059  {
22060  return m_KillPassword;
22061  }
22062 
22064  inline void
22066  llrp_u32_t value)
22067  {
22068  m_KillPassword = value;
22069  }
22070 
22071 
22072 };
22073 
22074 
22110 class CC1G2Lock : public CParameter
22111 {
22112  public:
22113  CC1G2Lock (void);
22114  ~CC1G2Lock (void);
22115 
22118 
22119  static const CFieldDescriptor * const
22120  s_apFieldDescriptorTable[];
22121 
22122  static const CTypeDescriptor
22123  s_typeDescriptor;
22124 
22125  void
22126  decodeFields (
22127  CDecoderStream * pDecoderStream);
22128 
22129  void
22130  assimilateSubParameters (
22131  CErrorDetails * pError);
22132 
22133  void
22134  encode (
22135  CEncoderStream * pEncoderStream) const;
22136 
22137 
22138 
22139  static CElement *
22140  s_construct (void);
22141 
22142  static void
22143  s_decodeFields (
22144  CDecoderStream * pDecoderStream,
22145  CElement * pElement);
22147 
22148 
22149  protected:
22150  llrp_u16_t m_OpSpecID;
22151 
22154  public:
22155  static const CFieldDescriptor
22156  s_fdOpSpecID;
22158 
22160  inline llrp_u16_t
22162  {
22163  return m_OpSpecID;
22164  }
22165 
22167  inline void
22169  llrp_u16_t value)
22170  {
22171  m_OpSpecID = value;
22172  }
22173 
22174 
22175  protected:
22176  llrp_u32_t m_AccessPassword;
22177 
22180  public:
22181  static const CFieldDescriptor
22182  s_fdAccessPassword;
22184 
22186  inline llrp_u32_t
22188  {
22189  return m_AccessPassword;
22190  }
22191 
22193  inline void
22195  llrp_u32_t value)
22196  {
22197  m_AccessPassword = value;
22198  }
22199 
22200 
22201  protected:
22202  std::list<CC1G2LockPayload *> m_listC1G2LockPayload;
22203 
22204  public:
22206  inline std::list<CC1G2LockPayload *>::iterator
22208  {
22209  return m_listC1G2LockPayload.begin();
22210  }
22211 
22213  inline std::list<CC1G2LockPayload *>::iterator
22215  {
22216  return m_listC1G2LockPayload.end();
22217  }
22218 
22220  inline void
22222  {
22223  clearSubParameterList ((tListOfParameters *) &m_listC1G2LockPayload);
22224  }
22225 
22227  inline int
22229  {
22230  return (int) (m_listC1G2LockPayload.size());
22231  }
22232 
22233  EResultCode
22236  CC1G2LockPayload * pValue);
22237 
22238 
22239 };
22240 
22241 
22273 class CC1G2LockPayload : public CParameter
22274 {
22275  public:
22276  CC1G2LockPayload (void);
22277  ~CC1G2LockPayload (void);
22278 
22281 
22282  static const CFieldDescriptor * const
22283  s_apFieldDescriptorTable[];
22284 
22285  static const CTypeDescriptor
22286  s_typeDescriptor;
22287 
22288  void
22289  decodeFields (
22290  CDecoderStream * pDecoderStream);
22291 
22292  void
22293  assimilateSubParameters (
22294  CErrorDetails * pError);
22295 
22296  void
22297  encode (
22298  CEncoderStream * pEncoderStream) const;
22299 
22300 
22301 
22302  static CElement *
22303  s_construct (void);
22304 
22305  static void
22306  s_decodeFields (
22307  CDecoderStream * pDecoderStream,
22308  CElement * pElement);
22310 
22311 
22312  protected:
22313  EC1G2LockPrivilege m_ePrivilege;
22314 
22317  public:
22318  static const CFieldDescriptor
22319  s_fdPrivilege;
22321 
22323  inline EC1G2LockPrivilege
22325  {
22326  return m_ePrivilege;
22327  }
22328 
22330  inline void
22332  EC1G2LockPrivilege value)
22333  {
22334  m_ePrivilege = value;
22335  }
22336 
22337 
22338  protected:
22339  EC1G2LockDataField m_eDataField;
22340 
22343  public:
22344  static const CFieldDescriptor
22345  s_fdDataField;
22347 
22349  inline EC1G2LockDataField
22351  {
22352  return m_eDataField;
22353  }
22354 
22356  inline void
22358  EC1G2LockDataField value)
22359  {
22360  m_eDataField = value;
22361  }
22362 
22363 
22364 };
22365 
22366 
22409 class CC1G2BlockErase : public CParameter
22410 {
22411  public:
22412  CC1G2BlockErase (void);
22413  ~CC1G2BlockErase (void);
22414 
22417 
22418  static const CFieldDescriptor * const
22419  s_apFieldDescriptorTable[];
22420 
22421  static const CTypeDescriptor
22422  s_typeDescriptor;
22423 
22424  void
22425  decodeFields (
22426  CDecoderStream * pDecoderStream);
22427 
22428  void
22429  assimilateSubParameters (
22430  CErrorDetails * pError);
22431 
22432  void
22433  encode (
22434  CEncoderStream * pEncoderStream) const;
22435 
22436 
22437 
22438  static CElement *
22439  s_construct (void);
22440 
22441  static void
22442  s_decodeFields (
22443  CDecoderStream * pDecoderStream,
22444  CElement * pElement);
22446 
22447 
22448  protected:
22449  llrp_u16_t m_OpSpecID;
22450 
22453  public:
22454  static const CFieldDescriptor
22455  s_fdOpSpecID;
22457 
22459  inline llrp_u16_t
22461  {
22462  return m_OpSpecID;
22463  }
22464 
22466  inline void
22468  llrp_u16_t value)
22469  {
22470  m_OpSpecID = value;
22471  }
22472 
22473 
22474  protected:
22475  llrp_u32_t m_AccessPassword;
22476 
22479  public:
22480  static const CFieldDescriptor
22481  s_fdAccessPassword;
22483 
22485  inline llrp_u32_t
22487  {
22488  return m_AccessPassword;
22489  }
22490 
22492  inline void
22494  llrp_u32_t value)
22495  {
22496  m_AccessPassword = value;
22497  }
22498 
22499 
22500  protected:
22501  llrp_u2_t m_MB;
22502 
22505  public:
22506  static const CFieldDescriptor
22507  s_fdMB;
22509 
22511  inline llrp_u2_t
22512  getMB (void)
22513  {
22514  return m_MB;
22515  }
22516 
22518  inline void
22520  llrp_u2_t value)
22521  {
22522  m_MB = value;
22523  }
22524 
22525 
22526  protected:
22527  llrp_u16_t m_WordPointer;
22528 
22531  public:
22532  static const CFieldDescriptor
22533  s_fdWordPointer;
22535 
22537  inline llrp_u16_t
22539  {
22540  return m_WordPointer;
22541  }
22542 
22544  inline void
22546  llrp_u16_t value)
22547  {
22548  m_WordPointer = value;
22549  }
22550 
22551 
22552  protected:
22553  llrp_u16_t m_WordCount;
22554 
22557  public:
22558  static const CFieldDescriptor
22559  s_fdWordCount;
22561 
22563  inline llrp_u16_t
22565  {
22566  return m_WordCount;
22567  }
22568 
22570  inline void
22572  llrp_u16_t value)
22573  {
22574  m_WordCount = value;
22575  }
22576 
22577 
22578 };
22579 
22580 
22623 class CC1G2BlockWrite : public CParameter
22624 {
22625  public:
22626  CC1G2BlockWrite (void);
22627  ~CC1G2BlockWrite (void);
22628 
22631 
22632  static const CFieldDescriptor * const
22633  s_apFieldDescriptorTable[];
22634 
22635  static const CTypeDescriptor
22636  s_typeDescriptor;
22637 
22638  void
22639  decodeFields (
22640  CDecoderStream * pDecoderStream);
22641 
22642  void
22643  assimilateSubParameters (
22644  CErrorDetails * pError);
22645 
22646  void
22647  encode (
22648  CEncoderStream * pEncoderStream) const;
22649 
22650 
22651 
22652  static CElement *
22653  s_construct (void);
22654 
22655  static void
22656  s_decodeFields (
22657  CDecoderStream * pDecoderStream,
22658  CElement * pElement);
22660 
22661 
22662  protected:
22663  llrp_u16_t m_OpSpecID;
22664 
22667  public:
22668  static const CFieldDescriptor
22669  s_fdOpSpecID;
22671 
22673  inline llrp_u16_t
22675  {
22676  return m_OpSpecID;
22677  }
22678 
22680  inline void
22682  llrp_u16_t value)
22683  {
22684  m_OpSpecID = value;
22685  }
22686 
22687 
22688  protected:
22689  llrp_u32_t m_AccessPassword;
22690 
22693  public:
22694  static const CFieldDescriptor
22695  s_fdAccessPassword;
22697 
22699  inline llrp_u32_t
22701  {
22702  return m_AccessPassword;
22703  }
22704 
22706  inline void
22708  llrp_u32_t value)
22709  {
22710  m_AccessPassword = value;
22711  }
22712 
22713 
22714  protected:
22715  llrp_u2_t m_MB;
22716 
22719  public:
22720  static const CFieldDescriptor
22721  s_fdMB;
22723 
22725  inline llrp_u2_t
22726  getMB (void)
22727  {
22728  return m_MB;
22729  }
22730 
22732  inline void
22734  llrp_u2_t value)
22735  {
22736  m_MB = value;
22737  }
22738 
22739 
22740  protected:
22741  llrp_u16_t m_WordPointer;
22742 
22745  public:
22746  static const CFieldDescriptor
22747  s_fdWordPointer;
22749 
22751  inline llrp_u16_t
22753  {
22754  return m_WordPointer;
22755  }
22756 
22758  inline void
22760  llrp_u16_t value)
22761  {
22762  m_WordPointer = value;
22763  }
22764 
22765 
22766  protected:
22767  llrp_u16v_t m_WriteData;
22768 
22771  public:
22772  static const CFieldDescriptor
22773  s_fdWriteData;
22775 
22777  inline llrp_u16v_t
22779  {
22780  return m_WriteData;
22781  }
22782 
22784  inline void
22786  llrp_u16v_t value)
22787  {
22788  m_WriteData = value;
22789  }
22790 
22791 
22792 };
22793 
22794 
22827 class CC1G2EPCMemorySelector : public CParameter
22828 {
22829  public:
22830  CC1G2EPCMemorySelector (void);
22831  ~CC1G2EPCMemorySelector (void);
22832 
22835 
22836  static const CFieldDescriptor * const
22837  s_apFieldDescriptorTable[];
22838 
22839  static const CTypeDescriptor
22840  s_typeDescriptor;
22841 
22842  void
22843  decodeFields (
22844  CDecoderStream * pDecoderStream);
22845 
22846  void
22847  assimilateSubParameters (
22848  CErrorDetails * pError);
22849 
22850  void
22851  encode (
22852  CEncoderStream * pEncoderStream) const;
22853 
22854 
22855 
22856  static CElement *
22857  s_construct (void);
22858 
22859  static void
22860  s_decodeFields (
22861  CDecoderStream * pDecoderStream,
22862  CElement * pElement);
22864 
22865 
22866  protected:
22867  llrp_u1_t m_EnableCRC;
22868 
22871  public:
22872  static const CFieldDescriptor
22873  s_fdEnableCRC;
22875 
22877  inline llrp_u1_t
22879  {
22880  return m_EnableCRC;
22881  }
22882 
22884  inline void
22886  llrp_u1_t value)
22887  {
22888  m_EnableCRC = value;
22889  }
22890 
22891 
22892  protected:
22893  llrp_u1_t m_EnablePCBits;
22894 
22897  public:
22898  static const CFieldDescriptor
22899  s_fdEnablePCBits;
22901 
22903  inline llrp_u1_t
22905  {
22906  return m_EnablePCBits;
22907  }
22908 
22910  inline void
22912  llrp_u1_t value)
22913  {
22914  m_EnablePCBits = value;
22915  }
22916 
22917 
22918 };
22919 
22920 
22951 class CC1G2_PC : public CParameter
22952 {
22953  public:
22954  CC1G2_PC (void);
22955  ~CC1G2_PC (void);
22956 
22959 
22960  static const CFieldDescriptor * const
22961  s_apFieldDescriptorTable[];
22962 
22963  static const CTypeDescriptor
22964  s_typeDescriptor;
22965 
22966  void
22967  decodeFields (
22968  CDecoderStream * pDecoderStream);
22969 
22970  void
22971  assimilateSubParameters (
22972  CErrorDetails * pError);
22973 
22974  void
22975  encode (
22976  CEncoderStream * pEncoderStream) const;
22977 
22978 
22979 
22980  static CElement *
22981  s_construct (void);
22982 
22983  static void
22984  s_decodeFields (
22985  CDecoderStream * pDecoderStream,
22986  CElement * pElement);
22988 
22989 
22990  protected:
22991  llrp_u16_t m_PC_Bits;
22992 
22995  public:
22996  static const CFieldDescriptor
22997  s_fdPC_Bits;
22999 
23001  inline llrp_u16_t
23002  getPC_Bits (void)
23003  {
23004  return m_PC_Bits;
23005  }
23006 
23008  inline void
23010  llrp_u16_t value)
23011  {
23012  m_PC_Bits = value;
23013  }
23014 
23015 
23016 };
23017 
23018 
23049 class CC1G2_CRC : public CParameter
23050 {
23051  public:
23052  CC1G2_CRC (void);
23053  ~CC1G2_CRC (void);
23054 
23057 
23058  static const CFieldDescriptor * const
23059  s_apFieldDescriptorTable[];
23060 
23061  static const CTypeDescriptor
23062  s_typeDescriptor;
23063 
23064  void
23065  decodeFields (
23066  CDecoderStream * pDecoderStream);
23067 
23068  void
23069  assimilateSubParameters (
23070  CErrorDetails * pError);
23071 
23072  void
23073  encode (
23074  CEncoderStream * pEncoderStream) const;
23075 
23076 
23077 
23078  static CElement *
23079  s_construct (void);
23080 
23081  static void
23082  s_decodeFields (
23083  CDecoderStream * pDecoderStream,
23084  CElement * pElement);
23086 
23087 
23088  protected:
23089  llrp_u16_t m_CRC;
23090 
23093  public:
23094  static const CFieldDescriptor
23095  s_fdCRC;
23097 
23099  inline llrp_u16_t
23100  getCRC (void)
23101  {
23102  return m_CRC;
23103  }
23104 
23106  inline void
23108  llrp_u16_t value)
23109  {
23110  m_CRC = value;
23111  }
23112 
23113 
23114 };
23115 
23116 
23141 class CC1G2SingulationDetails : public CParameter
23142 {
23143  public:
23144  CC1G2SingulationDetails (void);
23145  ~CC1G2SingulationDetails (void);
23146 
23149 
23150  static const CFieldDescriptor * const
23151  s_apFieldDescriptorTable[];
23152 
23153  static const CTypeDescriptor
23154  s_typeDescriptor;
23155 
23156  void
23157  decodeFields (
23158  CDecoderStream * pDecoderStream);
23159 
23160  void
23161  assimilateSubParameters (
23162  CErrorDetails * pError);
23163 
23164  void
23165  encode (
23166  CEncoderStream * pEncoderStream) const;
23167 
23168 
23169 
23170  static CElement *
23171  s_construct (void);
23172 
23173  static void
23174  s_decodeFields (
23175  CDecoderStream * pDecoderStream,
23176  CElement * pElement);
23178 
23179 
23180  protected:
23181  llrp_u16_t m_NumCollisionSlots;
23182 
23185  public:
23186  static const CFieldDescriptor
23187  s_fdNumCollisionSlots;
23189 
23191  inline llrp_u16_t
23193  {
23194  return m_NumCollisionSlots;
23195  }
23196 
23198  inline void
23200  llrp_u16_t value)
23201  {
23202  m_NumCollisionSlots = value;
23203  }
23204 
23205 
23206  protected:
23207  llrp_u16_t m_NumEmptySlots;
23208 
23211  public:
23212  static const CFieldDescriptor
23213  s_fdNumEmptySlots;
23215 
23217  inline llrp_u16_t
23219  {
23220  return m_NumEmptySlots;
23221  }
23222 
23224  inline void
23226  llrp_u16_t value)
23227  {
23228  m_NumEmptySlots = value;
23229  }
23230 
23231 
23232 };
23233 
23234 
23267 class CC1G2ReadOpSpecResult : public CParameter
23268 {
23269  public:
23270  CC1G2ReadOpSpecResult (void);
23271  ~CC1G2ReadOpSpecResult (void);
23272 
23275 
23276  static const CFieldDescriptor * const
23277  s_apFieldDescriptorTable[];
23278 
23279  static const CTypeDescriptor
23280  s_typeDescriptor;
23281 
23282  void
23283  decodeFields (
23284  CDecoderStream * pDecoderStream);
23285 
23286  void
23287  assimilateSubParameters (
23288  CErrorDetails * pError);
23289 
23290  void
23291  encode (
23292  CEncoderStream * pEncoderStream) const;
23293 
23294 
23295 
23296  static CElement *
23297  s_construct (void);
23298 
23299  static void
23300  s_decodeFields (
23301  CDecoderStream * pDecoderStream,
23302  CElement * pElement);
23304 
23305 
23306  protected:
23307  EC1G2ReadResultType m_eResult;
23308 
23311  public:
23312  static const CFieldDescriptor
23313  s_fdResult;
23315 
23317  inline EC1G2ReadResultType
23318  getResult (void)
23319  {
23320  return m_eResult;
23321  }
23322 
23324  inline void
23326  EC1G2ReadResultType value)
23327  {
23328  m_eResult = value;
23329  }
23330 
23331 
23332  protected:
23333  llrp_u16_t m_OpSpecID;
23334 
23337  public:
23338  static const CFieldDescriptor
23339  s_fdOpSpecID;
23341 
23343  inline llrp_u16_t
23345  {
23346  return m_OpSpecID;
23347  }
23348 
23350  inline void
23352  llrp_u16_t value)
23353  {
23354  m_OpSpecID = value;
23355  }
23356 
23357 
23358  protected:
23359  llrp_u16v_t m_ReadData;
23360 
23363  public:
23364  static const CFieldDescriptor
23365  s_fdReadData;
23367 
23369  inline llrp_u16v_t
23371  {
23372  return m_ReadData;
23373  }
23374 
23376  inline void
23378  llrp_u16v_t value)
23379  {
23380  m_ReadData = value;
23381  }
23382 
23383 
23384 };
23385 
23386 
23424 class CC1G2WriteOpSpecResult : public CParameter
23425 {
23426  public:
23427  CC1G2WriteOpSpecResult (void);
23428  ~CC1G2WriteOpSpecResult (void);
23429 
23432 
23433  static const CFieldDescriptor * const
23434  s_apFieldDescriptorTable[];
23435 
23436  static const CTypeDescriptor
23437  s_typeDescriptor;
23438 
23439  void
23440  decodeFields (
23441  CDecoderStream * pDecoderStream);
23442 
23443  void
23444  assimilateSubParameters (
23445  CErrorDetails * pError);
23446 
23447  void
23448  encode (
23449  CEncoderStream * pEncoderStream) const;
23450 
23451 
23452 
23453  static CElement *
23454  s_construct (void);
23455 
23456  static void
23457  s_decodeFields (
23458  CDecoderStream * pDecoderStream,
23459  CElement * pElement);
23461 
23462 
23463  protected:
23464  EC1G2WriteResultType m_eResult;
23465 
23468  public:
23469  static const CFieldDescriptor
23470  s_fdResult;
23472 
23474  inline EC1G2WriteResultType
23475  getResult (void)
23476  {
23477  return m_eResult;
23478  }
23479 
23481  inline void
23483  EC1G2WriteResultType value)
23484  {
23485  m_eResult = value;
23486  }
23487 
23488 
23489  protected:
23490  llrp_u16_t m_OpSpecID;
23491 
23494  public:
23495  static const CFieldDescriptor
23496  s_fdOpSpecID;
23498 
23500  inline llrp_u16_t
23502  {
23503  return m_OpSpecID;
23504  }
23505 
23507  inline void
23509  llrp_u16_t value)
23510  {
23511  m_OpSpecID = value;
23512  }
23513 
23514 
23515  protected:
23516  llrp_u16_t m_NumWordsWritten;
23517 
23520  public:
23521  static const CFieldDescriptor
23522  s_fdNumWordsWritten;
23524 
23526  inline llrp_u16_t
23528  {
23529  return m_NumWordsWritten;
23530  }
23531 
23533  inline void
23535  llrp_u16_t value)
23536  {
23537  m_NumWordsWritten = value;
23538  }
23539 
23540 
23541 };
23542 
23543 
23573 class CC1G2KillOpSpecResult : public CParameter
23574 {
23575  public:
23576  CC1G2KillOpSpecResult (void);
23577  ~CC1G2KillOpSpecResult (void);
23578 
23581 
23582  static const CFieldDescriptor * const
23583  s_apFieldDescriptorTable[];
23584 
23585  static const CTypeDescriptor
23586  s_typeDescriptor;
23587 
23588  void
23589  decodeFields (
23590  CDecoderStream * pDecoderStream);
23591 
23592  void
23593  assimilateSubParameters (
23594  CErrorDetails * pError);
23595 
23596  void
23597  encode (
23598  CEncoderStream * pEncoderStream) const;
23599 
23600 
23601 
23602  static CElement *
23603  s_construct (void);
23604 
23605  static void
23606  s_decodeFields (
23607  CDecoderStream * pDecoderStream,
23608  CElement * pElement);
23610 
23611 
23612  protected:
23613  EC1G2KillResultType m_eResult;
23614 
23617  public:
23618  static const CFieldDescriptor
23619  s_fdResult;
23621 
23623  inline EC1G2KillResultType
23624  getResult (void)
23625  {
23626  return m_eResult;
23627  }
23628 
23630  inline void
23632  EC1G2KillResultType value)
23633  {
23634  m_eResult = value;
23635  }
23636 
23637 
23638  protected:
23639  llrp_u16_t m_OpSpecID;
23640 
23643  public:
23644  static const CFieldDescriptor
23645  s_fdOpSpecID;
23647 
23649  inline llrp_u16_t
23651  {
23652  return m_OpSpecID;
23653  }
23654 
23656  inline void
23658  llrp_u16_t value)
23659  {
23660  m_OpSpecID = value;
23661  }
23662 
23663 
23664 };
23665 
23666 
23698 class CC1G2LockOpSpecResult : public CParameter
23699 {
23700  public:
23701  CC1G2LockOpSpecResult (void);
23702  ~CC1G2LockOpSpecResult (void);
23703 
23706 
23707  static const CFieldDescriptor * const
23708  s_apFieldDescriptorTable[];
23709 
23710  static const CTypeDescriptor
23711  s_typeDescriptor;
23712 
23713  void
23714  decodeFields (
23715  CDecoderStream * pDecoderStream);
23716 
23717  void
23718  assimilateSubParameters (
23719  CErrorDetails * pError);
23720 
23721  void
23722  encode (
23723  CEncoderStream * pEncoderStream) const;
23724 
23725 
23726 
23727  static CElement *
23728  s_construct (void);
23729 
23730  static void
23731  s_decodeFields (
23732  CDecoderStream * pDecoderStream,
23733  CElement * pElement);
23735 
23736 
23737  protected:
23738  EC1G2LockResultType m_eResult;
23739 
23742  public:
23743  static const CFieldDescriptor
23744  s_fdResult;
23746 
23748  inline EC1G2LockResultType
23749  getResult (void)
23750  {
23751  return m_eResult;
23752  }
23753 
23755  inline void
23757  EC1G2LockResultType value)
23758  {
23759  m_eResult = value;
23760  }
23761 
23762 
23763  protected:
23764  llrp_u16_t m_OpSpecID;
23765 
23768  public:
23769  static const CFieldDescriptor
23770  s_fdOpSpecID;
23772 
23774  inline llrp_u16_t
23776  {
23777  return m_OpSpecID;
23778  }
23779 
23781  inline void
23783  llrp_u16_t value)
23784  {
23785  m_OpSpecID = value;
23786  }
23787 
23788 
23789 };
23790 
23791 
23830 class CC1G2BlockEraseOpSpecResult : public CParameter
23831 {
23832  public:
23835 
23838 
23839  static const CFieldDescriptor * const
23840  s_apFieldDescriptorTable[];
23841 
23842  static const CTypeDescriptor
23843  s_typeDescriptor;
23844 
23845  void
23846  decodeFields (
23847  CDecoderStream * pDecoderStream);
23848 
23849  void
23850  assimilateSubParameters (
23851  CErrorDetails * pError);
23852 
23853  void
23854  encode (
23855  CEncoderStream * pEncoderStream) const;
23856 
23857 
23858 
23859  static CElement *
23860  s_construct (void);
23861 
23862  static void
23863  s_decodeFields (
23864  CDecoderStream * pDecoderStream,
23865  CElement * pElement);
23867 
23868 
23869  protected:
23870  EC1G2BlockEraseResultType m_eResult;
23871 
23874  public:
23875  static const CFieldDescriptor
23876  s_fdResult;
23878 
23880  inline EC1G2BlockEraseResultType
23881  getResult (void)
23882  {
23883  return m_eResult;
23884  }
23885 
23887  inline void
23889  EC1G2BlockEraseResultType value)
23890  {
23891  m_eResult = value;
23892  }
23893 
23894 
23895  protected:
23896  llrp_u16_t m_OpSpecID;
23897 
23900  public:
23901  static const CFieldDescriptor
23902  s_fdOpSpecID;
23904 
23906  inline llrp_u16_t
23908  {
23909  return m_OpSpecID;
23910  }
23911 
23913  inline void
23915  llrp_u16_t value)
23916  {
23917  m_OpSpecID = value;
23918  }
23919 
23920 
23921 };
23922 
23923 
23963 class CC1G2BlockWriteOpSpecResult : public CParameter
23964 {
23965  public:
23968 
23971 
23972  static const CFieldDescriptor * const
23973  s_apFieldDescriptorTable[];
23974 
23975  static const CTypeDescriptor
23976  s_typeDescriptor;
23977 
23978  void
23979  decodeFields (
23980  CDecoderStream * pDecoderStream);
23981 
23982  void
23983  assimilateSubParameters (
23984  CErrorDetails * pError);
23985 
23986  void
23987  encode (
23988  CEncoderStream * pEncoderStream) const;
23989 
23990 
23991 
23992  static CElement *
23993  s_construct (void);
23994 
23995  static void
23996  s_decodeFields (
23997  CDecoderStream * pDecoderStream,
23998  CElement * pElement);
24000 
24001 
24002  protected:
24003  EC1G2BlockWriteResultType m_eResult;
24004 
24007  public:
24008  static const CFieldDescriptor
24009  s_fdResult;
24011 
24013  inline EC1G2BlockWriteResultType
24014  getResult (void)
24015  {
24016  return m_eResult;
24017  }
24018 
24020  inline void
24022  EC1G2BlockWriteResultType value)
24023  {
24024  m_eResult = value;
24025  }
24026 
24027 
24028  protected:
24029  llrp_u16_t m_OpSpecID;
24030 
24033  public:
24034  static const CFieldDescriptor
24035  s_fdOpSpecID;
24037 
24039  inline llrp_u16_t
24041  {
24042  return m_OpSpecID;
24043  }
24044 
24046  inline void
24048  llrp_u16_t value)
24049  {
24050  m_OpSpecID = value;
24051  }
24052 
24053 
24054  protected:
24055  llrp_u16_t m_NumWordsWritten;
24056 
24059  public:
24060  static const CFieldDescriptor
24061  s_fdNumWordsWritten;
24063 
24065  inline llrp_u16_t
24067  {
24068  return m_NumWordsWritten;
24069  }
24070 
24072  inline void
24074  llrp_u16_t value)
24075  {
24076  m_NumWordsWritten = value;
24077  }
24078 
24079 
24080 };
24081 
24082 
24085 class CSpecParameter
24086 {
24089  public:
24090  static const CTypeDescriptor
24091  s_typeDescriptor;
24092 
24093  static llrp_bool_t
24094  isMember (
24095  CParameter * pParameter);
24097 
24098 };
24099 
24100 class CAccessCommandOpSpec
24101 {
24104  public:
24105  static const CTypeDescriptor
24106  s_typeDescriptor;
24107 
24108  static llrp_bool_t
24109  isMember (
24110  CParameter * pParameter);
24112 
24113 };
24114 
24115 class CAccessCommandOpSpecResult
24116 {
24119  public:
24120  static const CTypeDescriptor
24121  s_typeDescriptor;
24122 
24123  static llrp_bool_t
24124  isMember (
24125  CParameter * pParameter);
24127 
24128 };
24129 
24130 class CEPCParameter
24131 {
24134  public:
24135  static const CTypeDescriptor
24136  s_typeDescriptor;
24137 
24138  static llrp_bool_t
24139  isMember (
24140  CParameter * pParameter);
24142 
24143 };
24144 
24145 class CTimestamp
24146 {
24149  public:
24150  static const CTypeDescriptor
24151  s_typeDescriptor;
24152 
24153  static llrp_bool_t
24154  isMember (
24155  CParameter * pParameter);
24157 
24158 };
24159 
24160 class CC1G2OpSpec
24161 {
24164  public:
24165  static const CTypeDescriptor
24166  s_typeDescriptor;
24167 
24168  static llrp_bool_t
24169  isMember (
24170  CParameter * pParameter);
24172 
24173 };
24174 
24175 class CAirProtocolLLRPCapabilities
24176 {
24179  public:
24180  static const CTypeDescriptor
24181  s_typeDescriptor;
24182 
24183  static llrp_bool_t
24184  isMember (
24185  CParameter * pParameter);
24187 
24188 };
24189 
24190 class CAirProtocolUHFRFModeTable
24191 {
24194  public:
24195  static const CTypeDescriptor
24196  s_typeDescriptor;
24197 
24198  static llrp_bool_t
24199  isMember (
24200  CParameter * pParameter);
24202 
24203 };
24204 
24205 class CAirProtocolInventoryCommandSettings
24206 {
24209  public:
24210  static const CTypeDescriptor
24211  s_typeDescriptor;
24212 
24213  static llrp_bool_t
24214  isMember (
24215  CParameter * pParameter);
24217 
24218 };
24219 
24220 class CAirProtocolTagSpec
24221 {
24224  public:
24225  static const CTypeDescriptor
24226  s_typeDescriptor;
24227 
24228  static llrp_bool_t
24229  isMember (
24230  CParameter * pParameter);
24232 
24233 };
24234 
24235 class CAirProtocolOpSpec
24236 {
24239  public:
24240  static const CTypeDescriptor
24241  s_typeDescriptor;
24242 
24243  static llrp_bool_t
24244  isMember (
24245  CParameter * pParameter);
24247 
24248 };
24249 
24250 class CAirProtocolEPCMemorySelector
24251 {
24254  public:
24255  static const CTypeDescriptor
24256  s_typeDescriptor;
24257 
24258  static llrp_bool_t
24259  isMember (
24260  CParameter * pParameter);
24262 
24263 };
24264 
24265 class CAirProtocolTagData
24266 {
24269  public:
24270  static const CTypeDescriptor
24271  s_typeDescriptor;
24272 
24273  static llrp_bool_t
24274  isMember (
24275  CParameter * pParameter);
24277 
24278 };
24279 
24280 class CAirProtocolSingulationDetails
24281 {
24284  public:
24285  static const CTypeDescriptor
24286  s_typeDescriptor;
24287 
24288  static llrp_bool_t
24289  isMember (
24290  CParameter * pParameter);
24292 
24293 };
24294 
24295 
24307 extern void
24309  CTypeRegistry * pTypeRegistry);
llrp_u16_t getN(void)
Get accessor functions for the LLRP N field.
Definition: out_ltkcpp.h:13675
void setEnableFirstSeenTimestamp(llrp_u1_t value)
Set accessor functions for the LLRP EnableFirstSeenTimestamp field.
Definition: out_ltkcpp.h:14002
void setWordPointer(llrp_u16_t value)
Set accessor functions for the LLRP WordPointer field.
Definition: out_ltkcpp.h:22759
llrp_utf8v_t getMessage(void)
Get accessor functions for the LLRP Message field.
Definition: out_ltkcpp.h:17978
Class Definition CERROR_MESSAGE for LLRP message ERROR_MESSAGE.
Definition: out_ltkcpp.h:6659
EResultCode addAirProtocolTagData(CParameter *pValue)
Add a AirProtocolTagData to the LLRP sub-parameter list.
std::list< CAccessSpec * >::iterator beginAccessSpec(void)
Returns the first element of the AccessSpec sub-parameter list.
Definition: out_ltkcpp.h:4520
void setRequestedData(EGetReaderConfigRequestedData value)
Set accessor functions for the LLRP RequestedData field.
Definition: out_ltkcpp.h:4851
void setAccessSpecID(llrp_u32_t value)
Set accessor functions for the LLRP AccessSpecID field.
Definition: out_ltkcpp.h:4067
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:2921
llrp_u16v_t getWriteData(void)
Get accessor functions for the LLRP WriteData field.
Definition: out_ltkcpp.h:21933
CPeakRSSI * getPeakRSSI(void)
Get accessor functions for the LLRP PeakRSSI sub-parameter.
Definition: out_ltkcpp.h:14525
std::list< CParameter * >::iterator endAirProtocolTagData(void)
Returns the last element of the AirProtocolTagData sub-parameter list.
Definition: out_ltkcpp.h:14651
EResultCode setLLRPConfigurationStateValue(CLLRPConfigurationStateValue *pValue)
Set accessor functions for the LLRP LLRPConfigurationStateValue sub-parameter.
Class Definition CConnectionAttemptEvent for LLRP parameter ConnectionAttemptEvent.
Definition: out_ltkcpp.h:18712
void setEndFrequency(llrp_u32_t value)
Set accessor functions for the LLRP EndFrequency field.
Definition: out_ltkcpp.h:11120
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
llrp_bytesToEnd_t getData(void)
Get accessor functions for the LLRP Data field.
Definition: out_ltkcpp.h:7076
std::list< CParameter * >::iterator beginAirProtocolEPCMemorySelector(void)
Returns the first element of the AirProtocolEPCMemorySelector sub-parameter list. ...
Definition: out_ltkcpp.h:14093
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:22681
llrp_u16_t getCRC(void)
Get accessor functions for the LLRP CRC field.
Definition: out_ltkcpp.h:23100
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:18349
llrp_u32_t getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID field.
Definition: out_ltkcpp.h:12126
void setEnableCRC(llrp_u1_t value)
Set accessor functions for the LLRP EnableCRC field.
Definition: out_ltkcpp.h:22885
void setPeriodicTriggerValue(llrp_u32_t value)
Set accessor functions for the LLRP PeriodicTriggerValue field.
Definition: out_ltkcpp.h:12708
void setFrequency(llrp_u32_t value)
Set accessor functions for the LLRP Frequency field.
Definition: out_ltkcpp.h:16566
EResultCode setTagObservationTrigger(CTagObservationTrigger *pValue)
Set accessor functions for the LLRP TagObservationTrigger sub-parameter.
EResultCode setTimestamp(CParameter *pValue)
Set accessor functions for the LLRP Timestamp sub-parameter.
Class Definition CDELETE_ACCESSSPEC_RESPONSE for LLRP message DELETE_ACCESSSPEC_RESPONSE.
Definition: out_ltkcpp.h:3917
void setStatusCode(EStatusCode value)
Set accessor functions for the LLRP StatusCode field.
Definition: out_ltkcpp.h:18946
void setHopping(llrp_u1_t value)
Set accessor functions for the LLRP Hopping field.
Definition: out_ltkcpp.h:8978
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:23650
EC1G2WriteResultType getResult(void)
Get accessor functions for the LLRP Result field.
Definition: out_ltkcpp.h:23475
void clearTagReportData(void)
Clears the LLRP TagReportData sub-parameter list.
Definition: out_ltkcpp.h:6200
CAntennaID * getAntennaID(void)
Get accessor functions for the LLRP AntennaID sub-parameter.
Definition: out_ltkcpp.h:18049
void setGPIPortNumber(llrp_u16_t value)
Set accessor functions for the LLRP GPIPortNumber field.
Definition: out_ltkcpp.h:17518
llrp_u32_t getVendorIdentifier(void)
Get accessor functions for the LLRP VendorIdentifier field.
Definition: out_ltkcpp.h:7024
EAccessReportTriggerType getAccessReportTrigger(void)
Get accessor functions for the LLRP AccessReportTrigger field.
Definition: out_ltkcpp.h:14209
std::list< CTransmitPowerLevelTableEntry * >::iterator beginTransmitPowerLevelTableEntry(void)
Returns the first element of the TransmitPowerLevelTableEntry sub-parameter list. ...
Definition: out_ltkcpp.h:8672
CTagObservationTrigger * getTagObservationTrigger(void)
Get accessor functions for the LLRP TagObservationTrigger sub-parameter.
Definition: out_ltkcpp.h:10552
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:4923
Class Definition CPeakRSSI for LLRP parameter PeakRSSI.
Definition: out_ltkcpp.h:15393
EResultCode setC1G2TagInventoryStateAwareFilterAction(CC1G2TagInventoryStateAwareFilterAction *pValue)
Set accessor functions for the LLRP C1G2TagInventoryStateAwareFilterAction sub-parameter.
llrp_u16_t getWordPointer(void)
Get accessor functions for the LLRP WordPointer field.
Definition: out_ltkcpp.h:22538
std::list< CParameter * >::iterator endSpecParameter(void)
Returns the last element of the SpecParameter sub-parameter list.
Definition: out_ltkcpp.h:9463
void setReceiveSensitivityValue(llrp_s16_t value)
Set accessor functions for the LLRP ReceiveSensitivityValue field.
Definition: out_ltkcpp.h:7580
Class Definition CFirstSeenTimestampUTC for LLRP parameter FirstSeenTimestampUTC. ...
Definition: out_ltkcpp.h:15597
Class Definition CADD_ACCESSSPEC_RESPONSE for LLRP message ADD_ACCESSSPEC_RESPONSE.
Definition: out_ltkcpp.h:3727
std::list< CGPOWriteData * >::iterator beginGPOWriteData(void)
Returns the first element of the GPOWriteData sub-parameter list.
Definition: out_ltkcpp.h:5643
llrp_u16_t getSpecIndex(void)
Get accessor functions for the LLRP SpecIndex field.
Definition: out_ltkcpp.h:18368
Class Definition CLastSeenTimestampUptime for LLRP parameter LastSeenTimestampUptime.
Definition: out_ltkcpp.h:15904
Class Definition CSpecIndex for LLRP parameter SpecIndex.
Definition: out_ltkcpp.h:15096
CC1G2TagInventoryStateUnawareFilterAction * getC1G2TagInventoryStateUnawareFilterAction(void)
Get accessor functions for the LLRP C1G2TagInventoryStateUnawareFilterAction sub-parameter.
Definition: out_ltkcpp.h:20321
EResultCode setC1G2SingulationControl(CC1G2SingulationControl *pValue)
Set accessor functions for the LLRP C1G2SingulationControl sub-parameter.
void setCanDoTagInventoryStateAwareSingulation(llrp_u1_t value)
Set accessor functions for the LLRP CanDoTagInventoryStateAwareSingulation field. ...
Definition: out_ltkcpp.h:8192
void setAccessSpecID(llrp_u32_t value)
Set accessor functions for the LLRP AccessSpecID field.
Definition: out_ltkcpp.h:11434
llrp_u16_t getMaxNumSelectFiltersPerQuery(void)
Get accessor functions for the LLRP MaxNumSelectFiltersPerQuery field.
Definition: out_ltkcpp.h:19444
Class Definition CPerAntennaReceiveSensitivityRange for LLRP parameter PerAntennaReceiveSensitivityRa...
Definition: out_ltkcpp.h:7627
EResultCode setRFTransmitter(CRFTransmitter *pValue)
Set accessor functions for the LLRP RFTransmitter sub-parameter.
Class Definition CClientRequestOpSpecResult for LLRP parameter ClientRequestOpSpecResult.
Definition: out_ltkcpp.h:16099
llrp_u32_t getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID field.
Definition: out_ltkcpp.h:4060
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:12835
int countPerAntennaReceiveSensitivityRange(void)
Count of the LLRP PerAntennaReceiveSensitivityRange sub-parameter list.
Definition: out_ltkcpp.h:7393
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:5358
std::list< CParameter * >::iterator endAirProtocolOpSpec(void)
Returns the last element of the AirProtocolOpSpec sub-parameter list.
Definition: out_ltkcpp.h:12170
EResultCode setSpecIndex(CSpecIndex *pValue)
Set accessor functions for the LLRP SpecIndex sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:2035
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
Definition: out_ltkcpp.h:21655
EAccessSpecState getCurrentState(void)
Get accessor functions for the LLRP CurrentState field.
Definition: out_ltkcpp.h:11505
EResultCode setROSpecEvent(CROSpecEvent *pValue)
Set accessor functions for the LLRP ROSpecEvent sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:11609
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode setROSpecID(CROSpecID *pValue)
Set accessor functions for the LLRP ROSpecID sub-parameter.
CAISpecEvent * getAISpecEvent(void)
Get accessor functions for the LLRP AISpecEvent sub-parameter.
Definition: out_ltkcpp.h:17197
EStatusCode getErrorCode(void)
Get accessor functions for the LLRP ErrorCode field.
Definition: out_ltkcpp.h:19251
llrp_u32_t getPreemptingROSpecID(void)
Get accessor functions for the LLRP PreemptingROSpecID field.
Definition: out_ltkcpp.h:17692
CROSpecEvent * getROSpecEvent(void)
Get accessor functions for the LLRP ROSpecEvent sub-parameter.
Definition: out_ltkcpp.h:17112
llrp_u64_t getMicroseconds(void)
Get accessor functions for the LLRP Microseconds field.
Definition: out_ltkcpp.h:6811
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:23775
void setAccessSpecID(llrp_u32_t value)
Set accessor functions for the LLRP AccessSpecID field.
Definition: out_ltkcpp.h:4257
llrp_u1_t getHasUTCClockCapability(void)
Get accessor functions for the LLRP HasUTCClockCapability field.
Definition: out_ltkcpp.h:7236
int countTransmitPowerLevelTableEntry(void)
Count of the LLRP TransmitPowerLevelTableEntry sub-parameter list.
Definition: out_ltkcpp.h:8693
llrp_u1_t getGPIEvent(void)
Get accessor functions for the LLRP GPIEvent field.
Definition: out_ltkcpp.h:10025
void setErrorCode(EStatusCode value)
Set accessor functions for the LLRP ErrorCode field.
Definition: out_ltkcpp.h:19131
llrp_u16_t getChannelIndex(void)
Get accessor functions for the LLRP ChannelIndex field.
Definition: out_ltkcpp.h:15542
void clearReceiveSensitivityTableEntry(void)
Clears the LLRP ReceiveSensitivityTableEntry sub-parameter list.
Definition: out_ltkcpp.h:7348
llrp_s16_t getReceiveSensitivityValue(void)
Get accessor functions for the LLRP ReceiveSensitivityValue field.
Definition: out_ltkcpp.h:7573
void setDeviceManufacturerName(llrp_u32_t value)
Set accessor functions for the LLRP DeviceManufacturerName field.
Definition: out_ltkcpp.h:7269
Class Definition CC1G2TagInventoryStateAwareSingulationAction for LLRP parameter C1G2TagInventoryStat...
Definition: out_ltkcpp.h:21116
Class Definition CIdentification for LLRP parameter Identification.
Definition: out_ltkcpp.h:12366
void setKillPassword(llrp_u32_t value)
Set accessor functions for the LLRP KillPassword field.
Definition: out_ltkcpp.h:22065
std::list< CAntennaConfiguration * >::iterator beginAntennaConfiguration(void)
Returns the first element of the AntennaConfiguration sub-parameter list.
Definition: out_ltkcpp.h:5128
void setPIEValue(llrp_u32_t value)
Set accessor functions for the LLRP PIEValue field.
Definition: out_ltkcpp.h:19852
CRFReceiver * getRFReceiver(void)
Get accessor functions for the LLRP RFReceiver sub-parameter.
Definition: out_ltkcpp.h:12975
void setWordPointer(llrp_u16_t value)
Set accessor functions for the LLRP WordPointer field.
Definition: out_ltkcpp.h:21707
void setHopTableID(llrp_u8_t value)
Set accessor functions for the LLRP HopTableID field.
Definition: out_ltkcpp.h:9147
llrp_u16_t getWordPointer(void)
Get accessor functions for the LLRP WordPointer field.
Definition: out_ltkcpp.h:21907
Class Definition CEPC_96 for LLRP parameter EPC_96.
Definition: out_ltkcpp.h:14900
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:2436
int countGPIPortCurrentState(void)
Count of the LLRP GPIPortCurrentState sub-parameter list.
Definition: out_ltkcpp.h:5702
llrp_u32_t getVendorIdentifier(void)
Get accessor functions for the LLRP VendorIdentifier field.
Definition: out_ltkcpp.h:1857
llrp_u8_t getMessageSubtype(void)
Get accessor functions for the LLRP MessageSubtype field.
Definition: out_ltkcpp.h:1883
llrp_u32_t getMaxNumSpecsPerROSpec(void)
Get accessor functions for the LLRP MaxNumSpecsPerROSpec field.
Definition: out_ltkcpp.h:8315
std::list< CC1G2Filter * >::iterator beginC1G2Filter(void)
Returns the first element of the C1G2Filter sub-parameter list.
Definition: out_ltkcpp.h:20051
EResultCode setGPIOCapabilities(CGPIOCapabilities *pValue)
Set accessor functions for the LLRP GPIOCapabilities sub-parameter.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:6022
Class Definition CC1G2Write for LLRP parameter C1G2Write.
Definition: out_ltkcpp.h:21778
EResultCode setAirProtocolSingulationDetails(CParameter *pValue)
Set accessor functions for the LLRP AirProtocolSingulationDetails sub-parameter.
EResultCode setLLRPCapabilities(CLLRPCapabilities *pValue)
Set accessor functions for the LLRP LLRPCapabilities sub-parameter.
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
Definition: out_ltkcpp.h:22187
Class Definition CTagObservationTrigger for LLRP parameter TagObservationTrigger. ...
Definition: out_ltkcpp.h:10601
void setReadData(llrp_u16v_t value)
Set accessor functions for the LLRP ReadData field.
Definition: out_ltkcpp.h:23377
Class Definition CC1G2UHFRFModeTable for LLRP parameter C1G2UHFRFModeTable.
Definition: out_ltkcpp.h:19491
std::list< CTransmitPowerLevelTableEntry * >::iterator endTransmitPowerLevelTableEntry(void)
Returns the last element of the TransmitPowerLevelTableEntry sub-parameter list.
Definition: out_ltkcpp.h:8679
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
CRFTransmitter * getRFTransmitter(void)
Get accessor functions for the LLRP RFTransmitter sub-parameter.
Definition: out_ltkcpp.h:12992
CAccessSpec * getAccessSpec(void)
Get accessor functions for the LLRP AccessSpec sub-parameter.
Definition: out_ltkcpp.h:3683
EROSpecEventType getEventType(void)
Get accessor functions for the LLRP EventType field.
Definition: out_ltkcpp.h:17640
Class Definition CUptime for LLRP parameter Uptime.
Definition: out_ltkcpp.h:6862
EResultCode addTagReportData(CTagReportData *pValue)
Add a TagReportData to the LLRP sub-parameter list.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:3294
Class Definition CConnectionCloseEvent for LLRP parameter ConnectionCloseEvent.
Definition: out_ltkcpp.h:18820
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:3301
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:18497
std::list< CGPIPortCurrentState * >::iterator endGPIPortCurrentState(void)
Returns the last element of the GPIPortCurrentState sub-parameter list.
Definition: out_ltkcpp.h:5688
Class Definition CTransmitPowerLevelTableEntry for LLRP parameter TransmitPowerLevelTableEntry.
Definition: out_ltkcpp.h:8793
Class Definition CDISABLE_ACCESSSPEC_RESPONSE for LLRP message DISABLE_ACCESSSPEC_RESPONSE.
Definition: out_ltkcpp.h:4297
std::list< CAntennaConfiguration * >::iterator endAntennaConfiguration(void)
Returns the last element of the AntennaConfiguration sub-parameter list.
Definition: out_ltkcpp.h:5561
std::list< CReceiveSensitivityTableEntry * >::iterator endReceiveSensitivityTableEntry(void)
Returns the last element of the ReceiveSensitivityTableEntry sub-parameter list.
Definition: out_ltkcpp.h:7341
void setMicroseconds(llrp_u64_t value)
Set accessor functions for the LLRP Microseconds field.
Definition: out_ltkcpp.h:15962
std::list< CGPOWriteData * >::iterator endGPOWriteData(void)
Returns the last element of the GPOWriteData sub-parameter list.
Definition: out_ltkcpp.h:5296
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:2914
CROReportSpec * getROReportSpec(void)
Get accessor functions for the LLRP ROReportSpec sub-parameter.
Definition: out_ltkcpp.h:9494
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
void setDurationTrigger(llrp_u32_t value)
Set accessor functions for the LLRP DurationTrigger field.
Definition: out_ltkcpp.h:10522
void setPeakRSSI(llrp_s8_t value)
Set accessor functions for the LLRP PeakRSSI field.
Definition: out_ltkcpp.h:15451
Class Definition CFirstSeenTimestampUptime for LLRP parameter FirstSeenTimestampUptime.
Definition: out_ltkcpp.h:15702
EResultCode setClientRequestResponse(CClientRequestResponse *pValue)
Set accessor functions for the LLRP ClientRequestResponse sub-parameter.
int countAirProtocolOpSpec(void)
Count of the LLRP AirProtocolOpSpec sub-parameter list.
Definition: out_ltkcpp.h:12184
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
Definition: out_ltkcpp.h:22700
void setEnablePeakRSSI(llrp_u1_t value)
Set accessor functions for the LLRP EnablePeakRSSI field.
Definition: out_ltkcpp.h:13976
EResultCode setGPIEvent(CGPIEvent *pValue)
Set accessor functions for the LLRP GPIEvent sub-parameter.
CParameter * getTimestamp(void)
Get accessor functions for the LLRP Timestamp sub-parameter.
Definition: out_ltkcpp.h:16657
EResultCode setGPITriggerValue(CGPITriggerValue *pValue)
Set accessor functions for the LLRP GPITriggerValue sub-parameter.
Class Definition CSTART_ROSPEC_RESPONSE for LLRP message START_ROSPEC_RESPONSE.
Definition: out_ltkcpp.h:2771
Class Definition CFieldError for LLRP parameter FieldError.
Definition: out_ltkcpp.h:19047
Class Definition CC1G2SingulationControl for LLRP parameter C1G2SingulationControl.
Definition: out_ltkcpp.h:20947
llrp_u16_t getGPIPortNum(void)
Get accessor functions for the LLRP GPIPortNum field.
Definition: out_ltkcpp.h:4870
Class Definition CAccessCommand for LLRP parameter AccessCommand.
Definition: out_ltkcpp.h:11807
llrp_u16_t getParameterType(void)
Get accessor functions for the LLRP ParameterType field.
Definition: out_ltkcpp.h:19225
EC1G2TagInventoryStateAwareS getS(void)
Get accessor functions for the LLRP S field.
Definition: out_ltkcpp.h:21193
Class Definition CRFTransmitter for LLRP parameter RFTransmitter.
Definition: out_ltkcpp.h:13174
void clearC1G2LockPayload(void)
Clears the LLRP C1G2LockPayload sub-parameter list.
Definition: out_ltkcpp.h:22221
void setTari(llrp_u16_t value)
Set accessor functions for the LLRP Tari field.
Definition: out_ltkcpp.h:20853
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:16436
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:10962
int countTagReportData(void)
Count of the LLRP TagReportData sub-parameter list.
Definition: out_ltkcpp.h:6207
void clearPerAntennaReceiveSensitivityRange(void)
Clears the LLRP PerAntennaReceiveSensitivityRange sub-parameter list.
Definition: out_ltkcpp.h:7386
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:18216
void setMatch(llrp_u1_t value)
Set accessor functions for the LLRP Match field.
Definition: out_ltkcpp.h:21445
EResultCode addAccessCommandOpSpecResult(CParameter *pValue)
Add a AccessCommandOpSpecResult to the LLRP sub-parameter list.
EResultCode setInventoryParameterSpecID(CInventoryParameterSpecID *pValue)
Set accessor functions for the LLRP InventoryParameterSpecID sub-parameter.
llrp_u1_t getGPIEvent(void)
Get accessor functions for the LLRP GPIEvent field.
Definition: out_ltkcpp.h:17537
void setChannelIndex(llrp_u16_t value)
Set accessor functions for the LLRP ChannelIndex field.
Definition: out_ltkcpp.h:15549
Class Definition CC1G2BlockErase for LLRP parameter C1G2BlockErase.
Definition: out_ltkcpp.h:22409
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:17666
std::list< CAntennaProperties * >::iterator beginAntennaProperties(void)
Returns the first element of the AntennaProperties sub-parameter list.
Definition: out_ltkcpp.h:5516
void setDurationTriggerValue(llrp_u32_t value)
Set accessor functions for the LLRP DurationTriggerValue field.
Definition: out_ltkcpp.h:10184
Class Definition CENABLE_ROSPEC for LLRP message ENABLE_ROSPEC.
Definition: out_ltkcpp.h:3053
EResultCode addAirProtocolUHFRFModeTable(CParameter *pValue)
Add a AirProtocolUHFRFModeTable to the LLRP sub-parameter list.
void setIndex(llrp_u16_t value)
Set accessor functions for the LLRP Index field.
Definition: out_ltkcpp.h:8851
llrp_u16_t getTari(void)
Get accessor functions for the LLRP Tari field.
Definition: out_ltkcpp.h:20846
llrp_u32_t getLLRPConfigurationStateValue(void)
Get accessor functions for the LLRP LLRPConfigurationStateValue field.
Definition: out_ltkcpp.h:12313
Class Definition CENABLE_EVENTS_AND_REPORTS for LLRP message ENABLE_EVENTS_AND_REPORTS.
Definition: out_ltkcpp.h:6559
llrp_u16_t getMaxNumberOfAntennaSupported(void)
Get accessor functions for the LLRP MaxNumberOfAntennaSupported field.
Definition: out_ltkcpp.h:7184
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:21829
void setNumGPOs(llrp_u16_t value)
Set accessor functions for the LLRP NumGPOs field.
Definition: out_ltkcpp.h:7987
void clearFrequencyHopTable(void)
Clears the LLRP FrequencyHopTable sub-parameter list.
Definition: out_ltkcpp.h:9005
llrp_u1_t getCanSupportBlockWrite(void)
Get accessor functions for the LLRP CanSupportBlockWrite field.
Definition: out_ltkcpp.h:19418
EC1G2KillResultType getResult(void)
Get accessor functions for the LLRP Result field.
Definition: out_ltkcpp.h:23624
EResultCode setFrequencyInformation(CFrequencyInformation *pValue)
Set accessor functions for the LLRP FrequencyInformation sub-parameter.
void setOffset(llrp_u32_t value)
Set accessor functions for the LLRP Offset field.
Definition: out_ltkcpp.h:9850
CParameterError * getParameterError(void)
Get accessor functions for the LLRP ParameterError sub-parameter.
Definition: out_ltkcpp.h:19288
EResultCode addReceiveSensitivityTableEntry(CReceiveSensitivityTableEntry *pValue)
Add a ReceiveSensitivityTableEntry to the LLRP sub-parameter list.
Class Definition CCustom for LLRP parameter Custom.
Definition: out_ltkcpp.h:6973
void setEnableLastSeenTimestamp(llrp_u1_t value)
Set accessor functions for the LLRP EnableLastSeenTimestamp field.
Definition: out_ltkcpp.h:14028
CClientRequestResponse * getClientRequestResponse(void)
Get accessor functions for the LLRP ClientRequestResponse sub-parameter.
Definition: out_ltkcpp.h:4719
EAISpecEventType getEventType(void)
Get accessor functions for the LLRP EventType field.
Definition: out_ltkcpp.h:18471
llrp_u16_t getNumGPOs(void)
Get accessor functions for the LLRP NumGPOs field.
Definition: out_ltkcpp.h:7980
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
Definition: out_ltkcpp.h:21648
void setNextChannelIndex(llrp_u16_t value)
Set accessor functions for the LLRP NextChannelIndex field.
Definition: out_ltkcpp.h:17418
llrp_u1_t getMatch(void)
Get accessor functions for the LLRP Match field.
Definition: out_ltkcpp.h:21438
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:10948
llrp_u1_t getEnableAccessSpecID(void)
Get accessor functions for the LLRP EnableAccessSpecID field.
Definition: out_ltkcpp.h:14073
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:17265
ENotificationEventType getEventType(void)
Get accessor functions for the LLRP EventType field.
Definition: out_ltkcpp.h:16864
Class Definition CC1G2WriteOpSpecResult for LLRP parameter C1G2WriteOpSpecResult. ...
Definition: out_ltkcpp.h:23424
Class Definition CDISABLE_ROSPEC for LLRP message DISABLE_ROSPEC.
Definition: out_ltkcpp.h:3243
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:16429
CAccessReportSpec * getAccessReportSpec(void)
Get accessor functions for the LLRP AccessReportSpec sub-parameter.
Definition: out_ltkcpp.h:5609
EResultCode setOpSpecID(COpSpecID *pValue)
Set accessor functions for the LLRP OpSpecID sub-parameter.
llrp_u2_t getSession(void)
Get accessor functions for the LLRP Session field.
Definition: out_ltkcpp.h:20998
void setKeepaliveTriggerType(EKeepaliveTriggerType value)
Set accessor functions for the LLRP KeepaliveTriggerType field.
Definition: out_ltkcpp.h:12682
Class Definition CRegulatoryCapabilities for LLRP parameter RegulatoryCapabilities.
Definition: out_ltkcpp.h:8446
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:12033
EResultCode addFrequencyHopTable(CFrequencyHopTable *pValue)
Add a FrequencyHopTable to the LLRP sub-parameter list.
Class Definition CC1G2TagInventoryMask for LLRP parameter C1G2TagInventoryMask.
Definition: out_ltkcpp.h:20361
std::list< CParameter * >::iterator endAccessCommandOpSpecResult(void)
Returns the last element of the AccessCommandOpSpecResult sub-parameter list.
Definition: out_ltkcpp.h:14706
void setTagData(llrp_u1v_t value)
Set accessor functions for the LLRP TagData field.
Definition: out_ltkcpp.h:21523
llrp_u16_t getSpecIndex(void)
Get accessor functions for the LLRP SpecIndex field.
Definition: out_ltkcpp.h:15147
std::list< CAntennaProperties * >::iterator beginAntennaProperties(void)
Returns the first element of the AntennaProperties sub-parameter list.
Definition: out_ltkcpp.h:5090
void setROReportTrigger(EROReportTriggerType value)
Set accessor functions for the LLRP ROReportTrigger field.
Definition: out_ltkcpp.h:13656
void setProtocolID(EAirProtocols value)
Set accessor functions for the LLRP ProtocolID field.
Definition: out_ltkcpp.h:11486
Class Definition CC1G2TagInventoryStateAwareFilterAction for LLRP parameter C1G2TagInventoryStateAwar...
Definition: out_ltkcpp.h:20531
CAccessSpecID * getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID sub-parameter.
Definition: out_ltkcpp.h:14682
EResultCode setFixedFrequencyTable(CFixedFrequencyTable *pValue)
Set accessor functions for the LLRP FixedFrequencyTable sub-parameter.
EResultCode addAirProtocolEPCMemorySelector(CParameter *pValue)
Add a AirProtocolEPCMemorySelector to the LLRP sub-parameter list.
CGPITriggerValue * getGPITriggerValue(void)
Get accessor functions for the LLRP GPITriggerValue sub-parameter.
Definition: out_ltkcpp.h:10197
std::list< CRFSurveyReportData * >::iterator endRFSurveyReportData(void)
Returns the last element of the RFSurveyReportData sub-parameter list.
Definition: out_ltkcpp.h:6231
void setMessage(llrp_utf8v_t value)
Set accessor functions for the LLRP Message field.
Definition: out_ltkcpp.h:17985
CParameter * getEPCParameter(void)
Get accessor functions for the LLRP EPCParameter sub-parameter.
Definition: out_ltkcpp.h:14440
EResultCode setUTCTimestamp(CUTCTimestamp *pValue)
Set accessor functions for the LLRP UTCTimestamp sub-parameter.
void setMicroseconds(llrp_u64_t value)
Set accessor functions for the LLRP Microseconds field.
Definition: out_ltkcpp.h:15861
llrp_u16_t getCountryCode(void)
Get accessor functions for the LLRP CountryCode field.
Definition: out_ltkcpp.h:8497
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
Definition: out_ltkcpp.h:22486
EResultCode addC1G2UHFRFModeTableEntry(CC1G2UHFRFModeTableEntry *pValue)
Add a C1G2UHFRFModeTableEntry to the LLRP sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:8560
void setMicroseconds(llrp_u64_t value)
Set accessor functions for the LLRP Microseconds field.
Definition: out_ltkcpp.h:15655
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:17286
EResultCode addRFSurveyReportData(CRFSurveyReportData *pValue)
Add a RFSurveyReportData to the LLRP sub-parameter list.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:4152
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:18342
void setGPOData(llrp_u1_t value)
Set accessor functions for the LLRP GPOData field.
Definition: out_ltkcpp.h:12583
Class Definition CAntennaEvent for LLRP parameter AntennaEvent.
Definition: out_ltkcpp.h:18588
void setIDType(EIdentificationType value)
Set accessor functions for the LLRP IDType field.
Definition: out_ltkcpp.h:12424
Class Definition CKEEPALIVE_ACK for LLRP message KEEPALIVE_ACK.
Definition: out_ltkcpp.h:6399
void setCanSetAntennaProperties(llrp_u1_t value)
Set accessor functions for the LLRP CanSetAntennaProperties field.
Definition: out_ltkcpp.h:7217
void setParameterSubtype(llrp_u32_t value)
Set accessor functions for the LLRP ParameterSubtype field.
Definition: out_ltkcpp.h:7057
void setReceiverSensitivity(llrp_u16_t value)
Set accessor functions for the LLRP ReceiverSensitivity field.
Definition: out_ltkcpp.h:13132
void setTimeout(llrp_u32_t value)
Set accessor functions for the LLRP Timeout field.
Definition: out_ltkcpp.h:10058
void setNumGPIs(llrp_u16_t value)
Set accessor functions for the LLRP NumGPIs field.
Definition: out_ltkcpp.h:7961
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
Definition: out_ltkcpp.h:22519
void setCountryCode(llrp_u16_t value)
Set accessor functions for the LLRP CountryCode field.
Definition: out_ltkcpp.h:8504
Class Definition CC1G2BlockWrite for LLRP parameter C1G2BlockWrite.
Definition: out_ltkcpp.h:22623
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
Definition: out_ltkcpp.h:22512
void clearAntennaConfiguration(void)
Clears the LLRP AntennaConfiguration sub-parameter list.
Definition: out_ltkcpp.h:10917
Class Definition CCLIENT_REQUEST_OP_RESPONSE for LLRP message CLIENT_REQUEST_OP_RESPONSE.
Definition: out_ltkcpp.h:4674
EResultCode setReaderEventNotificationData(CReaderEventNotificationData *pValue)
Set accessor functions for the LLRP ReaderEventNotificationData sub-parameter.
CSpecIndex * getSpecIndex(void)
Get accessor functions for the LLRP SpecIndex sub-parameter.
Definition: out_ltkcpp.h:16360
std::list< CFrequencyRSSILevelEntry * >::iterator beginFrequencyRSSILevelEntry(void)
Returns the first element of the FrequencyRSSILevelEntry sub-parameter list.
Definition: out_ltkcpp.h:16377
Class Definition CENABLE_ACCESSSPEC for LLRP message ENABLE_ACCESSSPEC.
Definition: out_ltkcpp.h:4009
std::list< CC1G2TargetTag * >::iterator beginC1G2TargetTag(void)
Returns the first element of the C1G2TargetTag sub-parameter list.
Definition: out_ltkcpp.h:21291
llrp_u16_t getSpecIndex(void)
Get accessor functions for the LLRP SpecIndex field.
Definition: out_ltkcpp.h:18523
CC1G2TagInventoryStateAwareSingulationAction * getC1G2TagInventoryStateAwareSingulationAction(void)
Get accessor functions for the LLRP C1G2TagInventoryStateAwareSingulationAction sub-parameter.
Definition: out_ltkcpp.h:21070
Class Definition CSTOP_ROSPEC_RESPONSE for LLRP message STOP_ROSPEC_RESPONSE.
Definition: out_ltkcpp.h:2961
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setAISpecStopTriggerType(EAISpecStopTriggerType value)
Set accessor functions for the LLRP AISpecStopTriggerType field.
Definition: out_ltkcpp.h:10496
llrp_u32_t getDurationTrigger(void)
Get accessor functions for the LLRP DurationTrigger field.
Definition: out_ltkcpp.h:10515
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:2143
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:11150
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
Definition: out_ltkcpp.h:21881
void setAction(EC1G2StateUnawareAction value)
Set accessor functions for the LLRP Action field.
Definition: out_ltkcpp.h:20725
ETagObservationTriggerType getTriggerType(void)
Get accessor functions for the LLRP TriggerType field.
Definition: out_ltkcpp.h:10652
void setPointer(llrp_u16_t value)
Set accessor functions for the LLRP Pointer field.
Definition: out_ltkcpp.h:20445
llrp_u1_t getEnableFirstSeenTimestamp(void)
Get accessor functions for the LLRP EnableFirstSeenTimestamp field.
Definition: out_ltkcpp.h:13995
void clearAccessCommandOpSpecResult(void)
Clears the LLRP AccessCommandOpSpecResult sub-parameter list.
Definition: out_ltkcpp.h:14713
llrp_u64_t getMicroseconds(void)
Get accessor functions for the LLRP Microseconds field.
Definition: out_ltkcpp.h:15648
void setMaxNumberOfAntennaSupported(llrp_u16_t value)
Set accessor functions for the LLRP MaxNumberOfAntennaSupported field.
Definition: out_ltkcpp.h:7191
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:17272
int countEventNotificationState(void)
Count of the LLRP EventNotificationState sub-parameter list.
Definition: out_ltkcpp.h:16767
void setIndex(llrp_u16_t value)
Set accessor functions for the LLRP Index field.
Definition: out_ltkcpp.h:7554
llrp_u96_t getEPC(void)
Get accessor functions for the LLRP EPC field.
Definition: out_ltkcpp.h:14951
llrp_u1_t getAntennaConnected(void)
Get accessor functions for the LLRP AntennaConnected field.
Definition: out_ltkcpp.h:12802
llrp_u16_t getNumCollisionSlots(void)
Get accessor functions for the LLRP NumCollisionSlots field.
Definition: out_ltkcpp.h:23192
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:5351
void setAccessReportTrigger(EAccessReportTriggerType value)
Set accessor functions for the LLRP AccessReportTrigger field.
Definition: out_ltkcpp.h:14216
void setCanReportBufferFillWarning(llrp_u1_t value)
Set accessor functions for the LLRP CanReportBufferFillWarning field.
Definition: out_ltkcpp.h:8140
EGetReaderConfigRequestedData getRequestedData(void)
Get accessor functions for the LLRP RequestedData field.
Definition: out_ltkcpp.h:4844
EResultCode setGeneralDeviceCapabilities(CGeneralDeviceCapabilities *pValue)
Set accessor functions for the LLRP GeneralDeviceCapabilities sub-parameter.
EResultCode addAntennaProperties(CAntennaProperties *pValue)
Add a AntennaProperties to the LLRP sub-parameter list.
void enrollCoreTypesIntoRegistry(CTypeRegistry *pTypeRegistry)
Enrolls the types for Core into the LTKCPP registry.
Class Definition CReceiveSensitivityTableEntry for LLRP parameter ReceiveSensitivityTableEntry.
Definition: out_ltkcpp.h:7496
void setWordCount(llrp_u16_t value)
Set accessor functions for the LLRP WordCount field.
Definition: out_ltkcpp.h:21733
void setN(llrp_u32_t value)
Set accessor functions for the LLRP N field.
Definition: out_ltkcpp.h:11327
Class Definition CGeneralDeviceCapabilities for LLRP parameter GeneralDeviceCapabilities.
Definition: out_ltkcpp.h:7133
llrp_u32_t getDurationTriggerValue(void)
Get accessor functions for the LLRP DurationTriggerValue field.
Definition: out_ltkcpp.h:10177
void setFrequency(llrp_u32v_t value)
Set accessor functions for the LLRP Frequency field.
Definition: out_ltkcpp.h:9271
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:12026
CPeriodicTriggerValue * getPeriodicTriggerValue(void)
Get accessor functions for the LLRP PeriodicTriggerValue sub-parameter.
Definition: out_ltkcpp.h:9718
void clearPerAntennaAirProtocol(void)
Clears the LLRP PerAntennaAirProtocol sub-parameter list.
Definition: out_ltkcpp.h:7441
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:2731
llrp_u16_t getChannelIndex(void)
Get accessor functions for the LLRP ChannelIndex field.
Definition: out_ltkcpp.h:13251
llrp_u16_t getGPIPortNumber(void)
Get accessor functions for the LLRP GPIPortNumber field.
Definition: out_ltkcpp.h:17511
EResultCode
Error result codes for LTK operations.
Definition: ltkcpp_base.h:583
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
Definition: out_ltkcpp.h:22707
void setResult(EC1G2BlockEraseResultType value)
Set accessor functions for the LLRP Result field.
Definition: out_ltkcpp.h:23888
llrp_u1_t getCanSetAntennaProperties(void)
Get accessor functions for the LLRP CanSetAntennaProperties field.
Definition: out_ltkcpp.h:7210
llrp_u16_t getWordCount(void)
Get accessor functions for the LLRP WordCount field.
Definition: out_ltkcpp.h:22564
llrp_utf8v_t getReaderFirmwareVersion(void)
Get accessor functions for the LLRP ReaderFirmwareVersion field.
Definition: out_ltkcpp.h:7314
EResultCode setChannelIndex(CChannelIndex *pValue)
Set accessor functions for the LLRP ChannelIndex sub-parameter.
EResultCode setGPITriggerValue(CGPITriggerValue *pValue)
Set accessor functions for the LLRP GPITriggerValue sub-parameter.
Class Definition CC1G2UHFRFModeTableEntry for LLRP parameter C1G2UHFRFModeTableEntry.
Definition: out_ltkcpp.h:19612
void setS(EC1G2TagInventoryStateAwareS value)
Set accessor functions for the LLRP S field.
Definition: out_ltkcpp.h:21200
void setData(llrp_bytesToEnd_t value)
Set accessor functions for the LLRP Data field.
Definition: out_ltkcpp.h:7083
llrp_u32_t getBDRValue(void)
Get accessor functions for the LLRP BDRValue field.
Definition: out_ltkcpp.h:19819
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u1v_t getTagMask(void)
Get accessor functions for the LLRP TagMask field.
Definition: out_ltkcpp.h:20464
CLLRPConfigurationStateValue * getLLRPConfigurationStateValue(void)
Get accessor functions for the LLRP LLRPConfigurationStateValue sub-parameter.
Definition: out_ltkcpp.h:5217
std::list< CEventNotificationState * >::iterator beginEventNotificationState(void)
Returns the first element of the EventNotificationState sub-parameter list.
Definition: out_ltkcpp.h:16746
int countC1G2LockPayload(void)
Count of the LLRP C1G2LockPayload sub-parameter list.
Definition: out_ltkcpp.h:22228
EResultCode setEventsAndReports(CEventsAndReports *pValue)
Set accessor functions for the LLRP EventsAndReports sub-parameter.
void setCurrentState(EAccessSpecState value)
Set accessor functions for the LLRP CurrentState field.
Definition: out_ltkcpp.h:11512
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:23914
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:10370
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:2235
llrp_u16_t getOperationCountValue(void)
Get accessor functions for the LLRP OperationCountValue field.
Definition: out_ltkcpp.h:11748
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:20144
Class Definition CGET_ROSPECS for LLRP message GET_ROSPECS.
Definition: out_ltkcpp.h:3429
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
Definition: out_ltkcpp.h:21412
void setWordPointer(llrp_u16_t value)
Set accessor functions for the LLRP WordPointer field.
Definition: out_ltkcpp.h:21914
void setModeIndex(llrp_u16_t value)
Set accessor functions for the LLRP ModeIndex field.
Definition: out_ltkcpp.h:20827
Class Definition CROReportSpec for LLRP parameter ROReportSpec.
Definition: out_ltkcpp.h:13598
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:3962
void setReportBufferPercentageFull(llrp_u8_t value)
Set accessor functions for the LLRP ReportBufferPercentageFull field.
Definition: out_ltkcpp.h:17804
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
CLastSeenTimestampUptime * getLastSeenTimestampUptime(void)
Get accessor functions for the LLRP LastSeenTimestampUptime sub-parameter.
Definition: out_ltkcpp.h:14610
CConnectionCloseEvent * getConnectionCloseEvent(void)
Get accessor functions for the LLRP ConnectionCloseEvent sub-parameter.
Definition: out_ltkcpp.h:17248
EStatusCode getStatusCode(void)
Get accessor functions for the LLRP StatusCode field.
Definition: out_ltkcpp.h:18939
EResultCode setRFReceiver(CRFReceiver *pValue)
Set accessor functions for the LLRP RFReceiver sub-parameter.
std::list< CRFSurveyReportData * >::iterator beginRFSurveyReportData(void)
Returns the first element of the RFSurveyReportData sub-parameter list.
Definition: out_ltkcpp.h:6224
void setDurationPeriod(llrp_u32_t value)
Set accessor functions for the LLRP DurationPeriod field.
Definition: out_ltkcpp.h:11301
Class Definition CUTCTimestamp for LLRP parameter UTCTimestamp.
Definition: out_ltkcpp.h:6760
llrp_u16_t getPointer(void)
Get accessor functions for the LLRP Pointer field.
Definition: out_ltkcpp.h:21464
EResultCode addEventNotificationState(CEventNotificationState *pValue)
Add a EventNotificationState to the LLRP sub-parameter list.
Class Definition CChannelIndex for LLRP parameter ChannelIndex.
Definition: out_ltkcpp.h:15491
void setRequestedData(EGetReaderCapabilitiesRequestedData value)
Set accessor functions for the LLRP RequestedData field.
Definition: out_ltkcpp.h:2015
Class Definition CC1G2TagInventoryStateUnawareFilterAction for LLRP parameter C1G2TagInventoryStateUn...
Definition: out_ltkcpp.h:20667
Class Definition CGET_READER_CONFIG for LLRP message GET_READER_CONFIG.
Definition: out_ltkcpp.h:4767
llrp_u8v_t getReaderID(void)
Get accessor functions for the LLRP ReaderID field.
Definition: out_ltkcpp.h:12443
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:22161
void setPointer(llrp_u16_t value)
Set accessor functions for the LLRP Pointer field.
Definition: out_ltkcpp.h:21471
EResultCode setAccessReportSpec(CAccessReportSpec *pValue)
Set accessor functions for the LLRP AccessReportSpec sub-parameter.
Class Definition CAccessSpecStopTrigger for LLRP parameter AccessSpecStopTrigger. ...
Definition: out_ltkcpp.h:11671
void clearROSpec(void)
Clears the LLRP ROSpec sub-parameter list.
Definition: out_ltkcpp.h:3578
void setEventType(EROSpecEventType value)
Set accessor functions for the LLRP EventType field.
Definition: out_ltkcpp.h:17647
CFieldError * getFieldError(void)
Get accessor functions for the LLRP FieldError sub-parameter.
Definition: out_ltkcpp.h:19271
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode setLastSeenTimestampUptime(CLastSeenTimestampUptime *pValue)
Set accessor functions for the LLRP LastSeenTimestampUptime sub-parameter.
void setPeakRSSI(llrp_s8_t value)
Set accessor functions for the LLRP PeakRSSI field.
Definition: out_ltkcpp.h:16644
void setStepTariValue(llrp_u32_t value)
Set accessor functions for the LLRP StepTariValue field.
Definition: out_ltkcpp.h:19930
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:23351
CGeneralDeviceCapabilities * getGeneralDeviceCapabilities(void)
Get accessor functions for the LLRP GeneralDeviceCapabilities sub-parameter.
Definition: out_ltkcpp.h:2160
EResultCode setC1G2RFControl(CC1G2RFControl *pValue)
Set accessor functions for the LLRP C1G2RFControl sub-parameter.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:23782
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u1_t getHoldEventsAndReportsUponReconnect(void)
Get accessor functions for the LLRP HoldEventsAndReportsUponReconnect field.
Definition: out_ltkcpp.h:13539
Class Definition CROSpecStartTrigger for LLRP parameter ROSpecStartTrigger.
Definition: out_ltkcpp.h:9647
EC1G2TruncateAction getT(void)
Get accessor functions for the LLRP T field.
Definition: out_ltkcpp.h:20267
CAccessCommand * getAccessCommand(void)
Get accessor functions for the LLRP AccessCommand sub-parameter.
Definition: out_ltkcpp.h:11568
Class Definition CFrequencyInformation for LLRP parameter FrequencyInformation.
Definition: out_ltkcpp.h:8920
llrp_s16_t getTransmitPowerValue(void)
Get accessor functions for the LLRP TransmitPowerValue field.
Definition: out_ltkcpp.h:8870
EResultCode setRFSurveyEvent(CRFSurveyEvent *pValue)
Set accessor functions for the LLRP RFSurveyEvent sub-parameter.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:2541
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:18223
llrp_u16_t getGPIPortNum(void)
Get accessor functions for the LLRP GPIPortNum field.
Definition: out_ltkcpp.h:9999
std::list< CGPIPortCurrentState * >::iterator endGPIPortCurrentState(void)
Returns the last element of the GPIPortCurrentState sub-parameter list.
Definition: out_ltkcpp.h:5258
CGPITriggerValue * getGPITriggerValue(void)
Get accessor functions for the LLRP GPITriggerValue sub-parameter.
Definition: out_ltkcpp.h:10535
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:11623
EAntennaEventType getEventType(void)
Get accessor functions for the LLRP EventType field.
Definition: out_ltkcpp.h:18639
void setOperationCountValue(llrp_u16_t value)
Set accessor functions for the LLRP OperationCountValue field.
Definition: out_ltkcpp.h:11755
std::list< CReceiveSensitivityTableEntry * >::iterator beginReceiveSensitivityTableEntry(void)
Returns the first element of the ReceiveSensitivityTableEntry sub-parameter list. ...
Definition: out_ltkcpp.h:7334
EResultCode addGPOWriteData(CGPOWriteData *pValue)
Add a GPOWriteData to the LLRP sub-parameter list.
CAntennaEvent * getAntennaEvent(void)
Get accessor functions for the LLRP AntennaEvent sub-parameter.
Definition: out_ltkcpp.h:17214
llrp_u32_t getN(void)
Get accessor functions for the LLRP N field.
Definition: out_ltkcpp.h:11320
Class Definition CInventoryParameterSpecID for LLRP parameter InventoryParameterSpecID.
Definition: out_ltkcpp.h:15194
llrp_bytesToEnd_t getData(void)
Get accessor functions for the LLRP Data field.
Definition: out_ltkcpp.h:1909
Class Definition CPerAntennaAirProtocol for LLRP parameter PerAntennaAirProtocol. ...
Definition: out_ltkcpp.h:7778
void clearGPIPortCurrentState(void)
Clears the LLRP GPIPortCurrentState sub-parameter list.
Definition: out_ltkcpp.h:5695
llrp_u32_t getDeviceManufacturerName(void)
Get accessor functions for the LLRP DeviceManufacturerName field.
Definition: out_ltkcpp.h:7262
CSpecIndex * getSpecIndex(void)
Get accessor functions for the LLRP SpecIndex sub-parameter.
Definition: out_ltkcpp.h:18015
Class Definition CReportBufferLevelWarningEvent for LLRP parameter ReportBufferLevelWarningEvent.
Definition: out_ltkcpp.h:17746
EResultCode addGPIPortCurrentState(CGPIPortCurrentState *pValue)
Add a GPIPortCurrentState to the LLRP sub-parameter list.
llrp_u32_t getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID field.
Definition: out_ltkcpp.h:4250
Class Definition CKeepaliveSpec for LLRP parameter KeepaliveSpec.
Definition: out_ltkcpp.h:12624
int countC1G2TargetTag(void)
Count of the LLRP C1G2TargetTag sub-parameter list.
Definition: out_ltkcpp.h:21312
Class Definition CAntennaProperties for LLRP parameter AntennaProperties.
Definition: out_ltkcpp.h:12751
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:18121
llrp_u1_t getEnableTagSeenCount(void)
Get accessor functions for the LLRP EnableTagSeenCount field.
Definition: out_ltkcpp.h:14047
llrp_u32_t getBandwidth(void)
Get accessor functions for the LLRP Bandwidth field.
Definition: out_ltkcpp.h:16585
EResultCode setConnectionAttemptEvent(CConnectionAttemptEvent *pValue)
Set accessor functions for the LLRP ConnectionAttemptEvent sub-parameter.
std::list< CParameter * >::iterator beginAirProtocolTagData(void)
Returns the first element of the AirProtocolTagData sub-parameter list.
Definition: out_ltkcpp.h:14644
std::list< CAntennaConfiguration * >::iterator endAntennaConfiguration(void)
Returns the last element of the AntennaConfiguration sub-parameter list.
Definition: out_ltkcpp.h:5135
void setMaxNumROSpecs(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumROSpecs field.
Definition: out_ltkcpp.h:8296
void clearAccessSpec(void)
Clears the LLRP AccessSpec sub-parameter list.
Definition: out_ltkcpp.h:4534
llrp_u32_t getMaxTariValue(void)
Get accessor functions for the LLRP MaxTariValue field.
Definition: out_ltkcpp.h:19897
EResultCode setROBoundarySpec(CROBoundarySpec *pValue)
Set accessor functions for the LLRP ROBoundarySpec sub-parameter.
CReportBufferLevelWarningEvent * getReportBufferLevelWarningEvent(void)
Get accessor functions for the LLRP ReportBufferLevelWarningEvent sub-parameter.
Definition: out_ltkcpp.h:17129
Class Definition CRO_ACCESS_REPORT for LLRP message RO_ACCESS_REPORT.
Definition: out_ltkcpp.h:6141
Class Definition CC1G2ReadOpSpecResult for LLRP parameter C1G2ReadOpSpecResult.
Definition: out_ltkcpp.h:23267
llrp_u8_t getHopTableID(void)
Get accessor functions for the LLRP HopTableID field.
Definition: out_ltkcpp.h:9140
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:11171
llrp_u32_t getFrequency(void)
Get accessor functions for the LLRP Frequency field.
Definition: out_ltkcpp.h:16559
void setWriteData(llrp_u16v_t value)
Set accessor functions for the LLRP WriteData field.
Definition: out_ltkcpp.h:22785
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:16150
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:4937
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:2028
void setResult(EC1G2BlockWriteResultType value)
Set accessor functions for the LLRP Result field.
Definition: out_ltkcpp.h:24021
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:2242
llrp_u32_t getStepTariValue(void)
Get accessor functions for the LLRP StepTariValue field.
Definition: out_ltkcpp.h:19923
llrp_u16v_t getWriteData(void)
Get accessor functions for the LLRP WriteData field.
Definition: out_ltkcpp.h:22778
Class Definition CC1G2LockPayload for LLRP parameter C1G2LockPayload.
Definition: out_ltkcpp.h:22273
void setSupportsClientRequestOpSpec(llrp_u1_t value)
Set accessor functions for the LLRP SupportsClientRequestOpSpec field.
Definition: out_ltkcpp.h:8166
Class Definition CGPITriggerValue for LLRP parameter GPITriggerValue.
Definition: out_ltkcpp.h:9948
void setEnableAccessSpecID(llrp_u1_t value)
Set accessor functions for the LLRP EnableAccessSpecID field.
Definition: out_ltkcpp.h:14080
std::list< CC1G2UHFRFModeTableEntry * >::iterator beginC1G2UHFRFModeTableEntry(void)
Returns the first element of the C1G2UHFRFModeTableEntry sub-parameter list.
Definition: out_ltkcpp.h:19536
EC1G2DRValue getDRValue(void)
Get accessor functions for the LLRP DRValue field.
Definition: out_ltkcpp.h:19689
CTagReportContentSelector * getTagReportContentSelector(void)
Get accessor functions for the LLRP TagReportContentSelector sub-parameter.
Definition: out_ltkcpp.h:13695
Class Definition CTagSeenCount for LLRP parameter TagSeenCount.
Definition: out_ltkcpp.h:16004
Class Definition CAISpec for LLRP parameter AISpec.
Definition: out_ltkcpp.h:10244
void setSpecIndex(llrp_u16_t value)
Set accessor functions for the LLRP SpecIndex field.
Definition: out_ltkcpp.h:18375
void setHopTableID(llrp_u16_t value)
Set accessor functions for the LLRP HopTableID field.
Definition: out_ltkcpp.h:13232
EResultCode setAISpecEvent(CAISpecEvent *pValue)
Set accessor functions for the LLRP AISpecEvent sub-parameter.
EResultCode setRegulatoryCapabilities(CRegulatoryCapabilities *pValue)
Set accessor functions for the LLRP RegulatoryCapabilities sub-parameter.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:18504
CGPITriggerValue * getGPITriggerValue(void)
Get accessor functions for the LLRP GPITriggerValue sub-parameter.
Definition: out_ltkcpp.h:9735
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:2534
CParameter * getAirProtocolSingulationDetails(void)
Get accessor functions for the LLRP AirProtocolSingulationDetails sub-parameter.
Definition: out_ltkcpp.h:18543
void setReceiveSensitivityIndexMax(llrp_u16_t value)
Set accessor functions for the LLRP ReceiveSensitivityIndexMax field.
Definition: out_ltkcpp.h:7737
Class Definition CROSpec for LLRP parameter ROSpec.
Definition: out_ltkcpp.h:9316
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:14744
Class Definition CC1G2SingulationDetails for LLRP parameter C1G2SingulationDetails.
Definition: out_ltkcpp.h:23141
int countC1G2Filter(void)
Count of the LLRP C1G2Filter sub-parameter list.
Definition: out_ltkcpp.h:20072
std::list< CFrequencyRSSILevelEntry * >::iterator endFrequencyRSSILevelEntry(void)
Returns the last element of the FrequencyRSSILevelEntry sub-parameter list.
Definition: out_ltkcpp.h:16384
EAccessSpecStopTriggerType getAccessSpecStopTrigger(void)
Get accessor functions for the LLRP AccessSpecStopTrigger field.
Definition: out_ltkcpp.h:11722
EResultCode setUHFBandCapabilities(CUHFBandCapabilities *pValue)
Set accessor functions for the LLRP UHFBandCapabilities sub-parameter.
void setChannelIndex(llrp_u16_t value)
Set accessor functions for the LLRP ChannelIndex field.
Definition: out_ltkcpp.h:13258
EC1G2TagInventoryStateAwareI getI(void)
Get accessor functions for the LLRP I field.
Definition: out_ltkcpp.h:21167
CUHFBandCapabilities * getUHFBandCapabilities(void)
Get accessor functions for the LLRP UHFBandCapabilities sub-parameter.
Definition: out_ltkcpp.h:8543
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:3111
void setPC_Bits(llrp_u16_t value)
Set accessor functions for the LLRP PC_Bits field.
Definition: out_ltkcpp.h:23009
Class Definition CC1G2RFControl for LLRP parameter C1G2RFControl.
Definition: out_ltkcpp.h:20769
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:12828
void setTimeout(llrp_u32_t value)
Set accessor functions for the LLRP Timeout field.
Definition: out_ltkcpp.h:10763
int countAirProtocolTagData(void)
Count of the LLRP AirProtocolTagData sub-parameter list.
Definition: out_ltkcpp.h:14665
llrp_u8_t getMaxNumPriorityLevelsSupported(void)
Get accessor functions for the LLRP MaxNumPriorityLevelsSupported field.
Definition: out_ltkcpp.h:8237
llrp_u32_t getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID field.
Definition: out_ltkcpp.h:3870
Class Definition CInventoryParameterSpec for LLRP parameter InventoryParameterSpec.
Definition: out_ltkcpp.h:10806
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
llrp_u32_t getMaxNumROSpecs(void)
Get accessor functions for the LLRP MaxNumROSpecs field.
Definition: out_ltkcpp.h:8289
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
llrp_u16v_t getAntennaIDs(void)
Get accessor functions for the LLRP AntennaIDs field.
Definition: out_ltkcpp.h:10295
EResultCode addROSpec(CROSpec *pValue)
Add a ROSpec to the LLRP sub-parameter list.
CFixedFrequencyTable * getFixedFrequencyTable(void)
Get accessor functions for the LLRP FixedFrequencyTable sub-parameter.
Definition: out_ltkcpp.h:9029
EROSpecStartTriggerType getROSpecStartTriggerType(void)
Get accessor functions for the LLRP ROSpecStartTriggerType field.
Definition: out_ltkcpp.h:9698
void setTriggerType(ETagObservationTriggerType value)
Set accessor functions for the LLRP TriggerType field.
Definition: out_ltkcpp.h:10659
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:17279
void clearEventNotificationState(void)
Clears the LLRP EventNotificationState sub-parameter list.
Definition: out_ltkcpp.h:16760
EResultCode setC1G2TagInventoryStateUnawareFilterAction(CC1G2TagInventoryStateUnawareFilterAction *pValue)
Set accessor functions for the LLRP C1G2TagInventoryStateUnawareFilterAction sub-parameter.
void setReaderID(llrp_u8v_t value)
Set accessor functions for the LLRP ReaderID field.
Definition: out_ltkcpp.h:12450
Class Definition CSET_READER_CONFIG_RESPONSE for LLRP message SET_READER_CONFIG_RESPONSE.
Definition: out_ltkcpp.h:5801
void setEnableTagSeenCount(llrp_u1_t value)
Set accessor functions for the LLRP EnableTagSeenCount field.
Definition: out_ltkcpp.h:14054
EResultCode addGPOWriteData(CGPOWriteData *pValue)
Add a GPOWriteData to the LLRP sub-parameter list.
std::list< CInventoryParameterSpec * >::iterator endInventoryParameterSpec(void)
Returns the last element of the InventoryParameterSpec sub-parameter list.
Definition: out_ltkcpp.h:10339
int countReceiveSensitivityTableEntry(void)
Count of the LLRP ReceiveSensitivityTableEntry sub-parameter list.
Definition: out_ltkcpp.h:7355
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:3006
CC1G2RFControl * getC1G2RFControl(void)
Get accessor functions for the LLRP C1G2RFControl sub-parameter.
Definition: out_ltkcpp.h:20089
EC1G2LockDataField getDataField(void)
Get accessor functions for the LLRP DataField field.
Definition: out_ltkcpp.h:22350
EResultCode setAccessSpec(CAccessSpec *pValue)
Set accessor functions for the LLRP AccessSpec sub-parameter.
CReaderExceptionEvent * getReaderExceptionEvent(void)
Get accessor functions for the LLRP ReaderExceptionEvent sub-parameter.
Definition: out_ltkcpp.h:17163
void setStopTriggerType(ERFSurveySpecStopTriggerType value)
Set accessor functions for the LLRP StopTriggerType field.
Definition: out_ltkcpp.h:11275
llrp_u16_t getGPIPortNum(void)
Get accessor functions for the LLRP GPIPortNum field.
Definition: out_ltkcpp.h:13388
void setMaxNumInventoryParameterSpecsPerAISpec(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumInventoryParameterSpecsPerAISpec field. ...
Definition: out_ltkcpp.h:8348
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:11928
void setT(llrp_u16_t value)
Set accessor functions for the LLRP T field.
Definition: out_ltkcpp.h:10737
EResultCode setFirstSeenTimestampUTC(CFirstSeenTimestampUTC *pValue)
Set accessor functions for the LLRP FirstSeenTimestampUTC sub-parameter.
Class Definition CDISABLE_ROSPEC_RESPONSE for LLRP message DISABLE_ROSPEC_RESPONSE.
Definition: out_ltkcpp.h:3341
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:4916
ERFSurveyEventType getEventType(void)
Get accessor functions for the LLRP EventType field.
Definition: out_ltkcpp.h:18316
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:23508
void setResult(EC1G2WriteResultType value)
Set accessor functions for the LLRP Result field.
Definition: out_ltkcpp.h:23482
std::list< CC1G2TargetTag * >::iterator endC1G2TargetTag(void)
Returns the last element of the C1G2TargetTag sub-parameter list.
Definition: out_ltkcpp.h:21298
EAirProtocols getProtocolID(void)
Get accessor functions for the LLRP ProtocolID field.
Definition: out_ltkcpp.h:10883
CROSpecID * getROSpecID(void)
Get accessor functions for the LLRP ROSpecID sub-parameter.
Definition: out_ltkcpp.h:14457
int countAntennaConfiguration(void)
Count of the LLRP AntennaConfiguration sub-parameter list.
Definition: out_ltkcpp.h:5575
EResultCode setGPITriggerValue(CGPITriggerValue *pValue)
Set accessor functions for the LLRP GPITriggerValue sub-parameter.
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
Class Definition CReaderExceptionEvent for LLRP parameter ReaderExceptionEvent.
Definition: out_ltkcpp.h:17927
std::list< CFrequencyHopTable * >::iterator endFrequencyHopTable(void)
Returns the last element of the FrequencyHopTable sub-parameter list.
Definition: out_ltkcpp.h:8998
llrp_u16_t getIndex(void)
Get accessor functions for the LLRP Index field.
Definition: out_ltkcpp.h:7547
Class Definition CLLRPStatus for LLRP parameter LLRPStatus.
Definition: out_ltkcpp.h:18888
void clearAccessCommandOpSpec(void)
Clears the LLRP AccessCommandOpSpec sub-parameter list.
Definition: out_ltkcpp.h:11883
int countAccessSpec(void)
Count of the LLRP AccessSpec sub-parameter list.
Definition: out_ltkcpp.h:4541
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:13726
EC1G2LockResultType getResult(void)
Get accessor functions for the LLRP Result field.
Definition: out_ltkcpp.h:23749
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:2816
void setInventoryParameterSpecID(llrp_u16_t value)
Set accessor functions for the LLRP InventoryParameterSpecID field.
Definition: out_ltkcpp.h:15252
Class Definition CC1G2KillOpSpecResult for LLRP parameter C1G2KillOpSpecResult.
Definition: out_ltkcpp.h:23573
void setEventType(EAntennaEventType value)
Set accessor functions for the LLRP EventType field.
Definition: out_ltkcpp.h:18646
CAntennaID * getAntennaID(void)
Get accessor functions for the LLRP AntennaID sub-parameter.
Definition: out_ltkcpp.h:14508
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:5743
Class Definition CGPOWriteData for LLRP parameter GPOWriteData.
Definition: out_ltkcpp.h:12499
EResultCode addSpecParameter(CParameter *pValue)
Add a SpecParameter to the LLRP sub-parameter list.
llrp_u8v_t getProtocolID(void)
Get accessor functions for the LLRP ProtocolID field.
Definition: out_ltkcpp.h:7855
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:11921
void setGPIEvent(llrp_u1_t value)
Set accessor functions for the LLRP GPIEvent field.
Definition: out_ltkcpp.h:10032
int countAntennaProperties(void)
Count of the LLRP AntennaProperties sub-parameter list.
Definition: out_ltkcpp.h:5111
Class Definition CC1G2BlockEraseOpSpecResult for LLRP parameter C1G2BlockEraseOpSpecResult.
Definition: out_ltkcpp.h:23830
Class Definition CLLRPCapabilities for LLRP parameter LLRPCapabilities.
Definition: out_ltkcpp.h:8056
Class Definition CEPCData for LLRP parameter EPCData.
Definition: out_ltkcpp.h:14802
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:22032
CRFSurveySpecStopTrigger * getRFSurveySpecStopTrigger(void)
Get accessor functions for the LLRP RFSurveySpecStopTrigger sub-parameter.
Definition: out_ltkcpp.h:11133
llrp_u64_t getMicroseconds(void)
Get accessor functions for the LLRP Microseconds field.
Definition: out_ltkcpp.h:15854
CEventsAndReports * getEventsAndReports(void)
Get accessor functions for the LLRP EventsAndReports sub-parameter.
Definition: out_ltkcpp.h:5719
Class Definition CClientRequestOpSpec for LLRP parameter ClientRequestOpSpec.
Definition: out_ltkcpp.h:11975
Class Definition CRFSurveySpec for LLRP parameter RFSurveySpec.
Definition: out_ltkcpp.h:11010
void setErrorDescription(llrp_utf8v_t value)
Set accessor functions for the LLRP ErrorDescription field.
Definition: out_ltkcpp.h:18972
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:11914
int countGPOWriteData(void)
Count of the LLRP GPOWriteData sub-parameter list.
Definition: out_ltkcpp.h:5664
EResultCode setReportBufferLevelWarningEvent(CReportBufferLevelWarningEvent *pValue)
Set accessor functions for the LLRP ReportBufferLevelWarningEvent sub-parameter.
Class Definition CREADER_EVENT_NOTIFICATION for LLRP message READER_EVENT_NOTIFICATION.
Definition: out_ltkcpp.h:6471
Class Definition CAccessSpec for LLRP parameter AccessSpec.
Definition: out_ltkcpp.h:11376
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:3386
EROSpecState getCurrentState(void)
Get accessor functions for the LLRP CurrentState field.
Definition: out_ltkcpp.h:9419
llrp_u16_t getTagPopulation(void)
Get accessor functions for the LLRP TagPopulation field.
Definition: out_ltkcpp.h:21024
void setFieldNum(llrp_u16_t value)
Set accessor functions for the LLRP FieldNum field.
Definition: out_ltkcpp.h:19105
Class Definition CCLOSE_CONNECTION for LLRP message CLOSE_CONNECTION.
Definition: out_ltkcpp.h:5901
EResultCode setReaderEventNotificationSpec(CReaderEventNotificationSpec *pValue)
Set accessor functions for the LLRP ReaderEventNotificationSpec sub-parameter.
void setMaxNumAccessSpecs(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumAccessSpecs field.
Definition: out_ltkcpp.h:8374
EC1G2BlockEraseResultType getResult(void)
Get accessor functions for the LLRP Result field.
Definition: out_ltkcpp.h:23881
llrp_u16_t getInventoryParameterSpecID(void)
Get accessor functions for the LLRP InventoryParameterSpecID field.
Definition: out_ltkcpp.h:15245
llrp_u1_t getCanReportBufferFillWarning(void)
Get accessor functions for the LLRP CanReportBufferFillWarning field.
Definition: out_ltkcpp.h:8133
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:20123
EResultCode setIdentification(CIdentification *pValue)
Set accessor functions for the LLRP Identification sub-parameter.
Class Definition CDELETE_ACCESSSPEC for LLRP message DELETE_ACCESSSPEC.
Definition: out_ltkcpp.h:3819
void setWriteData(llrp_u16v_t value)
Set accessor functions for the LLRP WriteData field.
Definition: out_ltkcpp.h:21940
std::list< CTagReportData * >::iterator beginTagReportData(void)
Returns the first element of the TagReportData sub-parameter list.
Definition: out_ltkcpp.h:6186
std::list< CParameter * >::iterator beginAirProtocolInventoryCommandSettings(void)
Returns the first element of the AirProtocolInventoryCommandSettings sub-parameter list...
Definition: out_ltkcpp.h:13009
Class Definition CUHFBandCapabilities for LLRP parameter UHFBandCapabilities.
Definition: out_ltkcpp.h:8627
EResultCode setROSpecID(CROSpecID *pValue)
Set accessor functions for the LLRP ROSpecID sub-parameter.
void setTagInventoryStateAware(llrp_u1_t value)
Set accessor functions for the LLRP TagInventoryStateAware field.
Definition: out_ltkcpp.h:20038
EResultCode addGPIPortCurrentState(CGPIPortCurrentState *pValue)
Add a GPIPortCurrentState to the LLRP sub-parameter list.
Class Definition CAISpecEvent for LLRP parameter AISpecEvent.
Definition: out_ltkcpp.h:18420
void setModelName(llrp_u32_t value)
Set accessor functions for the LLRP ModelName field.
Definition: out_ltkcpp.h:7295
EC1G2MValue getMValue(void)
Get accessor functions for the LLRP MValue field.
Definition: out_ltkcpp.h:19741
int countAccessCommandOpSpec(void)
Count of the LLRP AccessCommandOpSpec sub-parameter list.
Definition: out_ltkcpp.h:11890
void setHasUTCClockCapability(llrp_u1_t value)
Set accessor functions for the LLRP HasUTCClockCapability field.
Definition: out_ltkcpp.h:7243
std::list< CAntennaProperties * >::iterator endAntennaProperties(void)
Returns the last element of the AntennaProperties sub-parameter list.
Definition: out_ltkcpp.h:5523
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:4930
EResultCode setAISpecStopTrigger(CAISpecStopTrigger *pValue)
Set accessor functions for the LLRP AISpecStopTrigger sub-parameter.
CReaderEventNotificationSpec * getReaderEventNotificationSpec(void)
Get accessor functions for the LLRP ReaderEventNotificationSpec sub-parameter.
Definition: out_ltkcpp.h:5499
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode setTagReportContentSelector(CTagReportContentSelector *pValue)
Set accessor functions for the LLRP TagReportContentSelector sub-parameter.
EResultCode addAccessSpec(CAccessSpec *pValue)
Add a AccessSpec to the LLRP sub-parameter list.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:11068
int countFrequencyRSSILevelEntry(void)
Count of the LLRP FrequencyRSSILevelEntry sub-parameter list.
Definition: out_ltkcpp.h:16398
Class Definition CFixedFrequencyTable for LLRP parameter FixedFrequencyTable.
Definition: out_ltkcpp.h:9213
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:6276
Class Definition CReportBufferOverflowErrorEvent for LLRP parameter ReportBufferOverflowErrorEvent.
Definition: out_ltkcpp.h:17848
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:3772
EResultCode setAccessReportSpec(CAccessReportSpec *pValue)
Set accessor functions for the LLRP AccessReportSpec sub-parameter.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:16157
Class Definition CADD_ACCESSSPEC for LLRP message ADD_ACCESSSPEC.
Definition: out_ltkcpp.h:3638
void setVendorIdentifier(llrp_u32_t value)
Set accessor functions for the LLRP VendorIdentifier field.
Definition: out_ltkcpp.h:1864
CInventoryParameterSpecID * getInventoryParameterSpecID(void)
Get accessor functions for the LLRP InventoryParameterSpecID sub-parameter.
Definition: out_ltkcpp.h:18032
void setEnableChannelIndex(llrp_u1_t value)
Set accessor functions for the LLRP EnableChannelIndex field.
Definition: out_ltkcpp.h:13950
void setROSpecStartTriggerType(EROSpecStartTriggerType value)
Set accessor functions for the LLRP ROSpecStartTriggerType field.
Definition: out_ltkcpp.h:9705
void setModeIdentifier(llrp_u32_t value)
Set accessor functions for the LLRP ModeIdentifier field.
Definition: out_ltkcpp.h:19670
void setEventType(ENotificationEventType value)
Set accessor functions for the LLRP EventType field.
Definition: out_ltkcpp.h:16871
EResultCode addPerAntennaAirProtocol(CPerAntennaAirProtocol *pValue)
Add a PerAntennaAirProtocol to the LLRP sub-parameter list.
void setNumberOfAttempts(llrp_u16_t value)
Set accessor functions for the LLRP NumberOfAttempts field.
Definition: out_ltkcpp.h:10711
Class Definition CGPIPortCurrentState for LLRP parameter GPIPortCurrentState.
Definition: out_ltkcpp.h:13337
llrp_u1_t getGPOData(void)
Get accessor functions for the LLRP GPOData field.
Definition: out_ltkcpp.h:12576
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:15049
llrp_u1v_t getEPC(void)
Get accessor functions for the LLRP EPC field.
Definition: out_ltkcpp.h:14853
CLastSeenTimestampUTC * getLastSeenTimestampUTC(void)
Get accessor functions for the LLRP LastSeenTimestampUTC sub-parameter.
Definition: out_ltkcpp.h:14593
void setErrorCode(EStatusCode value)
Set accessor functions for the LLRP ErrorCode field.
Definition: out_ltkcpp.h:19258
llrp_s8_t getAverageRSSI(void)
Get accessor functions for the LLRP AverageRSSI field.
Definition: out_ltkcpp.h:16611
llrp_u32v_t getFrequency(void)
Get accessor functions for the LLRP Frequency field.
Definition: out_ltkcpp.h:9264
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:5365
Class Definition CSET_READER_CONFIG for LLRP message SET_READER_CONFIG.
Definition: out_ltkcpp.h:5428
std::list< CFrequencyHopTable * >::iterator beginFrequencyHopTable(void)
Returns the first element of the FrequencyHopTable sub-parameter list.
Definition: out_ltkcpp.h:8991
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setStatus(EConnectionAttemptStatusType value)
Set accessor functions for the LLRP Status field.
Definition: out_ltkcpp.h:18770
llrp_u16_t getTagCount(void)
Get accessor functions for the LLRP TagCount field.
Definition: out_ltkcpp.h:16055
CChannelIndex * getChannelIndex(void)
Get accessor functions for the LLRP ChannelIndex sub-parameter.
Definition: out_ltkcpp.h:14542
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:14737
llrp_u1_t getEnableChannelIndex(void)
Get accessor functions for the LLRP EnableChannelIndex field.
Definition: out_ltkcpp.h:13943
EResultCode setHoppingEvent(CHoppingEvent *pValue)
Set accessor functions for the LLRP HoppingEvent sub-parameter.
llrp_u32_t getMinTariValue(void)
Get accessor functions for the LLRP MinTariValue field.
Definition: out_ltkcpp.h:19871
void setNumEmptySlots(llrp_u16_t value)
Set accessor functions for the LLRP NumEmptySlots field.
Definition: out_ltkcpp.h:23225
void setMaxTariValue(llrp_u32_t value)
Set accessor functions for the LLRP MaxTariValue field.
Definition: out_ltkcpp.h:19904
void setReaderFirmwareVersion(llrp_utf8v_t value)
Set accessor functions for the LLRP ReaderFirmwareVersion field.
Definition: out_ltkcpp.h:7321
CC1G2TagInventoryMask * getC1G2TagInventoryMask(void)
Get accessor functions for the LLRP C1G2TagInventoryMask sub-parameter.
Definition: out_ltkcpp.h:20287
void setAccessSpecID(llrp_u32_t value)
Set accessor functions for the LLRP AccessSpecID field.
Definition: out_ltkcpp.h:12133
std::list< CPerAntennaAirProtocol * >::iterator endPerAntennaAirProtocol(void)
Returns the last element of the PerAntennaAirProtocol sub-parameter list.
Definition: out_ltkcpp.h:7434
Class Definition CGPIOCapabilities for LLRP parameter GPIOCapabilities.
Definition: out_ltkcpp.h:7903
Class Definition CGET_ROSPECS_RESPONSE for LLRP message GET_ROSPECS_RESPONSE.
Definition: out_ltkcpp.h:3502
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:11531
void setForwardLinkModulation(EC1G2ForwardLinkModulation value)
Set accessor functions for the LLRP ForwardLinkModulation field.
Definition: out_ltkcpp.h:19774
void setI(EC1G2TagInventoryStateAwareI value)
Set accessor functions for the LLRP I field.
Definition: out_ltkcpp.h:21174
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:3196
CTagReportData * getTagReportData(void)
Get accessor functions for the LLRP TagReportData sub-parameter.
Definition: out_ltkcpp.h:4630
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EC1G2BlockWriteResultType getResult(void)
Get accessor functions for the LLRP Result field.
Definition: out_ltkcpp.h:24014
Class Definition CAccessReportSpec for LLRP parameter AccessReportSpec.
Definition: out_ltkcpp.h:14158
std::list< CAccessSpec * >::iterator endAccessSpec(void)
Returns the last element of the AccessSpec sub-parameter list.
Definition: out_ltkcpp.h:4527
Class Definition CDELETE_ROSPEC_RESPONSE for LLRP message DELETE_ROSPEC_RESPONSE. ...
Definition: out_ltkcpp.h:2581
void setEnablePCBits(llrp_u1_t value)
Set accessor functions for the LLRP EnablePCBits field.
Definition: out_ltkcpp.h:22911
EResultCode setRFSurveySpecStopTrigger(CRFSurveySpecStopTrigger *pValue)
Set accessor functions for the LLRP RFSurveySpecStopTrigger sub-parameter.
void setGPIPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPIPortNum field.
Definition: out_ltkcpp.h:4877
void setMicroseconds(llrp_u64_t value)
Set accessor functions for the LLRP Microseconds field.
Definition: out_ltkcpp.h:6920
llrp_u1_t getSupportsClientRequestOpSpec(void)
Get accessor functions for the LLRP SupportsClientRequestOpSpec field.
Definition: out_ltkcpp.h:8159
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:11157
void setMaxNumOpSpecsPerAccessSpec(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumOpSpecsPerAccessSpec field.
Definition: out_ltkcpp.h:8400
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:17673
CFrequencyInformation * getFrequencyInformation(void)
Get accessor functions for the LLRP FrequencyInformation sub-parameter.
Definition: out_ltkcpp.h:8710
CTagSeenCount * getTagSeenCount(void)
Get accessor functions for the LLRP TagSeenCount sub-parameter.
Definition: out_ltkcpp.h:14627
Class Definition CCLOSE_CONNECTION_RESPONSE for LLRP message CLOSE_CONNECTION_RESPONSE.
Definition: out_ltkcpp.h:5977
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
Definition: out_ltkcpp.h:21862
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:6269
Class Definition CDISABLE_ACCESSSPEC for LLRP message DISABLE_ACCESSSPEC.
Definition: out_ltkcpp.h:4199
CROSpecID * getROSpecID(void)
Get accessor functions for the LLRP ROSpecID sub-parameter.
Definition: out_ltkcpp.h:16343
void setTagMask(llrp_u1v_t value)
Set accessor functions for the LLRP TagMask field.
Definition: out_ltkcpp.h:20471
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:5056
std::list< CROSpec * >::iterator beginROSpec(void)
Returns the first element of the ROSpec sub-parameter list.
Definition: out_ltkcpp.h:3564
void setLLRPConfigurationStateValue(llrp_u32_t value)
Set accessor functions for the LLRP LLRPConfigurationStateValue field.
Definition: out_ltkcpp.h:12320
void clearGPOWriteData(void)
Clears the LLRP GPOWriteData sub-parameter list.
Definition: out_ltkcpp.h:5303
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:23501
Class Definition CC1G2Lock for LLRP parameter C1G2Lock.
Definition: out_ltkcpp.h:22110
EResultCode addPerAntennaReceiveSensitivityRange(CPerAntennaReceiveSensitivityRange *pValue)
Add a PerAntennaReceiveSensitivityRange to the LLRP sub-parameter list.
void setTarget(EC1G2StateAwareTarget value)
Set accessor functions for the LLRP Target field.
Definition: out_ltkcpp.h:20589
EC1G2StateAwareTarget getTarget(void)
Get accessor functions for the LLRP Target field.
Definition: out_ltkcpp.h:20582
void setCanSupportBlockWrite(llrp_u1_t value)
Set accessor functions for the LLRP CanSupportBlockWrite field.
Definition: out_ltkcpp.h:19425
Class Definition COpSpecID for LLRP parameter OpSpecID.
Definition: out_ltkcpp.h:18165
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
Definition: out_ltkcpp.h:22493
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:14751
void setAntennaIDs(llrp_u16v_t value)
Set accessor functions for the LLRP AntennaIDs field.
Definition: out_ltkcpp.h:10302
int countGPIPortCurrentState(void)
Count of the LLRP GPIPortCurrentState sub-parameter list.
Definition: out_ltkcpp.h:5272
EResultCode addAntennaConfiguration(CAntennaConfiguration *pValue)
Add a AntennaConfiguration to the LLRP sub-parameter list.
void setCanSupportBlockErase(llrp_u1_t value)
Set accessor functions for the LLRP CanSupportBlockErase field.
Definition: out_ltkcpp.h:19399
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:22039
void clearAntennaConfiguration(void)
Clears the LLRP AntennaConfiguration sub-parameter list.
Definition: out_ltkcpp.h:5568
Class Definition CC1G2_PC for LLRP parameter C1G2_PC.
Definition: out_ltkcpp.h:22951
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:3104
void clearAirProtocolOpSpec(void)
Clears the LLRP AirProtocolOpSpec sub-parameter list.
Definition: out_ltkcpp.h:12177
std::list< CGPOWriteData * >::iterator beginGPOWriteData(void)
Returns the first element of the GPOWriteData sub-parameter list.
Definition: out_ltkcpp.h:5289
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:11061
CROReportSpec * getROReportSpec(void)
Get accessor functions for the LLRP ROReportSpec sub-parameter.
Definition: out_ltkcpp.h:5183
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
EResultCode setParameterError(CParameterError *pValue)
Set accessor functions for the LLRP ParameterError sub-parameter.
void setSpecIndex(llrp_u16_t value)
Set accessor functions for the LLRP SpecIndex field.
Definition: out_ltkcpp.h:15154
void setT(EC1G2TruncateAction value)
Set accessor functions for the LLRP T field.
Definition: out_ltkcpp.h:20274
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:13712
std::list< CParameter * >::iterator beginAirProtocolUHFRFModeTable(void)
Returns the first element of the AirProtocolUHFRFModeTable sub-parameter list.
Definition: out_ltkcpp.h:8727
llrp_s8_t getPeakRSSI(void)
Get accessor functions for the LLRP PeakRSSI field.
Definition: out_ltkcpp.h:16637
llrp_u16_t getNumGPIs(void)
Get accessor functions for the LLRP NumGPIs field.
Definition: out_ltkcpp.h:7954
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:15350
int countSpecParameter(void)
Count of the LLRP SpecParameter sub-parameter list.
Definition: out_ltkcpp.h:9477
Class Definition CENABLE_ROSPEC_RESPONSE for LLRP message ENABLE_ROSPEC_RESPONSE. ...
Definition: out_ltkcpp.h:3151
EResultCode addFrequencyRSSILevelEntry(CFrequencyRSSILevelEntry *pValue)
Add a FrequencyRSSILevelEntry to the LLRP sub-parameter list.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:7678
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:18114
llrp_u1_t getEnableROSpecID(void)
Get accessor functions for the LLRP EnableROSpecID field.
Definition: out_ltkcpp.h:13839
void setHoldEventsAndReportsUponReconnect(llrp_u1_t value)
Set accessor functions for the LLRP HoldEventsAndReportsUponReconnect field.
Definition: out_ltkcpp.h:13546
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u32_t getMaxNumOpSpecsPerAccessSpec(void)
Get accessor functions for the LLRP MaxNumOpSpecsPerAccessSpec field.
Definition: out_ltkcpp.h:8393
void clearAirProtocolTagData(void)
Clears the LLRP AirProtocolTagData sub-parameter list.
Definition: out_ltkcpp.h:14658
llrp_u1_t getEnableCRC(void)
Get accessor functions for the LLRP EnableCRC field.
Definition: out_ltkcpp.h:22878
void setMinTariValue(llrp_u32_t value)
Set accessor functions for the LLRP MinTariValue field.
Definition: out_ltkcpp.h:19878
EResultCode addC1G2TargetTag(CC1G2TargetTag *pValue)
Add a C1G2TargetTag to the LLRP sub-parameter list.
void clearGPIPortCurrentState(void)
Clears the LLRP GPIPortCurrentState sub-parameter list.
Definition: out_ltkcpp.h:5265
void clearAirProtocolInventoryCommandSettings(void)
Clears the LLRP AirProtocolInventoryCommandSettings sub-parameter list.
Definition: out_ltkcpp.h:13023
EResultCode setEPCParameter(CParameter *pValue)
Set accessor functions for the LLRP EPCParameter sub-parameter.
CFieldError * getFieldError(void)
Get accessor functions for the LLRP FieldError sub-parameter.
Definition: out_ltkcpp.h:18985
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:10384
ERFSurveySpecStopTriggerType getStopTriggerType(void)
Get accessor functions for the LLRP StopTriggerType field.
Definition: out_ltkcpp.h:11268
void setNumWordsWritten(llrp_u16_t value)
Set accessor functions for the LLRP NumWordsWritten field.
Definition: out_ltkcpp.h:24073
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:5757
Class Definition CGET_READER_CAPABILITIES for LLRP message GET_READER_CAPABILITIES.
Definition: out_ltkcpp.h:1957
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:6283
EResultCode setReportBufferOverflowErrorEvent(CReportBufferOverflowErrorEvent *pValue)
Set accessor functions for the LLRP ReportBufferOverflowErrorEvent sub-parameter. ...
llrp_u16_t getGPOPortNumber(void)
Get accessor functions for the LLRP GPOPortNumber field.
Definition: out_ltkcpp.h:12550
CAccessReportSpec * getAccessReportSpec(void)
Get accessor functions for the LLRP AccessReportSpec sub-parameter.
Definition: out_ltkcpp.h:5200
llrp_u16_t getNumberOfTags(void)
Get accessor functions for the LLRP NumberOfTags field.
Definition: out_ltkcpp.h:10678
COpSpecID * getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID sub-parameter.
Definition: out_ltkcpp.h:18083
void setMessageSubtype(llrp_u8_t value)
Set accessor functions for the LLRP MessageSubtype field.
Definition: out_ltkcpp.h:1890
llrp_u1_t getHopping(void)
Get accessor functions for the LLRP Hopping field.
Definition: out_ltkcpp.h:8971
Class Definition CC1G2Read for LLRP parameter C1G2Read.
Definition: out_ltkcpp.h:21571
void setCommunicationsStandard(ECommunicationsStandard value)
Set accessor functions for the LLRP CommunicationsStandard field.
Definition: out_ltkcpp.h:8530
Class Definition CC1G2BlockWriteOpSpecResult for LLRP parameter C1G2BlockWriteOpSpecResult.
Definition: out_ltkcpp.h:23963
void setReceiveSensitivityIndexMin(llrp_u16_t value)
Set accessor functions for the LLRP ReceiveSensitivityIndexMin field.
Definition: out_ltkcpp.h:7711
void setProtocolID(llrp_u8v_t value)
Set accessor functions for the LLRP ProtocolID field.
Definition: out_ltkcpp.h:7862
std::list< CC1G2LockPayload * >::iterator endC1G2LockPayload(void)
Returns the last element of the C1G2LockPayload sub-parameter list.
Definition: out_ltkcpp.h:22214
llrp_u32_t getModelName(void)
Get accessor functions for the LLRP ModelName field.
Definition: out_ltkcpp.h:7288
EResultCode setConnectionCloseEvent(CConnectionCloseEvent *pValue)
Set accessor functions for the LLRP ConnectionCloseEvent sub-parameter.
EResultCode setFieldError(CFieldError *pValue)
Set accessor functions for the LLRP FieldError sub-parameter.
llrp_u16_t getT(void)
Get accessor functions for the LLRP T field.
Definition: out_ltkcpp.h:10730
int countC1G2UHFRFModeTableEntry(void)
Count of the LLRP C1G2UHFRFModeTableEntry sub-parameter list.
Definition: out_ltkcpp.h:19557
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
llrp_u16_t getInventoryParameterSpecID(void)
Get accessor functions for the LLRP InventoryParameterSpecID field.
Definition: out_ltkcpp.h:10857
void setVendorIdentifier(llrp_u32_t value)
Set accessor functions for the LLRP VendorIdentifier field.
Definition: out_ltkcpp.h:7031
std::list< CC1G2LockPayload * >::iterator beginC1G2LockPayload(void)
Returns the first element of the C1G2LockPayload sub-parameter list.
Definition: out_ltkcpp.h:22207
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:2042
std::list< CParameter * >::iterator endAirProtocolEPCMemorySelector(void)
Returns the last element of the AirProtocolEPCMemorySelector sub-parameter list.
Definition: out_ltkcpp.h:14100
llrp_u16_t getIndex(void)
Get accessor functions for the LLRP Index field.
Definition: out_ltkcpp.h:8844
llrp_u16_t getNumEmptySlots(void)
Get accessor functions for the LLRP NumEmptySlots field.
Definition: out_ltkcpp.h:23218
llrp_u32_t getEndFrequency(void)
Get accessor functions for the LLRP EndFrequency field.
Definition: out_ltkcpp.h:11113
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:11616
Class Definition CEventNotificationState for LLRP parameter EventNotificationState.
Definition: out_ltkcpp.h:16813
void setTagPopulation(llrp_u16_t value)
Set accessor functions for the LLRP TagPopulation field.
Definition: out_ltkcpp.h:21031
void setProtocolID(EAirProtocols value)
Set accessor functions for the LLRP ProtocolID field.
Definition: out_ltkcpp.h:10890
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:5736
void setParameterType(llrp_u16_t value)
Set accessor functions for the LLRP ParameterType field.
Definition: out_ltkcpp.h:19232
EResultCode addC1G2LockPayload(CC1G2LockPayload *pValue)
Add a C1G2LockPayload to the LLRP sub-parameter list.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
Definition: out_ltkcpp.h:20419
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CROSpec * >::iterator endROSpec(void)
Returns the last element of the ROSpec sub-parameter list.
Definition: out_ltkcpp.h:3571
EResultCode setKeepaliveSpec(CKeepaliveSpec *pValue)
Set accessor functions for the LLRP KeepaliveSpec sub-parameter.
llrp_u16_t getReceiveSensitivityIndexMin(void)
Get accessor functions for the LLRP ReceiveSensitivityIndexMin field.
Definition: out_ltkcpp.h:7704
EResultCode addTransmitPowerLevelTableEntry(CTransmitPowerLevelTableEntry *pValue)
Add a TransmitPowerLevelTableEntry to the LLRP sub-parameter list.
llrp_u1_t getCanDoRFSurvey(void)
Get accessor functions for the LLRP CanDoRFSurvey field.
Definition: out_ltkcpp.h:8107
EC1G2LockPrivilege getPrivilege(void)
Get accessor functions for the LLRP Privilege field.
Definition: out_ltkcpp.h:22324
void setGPIPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPIPortNum field.
Definition: out_ltkcpp.h:10006
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
Definition: out_ltkcpp.h:21681
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:15343
llrp_u1v_t getTagMask(void)
Get accessor functions for the LLRP TagMask field.
Definition: out_ltkcpp.h:21490
int countFrequencyHopTable(void)
Count of the LLRP FrequencyHopTable sub-parameter list.
Definition: out_ltkcpp.h:9012
Class Definition CC1G2LLRPCapabilities for LLRP parameter C1G2LLRPCapabilities.
Definition: out_ltkcpp.h:19341
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:6704
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:2626
llrp_u32_t getModeIdentifier(void)
Get accessor functions for the LLRP ModeIdentifier field.
Definition: out_ltkcpp.h:19663
Class Definition CAntennaID for LLRP parameter AntennaID.
Definition: out_ltkcpp.h:15292
EAISpecStopTriggerType getAISpecStopTriggerType(void)
Get accessor functions for the LLRP AISpecStopTriggerType field.
Definition: out_ltkcpp.h:10489
std::list< CTagReportData * >::iterator endTagReportData(void)
Returns the last element of the TagReportData sub-parameter list.
Definition: out_ltkcpp.h:6193
llrp_u16_t getPointer(void)
Get accessor functions for the LLRP Pointer field.
Definition: out_ltkcpp.h:20438
EResultCode setAirProtocolLLRPCapabilities(CParameter *pValue)
Set accessor functions for the LLRP AirProtocolLLRPCapabilities sub-parameter.
llrp_u32_t getMaxNumInventoryParameterSpecsPerAISpec(void)
Get accessor functions for the LLRP MaxNumInventoryParameterSpecsPerAISpec field. ...
Definition: out_ltkcpp.h:8341
void clearGPOWriteData(void)
Clears the LLRP GPOWriteData sub-parameter list.
Definition: out_ltkcpp.h:5657
CGPIEvent * getGPIEvent(void)
Get accessor functions for the LLRP GPIEvent sub-parameter.
Definition: out_ltkcpp.h:17095
void setN(llrp_u16_t value)
Set accessor functions for the LLRP N field.
Definition: out_ltkcpp.h:13682
llrp_u32_t getPIEValue(void)
Get accessor functions for the LLRP PIEValue field.
Definition: out_ltkcpp.h:19845
void clearC1G2Filter(void)
Clears the LLRP C1G2Filter sub-parameter list.
Definition: out_ltkcpp.h:20065
void setAverageRSSI(llrp_s8_t value)
Set accessor functions for the LLRP AverageRSSI field.
Definition: out_ltkcpp.h:16618
void setTransmitPower(llrp_u16_t value)
Set accessor functions for the LLRP TransmitPower field.
Definition: out_ltkcpp.h:13284
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
Definition: out_ltkcpp.h:20412
llrp_u16_t getReceiverSensitivity(void)
Get accessor functions for the LLRP ReceiverSensitivity field.
Definition: out_ltkcpp.h:13125
Class Definition CRFSurveyEvent for LLRP parameter RFSurveyEvent.
Definition: out_ltkcpp.h:18265
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
Definition: out_ltkcpp.h:22726
void setDataField(EC1G2LockDataField value)
Set accessor functions for the LLRP DataField field.
Definition: out_ltkcpp.h:22357
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
Definition: out_ltkcpp.h:21419
Class Definition CTagReportData for LLRP parameter TagReportData.
Definition: out_ltkcpp.h:14395
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode addAirProtocolOpSpec(CParameter *pValue)
Add a AirProtocolOpSpec to the LLRP sub-parameter list.
std::list< CEventNotificationState * >::iterator endEventNotificationState(void)
Returns the last element of the EventNotificationState sub-parameter list.
Definition: out_ltkcpp.h:16753
EResultCode setTagSeenCount(CTagSeenCount *pValue)
Set accessor functions for the LLRP TagSeenCount sub-parameter.
llrp_u16_t getWordCount(void)
Get accessor functions for the LLRP WordCount field.
Definition: out_ltkcpp.h:21726
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:12955
void setConfig(llrp_u1_t value)
Set accessor functions for the LLRP Config field.
Definition: out_ltkcpp.h:13421
void clearSpecParameter(void)
Clears the LLRP SpecParameter sub-parameter list.
Definition: out_ltkcpp.h:9470
void setEventType(EAISpecEventType value)
Set accessor functions for the LLRP EventType field.
Definition: out_ltkcpp.h:18478
std::list< CParameter * >::iterator beginSpecParameter(void)
Returns the first element of the SpecParameter sub-parameter list.
Definition: out_ltkcpp.h:9456
void setBDRValue(llrp_u32_t value)
Set accessor functions for the LLRP BDRValue field.
Definition: out_ltkcpp.h:19826
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:16422
CParameterError * getParameterError(void)
Get accessor functions for the LLRP ParameterError sub-parameter.
Definition: out_ltkcpp.h:19002
EResultCode setInventoryParameterSpecID(CInventoryParameterSpecID *pValue)
Set accessor functions for the LLRP InventoryParameterSpecID sub-parameter.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:3547
void setCRC(llrp_u16_t value)
Set accessor functions for the LLRP CRC field.
Definition: out_ltkcpp.h:23107
EResultCode setROSpec(CROSpec *pValue)
Set accessor functions for the LLRP ROSpec sub-parameter.
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:9367
EResultCode setROSpecID(CROSpecID *pValue)
Set accessor functions for the LLRP ROSpecID sub-parameter.
llrp_u16_t getHopTableID(void)
Get accessor functions for the LLRP HopTableID field.
Definition: out_ltkcpp.h:17385
void setTagCount(llrp_u16_t value)
Set accessor functions for the LLRP TagCount field.
Definition: out_ltkcpp.h:16062
EResultCode setAccessSpecStopTrigger(CAccessSpecStopTrigger *pValue)
Set accessor functions for the LLRP AccessSpecStopTrigger sub-parameter.
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:22467
EAirProtocols getProtocolID(void)
Get accessor functions for the LLRP ProtocolID field.
Definition: out_ltkcpp.h:11479
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
CC1G2SingulationControl * getC1G2SingulationControl(void)
Get accessor functions for the LLRP C1G2SingulationControl sub-parameter.
Definition: out_ltkcpp.h:20106
void setAccessSpecStopTrigger(EAccessSpecStopTriggerType value)
Set accessor functions for the LLRP AccessSpecStopTrigger field.
Definition: out_ltkcpp.h:11729
void clearRFSurveyReportData(void)
Clears the LLRP RFSurveyReportData sub-parameter list.
Definition: out_ltkcpp.h:6238
EROReportTriggerType getROReportTrigger(void)
Get accessor functions for the LLRP ROReportTrigger field.
Definition: out_ltkcpp.h:13649
Class Definition CEventsAndReports for LLRP parameter EventsAndReports.
Definition: out_ltkcpp.h:13488
CEPCData * getEPCData(void)
Get accessor functions for the LLRP EPCData sub-parameter.
Definition: out_ltkcpp.h:12146
void setNumCollisionSlots(llrp_u16_t value)
Set accessor functions for the LLRP NumCollisionSlots field.
Definition: out_ltkcpp.h:23199
EGetReaderCapabilitiesRequestedData getRequestedData(void)
Get accessor functions for the LLRP RequestedData field.
Definition: out_ltkcpp.h:2008
void setPrivilege(EC1G2LockPrivilege value)
Set accessor functions for the LLRP Privilege field.
Definition: out_ltkcpp.h:22331
EResultCode setPeakRSSI(CPeakRSSI *pValue)
Set accessor functions for the LLRP PeakRSSI sub-parameter.
int countInventoryParameterSpec(void)
Count of the LLRP InventoryParameterSpec sub-parameter list.
Definition: out_ltkcpp.h:10353
EResultCode addAntennaProperties(CAntennaProperties *pValue)
Add a AntennaProperties to the LLRP sub-parameter list.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:18665
EResultCode setReaderEventNotificationSpec(CReaderEventNotificationSpec *pValue)
Set accessor functions for the LLRP ReaderEventNotificationSpec sub-parameter.
void setState(EGPIPortState value)
Set accessor functions for the LLRP State field.
Definition: out_ltkcpp.h:13447
std::list< CPerAntennaReceiveSensitivityRange * >::iterator endPerAntennaReceiveSensitivityRange(void)
Returns the last element of the PerAntennaReceiveSensitivityRange sub-parameter list.
Definition: out_ltkcpp.h:7379
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:8581
void setSpectralMaskIndicator(EC1G2SpectralMaskIndicator value)
Set accessor functions for the LLRP SpectralMaskIndicator field.
Definition: out_ltkcpp.h:19800
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:10955
int countGPOWriteData(void)
Count of the LLRP GPOWriteData sub-parameter list.
Definition: out_ltkcpp.h:5310
Class Definition CC1G2InventoryCommand for LLRP parameter C1G2InventoryCommand.
Definition: out_ltkcpp.h:19980
EResultCode setAntennaID(CAntennaID *pValue)
Set accessor functions for the LLRP AntennaID sub-parameter.
llrp_u16_t getWordPointer(void)
Get accessor functions for the LLRP WordPointer field.
Definition: out_ltkcpp.h:22752
CParameter * getAirProtocolTagSpec(void)
Get accessor functions for the LLRP AirProtocolTagSpec sub-parameter.
Definition: out_ltkcpp.h:11852
Class Definition CADD_ROSPEC for LLRP message ADD_ROSPEC.
Definition: out_ltkcpp.h:2302
llrp_u1_t getConfig(void)
Get accessor functions for the LLRP Config field.
Definition: out_ltkcpp.h:13414
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:11164
llrp_u32_t getTimeout(void)
Get accessor functions for the LLRP Timeout field.
Definition: out_ltkcpp.h:10051
CROSpecStopTrigger * getROSpecStopTrigger(void)
Get accessor functions for the LLRP ROSpecStopTrigger sub-parameter.
Definition: out_ltkcpp.h:9601
llrp_u32_t getParameterSubtype(void)
Get accessor functions for the LLRP ParameterSubtype field.
Definition: out_ltkcpp.h:7050
void setNotificationState(llrp_u1_t value)
Set accessor functions for the LLRP NotificationState field.
Definition: out_ltkcpp.h:16897
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:12962
int countROSpec(void)
Count of the LLRP ROSpec sub-parameter list.
Definition: out_ltkcpp.h:3585
EResultCode setROReportSpec(CROReportSpec *pValue)
Set accessor functions for the LLRP ROReportSpec sub-parameter.
llrp_u32_t getPeriod(void)
Get accessor functions for the LLRP Period field.
Definition: out_ltkcpp.h:9869
int countAccessCommandOpSpecResult(void)
Count of the LLRP AccessCommandOpSpecResult sub-parameter list.
Definition: out_ltkcpp.h:14720
ECommunicationsStandard getCommunicationsStandard(void)
Get accessor functions for the LLRP CommunicationsStandard field.
Definition: out_ltkcpp.h:8523
Class Definition CSTART_ROSPEC for LLRP message START_ROSPEC.
Definition: out_ltkcpp.h:2673
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
std::list< CC1G2Filter * >::iterator endC1G2Filter(void)
Returns the last element of the C1G2Filter sub-parameter list.
Definition: out_ltkcpp.h:20058
std::list< CPerAntennaReceiveSensitivityRange * >::iterator beginPerAntennaReceiveSensitivityRange(void)
Returns the first element of the PerAntennaReceiveSensitivityRange sub-parameter list.
Definition: out_ltkcpp.h:7372
std::list< CGPOWriteData * >::iterator endGPOWriteData(void)
Returns the last element of the GPOWriteData sub-parameter list.
Definition: out_ltkcpp.h:5650
CROSpec * getROSpec(void)
Get accessor functions for the LLRP ROSpec sub-parameter.
Definition: out_ltkcpp.h:2347
Class Definition CC1G2Kill for LLRP parameter C1G2Kill.
Definition: out_ltkcpp.h:21981
void setROSpecStopTriggerType(EROSpecStopTriggerType value)
Set accessor functions for the LLRP ROSpecStopTriggerType field.
Definition: out_ltkcpp.h:10158
EResultCode setROSpecStopTrigger(CROSpecStopTrigger *pValue)
Set accessor functions for the LLRP ROSpecStopTrigger sub-parameter.
Class Definition CAntennaConfiguration for LLRP parameter AntennaConfiguration.
Definition: out_ltkcpp.h:12904
Class Definition CROSpecStopTrigger for LLRP parameter ROSpecStopTrigger.
Definition: out_ltkcpp.h:10100
llrp_u8_t getPriority(void)
Get accessor functions for the LLRP Priority field.
Definition: out_ltkcpp.h:9393
llrp_u1_t getEnablePeakRSSI(void)
Get accessor functions for the LLRP EnablePeakRSSI field.
Definition: out_ltkcpp.h:13969
Class Definition CAccessSpecID for LLRP parameter AccessSpecID.
Definition: out_ltkcpp.h:16197
CHoppingEvent * getHoppingEvent(void)
Get accessor functions for the LLRP HoppingEvent sub-parameter.
Definition: out_ltkcpp.h:17078
void setGPIPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPIPortNum field.
Definition: out_ltkcpp.h:13395
void setEventType(ERFSurveyEventType value)
Set accessor functions for the LLRP EventType field.
Definition: out_ltkcpp.h:18323
llrp_u8_t getReportBufferPercentageFull(void)
Get accessor functions for the LLRP ReportBufferPercentageFull field.
Definition: out_ltkcpp.h:17797
CAccessSpecID * getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID sub-parameter.
Definition: out_ltkcpp.h:18066
EROSpecStopTriggerType getROSpecStopTriggerType(void)
Get accessor functions for the LLRP ROSpecStopTriggerType field.
Definition: out_ltkcpp.h:10151
void setTransmitPowerValue(llrp_s16_t value)
Set accessor functions for the LLRP TransmitPowerValue field.
Definition: out_ltkcpp.h:8877
void setMicroseconds(llrp_u64_t value)
Set accessor functions for the LLRP Microseconds field.
Definition: out_ltkcpp.h:15760
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
Definition: out_ltkcpp.h:22733
EResultCode setEPCData(CEPCData *pValue)
Set accessor functions for the LLRP EPCData sub-parameter.
CLLRPCapabilities * getLLRPCapabilities(void)
Get accessor functions for the LLRP LLRPCapabilities sub-parameter.
Definition: out_ltkcpp.h:2177
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:11453
llrp_u16_t getWordPointer(void)
Get accessor functions for the LLRP WordPointer field.
Definition: out_ltkcpp.h:21700
void setEPC(llrp_u1v_t value)
Set accessor functions for the LLRP EPC field.
Definition: out_ltkcpp.h:14860
llrp_u32_t getTagTransitTime(void)
Get accessor functions for the LLRP TagTransitTime field.
Definition: out_ltkcpp.h:21050
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:10941
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
EResultCode addC1G2Filter(CC1G2Filter *pValue)
Add a C1G2Filter to the LLRP sub-parameter list.
CSpecIndex * getSpecIndex(void)
Get accessor functions for the LLRP SpecIndex sub-parameter.
Definition: out_ltkcpp.h:14474
int countAirProtocolEPCMemorySelector(void)
Count of the LLRP AirProtocolEPCMemorySelector sub-parameter list.
Definition: out_ltkcpp.h:14114
llrp_u1_t getEnableLastSeenTimestamp(void)
Get accessor functions for the LLRP EnableLastSeenTimestamp field.
Definition: out_ltkcpp.h:14021
void clearInventoryParameterSpec(void)
Clears the LLRP InventoryParameterSpec sub-parameter list.
Definition: out_ltkcpp.h:10346
CROBoundarySpec * getROBoundarySpec(void)
Get accessor functions for the LLRP ROBoundarySpec sub-parameter.
Definition: out_ltkcpp.h:9439
void setInventoryParameterSpecID(llrp_u16_t value)
Set accessor functions for the LLRP InventoryParameterSpecID field.
Definition: out_ltkcpp.h:10864
void setStartFrequency(llrp_u32_t value)
Set accessor functions for the LLRP StartFrequency field.
Definition: out_ltkcpp.h:11094
void clearAntennaProperties(void)
Clears the LLRP AntennaProperties sub-parameter list.
Definition: out_ltkcpp.h:5530
Class Definition CParameterError for LLRP parameter ParameterError.
Definition: out_ltkcpp.h:19174
EResultCode setAntennaEvent(CAntennaEvent *pValue)
Set accessor functions for the LLRP AntennaEvent sub-parameter.
EResultCode setReaderExceptionEvent(CReaderExceptionEvent *pValue)
Set accessor functions for the LLRP ReaderExceptionEvent sub-parameter.
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:2249
void setFrequency(llrp_u32v_t value)
Set accessor functions for the LLRP Frequency field.
Definition: out_ltkcpp.h:9173
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:23344
CEventsAndReports * getEventsAndReports(void)
Get accessor functions for the LLRP EventsAndReports sub-parameter.
Definition: out_ltkcpp.h:5327
llrp_u64_t getMicroseconds(void)
Get accessor functions for the LLRP Microseconds field.
Definition: out_ltkcpp.h:6913
EResultCode setC1G2TagInventoryStateAwareSingulationAction(CC1G2TagInventoryStateAwareSingulationAction *pValue)
Set accessor functions for the LLRP C1G2TagInventoryStateAwareSingulationAction sub-parameter.
std::list< CGPIPortCurrentState * >::iterator beginGPIPortCurrentState(void)
Returns the first element of the GPIPortCurrentState sub-parameter list.
Definition: out_ltkcpp.h:5251
llrp_u16_t getPC_Bits(void)
Get accessor functions for the LLRP PC_Bits field.
Definition: out_ltkcpp.h:23002
Class Definition CC1G2TargetTag for LLRP parameter C1G2TargetTag.
Definition: out_ltkcpp.h:21361
EResultCode setLastSeenTimestampUTC(CLastSeenTimestampUTC *pValue)
Set accessor functions for the LLRP LastSeenTimestampUTC sub-parameter.
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:7829
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:18672
void setAction(EC1G2StateAwareAction value)
Set accessor functions for the LLRP Action field.
Definition: out_ltkcpp.h:20615
EResultCode setAntennaID(CAntennaID *pValue)
Set accessor functions for the LLRP AntennaID sub-parameter.
void setResult(EC1G2KillResultType value)
Set accessor functions for the LLRP Result field.
Definition: out_ltkcpp.h:23631
void setClientRequestOpSpecTimeout(llrp_u16_t value)
Set accessor functions for the LLRP ClientRequestOpSpecTimeout field.
Definition: out_ltkcpp.h:8270
std::list< CAntennaConfiguration * >::iterator endAntennaConfiguration(void)
Returns the last element of the AntennaConfiguration sub-parameter list.
Definition: out_ltkcpp.h:10910
llrp_u16_t getModeIndex(void)
Get accessor functions for the LLRP ModeIndex field.
Definition: out_ltkcpp.h:20820
llrp_u32_t getMaxNumAccessSpecs(void)
Get accessor functions for the LLRP MaxNumAccessSpecs field.
Definition: out_ltkcpp.h:8367
llrp_u16_t getNextChannelIndex(void)
Get accessor functions for the LLRP NextChannelIndex field.
Definition: out_ltkcpp.h:17411
llrp_u1_t getSupportsEventAndReportHolding(void)
Get accessor functions for the LLRP SupportsEventAndReportHolding field.
Definition: out_ltkcpp.h:8211
void clearC1G2UHFRFModeTableEntry(void)
Clears the LLRP C1G2UHFRFModeTableEntry sub-parameter list.
Definition: out_ltkcpp.h:19550
CROSpecID * getROSpecID(void)
Get accessor functions for the LLRP ROSpecID sub-parameter.
Definition: out_ltkcpp.h:17998
EResultCode setSpecIndex(CSpecIndex *pValue)
Set accessor functions for the LLRP SpecIndex sub-parameter.
Class Definition CLastSeenTimestampUTC for LLRP parameter LastSeenTimestampUTC.
Definition: out_ltkcpp.h:15803
EResultCode setPeriodicTriggerValue(CPeriodicTriggerValue *pValue)
Set accessor functions for the LLRP PeriodicTriggerValue sub-parameter.
llrp_u16_t getFieldNum(void)
Get accessor functions for the LLRP FieldNum field.
Definition: out_ltkcpp.h:19098
int countAirProtocolInventoryCommandSettings(void)
Count of the LLRP AirProtocolInventoryCommandSettings sub-parameter list.
Definition: out_ltkcpp.h:13030
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:22168
llrp_u1_t getEnableInventoryParameterSpecID(void)
Get accessor functions for the LLRP EnableInventoryParameterSpecID field.
Definition: out_ltkcpp.h:13891
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:2049
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:21629
void setCanDoRFSurvey(llrp_u1_t value)
Set accessor functions for the LLRP CanDoRFSurvey field.
Definition: out_ltkcpp.h:8114
EResultCode setROReportSpec(CROReportSpec *pValue)
Set accessor functions for the LLRP ROReportSpec sub-parameter.
int countAntennaConfiguration(void)
Count of the LLRP AntennaConfiguration sub-parameter list.
Definition: out_ltkcpp.h:5149
void setMaxNumSpecsPerROSpec(llrp_u32_t value)
Set accessor functions for the LLRP MaxNumSpecsPerROSpec field.
Definition: out_ltkcpp.h:8322
CReportBufferOverflowErrorEvent * getReportBufferOverflowErrorEvent(void)
Get accessor functions for the LLRP ReportBufferOverflowErrorEvent sub-parameter. ...
Definition: out_ltkcpp.h:17146
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:10391
void setGPIEvent(llrp_u1_t value)
Set accessor functions for the LLRP GPIEvent field.
Definition: out_ltkcpp.h:17544
Class Definition CClientRequestResponse for LLRP parameter ClientRequestResponse. ...
Definition: out_ltkcpp.h:12075
llrp_u1_t getResetToFactoryDefault(void)
Get accessor functions for the LLRP ResetToFactoryDefault field.
Definition: out_ltkcpp.h:5479
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:10377
EResultCode setROReportSpec(CROReportSpec *pValue)
Set accessor functions for the LLRP ROReportSpec sub-parameter.
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:5846
std::list< CGPIPortCurrentState * >::iterator beginGPIPortCurrentState(void)
Returns the first element of the GPIPortCurrentState sub-parameter list.
Definition: out_ltkcpp.h:5681
CAISpecStopTrigger * getAISpecStopTrigger(void)
Get accessor functions for the LLRP AISpecStopTrigger sub-parameter.
Definition: out_ltkcpp.h:10315
void setMB(llrp_u2_t value)
Set accessor functions for the LLRP MB field.
Definition: out_ltkcpp.h:21888
llrp_u32_t getKillPassword(void)
Get accessor functions for the LLRP KillPassword field.
Definition: out_ltkcpp.h:22058
llrp_u16_t getNumWordsWritten(void)
Get accessor functions for the LLRP NumWordsWritten field.
Definition: out_ltkcpp.h:24066
Class Definition CADD_ROSPEC_RESPONSE for LLRP message ADD_ROSPEC_RESPONSE.
Definition: out_ltkcpp.h:2391
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:24047
void setMaxNumPriorityLevelsSupported(llrp_u8_t value)
Set accessor functions for the LLRP MaxNumPriorityLevelsSupported field.
Definition: out_ltkcpp.h:8244
EResultCode addAirProtocolInventoryCommandSettings(CParameter *pValue)
Add a AirProtocolInventoryCommandSettings to the LLRP sub-parameter list.
Class Definition CAISpecStopTrigger for LLRP parameter AISpecStopTrigger.
Definition: out_ltkcpp.h:10438
llrp_u32_t getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID field.
Definition: out_ltkcpp.h:11427
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setEnableInventoryParameterSpecID(llrp_u1_t value)
Set accessor functions for the LLRP EnableInventoryParameterSpecID field.
Definition: out_ltkcpp.h:13898
EResultCode setFirstSeenTimestampUptime(CFirstSeenTimestampUptime *pValue)
Set accessor functions for the LLRP FirstSeenTimestampUptime sub-parameter.
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:9374
Class Definition CROSpecID for LLRP parameter ROSpecID.
Definition: out_ltkcpp.h:14998
void setDRValue(EC1G2DRValue value)
Set accessor functions for the LLRP DRValue field.
Definition: out_ltkcpp.h:19696
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:24040
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
std::list< CAntennaProperties * >::iterator endAntennaProperties(void)
Returns the last element of the AntennaProperties sub-parameter list.
Definition: out_ltkcpp.h:5097
void setEnableAntennaID(llrp_u1_t value)
Set accessor functions for the LLRP EnableAntennaID field.
Definition: out_ltkcpp.h:13924
CReaderEventNotificationData * getReaderEventNotificationData(void)
Get accessor functions for the LLRP ReaderEventNotificationData sub-parameter.
Definition: out_ltkcpp.h:6516
void clearAntennaConfiguration(void)
Clears the LLRP AntennaConfiguration sub-parameter list.
Definition: out_ltkcpp.h:5142
void clearAirProtocolUHFRFModeTable(void)
Clears the LLRP AirProtocolUHFRFModeTable sub-parameter list.
Definition: out_ltkcpp.h:8741
CInventoryParameterSpecID * getInventoryParameterSpecID(void)
Get accessor functions for the LLRP InventoryParameterSpecID sub-parameter.
Definition: out_ltkcpp.h:14491
Class Definition CFrequencyRSSILevelEntry for LLRP parameter FrequencyRSSILevelEntry.
Definition: out_ltkcpp.h:16508
int countPerAntennaAirProtocol(void)
Count of the LLRP PerAntennaAirProtocol sub-parameter list.
Definition: out_ltkcpp.h:7448
void setGPOPortNumber(llrp_u16_t value)
Set accessor functions for the LLRP GPOPortNumber field.
Definition: out_ltkcpp.h:12557
EResultCode setFieldError(CFieldError *pValue)
Set accessor functions for the LLRP FieldError sub-parameter.
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:7685
Class Definition CDELETE_ROSPEC for LLRP message DELETE_ROSPEC.
Definition: out_ltkcpp.h:2483
void setResetToFactoryDefault(llrp_u1_t value)
Set accessor functions for the LLRP ResetToFactoryDefault field.
Definition: out_ltkcpp.h:5486
llrp_u1_t getCanSupportBlockErase(void)
Get accessor functions for the LLRP CanSupportBlockErase field.
Definition: out_ltkcpp.h:19392
llrp_u1_t getNotificationState(void)
Get accessor functions for the LLRP NotificationState field.
Definition: out_ltkcpp.h:16890
llrp_u16_t getHopTableID(void)
Get accessor functions for the LLRP HopTableID field.
Definition: out_ltkcpp.h:13225
Class Definition CReaderEventNotificationSpec for LLRP parameter ReaderEventNotificationSpec.
Definition: out_ltkcpp.h:16701
void setNumberOfTags(llrp_u16_t value)
Set accessor functions for the LLRP NumberOfTags field.
Definition: out_ltkcpp.h:10685
EResultCode addAccessCommandOpSpec(CParameter *pValue)
Add a AccessCommandOpSpec to the LLRP sub-parameter list.
void setSpecIndex(llrp_u16_t value)
Set accessor functions for the LLRP SpecIndex field.
Definition: out_ltkcpp.h:18530
void setTagMask(llrp_u1v_t value)
Set accessor functions for the LLRP TagMask field.
Definition: out_ltkcpp.h:21497
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:11460
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:14758
void setSupportsEventAndReportHolding(llrp_u1_t value)
Set accessor functions for the LLRP SupportsEventAndReportHolding field.
Definition: out_ltkcpp.h:8218
EResultCode setParameterError(CParameterError *pValue)
Set accessor functions for the LLRP ParameterError sub-parameter.
EC1G2StateUnawareAction getAction(void)
Get accessor functions for the LLRP Action field.
Definition: out_ltkcpp.h:20718
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:5750
llrp_u1_t getTagInventoryStateAware(void)
Get accessor functions for the LLRP TagInventoryStateAware field.
Definition: out_ltkcpp.h:20031
llrp_u32_t getPeriodicTriggerValue(void)
Get accessor functions for the LLRP PeriodicTriggerValue field.
Definition: out_ltkcpp.h:12701
EResultCode setTimestamp(CParameter *pValue)
Set accessor functions for the LLRP Timestamp sub-parameter.
Class Definition CLLRPConfigurationStateValue for LLRP parameter LLRPConfigurationStateValue.
Definition: out_ltkcpp.h:12262
EResultCode setROSpecStartTrigger(CROSpecStartTrigger *pValue)
Set accessor functions for the LLRP ROSpecStartTrigger sub-parameter.
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
Class Definition CCLIENT_REQUEST_OP for LLRP message CLIENT_REQUEST_OP.
Definition: out_ltkcpp.h:4585
EResultCode addAntennaConfiguration(CAntennaConfiguration *pValue)
Add a AntennaConfiguration to the LLRP sub-parameter list.
std::list< CParameter * >::iterator beginAirProtocolOpSpec(void)
Returns the first element of the AirProtocolOpSpec sub-parameter list.
Definition: out_ltkcpp.h:12163
int countAirProtocolUHFRFModeTable(void)
Count of the LLRP AirProtocolUHFRFModeTable sub-parameter list.
Definition: out_ltkcpp.h:8748
llrp_u16v_t getReadData(void)
Get accessor functions for the LLRP ReadData field.
Definition: out_ltkcpp.h:23370
llrp_u32_t getDurationPeriod(void)
Get accessor functions for the LLRP DurationPeriod field.
Definition: out_ltkcpp.h:11294
Class Definition CGET_READER_CONFIG_RESPONSE for LLRP message GET_READER_CONFIG_RESPONSE.
Definition: out_ltkcpp.h:5011
CROSpecStartTrigger * getROSpecStartTrigger(void)
Get accessor functions for the LLRP ROSpecStartTrigger sub-parameter.
Definition: out_ltkcpp.h:9584
Class Definition CC1G2EPCMemorySelector for LLRP parameter C1G2EPCMemorySelector. ...
Definition: out_ltkcpp.h:22827
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:21622
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:2228
CRegulatoryCapabilities * getRegulatoryCapabilities(void)
Get accessor functions for the LLRP RegulatoryCapabilities sub-parameter.
Definition: out_ltkcpp.h:2194
llrp_u16_t getReceiveSensitivityIndexMax(void)
Get accessor functions for the LLRP ReceiveSensitivityIndexMax field.
Definition: out_ltkcpp.h:7730
CReaderEventNotificationSpec * getReaderEventNotificationSpec(void)
Get accessor functions for the LLRP ReaderEventNotificationSpec sub-parameter.
Definition: out_ltkcpp.h:5166
Class Definition CPeriodicTriggerValue for LLRP parameter PeriodicTriggerValue.
Definition: out_ltkcpp.h:9792
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:20137
void setEnableSpecIndex(llrp_u1_t value)
Set accessor functions for the LLRP EnableSpecIndex field.
Definition: out_ltkcpp.h:13872
void setEPC(llrp_u96_t value)
Set accessor functions for the LLRP EPC field.
Definition: out_ltkcpp.h:14958
int countAntennaProperties(void)
Count of the LLRP AntennaProperties sub-parameter list.
Definition: out_ltkcpp.h:5537
EKeepaliveTriggerType getKeepaliveTriggerType(void)
Get accessor functions for the LLRP KeepaliveTriggerType field.
Definition: out_ltkcpp.h:12675
Class Definition CFrequencyHopTable for LLRP parameter FrequencyHopTable.
Definition: out_ltkcpp.h:9089
EResultCode setC1G2TagInventoryMask(CC1G2TagInventoryMask *pValue)
Set accessor functions for the LLRP C1G2TagInventoryMask sub-parameter.
std::list< CParameter * >::iterator endAirProtocolUHFRFModeTable(void)
Returns the last element of the AirProtocolUHFRFModeTable sub-parameter list.
Definition: out_ltkcpp.h:8734
EResultCode setAirProtocolTagSpec(CParameter *pValue)
Set accessor functions for the LLRP AirProtocolTagSpec sub-parameter.
EC1G2SpectralMaskIndicator getSpectralMaskIndicator(void)
Get accessor functions for the LLRP SpectralMaskIndicator field.
Definition: out_ltkcpp.h:19793
void clearTransmitPowerLevelTableEntry(void)
Clears the LLRP TransmitPowerLevelTableEntry sub-parameter list.
Definition: out_ltkcpp.h:8686
std::list< CAntennaConfiguration * >::iterator beginAntennaConfiguration(void)
Returns the first element of the AntennaConfiguration sub-parameter list.
Definition: out_ltkcpp.h:5554
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:11907
Class Definition CGET_READER_CAPABILITIES_RESPONSE for LLRP message GET_READER_CAPABILITIES_RESPONSE...
Definition: out_ltkcpp.h:2098
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:20130
Class Definition CRFSurveyReportData for LLRP parameter RFSurveyReportData.
Definition: out_ltkcpp.h:16298
std::list< CParameter * >::iterator beginAccessCommandOpSpec(void)
Returns the first element of the AccessCommandOpSpec sub-parameter list.
Definition: out_ltkcpp.h:11869
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:4342
EResultCode setAccessCommand(CAccessCommand *pValue)
Set accessor functions for the LLRP AccessCommand sub-parameter.
std::list< CAntennaConfiguration * >::iterator beginAntennaConfiguration(void)
Returns the first element of the AntennaConfiguration sub-parameter list.
Definition: out_ltkcpp.h:10903
EIdentificationType getIDType(void)
Get accessor functions for the LLRP IDType field.
Definition: out_ltkcpp.h:12417
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:15056
llrp_u64_t getMicroseconds(void)
Get accessor functions for the LLRP Microseconds field.
Definition: out_ltkcpp.h:15753
void clearAntennaProperties(void)
Clears the LLRP AntennaProperties sub-parameter list.
Definition: out_ltkcpp.h:5104
CAccessReportSpec * getAccessReportSpec(void)
Get accessor functions for the LLRP AccessReportSpec sub-parameter.
Definition: out_ltkcpp.h:11585
llrp_utf8v_t getErrorDescription(void)
Get accessor functions for the LLRP ErrorDescription field.
Definition: out_ltkcpp.h:18965
llrp_u32_t getAccessSpecID(void)
Get accessor functions for the LLRP AccessSpecID field.
Definition: out_ltkcpp.h:16248
CRFSurveyEvent * getRFSurveyEvent(void)
Get accessor functions for the LLRP RFSurveyEvent sub-parameter.
Definition: out_ltkcpp.h:17180
Class Definition CKEEPALIVE for LLRP message KEEPALIVE.
Definition: out_ltkcpp.h:6326
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:18100
Class Definition CGET_ACCESSSPECS_RESPONSE for LLRP message GET_ACCESSSPECS_RESPONSE.
Definition: out_ltkcpp.h:4458
CAccessSpecStopTrigger * getAccessSpecStopTrigger(void)
Get accessor functions for the LLRP AccessSpecStopTrigger sub-parameter.
Definition: out_ltkcpp.h:11551
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:11602
llrp_u32_t getTimeout(void)
Get accessor functions for the LLRP Timeout field.
Definition: out_ltkcpp.h:10756
EResultCode setTagReportData(CTagReportData *pValue)
Set accessor functions for the LLRP TagReportData sub-parameter.
void setTagTransitTime(llrp_u32_t value)
Set accessor functions for the LLRP TagTransitTime field.
Definition: out_ltkcpp.h:21057
std::list< CPerAntennaAirProtocol * >::iterator beginPerAntennaAirProtocol(void)
Returns the first element of the PerAntennaAirProtocol sub-parameter list.
Definition: out_ltkcpp.h:7427
Class Definition CTagReportContentSelector for LLRP parameter TagReportContentSelector.
Definition: out_ltkcpp.h:13788
void setNumWordsWritten(llrp_u16_t value)
Set accessor functions for the LLRP NumWordsWritten field.
Definition: out_ltkcpp.h:23534
Class Definition CENABLE_ACCESSSPEC_RESPONSE for LLRP message ENABLE_ACCESSSPEC_RESPONSE.
Definition: out_ltkcpp.h:4107
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:8567
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:13719
void setSession(llrp_u2_t value)
Set accessor functions for the LLRP Session field.
Definition: out_ltkcpp.h:21005
EC1G2StateAwareAction getAction(void)
Get accessor functions for the LLRP Action field.
Definition: out_ltkcpp.h:20608
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:23657
llrp_u16_t getGPOPortNum(void)
Get accessor functions for the LLRP GPOPortNum field.
Definition: out_ltkcpp.h:4896
CIdentification * getIdentification(void)
Get accessor functions for the LLRP Identification sub-parameter.
Definition: out_ltkcpp.h:5073
EC1G2ReadResultType getResult(void)
Get accessor functions for the LLRP Result field.
Definition: out_ltkcpp.h:23318
Class Definition CSTOP_ROSPEC for LLRP message STOP_ROSPEC.
Definition: out_ltkcpp.h:2863
EResultCode setAccessSpecID(CAccessSpecID *pValue)
Set accessor functions for the LLRP AccessSpecID sub-parameter.
std::list< CC1G2UHFRFModeTableEntry * >::iterator endC1G2UHFRFModeTableEntry(void)
Returns the last element of the C1G2UHFRFModeTableEntry sub-parameter list.
Definition: out_ltkcpp.h:19543
llrp_u2_t getMB(void)
Get accessor functions for the LLRP MB field.
Definition: out_ltkcpp.h:21674
std::list< CInventoryParameterSpec * >::iterator beginInventoryParameterSpec(void)
Returns the first element of the InventoryParameterSpec sub-parameter list.
Definition: out_ltkcpp.h:10332
void setData(llrp_bytesToEnd_t value)
Set accessor functions for the LLRP Data field.
Definition: out_ltkcpp.h:1916
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:23907
Class Definition CCUSTOM_MESSAGE for LLRP message CUSTOM_MESSAGE.
Definition: out_ltkcpp.h:1806
llrp_u1_t getEnableSpecIndex(void)
Get accessor functions for the LLRP EnableSpecIndex field.
Definition: out_ltkcpp.h:13865
EResultCode addCustom(CParameter *pValue)
Add a Custom to the LLRP sub-parameter list.
void setAccessSpecID(llrp_u32_t value)
Set accessor functions for the LLRP AccessSpecID field.
Definition: out_ltkcpp.h:3877
void setAccessPassword(llrp_u32_t value)
Set accessor functions for the LLRP AccessPassword field.
Definition: out_ltkcpp.h:22194
llrp_u32_t getAccessPassword(void)
Get accessor functions for the LLRP AccessPassword field.
Definition: out_ltkcpp.h:21855
llrp_u1_t getEnableAntennaID(void)
Get accessor functions for the LLRP EnableAntennaID field.
Definition: out_ltkcpp.h:13917
llrp_u32_t getROSpecID(void)
Get accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:2724
CLLRPStatus * getLLRPStatus(void)
Get accessor functions for the LLRP LLRPStatus sub-parameter.
Definition: out_ltkcpp.h:4503
int countRFSurveyReportData(void)
Count of the LLRP RFSurveyReportData sub-parameter list.
Definition: out_ltkcpp.h:6245
void setResult(EC1G2LockResultType value)
Set accessor functions for the LLRP Result field.
Definition: out_ltkcpp.h:23756
void setPreemptingROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP PreemptingROSpecID field.
Definition: out_ltkcpp.h:17699
EResultCode setAccessReportSpec(CAccessReportSpec *pValue)
Set accessor functions for the LLRP AccessReportSpec sub-parameter.
llrp_u16_t getNumberOfAttempts(void)
Get accessor functions for the LLRP NumberOfAttempts field.
Definition: out_ltkcpp.h:10704
void setAccessSpecID(llrp_u32_t value)
Set accessor functions for the LLRP AccessSpecID field.
Definition: out_ltkcpp.h:16255
std::list< CParameter * >::iterator endAirProtocolInventoryCommandSettings(void)
Returns the last element of the AirProtocolInventoryCommandSettings sub-parameter list...
Definition: out_ltkcpp.h:13016
EStatusCode getErrorCode(void)
Get accessor functions for the LLRP ErrorCode field.
Definition: out_ltkcpp.h:19124
llrp_s8_t getPeakRSSI(void)
Get accessor functions for the LLRP PeakRSSI field.
Definition: out_ltkcpp.h:15444
std::list< CParameter * >::iterator beginAccessCommandOpSpecResult(void)
Returns the first element of the AccessCommandOpSpecResult sub-parameter list.
Definition: out_ltkcpp.h:14699
CParameter * getAirProtocolLLRPCapabilities(void)
Get accessor functions for the LLRP AirProtocolLLRPCapabilities sub-parameter.
Definition: out_ltkcpp.h:2211
llrp_u16_t getTransmitPower(void)
Get accessor functions for the LLRP TransmitPower field.
Definition: out_ltkcpp.h:13277
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:22674
CFirstSeenTimestampUptime * getFirstSeenTimestampUptime(void)
Get accessor functions for the LLRP FirstSeenTimestampUptime sub-parameter.
Definition: out_ltkcpp.h:14576
Class Definition CGPIEvent for LLRP parameter GPIEvent.
Definition: out_ltkcpp.h:17460
EResultCode setKeepaliveSpec(CKeepaliveSpec *pValue)
Set accessor functions for the LLRP KeepaliveSpec sub-parameter.
CFirstSeenTimestampUTC * getFirstSeenTimestampUTC(void)
Get accessor functions for the LLRP FirstSeenTimestampUTC sub-parameter.
Definition: out_ltkcpp.h:14559
CC1G2TagInventoryStateAwareFilterAction * getC1G2TagInventoryStateAwareFilterAction(void)
Get accessor functions for the LLRP C1G2TagInventoryStateAwareFilterAction sub-parameter.
Definition: out_ltkcpp.h:20304
void setCurrentState(EROSpecState value)
Set accessor functions for the LLRP CurrentState field.
Definition: out_ltkcpp.h:9426
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
void setPeriod(llrp_u32_t value)
Set accessor functions for the LLRP Period field.
Definition: out_ltkcpp.h:9876
Class Definition CC1G2Filter for LLRP parameter C1G2Filter.
Definition: out_ltkcpp.h:20216
void setAntennaGain(llrp_s16_t value)
Set accessor functions for the LLRP AntennaGain field.
Definition: out_ltkcpp.h:12861
void setEnableROSpecID(llrp_u1_t value)
Set accessor functions for the LLRP EnableROSpecID field.
Definition: out_ltkcpp.h:13846
CROReportSpec * getROReportSpec(void)
Get accessor functions for the LLRP ROReportSpec sub-parameter.
Definition: out_ltkcpp.h:5592
std::list< CParameter * >::iterator endCustom(void)
Returns the last element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:18107
void setMicroseconds(llrp_u64_t value)
Set accessor functions for the LLRP Microseconds field.
Definition: out_ltkcpp.h:6818
Class Definition CHoppingEvent for LLRP parameter HoppingEvent.
Definition: out_ltkcpp.h:17334
void setMValue(EC1G2MValue value)
Set accessor functions for the LLRP MValue field.
Definition: out_ltkcpp.h:19748
void clearAirProtocolEPCMemorySelector(void)
Clears the LLRP AirProtocolEPCMemorySelector sub-parameter list.
Definition: out_ltkcpp.h:14107
void clearCustom(void)
Clears the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:8574
Class Definition CGET_ACCESSSPECS for LLRP message GET_ACCESSSPECS.
Definition: out_ltkcpp.h:4385
llrp_u16_t getOpSpecID(void)
Get accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:22460
Class Definition CC1G2_CRC for LLRP parameter C1G2_CRC.
Definition: out_ltkcpp.h:23049
CParameter * getTimestamp(void)
Get accessor functions for the LLRP Timestamp sub-parameter.
Definition: out_ltkcpp.h:17061
Class Definition CGET_REPORT for LLRP message GET_REPORT.
Definition: out_ltkcpp.h:6067
void setMaxNumSelectFiltersPerQuery(llrp_u16_t value)
Set accessor functions for the LLRP MaxNumSelectFiltersPerQuery field.
Definition: out_ltkcpp.h:19451
void setWordCount(llrp_u16_t value)
Set accessor functions for the LLRP WordCount field.
Definition: out_ltkcpp.h:22571
EResultCode setAccessSpecID(CAccessSpecID *pValue)
Set accessor functions for the LLRP AccessSpecID sub-parameter.
EResultCode addInventoryParameterSpec(CInventoryParameterSpec *pValue)
Add a InventoryParameterSpec to the LLRP sub-parameter list.
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:16415
llrp_u16_t getAntennaID(void)
Get accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:4818
void setROSpecID(llrp_u32_t value)
Set accessor functions for the LLRP ROSpecID field.
Definition: out_ltkcpp.h:11538
void clearC1G2TargetTag(void)
Clears the LLRP C1G2TargetTag sub-parameter list.
Definition: out_ltkcpp.h:21305
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:7836
Class Definition CRFSurveySpecStopTrigger for LLRP parameter RFSurveySpecStopTrigger.
Definition: out_ltkcpp.h:11217
void setGPOPortNum(llrp_u16_t value)
Set accessor functions for the LLRP GPOPortNum field.
Definition: out_ltkcpp.h:4903
llrp_u64_t getMicroseconds(void)
Get accessor functions for the LLRP Microseconds field.
Definition: out_ltkcpp.h:15955
void setBandwidth(llrp_u32_t value)
Set accessor functions for the LLRP Bandwidth field.
Definition: out_ltkcpp.h:16592
void clearFrequencyRSSILevelEntry(void)
Clears the LLRP FrequencyRSSILevelEntry sub-parameter list.
Definition: out_ltkcpp.h:16391
void setResult(EC1G2ReadResultType value)
Set accessor functions for the LLRP Result field.
Definition: out_ltkcpp.h:23325
llrp_u16_t getNumWordsWritten(void)
Get accessor functions for the LLRP NumWordsWritten field.
Definition: out_ltkcpp.h:23527
CGPIOCapabilities * getGPIOCapabilities(void)
Get accessor functions for the LLRP GPIOCapabilities sub-parameter.
Definition: out_ltkcpp.h:7410
EResultCode setEventsAndReports(CEventsAndReports *pValue)
Set accessor functions for the LLRP EventsAndReports sub-parameter.
void setPriority(llrp_u8_t value)
Set accessor functions for the LLRP Priority field.
Definition: out_ltkcpp.h:9400
Class Definition CC1G2LockOpSpecResult for LLRP parameter C1G2LockOpSpecResult.
Definition: out_ltkcpp.h:23698
EC1G2ForwardLinkModulation getForwardLinkModulation(void)
Get accessor functions for the LLRP ForwardLinkModulation field.
Definition: out_ltkcpp.h:19767
llrp_u32v_t getFrequency(void)
Get accessor functions for the LLRP Frequency field.
Definition: out_ltkcpp.h:9166
void setAntennaID(llrp_u16_t value)
Set accessor functions for the LLRP AntennaID field.
Definition: out_ltkcpp.h:4825
CKeepaliveSpec * getKeepaliveSpec(void)
Get accessor functions for the LLRP KeepaliveSpec sub-parameter.
Definition: out_ltkcpp.h:5626
llrp_u32_t getOffset(void)
Get accessor functions for the LLRP Offset field.
Definition: out_ltkcpp.h:9843
Class Definition CRFReceiver for LLRP parameter RFReceiver.
Definition: out_ltkcpp.h:13074
int countAntennaConfiguration(void)
Count of the LLRP AntennaConfiguration sub-parameter list.
Definition: out_ltkcpp.h:10924
llrp_u1_t getEnablePCBits(void)
Get accessor functions for the LLRP EnablePCBits field.
Definition: out_ltkcpp.h:22904
void setHopTableID(llrp_u16_t value)
Set accessor functions for the LLRP HopTableID field.
Definition: out_ltkcpp.h:17392
EResultCode setLLRPStatus(CLLRPStatus *pValue)
Set accessor functions for the LLRP LLRPStatus sub-parameter.
llrp_u32_t getStartFrequency(void)
Get accessor functions for the LLRP StartFrequency field.
Definition: out_ltkcpp.h:11087
std::list< CParameter * >::iterator beginCustom(void)
Returns the first element of the Custom sub-parameter list.
Definition: out_ltkcpp.h:5344
Class Definition CROBoundarySpec for LLRP parameter ROBoundarySpec.
Definition: out_ltkcpp.h:9539
llrp_u1_t getEPCHAGTCConformance(void)
Get accessor functions for the LLRP EPCHAGTCConformance field.
Definition: out_ltkcpp.h:19715
CKeepaliveSpec * getKeepaliveSpec(void)
Get accessor functions for the LLRP KeepaliveSpec sub-parameter.
Definition: out_ltkcpp.h:5234
CConnectionAttemptEvent * getConnectionAttemptEvent(void)
Get accessor functions for the LLRP ConnectionAttemptEvent sub-parameter.
Definition: out_ltkcpp.h:17231
void setWordPointer(llrp_u16_t value)
Set accessor functions for the LLRP WordPointer field.
Definition: out_ltkcpp.h:22545
llrp_s16_t getAntennaGain(void)
Get accessor functions for the LLRP AntennaGain field.
Definition: out_ltkcpp.h:12854
llrp_u16_t getClientRequestOpSpecTimeout(void)
Get accessor functions for the LLRP ClientRequestOpSpecTimeout field.
Definition: out_ltkcpp.h:8263
llrp_u1_t getCanDoTagInventoryStateAwareSingulation(void)
Get accessor functions for the LLRP CanDoTagInventoryStateAwareSingulation field. ...
Definition: out_ltkcpp.h:8185
llrp_u1v_t getTagData(void)
Get accessor functions for the LLRP TagData field.
Definition: out_ltkcpp.h:21516
EConnectionAttemptStatusType getStatus(void)
Get accessor functions for the LLRP Status field.
Definition: out_ltkcpp.h:18763
EGPIPortState getState(void)
Get accessor functions for the LLRP State field.
Definition: out_ltkcpp.h:13440
EResultCode setSpecIndex(CSpecIndex *pValue)
Set accessor functions for the LLRP SpecIndex sub-parameter.
EResultCode addAntennaConfiguration(CAntennaConfiguration *pValue)
Add a AntennaConfiguration to the LLRP sub-parameter list.
CUTCTimestamp * getUTCTimestamp(void)
Get accessor functions for the LLRP UTCTimestamp sub-parameter.
Definition: out_ltkcpp.h:9889
void setOpSpecID(llrp_u16_t value)
Set accessor functions for the LLRP OpSpecID field.
Definition: out_ltkcpp.h:21836
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.
Definition: out_ltkcpp.h:6262
std::list< CParameter * >::iterator endAccessCommandOpSpec(void)
Returns the last element of the AccessCommandOpSpec sub-parameter list.
Definition: out_ltkcpp.h:11876
Class Definition CC1G2TagSpec for LLRP parameter C1G2TagSpec.
Definition: out_ltkcpp.h:21246
Class Definition CROSpecEvent for LLRP parameter ROSpecEvent.
Definition: out_ltkcpp.h:17589
void setAntennaConnected(llrp_u1_t value)
Set accessor functions for the LLRP AntennaConnected field.
Definition: out_ltkcpp.h:12809
int countCustom(void)
Count of the LLRP Custom sub-parameter list.
Definition: out_ltkcpp.h:13733
void setEPCHAGTCConformance(llrp_u1_t value)
Set accessor functions for the LLRP EPCHAGTCConformance field.
Definition: out_ltkcpp.h:19722
Class Definition CReaderEventNotificationData for LLRP parameter ReaderEventNotificationData.
Definition: out_ltkcpp.h:17016